@tscircuit/core 0.0.2118 → 0.0.2119

package/dist/index.js

@@ -93724,6 +93724,265 @@ var balanceZShapes = ({
     tracePath: finalSimplifiedPath
   };
 };
+var LABEL_SEARCH_STEP = 0.05;
+var MAX_RECORDED_CANDIDATES = 2e3;
+var WICK_CLEARANCE = 1e-3;
+var EPS8 = 1e-9;
+var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS8;
+var CANDIDATE_SELECTED_COLOR = "blue";
+var CANDIDATE_REJECTED_COLOR = "red";
+var isYOrientation = (orientation2) => orientation2 === "y+" || orientation2 === "y-";
+var isXOrientation = (orientation2) => orientation2 === "x+" || orientation2 === "x-";
+var rectsOverlap = (a2, b2) => Math.min(a2.maxX, b2.maxX) - Math.max(a2.minX, b2.minX) > EPS8 && Math.min(a2.maxY, b2.maxY) - Math.max(a2.minY, b2.minY) > EPS8;
+var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS8;
+var traceCrossesBoundsInterior = (bounds, traceMap) => {
+  for (const trace of Object.values(traceMap)) {
+    const points = trace.tracePath;
+    for (let i2 = 0; i2 < points.length - 1; i2++) {
+      if (segmentCrossesBoundsInterior(points[i2], points[i2 + 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 + EPS8 || p1.x >= interiorBounds.maxX - EPS8) {
+      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 + EPS8 || p1.y >= interiorBounds.maxY - EPS8) {
+      return false;
+    }
+    return rangesOverlap(
+      Math.min(p1.x, p2.x),
+      Math.max(p1.x, p2.x),
+      interiorBounds.minX,
+      interiorBounds.maxX
+    );
+  }
+  return false;
+};
+var tracePathCrossesAnyBounds = (tracePath, bounds) => {
+  for (let i2 = 0; i2 < tracePath.length - 1; i2++) {
+    if (segmentCrossesBoundsInterior(tracePath[i2], tracePath[i2 + 1], bounds)) {
+      return true;
+    }
+  }
+  return false;
+};
+var tracePathIntersectsBounds = (tracePath, bounds) => {
+  for (let i2 = 0; i2 < tracePath.length - 1; i2++) {
+    if (segmentIntersectsRect2(tracePath[i2], tracePath[i2 + 1], bounds)) {
+      return true;
+    }
+  }
+  return false;
+};
+var getSideDistances = (point6, bounds) => [
+  ["left", Math.abs(point6.x - bounds.minX)],
+  ["right", Math.abs(point6.x - bounds.maxX)],
+  ["bottom", Math.abs(point6.y - bounds.minY)],
+  ["top", Math.abs(point6.y - bounds.maxY)]
+];
+var getConnectorTracePath = (source, target, orientation2) => simplifyOrthogonalPath(
+  isYOrientation(orientation2) ? [source, { x: target.x, y: source.y }, target] : [source, { x: source.x, y: target.y }, target]
+);
+var simplifyOrthogonalPath = (path) => {
+  const deduped = path.filter(
+    (point6, index2) => index2 === 0 || !pointsEqual3(point6, path[index2 - 1])
+  );
+  if (deduped.length < 3) return deduped;
+  const simplified = [deduped[0]];
+  for (let i2 = 1; i2 < deduped.length - 1; i2++) {
+    const prev = simplified[simplified.length - 1];
+    const point6 = deduped[i2];
+    const next = deduped[i2 + 1];
+    if (sameX(prev, point6) && sameX(point6, next) || sameY(prev, point6) && sameY(point6, next)) {
+      continue;
+    }
+    simplified.push(point6);
+  }
+  simplified.push(deduped[deduped.length - 1]);
+  return simplified;
+};
+var pointsEqual3 = (a2, b2) => sameX(a2, b2) && sameY(a2, b2);
+var sameX = (a2, b2) => Math.abs(a2.x - b2.x) <= EPS8;
+var sameY = (a2, b2) => Math.abs(a2.y - b2.y) <= EPS8;
+var getMaxSearchDistance = (inputProblem) => {
+  const maxChipWidth = Math.max(
+    ...inputProblem.chips.map((chip) => chip.width),
+    1
+  );
+  return maxChipWidth * 3;
+};
+var EPS9 = 1e-6;
+var isTraceLine = (trace) => getUniquePinCount(trace.pinIds) >= 2;
+var rectsOverlap2 = (a2, b2) => Math.min(a2.maxX, b2.maxX) - Math.max(a2.minX, b2.minX) > EPS9 && Math.min(a2.maxY, b2.maxY) - Math.max(a2.minY, b2.minY) > EPS9;
+var getTraceCorners = (path) => {
+  const corners = [];
+  for (let i2 = 1; i2 < path.length - 1; i2++) {
+    const previousPoint = path[i2 - 1];
+    const cornerPoint = path[i2];
+    const nextPoint = path[i2 + 1];
+    if (isTraceCorner(previousPoint, cornerPoint, nextPoint)) {
+      corners.push(cornerPoint);
+    }
+  }
+  return corners;
+};
+var tracePathContainsPoint = (path, point6) => {
+  for (let i2 = 0; i2 < path.length - 1; i2++) {
+    if (isPointOnSegment(point6, path[i2], path[i2 + 1])) return true;
+  }
+  return false;
+};
+var getDistance2 = (a2, b2) => Math.abs(a2.x - b2.x) + Math.abs(a2.y - b2.y);
+var getUniquePinCount = (pinIds) => new Set(pinIds).size;
+var isTraceCorner = (a2, b2, c2) => getSegmentOrientation(a2, b2) !== getSegmentOrientation(b2, c2);
+var isPointOnSegment = (point6, start, end) => {
+  if (getSegmentOrientation(start, end) === "horizontal") {
+    return Math.abs(point6.y - start.y) <= EPS9 && point6.x >= Math.min(start.x, end.x) - EPS9 && point6.x <= Math.max(start.x, end.x) + EPS9;
+  }
+  return Math.abs(point6.x - start.x) <= EPS9 && point6.y >= Math.min(start.y, end.y) - EPS9 && point6.y <= Math.max(start.y, end.y) + EPS9;
+};
+var getSegmentOrientation = (a2, b2) => Math.abs(a2.y - b2.y) <= EPS9 ? "horizontal" : "vertical";
+var getGroundNetIds = (inputProblem, netConnMap) => {
+  const groundNetIds = /* @__PURE__ */ new Set();
+  for (const connection of inputProblem.netConnections) {
+    if (!connection.isGround) continue;
+    const netId = netConnMap.getNetConnectedToId(connection.netId);
+    if (netId) groundNetIds.add(netId);
+  }
+  return groundNetIds;
+};
+var placeGroundRailLabelsAtOuterEnd = ({
+  inputProblem,
+  traces,
+  netLabelPlacements
+}) => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
+  const groundNetIds = getGroundNetIds(inputProblem, netConnMap);
+  if (groundNetIds.size === 0) return netLabelPlacements;
+  const chipMap = new Map(inputProblem.chips.map((chip) => [chip.chipId, chip]));
+  const traceMap = Object.fromEntries(
+    traces.map((trace) => [trace.mspPairId, trace])
+  );
+  const obstacles = getObstacleRects(inputProblem);
+  const output = [...netLabelPlacements];
+  for (const rail of traces) {
+    if (!groundNetIds.has(rail.globalConnNetId)) continue;
+    const [a2, b2] = rail.pins;
+    if (a2.chipId === b2.chipId || !nearlyEqual(a2.y, b2.y) || ![a2, b2].every(
+      (pin) => pin._facingDirection === "y-" && chipMap.get(pin.chipId)?.pins.length === 2
+    ))
+      continue;
+    const path = simplifyPath(rail.tracePath);
+    if (path.length !== 4 || !isVertical2(path[0], path[1]) || !isHorizontal22(path[1], path[2]) || !isVertical2(path[2], path[3]) || path[1].y >= a2.y)
+      continue;
+    for (const feed of traces) {
+      if (feed.globalConnNetId !== rail.globalConnNetId) continue;
+      const shared = feed.pins.find((pin) => rail.pinIds.includes(pin.pinId));
+      const icPin = feed.pins.find(
+        (pin) => !rail.pinIds.includes(pin.pinId) && (chipMap.get(pin.chipId)?.pins.length ?? 0) > 2
+      );
+      if (!shared || !icPin || !nearlyEqual(icPin.y, path[1].y)) continue;
+      const outer = shared.pinId === a2.pinId ? b2 : a2;
+      if (Math.abs(outer.x - icPin.x) <= Math.abs(shared.x - icPin.x)) continue;
+      const anchorPoint = { x: outer.x, y: path[1].y };
+      if (!tracePathContainsPoint(rail.tracePath, anchorPoint)) continue;
+      for (let index2 = 0; index2 < output.length; index2++) {
+        const label = output[index2];
+        if (label.globalConnNetId !== rail.globalConnNetId || label.orientation !== "y-" || !label.mspConnectionPairIds.some(
+          (id) => id === feed.mspPairId || id === rail.mspPairId
+        ) || !tracePathContainsPoint(feed.tracePath, label.anchorPoint) && !tracePathContainsPoint(rail.tracePath, label.anchorPoint))
+          continue;
+        const center = getCenterFromAnchor(
+          anchorPoint,
+          label.orientation,
+          label.width,
+          label.height
+        );
+        const bounds = getRectBounds(center, label.width, label.height);
+        if (obstacles.some((obstacle) => rectsOverlap2(bounds, obstacle)) || traceCrossesBoundsInterior(bounds, traceMap) || output.some(
+          (other, otherIndex) => otherIndex !== index2 && rectsOverlap2(
+            bounds,
+            getRectBounds(other.center, other.width, other.height)
+          )
+        ))
+          continue;
+        output[index2] = {
+          ...label,
+          anchorPoint,
+          center,
+          mspConnectionPairIds: [rail.mspPairId],
+          pinIds: [...rail.pinIds]
+        };
+      }
+    }
+  }
+  for (let index2 = 0; index2 < output.length; index2++) {
+    const label = output[index2];
+    if (label.orientation !== "y-" || !groundNetIds.has(label.globalConnNetId))
+      continue;
+    const hasSharedRail = inputProblem.netConnections.some(
+      (candidate) => candidate.pinIds.length > 2 && netConnMap.getNetConnectedToId(candidate.netId) === label.globalConnNetId
+    );
+    if (!hasSharedRail) continue;
+    const columnSegments = traces.filter((trace) => trace.globalConnNetId === label.globalConnNetId).flatMap(
+      (trace) => trace.tracePath.slice(1).flatMap((end, pointIndex) => {
+        const start = trace.tracePath[pointIndex];
+        return nearlyEqual(start.x, label.anchorPoint.x) && nearlyEqual(end.x, label.anchorPoint.x) ? [
+          {
+            minY: Math.min(start.y, end.y),
+            maxY: Math.max(start.y, end.y)
+          }
+        ] : [];
+      })
+    ).sort((a2, b2) => b2.maxY - a2.maxY);
+    let lowestY = label.anchorPoint.y;
+    for (const segment2 of columnSegments) {
+      if (segment2.maxY + RAIL_ALIGNMENT_EPSILON >= lowestY && segment2.minY < lowestY) {
+        lowestY = segment2.minY;
+      }
+    }
+    if (nearlyEqual(lowestY, label.anchorPoint.y)) continue;
+    const anchorPoint = { x: label.anchorPoint.x, y: lowestY };
+    const center = getCenterFromAnchor(
+      anchorPoint,
+      label.orientation,
+      label.width,
+      label.height
+    );
+    const bounds = getRectBounds(center, label.width, label.height);
+    if (obstacles.some((obstacle) => rectsOverlap2(bounds, obstacle)) || traceCrossesBoundsInterior(bounds, traceMap) || output.some(
+      (other, otherIndex) => otherIndex !== index2 && rectsOverlap2(
+        bounds,
+        getRectBounds(other.center, other.width, other.height)
+      )
+    ))
+      continue;
+    output[index2] = { ...label, anchorPoint, center };
+  }
+  return output;
+};
 var getAlongBounds = (orientation2, minAlong, maxAlong) => orientation2 === "vertical" ? { minX: 0, maxX: 0, minY: minAlong, maxY: maxAlong } : { minX: minAlong, maxX: maxAlong, minY: 0, maxY: 0 };
 var hasPositiveAlongOverlap = (orientation2, first, second) => {
   const overlap = boundsIntersection(first, second);
@@ -93768,37 +94027,6 @@ var getRailAlignmentFallbackCoordinates = ({
   }
   return getDistinctCoordinates(coordinates);
 };
-var EPS8 = 1e-6;
-var isTraceLine = (trace) => getUniquePinCount(trace.pinIds) >= 2;
-var rectsOverlap = (a2, b2) => Math.min(a2.maxX, b2.maxX) - Math.max(a2.minX, b2.minX) > EPS8 && Math.min(a2.maxY, b2.maxY) - Math.max(a2.minY, b2.minY) > EPS8;
-var getTraceCorners = (path) => {
-  const corners = [];
-  for (let i2 = 1; i2 < path.length - 1; i2++) {
-    const previousPoint = path[i2 - 1];
-    const cornerPoint = path[i2];
-    const nextPoint = path[i2 + 1];
-    if (isTraceCorner(previousPoint, cornerPoint, nextPoint)) {
-      corners.push(cornerPoint);
-    }
-  }
-  return corners;
-};
-var tracePathContainsPoint = (path, point6) => {
-  for (let i2 = 0; i2 < path.length - 1; i2++) {
-    if (isPointOnSegment(point6, path[i2], path[i2 + 1])) return true;
-  }
-  return false;
-};
-var getDistance2 = (a2, b2) => Math.abs(a2.x - b2.x) + Math.abs(a2.y - b2.y);
-var getUniquePinCount = (pinIds) => new Set(pinIds).size;
-var isTraceCorner = (a2, b2, c2) => getSegmentOrientation(a2, b2) !== getSegmentOrientation(b2, c2);
-var isPointOnSegment = (point6, start, end) => {
-  if (getSegmentOrientation(start, end) === "horizontal") {
-    return Math.abs(point6.y - start.y) <= EPS8 && point6.x >= Math.min(start.x, end.x) - EPS8 && point6.x <= Math.max(start.x, end.x) + EPS8;
-  }
-  return Math.abs(point6.x - start.x) <= EPS8 && point6.y >= Math.min(start.y, end.y) - EPS8 && point6.y <= Math.max(start.y, end.y) + EPS8;
-};
-var getSegmentOrientation = (a2, b2) => Math.abs(a2.y - b2.y) <= EPS8 ? "horizontal" : "vertical";
 var hasLabelOnAdjacentInteriorLeg = (segment2, trace, anchorPoint) => {
   const pathsFromRailEnds = [
     trace.tracePath.slice(0, segment2.segmentIndex + 1).reverse(),
@@ -93937,15 +94165,15 @@ var preservesLabelAnchors = (labels, before, after) => labels.every((label) => {
   const anchoredAfter = getAnchoredTraceIds(label, after);
   return [...anchoredBefore].every((traceId) => anchoredAfter.has(traceId));
 });
-var EPS9 = 1e-9;
+var EPS10 = 1e-9;
 var segmentRunsAlongRectBoundary = (start, end, rect) => {
-  const isVertical6 = Math.abs(start.x - end.x) < EPS9;
-  const isHorizontal5 = Math.abs(start.y - end.y) < EPS9;
+  const isVertical6 = Math.abs(start.x - end.x) < EPS10;
+  const isHorizontal5 = Math.abs(start.y - end.y) < EPS10;
   if (isVertical6) {
-    return Math.abs(start.x - rect.minX) < EPS9 || Math.abs(start.x - rect.maxX) < EPS9;
+    return Math.abs(start.x - rect.minX) < EPS10 || Math.abs(start.x - rect.maxX) < EPS10;
   }
   if (isHorizontal5) {
-    return Math.abs(start.y - rect.minY) < EPS9 || Math.abs(start.y - rect.maxY) < EPS9;
+    return Math.abs(start.y - rect.minY) < EPS10 || Math.abs(start.y - rect.maxY) < EPS10;
   }
   return false;
 };
@@ -93958,10 +94186,10 @@ var getPathLength4 = (path) => {
   return length8;
 };
 var getDistance22 = (a2, b2) => Math.abs(a2.x - b2.x) + Math.abs(a2.y - b2.y);
-var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS9 || Math.abs(start.y - end.y) < EPS9;
-var getSegmentOrientation2 = (start, end) => Math.abs(start.y - end.y) < EPS9 ? "horizontal" : "vertical";
+var isAxisAlignedSegment = (start, end) => Math.abs(start.x - end.x) < EPS10 || Math.abs(start.y - end.y) < EPS10;
+var getSegmentOrientation2 = (start, end) => Math.abs(start.y - end.y) < EPS10 ? "horizontal" : "vertical";
 var projectPointToSegment = (point6, start, end) => {
-  if (Math.abs(start.x - end.x) < EPS9) {
+  if (Math.abs(start.x - end.x) < EPS10) {
     return {
       x: start.x,
       y: Math.min(
@@ -93970,7 +94198,7 @@ var projectPointToSegment = (point6, start, end) => {
       )
     };
   }
-  if (Math.abs(start.y - end.y) < EPS9) {
+  if (Math.abs(start.y - end.y) < EPS10) {
     return {
       x: Math.min(
         Math.max(point6.x, Math.min(start.x, end.x)),
@@ -94013,9 +94241,9 @@ var findSegmentContainingPoint = (path, point6) => {
 };
 var isPointWithinSegmentPrimaryRange = (point6, segment2) => {
   if (segment2.orientation === "horizontal") {
-    return point6.x >= Math.min(segment2.start.x, segment2.end.x) - EPS9 && point6.x <= Math.max(segment2.start.x, segment2.end.x) + EPS9;
+    return point6.x >= Math.min(segment2.start.x, segment2.end.x) - EPS10 && point6.x <= Math.max(segment2.start.x, segment2.end.x) + EPS10;
   }
-  return point6.y >= Math.min(segment2.start.y, segment2.end.y) - EPS9 && point6.y <= Math.max(segment2.start.y, segment2.end.y) + EPS9;
+  return point6.y >= Math.min(segment2.start.y, segment2.end.y) - EPS10 && point6.y <= Math.max(segment2.start.y, segment2.end.y) + EPS10;
 };
 var findPreferredReroutedSegment = (path, originalSegmentIndex, originalSegmentCount, orientation2, anchorPoint) => {
   const matchingSegments = getSegments3(path).filter(
@@ -94043,18 +94271,18 @@ var projectPointToPath = (point6, path) => {
   return bestPoint;
 };
 var segmentsIntersect2 = (a1, a2, b1, b2) => {
-  const aVertical = Math.abs(a1.x - a2.x) < EPS9;
-  const bVertical = Math.abs(b1.x - b2.x) < EPS9;
-  const between2 = (value, p1, p2) => value >= Math.min(p1, p2) - EPS9 && value <= Math.max(p1, p2) + EPS9;
+  const aVertical = Math.abs(a1.x - a2.x) < EPS10;
+  const bVertical = Math.abs(b1.x - b2.x) < EPS10;
+  const between2 = (value, p1, p2) => value >= Math.min(p1, p2) - EPS10 && value <= Math.max(p1, p2) + EPS10;
   if (aVertical && bVertical) {
-    if (Math.abs(a1.x - b1.x) > EPS9) return false;
+    if (Math.abs(a1.x - b1.x) > EPS10) 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 > EPS9;
+    return overlap > EPS10;
   }
   if (!aVertical && !bVertical) {
-    if (Math.abs(a1.y - b1.y) > EPS9) return false;
+    if (Math.abs(a1.y - b1.y) > EPS10) 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 > EPS9;
+    return overlap > EPS10;
   }
   const verticalA = aVertical ? a1 : b1;
   const verticalB = aVertical ? a2 : b2;
@@ -94125,6 +94353,7 @@ var tracePathChanged = (original, candidate) => original.tracePath.length !== ca
   (point6, index2) => !pointsEqual22(point6, original.tracePath[index2])
 );
 var evaluateRailGroup = ({
+  inputProblem,
   group,
   traces,
   netLabelPlacements,
@@ -94147,6 +94376,11 @@ var evaluateRailGroup = ({
   const otherNetTraces = traces.filter(
     (trace) => trace.globalConnNetId !== group[0].globalConnNetId
   );
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
+  const groundNetIds = getGroundNetIds(inputProblem, netConnMap);
+  const groundLabelIndices = netLabelPlacements.flatMap(
+    (label, index2) => label.globalConnNetId === group[0].globalConnNetId && groundNetIds.has(label.globalConnNetId) ? [index2] : []
+  );
   const immutableSameNetTraces = traces.filter(
     (trace) => trace.globalConnNetId === group[0].globalConnNetId && !eligibleTraceIds.has(trace.mspPairId)
   );
@@ -94166,11 +94400,24 @@ var evaluateRailGroup = ({
       const allCandidateTraces = traces.map(
         (trace) => candidateMap.get(trace.mspPairId) ?? trace
       );
+      const placedGroundLabels = groundLabelIndices.length ? placeGroundRailLabelsAtOuterEnd({
+        inputProblem,
+        traces: allCandidateTraces,
+        netLabelPlacements
+      }) : netLabelPlacements;
+      const groundLabelBounds = groundLabelIndices.map((index2) => {
+        const label = placedGroundLabels[index2];
+        return getRectBounds(label.center, label.width, label.height);
+      });
       const candidatesAreClear = candidateTraces.every(
         (candidate2) => !isPathCollidingWithObstacles(candidate2.tracePath, obstacles) && detectTraceLabelOverlap({
           traces: [candidate2],
           netLabels: netLabelPlacements
-        }).length === 0 && !doesPathOverlapTraceStrokes(candidate2.tracePath, otherNetTraces) && !doesPathCoincideWithTraces(
+        }).length === 0 && // Ground labels may move to the new rail end later in the pipeline.
+        // Reject alignment if even that placement leaves a symbol crossed.
+        !groundLabelBounds.some(
+          (bounds) => tracePathCrossesAnyBounds(candidate2.tracePath, bounds)
+        ) && !doesPathOverlapTraceStrokes(candidate2.tracePath, otherNetTraces) && !doesPathCoincideWithTraces(
           candidate2.tracePath,
           immutableSameNetTraces.filter(
             (trace) => trace.mspPairId !== candidate2.mspPairId
@@ -94439,6 +94686,7 @@ var alignSameNetRails = ({
     let applied = null;
     for (const group of groups) {
       applied = evaluateRailGroup({
+        inputProblem,
         group,
         traces: outputTraces,
         netLabelPlacements,
@@ -94493,7 +94741,7 @@ var getTraceObstacles = (allTraces, excludeTraceId) => {
   }
   return obstacles;
 };
-var EPS10 = 1e-6;
+var EPS11 = 1e-6;
 var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   const intersections2 = [];
   for (const obstacle of obstacles) {
@@ -94512,7 +94760,7 @@ var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
   }
   return intersections2;
 };
-var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS10 && Math.abs(first.y - second.y) < EPS10;
+var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS11 && Math.abs(first.y - second.y) < EPS11;
 var findPerpendicularPathCrossings = (path, otherPath, options = {}) => {
   const crossings = [];
   const firstPathSegmentIndex = options.includeTerminalSegments ? 0 : 1;
@@ -94522,11 +94770,11 @@ var findPerpendicularPathCrossings = (path, otherPath, options = {}) => {
   for (let pathSegmentIndex = firstPathSegmentIndex; pathSegmentIndex < lastPathSegmentIndex; pathSegmentIndex++) {
     const start = path[pathSegmentIndex];
     const end = path[pathSegmentIndex + 1];
-    const isVertical6 = Math.abs(start.x - end.x) < EPS10;
+    const isVertical6 = Math.abs(start.x - end.x) < EPS11;
     for (let otherPathSegmentIndex = firstOtherPathSegmentIndex; otherPathSegmentIndex < lastOtherPathSegmentIndex; otherPathSegmentIndex++) {
       const otherStart = otherPath[otherPathSegmentIndex];
       const otherEnd = otherPath[otherPathSegmentIndex + 1];
-      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS10;
+      const otherIsVertical = Math.abs(otherStart.x - otherEnd.x) < EPS11;
       if (isVertical6 === otherIsVertical) continue;
       const intersection2 = getSegmentIntersection(
         start,
@@ -94544,8 +94792,8 @@ var findPerpendicularPathCrossings = (path, otherPath, options = {}) => {
   }
   return crossings;
 };
-var EPS11 = 1e-6;
-var isVertical3 = (a2, b2, eps = EPS11) => Math.abs(a2.x - b2.x) < eps;
+var EPS12 = 1e-6;
+var isVertical3 = (a2, b2, eps = EPS12) => Math.abs(a2.x - b2.x) < eps;
 var generateLShapeRerouteCandidates = ({
   lShape,
   rectangle,
@@ -94558,7 +94806,7 @@ var generateLShapeRerouteCandidates = ({
   let c2;
   let i1_padded = interactionPoint1;
   let i2_padded = interactionPoint2;
-  if (Math.abs(p2.x - x2) < EPS11 && Math.abs(p2.y - (y2 + height)) < EPS11) {
+  if (Math.abs(p2.x - x2) < EPS12 && Math.abs(p2.y - (y2 + height)) < EPS12) {
     c2 = { x: x2 + width + padding, y: y2 - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -94570,7 +94818,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x2 + width)) < EPS11 && Math.abs(p2.y - (y2 + height)) < EPS11) {
+  } else if (Math.abs(p2.x - (x2 + width)) < EPS12 && Math.abs(p2.y - (y2 + height)) < EPS12) {
     c2 = { x: x2 - padding, y: y2 - padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y - padding };
@@ -94582,7 +94830,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x - padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - x2) < EPS11 && Math.abs(p2.y - y2) < EPS11) {
+  } else if (Math.abs(p2.x - x2) < EPS12 && Math.abs(p2.y - y2) < EPS12) {
     c2 = { x: x2 + width + padding, y: y2 + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -94594,7 +94842,7 @@ var generateLShapeRerouteCandidates = ({
     } else {
       i2_padded = { x: interactionPoint2.x + padding, y: interactionPoint2.y };
     }
-  } else if (Math.abs(p2.x - (x2 + width)) < EPS11 && Math.abs(p2.y - y2) < EPS11) {
+  } else if (Math.abs(p2.x - (x2 + width)) < EPS12 && Math.abs(p2.y - y2) < EPS12) {
     c2 = { x: x2 - padding, y: y2 + height + padding };
     if (isVertical3(p1, p2)) {
       i1_padded = { x: interactionPoint1.x, y: interactionPoint1.y + padding };
@@ -94668,7 +94916,7 @@ var generatePerpendicularTraceDetours = ({
   const buildDetours = (path, index2) => {
     const start = path[index2];
     const end = path[index2 + 1];
-    const movingAxis = Math.abs(start.x - end.x) < EPS11 ? "y" : "x";
+    const movingAxis = Math.abs(start.x - end.x) < EPS12 ? "y" : "x";
     const detourAxis = movingAxis === "x" ? "y" : "x";
     const bounds = obstacleBounds ?? {
       minX: Math.min(obstacleStart.x, obstacleEnd.x),
@@ -95274,14 +95522,14 @@ var UntangleTraceSubsolver = class extends BaseSolver10 {
     }
   }
 };
-var EPS12 = 1e-6;
-var sameX = (a2, b2) => Math.abs(a2.x - b2.x) <= EPS12;
-var sameY = (a2, b2) => Math.abs(a2.y - b2.y) <= EPS12;
+var EPS13 = 1e-6;
+var sameX2 = (a2, b2) => Math.abs(a2.x - b2.x) <= EPS13;
+var sameY2 = (a2, b2) => Math.abs(a2.y - b2.y) <= EPS13;
 var is4PointRectangle = (path) => {
   if (path.length !== 4) return false;
   const [p0, p1, p2, p3] = path;
-  const isHVHC = sameY(p0, p1) && sameX(p1, p2) && sameY(p2, p3) && sameX(p0, p3);
-  const isVHVC = sameX(p0, p1) && sameY(p1, p2) && sameX(p2, p3) && sameY(p0, p3);
+  const isHVHC = sameY2(p0, p1) && sameX2(p1, p2) && sameY2(p2, p3) && sameX2(p0, p3);
+  const isVHVC = sameX2(p0, p1) && sameY2(p1, p2) && sameX2(p2, p3) && sameY2(p0, p3);
   return isHVHC || isVHVC;
 };
 var getInteriorShortcutPaths = (path) => {
@@ -95312,7 +95560,7 @@ var getInteriorShortcutPaths = (path) => {
   }
   return candidates;
 };
-var EPS13 = 1e-6;
+var EPS14 = 1e-6;
 var getConnectorObstacleBounds = (connector, segmentIndex, labels) => {
   const start = connector.tracePath[segmentIndex];
   const end = connector.tracePath[segmentIndex + 1];
@@ -95409,7 +95657,7 @@ var rerouteGeneratedNetLabelConnectorCrossings = ({
           path
         }))
       ).filter(
-        (candidate) => getPathLength4(candidate.path) <= getPathLength4(trace.tracePath) + EPS13 && countTurns(candidate.path) <= countTurns(trace.tracePath) + 2 && !isPathCollidingWithObstacles(
+        (candidate) => getPathLength4(candidate.path) <= getPathLength4(trace.tracePath) + EPS14 && countTurns(candidate.path) <= countTurns(trace.tracePath) + 2 && !isPathCollidingWithObstacles(
           candidate.path,
           componentAndTextObstacles
         ) && !hasCollisionsWithLabels(candidate.path, foreignLabelBounds) && !isPathColliding(candidate.path, foreignTraces, trace.mspPairId).isColliding && !doesPathCoincideWithTraces(candidate.path, foreignTraces)
@@ -95420,7 +95668,7 @@ var rerouteGeneratedNetLabelConnectorCrossings = ({
     });
     candidates.sort((first, second) => {
       const lengthDifference = getPathLength4(first.path) - getPathLength4(second.path);
-      return Math.abs(lengthDifference) > EPS13 ? lengthDifference : countTurns(first.path) - countTurns(second.path);
+      return Math.abs(lengthDifference) > EPS14 ? lengthDifference : countTurns(first.path) - countTurns(second.path);
     });
     const bestCandidate = candidates[0];
     if (!bestCandidate) break;
@@ -95788,7 +96036,7 @@ var doesPathRunAlongChipBoundary = (path, chipObstacles) => {
     const end = path[i2 + 1];
     for (const obstacle of chipObstacles) {
       if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
-      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS9) {
+      if (getSegmentOverlapWithRectSpan(start, end, obstacle) > EPS10) {
         return true;
       }
     }
@@ -95803,13 +96051,13 @@ var getChipBoundaryOverlap = (path, chipObstacles) => {
     for (const obstacle of chipObstacles) {
       if (!segmentRunsAlongRectBoundary(start, end, obstacle)) continue;
       const overlap = getSegmentOverlapWithRectSpan(start, end, obstacle);
-      if (overlap > EPS9) total += overlap;
+      if (overlap > EPS10) total += overlap;
     }
   }
   return total;
 };
 var getSegmentOverlapWithRectSpan = (start, end, rect) => {
-  const isVertical6 = Math.abs(start.x - end.x) < EPS9;
+  const isVertical6 = Math.abs(start.x - end.x) < EPS10;
   if (isVertical6) {
     return Math.min(Math.max(start.y, end.y), rect.maxY) - Math.max(Math.min(start.y, end.y), rect.minY);
   }
@@ -96255,8 +96503,8 @@ var scoreSolutionTracePath = (params) => {
   }
   return { chipEdgeRuns, traceCrossings };
 };
-var CANDIDATE_SELECTED_COLOR = "blue";
-var CANDIDATE_REJECTED_COLOR = "red";
+var CANDIDATE_SELECTED_COLOR2 = "blue";
+var CANDIDATE_REJECTED_COLOR2 = "red";
 var visualizeExample28Solver = (state) => {
   const graphics = visualizeInputProblem(state.inputProblem);
   drawTraces(graphics, state);
@@ -96302,7 +96550,7 @@ 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,
+      strokeColor: candidate.selected ? CANDIDATE_SELECTED_COLOR2 : CANDIDATE_REJECTED_COLOR2,
       strokeDash: candidate.selected ? void 0 : "4 2",
       label: `${candidate.selected ? "selected" : candidate.status} reroute${scoreLabel}`
     });
@@ -96316,7 +96564,7 @@ var drawCurrentOverlap = (graphics, state) => {
     width: label.width,
     height: label.height,
     fill: "rgba(255, 0, 0, 0.2)",
-    strokeColor: CANDIDATE_REJECTED_COLOR,
+    strokeColor: CANDIDATE_REJECTED_COLOR2,
     label: `overlap target
 ${label.netId ?? label.globalConnNetId}`
   });
@@ -96559,107 +96807,6 @@ var createPortOnlyLabelConnectorTrace = ({
     pinIds: label.pinIds
   };
 };
-var LABEL_SEARCH_STEP = 0.05;
-var MAX_RECORDED_CANDIDATES = 2e3;
-var WICK_CLEARANCE = 1e-3;
-var EPS14 = 1e-9;
-var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS14;
-var CANDIDATE_SELECTED_COLOR2 = "blue";
-var CANDIDATE_REJECTED_COLOR2 = "red";
-var isYOrientation = (orientation2) => orientation2 === "y+" || orientation2 === "y-";
-var isXOrientation = (orientation2) => orientation2 === "x+" || orientation2 === "x-";
-var rectsOverlap2 = (a2, b2) => Math.min(a2.maxX, b2.maxX) - Math.max(a2.minX, b2.minX) > EPS14 && Math.min(a2.maxY, b2.maxY) - Math.max(a2.minY, b2.minY) > EPS14;
-var rangesOverlap = (minA, maxA, minB, maxB) => Math.min(maxA, maxB) - Math.max(minA, minB) > EPS14;
-var traceCrossesBoundsInterior = (bounds, traceMap) => {
-  for (const trace of Object.values(traceMap)) {
-    const points = trace.tracePath;
-    for (let i2 = 0; i2 < points.length - 1; i2++) {
-      if (segmentCrossesBoundsInterior(points[i2], points[i2 + 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 (sameX2(p1, p2)) {
-    if (p1.x <= interiorBounds.minX + EPS14 || p1.x >= interiorBounds.maxX - EPS14) {
-      return false;
-    }
-    return rangesOverlap(
-      Math.min(p1.y, p2.y),
-      Math.max(p1.y, p2.y),
-      interiorBounds.minY,
-      interiorBounds.maxY
-    );
-  }
-  if (sameY2(p1, p2)) {
-    if (p1.y <= interiorBounds.minY + EPS14 || p1.y >= interiorBounds.maxY - EPS14) {
-      return false;
-    }
-    return rangesOverlap(
-      Math.min(p1.x, p2.x),
-      Math.max(p1.x, p2.x),
-      interiorBounds.minX,
-      interiorBounds.maxX
-    );
-  }
-  return false;
-};
-var tracePathIntersectsBounds = (tracePath, bounds) => {
-  for (let i2 = 0; i2 < tracePath.length - 1; i2++) {
-    if (segmentIntersectsRect2(tracePath[i2], tracePath[i2 + 1], bounds)) {
-      return true;
-    }
-  }
-  return false;
-};
-var getSideDistances = (point6, bounds) => [
-  ["left", Math.abs(point6.x - bounds.minX)],
-  ["right", Math.abs(point6.x - bounds.maxX)],
-  ["bottom", Math.abs(point6.y - bounds.minY)],
-  ["top", Math.abs(point6.y - bounds.maxY)]
-];
-var getConnectorTracePath = (source, target, orientation2) => simplifyOrthogonalPath(
-  isYOrientation(orientation2) ? [source, { x: target.x, y: source.y }, target] : [source, { x: source.x, y: target.y }, target]
-);
-var simplifyOrthogonalPath = (path) => {
-  const deduped = path.filter(
-    (point6, index2) => index2 === 0 || !pointsEqual3(point6, path[index2 - 1])
-  );
-  if (deduped.length < 3) return deduped;
-  const simplified = [deduped[0]];
-  for (let i2 = 1; i2 < deduped.length - 1; i2++) {
-    const prev = simplified[simplified.length - 1];
-    const point6 = deduped[i2];
-    const next = deduped[i2 + 1];
-    if (sameX2(prev, point6) && sameX2(point6, next) || sameY2(prev, point6) && sameY2(point6, next)) {
-      continue;
-    }
-    simplified.push(point6);
-  }
-  simplified.push(deduped[deduped.length - 1]);
-  return simplified;
-};
-var pointsEqual3 = (a2, b2) => sameX2(a2, b2) && sameY2(a2, b2);
-var sameX2 = (a2, b2) => Math.abs(a2.x - b2.x) <= EPS14;
-var sameY2 = (a2, b2) => Math.abs(a2.y - b2.y) <= EPS14;
-var getMaxSearchDistance = (inputProblem) => {
-  const maxChipWidth = Math.max(
-    ...inputProblem.chips.map((chip) => chip.width),
-    1
-  );
-  return maxChipWidth * 3;
-};
 var isPortOnlyLabel = (label) => label.mspConnectionPairIds.length === 0;
 var orderRoutedLabelsBeforeOverlappingPortLabels = ({
   labelIndices,
@@ -96685,7 +96832,7 @@ var orderRoutedLabelsBeforeOverlappingPortLabels = ({
         portOnlyLabel.width,
         portOnlyLabel.height
       );
-      return rectsOverlap2(routedBounds, portOnlyBounds);
+      return rectsOverlap(routedBounds, portOnlyBounds);
     });
     const routedPosition = orderedLabelIndices.indexOf(routedLabelIndex);
     if (blockingPosition === -1 || blockingPosition > routedPosition) continue;
@@ -96738,7 +96885,7 @@ var drawCurrentLabel = (graphics, currentLabel, solved) => {
     width: currentLabel.width,
     height: currentLabel.height,
     fill: "rgba(255, 0, 0, 0.2)",
-    strokeColor: CANDIDATE_REJECTED_COLOR2,
+    strokeColor: CANDIDATE_REJECTED_COLOR,
     label: `available orientation target
 ${currentLabel.netId ?? currentLabel.globalConnNetId}`
   });
@@ -96746,7 +96893,7 @@ ${currentLabel.netId ?? currentLabel.globalConnNetId}`
 var drawCurrentCandidates2 = (graphics, candidates, solved) => {
   if (solved) return;
   for (const candidate of candidates) {
-    const color3 = candidate.selected ? CANDIDATE_SELECTED_COLOR2 : CANDIDATE_REJECTED_COLOR2;
+    const color3 = candidate.selected ? CANDIDATE_SELECTED_COLOR : CANDIDATE_REJECTED_COLOR;
     const distanceLabel = candidate.distance === void 0 ? "" : `
 distance: ${candidate.distance.toFixed(3)}`;
     const outwardDistanceLabel = candidate.outwardDistance === void 0 || candidate.outwardDistance === 0 ? "" : `
@@ -96804,7 +96951,7 @@ var AvailableNetOrientationObstacleIndex = class {
   }
   getTraceSegmentsInBounds(bounds) {
     if (!this.traceSegmentIndex) return [];
-    const searchBounds = getPaddedBounds(bounds, EPS14);
+    const searchBounds = getPaddedBounds(bounds, EPS8);
     return this.traceSegmentIndex.search(
       searchBounds.minX,
       searchBounds.minY,
@@ -96817,7 +96964,7 @@ var AvailableNetOrientationObstacleIndex = class {
     for (let pointIndex = 0; pointIndex < tracePath.length - 1; pointIndex++) {
       const segmentBounds = getPaddedBounds(
         getSegmentBounds(tracePath[pointIndex], tracePath[pointIndex + 1]),
-        EPS14
+        EPS8
       );
       for (const labelIndex of this.getLabelIndicesInBounds(segmentBounds)) {
         labelIndices.add(labelIndex);
@@ -96830,7 +96977,7 @@ var AvailableNetOrientationObstacleIndex = class {
       const start = tracePath[pointIndex];
       const end = tracePath[pointIndex + 1];
       const nearbyChips = this.chipObstacleSpatialIndex.getChipsInBounds(
-        getPaddedBounds(getSegmentBounds(start, end), EPS14)
+        getPaddedBounds(getSegmentBounds(start, end), EPS8)
       );
       for (const chip of nearbyChips) {
         if (segmentCrossesBoundsInterior(start, end, chip.bounds)) return true;
@@ -97088,7 +97235,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
         if (otherIndex === labelIndex) return false;
         if (otherLabel.globalConnNetId === label.globalConnNetId) return false;
         const otherBounds = this.getHorizontalConstraintMismatchBounds(otherLabel);
-        return otherBounds ? rectsOverlap2(bounds2, otherBounds) : false;
+        return otherBounds ? rectsOverlap(bounds2, otherBounds) : false;
       });
       if (overlapsHorizontalConstraintMismatch) return true;
     }
@@ -97097,7 +97244,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
     return this.outputNetLabelPlacements.some((otherLabel, otherIndex) => {
       if (otherIndex === labelIndex) return false;
       if (otherLabel.globalConnNetId === label.globalConnNetId) return false;
-      return rectsOverlap2(
+      return rectsOverlap(
         bounds,
         getRectBounds(otherLabel.center, otherLabel.width, otherLabel.height)
       );
@@ -97134,7 +97281,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
           const bounds = getRectBounds(label.center, label.width, label.height);
           return labelIndices.slice(position + 1).some((otherIndex) => {
             const other = this.outputNetLabelPlacements[otherIndex];
-            return rectsOverlap2(
+            return rectsOverlap(
               bounds,
               getRectBounds(other.center, other.width, other.height)
             );
@@ -97285,7 +97432,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
       labelIndex,
       orientations
     );
-    const rotatedCandidateNeedsLateralBranch = rotatedCandidate !== null && Math.abs(rotatedCandidate.anchorPoint.x - label.anchorPoint.x) > EPS14;
+    const rotatedCandidateNeedsLateralBranch = rotatedCandidate !== null && Math.abs(rotatedCandidate.anchorPoint.x - label.anchorPoint.x) > EPS8;
     if (isDownwardGroundRail && rotatedCandidateNeedsLateralBranch) {
       const downwardRailCandidate = this.findValidCandidateInShiftColumn({
         label,
@@ -97344,7 +97491,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
       index: index2,
       pin: this.pinMap[otherLabel.pinIds[0]]
     })).filter(
-      ({ index: index2, pin: otherPin }) => this.crowdedPortOnlyLabelIndices.has(index2) && otherPin?.chipId === pin.chipId && otherPin.x > pin.x + EPS14
+      ({ index: index2, pin: otherPin }) => this.crowdedPortOnlyLabelIndices.has(index2) && otherPin?.chipId === pin.chipId && otherPin.x > pin.x + EPS8
     ).sort((a2, b2) => a2.pin.x - b2.pin.x)[0]?.pin;
     if (orientation2 === "y-" && nextPinToRight) return null;
     const anchorX = orientation2 === "y-" ? Math.max(
@@ -97377,7 +97524,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
     const centeredAnchorY = hasUpFacingStack ? (lowestUpFacingLabelY + highestUpFacingLabelY) / 2 : stackedAnchorY;
     const anchorYs = orientation2 === "y-" ? [centeredAnchorY, stackedAnchorY] : [stackedAnchorY];
     for (const anchorY of anchorYs) {
-      if (anchorY - label.anchorPoint.y > this.maxSearchDistance + EPS14) {
+      if (anchorY - label.anchorPoint.y > this.maxSearchDistance + EPS8) {
         continue;
       }
       const candidate = this.createCandidate(
@@ -97406,11 +97553,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
       if (trace.globalConnNetId !== label.globalConnNetId) return false;
       const path = trace.tracePath;
       return path.some((point6, pointIndex) => {
-        if (Math.abs(point6.x - label.anchorPoint.x) > EPS14 || Math.abs(point6.y - label.anchorPoint.y) > EPS14) {
+        if (Math.abs(point6.x - label.anchorPoint.x) > EPS8 || Math.abs(point6.y - label.anchorPoint.y) > EPS8) {
           return false;
         }
         return [path[pointIndex - 1], path[pointIndex + 1]].some(
-          (neighbor) => neighbor && Math.abs(neighbor.x - point6.x) <= EPS14 && (neighbor.y - point6.y) * direction.y > EPS14
+          (neighbor) => neighbor && Math.abs(neighbor.x - point6.x) <= EPS8 && (neighbor.y - point6.y) * direction.y > EPS8
         );
       });
     });
@@ -97500,7 +97647,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
         orientation2
       );
       if (outwardDirection2.x === 0 && outwardDirection2.y === 0) continue;
-      for (let distance33 = LABEL_SEARCH_STEP; distance33 <= this.maxSearchDistance + EPS14; distance33 += LABEL_SEARCH_STEP) {
+      for (let distance33 = LABEL_SEARCH_STEP; distance33 <= this.maxSearchDistance + EPS8; distance33 += LABEL_SEARCH_STEP) {
         const anchorPoint = {
           x: connectorSource.x + outwardDirection2.x * distance33,
           y: connectorSource.y + outwardDirection2.y * distance33
@@ -97578,7 +97725,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
     const furthestRowPoints = points.filter(
       (point6) => Math.abs(
         point6.x * direction.x + point6.y * direction.y - furthestAlong
-      ) <= EPS14
+      ) <= EPS8
     );
     const directHostPinIds = new Set(
       [...directHostTraceIds].flatMap(
@@ -97599,7 +97746,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
       preferNearestBendOnOutwardRow: adjacentTraces.some(
         (trace) => furthestRowPoints.some(
           (point6) => trace.tracePath.some(
-            (tracePoint) => Math.abs(tracePoint.x - point6.x) <= EPS14 && Math.abs(tracePoint.y - point6.y) <= EPS14
+            (tracePoint) => Math.abs(tracePoint.x - point6.x) <= EPS8 && Math.abs(tracePoint.y - point6.y) <= EPS8
           )
         )
       )
@@ -97611,7 +97758,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
       for (let i2 = 0; i2 < otherTrace.tracePath.length - 1; i2++) {
         const start = otherTrace.tracePath[i2];
         const end = otherTrace.tracePath[i2 + 1];
-        if (Math.abs(start.x - end.x) <= EPS14 && Math.abs(start.y - end.y) > EPS14) {
+        if (Math.abs(start.x - end.x) <= EPS8 && Math.abs(start.y - end.y) > EPS8) {
           verticalRailXs.add(start.x);
         }
       }
@@ -97619,7 +97766,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
     for (let i2 = 0; i2 < trace.tracePath.length - 1; i2++) {
       const start = trace.tracePath[i2];
       const end = trace.tracePath[i2 + 1];
-      if (Math.abs(start.x - end.x) <= EPS14 && Math.abs(start.y - end.y) > EPS14 && [...verticalRailXs].some((x2) => Math.abs(x2 - start.x) <= EPS14)) {
+      if (Math.abs(start.x - end.x) <= EPS8 && Math.abs(start.y - end.y) > EPS8 && [...verticalRailXs].some((x2) => Math.abs(x2 - start.x) <= EPS8)) {
         return true;
       }
     }
@@ -97638,7 +97785,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
     );
     const maxSearchDistance = this.getSearchDistanceLimit(label, orientation2);
     const maxOutwardDistance = outwardDirection2.x === 0 && outwardDirection2.y === 0 ? 0 : this.maxSearchDistance;
-    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS14; outwardDistance += LABEL_SEARCH_STEP) {
+    for (let outwardDistance = 0; outwardDistance <= maxOutwardDistance + EPS8; outwardDistance += LABEL_SEARCH_STEP) {
       const baseAnchor = {
         x: initialBaseAnchor.x + outwardDirection2.x * outwardDistance,
         y: initialBaseAnchor.y + outwardDirection2.y * outwardDistance
@@ -97714,7 +97861,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
       connectorSource,
       startDistance = LABEL_SEARCH_STEP
     } = params;
-    for (let distance33 = startDistance; distance33 <= maxSearchDistance + EPS14; distance33 += LABEL_SEARCH_STEP) {
+    for (let distance33 = startDistance; distance33 <= maxSearchDistance + EPS8; distance33 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance33,
         y: baseAnchor.y + direction.y * distance33
@@ -97828,14 +97975,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
       for (let pointIndex = 0; pointIndex < hostTrace.tracePath.length - 1; pointIndex++) {
         const start = hostTrace.tracePath[pointIndex];
         const end = hostTrace.tracePath[pointIndex + 1];
-        const segmentIsPerpendicularToLabel = isYOrientation(orientation2) ? Math.abs(start.y - end.y) <= EPS14 : Math.abs(start.x - end.x) <= EPS14;
+        const segmentIsPerpendicularToLabel = isYOrientation(orientation2) ? Math.abs(start.y - end.y) <= EPS8 : Math.abs(start.x - end.x) <= EPS8;
         if (!segmentIsPerpendicularToLabel) continue;
         const source = isYOrientation(orientation2) ? { x: targetAnchor.x, y: start.y } : { x: start.x, y: targetAnchor.y };
         if (!tracePathContainsPoint([start, end], label.anchorPoint) || !tracePathContainsPoint([start, end], source)) {
           continue;
         }
         const targetDistanceAlongOrientation = (targetAnchor.x - source.x) * orientationDirection.x + (targetAnchor.y - source.y) * orientationDirection.y;
-        if (targetDistanceAlongOrientation >= -EPS14) {
+        if (targetDistanceAlongOrientation >= -EPS8) {
           projectedSources.push(source);
         }
       }
@@ -98094,9 +98241,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
       const { anchorPoint, orientation: orientation2 } = candidate;
       const chipBounds = chip.bounds;
       if (isYOrientation(orientation2)) {
-        return anchorPoint.x < chipBounds.minX - EPS14 || anchorPoint.x > chipBounds.maxX + EPS14;
+        return anchorPoint.x < chipBounds.minX - EPS8 || anchorPoint.x > chipBounds.maxX + EPS8;
       }
-      return anchorPoint.y < chipBounds.minY - EPS14 || anchorPoint.y > chipBounds.maxY + EPS14;
+      return anchorPoint.y < chipBounds.minY - EPS8 || anchorPoint.y > chipBounds.maxY + EPS8;
     });
   }
   staysOutsideConnectedPinRow(params) {
@@ -98104,9 +98251,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
     const pin = this.pinMap[label.pinIds[0]];
     if (!pin || !isYOrientation(candidate.orientation)) return false;
     if (candidate.anchorPoint.x < pin.x) {
-      return bounds.maxX <= pin.x + CONNECTED_PIN_ROW_OVERLAP_TOLERANCE + EPS14;
+      return bounds.maxX <= pin.x + CONNECTED_PIN_ROW_OVERLAP_TOLERANCE + EPS8;
     }
-    return bounds.minX >= pin.x - CONNECTED_PIN_ROW_OVERLAP_TOLERANCE - EPS14;
+    return bounds.minX >= pin.x - CONNECTED_PIN_ROW_OVERLAP_TOLERANCE - EPS8;
   }
   getBoundsStatus(candidateBoundsCheck) {
     const { bounds, labelIndex, label, ignoreChipCollisions } = candidateBoundsCheck;
@@ -98187,14 +98334,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
       candidate.width,
       candidate.height
     );
-    if (labelBounds.minY < chip.bounds.minY - EPS14 || labelBounds.maxY > chip.bounds.maxY + EPS14) {
+    if (labelBounds.minY < chip.bounds.minY - EPS8 || labelBounds.maxY > chip.bounds.maxY + EPS8) {
       return false;
     }
-    if (candidate.anchorPoint.x >= chip.bounds.minX - EPS14 && candidate.anchorPoint.x <= chip.bounds.maxX + EPS14) {
+    if (candidate.anchorPoint.x >= chip.bounds.minX - EPS8 && candidate.anchorPoint.x <= chip.bounds.maxX + EPS8) {
       return false;
     }
     return chip.pins.every(
-      (pin) => label.pinIds.includes(pin.pinId) || pin.y <= labelBounds.minY + EPS14 || pin.y >= labelBounds.maxY - EPS14
+      (pin) => label.pinIds.includes(pin.pinId) || pin.y <= labelBounds.minY + EPS8 || pin.y >= labelBounds.maxY - EPS8
     );
   }
   getTextBlockedMultiPinRailTraces(label, orientation2) {
@@ -98221,20 +98368,20 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
     const pins = [...connectedPinIds].map((pinId) => this.pinMap[pinId]);
     const direction = dir(orientation2);
     const pinX = pins[0].x;
-    if (pins.some((pin) => Math.abs(pin.x - pinX) > EPS14)) return null;
-    const sidePins = this.inputProblem.chips.find((chip) => chip.chipId === componentId).pins.filter((pin) => Math.abs(pin.x - pinX) <= EPS14);
+    if (pins.some((pin) => Math.abs(pin.x - pinX) > EPS8)) return null;
+    const sidePins = this.inputProblem.chips.find((chip) => chip.chipId === componentId).pins.filter((pin) => Math.abs(pin.x - pinX) <= EPS8);
     const minY = Math.min(...pins.map((pin) => pin.y));
     const maxY = Math.max(...pins.map((pin) => pin.y));
     if (sidePins.some(
-      (pin) => pin.y >= minY - EPS14 && pin.y <= maxY + EPS14 && !connectedPinIds.has(pin.pinId)
-    ) || orientation2 === "y-" && minY > Math.min(...sidePins.map((pin) => pin.y)) + EPS14 || orientation2 === "y+" && maxY < Math.max(...sidePins.map((pin) => pin.y)) - EPS14) {
+      (pin) => pin.y >= minY - EPS8 && pin.y <= maxY + EPS8 && !connectedPinIds.has(pin.pinId)
+    ) || orientation2 === "y-" && minY > Math.min(...sidePins.map((pin) => pin.y)) + EPS8 || orientation2 === "y+" && maxY < Math.max(...sidePins.map((pin) => pin.y)) - EPS8) {
       return null;
     }
     const outerPinPosition = Math.max(
       ...pins.map((pin) => pin.x * direction.x + pin.y * direction.y)
     );
     const blockedByText = (this.inputProblem.textBoxes ?? []).some(
-      (textBox) => textBox.chipId === componentId && textBox.center.x * direction.x + textBox.center.y * direction.y > outerPinPosition + EPS14
+      (textBox) => textBox.chipId === componentId && textBox.center.x * direction.x + textBox.center.y * direction.y > outerPinPosition + EPS8
     );
     return blockedByText ? [...connectedTraces] : null;
   }
@@ -98250,7 +98397,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
       ...new Set(
         localTraces.flatMap((trace) => trace.tracePath.map((point6) => point6.x))
       )
-    ].filter((x2) => Math.abs(x2 - pinX) > EPS14).sort((a2, b2) => Math.abs(a2 - pinX) - Math.abs(b2 - pinX));
+    ].filter((x2) => Math.abs(x2 - pinX) > EPS8).sort((a2, b2) => Math.abs(a2 - pinX) - Math.abs(b2 - pinX));
     for (const x2 of railXs) {
       const connectorSource = { x: x2, y: connectorY };
       if (!Object.values(this.traceMap).some(
@@ -98313,8 +98460,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
     if (!chip) return null;
     const sides = new Set(
       pins.map((pin) => {
-        if (Math.abs(pin.x - chip.bounds.minX) <= EPS14) return "left";
-        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS14) return "right";
+        if (Math.abs(pin.x - chip.bounds.minX) <= EPS8) return "left";
+        if (Math.abs(pin.x - chip.bounds.maxX) <= EPS8) return "right";
         return null;
       })
     );
@@ -98351,7 +98498,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
       return null;
     }
     const renderedWidth = this.getNetConnectionForLabel(label)?.netLabelHeight;
-    if (renderedWidth === void 0 || renderedWidth <= label.width + label.height + EPS14) {
+    if (renderedWidth === void 0 || renderedWidth <= label.width + label.height + EPS8) {
       return null;
     }
     const placementBaseCenter = getCenterFromAnchor(
@@ -98420,22 +98567,22 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
         otherBounds.minX -= LABEL_SEARCH_STEP;
         otherBounds.maxX += LABEL_SEARCH_STEP;
       }
-      if (rectsOverlap2(bounds, otherBounds)) return true;
+      if (rectsOverlap(bounds, otherBounds)) return true;
     }
     return false;
   }
   sharesChipBoundary(bounds) {
     const boundarySearchBounds = {
-      minX: bounds.minX - WICK_CLEARANCE - EPS14,
-      minY: bounds.minY - WICK_CLEARANCE - EPS14,
-      maxX: bounds.maxX + WICK_CLEARANCE + EPS14,
-      maxY: bounds.maxY + WICK_CLEARANCE + EPS14
+      minX: bounds.minX - WICK_CLEARANCE - EPS8,
+      minY: bounds.minY - WICK_CLEARANCE - EPS8,
+      maxX: bounds.maxX + WICK_CLEARANCE + EPS8,
+      maxY: bounds.maxY + WICK_CLEARANCE + EPS8
     };
     const nearbyChips = this.chipObstacleSpatialIndex.getChipsInBounds(boundarySearchBounds);
     for (const chip of nearbyChips) {
       const chipBounds = chip.bounds;
-      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS14 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS14;
-      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS14 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS14;
+      const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS8 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS8;
+      const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS8 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS8;
       if (adjacentToVerticalSide && rangesOverlap(
         bounds.minY,
         bounds.maxY,
@@ -98497,7 +98644,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
     let nearestDistance = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const bounds = chip.bounds;
-      if (point6.x < bounds.minX - EPS14 || point6.x > bounds.maxX + EPS14 || point6.y < bounds.minY - EPS14 || point6.y > bounds.maxY + EPS14) {
+      if (point6.x < bounds.minX - EPS8 || point6.x > bounds.maxX + EPS8 || point6.y < bounds.minY - EPS8 || point6.y > bounds.maxY + EPS8) {
         continue;
       }
       for (const [side, distance33] of getSideDistances(point6, bounds)) {
@@ -98514,8 +98661,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver10 {
     let nearestDistanceSq = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
       const bounds = chip.bounds;
-      const dx2 = point6.x < bounds.minX - EPS14 ? bounds.minX - point6.x : point6.x > bounds.maxX + EPS14 ? point6.x - bounds.maxX : 0;
-      const dy2 = point6.y < bounds.minY - EPS14 ? bounds.minY - point6.y : point6.y > bounds.maxY + EPS14 ? point6.y - bounds.maxY : 0;
+      const dx2 = point6.x < bounds.minX - EPS8 ? bounds.minX - point6.x : point6.x > bounds.maxX + EPS8 ? point6.x - bounds.maxX : 0;
+      const dy2 = point6.y < bounds.minY - EPS8 ? bounds.minY - point6.y : point6.y > bounds.maxY + EPS8 ? point6.y - bounds.maxY : 0;
       if (dx2 === 0 && dy2 === 0) continue;
       const distanceSq = dx2 ** 2 + dy2 ** 2;
       if (distanceSq >= nearestDistanceSq) continue;
@@ -98667,7 +98814,7 @@ var getRemovableRailLabelConnectors = ({
     const endpoints = [connector.tracePath[0], connector.tracePath.at(-1)];
     if (!endpoints[0] || !endpoints[1]) continue;
     const labelEnd = endpoints.findIndex(
-      (point6) => getDistance2(point6, label.anchorPoint) <= EPS8
+      (point6) => getDistance2(point6, label.anchorPoint) <= EPS9
     );
     if (labelEnd === -1) continue;
     const source = endpoints[1 - labelEnd];
@@ -98714,11 +98861,11 @@ var getStraightPortConnectorCandidate = ({
       continue;
     const path = simplifyPath(connector.tracePath);
     if (path.length < 4) continue;
-    if (getDistance2(path.at(-1), pin) <= EPS8) path.reverse();
-    if (getDistance2(path[0], pin) > EPS8 || getDistance2(path.at(-1), label.anchorPoint) > EPS8 || Math.abs(path[1].y - pin.y) > EPS8)
+    if (getDistance2(path.at(-1), pin) <= EPS9) path.reverse();
+    if (getDistance2(path[0], pin) > EPS9 || getDistance2(path.at(-1), label.anchorPoint) > EPS9 || Math.abs(path[1].y - pin.y) > EPS9)
       continue;
     const anchorPoint = { x: label.anchorPoint.x, y: pin.y };
-    if ((anchorPoint.x - pin.x) * (path[1].x - pin.x) <= EPS8) continue;
+    if ((anchorPoint.x - pin.x) * (path[1].x - pin.x) <= EPS9) continue;
     const reroutedTracePath = [path[0], anchorPoint];
     const protectedPoints = [
       ...getSameNetJunctions(connector, traces),
@@ -98756,13 +98903,13 @@ var getSimplifiedRailConnectorCandidates = (params) => {
     if (countTurns(path) < 2) continue;
     for (const source of getTraceCorners(simplifyPath(rail.tracePath))) {
       const anchor = label.anchorPoint;
-      if ((anchor.y - source.y) * direction < -EPS8) continue;
+      if ((anchor.y - source.y) * direction < -EPS9) continue;
       const reroutedTracePath = simplifyPath([
         source,
         { x: anchor.x, y: source.y },
         anchor
       ]);
-      if (countTurns(reroutedTracePath) >= countTurns(path) || getPathLength4(reroutedTracePath) > getPathLength4(path) + EPS8)
+      if (countTurns(reroutedTracePath) >= countTurns(path) || getPathLength4(reroutedTracePath) > getPathLength4(path) + EPS9)
         continue;
       if (traces.some(
         (other) => other.globalConnNetId !== connector.globalConnNetId && countPathIntersections(reroutedTracePath, other.tracePath) > countPathIntersections(path, other.tracePath)
@@ -98996,13 +99143,13 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver10 {
   }
   intersectsAnyChip(bounds) {
     return this.inputProblem.chips.some(
-      (chip) => rectsOverlap(bounds, getRectBounds(chip.center, chip.width, chip.height))
+      (chip) => rectsOverlap2(bounds, getRectBounds(chip.center, chip.width, chip.height))
     );
   }
   intersectsAnyOtherNetLabel(bounds, labelIndex) {
     return this.outputNetLabelPlacements.some((label, index2) => {
       if (index2 === labelIndex) return false;
-      return rectsOverlap(
+      return rectsOverlap2(
         bounds,
         getRectBounds(label.center, label.width, label.height)
       );
@@ -99023,7 +99170,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver10 {
       for (const anchorPoint of getTraceCorners(path)) {
         const cornerIndex = path.indexOf(anchorPoint);
         const anchorAlignedToPin = pins.some(
-          (pin) => Math.abs(pin.x - anchorPoint.x) <= EPS8
+          (pin) => Math.abs(pin.x - anchorPoint.x) <= EPS9
         );
         const pinAligned = anchorAlignedToPin || allowRailAlignedFallback && this.isPinAlignedCorner(path, cornerIndex);
         if (!pinAligned) continue;
@@ -99116,7 +99263,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver10 {
       return [];
     }
     const pins = this.inputProblem.chips.flatMap((chip) => chip.pins).filter((pin) => label.pinIds.includes(pin.pinId));
-    if (pins.length !== 2 || pins[0]._facingDirection !== pins[1]._facingDirection || pins[0]._facingDirection !== "x+" && pins[0]._facingDirection !== "x-" || Math.abs(pins[0].y - pins[1].y) > EPS8) {
+    if (pins.length !== 2 || pins[0]._facingDirection !== pins[1]._facingDirection || pins[0]._facingDirection !== "x+" && pins[0]._facingDirection !== "x-" || Math.abs(pins[0].y - pins[1].y) > EPS9) {
       return [];
     }
     const configuredOrientations = this.inputProblem.availableNetLabelOrientations[label.netId];
@@ -99141,7 +99288,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver10 {
       getMaxSearchDistance(this.inputProblem),
       label.height * 2
     );
-    for (let distance33 = WICK_CLEARANCE + LABEL_SEARCH_STEP; distance33 <= maxSearchDistance + EPS8; distance33 += LABEL_SEARCH_STEP) {
+    for (let distance33 = WICK_CLEARANCE + LABEL_SEARCH_STEP; distance33 <= maxSearchDistance + EPS9; distance33 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: sourcePoint.x,
         y: sourcePoint.y + direction * distance33
@@ -99193,12 +99340,12 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver10 {
     return traceCrossesBoundsInterior(bounds, this.traceMap);
   }
   pointsEqual(a2, b2) {
-    return Math.abs(a2.x - b2.x) <= EPS8 && Math.abs(a2.y - b2.y) <= EPS8;
+    return Math.abs(a2.x - b2.x) <= EPS9 && Math.abs(a2.y - b2.y) <= EPS9;
   }
   getVerticalSegmentPointIndices(path, cornerIndex) {
     const corner = path[cornerIndex];
-    const previousIsVertical = Math.abs(path[cornerIndex - 1].x - corner.x) <= EPS8;
-    const nextIsVertical = Math.abs(path[cornerIndex + 1].x - corner.x) <= EPS8;
+    const previousIsVertical = Math.abs(path[cornerIndex - 1].x - corner.x) <= EPS9;
+    const nextIsVertical = Math.abs(path[cornerIndex + 1].x - corner.x) <= EPS9;
     if (previousIsVertical === nextIsVertical) return null;
     const indices = previousIsVertical ? [cornerIndex - 1, cornerIndex] : [cornerIndex, cornerIndex + 1];
     return indices;
@@ -99235,7 +99382,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver10 {
       label.height
     );
     const labelBounds = getRectBounds(center, label.width, label.height);
-    const collidingChipBounds = this.inputProblem.chips.map((chip) => getRectBounds(chip.center, chip.width, chip.height)).filter((chipBounds) => rectsOverlap(labelBounds, chipBounds));
+    const collidingChipBounds = this.inputProblem.chips.map((chip) => getRectBounds(chip.center, chip.width, chip.height)).filter((chipBounds) => rectsOverlap2(labelBounds, chipBounds));
     const shiftedCoordinates = /* @__PURE__ */ new Set();
     for (const chipBounds of collidingChipBounds) {
       shiftedCoordinates.add(chipBounds.minX - label.width / 2);
@@ -99248,7 +99395,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver10 {
         const end = otherTrace.tracePath[i2 + 1];
         if (!segmentCrossesBoundsInterior(start, end, labelBounds)) continue;
         const halfLabelWidth = label.width / 2;
-        if (Math.abs(start.x - end.x) <= EPS8) {
+        if (Math.abs(start.x - end.x) <= EPS9) {
           shiftedCoordinates.add(
             start.x - halfLabelWidth - LABEL_TRACE_CLEARANCE3
           );
@@ -99266,7 +99413,7 @@ var RailNetLabelCornerPlacementSolver = class extends BaseSolver10 {
       }
     }
     return [...shiftedCoordinates].flatMap((x2) => {
-      if (Math.abs(x2 - corner.x) <= EPS8) return [];
+      if (Math.abs(x2 - corner.x) <= EPS9) return [];
       const reroutedTracePath = simplifyPath(
         path.map(
           (point6, pointIndex) => verticalPointIndices.includes(pointIndex) ? { ...point6, x: x2 } : point6
@@ -102705,7 +102852,7 @@ var candidateIsClear = ({
       }
     }
     for (const obstacle of obstacles) {
-      if (rectsOverlap(candidateBounds, obstacle) && !rectsOverlap(originalBounds, obstacle)) {
+      if (rectsOverlap2(candidateBounds, obstacle) && !rectsOverlap2(originalBounds, obstacle)) {
         return false;
       }
     }
@@ -102723,7 +102870,7 @@ var candidateIsClear = ({
         candidateOther.width,
         candidateOther.height
       );
-      if (rectsOverlap(candidateBounds, candidateOtherBounds) && !rectsOverlap(originalBounds, originalOtherBounds)) {
+      if (rectsOverlap2(candidateBounds, candidateOtherBounds) && !rectsOverlap2(originalBounds, originalOtherBounds)) {
         return false;
       }
     }
@@ -103036,100 +103183,6 @@ var alignSameNetJunctions = ({
     collapsedCycleCount: cycleCollapse.collapsedCycleCount
   };
 };
-var placeGroundRailLabelsAtOuterEnd = ({
-  inputProblem,
-  traces,
-  netLabelPlacements
-}) => {
-  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
-  const groundNetId = netConnMap.getNetConnectedToId("GND");
-  if (!groundNetId) return netLabelPlacements;
-  const chipMap = new Map(inputProblem.chips.map((chip) => [chip.chipId, chip]));
-  const traceMap = Object.fromEntries(
-    traces.map((trace) => [trace.mspPairId, trace])
-  );
-  const obstacles = getObstacleRects(inputProblem);
-  const output = [...netLabelPlacements];
-  for (const rail of traces) {
-    if (rail.globalConnNetId !== groundNetId) continue;
-    const [a2, b2] = rail.pins;
-    if (a2.chipId === b2.chipId || !nearlyEqual(a2.y, b2.y) || ![a2, b2].every(
-      (pin) => pin._facingDirection === "y-" && chipMap.get(pin.chipId)?.pins.length === 2
-    ))
-      continue;
-    const path = simplifyPath(rail.tracePath);
-    if (path.length !== 4 || !isVertical2(path[0], path[1]) || !isHorizontal22(path[1], path[2]) || !isVertical2(path[2], path[3]) || path[1].y >= a2.y)
-      continue;
-    for (const feed of traces) {
-      if (feed.globalConnNetId !== groundNetId) continue;
-      const shared = feed.pins.find((pin) => rail.pinIds.includes(pin.pinId));
-      const icPin = feed.pins.find(
-        (pin) => !rail.pinIds.includes(pin.pinId) && (chipMap.get(pin.chipId)?.pins.length ?? 0) > 2
-      );
-      if (!shared || !icPin || !nearlyEqual(icPin.y, path[1].y)) continue;
-      const outer = shared.pinId === a2.pinId ? b2 : a2;
-      if (Math.abs(outer.x - icPin.x) <= Math.abs(shared.x - icPin.x)) continue;
-      const anchorPoint = { x: outer.x, y: path[1].y };
-      if (!tracePathContainsPoint(rail.tracePath, anchorPoint)) continue;
-      for (let index2 = 0; index2 < output.length; index2++) {
-        const label = output[index2];
-        if (label.globalConnNetId !== groundNetId || label.orientation !== "y-" || !label.mspConnectionPairIds.some(
-          (id) => id === feed.mspPairId || id === rail.mspPairId
-        ) || !tracePathContainsPoint(feed.tracePath, label.anchorPoint) && !tracePathContainsPoint(rail.tracePath, label.anchorPoint))
-          continue;
-        const center = getCenterFromAnchor(
-          anchorPoint,
-          label.orientation,
-          label.width,
-          label.height
-        );
-        const bounds = getRectBounds(center, label.width, label.height);
-        if (obstacles.some((obstacle) => rectsOverlap(bounds, obstacle)) || traceCrossesBoundsInterior(bounds, traceMap) || output.some(
-          (other, otherIndex) => otherIndex !== index2 && rectsOverlap(
-            bounds,
-            getRectBounds(other.center, other.width, other.height)
-          )
-        ))
-          continue;
-        output[index2] = {
-          ...label,
-          anchorPoint,
-          center,
-          mspConnectionPairIds: [rail.mspPairId],
-          pinIds: [...rail.pinIds]
-        };
-      }
-    }
-  }
-  for (let index2 = 0; index2 < output.length; index2++) {
-    const label = output[index2];
-    if (label.orientation !== "y-") continue;
-    const connection = inputProblem.netConnections.find(
-      (candidate) => candidate.isGround && candidate.netId === label.netId && candidate.pinIds.length > 2
-    );
-    if (!connection) continue;
-    const anchorPoint = traces.filter((trace) => trace.globalConnNetId === label.globalConnNetId).flatMap((trace) => trace.tracePath).filter(
-      (point6) => nearlyEqual(point6.x, label.anchorPoint.x) && point6.y < label.anchorPoint.y
-    ).sort((a2, b2) => a2.y - b2.y)[0];
-    if (!anchorPoint) continue;
-    const center = getCenterFromAnchor(
-      anchorPoint,
-      label.orientation,
-      label.width,
-      label.height
-    );
-    const bounds = getRectBounds(center, label.width, label.height);
-    if (obstacles.some((obstacle) => rectsOverlap(bounds, obstacle)) || traceCrossesBoundsInterior(bounds, traceMap) || output.some(
-      (other, otherIndex) => otherIndex !== index2 && rectsOverlap(
-        bounds,
-        getRectBounds(other.center, other.width, other.height)
-      )
-    ))
-      continue;
-    output[index2] = { ...label, anchorPoint, center };
-  }
-  return output;
-};
 var MAX_LOCAL_RAIL_SHIFT = 0.5;
 var MIN_ESCAPE_LENGTH = 1;
 var shortenSameSideRailToLabelAnchor = ({
@@ -118287,7 +118340,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.2117",
+  version: "0.0.2118",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -118348,7 +118401,7 @@ var package_default = {
     "@tscircuit/ngspice-spice-engine": "^0.0.20",
     "@tscircuit/props": "^0.0.697",
     "@tscircuit/schematic-match-adapt": "^0.0.18",
-    "@tscircuit/schematic-trace-solver": "https://jscdn.tscircuit.com/@tscircuit/schematic-trace-solver/0.0.229.tgz",
+    "@tscircuit/schematic-trace-solver": "https://jscdn.tscircuit.com/@tscircuit/schematic-trace-solver/0.0.230.tgz",
     "@tscircuit/solver-utils": "^0.0.16",
     "@tscircuit/soup-util": "^0.0.41",
     "@tscircuit/via-stitch-solver": "github:tscircuit/via-stitch-solver#64f2ac7781b795bdc0d74ba411988e60767fa653",