@tscircuit/schematic-trace-solver 0.0.48 → 0.0.50

package/dist/index.js

@@ -271,19 +271,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS5 = 1e-9;
+  const EPS7 = 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) < -EPS5) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS7) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS5) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS7) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS5 || Math.abs(p1.y - p2.y) < EPS5) {
+  if (Math.abs(p1.x - p2.x) < EPS7 || Math.abs(p1.y - p2.y) < EPS7) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -810,8 +810,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS5 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS5 && Math.abs(p.y - q.y) < EPS5;
+      const EPS7 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS7 && Math.abs(p.y - q.y) < EPS7;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1010,13 +1010,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS5 = 1e-6
+  EPS: EPS7 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical3 = Math.abs(start.x - end.x) < EPS5;
-  const isHorizontal2 = Math.abs(start.y - end.y) < EPS5;
+  const isVertical3 = Math.abs(start.x - end.x) < EPS7;
+  const isHorizontal2 = Math.abs(start.y - end.y) < EPS7;
   if (!isVertical3 && !isHorizontal2) return;
   const segDir = isVertical3 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (si === 0) {
@@ -1083,13 +1083,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
-    const EPS5 = 1e-6;
+    const EPS7 = 1e-6;
     const offsets = this.overlappingTraceSegments.map((_, idx) => {
       const n = Math.floor(idx / 2) + 1;
       const signed = idx % 2 === 0 ? -n : n;
       return signed * this.SHIFT_DISTANCE;
     });
-    const eq = (a, b) => Math.abs(a - b) < EPS5;
+    const eq = (a, b) => Math.abs(a - b) < EPS7;
     const samePoint = (p, q) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y);
     this.overlappingTraceSegments.forEach((group, gidx) => {
       const offset = offsets[gidx];
@@ -1115,13 +1115,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
               segmentIndex: si,
               offset,
               JOG_SIZE,
-              EPS: EPS5
+              EPS: EPS7
             });
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            const isVertical3 = Math.abs(start.x - end.x) < EPS5;
-            const isHorizontal2 = Math.abs(start.y - end.y) < EPS5;
+            const isVertical3 = Math.abs(start.x - end.x) < EPS7;
+            const isHorizontal2 = Math.abs(start.y - end.y) < EPS7;
             if (!isVertical3 && !isHorizontal2) continue;
             if (isVertical3) {
               start.x += offset;
@@ -1218,7 +1218,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS5 = 2e-3;
+    const EPS7 = 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++) {
@@ -1236,7 +1236,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           const minB = Math.min(b1, b2);
           const maxB = Math.max(b1, b2);
           const overlap = Math.min(maxA, maxB) - Math.max(minA, minB);
-          return overlap > EPS5;
+          return overlap > EPS7;
         };
         for (let pa = 0; pa < pathsA.length; pa++) {
           const pathA = pathsA[pa];
@@ -1244,8 +1244,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) < EPS5;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS5;
+            const aVert = Math.abs(a1.x - a2.x) < EPS7;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS7;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -1253,11 +1253,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) < EPS5;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS5;
+                const bVert = Math.abs(b1.x - b2.x) < EPS7;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS7;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS5) {
+                  if (Math.abs(a1.x - b1.x) < EPS7) {
                     if (overlaps1D(a1.y, a2.y, b1.y, b2.y)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1278,7 +1278,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     }
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS5) {
+                  if (Math.abs(a1.y - b1.y) < EPS7) {
                     if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1316,14 +1316,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS5 = 2e-3;
+    const EPS7 = 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 isHorizontal2 = Math.abs(p1.y - p2.y) < EPS5;
-        const isVertical3 = Math.abs(p1.x - p2.x) < EPS5;
+        const isHorizontal2 = Math.abs(p1.y - p2.y) < EPS7;
+        const isVertical3 = Math.abs(p1.x - p2.x) < EPS7;
         if (!isHorizontal2 && !isVertical3) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -1337,13 +1337,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS5 = 2e-3;
+    const EPS7 = 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) < EPS5 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS5 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS5 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS5 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS7 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS7 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS7 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS7 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -1507,24 +1507,24 @@ function getRectBounds(center, w, h) {
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS5 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS5;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS5;
+function segmentIntersectsRect2(p1, p2, rect, EPS7 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS7;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS7;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS5 || x > rect.maxX + EPS5) return false;
+    if (x < rect.minX - EPS7 || x > rect.maxX + EPS7) 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 > EPS5;
+    return overlap > EPS7;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS5 || y > rect.maxY + EPS5) return false;
+    if (y < rect.minY - EPS7 || y > rect.maxY + EPS7) 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 > EPS5;
+    return overlap > EPS7;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -1902,14 +1902,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS5 = 1e-6;
+    const EPS7 = 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) < EPS5;
-        const isV = Math.abs(a.x - b.x) < EPS5;
+        const isH = Math.abs(a.y - b.y) < EPS7;
+        const isV = Math.abs(a.x - b.x) < EPS7;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -2856,7 +2856,7 @@ var SingleOverlapSolver = class extends BaseSolver {
       paddingBuffer: effectivePadding
       // Use the calculated, larger padding
     });
-    const getPathLength = (pts) => {
+    const getPathLength2 = (pts) => {
       let len = 0;
       for (let i = 0; i < pts.length - 1; i++) {
         const dx = pts[i + 1].x - pts[i].x;
@@ -2866,7 +2866,7 @@ var SingleOverlapSolver = class extends BaseSolver {
       return len;
     };
     this.queuedCandidatePaths = candidates.sort(
-      (a, b) => getPathLength(a) - getPathLength(b)
+      (a, b) => getPathLength2(a) - getPathLength2(b)
     );
     this.obstacles = getObstacleRects(this.problem);
   }
@@ -4669,6 +4669,1391 @@ var TraceCleanupSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/Example28Solver/types.ts
+var EPS5 = 1e-9;
+
+// lib/solvers/Example28Solver/geometry.ts
+var getPathKey = (path) => path.map((point) => `${point.x},${point.y}`).join(";");
+var getPathLength = (path) => {
+  let length = 0;
+  for (let i = 0; i < path.length - 1; i++) {
+    length += Math.abs(path[i + 1].x - path[i].x) + Math.abs(path[i + 1].y - path[i].y);
+  }
+  return length;
+};
+var getDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS5 || Math.abs(start.y - end.y) < EPS5;
+var getSegmentOrientation = (start, end) => Math.abs(start.y - end.y) < EPS5 ? "horizontal" : "vertical";
+var projectPointToSegment = (point, start, end) => {
+  if (Math.abs(start.x - end.x) < EPS5) {
+    return {
+      x: start.x,
+      y: Math.min(
+        Math.max(point.y, Math.min(start.y, end.y)),
+        Math.max(start.y, end.y)
+      )
+    };
+  }
+  if (Math.abs(start.y - end.y) < EPS5) {
+    return {
+      x: Math.min(
+        Math.max(point.x, Math.min(start.x, end.x)),
+        Math.max(start.x, end.x)
+      ),
+      y: start.y
+    };
+  }
+  return start;
+};
+var getPointToSegmentDistance = (point, start, end) => getDistance(point, projectPointToSegment(point, start, end));
+var getSegments = (path) => {
+  const segments = [];
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i];
+    const end = path[i + 1];
+    if (!isAxisAlignedSegment(start, end)) continue;
+    segments.push({
+      start,
+      end,
+      orientation: getSegmentOrientation(start, end)
+    });
+  }
+  return segments;
+};
+var findSegmentContainingPoint = (path, point) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i];
+    const end = path[i + 1];
+    if (!isAxisAlignedSegment(start, end)) continue;
+    if (getPointToSegmentDistance(point, start, end) > 1e-6) continue;
+    return {
+      index: i,
+      start,
+      end,
+      orientation: getSegmentOrientation(start, end)
+    };
+  }
+  return null;
+};
+var isPointWithinSegmentPrimaryRange = (point, segment) => {
+  if (segment.orientation === "horizontal") {
+    return point.x >= Math.min(segment.start.x, segment.end.x) - EPS5 && point.x <= Math.max(segment.start.x, segment.end.x) + EPS5;
+  }
+  return point.y >= Math.min(segment.start.y, segment.end.y) - EPS5 && point.y <= Math.max(segment.start.y, segment.end.y) + EPS5;
+};
+var findPreferredReroutedSegment = (path, originalSegmentIndex, originalSegmentCount, orientation, anchorPoint) => {
+  const matchingSegments = getSegments(path).filter(
+    (segment) => segment.orientation === orientation
+  );
+  if (matchingSegments.length === 0) return null;
+  const containingSegments = matchingSegments.filter(
+    (segment) => isPointWithinSegmentPrimaryRange(anchorPoint, segment)
+  );
+  const candidateSegments = containingSegments.length > 0 ? containingSegments : matchingSegments;
+  const isNearStart = originalSegmentIndex < originalSegmentCount / 2;
+  return isNearStart ? candidateSegments[0] : candidateSegments[candidateSegments.length - 1];
+};
+var projectPointToPath = (point, path) => {
+  let bestPoint = null;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < path.length - 1; i++) {
+    const projectedPoint = projectPointToSegment(point, path[i], path[i + 1]);
+    const distance3 = getDistance(point, projectedPoint);
+    if (distance3 < bestDistance) {
+      bestPoint = projectedPoint;
+      bestDistance = distance3;
+    }
+  }
+  return bestPoint;
+};
+var segmentsIntersect = (a1, a2, b1, b2) => {
+  const aVertical = Math.abs(a1.x - a2.x) < EPS5;
+  const bVertical = Math.abs(b1.x - b2.x) < EPS5;
+  const between = (value, p1, p2) => value >= Math.min(p1, p2) - EPS5 && value <= Math.max(p1, p2) + EPS5;
+  if (aVertical && bVertical) {
+    if (Math.abs(a1.x - b1.x) > EPS5) return false;
+    const overlap = Math.min(Math.max(a1.y, a2.y), Math.max(b1.y, b2.y)) - Math.max(Math.min(a1.y, a2.y), Math.min(b1.y, b2.y));
+    return overlap > EPS5;
+  }
+  if (!aVertical && !bVertical) {
+    if (Math.abs(a1.y - b1.y) > EPS5) return false;
+    const overlap = Math.min(Math.max(a1.x, a2.x), Math.max(b1.x, b2.x)) - Math.max(Math.min(a1.x, a2.x), Math.min(b1.x, b2.x));
+    return overlap > EPS5;
+  }
+  const verticalA = aVertical ? a1 : b1;
+  const verticalB = aVertical ? a2 : b2;
+  const horizontalA = aVertical ? b1 : a1;
+  const horizontalB = aVertical ? b2 : a2;
+  return between(verticalA.x, horizontalA.x, horizontalB.x) && between(horizontalA.y, verticalA.y, verticalB.y);
+};
+var countPathIntersections = (pathA, pathB) => {
+  let count = 0;
+  for (let i = 0; i < pathA.length - 1; i++) {
+    for (let j = 0; j < pathB.length - 1; j++) {
+      if (segmentsIntersect(pathA[i], pathA[i + 1], pathB[j], pathB[j + 1])) {
+        count++;
+      }
+    }
+  }
+  return count;
+};
+var isPathCollidingWithChipInterior = (path, chipObstacles) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    const start = path[i];
+    const end = path[i + 1];
+    for (const obstacle of chipObstacles) {
+      if (!segmentIntersectsRect(start, end, obstacle)) continue;
+      if (segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
+      return true;
+    }
+  }
+  return false;
+};
+var segmentRunsAlongRectBoundary = (start, end, rect) => {
+  const isVertical3 = Math.abs(start.x - end.x) < EPS5;
+  const isHorizontal2 = Math.abs(start.y - end.y) < EPS5;
+  if (isVertical3) {
+    return Math.abs(start.x - rect.minX) < EPS5 || Math.abs(start.x - rect.maxX) < EPS5;
+  }
+  if (isHorizontal2) {
+    return Math.abs(start.y - rect.minY) < EPS5 || Math.abs(start.y - rect.maxY) < EPS5;
+  }
+  return false;
+};
+
+// lib/solvers/Example28Solver/labelMovement.ts
+var moveAttachedLabelsToReroutedTrace = ({
+  trace,
+  originalTracePath,
+  reroutedTracePath,
+  netLabelPlacements
+}) => netLabelPlacements.map((label) => {
+  if (!isLabelAttachedToTrace(label, trace)) return label;
+  const movedAnchorPoint = getMovedAnchorPointForReroute(
+    label.anchorPoint,
+    originalTracePath,
+    reroutedTracePath
+  );
+  if (!movedAnchorPoint) return label;
+  const delta = {
+    x: movedAnchorPoint.x - label.anchorPoint.x,
+    y: movedAnchorPoint.y - label.anchorPoint.y
+  };
+  return {
+    ...label,
+    anchorPoint: movedAnchorPoint,
+    center: {
+      x: label.center.x + delta.x,
+      y: label.center.y + delta.y
+    }
+  };
+});
+var isLabelAttachedToTrace = (label, trace) => label.globalConnNetId === trace.globalConnNetId || label.mspConnectionPairIds.includes(trace.mspPairId);
+var getMovedAnchorPointForReroute = (anchorPoint, originalTracePath, reroutedTracePath) => {
+  const originalSegment = findSegmentContainingPoint(
+    originalTracePath,
+    anchorPoint
+  );
+  if (!originalSegment) return null;
+  const preferredSegment = findPreferredReroutedSegment(
+    reroutedTracePath,
+    originalSegment.index,
+    originalTracePath.length - 1,
+    originalSegment.orientation,
+    anchorPoint
+  );
+  if (!preferredSegment) {
+    return projectPointToPath(anchorPoint, reroutedTracePath);
+  }
+  return projectPointToSegment(
+    anchorPoint,
+    preferredSegment.start,
+    preferredSegment.end
+  );
+};
+
+// lib/utils/dir.ts
+var dir = (facingDirection) => {
+  switch (facingDirection) {
+    case "x+":
+      return { x: 1, y: 0 };
+    case "x-":
+      return { x: -1, y: 0 };
+    case "y+":
+      return { x: 0, y: 1 };
+    case "y-":
+      return { x: 0, y: -1 };
+  }
+  throw new Error(`Invalid facing direction: ${facingDirection}`);
+};
+
+// lib/solvers/Example28Solver/reroute.ts
+var LABEL_SIDE_CLEARANCE = 0.1;
+var LABEL_HUG_CLEARANCE = 1e-3;
+var findBestReroutePath = ({
+  trace,
+  obstacleLabel,
+  inputProblem,
+  outputTraces,
+  outputNetLabelPlacements,
+  chipObstacles
+}) => {
+  const candidateResults = generateRerouteCandidateResults({
+    trace,
+    label: obstacleLabel,
+    inputProblem,
+    outputTraces,
+    outputNetLabelPlacements,
+    chipObstacles
+  });
+  const bestPath = selectBestReroutePath({
+    trace,
+    obstacleLabel,
+    outputTraces,
+    outputNetLabelPlacements,
+    candidateResults
+  });
+  markSelectedCandidate(candidateResults, bestPath);
+  return { bestPath, candidateResults };
+};
+var generateRerouteCandidateResults = ({
+  trace,
+  label,
+  inputProblem,
+  outputTraces,
+  outputNetLabelPlacements,
+  chipObstacles
+}) => {
+  const rawCandidates = generateCandidatePaths(trace, label, inputProblem);
+  const seen = /* @__PURE__ */ new Set();
+  const candidateResults = [];
+  for (const rawCandidate of rawCandidates) {
+    candidateResults.push(
+      createCandidateResult({
+        trace,
+        obstacleLabel: label,
+        path: simplifyPath(rawCandidate),
+        seen,
+        outputTraces,
+        outputNetLabelPlacements,
+        chipObstacles
+      })
+    );
+  }
+  return candidateResults;
+};
+var generateCandidatePaths = (trace, label, inputProblem) => [
+  ...generateLabelHugCandidates(trace, label),
+  ...generateRerouteCandidates({
+    trace,
+    label,
+    problem: inputProblem,
+    paddingBuffer: LABEL_SIDE_CLEARANCE,
+    detourCount: 0
+  }),
+  ...generateEndpointDetourCandidates(trace, label)
+];
+var createCandidateResult = ({
+  trace,
+  obstacleLabel,
+  path,
+  seen,
+  outputTraces,
+  outputNetLabelPlacements,
+  chipObstacles
+}) => {
+  const key = getPathKey(path);
+  if (seen.has(key)) {
+    return {
+      path,
+      status: "duplicate",
+      selected: false
+    };
+  }
+  seen.add(key);
+  if (isPathCollidingWithChipInterior(path, chipObstacles)) {
+    return {
+      path,
+      status: "chip-collision",
+      selected: false
+    };
+  }
+  return {
+    path,
+    score: scoreTracePath({
+      trace,
+      tracePath: path,
+      obstacleLabel,
+      outputTraces,
+      outputNetLabelPlacements
+    }),
+    status: "valid",
+    selected: false
+  };
+};
+var generateEndpointDetourCandidates = (trace, label) => {
+  const start = trace.tracePath[0];
+  const end = trace.tracePath[trace.tracePath.length - 1];
+  if (!start || !end) return [];
+  const bounds = getRectBounds(label.center, label.width, label.height);
+  const padding = LABEL_SIDE_CLEARANCE;
+  const labelDirection = dir(label.orientation);
+  const labelSideX = labelDirection.x < 0 ? bounds.minX - padding : bounds.maxX + padding;
+  const oppositeSideX = labelDirection.x < 0 ? bounds.maxX + padding : bounds.minX - padding;
+  const topY = bounds.maxY + padding;
+  const bottomY = bounds.minY - padding;
+  const candidates = [];
+  for (const sideX of [labelSideX, oppositeSideX]) {
+    candidates.push(
+      [
+        start,
+        { x: start.x, y: topY },
+        { x: sideX, y: topY },
+        { x: sideX, y: bottomY },
+        { x: end.x, y: bottomY },
+        end
+      ],
+      [
+        start,
+        { x: start.x, y: bottomY },
+        { x: sideX, y: bottomY },
+        { x: sideX, y: topY },
+        { x: end.x, y: topY },
+        end
+      ]
+    );
+  }
+  return candidates;
+};
+var generateLabelHugCandidates = (trace, label) => {
+  const start = trace.tracePath[0];
+  const end = trace.tracePath[trace.tracePath.length - 1];
+  if (!start || !end) return [];
+  const labelDirection = dir(label.orientation);
+  if (labelDirection.x === 0) return [];
+  const bounds = getRectBounds(label.center, label.width, label.height);
+  const sideX = labelDirection.x < 0 ? bounds.minX - LABEL_SIDE_CLEARANCE : bounds.maxX + LABEL_SIDE_CLEARANCE;
+  const topY = bounds.maxY + LABEL_HUG_CLEARANCE;
+  const bottomY = bounds.minY - LABEL_HUG_CLEARANCE;
+  const startsAboveEnd = start.y >= end.y;
+  const firstY = startsAboveEnd ? topY : bottomY;
+  const secondY = startsAboveEnd ? bottomY : topY;
+  return [
+    [
+      start,
+      { x: start.x, y: firstY },
+      { x: sideX, y: firstY },
+      { x: sideX, y: secondY },
+      { x: end.x, y: secondY },
+      end
+    ],
+    [
+      start,
+      { x: start.x, y: secondY },
+      { x: sideX, y: secondY },
+      { x: sideX, y: firstY },
+      { x: end.x, y: firstY },
+      end
+    ]
+  ];
+};
+var selectBestReroutePath = ({
+  trace,
+  obstacleLabel,
+  outputTraces,
+  outputNetLabelPlacements,
+  candidateResults
+}) => {
+  let bestPath = null;
+  let bestScore = scoreTracePath({
+    trace,
+    tracePath: trace.tracePath,
+    obstacleLabel,
+    outputTraces,
+    outputNetLabelPlacements
+  });
+  for (const candidate of candidateResults) {
+    if (candidate.status !== "valid" || !candidate.score) continue;
+    if (!isBetterScore(candidate.score, bestScore)) continue;
+    bestScore = candidate.score;
+    bestPath = candidate.path;
+  }
+  return bestPath;
+};
+var markSelectedCandidate = (candidateResults, bestPath) => {
+  if (!bestPath) return;
+  for (const candidate of candidateResults) {
+    candidate.selected = candidate.path === bestPath;
+  }
+};
+var scoreTracePath = ({
+  trace,
+  tracePath,
+  obstacleLabel,
+  outputTraces,
+  outputNetLabelPlacements
+}) => {
+  const candidateTrace = { ...trace, tracePath };
+  return {
+    labelIntersections: detectTraceLabelOverlap({
+      traces: [candidateTrace],
+      netLabels: outputNetLabelPlacements
+    }).length,
+    labelHugDistance: getLabelHugDistance(tracePath, obstacleLabel),
+    traceIntersections: countTraceIntersections(candidateTrace, outputTraces),
+    pathLength: getPathLength(tracePath)
+  };
+};
+var countTraceIntersections = (trace, outputTraces) => {
+  let count = 0;
+  for (const otherTrace of outputTraces) {
+    if (otherTrace.mspPairId === trace.mspPairId) continue;
+    count += countPathIntersections(trace.tracePath, otherTrace.tracePath);
+  }
+  return count;
+};
+var isBetterScore = (score, bestScore) => {
+  if (score.labelIntersections !== bestScore.labelIntersections) {
+    return score.labelIntersections < bestScore.labelIntersections;
+  }
+  if (score.labelHugDistance !== bestScore.labelHugDistance) {
+    return score.labelHugDistance < bestScore.labelHugDistance;
+  }
+  if (score.traceIntersections !== bestScore.traceIntersections) {
+    return score.traceIntersections < bestScore.traceIntersections;
+  }
+  return score.pathLength < bestScore.pathLength;
+};
+var getLabelHugDistance = (tracePath, obstacleLabel) => {
+  const bounds = getRectBounds(
+    obstacleLabel.center,
+    obstacleLabel.width,
+    obstacleLabel.height
+  );
+  let distance3 = 0;
+  for (const point of tracePath) {
+    distance3 += getPointDistanceFromRect(point, bounds);
+  }
+  return distance3;
+};
+var getPointDistanceFromRect = (point, rect) => {
+  const dx = Math.max(rect.minX - point.x, 0, point.x - rect.maxX);
+  const dy = Math.max(rect.minY - point.y, 0, point.y - rect.maxY);
+  return dx + dy;
+};
+
+// lib/solvers/Example28Solver/visualize.ts
+var CANDIDATE_SELECTED_COLOR = "blue";
+var CANDIDATE_REJECTED_COLOR = "red";
+var visualizeExample28Solver = (state) => {
+  const graphics = visualizeInputProblem(state.inputProblem);
+  drawTraces(graphics, state);
+  drawNetLabels(graphics, state);
+  if (!state.solved) {
+    drawCurrentCandidates(graphics, state.currentCandidateResults);
+    drawCurrentOverlap(graphics, state);
+  }
+  return graphics;
+};
+var drawTraces = (graphics, state) => {
+  for (const trace of state.outputTraces) {
+    graphics.lines.push({
+      points: trace.tracePath,
+      strokeColor: "purple"
+    });
+  }
+};
+var drawNetLabels = (graphics, state) => {
+  for (const label of state.outputNetLabelPlacements) {
+    const color = getColorFromString(label.globalConnNetId, 0.35);
+    graphics.rects.push({
+      center: label.center,
+      width: label.width,
+      height: label.height,
+      fill: color,
+      strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+      label: `netId: ${label.netId}
+globalConnNetId: ${label.globalConnNetId}`
+    });
+    graphics.points.push({
+      ...label.anchorPoint,
+      color: getColorFromString(label.globalConnNetId, 0.9),
+      label: `anchorPoint
+orientation: ${label.orientation}`
+    });
+  }
+};
+var drawCurrentCandidates = (graphics, candidateResults) => {
+  for (const candidate of candidateResults) {
+    const scoreLabel = candidate.score ? `
+label intersections: ${candidate.score.labelIntersections}
+trace intersections: ${candidate.score.traceIntersections}` : "";
+    graphics.lines.push({
+      points: candidate.path,
+      strokeColor: candidate.selected ? CANDIDATE_SELECTED_COLOR : CANDIDATE_REJECTED_COLOR,
+      strokeDash: candidate.selected ? void 0 : "4 2",
+      label: `${candidate.selected ? "selected" : candidate.status} reroute${scoreLabel}`
+    });
+  }
+};
+var drawCurrentOverlap = (graphics, state) => {
+  if (!state.currentOverlap) return;
+  const label = state.currentOverlap.label;
+  graphics.rects.push({
+    center: label.center,
+    width: label.width,
+    height: label.height,
+    fill: "rgba(255, 0, 0, 0.2)",
+    strokeColor: CANDIDATE_REJECTED_COLOR,
+    label: `overlap target
+${label.netId ?? label.globalConnNetId}`
+  });
+};
+
+// lib/solvers/Example28Solver/Example28Solver.ts
+var Example28Solver = class extends BaseSolver {
+  inputProblem;
+  traces;
+  netLabelPlacements;
+  outputTraces;
+  outputNetLabelPlacements;
+  queuedOverlaps = [];
+  currentOverlap = null;
+  currentCandidateResults = [];
+  chipObstacles;
+  constructor(params) {
+    super();
+    this.inputProblem = params.inputProblem;
+    this.traces = params.traces;
+    this.netLabelPlacements = params.netLabelPlacements;
+    this.outputTraces = [...params.traces];
+    this.outputNetLabelPlacements = [...params.netLabelPlacements];
+    this.chipObstacles = getObstacleRects(params.inputProblem);
+    this.initializeQueuedOverlaps();
+    this.currentOverlap = this.queuedOverlaps[0] ?? null;
+  }
+  getConstructorParams() {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements
+    };
+  }
+  _step() {
+    const overlap = this.queuedOverlaps.shift();
+    if (!overlap) {
+      this.finish();
+      return;
+    }
+    if (!this.isOverlapStillPresent(overlap)) {
+      this.currentOverlap = overlap;
+      this.currentCandidateResults = [];
+      return;
+    }
+    this.rerouteOverlappingTrace(overlap);
+  }
+  finish() {
+    this.currentOverlap = null;
+    this.currentCandidateResults = [];
+    this.solved = true;
+  }
+  initializeQueuedOverlaps() {
+    const queuedOverlaps = [];
+    const seenPairs = /* @__PURE__ */ new Set();
+    for (const overlap of this.getTraceLabelOverlaps()) {
+      if (!this.shouldRerouteOverlap(overlap)) continue;
+      const key = this.getOverlapKey(overlap);
+      if (seenPairs.has(key)) continue;
+      seenPairs.add(key);
+      queuedOverlaps.push(overlap);
+    }
+    this.queuedOverlaps = queuedOverlaps;
+  }
+  getTraceLabelOverlaps() {
+    return detectTraceLabelOverlap({
+      traces: this.outputTraces,
+      netLabels: this.outputNetLabelPlacements
+    });
+  }
+  shouldRerouteOverlap(overlap) {
+    return this.isXFacingLabel(overlap.label) && !this.hasExplicitOrientationConstraint(overlap.label);
+  }
+  isXFacingLabel(label) {
+    return label.orientation === "x+" || label.orientation === "x-";
+  }
+  hasExplicitOrientationConstraint(label) {
+    const effectiveNetId = label.netId ?? label.globalConnNetId;
+    return Object.hasOwn(
+      this.inputProblem.availableNetLabelOrientations,
+      effectiveNetId
+    );
+  }
+  getOverlapKey(overlap) {
+    const labelNetId = overlap.label.netId ?? overlap.label.globalConnNetId;
+    return `${overlap.trace.mspPairId}:${labelNetId}:${overlap.label.anchorPoint.x}:${overlap.label.anchorPoint.y}`;
+  }
+  isOverlapStillPresent(overlap) {
+    const currentTrace = this.getCurrentTrace(overlap.trace);
+    if (!currentTrace) return false;
+    return detectTraceLabelOverlap({
+      traces: [currentTrace],
+      netLabels: [overlap.label]
+    }).length > 0;
+  }
+  getCurrentTrace(trace) {
+    return this.outputTraces.find((t) => t.mspPairId === trace.mspPairId);
+  }
+  rerouteOverlappingTrace(overlap) {
+    this.currentOverlap = overlap;
+    this.currentCandidateResults = [];
+    const traceIndex = this.outputTraces.findIndex(
+      (trace) => trace.mspPairId === overlap.trace.mspPairId
+    );
+    if (traceIndex === -1) return;
+    const currentTrace = this.outputTraces[traceIndex];
+    const rerouteResult = findBestReroutePath({
+      trace: currentTrace,
+      obstacleLabel: overlap.label,
+      inputProblem: this.inputProblem,
+      outputTraces: this.outputTraces,
+      outputNetLabelPlacements: this.outputNetLabelPlacements,
+      chipObstacles: this.chipObstacles
+    });
+    this.currentCandidateResults = rerouteResult.candidateResults;
+    if (!rerouteResult.bestPath) return;
+    const originalTracePath = currentTrace.tracePath;
+    this.outputTraces[traceIndex] = {
+      ...currentTrace,
+      tracePath: rerouteResult.bestPath
+    };
+    this.outputNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
+      trace: currentTrace,
+      originalTracePath,
+      reroutedTracePath: rerouteResult.bestPath,
+      netLabelPlacements: this.outputNetLabelPlacements
+    });
+  }
+  visualize() {
+    return visualizeExample28Solver({
+      inputProblem: this.inputProblem,
+      outputTraces: this.outputTraces,
+      outputNetLabelPlacements: this.outputNetLabelPlacements,
+      solved: this.solved,
+      currentOverlap: this.currentOverlap,
+      currentCandidateResults: this.currentCandidateResults
+    });
+  }
+};
+
+// lib/solvers/AvailableNetOrientationSolver/constants.ts
+var LABEL_SEARCH_STEP = 0.05;
+var WICK_CLEARANCE = 1e-3;
+var EPS6 = 1e-9;
+var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS6;
+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 rectsOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS6 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS6;
+var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS6;
+var traceCrossesBoundsInterior = (bounds, traceMap) => {
+  for (const trace of Object.values(traceMap)) {
+    const points = trace.tracePath;
+    for (let i = 0; i < points.length - 1; i++) {
+      if (segmentCrossesBoundsInterior(points[i], points[i + 1], bounds)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
+  const interiorBounds = {
+    minX: bounds.minX + TRACE_BOUNDARY_TOLERANCE,
+    minY: bounds.minY + TRACE_BOUNDARY_TOLERANCE,
+    maxX: bounds.maxX - TRACE_BOUNDARY_TOLERANCE,
+    maxY: bounds.maxY - TRACE_BOUNDARY_TOLERANCE
+  };
+  if (interiorBounds.minX >= interiorBounds.maxX || interiorBounds.minY >= interiorBounds.maxY) {
+    return false;
+  }
+  if (sameX(p1, p2)) {
+    if (p1.x <= interiorBounds.minX + EPS6 || p1.x >= interiorBounds.maxX - EPS6) {
+      return false;
+    }
+    return rangesOverlap(
+      Math.min(p1.y, p2.y),
+      Math.max(p1.y, p2.y),
+      interiorBounds.minY,
+      interiorBounds.maxY
+    );
+  }
+  if (sameY(p1, p2)) {
+    if (p1.y <= interiorBounds.minY + EPS6 || p1.y >= interiorBounds.maxY - EPS6) {
+      return false;
+    }
+    return rangesOverlap(
+      Math.min(p1.x, p2.x),
+      Math.max(p1.x, p2.x),
+      interiorBounds.minX,
+      interiorBounds.maxX
+    );
+  }
+  return false;
+};
+var tracePathCrossesAnyTrace = (tracePath, traceMap) => {
+  for (const trace of Object.values(traceMap)) {
+    const points = trace.tracePath;
+    for (let i = 0; i < tracePath.length - 1; i++) {
+      for (let j = 0; j < points.length - 1; j++) {
+        if (segmentsStrictlyCross(
+          tracePath[i],
+          tracePath[i + 1],
+          points[j],
+          points[j + 1]
+        )) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+};
+var segmentsStrictlyCross = (a1, a2, b1, b2) => {
+  if (sameX(a1, a2) && sameY(b1, b2)) {
+    return a1.x > Math.min(b1.x, b2.x) + EPS6 && a1.x < Math.max(b1.x, b2.x) - EPS6 && b1.y > Math.min(a1.y, a2.y) + EPS6 && b1.y < Math.max(a1.y, a2.y) - EPS6;
+  }
+  if (sameY(a1, a2) && sameX(b1, b2)) {
+    return b1.x > Math.min(a1.x, a2.x) + EPS6 && b1.x < Math.max(a1.x, a2.x) - EPS6 && a1.y > Math.min(b1.y, b2.y) + EPS6 && a1.y < Math.max(b1.y, b2.y) - EPS6;
+  }
+  return false;
+};
+var getSideDistances = (point, bounds) => [
+  ["left", Math.abs(point.x - bounds.minX)],
+  ["right", Math.abs(point.x - bounds.maxX)],
+  ["bottom", Math.abs(point.y - bounds.minY)],
+  ["top", Math.abs(point.y - bounds.maxY)]
+];
+var getConnectorTracePath = (source, target, orientation) => simplifyOrthogonalPath(
+  isYOrientation(orientation) ? [source, { x: target.x, y: source.y }, target] : [source, { x: source.x, y: target.y }, target]
+);
+var simplifyOrthogonalPath = (path) => {
+  const deduped = path.filter(
+    (point, index) => index === 0 || !pointsEqual(point, path[index - 1])
+  );
+  if (deduped.length < 3) return deduped;
+  const simplified = [deduped[0]];
+  for (let i = 1; i < deduped.length - 1; i++) {
+    const prev = simplified[simplified.length - 1];
+    const point = deduped[i];
+    const next = deduped[i + 1];
+    if (sameX(prev, point) && sameX(point, next) || sameY(prev, point) && sameY(point, next)) {
+      continue;
+    }
+    simplified.push(point);
+  }
+  simplified.push(deduped[deduped.length - 1]);
+  return simplified;
+};
+var pointsEqual = (a, b) => sameX(a, b) && sameY(a, b);
+var sameX = (a, b) => Math.abs(a.x - b.x) <= EPS6;
+var sameY = (a, b) => Math.abs(a.y - b.y) <= EPS6;
+var getMaxSearchDistance = (inputProblem) => {
+  const maxChipWidth = Math.max(
+    ...inputProblem.chips.map((chip) => chip.width),
+    1
+  );
+  return maxChipWidth * 3;
+};
+
+// lib/solvers/AvailableNetOrientationSolver/traces.ts
+var getPinMap = (inputProblem) => {
+  const pinMap = {};
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) {
+      pinMap[pin.pinId] = { ...pin, chipId: chip.chipId };
+    }
+  }
+  return pinMap;
+};
+var getTracePins = (label, pinMap) => {
+  const pins = label.pinIds.flatMap((pinId) => {
+    const pin = pinMap[pinId];
+    return pin ? [pin] : [];
+  });
+  if (pins.length >= 2) return [pins[0], pins[1]];
+  if (pins.length === 1) return [pins[0], pins[0]];
+  const syntheticPin = {
+    pinId: `${label.globalConnNetId}-netlabel-anchor`,
+    x: label.anchorPoint.x,
+    y: label.anchorPoint.y,
+    chipId: "available-net-orientation"
+  };
+  return [syntheticPin, syntheticPin];
+};
+var toNetLabelPlacementPatch = (candidate) => ({
+  orientation: candidate.orientation,
+  anchorPoint: candidate.anchorPoint,
+  center: candidate.center,
+  width: candidate.width,
+  height: candidate.height
+});
+
+// lib/solvers/AvailableNetOrientationSolver/visualize.ts
+var visualizeAvailableNetOrientationSolver = (params) => {
+  const graphics = visualizeInputProblem(params.inputProblem);
+  ensureGraphicsArrays(graphics);
+  drawTraces2(graphics, params.traces);
+  drawNetLabels2(graphics, params.outputNetLabelPlacements);
+  drawCurrentLabel(graphics, params.currentLabel, params.solved);
+  drawCurrentCandidates2(graphics, params.currentCandidateResults, params.solved);
+  return graphics;
+};
+var drawTraces2 = (graphics, traces) => {
+  for (const trace of traces) {
+    graphics.lines.push({
+      points: trace.tracePath,
+      strokeColor: "purple"
+    });
+  }
+};
+var drawNetLabels2 = (graphics, labels) => {
+  for (const label of labels) {
+    graphics.rects.push({
+      center: label.center,
+      width: label.width,
+      height: label.height,
+      fill: getColorFromString(label.globalConnNetId, 0.35),
+      strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+      label: `netId: ${label.netId}
+globalConnNetId: ${label.globalConnNetId}`
+    });
+    graphics.points.push({
+      x: label.anchorPoint.x,
+      y: label.anchorPoint.y,
+      color: getColorFromString(label.globalConnNetId, 0.9),
+      label: `anchorPoint
+orientation: ${label.orientation}`
+    });
+  }
+};
+var drawCurrentLabel = (graphics, currentLabel, solved) => {
+  if (!currentLabel || solved) return;
+  graphics.rects.push({
+    center: currentLabel.center,
+    width: currentLabel.width,
+    height: currentLabel.height,
+    fill: "rgba(255, 0, 0, 0.2)",
+    strokeColor: CANDIDATE_REJECTED_COLOR2,
+    label: `available orientation target
+${currentLabel.netId ?? currentLabel.globalConnNetId}`
+  });
+};
+var drawCurrentCandidates2 = (graphics, candidates, solved) => {
+  if (solved) return;
+  for (const candidate of candidates) {
+    const color = candidate.selected ? CANDIDATE_SELECTED_COLOR2 : CANDIDATE_REJECTED_COLOR2;
+    const distanceLabel = candidate.distance === void 0 ? "" : `
+distance: ${candidate.distance.toFixed(3)}`;
+    const outwardDistanceLabel = candidate.outwardDistance === void 0 || candidate.outwardDistance === 0 ? "" : `
+outward distance: ${candidate.outwardDistance.toFixed(3)}`;
+    graphics.rects.push({
+      center: candidate.center,
+      width: candidate.width,
+      height: candidate.height,
+      fill: candidate.selected ? "rgba(0, 0, 255, 0.2)" : "rgba(255, 0, 0, 0.15)",
+      strokeColor: color,
+      strokeDash: candidate.selected ? void 0 : "4 2",
+      label: `${candidate.selected ? "selected" : candidate.status} available orientation
+phase: ${candidate.phase}
+orientation: ${candidate.orientation}${distanceLabel}${outwardDistanceLabel}`
+    });
+    graphics.points.push({
+      x: candidate.anchorPoint.x,
+      y: candidate.anchorPoint.y,
+      color,
+      label: `candidate anchor
+${candidate.phase}
+${candidate.orientation}`
+    });
+  }
+};
+var ensureGraphicsArrays = (graphics) => {
+  if (!graphics.lines) graphics.lines = [];
+  if (!graphics.points) graphics.points = [];
+  if (!graphics.rects) graphics.rects = [];
+  if (!graphics.circles) graphics.circles = [];
+  if (!graphics.texts) graphics.texts = [];
+};
+
+// lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts
+var AvailableNetOrientationSolver = class extends BaseSolver {
+  inputProblem;
+  traces;
+  netLabelPlacements;
+  outputNetLabelPlacements;
+  queuedLabelIndices = [];
+  currentLabelIndex = null;
+  currentLabel = null;
+  currentCandidateResults = [];
+  traceMap;
+  chipObstacleSpatialIndex;
+  maxSearchDistance;
+  pinMap;
+  constructor(params) {
+    super();
+    this.inputProblem = params.inputProblem;
+    this.traces = [...params.traces];
+    this.netLabelPlacements = params.netLabelPlacements;
+    this.outputNetLabelPlacements = [...params.netLabelPlacements];
+    this.traceMap = Object.fromEntries(
+      this.traces.map((trace) => [trace.mspPairId, trace])
+    );
+    this.pinMap = getPinMap(params.inputProblem);
+    this.chipObstacleSpatialIndex = params.inputProblem._chipObstacleSpatialIndex ?? new ChipObstacleSpatialIndex(params.inputProblem.chips);
+    this.maxSearchDistance = getMaxSearchDistance(params.inputProblem);
+    this.queuedLabelIndices = this.getProcessableLabelIndices();
+    this.setCurrentLabel(this.queuedLabelIndices[0] ?? null);
+  }
+  getConstructorParams() {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements
+    };
+  }
+  _step() {
+    const labelIndex = this.queuedLabelIndices.shift();
+    if (labelIndex === void 0) {
+      this.finish();
+      return;
+    }
+    this.processLabel(labelIndex);
+  }
+  getOutput() {
+    return {
+      traces: this.traces,
+      netLabelPlacements: this.outputNetLabelPlacements
+    };
+  }
+  getProcessableLabelIndices() {
+    const indices = [];
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      if (this.shouldProcessLabel(this.outputNetLabelPlacements[i], i)) {
+        indices.push(i);
+      }
+    }
+    return indices;
+  }
+  shouldProcessLabel(label, labelIndex) {
+    const orientations = this.getAvailableOrientations(label);
+    if (orientations.length === 0) return false;
+    return !(orientations.includes(label.orientation) && this.isLabelPlacementValid(label, labelIndex));
+  }
+  processLabel(labelIndex) {
+    const label = this.outputNetLabelPlacements[labelIndex];
+    this.setCurrentLabel(labelIndex);
+    this.currentCandidateResults = [];
+    const candidate = this.findCorrectedCandidate(label, labelIndex);
+    if (!candidate) return;
+    this.applyCandidate(label, candidate, labelIndex);
+  }
+  applyCandidate(label, candidate, labelIndex) {
+    this.outputNetLabelPlacements[labelIndex] = {
+      ...label,
+      ...toNetLabelPlacementPatch(candidate)
+    };
+    this.addConnectorTrace(label, candidate, labelIndex);
+  }
+  addConnectorTrace(label, candidate, labelIndex) {
+    const tracePath = getConnectorTracePath(
+      label.anchorPoint,
+      candidate.anchorPoint,
+      candidate.orientation
+    );
+    if (tracePath.length < 2) return;
+    const mspPairId = `available-net-orientation-${labelIndex}-${label.netId ?? label.globalConnNetId}`;
+    const connectorTrace = {
+      mspPairId,
+      dcConnNetId: label.dcConnNetId ?? label.globalConnNetId,
+      globalConnNetId: label.globalConnNetId,
+      userNetId: label.netId,
+      pins: getTracePins(label, this.pinMap),
+      tracePath,
+      mspConnectionPairIds: [mspPairId],
+      pinIds: label.pinIds
+    };
+    this.traces.push(connectorTrace);
+    this.traceMap[mspPairId] = connectorTrace;
+  }
+  finish() {
+    this.currentLabelIndex = null;
+    this.currentLabel = null;
+    this.currentCandidateResults = [];
+    this.solved = true;
+  }
+  setCurrentLabel(labelIndex) {
+    this.currentLabelIndex = labelIndex;
+    this.currentLabel = labelIndex === null ? null : this.outputNetLabelPlacements[labelIndex];
+  }
+  findCorrectedCandidate(label, labelIndex) {
+    const orientations = this.getAvailableOrientations(label);
+    const rotatedCandidate = this.findValidRotatedCandidate(
+      label,
+      labelIndex,
+      orientations
+    );
+    return rotatedCandidate ?? this.findValidShiftedCandidate(label, orientations[0], labelIndex);
+  }
+  findValidRotatedCandidate(label, labelIndex, orientations) {
+    for (const orientation of orientations) {
+      const candidate = this.createCandidate(
+        label,
+        this.getSearchStartAnchor(label, orientation),
+        orientation
+      );
+      const result = this.evaluateCandidate(
+        candidate,
+        label,
+        labelIndex,
+        "rotate"
+      );
+      this.currentCandidateResults.push(result);
+      if (result.status === "valid") {
+        result.selected = true;
+        return result;
+      }
+    }
+    return null;
+  }
+  getAvailableOrientations(label) {
+    const effectiveNetId = label.netId ?? label.globalConnNetId;
+    return this.inputProblem.availableNetLabelOrientations[effectiveNetId] ?? [];
+  }
+  findValidShiftedCandidate(label, orientation, labelIndex) {
+    const direction = dir(orientation);
+    const initialBaseAnchor = this.getSearchStartAnchor(label, orientation);
+    const outwardDirection = this.getPerpendicularOutwardDirection(
+      label.anchorPoint,
+      orientation
+    );
+    const maxSearchDistance = this.getSearchDistanceLimit(label, orientation);
+    const maxOutwardDistance = outwardDirection.x === 0 && outwardDirection.y === 0 ? 0 : this.maxSearchDistance;
+    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS6; outwardDistance += LABEL_SEARCH_STEP) {
+      const baseAnchor = {
+        x: initialBaseAnchor.x + outwardDirection.x * outwardDistance,
+        y: initialBaseAnchor.y + outwardDirection.y * outwardDistance
+      };
+      const candidate = this.findValidCandidateInShiftColumn({
+        label,
+        labelIndex,
+        orientation,
+        direction,
+        baseAnchor,
+        maxSearchDistance,
+        outwardDistance
+      });
+      if (candidate) return candidate;
+    }
+    return null;
+  }
+  findValidCandidateInShiftColumn(params) {
+    const {
+      label,
+      labelIndex,
+      orientation,
+      direction,
+      baseAnchor,
+      maxSearchDistance,
+      outwardDistance
+    } = params;
+    for (let distance3 = LABEL_SEARCH_STEP; distance3 <= maxSearchDistance + EPS6; distance3 += LABEL_SEARCH_STEP) {
+      const anchorPoint = {
+        x: baseAnchor.x + direction.x * distance3,
+        y: baseAnchor.y + direction.y * distance3
+      };
+      const candidate = this.createCandidate(label, anchorPoint, orientation);
+      const result = this.evaluateCandidate(
+        candidate,
+        label,
+        labelIndex,
+        "shift",
+        distance3,
+        outwardDistance
+      );
+      this.currentCandidateResults.push(result);
+      if (result.status === "valid") {
+        result.selected = true;
+        return result;
+      }
+      if (result.status === "trace-collision") break;
+    }
+    return null;
+  }
+  evaluateCandidate(candidate, label, labelIndex, phase, distance3, outwardDistance) {
+    return {
+      ...candidate,
+      phase,
+      distance: distance3,
+      outwardDistance,
+      selected: false,
+      status: this.getCandidateStatus(candidate, label, labelIndex)
+    };
+  }
+  getSearchStartAnchor(label, orientation) {
+    const anchorPoint = this.getWickOffsetAnchor(label.anchorPoint, orientation);
+    const { width, height } = getDimsForOrientation({
+      orientation,
+      netLabelWidth: this.getNetLabelWidth(label)
+    });
+    return this.getSideOffsetAnchor({
+      anchorPoint,
+      labelAnchorPoint: label.anchorPoint,
+      orientation,
+      width,
+      height
+    });
+  }
+  getWickOffsetAnchor(anchorPoint, orientation) {
+    const direction = dir(orientation);
+    return {
+      x: anchorPoint.x + direction.x * WICK_CLEARANCE,
+      y: anchorPoint.y + direction.y * WICK_CLEARANCE
+    };
+  }
+  getSideOffsetAnchor(params) {
+    const { anchorPoint, labelAnchorPoint, orientation, width, height } = params;
+    const chipSide = this.getChipSideForPoint(labelAnchorPoint);
+    if (isYOrientation(orientation) && chipSide === "left") {
+      return {
+        x: anchorPoint.x - width / 2 - WICK_CLEARANCE,
+        y: anchorPoint.y
+      };
+    }
+    if (isYOrientation(orientation) && chipSide === "right") {
+      return {
+        x: anchorPoint.x + width / 2 + WICK_CLEARANCE,
+        y: anchorPoint.y
+      };
+    }
+    if (isXOrientation(orientation) && chipSide === "bottom") {
+      return {
+        x: anchorPoint.x,
+        y: anchorPoint.y - height / 2 - WICK_CLEARANCE
+      };
+    }
+    if (isXOrientation(orientation) && chipSide === "top") {
+      return {
+        x: anchorPoint.x,
+        y: anchorPoint.y + height / 2 + WICK_CLEARANCE
+      };
+    }
+    return anchorPoint;
+  }
+  getSearchDistanceLimit(label, orientation) {
+    const { width, height } = getDimsForOrientation({
+      orientation,
+      netLabelWidth: this.getNetLabelWidth(label)
+    });
+    const labelLength = orientation === "y+" || orientation === "y-" ? height : width;
+    return Math.min(this.maxSearchDistance, labelLength * 2);
+  }
+  createCandidate(label, anchorPoint, orientation) {
+    const { width, height } = getDimsForOrientation({
+      orientation,
+      netLabelWidth: this.getNetLabelWidth(label)
+    });
+    return {
+      orientation,
+      anchorPoint,
+      width,
+      height,
+      center: getCenterFromAnchor(anchorPoint, orientation, width, height)
+    };
+  }
+  getNetLabelWidth(label) {
+    if (!label.netId) return void 0;
+    return this.inputProblem.netConnections.find(
+      (connection) => connection.netId === label.netId
+    )?.netLabelWidth;
+  }
+  isLabelPlacementValid(label, labelIndex) {
+    return this.isCandidateValidWithOffset(
+      {
+        orientation: label.orientation,
+        anchorPoint: label.anchorPoint,
+        center: label.center,
+        width: label.width,
+        height: label.height
+      },
+      labelIndex
+    );
+  }
+  isCandidateValidWithOffset(candidate, labelIndex) {
+    const bounds = this.getOffsetCollisionBounds(candidate);
+    return this.getBoundsStatus(bounds, labelIndex) === "valid";
+  }
+  getCandidateStatus(candidate, label, labelIndex) {
+    const boundsStatus = this.getBoundsStatus(
+      getRectBounds(candidate.center, candidate.width, candidate.height),
+      labelIndex
+    );
+    if (boundsStatus !== "valid") return boundsStatus;
+    if (tracePathCrossesAnyTrace(
+      getConnectorTracePath(
+        label.anchorPoint,
+        candidate.anchorPoint,
+        candidate.orientation
+      ),
+      this.traceMap
+    )) {
+      return "trace-collision";
+    }
+    return "valid";
+  }
+  getBoundsStatus(bounds, labelIndex) {
+    if (this.chipObstacleSpatialIndex.getChipsInBounds(bounds).length > 0) {
+      return "chip-collision";
+    }
+    if (this.sharesChipBoundary(bounds)) {
+      return "chip-collision";
+    }
+    if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
+      return "trace-collision";
+    }
+    if (this.intersectsAnyOtherNetLabel(bounds, labelIndex)) {
+      return "netlabel-collision";
+    }
+    return "valid";
+  }
+  getOffsetCollisionBounds(candidate) {
+    const direction = dir(candidate.orientation);
+    const collisionTestOffset = 1e-4;
+    const testCenter = {
+      x: candidate.center.x + direction.x * collisionTestOffset,
+      y: candidate.center.y + direction.y * collisionTestOffset
+    };
+    return getRectBounds(testCenter, candidate.width, candidate.height);
+  }
+  intersectsAnyOtherNetLabel(bounds, labelIndex) {
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      if (i === labelIndex) continue;
+      const label = this.outputNetLabelPlacements[i];
+      const otherBounds = getRectBounds(label.center, label.width, label.height);
+      if (rectsOverlap(bounds, otherBounds)) return true;
+    }
+    return false;
+  }
+  sharesChipBoundary(bounds) {
+    for (const chip of this.chipObstacleSpatialIndex.chips) {
+      const chipBounds = chip.bounds;
+      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS6 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS6;
+      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS6 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS6;
+      if (adjacentToVerticalSide && rangesOverlap(
+        bounds.minY,
+        bounds.maxY,
+        chipBounds.minY,
+        chipBounds.maxY
+      )) {
+        return true;
+      }
+      if (adjacentToHorizontalSide && rangesOverlap(
+        bounds.minX,
+        bounds.maxX,
+        chipBounds.minX,
+        chipBounds.maxX
+      )) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getChipSideForPoint(point) {
+    const containingSide = this.getContainingChipSide(point);
+    if (containingSide) return containingSide;
+    const side = this.getOutsideChipSide(point);
+    if (side) return side;
+    return this.getNearestChipSide(point);
+  }
+  getPerpendicularOutwardDirection(point, orientation) {
+    const chipSide = this.getChipSideForPoint(point);
+    if (isYOrientation(orientation) && chipSide === "left") {
+      return { x: -1, y: 0 };
+    }
+    if (isYOrientation(orientation) && chipSide === "right") {
+      return { x: 1, y: 0 };
+    }
+    if (isXOrientation(orientation) && chipSide === "bottom") {
+      return { x: 0, y: -1 };
+    }
+    if (isXOrientation(orientation) && chipSide === "top") {
+      return { x: 0, y: 1 };
+    }
+    return { x: 0, y: 0 };
+  }
+  getContainingChipSide(point) {
+    let nearestSide = null;
+    let nearestDistance = Number.POSITIVE_INFINITY;
+    for (const chip of this.chipObstacleSpatialIndex.chips) {
+      const bounds = chip.bounds;
+      if (point.x < bounds.minX - EPS6 || point.x > bounds.maxX + EPS6 || point.y < bounds.minY - EPS6 || point.y > bounds.maxY + EPS6) {
+        continue;
+      }
+      for (const [side, distance3] of getSideDistances(point, bounds)) {
+        if (distance3 < nearestDistance) {
+          nearestSide = side;
+          nearestDistance = distance3;
+        }
+      }
+    }
+    return nearestSide;
+  }
+  getOutsideChipSide(point) {
+    let nearestSide = null;
+    let nearestDistanceSq = Number.POSITIVE_INFINITY;
+    for (const chip of this.chipObstacleSpatialIndex.chips) {
+      const bounds = chip.bounds;
+      const dx = point.x < bounds.minX - EPS6 ? bounds.minX - point.x : point.x > bounds.maxX + EPS6 ? point.x - bounds.maxX : 0;
+      const dy = point.y < bounds.minY - EPS6 ? bounds.minY - point.y : point.y > bounds.maxY + EPS6 ? point.y - bounds.maxY : 0;
+      if (dx === 0 && dy === 0) continue;
+      const distanceSq = dx ** 2 + dy ** 2;
+      if (distanceSq >= nearestDistanceSq) continue;
+      nearestDistanceSq = distanceSq;
+      if (dx > 0) {
+        nearestSide = point.x < bounds.minX ? "left" : "right";
+      } else {
+        nearestSide = point.y < bounds.minY ? "bottom" : "top";
+      }
+    }
+    return nearestSide;
+  }
+  getNearestChipSide(point) {
+    let nearestSide = null;
+    let nearestDistance = Number.POSITIVE_INFINITY;
+    for (const chip of this.chipObstacleSpatialIndex.chips) {
+      for (const [side, distance3] of getSideDistances(point, chip.bounds)) {
+        if (distance3 < nearestDistance) {
+          nearestSide = side;
+          nearestDistance = distance3;
+        }
+      }
+    }
+    return nearestSide;
+  }
+  visualize() {
+    return visualizeAvailableNetOrientationSolver({
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      outputNetLabelPlacements: this.outputNetLabelPlacements,
+      currentLabel: this.currentLabel,
+      currentCandidateResults: this.currentCandidateResults,
+      solved: this.solved
+    });
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -4689,6 +6074,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   labelMergingSolver;
   traceLabelOverlapAvoidanceSolver;
   traceCleanupSolver;
+  example28Solver;
+  availableNetOrientationSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -4824,6 +6211,27 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           }
         ];
       }
+    ),
+    definePipelineStep("example28Solver", Example28Solver, (instance) => {
+      const traces = instance.traceCleanupSolver?.getOutput().traces ?? instance.traceLabelOverlapAvoidanceSolver.getOutput().traces;
+      return [
+        {
+          inputProblem: instance.inputProblem,
+          traces,
+          netLabelPlacements: instance.netLabelPlacementSolver.netLabelPlacements
+        }
+      ];
+    }),
+    definePipelineStep(
+      "availableNetOrientationSolver",
+      AvailableNetOrientationSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.example28Solver.outputTraces,
+          netLabelPlacements: instance.example28Solver.outputNetLabelPlacements
+        }
+      ]
     )
   ];
   constructor(inputProblem) {