@tscircuit/schematic-trace-solver 0.0.51 → 0.0.53

package/dist/index.js

@@ -271,19 +271,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS8 = 1e-9;
+  const EPS9 = 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) < -EPS8) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS9) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS8) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS9) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS8 || Math.abs(p1.y - p2.y) < EPS8) {
+  if (Math.abs(p1.x - p2.x) < EPS9 || Math.abs(p1.y - p2.y) < EPS9) {
     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 EPS8 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS8 && Math.abs(p.y - q.y) < EPS8;
+      const EPS9 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS9 && Math.abs(p.y - q.y) < EPS9;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1010,17 +1010,17 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS8 = 1e-6
+  EPS: EPS9 = 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) < EPS8;
-  const isHorizontal2 = Math.abs(start.y - end.y) < EPS8;
-  if (!isVertical3 && !isHorizontal2) return;
-  const segDir = isVertical3 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
+  const isVertical4 = Math.abs(start.x - end.x) < EPS9;
+  const isHorizontal3 = Math.abs(start.y - end.y) < EPS9;
+  if (!isVertical4 && !isHorizontal3) return;
+  const segDir = isVertical4 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (si === 0) {
-    if (isVertical3) {
+    if (isVertical4) {
       const jogY = start.y + segDir * JOG_SIZE;
       pts.splice(
         1,
@@ -1040,7 +1040,7 @@ var applyJogToTerminalSegment = ({
       );
     }
   } else {
-    if (isVertical3) {
+    if (isVertical4) {
       const jogY = end.y - segDir * JOG_SIZE;
       pts.splice(
         si,
@@ -1083,13 +1083,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
-    const EPS8 = 1e-6;
+    const EPS9 = 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) < EPS8;
+    const eq = (a, b) => Math.abs(a - b) < EPS9;
     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,15 +1115,15 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
               segmentIndex: si,
               offset,
               JOG_SIZE,
-              EPS: EPS8
+              EPS: EPS9
             });
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            const isVertical3 = Math.abs(start.x - end.x) < EPS8;
-            const isHorizontal2 = Math.abs(start.y - end.y) < EPS8;
-            if (!isVertical3 && !isHorizontal2) continue;
-            if (isVertical3) {
+            const isVertical4 = Math.abs(start.x - end.x) < EPS9;
+            const isHorizontal3 = Math.abs(start.y - end.y) < EPS9;
+            if (!isVertical4 && !isHorizontal3) continue;
+            if (isVertical4) {
               start.x += offset;
               end.x += offset;
             } else {
@@ -1218,7 +1218,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS8 = 2e-3;
+    const EPS9 = 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 > EPS8;
+          return overlap > EPS9;
         };
         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) < EPS8;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS8;
+            const aVert = Math.abs(a1.x - a2.x) < EPS9;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS9;
             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) < EPS8;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS8;
+                const bVert = Math.abs(b1.x - b2.x) < EPS9;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS9;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS8) {
+                  if (Math.abs(a1.x - b1.x) < EPS9) {
                     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) < EPS8) {
+                  if (Math.abs(a1.y - b1.y) < EPS9) {
                     if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1316,15 +1316,15 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS8 = 2e-3;
+    const EPS9 = 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) < EPS8;
-        const isVertical3 = Math.abs(p1.x - p2.x) < EPS8;
-        if (!isHorizontal2 && !isVertical3) {
+        const isHorizontal3 = Math.abs(p1.y - p2.y) < EPS9;
+        const isVertical4 = Math.abs(p1.x - p2.x) < EPS9;
+        if (!isHorizontal3 && !isVertical4) {
           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 EPS8 = 2e-3;
+    const EPS9 = 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) < EPS8 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS8 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS8 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS8 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS9 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS9 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS9 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS9 : 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, EPS8 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS8;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS8;
+function segmentIntersectsRect2(p1, p2, rect, EPS9 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS9;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS9;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS8 || x > rect.maxX + EPS8) return false;
+    if (x < rect.minX - EPS9 || x > rect.maxX + EPS9) 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 > EPS8;
+    return overlap > EPS9;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS8 || y > rect.maxY + EPS8) return false;
+    if (y < rect.minY - EPS9 || y > rect.maxY + EPS9) 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 > EPS8;
+    return overlap > EPS9;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -1902,14 +1902,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS8 = 1e-6;
+    const EPS9 = 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) < EPS8;
-        const isV = Math.abs(a.x - b.x) < EPS8;
+        const isH = Math.abs(a.y - b.y) < EPS9;
+        const isV = Math.abs(a.x - b.x) < EPS9;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -2273,6 +2273,44 @@ orientation: ${p.orientation}`
   }
 };
 
+// lib/solvers/SchematicTracePipelineSolver/colorAvailableNetOrientationLabels.ts
+var AVAILABLE_Y_PLUS_COLOR = "#93c5fd";
+var AVAILABLE_Y_MINUS_COLOR = "#fca5a5";
+var AVAILABLE_ORIENTATION_FILL_ALPHA = "66";
+var colorAvailableNetOrientationLabels = (graphicsObject, inputProblem) => {
+  const availableOrientations = inputProblem.availableNetLabelOrientations;
+  if (!availableOrientations) return;
+  for (const rect of graphicsObject.rects ?? []) {
+    const orientations = getAvailableOrientationsForRect(
+      rect.label,
+      availableOrientations
+    );
+    if (!orientations) continue;
+    const hasYPlus = orientations.includes("y+");
+    const hasYMinus = orientations.includes("y-");
+    if (hasYPlus === hasYMinus) continue;
+    const color = hasYPlus ? AVAILABLE_Y_PLUS_COLOR : AVAILABLE_Y_MINUS_COLOR;
+    rect.fill = `${color}${AVAILABLE_ORIENTATION_FILL_ALPHA}`;
+    rect.stroke = color;
+    rect.color = color;
+  }
+};
+var getAvailableOrientationsForRect = (label, availableOrientations) => {
+  for (const netId of getNetIdsFromRectLabel(label)) {
+    if (Object.hasOwn(availableOrientations, netId)) {
+      return availableOrientations[netId];
+    }
+  }
+  return void 0;
+};
+var getNetIdsFromRectLabel = (label) => {
+  if (!label) return [];
+  return [
+    label.match(/^netId: (.+)$/m)?.[1],
+    label.match(/^globalConnNetId: (.+)$/m)?.[1]
+  ].filter((netId) => Boolean(netId && netId !== "undefined"));
+};
+
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/LabelMergingSolver/groupLabelsByChipAndOrientation.ts
 var groupLabelsByChipAndOrientation = ({
   labels,
@@ -4810,12 +4848,12 @@ var isPathCollidingWithChipInterior = (path, chipObstacles) => {
   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) {
+  const isVertical4 = Math.abs(start.x - end.x) < EPS5;
+  const isHorizontal3 = Math.abs(start.y - end.y) < EPS5;
+  if (isVertical4) {
     return Math.abs(start.x - rect.minX) < EPS5 || Math.abs(start.x - rect.maxX) < EPS5;
   }
-  if (isHorizontal2) {
+  if (isHorizontal3) {
     return Math.abs(start.y - rect.minY) < EPS5 || Math.abs(start.y - rect.maxY) < EPS5;
   }
   return false;
@@ -5641,16 +5679,15 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   getProcessableLabelIndices() {
     const indices = [];
     for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
-      if (this.shouldProcessLabel(this.outputNetLabelPlacements[i], i)) {
+      if (this.shouldProcessLabel(this.outputNetLabelPlacements[i])) {
         indices.push(i);
       }
     }
     return indices;
   }
-  shouldProcessLabel(label, labelIndex) {
+  shouldProcessLabel(label) {
     const orientations = this.getAvailableOrientations(label);
-    if (orientations.length === 0) return false;
-    return !(orientations.includes(label.orientation) && this.isLabelPlacementValid(label, labelIndex));
+    return orientations.length > 0 && !orientations.includes(label.orientation);
   }
   processLabel(labelIndex) {
     const label = this.outputNetLabelPlacements[labelIndex];
@@ -5879,22 +5916,6 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       (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),
@@ -5928,15 +5949,6 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     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;
@@ -6362,6 +6374,736 @@ var VccNetLabelCornerPlacementSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/TraceAnchoredNetLabelOverlapSolver/geometry.ts
+var EPS8 = 1e-6;
+var TRACE_BOUNDARY_TOLERANCE2 = 1e-6;
+var getLabelBounds = (label) => getRectBounds(label.center, label.width, label.height);
+var rectsOverlap3 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS8 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS8;
+var rectsTouchOrOverlap = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) >= -EPS8 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) >= -EPS8;
+var traceCrossesBoundsInterior2 = (bounds, traces) => {
+  for (const trace of traces) {
+    const points = trace.tracePath;
+    for (let i = 0; i < points.length - 1; i++) {
+      if (segmentCrossesBoundsInterior2(points[i], points[i + 1], bounds)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var getTraceLocationsForPoint = (point, traces) => {
+  const locations = [];
+  for (const trace of traces) {
+    if (getUniquePinCount2(trace.pinIds) < 2) continue;
+    let pathDistance = 0;
+    for (let i = 0; i < trace.tracePath.length - 1; i++) {
+      const start = trace.tracePath[i];
+      const end = trace.tracePath[i + 1];
+      const segmentLength = getManhattanDistance(start, end);
+      if (isPointOnSegment2(point, start, end)) {
+        locations.push({
+          trace,
+          distance: pathDistance + getManhattanDistance(start, point)
+        });
+      }
+      pathDistance += segmentLength;
+    }
+  }
+  return locations;
+};
+var getTraceLength = (trace) => {
+  let length = 0;
+  for (let i = 0; i < trace.tracePath.length - 1; i++) {
+    length += getManhattanDistance(trace.tracePath[i], trace.tracePath[i + 1]);
+  }
+  return length;
+};
+var getPointAtTraceDistance = (trace, distance3) => {
+  let pathDistance = 0;
+  for (let i = 0; i < trace.tracePath.length - 1; i++) {
+    const start = trace.tracePath[i];
+    const end = trace.tracePath[i + 1];
+    const segmentLength = getManhattanDistance(start, end);
+    const nextDistance = pathDistance + segmentLength;
+    if (distance3 <= nextDistance + EPS8) {
+      const offset = Math.max(
+        0,
+        Math.min(segmentLength, distance3 - pathDistance)
+      );
+      const direction = getSegmentDirection(start, end);
+      return {
+        x: start.x + direction.x * offset,
+        y: start.y + direction.y * offset
+      };
+    }
+    pathDistance = nextDistance;
+  }
+  return trace.tracePath[trace.tracePath.length - 1];
+};
+var getTraceVertexDistances = (trace) => {
+  const distances = [];
+  let pathDistance = 0;
+  for (let i = 0; i < trace.tracePath.length; i++) {
+    distances.push(pathDistance);
+    const nextPoint = trace.tracePath[i + 1];
+    if (nextPoint) {
+      pathDistance += getManhattanDistance(trace.tracePath[i], nextPoint);
+    }
+  }
+  return distances;
+};
+var getManhattanDistance = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+var segmentCrossesBoundsInterior2 = (start, end, bounds) => {
+  const interior = {
+    minX: bounds.minX + TRACE_BOUNDARY_TOLERANCE2,
+    minY: bounds.minY + TRACE_BOUNDARY_TOLERANCE2,
+    maxX: bounds.maxX - TRACE_BOUNDARY_TOLERANCE2,
+    maxY: bounds.maxY - TRACE_BOUNDARY_TOLERANCE2
+  };
+  if (interior.minX >= interior.maxX || interior.minY >= interior.maxY) {
+    return false;
+  }
+  if (isVertical3(start, end)) {
+    if (start.x <= interior.minX + EPS8 || start.x >= interior.maxX - EPS8) {
+      return false;
+    }
+    return rangesOverlap2(
+      Math.min(start.y, end.y),
+      Math.max(start.y, end.y),
+      interior.minY,
+      interior.maxY
+    );
+  }
+  if (isHorizontal2(start, end)) {
+    if (start.y <= interior.minY + EPS8 || start.y >= interior.maxY - EPS8) {
+      return false;
+    }
+    return rangesOverlap2(
+      Math.min(start.x, end.x),
+      Math.max(start.x, end.x),
+      interior.minX,
+      interior.maxX
+    );
+  }
+  return false;
+};
+var isPointOnSegment2 = (point, start, end) => {
+  if (isHorizontal2(start, end)) {
+    return Math.abs(point.y - start.y) <= EPS8 && point.x >= Math.min(start.x, end.x) - EPS8 && point.x <= Math.max(start.x, end.x) + EPS8;
+  }
+  if (isVertical3(start, end)) {
+    return Math.abs(point.x - start.x) <= EPS8 && point.y >= Math.min(start.y, end.y) - EPS8 && point.y <= Math.max(start.y, end.y) + EPS8;
+  }
+  return false;
+};
+var getSegmentDirection = (start, end) => ({
+  x: isVertical3(start, end) ? 0 : Math.sign(end.x - start.x),
+  y: isHorizontal2(start, end) ? 0 : Math.sign(end.y - start.y)
+});
+var isHorizontal2 = (start, end) => Math.abs(start.y - end.y) <= EPS8;
+var isVertical3 = (start, end) => Math.abs(start.x - end.x) <= EPS8;
+var rangesOverlap2 = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS8;
+var getUniquePinCount2 = (pinIds) => new Set(pinIds).size;
+
+// lib/solvers/TraceAnchoredNetLabelOverlapSolver/candidates.ts
+var CANDIDATE_STEP = 0.1;
+var generateCandidatesAlongTrace = (params) => {
+  const { inputProblem, label, traceLocation } = params;
+  const traceLength = getTraceLength(traceLocation.trace);
+  const orientationConstraint = getOrientationConstraint(inputProblem, label);
+  const candidateDistances = getCandidateDistances(
+    traceLength,
+    getTraceVertexDistances(traceLocation.trace)
+  );
+  const netLabelWidth = getNetLabelWidth(inputProblem, label);
+  const candidates = [];
+  const seenCandidateKeys = /* @__PURE__ */ new Set();
+  for (const pathDistance of candidateDistances) {
+    const point = getPointAtTraceDistance(traceLocation.trace, pathDistance);
+    const orientations = getOrientationsForPoint({
+      inputProblem,
+      label,
+      point,
+      orientationConstraint
+    });
+    for (const orientation of orientations) {
+      if (isSamePlacement(label, point, orientation)) continue;
+      const key = [point.x.toFixed(6), point.y.toFixed(6), orientation].join(
+        ":"
+      );
+      if (seenCandidateKeys.has(key)) continue;
+      seenCandidateKeys.add(key);
+      candidates.push(
+        createCandidate({
+          point,
+          orientation,
+          netLabelWidth,
+          traceLocation,
+          pathDistance,
+          label
+        })
+      );
+    }
+  }
+  return candidates;
+};
+var getCandidateDistances = (traceLength, vertexDistances) => {
+  const distances = /* @__PURE__ */ new Set();
+  const maxSteps = Math.ceil(traceLength / CANDIDATE_STEP);
+  for (let i = 0; i <= maxSteps; i++) {
+    const distance3 = Math.min(traceLength, i * CANDIDATE_STEP);
+    distances.add(roundDistance(distance3));
+  }
+  for (const distance3 of vertexDistances) {
+    distances.add(roundDistance(distance3));
+  }
+  return [...distances].filter((distance3) => distance3 >= -EPS8 && distance3 <= traceLength + EPS8).sort((a, b) => a - b);
+};
+var getOrientationsForPoint = (params) => {
+  const { inputProblem, label, point, orientationConstraint } = params;
+  if (orientationConstraint) {
+    return orientationConstraint;
+  }
+  return getUnconstrainedOrientations({
+    label,
+    inputProblem,
+    point
+  });
+};
+var createCandidate = (params) => {
+  const {
+    point,
+    orientation,
+    netLabelWidth,
+    traceLocation,
+    pathDistance,
+    label
+  } = params;
+  const { width, height } = getDimsForOrientation({
+    orientation,
+    netLabelWidth
+  });
+  return {
+    anchorPoint: point,
+    center: getCenterFromAnchor(point, orientation, width, height),
+    width,
+    height,
+    orientation,
+    traceId: traceLocation.trace.mspPairId,
+    pathDistance,
+    distanceFromOriginal: getManhattanDistance(point, label.anchorPoint),
+    status: "valid",
+    selected: false
+  };
+};
+var getOrientationConstraint = (inputProblem, label) => {
+  const availableOrientations = inputProblem.availableNetLabelOrientations ?? {};
+  for (const netId of getOrientationConstraintKeys(inputProblem, label)) {
+    if (Object.hasOwn(availableOrientations, netId)) {
+      return dedupeOrientations(
+        (availableOrientations[netId] ?? []).map(normalizeFacingDirection).filter(
+          (orientation) => orientation !== void 0
+        )
+      );
+    }
+  }
+  return null;
+};
+var getOrientationConstraintKeys = (inputProblem, label) => dedupeStrings([
+  label.netId,
+  label.globalConnNetId,
+  ...inputProblem.netConnections.filter(
+    (connection) => label.pinIds.some((pinId) => connection.pinIds.includes(pinId))
+  ).map((connection) => connection.netId)
+]);
+var getUnconstrainedOrientations = (params) => {
+  const { label, inputProblem, point } = params;
+  return dedupeOrientations([
+    ...getInitialOrientations(label),
+    ...getOutwardOrientations({
+      inputProblem,
+      point
+    }),
+    ...ALL_ORIENTATIONS
+  ]);
+};
+var getInitialOrientations = (label) => [
+  label.orientation,
+  getFlippedOrientation(label.orientation)
+];
+var getOutwardOrientations = (params) => {
+  const { inputProblem, point } = params;
+  const chipBounds = getChipBounds(inputProblem);
+  return dedupeOrientations(
+    getOutwardOrientationOptions(point, chipBounds).sort((a, b) => b.outwardScore - a.outwardScore).map(({ orientation }) => orientation)
+  );
+};
+var getOutwardOrientationOptions = (point, chipBounds) => {
+  const options = [];
+  options.push(
+    getOutwardAxisOption({
+      value: point.y,
+      min: chipBounds.minY,
+      max: chipBounds.maxY,
+      center: chipBounds.centerY,
+      positiveOrientation: "y+",
+      negativeOrientation: "y-"
+    })
+  );
+  options.push(
+    getOutwardAxisOption({
+      value: point.x,
+      min: chipBounds.minX,
+      max: chipBounds.maxX,
+      center: chipBounds.centerX,
+      positiveOrientation: "x+",
+      negativeOrientation: "x-"
+    })
+  );
+  return options;
+};
+var getOutwardAxisOption = (params) => {
+  const { value, min, max, center, positiveOrientation, negativeOrientation } = params;
+  if (value > max + EPS8) {
+    return {
+      orientation: positiveOrientation,
+      outwardScore: 1 + value - max
+    };
+  }
+  if (value < min - EPS8) {
+    return {
+      orientation: negativeOrientation,
+      outwardScore: 1 + min - value
+    };
+  }
+  return {
+    orientation: value >= center ? positiveOrientation : negativeOrientation,
+    outwardScore: getNormalizedCenterDistance(value, center, max - min)
+  };
+};
+var getNormalizedCenterDistance = (value, center, span) => Math.abs(value - center) / Math.max(EPS8, span / 2);
+var ALL_ORIENTATIONS = ["x+", "x-", "y+", "y-"];
+var getFlippedOrientation = (orientation) => {
+  switch (orientation) {
+    case "x+":
+      return "x-";
+    case "x-":
+      return "x+";
+    case "y+":
+      return "y-";
+    case "y-":
+      return "y+";
+  }
+};
+var getChipBounds = (inputProblem) => {
+  if (inputProblem.chips.length === 0) {
+    return {
+      minX: 0,
+      minY: 0,
+      maxX: 0,
+      maxY: 0,
+      centerX: 0,
+      centerY: 0
+    };
+  }
+  const bounds = inputProblem.chips.reduce(
+    (acc, chip) => ({
+      minX: Math.min(acc.minX, chip.center.x - chip.width / 2),
+      minY: Math.min(acc.minY, chip.center.y - chip.height / 2),
+      maxX: Math.max(acc.maxX, chip.center.x + chip.width / 2),
+      maxY: Math.max(acc.maxY, chip.center.y + chip.height / 2)
+    }),
+    {
+      minX: Number.POSITIVE_INFINITY,
+      minY: Number.POSITIVE_INFINITY,
+      maxX: Number.NEGATIVE_INFINITY,
+      maxY: Number.NEGATIVE_INFINITY
+    }
+  );
+  return {
+    ...bounds,
+    centerX: (bounds.minX + bounds.maxX) / 2,
+    centerY: (bounds.minY + bounds.maxY) / 2
+  };
+};
+var getNetLabelWidth = (inputProblem, label) => {
+  const configuredWidth = inputProblem.netConnections.find(
+    (connection) => connection.netId === label.netId
+  )?.netLabelWidth;
+  if (configuredWidth !== void 0) return configuredWidth;
+  return label.orientation === "y+" || label.orientation === "y-" ? label.height : label.width;
+};
+var roundDistance = (distance3) => Number(distance3.toFixed(6));
+var dedupeOrientations = (orientations) => [
+  ...new Set(orientations)
+];
+var normalizeFacingDirection = (value) => {
+  switch (value) {
+    case "x+":
+    case "+x":
+      return "x+";
+    case "x-":
+    case "-x":
+      return "x-";
+    case "y+":
+    case "+y":
+      return "y+";
+    case "y-":
+    case "-y":
+      return "y-";
+  }
+};
+var dedupeStrings = (values) => [
+  ...new Set(values.filter((value) => value !== void 0))
+];
+var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS8 && Math.abs(point.y - label.anchorPoint.y) <= EPS8 && orientation === label.orientation;
+
+// lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
+var CANDIDATE_SELECTED_COLOR4 = "blue";
+var CANDIDATE_REJECTED_COLOR4 = "red";
+var visualizeTraceAnchoredNetLabelOverlapSolver = (state) => {
+  const graphics = visualizeInputProblem(state.inputProblem);
+  ensureGraphicsArrays3(graphics);
+  drawTraces4(graphics, state.traces);
+  drawNetLabels4(graphics, state.inputProblem, state.outputNetLabelPlacements);
+  if (!state.solved) {
+    drawCurrentOverlap2(graphics, state);
+    drawCurrentCandidates4(graphics, state.currentCandidateResults);
+  }
+  return graphics;
+};
+var drawTraces4 = (graphics, traces) => {
+  for (const trace of traces) {
+    graphics.lines.push({
+      points: trace.tracePath,
+      strokeColor: "purple"
+    });
+  }
+};
+var drawNetLabels4 = (graphics, inputProblem, 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: getNetLabelVisualizationLabel(inputProblem, label)
+    });
+    graphics.points.push({
+      x: label.anchorPoint.x,
+      y: label.anchorPoint.y,
+      color: getColorFromString(label.globalConnNetId, 0.9),
+      label: `anchorPoint
+orientation: ${label.orientation}`
+    });
+  }
+};
+var drawCurrentOverlap2 = (graphics, state) => {
+  if (!state.currentOverlap) return;
+  for (const labelIndex of [
+    state.currentOverlap.firstLabelIndex,
+    state.currentOverlap.secondLabelIndex
+  ]) {
+    const label = state.outputNetLabelPlacements[labelIndex];
+    if (!label) continue;
+    graphics.rects.push({
+      center: label.center,
+      width: label.width,
+      height: label.height,
+      fill: "rgba(255, 0, 0, 0.2)",
+      strokeColor: CANDIDATE_REJECTED_COLOR4,
+      label: `netlabel overlap target
+${label.netId ?? label.globalConnNetId}
+${getAvailableOrientationText(state.inputProblem, label)}`
+    });
+  }
+};
+var drawCurrentCandidates4 = (graphics, candidates) => {
+  for (const candidate of candidates) {
+    const color = candidate.selected ? CANDIDATE_SELECTED_COLOR4 : CANDIDATE_REJECTED_COLOR4;
+    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} netlabel overlap candidate
+trace: ${candidate.traceId}
+path distance: ${candidate.pathDistance.toFixed(3)}
+orientation: ${candidate.orientation}
+distance from original: ${candidate.distanceFromOriginal.toFixed(3)}`
+    });
+    graphics.points.push({
+      ...candidate.anchorPoint,
+      color,
+      label: `candidate anchor
+${candidate.status}`
+    });
+  }
+};
+var ensureGraphicsArrays3 = (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 = [];
+};
+var getAvailableOrientationText = (inputProblem, label) => {
+  const orientations = getAvailableOrientationsForLabel(inputProblem, label);
+  return `available orientations: ${orientations?.join(", ") ?? "any"}`;
+};
+var getNetLabelVisualizationLabel = (inputProblem, label) => [
+  `netId: ${label.netId}`,
+  `globalConnNetId: ${label.globalConnNetId}`,
+  getAvailableOrientationText(inputProblem, label)
+].join("\n");
+var getAvailableOrientationsForLabel = (inputProblem, label) => {
+  const availableOrientations = inputProblem.availableNetLabelOrientations ?? {};
+  for (const netId of [label.netId, label.globalConnNetId]) {
+    if (netId && Object.hasOwn(availableOrientations, netId)) {
+      return availableOrientations[netId];
+    }
+  }
+  return void 0;
+};
+
+// lib/solvers/TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver.ts
+var TraceAnchoredNetLabelOverlapSolver = class extends BaseSolver {
+  inputProblem;
+  traces;
+  netLabelPlacements;
+  outputNetLabelPlacements;
+  currentOverlap = null;
+  currentCandidateResults = [];
+  activeSearch = null;
+  skippedOverlapKeys = /* @__PURE__ */ new Set();
+  constructor(params) {
+    super();
+    this.inputProblem = params.inputProblem;
+    this.traces = params.traces;
+    this.netLabelPlacements = params.netLabelPlacements;
+    this.outputNetLabelPlacements = [...params.netLabelPlacements];
+  }
+  getConstructorParams() {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements
+    };
+  }
+  _step() {
+    if (this.activeSearch?.completed) this.clearActiveSearch();
+    const search = this.getNextSearchWithCandidates();
+    if (!search) {
+      this.finish();
+      return;
+    }
+    this.evaluateNextCandidate(search);
+  }
+  getOutput() {
+    return {
+      netLabelPlacements: this.outputNetLabelPlacements
+    };
+  }
+  findNextOverlap() {
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      for (let j = i + 1; j < this.outputNetLabelPlacements.length; j++) {
+        if (!this.isLabelEligible(i) && !this.isLabelEligible(j)) continue;
+        const overlap = {
+          firstLabelIndex: i,
+          secondLabelIndex: j
+        };
+        if (this.skippedOverlapKeys.has(this.getOverlapKey(overlap))) continue;
+        if (this.labelsOverlap(overlap)) return overlap;
+      }
+    }
+    return null;
+  }
+  isLabelEligible(labelIndex) {
+    return this.getTraceLocationsForLabel(labelIndex).length > 0;
+  }
+  labelsOverlap(overlap) {
+    const first = this.outputNetLabelPlacements[overlap.firstLabelIndex];
+    const second = this.outputNetLabelPlacements[overlap.secondLabelIndex];
+    if (!first || !second) return false;
+    return rectsOverlap3(getLabelBounds(first), getLabelBounds(second));
+  }
+  startNextOverlapSearch() {
+    const overlap = this.findNextOverlap();
+    if (!overlap) return null;
+    const search = {
+      overlap,
+      queuedLabelIndices: this.getMoveLabelIndices(overlap),
+      labelIndex: null,
+      candidates: [],
+      candidateIndex: 0,
+      candidateResults: [],
+      completed: false
+    };
+    this.setActiveSearch(search);
+    return search;
+  }
+  getMoveLabelIndices(overlap) {
+    const labelIndices = [];
+    if (this.isLabelEligible(overlap.secondLabelIndex)) {
+      labelIndices.push(overlap.secondLabelIndex);
+    }
+    if (this.isLabelEligible(overlap.firstLabelIndex)) {
+      labelIndices.push(overlap.firstLabelIndex);
+    }
+    return labelIndices;
+  }
+  getNextSearchWithCandidates() {
+    while (true) {
+      const search = this.activeSearch ?? this.startNextOverlapSearch();
+      if (!search) return null;
+      if (this.activateNextLabelSearch(search)) return search;
+      this.skipSearch(search);
+    }
+  }
+  activateNextLabelSearch(search) {
+    if (search.labelIndex !== null && search.candidateIndex < search.candidates.length) {
+      return true;
+    }
+    while (search.queuedLabelIndices.length > 0) {
+      const labelIndex = search.queuedLabelIndices.shift();
+      const label = this.outputNetLabelPlacements[labelIndex];
+      if (!label) continue;
+      search.labelIndex = labelIndex;
+      search.candidates = this.getCandidatesForLabel(label);
+      search.candidateIndex = 0;
+      if (search.candidates.length > 0) return true;
+    }
+    search.labelIndex = null;
+    search.candidates = [];
+    search.candidateIndex = 0;
+    return false;
+  }
+  skipSearch(search) {
+    this.skippedOverlapKeys.add(this.getOverlapKey(search.overlap));
+    this.clearActiveSearch();
+  }
+  evaluateNextCandidate(search) {
+    const labelIndex = search.labelIndex;
+    if (labelIndex === null) return;
+    const label = this.outputNetLabelPlacements[labelIndex];
+    const candidate = search.candidates[search.candidateIndex];
+    if (!label || !candidate) return;
+    search.candidateIndex += 1;
+    const evaluatedCandidate = {
+      ...candidate,
+      status: this.getCandidateStatus(candidate, labelIndex)
+    };
+    search.candidateResults.push(evaluatedCandidate);
+    if (evaluatedCandidate.status !== "valid") return;
+    evaluatedCandidate.selected = true;
+    this.applyCandidate(labelIndex, label, evaluatedCandidate);
+    search.completed = true;
+  }
+  getCandidatesForLabel(label) {
+    const candidates = [];
+    for (const traceLocation of getTraceLocationsForPoint(
+      label.anchorPoint,
+      this.traces
+    ).filter(({ trace }) => this.isTraceAssociatedWithLabel(trace, label))) {
+      candidates.push(
+        ...generateCandidatesAlongTrace({
+          inputProblem: this.inputProblem,
+          label,
+          traceLocation
+        })
+      );
+    }
+    return candidates;
+  }
+  getCandidateStatus(candidate, labelIndex) {
+    const bounds = getLabelBounds(candidate);
+    if (this.intersectsAnyChip(bounds)) return "chip-collision";
+    if (traceCrossesBoundsInterior2(bounds, this.traces))
+      return "trace-collision";
+    if (this.intersectsAnyOtherLabel(bounds, labelIndex)) {
+      return "netlabel-collision";
+    }
+    return "valid";
+  }
+  applyCandidate(labelIndex, label, candidate) {
+    this.outputNetLabelPlacements[labelIndex] = {
+      ...label,
+      anchorPoint: candidate.anchorPoint,
+      center: candidate.center,
+      width: candidate.width,
+      height: candidate.height,
+      orientation: candidate.orientation
+    };
+  }
+  intersectsAnyChip(bounds) {
+    return this.inputProblem.chips.some(
+      (chip) => rectsTouchOrOverlap(
+        bounds,
+        getRectBounds(chip.center, chip.width, chip.height)
+      )
+    );
+  }
+  intersectsAnyOtherLabel(bounds, labelIndex) {
+    return this.outputNetLabelPlacements.some((label, index) => {
+      if (index === labelIndex) return false;
+      return rectsOverlap3(bounds, getLabelBounds(label));
+    });
+  }
+  getTraceLocationsForLabel(labelIndex) {
+    const label = this.outputNetLabelPlacements[labelIndex];
+    if (!label) return [];
+    return getTraceLocationsForPoint(label.anchorPoint, this.traces).filter(
+      ({ trace }) => this.isTraceAssociatedWithLabel(trace, label)
+    );
+  }
+  isTraceAssociatedWithLabel(trace, label) {
+    if (label.mspConnectionPairIds.includes(trace.mspPairId)) return true;
+    if (label.netId !== void 0 && label.netId === trace.userNetId) {
+      return true;
+    }
+    return label.globalConnNetId === trace.globalConnNetId;
+  }
+  getOverlapKey(overlap) {
+    const first = this.outputNetLabelPlacements[overlap.firstLabelIndex];
+    const second = this.outputNetLabelPlacements[overlap.secondLabelIndex];
+    return [
+      overlap.firstLabelIndex,
+      overlap.secondLabelIndex,
+      first?.anchorPoint.x,
+      first?.anchorPoint.y,
+      second?.anchorPoint.x,
+      second?.anchorPoint.y
+    ].join(":");
+  }
+  finish() {
+    this.clearActiveSearch();
+    this.solved = true;
+  }
+  setActiveSearch(search) {
+    this.activeSearch = search;
+    this.currentOverlap = search.overlap;
+    this.currentCandidateResults = search.candidateResults;
+  }
+  clearActiveSearch() {
+    this.activeSearch = null;
+    this.currentOverlap = null;
+    this.currentCandidateResults = [];
+  }
+  visualize() {
+    return visualizeTraceAnchoredNetLabelOverlapSolver({
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      outputNetLabelPlacements: this.outputNetLabelPlacements,
+      currentOverlap: this.currentOverlap,
+      currentCandidateResults: this.currentCandidateResults,
+      solved: this.solved
+    });
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -6385,6 +7127,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   example28Solver;
   availableNetOrientationSolver;
   vccNetLabelCornerPlacementSolver;
+  traceAnchoredNetLabelOverlapSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -6554,6 +7297,17 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           }
         ];
       }
+    ),
+    definePipelineStep(
+      "traceAnchoredNetLabelOverlapSolver",
+      TraceAnchoredNetLabelOverlapSolver,
+      (instance) => [
+        {
+          inputProblem: instance.inputProblem,
+          traces: instance.availableNetOrientationSolver.traces,
+          netLabelPlacements: instance.vccNetLabelCornerPlacementSolver.outputNetLabelPlacements
+        }
+      ]
     )
   ];
   constructor(inputProblem) {
@@ -6648,6 +7402,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       circles: visualizations.flatMap((v) => v.circles || []),
       texts: visualizations.flatMap((v) => v.texts || [])
     };
+    colorAvailableNetOrientationLabels(finalGraphics, this.inputProblem);
     return finalGraphics;
   }
   /**