@tscircuit/schematic-trace-solver 0.0.174 → 0.0.176

package/dist/index.js

@@ -325,19 +325,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS15 = 1e-9;
+  const EPS16 = 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) < -EPS15) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS16) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS15) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS16) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS15 || Math.abs(p1.y - p2.y) < EPS15) {
+  if (Math.abs(p1.x - p2.x) < EPS16 || Math.abs(p1.y - p2.y) < EPS16) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -1575,8 +1575,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS15 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS15 && Math.abs(p.y - q.y) < EPS15;
+      const EPS16 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS16 && Math.abs(p.y - q.y) < EPS16;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1887,13 +1887,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS15 = 1e-6
+  EPS: EPS16 = 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) < EPS15;
-  const isHorizontal5 = Math.abs(start.y - end.y) < EPS15;
+  const isVertical6 = Math.abs(start.x - end.x) < EPS16;
+  const isHorizontal5 = Math.abs(start.y - end.y) < EPS16;
   if (!isVertical6 && !isHorizontal5) return;
   const segDir = isVertical6 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (pts.length === 2) {
@@ -2327,7 +2327,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS15 = 2e-3;
+    const EPS16 = 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++) {
@@ -2354,7 +2354,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           segmentBIndex,
           rangeOverlap
         }) => {
-          if (rangeOverlap > EPS15) {
+          if (rangeOverlap > EPS16) {
             const keyA = `${pathAIndex}:${segmentAIndex}`;
             const keyB = `${pathBIndex}:${segmentBIndex}`;
             if (!seenA.has(keyA)) {
@@ -2373,7 +2373,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             }
             return;
           }
-          if (rangeOverlap < -EPS15) return;
+          if (rangeOverlap < -EPS16) return;
           const pathA = pathsA[pathAIndex].tracePath;
           const pathB = pathsB[pathBIndex].tracePath;
           const segmentAStart = pathA[segmentAIndex];
@@ -2396,8 +2396,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) < EPS15;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS15;
+            const aVert = Math.abs(a1.x - a2.x) < EPS16;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS16;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -2408,11 +2408,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) < EPS15;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS15;
+                const bVert = Math.abs(b1.x - b2.x) < EPS16;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS16;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS15) {
+                  if (Math.abs(a1.x - b1.x) < EPS16) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2422,7 +2422,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     });
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS15) {
+                  if (Math.abs(a1.y - b1.y) < EPS16) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2478,14 +2478,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS15 = 2e-3;
+    const EPS16 = 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) < EPS15;
-        const isVertical6 = Math.abs(p1.x - p2.x) < EPS15;
+        const isHorizontal5 = Math.abs(p1.y - p2.y) < EPS16;
+        const isVertical6 = Math.abs(p1.x - p2.x) < EPS16;
         if (!isHorizontal5 && !isVertical6) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -2499,13 +2499,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS15 = 2e-3;
+    const EPS16 = 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) < EPS15 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS15 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS15 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS15 : false;
+    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 elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -2667,24 +2667,24 @@ var ChipObstacleSpatialIndex = class {
 };
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS15 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS15;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS15;
+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;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS15 || x > rect.maxX + EPS15) return false;
+    if (x < rect.minX - EPS16 || x > rect.maxX + EPS16) 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 > EPS15;
+    return overlap > EPS16;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS15 || y > rect.maxY + EPS15) return false;
+    if (y < rect.minY - EPS16 || y > rect.maxY + EPS16) 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 > EPS15;
+    return overlap > EPS16;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -3083,14 +3083,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS15 = 1e-6;
+    const EPS16 = 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) < EPS15;
-        const isV = Math.abs(a.x - b.x) < EPS15;
+        const isH = Math.abs(a.y - b.y) < EPS16;
+        const isV = Math.abs(a.x - b.x) < EPS16;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -4171,7 +4171,11 @@ var GEOMETRY_EPS = 1e-6;
 var SCHEMATIC_TRACE_STROKE_WIDTH = 0.02;
 var SCHEMATIC_TRACE_MIN_CENTERLINE_CLEARANCE = SCHEMATIC_TRACE_STROKE_WIDTH + GEOMETRY_EPS;
 var SCHEMATIC_TRACE_MIN_VISUAL_CENTERLINE_CLEARANCE = SCHEMATIC_TRACE_STROKE_WIDTH * 3;
-var doesPathCoincideWithTraces = (path, traces) => {
+var doesPathCoincideWithTraces = (path, traces) => doesPathCoincideWithPaths(
+  path,
+  traces.map((trace) => trace.tracePath)
+);
+var doesPathCoincideWithPaths = (path, otherPaths) => {
   const rangesOverlap1D = (a1, a2, b1, b2) => Math.min(Math.max(a1, a2), Math.max(b1, b2)) - Math.max(Math.min(a1, a2), Math.min(b1, b2)) > COINCIDENT_EPS;
   for (let i = 0; i < path.length - 1; i++) {
     const pathSegStart = path[i];
@@ -4181,10 +4185,10 @@ var doesPathCoincideWithTraces = (path, traces) => {
     if (!isVertical6 && !isHorizontal5) continue;
     const crossAxis = isVertical6 ? "x" : "y";
     const alongAxis = isVertical6 ? "y" : "x";
-    for (const trace of traces) {
-      for (let j = 0; j < trace.tracePath.length - 1; j++) {
-        const traceSegStart = trace.tracePath[j];
-        const traceSegEnd = trace.tracePath[j + 1];
+    for (const otherPath of otherPaths) {
+      for (let j = 0; j < otherPath.length - 1; j++) {
+        const traceSegStart = otherPath[j];
+        const traceSegEnd = otherPath[j + 1];
         const isParallel = Math.abs(traceSegStart[crossAxis] - traceSegEnd[crossAxis]) < COINCIDENT_EPS;
         if (!isParallel) continue;
         const isCoincident = Math.abs(pathSegStart[crossAxis] - traceSegStart[crossAxis]) < COINCIDENT_EPS;
@@ -8862,6 +8866,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   inputProblem;
   traces;
   netLabelPlacements;
+  /** Exact provenance for connector traces created by this solver. */
+  netLabelConnectorTraceIds = /* @__PURE__ */ new Set();
   outputNetLabelPlacements;
   queuedLabelIndices = [];
   currentLabelIndex = null;
@@ -9112,6 +9118,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     };
     this.traces.push(connectorTrace);
     this.traceMap[mspPairId] = connectorTrace;
+    this.netLabelConnectorTraceIds.add(mspPairId);
   }
   finish() {
     this.currentLabelIndex = null;
@@ -9434,7 +9441,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         foundConnectedTrace = false;
         for (const trace of Object.values(this.traceMap)) {
           if (connectedTraceIds.has(trace.mspPairId)) continue;
-          if (trace.mspPairId.startsWith("available-net-orientation-")) continue;
+          if (this.netLabelConnectorTraceIds.has(trace.mspPairId)) continue;
           if (trace.globalConnNetId !== label.globalConnNetId) continue;
           if (!trace.pinIds.some((pinId) => connectedPinIds.has(pinId)))
             continue;
@@ -12669,11 +12676,99 @@ var pathEntersAnyNetLabel = ({
   return false;
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/findNearestSharedPinExitRail.ts
+var getPinFacingAxis = (pin) => {
+  if (!pin._facingDirection) return null;
+  return dir(pin._facingDirection).x === 0 ? "y" : "x";
+};
+var isCoordinateOnPinFacingSide = ({
+  coordinate,
+  axis,
+  pin
+}) => {
+  if (!pin._facingDirection) return false;
+  const facingVector = dir(pin._facingDirection);
+  return (coordinate - pin[axis]) * facingVector[axis] > 0;
+};
+var getSegmentAxis2 = (start, end) => {
+  if (isHorizontal2(start, end)) return "x";
+  if (isVertical2(start, end)) return "y";
+  return null;
+};
+var getAxisAlignedSegments = (path) => {
+  const segments = [];
+  for (let index = 0; index < path.length - 1; index++) {
+    const start = path[index];
+    const end = path[index + 1];
+    const axis = getSegmentAxis2(start, end);
+    if (!axis) continue;
+    const coordinateAxis = axis === "x" ? "y" : "x";
+    segments.push({ start, end, axis, coordinate: start[coordinateAxis] });
+  }
+  return segments;
+};
+var getPinExitPoint = ({
+  pin,
+  departureAxis,
+  railCoordinate
+}) => departureAxis === "x" ? { x: railCoordinate, y: pin.y } : { x: pin.x, y: railCoordinate };
+var findNearestSharedPinExitRail = ({
+  donorPath,
+  branchDepartureSegment,
+  sharedPin,
+  adjacentPin
+}) => {
+  const departureAxis = getPinFacingAxis(sharedPin);
+  if (!departureAxis) return null;
+  const railAxis = departureAxis === "x" ? "y" : "x";
+  const branchDeparture = getAxisAlignedSegments(branchDepartureSegment)[0];
+  if (!branchDeparture || branchDeparture.axis !== departureAxis) return null;
+  let nearestRail = null;
+  let nearestDistance = Number.POSITIVE_INFINITY;
+  for (const segment of getAxisAlignedSegments(donorPath)) {
+    if (segment.axis !== railAxis) continue;
+    if (!isCoordinateOnPinFacingSide({
+      coordinate: segment.coordinate,
+      axis: departureAxis,
+      pin: sharedPin
+    })) {
+      continue;
+    }
+    const sharedPinExit = getPinExitPoint({
+      pin: sharedPin,
+      departureAxis,
+      railCoordinate: segment.coordinate
+    });
+    const adjacentPinExit = getPinExitPoint({
+      pin: adjacentPin,
+      departureAxis,
+      railCoordinate: segment.coordinate
+    });
+    if (!tracePathContainsPoint([segment.start, segment.end], sharedPinExit) || !tracePathContainsPoint([segment.start, segment.end], adjacentPinExit) || !tracePathContainsPoint(
+      [branchDeparture.start, branchDeparture.end],
+      sharedPinExit
+    )) {
+      continue;
+    }
+    const distance7 = Math.abs(segment.coordinate - sharedPin[departureAxis]);
+    if (distance7 >= nearestDistance) continue;
+    nearestRail = { segment, sharedPinExit };
+    nearestDistance = distance7;
+  }
+  return nearestRail;
+};
+
 // lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts
 var MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2;
 var MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET = 0.2;
 var MAX_SHARED_PIN_RAIL_OFFSET = 0.05;
+var MAX_SHARED_ENDPOINT_RAIL_OFFSET = 0.8;
 var MIN_RETURN_STEM_LENGTH = 0.05;
+var getSegmentAxis3 = (start, end) => {
+  if (isHorizontal2(start, end)) return "x";
+  if (isVertical2(start, end)) return "y";
+  return null;
+};
 var getSharedPin = ({
   donorTrace,
   branchTrace
@@ -12826,11 +12921,366 @@ var getAlignedBranchPath = ({
   if (branchTrace.pins[0].pinId === sharedPin.pinId) return sharedToOther;
   return [...sharedToOther].reverse();
 };
+var getAlignedParallelPinExitPath = ({
+  donorTrace,
+  branchTrace
+}) => {
+  const sharedPin = getSharedPin({ donorTrace, branchTrace });
+  if (!sharedPin) return null;
+  const adjacentPin = getOtherPin({ trace: donorTrace, sharedPin });
+  const targetPin = getOtherPin({ trace: branchTrace, sharedPin });
+  if (!adjacentPin || !targetPin) return null;
+  const facing = sharedPin._facingDirection;
+  const departureAxis = getPinFacingAxis(sharedPin);
+  if (!facing || !departureAxis) return null;
+  const stemAxis = departureAxis === "x" ? "y" : "x";
+  if (adjacentPin.chipId !== sharedPin.chipId || adjacentPin._facingDirection !== facing || !nearlyEqual(adjacentPin[departureAxis], sharedPin[departureAxis]) || getPinFacingAxis(targetPin) !== stemAxis) {
+    return null;
+  }
+  const adjacentPinOffset = Math.abs(
+    adjacentPin[stemAxis] - sharedPin[stemAxis]
+  );
+  if (adjacentPinOffset > MAX_ALIGNED_LOAD_PIN_OFFSET && !nearlyEqual(adjacentPinOffset, MAX_ALIGNED_LOAD_PIN_OFFSET)) {
+    return null;
+  }
+  const branchStartsAtSharedPin = branchTrace.pins[0].pinId === sharedPin.pinId;
+  let sharedToTargetPath = simplifyPath(branchTrace.tracePath);
+  if (!branchStartsAtSharedPin) sharedToTargetPath.reverse();
+  if (sharedToTargetPath.length < 2) return null;
+  const branchDepartureSegment = [
+    sharedToTargetPath[0],
+    sharedToTargetPath[1]
+  ];
+  const sharedExitRail = findNearestSharedPinExitRail({
+    donorPath: donorTrace.tracePath,
+    branchDepartureSegment,
+    sharedPin,
+    adjacentPin
+  });
+  if (!sharedExitRail) return null;
+  const alignedRailCoordinate = adjacentPin[stemAxis];
+  if (!isCoordinateOnPinFacingSide({
+    coordinate: alignedRailCoordinate,
+    axis: stemAxis,
+    pin: targetPin
+  })) {
+    return null;
+  }
+  const alignedStemExit = {
+    ...sharedExitRail.sharedPinExit,
+    [stemAxis]: alignedRailCoordinate
+  };
+  const targetApproach = {
+    x: targetPin.x,
+    y: targetPin.y,
+    [stemAxis]: alignedRailCoordinate
+  };
+  const candidate = simplifyPath([
+    { x: sharedPin.x, y: sharedPin.y },
+    sharedExitRail.sharedPinExit,
+    alignedStemExit,
+    targetApproach,
+    { x: targetPin.x, y: targetPin.y }
+  ]);
+  return branchStartsAtSharedPin ? candidate : candidate.reverse();
+};
+var getAlignedSharedEndpointRailPath = ({
+  donorTrace,
+  branchTrace,
+  netLabelConnectorTraceIds
+}) => {
+  if (netLabelConnectorTraceIds.has(donorTrace.mspPairId) || netLabelConnectorTraceIds.has(branchTrace.mspPairId)) {
+    return null;
+  }
+  const sharedPin = getSharedPin({ donorTrace, branchTrace });
+  if (!sharedPin) return null;
+  const pathFromShared = (trace) => {
+    const path = simplifyPath(trace.tracePath);
+    return trace.pins[0].pinId === sharedPin.pinId ? path : [...path].reverse();
+  };
+  const donorPath = pathFromShared(donorTrace);
+  const branchPath = pathFromShared(branchTrace);
+  if (donorPath.length < 3 || branchPath.length < 4) return null;
+  const donorDepartureAxis = getSegmentAxis3(donorPath[0], donorPath[1]);
+  const branchDepartureAxis = getSegmentAxis3(branchPath[0], branchPath[1]);
+  if (!donorDepartureAxis || donorDepartureAxis !== branchDepartureAxis) {
+    return null;
+  }
+  const donorDeparture = donorPath[1][donorDepartureAxis] - donorPath[0][donorDepartureAxis];
+  const branchDeparture = branchPath[1][branchDepartureAxis] - branchPath[0][branchDepartureAxis];
+  if (Math.sign(donorDeparture) !== Math.sign(branchDeparture)) return null;
+  const donorRailAxis = getSegmentAxis3(donorPath[1], donorPath[2]);
+  const branchRailAxis = getSegmentAxis3(branchPath[1], branchPath[2]);
+  if (!donorRailAxis || donorRailAxis !== branchRailAxis || donorRailAxis === donorDepartureAxis) {
+    return null;
+  }
+  let branchParallelRailCount = 0;
+  for (let index = 1; index < branchPath.length - 2; index++) {
+    if (getSegmentAxis3(branchPath[index], branchPath[index + 1]) === branchRailAxis) {
+      branchParallelRailCount++;
+    }
+  }
+  if (branchParallelRailCount !== 1) return null;
+  const railCoordinateAxis = donorRailAxis === "x" ? "y" : "x";
+  const donorCoordinate = donorPath[1][railCoordinateAxis];
+  const branchCoordinate = branchPath[1][railCoordinateAxis];
+  const railOffset = Math.abs(donorCoordinate - branchCoordinate);
+  if (nearlyEqual(donorCoordinate, branchCoordinate) || railOffset > MAX_SHARED_ENDPOINT_RAIL_OFFSET) {
+    return null;
+  }
+  const donorRange = [
+    donorPath[1][donorRailAxis],
+    donorPath[2][donorRailAxis]
+  ].sort((a, b) => a - b);
+  const branchRange = [
+    branchPath[1][branchRailAxis],
+    branchPath[2][branchRailAxis]
+  ].sort((a, b) => a - b);
+  const railsTouchAfterAlignment = Math.min(donorRange[1], branchRange[1]) >= Math.max(donorRange[0], branchRange[0]) - 1e-6;
+  if (!railsTouchAfterAlignment) return null;
+  const candidateFromShared = simplifyPath(
+    branchPath.map(
+      (point, index) => index === 1 || index === 2 ? { ...point, [railCoordinateAxis]: donorCoordinate } : point
+    )
+  );
+  return branchTrace.pins[0].pinId === sharedPin.pinId ? candidateFromShared : candidateFromShared.reverse();
+};
+var getAlignedAttachedLabelConnectorPath = ({
+  donorTrace,
+  connectorTrace,
+  netLabelConnectorTraceIds
+}) => {
+  if (netLabelConnectorTraceIds.has(donorTrace.mspPairId) || !netLabelConnectorTraceIds.has(connectorTrace.mspPairId)) {
+    return null;
+  }
+  const findCandidate = (connectorPath) => {
+    if (connectorPath.length < 3) return null;
+    const junction = connectorPath[0];
+    const turn = connectorPath[1];
+    const railEnd = connectorPath[2];
+    const departureAxis = getSegmentAxis3(junction, turn);
+    const railAxis = getSegmentAxis3(turn, railEnd);
+    if (!departureAxis || !railAxis || departureAxis === railAxis) return null;
+    const donorSegmentIndex = donorTrace.tracePath.findIndex(
+      (point, index, path) => {
+        const next = path[index + 1];
+        return next && getSegmentAxis3(point, next) === departureAxis && tracePathContainsPoint([point, next], junction) && tracePathContainsPoint([point, next], turn);
+      }
+    );
+    if (donorSegmentIndex < 0) return null;
+    const donorSegmentStart = donorTrace.tracePath[donorSegmentIndex];
+    const donorSegmentEnd = donorTrace.tracePath[donorSegmentIndex + 1];
+    if (nearlyEqual(junction.x, donorSegmentStart.x) && nearlyEqual(junction.y, donorSegmentStart.y) || nearlyEqual(junction.x, donorSegmentEnd.x) && nearlyEqual(junction.y, donorSegmentEnd.y)) {
+      return null;
+    }
+    const adjacentDonorRails = [
+      donorSegmentIndex > 0 ? [donorTrace.tracePath[donorSegmentIndex - 1], donorSegmentStart] : null,
+      donorSegmentIndex + 2 < donorTrace.tracePath.length ? [donorSegmentEnd, donorTrace.tracePath[donorSegmentIndex + 2]] : null
+    ].flatMap(
+      (segment) => segment && getSegmentAxis3(segment[0], segment[1]) === railAxis ? [segment] : []
+    );
+    if (adjacentDonorRails.length === 0) return null;
+    const railCoordinateAxis = railAxis === "x" ? "y" : "x";
+    const connectorRailCoordinate = turn[railCoordinateAxis];
+    const connectorRange = [turn[railAxis], railEnd[railAxis]].sort(
+      (a, b) => a - b
+    );
+    const donorRail = adjacentDonorRails.map((segment) => ({
+      segment,
+      coordinate: segment[0][railCoordinateAxis],
+      offset: Math.abs(
+        segment[0][railCoordinateAxis] - connectorRailCoordinate
+      )
+    })).filter(({ segment, offset }) => {
+      if (offset > MAX_SHARED_ENDPOINT_RAIL_OFFSET) return false;
+      const donorRange = [segment[0][railAxis], segment[1][railAxis]].sort(
+        (a, b) => a - b
+      );
+      const overlapStart = Math.max(donorRange[0], connectorRange[0]);
+      const overlapEnd = Math.min(donorRange[1], connectorRange[1]);
+      return overlapEnd >= overlapStart - 1e-6 && Math.abs(overlapEnd - overlapStart) <= 1e-6;
+    }).sort((a, b) => a.offset - b.offset)[0];
+    if (!donorRail || nearlyEqual(donorRail.offset, 0)) return null;
+    return simplifyPath(
+      connectorPath.map(
+        (point, index) => index === 1 || index === 2 ? { ...point, [railCoordinateAxis]: donorRail.coordinate } : point
+      )
+    );
+  };
+  const forwardPath = simplifyPath(connectorTrace.tracePath);
+  const forwardCandidate = findCandidate(forwardPath);
+  if (forwardCandidate) return forwardCandidate;
+  const reverseCandidate = findCandidate([...forwardPath].reverse());
+  return reverseCandidate ? reverseCandidate.reverse() : null;
+};
+var pathsIntersect = (firstPath, secondPath) => {
+  if (firstPath.some((point) => tracePathContainsPoint(secondPath, point)) || secondPath.some((point) => tracePathContainsPoint(firstPath, point))) {
+    return true;
+  }
+  for (let firstIndex = 1; firstIndex < firstPath.length; firstIndex++) {
+    for (let secondIndex = 1; secondIndex < secondPath.length; secondIndex++) {
+      if (getSegmentIntersection3(
+        firstPath[firstIndex - 1],
+        firstPath[firstIndex],
+        secondPath[secondIndex - 1],
+        secondPath[secondIndex]
+      )) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var preserveAttachedLabelConnectorJunctions = ({
+  originalTrace,
+  candidateTrace,
+  traces,
+  netLabelConnectorTraceIds
+}) => {
+  let outputTraces = traces.map(
+    (trace) => trace.mspPairId === originalTrace.mspPairId ? candidateTrace : trace
+  );
+  for (const connector of traces) {
+    if (connector.mspPairId === originalTrace.mspPairId || !netLabelConnectorTraceIds.has(connector.mspPairId) || connector.globalConnNetId !== originalTrace.globalConnNetId || !pathsIntersect(originalTrace.tracePath, connector.tracePath) || pathsIntersect(candidateTrace.tracePath, connector.tracePath)) {
+      continue;
+    }
+    const endpointIndex = [0, connector.tracePath.length - 1].find(
+      (index) => tracePathContainsPoint(
+        originalTrace.tracePath,
+        connector.tracePath[index]
+      )
+    );
+    if (endpointIndex === void 0) return null;
+    const originalJunction = connector.tracePath[endpointIndex];
+    const movedJunction = getMovedAnchorPointForReroute(
+      originalJunction,
+      originalTrace.tracePath,
+      candidateTrace.tracePath
+    );
+    if (!movedJunction) return null;
+    const neighborIndex = endpointIndex === 0 ? 1 : endpointIndex - 1;
+    const neighbor = connector.tracePath[neighborIndex];
+    if (!neighbor || getSegmentAxis3(originalJunction, neighbor) !== getSegmentAxis3(movedJunction, neighbor)) {
+      return null;
+    }
+    const movedConnector = {
+      ...connector,
+      tracePath: connector.tracePath.map(
+        (point, index) => index === endpointIndex ? movedJunction : point
+      )
+    };
+    if (!pathsIntersect(candidateTrace.tracePath, movedConnector.tracePath)) {
+      return null;
+    }
+    outputTraces = outputTraces.map(
+      (trace) => trace.mspPairId === connector.mspPairId ? movedConnector : trace
+    );
+  }
+  return outputTraces;
+};
+var getPerpendicularPinRail = ({
+  trace,
+  endpointPin
+}) => {
+  const otherPin = getOtherPin({ trace, sharedPin: endpointPin });
+  if (!otherPin) return null;
+  const startsAtEndpoint = trace.pins[0].pinId === endpointPin.pinId;
+  let endpointToOtherPath = simplifyPath(trace.tracePath);
+  if (!startsAtEndpoint) endpointToOtherPath.reverse();
+  if (endpointToOtherPath.length !== 3) return null;
+  const [endpoint, railPoint, other] = endpointToOtherPath;
+  const endpointFacing = endpointPin._facingDirection;
+  if (endpointFacing === "y+" || endpointFacing === "y-") {
+    if (otherPin._facingDirection !== "x+" && otherPin._facingDirection !== "x-") {
+      return null;
+    }
+    if (!isVertical2(endpoint, railPoint) || !isHorizontal2(railPoint, other) || !railIsOnFacingSide({ railY: railPoint.y, pin: endpointPin })) {
+      return null;
+    }
+    const approachesOtherFromFacingSide2 = otherPin._facingDirection === "x-" ? railPoint.x < otherPin.x : railPoint.x > otherPin.x;
+    return approachesOtherFromFacingSide2 ? { railCoordinate: railPoint.y } : null;
+  }
+  if (endpointFacing !== "x+" && endpointFacing !== "x-") return null;
+  if (otherPin._facingDirection !== "y+" && otherPin._facingDirection !== "y-") {
+    return null;
+  }
+  if (!isHorizontal2(endpoint, railPoint) || !isVertical2(railPoint, other)) {
+    return null;
+  }
+  const railIsOnEndpointFacingSide = endpointFacing === "x+" ? railPoint.x > endpointPin.x : railPoint.x < endpointPin.x;
+  const approachesOtherFromFacingSide = otherPin._facingDirection === "y+" ? railPoint.y > otherPin.y : railPoint.y < otherPin.y;
+  return railIsOnEndpointFacingSide && approachesOtherFromFacingSide ? { railCoordinate: railPoint.x } : null;
+};
+var getAlignedPerpendicularEndpointBusPath = ({
+  donorTrace,
+  branchTrace,
+  traces
+}) => {
+  const sharedPin = getSharedPin({ donorTrace, branchTrace });
+  if (!sharedPin) return null;
+  const returnPin = getOtherPin({ trace: branchTrace, sharedPin });
+  if (!returnPin) return null;
+  const getOtherSameNetTracesAtPin = (pin) => traces.filter(
+    (trace) => trace.mspPairId !== branchTrace.mspPairId && trace.globalConnNetId === branchTrace.globalConnNetId && trace.pinIds.includes(pin.pinId)
+  );
+  const sharedDonorTraces = getOtherSameNetTracesAtPin(sharedPin);
+  const returnDonorTraces = getOtherSameNetTracesAtPin(returnPin);
+  if (sharedDonorTraces.length !== 1 || sharedDonorTraces[0].mspPairId !== donorTrace.mspPairId || returnDonorTraces.length !== 1) {
+    return null;
+  }
+  const sharedRail = getPerpendicularPinRail({
+    trace: donorTrace,
+    endpointPin: sharedPin
+  });
+  if (!sharedRail) return null;
+  const facing = sharedPin._facingDirection;
+  const verticalEndpoints = facing === "y+" || facing === "y-";
+  const horizontalEndpoints = facing === "x+" || facing === "x-";
+  if (!verticalEndpoints && !horizontalEndpoints) return null;
+  if (verticalEndpoints !== (returnPin._facingDirection === "y+" || returnPin._facingDirection === "y-")) {
+    return null;
+  }
+  const branchStartsAtSharedPin = branchTrace.pins[0].pinId === sharedPin.pinId;
+  let sharedToReturnPath = simplifyPath(branchTrace.tracePath);
+  if (!branchStartsAtSharedPin) sharedToReturnPath.reverse();
+  if (sharedToReturnPath.length !== 6) return null;
+  const expectedSegmentOrientations = verticalEndpoints ? ["V", "H", "V", "H", "V"] : ["H", "V", "H", "V", "H"];
+  const actualSegmentOrientations = sharedToReturnPath.slice(1).map(
+    (point, index) => isHorizontal2(sharedToReturnPath[index], point) ? "H" : isVertical2(sharedToReturnPath[index], point) ? "V" : "D"
+  );
+  if (actualSegmentOrientations.some(
+    (orientation, index) => orientation !== expectedSegmentOrientations[index]
+  )) {
+    return null;
+  }
+  const returnRail = getPerpendicularPinRail({
+    trace: returnDonorTraces[0],
+    endpointPin: returnPin
+  });
+  if (!returnRail) return null;
+  const candidate = verticalEndpoints ? simplifyPath([
+    { x: sharedPin.x, y: sharedPin.y },
+    { x: sharedPin.x, y: sharedRail.railCoordinate },
+    { x: sharedToReturnPath[2].x, y: sharedRail.railCoordinate },
+    { x: sharedToReturnPath[3].x, y: returnRail.railCoordinate },
+    { x: returnPin.x, y: returnRail.railCoordinate },
+    { x: returnPin.x, y: returnPin.y }
+  ]) : simplifyPath([
+    { x: sharedPin.x, y: sharedPin.y },
+    { x: sharedRail.railCoordinate, y: sharedPin.y },
+    { x: sharedRail.railCoordinate, y: sharedToReturnPath[2].y },
+    { x: returnRail.railCoordinate, y: sharedToReturnPath[3].y },
+    { x: returnRail.railCoordinate, y: returnPin.y },
+    { x: returnPin.x, y: returnPin.y }
+  ]);
+  return branchStartsAtSharedPin ? candidate : candidate.reverse();
+};
 var candidateIsClear = ({
   candidateTrace,
   originalTrace,
   traces,
   inputProblem,
+  originalNetLabelPlacements,
   candidateNetLabelPlacements,
   attachedLabelIndexes
 }) => {
@@ -12873,6 +13323,53 @@ var candidateIsClear = ({
   )) {
     return false;
   }
+  const labelHitsTrace = (label, trace) => pathIntersectsAnyNetLabel({
+    path: trace.tracePath,
+    netLabelPlacements: [label]
+  });
+  for (const labelIndex of attachedLabelIndexes) {
+    const originalLabel = originalNetLabelPlacements[labelIndex];
+    const candidateLabel = candidateNetLabelPlacements[labelIndex];
+    const originalBounds = getRectBounds(
+      originalLabel.center,
+      originalLabel.width,
+      originalLabel.height
+    );
+    const candidateBounds = getRectBounds(
+      candidateLabel.center,
+      candidateLabel.width,
+      candidateLabel.height
+    );
+    for (const trace of traces) {
+      if (trace.globalConnNetId === candidateLabel.globalConnNetId) continue;
+      if (labelHitsTrace(candidateLabel, trace) && !labelHitsTrace(originalLabel, trace)) {
+        return false;
+      }
+    }
+    for (const obstacle of obstacles) {
+      if (rectsOverlap(candidateBounds, obstacle) && !rectsOverlap(originalBounds, obstacle)) {
+        return false;
+      }
+    }
+    for (let otherIndex = 0; otherIndex < candidateNetLabelPlacements.length; otherIndex++) {
+      if (otherIndex === labelIndex) continue;
+      const originalOther = originalNetLabelPlacements[otherIndex];
+      const candidateOther = candidateNetLabelPlacements[otherIndex];
+      const originalOtherBounds = getRectBounds(
+        originalOther.center,
+        originalOther.width,
+        originalOther.height
+      );
+      const candidateOtherBounds = getRectBounds(
+        candidateOther.center,
+        candidateOther.width,
+        candidateOther.height
+      );
+      if (rectsOverlap(candidateBounds, candidateOtherBounds) && !rectsOverlap(originalBounds, originalOtherBounds)) {
+        return false;
+      }
+    }
+  }
   const otherNetLabelPlacements = candidateNetLabelPlacements.filter(
     (label) => label.globalConnNetId !== candidateTrace.globalConnNetId
   );
@@ -12956,13 +13453,14 @@ var getAlignedReturnBranchPath = ({
 var alignSameNetJunctions = ({
   inputProblem,
   traces,
-  netLabelPlacements
+  netLabelPlacements,
+  netLabelConnectorTraceIds
 }) => {
   let outputTraces = [...traces];
   let outputNetLabelPlacements = [...netLabelPlacements];
   let alignedJunctionCount = 0;
+  const alignedBranchTraceIds = /* @__PURE__ */ new Set();
   for (const alignReturnBranches of [false, true]) {
-    const alignedBranchTraceIds = /* @__PURE__ */ new Set();
     const donorTraceIds = traces.map((trace) => trace.mspPairId);
     const pendingDonorTraceIds = new Set(donorTraceIds);
     for (let donorIndex = 0; donorIndex < donorTraceIds.length; donorIndex++) {
@@ -12975,13 +13473,40 @@ var alignSameNetJunctions = ({
         if (alignedBranchTraceIds.has(branchTrace.mspPairId)) continue;
         if (donorTrace.mspPairId === branchTrace.mspPairId) continue;
         if (donorTrace.globalConnNetId !== branchTrace.globalConnNetId) continue;
-        const candidatePaths = alignReturnBranches ? [1, 0.5, 0.25].map(
-          (returnStemScale) => getAlignedReturnBranchPath({
+        const donorIsLabelConnector = netLabelConnectorTraceIds.has(
+          donorTrace.mspPairId
+        );
+        const branchIsLabelConnector = netLabelConnectorTraceIds.has(
+          branchTrace.mspPairId
+        );
+        const candidatePaths = branchIsLabelConnector ? alignReturnBranches && !donorIsLabelConnector ? [
+          getAlignedAttachedLabelConnectorPath({
+            donorTrace,
+            connectorTrace: branchTrace,
+            netLabelConnectorTraceIds
+          })
+        ] : [] : donorIsLabelConnector ? [] : alignReturnBranches ? [
+          ...[1, 0.5, 0.25].map(
+            (returnStemScale) => getAlignedReturnBranchPath({
+              donorTrace,
+              branchTrace,
+              returnStemScale
+            })
+          ),
+          getAlignedPerpendicularEndpointBusPath({
+            donorTrace,
+            branchTrace,
+            traces: outputTraces
+          }),
+          getAlignedSharedEndpointRailPath({
             donorTrace,
             branchTrace,
-            returnStemScale
+            netLabelConnectorTraceIds
           })
-        ) : [getAlignedBranchPath({ donorTrace, branchTrace })];
+        ] : [
+          getAlignedBranchPath({ donorTrace, branchTrace }),
+          getAlignedParallelPinExitPath({ donorTrace, branchTrace })
+        ];
         for (const candidatePath of candidatePaths) {
           if (!candidatePath) continue;
           const candidateTrace = { ...branchTrace, tracePath: candidatePath };
@@ -13005,20 +13530,47 @@ var alignSameNetJunctions = ({
             netLabelPlacements: outputNetLabelPlacements,
             attachedLabelIndexes
           });
+          const candidateTraces = preserveAttachedLabelConnectorJunctions({
+            originalTrace: branchTrace,
+            candidateTrace,
+            traces: outputTraces,
+            netLabelConnectorTraceIds
+          });
+          if (!candidateTraces) continue;
           if (!candidateIsClear({
             candidateTrace,
             originalTrace: branchTrace,
-            traces: outputTraces,
+            traces: candidateTraces,
             inputProblem,
+            originalNetLabelPlacements: outputNetLabelPlacements,
             candidateNetLabelPlacements,
             attachedLabelIndexes
           })) {
             continue;
           }
-          outputTraces = outputTraces.map((trace) => {
-            if (trace.mspPairId === branchTrace.mspPairId) return candidateTrace;
-            return trace;
+          const movedConnectorsAreClear = candidateTraces.every((trace) => {
+            if (trace.mspPairId === branchTrace.mspPairId || !netLabelConnectorTraceIds.has(trace.mspPairId)) {
+              return true;
+            }
+            const originalConnector = outputTraces.find(
+              (originalTrace) => originalTrace.mspPairId === trace.mspPairId
+            );
+            if (originalConnector.tracePath === trace.tracePath) return true;
+            return candidateIsClear({
+              candidateTrace: trace,
+              originalTrace: originalConnector,
+              traces: candidateTraces,
+              inputProblem,
+              originalNetLabelPlacements: outputNetLabelPlacements,
+              candidateNetLabelPlacements,
+              attachedLabelIndexes: getAttachedLabelIndexes(
+                originalConnector,
+                outputNetLabelPlacements
+              )
+            });
           });
+          if (!movedConnectorsAreClear) continue;
+          outputTraces = candidateTraces;
           outputNetLabelPlacements = candidateNetLabelPlacements;
           alignedBranchTraceIds.add(branchTrace.mspPairId);
           alignedJunctionCount++;
@@ -13830,7 +14382,7 @@ var alignPortOnlyInlineNetLabelStubs = ({
 };
 
 // lib/solvers/InlineNetLabelSolver/getAxisAlignedSegments.ts
-var getAxisAlignedSegments = (path, epsilon = 1e-6) => {
+var getAxisAlignedSegments2 = (path, epsilon = 1e-6) => {
   const segments = [];
   let runStart = null;
   let runAxis = null;
@@ -14445,6 +14997,131 @@ var pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
   };
 };
 
+// lib/solvers/InlineNetLabelSolver/restoreReroutesAroundSupersededLabels.ts
+import { getSegmentIntersection as getSegmentIntersection5 } from "@tscircuit/math-utils/line-intersections";
+
+// lib/utils/pathIntersectsRenderedLabel.ts
+import {
+  doesSegmentIntersectRect,
+  getBoundFromCenteredRect
+} from "@tscircuit/math-utils";
+var pathIntersectsRenderedLabel = (path, label) => {
+  let width = label.width;
+  let height = label.height;
+  if ("axis" in label && label.axis === "y") {
+    width = label.height;
+    height = label.width;
+  }
+  const bounds = getBoundFromCenteredRect({
+    center: label.center,
+    width,
+    height
+  });
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    if (doesSegmentIntersectRect(path[pathIndex], path[pathIndex + 1], bounds)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+// lib/solvers/InlineNetLabelSolver/restoreReroutesAroundSupersededLabels.ts
+var EPS14 = 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
+);
+var isStrictlySimpler = (candidate, current) => candidate.length < current.length && getPathLength5(candidate) <= getPathLength5(current) + EPS14;
+var getIntersectionKeys = (path, otherPath) => {
+  const intersections = /* @__PURE__ */ new Set();
+  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
+    for (let otherPathIndex = 0; otherPathIndex < otherPath.length - 1; otherPathIndex++) {
+      const point = getSegmentIntersection5(
+        path[pathIndex],
+        path[pathIndex + 1],
+        otherPath[otherPathIndex],
+        otherPath[otherPathIndex + 1]
+      );
+      if (point) {
+        intersections.add(`${point.x.toFixed(6)},${point.y.toFixed(6)}`);
+      }
+    }
+  }
+  return intersections;
+};
+var introducesNewCrossings = (candidatePath, currentPath, otherPaths) => otherPaths.some((otherPath) => {
+  const currentIntersections = getIntersectionKeys(currentPath, otherPath);
+  const candidateIntersections = getIntersectionKeys(candidatePath, otherPath);
+  return [...candidateIntersections].some(
+    (intersection) => !currentIntersections.has(intersection)
+  );
+});
+var restoreReroutesAroundSupersededLabels = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+  inlineNetLabelPlacements,
+  completedReroutes
+}) => {
+  const outputTraces = [...traces];
+  const supersededLabelGlobalConnNetIds = new Set(
+    inlineNetLabelPlacements.map((placement) => placement.globalConnNetId)
+  );
+  const obstacles = getObstacleRects(inputProblem);
+  let restoredTraceCount = 0;
+  for (const reroute of [...completedReroutes].reverse()) {
+    if (!supersededLabelGlobalConnNetIds.has(reroute.label.globalConnNetId)) {
+      continue;
+    }
+    const traceIndex = outputTraces.findIndex(
+      (trace) => trace.mspPairId === reroute.initialTrace.mspPairId
+    );
+    if (traceIndex < 0) continue;
+    const currentTrace = outputTraces[traceIndex];
+    const currentPath = simplifyPath(currentTrace.tracePath);
+    const recordedReroutePath = simplifyPath(reroute.reroutedTracePath);
+    if (!pathsEqual(currentPath, recordedReroutePath)) continue;
+    const candidatePath = simplifyPath(reroute.initialTrace.tracePath);
+    if (!isStrictlySimpler(candidatePath, currentPath)) continue;
+    const candidateTrace = { ...currentTrace, tracePath: candidatePath };
+    const otherNetTraces = outputTraces.filter(
+      (trace) => trace.mspPairId !== currentTrace.mspPairId && trace.globalConnNetId !== currentTrace.globalConnNetId
+    );
+    const otherNetInlineLabels = inlineNetLabelPlacements.filter(
+      (label) => label.globalConnNetId !== currentTrace.globalConnNetId
+    );
+    const otherNetInlineStubPaths = otherNetInlineLabels.flatMap(
+      (label) => label.stubTracePath ? [[...label.stubTracePath]] : []
+    );
+    if (isPathCollidingWithObstacles(candidatePath, obstacles) || detectTraceLabelOverlap({
+      traces: [candidateTrace],
+      netLabels: netLabelPlacements
+    }).length > 0 || otherNetInlineLabels.some(
+      (label) => pathIntersectsRenderedLabel(candidatePath, label)
+    ) || doesPathCoincideWithTraces(candidatePath, otherNetTraces) || doesPathCoincideWithPaths(candidatePath, otherNetInlineStubPaths) || introducesNewCrossings(
+      candidatePath,
+      currentPath,
+      otherNetTraces.map((trace) => trace.tracePath)
+    ) || introducesNewCrossings(
+      candidatePath,
+      currentPath,
+      otherNetInlineStubPaths
+    ) || !preservesLabelAnchors(
+      netLabelPlacements,
+      [currentTrace],
+      [candidateTrace]
+    )) {
+      continue;
+    }
+    outputTraces[traceIndex] = candidateTrace;
+    restoredTraceCount++;
+  }
+  return { traces: outputTraces, restoredTraceCount };
+};
+
 // lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts
 var DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
 var INLINE_NET_LABEL_TRACE_MARGIN = 0.05;
@@ -14477,6 +15154,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
   inputProblem;
   traces;
   inputNetLabelPlacements;
+  completedReroutes;
   inlineNetLabelPlacements = [];
   /** Eligible connections still waiting to be processed. */
   queuedConnections;
@@ -14490,6 +15168,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     this.inputProblem = input.inputProblem;
     this.traces = input.traces;
     this.inputNetLabelPlacements = input.netLabelPlacements;
+    this.completedReroutes = input.completedReroutes ?? [];
     this.globalConnMap = getConnectivityMapsFromInputProblem(
       this.inputProblem
     ).netConnMap;
@@ -14524,7 +15203,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
       {
         inputProblem: this.inputProblem,
         traces: this.traces,
-        netLabelPlacements: this.inputNetLabelPlacements
+        netLabelPlacements: this.inputNetLabelPlacements,
+        completedReroutes: this.completedReroutes
       }
     ];
   }
@@ -14840,7 +15520,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     pinIds,
     ignoredTraceIds = /* @__PURE__ */ new Set()
   }) {
-    const segments = getAxisAlignedSegments(trace.tracePath);
+    const segments = getAxisAlignedSegments2(trace.tracePath);
     if (segments.length === 0) return null;
     const height = connection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT;
     const netLabelText = connection.netLabelText?.trim() || void 0;
@@ -15097,9 +15777,17 @@ var InlineNetLabelSolver = class extends BaseSolver {
       if (blockedGlobalConnNetIds.size === 0) {
         this.inlineNetLabelPlacements = activeInlinePlacements;
         this.stats.pushedAnchoredNetLabelCount = pushed.movedLabelCount;
-        return {
+        const restored = restoreReroutesAroundSupersededLabels({
+          inputProblem: this.inputProblem,
           traces: pushed.traces,
           netLabelPlacements: pushed.netLabelPlacements,
+          inlineNetLabelPlacements: activeInlinePlacements,
+          completedReroutes: this.completedReroutes
+        });
+        this.stats.restoredSupersededLabelRerouteCount = restored.restoredTraceCount;
+        return {
+          traces: restored.traces,
+          netLabelPlacements: pushed.netLabelPlacements,
           inlineNetLabelPlacements: activeInlinePlacements
         };
       }
@@ -15307,12 +15995,6 @@ var getCollisionLimitedTerminalStubEnd = ({
   return isHorizontal5 ? { x: start.x + direction * availableLength, y: start.y } : { x: start.x, y: start.y + direction * availableLength };
 };
 
-// lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts
-import {
-  doesSegmentIntersectRect,
-  getBoundFromCenteredRect
-} from "@tscircuit/math-utils";
-
 // lib/solvers/NetLabelTraceRecovery/doesTraceRecoveryPathConflict.ts
 import { doSegmentsIntersect as doSegmentsIntersect4 } from "@tscircuit/math-utils";
 var EPSILON = 1e-6;
@@ -15407,12 +16089,12 @@ var getTraceRecoveryConnectivityMaps = (inputProblem) => {
 };
 
 // lib/solvers/NetLabelToTraceSolver/reduceTraceCrossings.ts
-var EPS14 = 1e-9;
-var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS14;
-var isVertical5 = (start, end) => Math.abs(start.x - end.x) < EPS14;
+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 compactConsecutivePoints = (path) => path.filter((point, index) => {
   const previousPoint = path[index - 1];
-  return !previousPoint || Math.abs(point.x - previousPoint.x) >= EPS14 || Math.abs(point.y - previousPoint.y) >= EPS14;
+  return !previousPoint || Math.abs(point.x - previousPoint.x) >= EPS15 || Math.abs(point.y - previousPoint.y) >= EPS15;
 });
 var isValidOrthogonalPath = (path) => {
   if (path.length < 2 || !path.every((point, index) => {
@@ -15450,7 +16132,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)) < EPS14) {
+      if (Math.abs(alignedCoordinate - (segmentIsVertical ? start.x : start.y)) < EPS15) {
         continue;
       }
       const candidate = tracePath.map((point) => ({ ...point }));
@@ -15513,25 +16195,6 @@ var RECOVERED_TRACE_PREFIX = "net-label-to-trace-";
 var MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET = 0.05;
 var MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET = 0.25;
 var getCanonicalPairKey = (firstPinId, secondPinId) => [firstPinId, secondPinId].sort().join("--");
-var pathIntersectsRenderedLabel = (path, label) => {
-  let width = label.width;
-  let height = label.height;
-  if ("axis" in label && label.axis === "y") {
-    width = label.height;
-    height = label.width;
-  }
-  const bounds = getBoundFromCenteredRect({
-    center: label.center,
-    width,
-    height
-  });
-  for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
-    if (doesSegmentIntersectRect(path[pathIndex], path[pathIndex + 1], bounds)) {
-      return true;
-    }
-  }
-  return false;
-};
 var getPerpendicularOffset = (firstPoint, secondPoint) => {
   const xDistance = Math.abs(firstPoint.x - secondPoint.x);
   const yDistance = Math.abs(firstPoint.y - secondPoint.y);
@@ -16174,9 +16837,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           inputTracePaths: instance.availableNetOrientationSolver.traces,
           globalConnMap: instance.mspConnectionPairSolver.globalConnMap,
           traceIdsToShift: new Set(
-            instance.availableNetOrientationSolver.traces.filter(
-              (trace) => trace.mspPairId.startsWith("available-net-orientation-")
-            ).map((trace) => trace.mspPairId)
+            instance.availableNetOrientationSolver.netLabelConnectorTraceIds
           )
         }
       ]
@@ -16335,7 +16996,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           {
             inputProblem: instance.inputProblem,
             traces: instance.netLabelNetLabelCollisionSolver.traces,
-            netLabelPlacements: collisionOutput.netLabelPlacements
+            netLabelPlacements: collisionOutput.netLabelPlacements,
+            netLabelConnectorTraceIds: instance.availableNetOrientationSolver.netLabelConnectorTraceIds
           }
         ];
       }
@@ -16345,11 +17007,17 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       InlineNetLabelSolver,
       (instance) => {
         const junctionOutput = instance.sameNetJunctionAlignmentSolver.getOutput();
+        const completedReroutes = [
+          ...instance.traceLabelOverlapAvoidanceSolver.getOutput().completedReroutes,
+          ...instance.preAlignmentNetLabelTraceCollisionSolver.getOutput().completedReroutes,
+          ...instance.netLabelTraceCollisionSolver.getOutput().completedReroutes
+        ];
         return [
           {
             inputProblem: instance.inputProblem,
             traces: junctionOutput.traces,
-            netLabelPlacements: junctionOutput.netLabelPlacements
+            netLabelPlacements: junctionOutput.netLabelPlacements,
+            completedReroutes
           }
         ];
       }