@tscircuit/rectdiff 0.0.26 → 0.0.28

package/dist/index.js

@@ -4,6 +4,388 @@ import {
   definePipelineStep as definePipelineStep3
 } from "@tscircuit/solver-utils";
 
+// lib/solvers/AdjacentLayerContainmentMergeSolver/AdjacentLayerContainmentMergeSolver.ts
+import { BaseSolver } from "@tscircuit/solver-utils";
+
+// lib/utils/getColorForZLayer.ts
+var getColorForZLayer = (zLayers) => {
+  const minZ = Math.min(...zLayers);
+  const colors = [
+    { fill: "#dbeafe", stroke: "#3b82f6" },
+    { fill: "#fef3c7", stroke: "#f59e0b" },
+    { fill: "#d1fae5", stroke: "#10b981" },
+    { fill: "#e9d5ff", stroke: "#a855f7" },
+    { fill: "#fed7aa", stroke: "#f97316" },
+    { fill: "#fecaca", stroke: "#ef4444" }
+  ];
+  return colors[minZ % colors.length];
+};
+
+// lib/utils/rectdiff-geometry.ts
+var EPS = 1e-9;
+var clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+var gt = (a, b) => a > b + EPS;
+var gte = (a, b) => a > b - EPS;
+var lt = (a, b) => a < b - EPS;
+var lte = (a, b) => a < b + EPS;
+function overlaps(a, b) {
+  return !(a.x + a.width <= b.x + EPS || b.x + b.width <= a.x + EPS || a.y + a.height <= b.y + EPS || b.y + b.height <= a.y + EPS);
+}
+function containsPoint(r, p) {
+  return p.x >= r.x - EPS && p.x <= r.x + r.width + EPS && p.y >= r.y - EPS && p.y <= r.y + r.height + EPS;
+}
+function distancePointToRectEdges(p, r) {
+  const minX = r.x;
+  const maxX = r.x + r.width;
+  const minY = r.y;
+  const maxY = r.y + r.height;
+  if (p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY) {
+    return Math.min(p.x - minX, maxX - p.x, p.y - minY, maxY - p.y);
+  }
+  const dx = p.x < minX ? minX - p.x : p.x > maxX ? p.x - maxX : 0;
+  const dy = p.y < minY ? minY - p.y : p.y > maxY ? p.y - maxY : 0;
+  if (dx === 0) return dy;
+  if (dy === 0) return dx;
+  return Math.hypot(dx, dy);
+}
+function intersect1D(r1, r2) {
+  const lo = Math.max(r1[0], r2[0]);
+  const hi = Math.min(r1[1], r2[1]);
+  return hi > lo + EPS ? [lo, hi] : null;
+}
+function subtractRect2D(A, B) {
+  if (!overlaps(A, B)) return [A];
+  const Xi = intersect1D([A.x, A.x + A.width], [B.x, B.x + B.width]);
+  const Yi = intersect1D([A.y, A.y + A.height], [B.y, B.y + B.height]);
+  if (!Xi || !Yi) return [A];
+  const [X0, X1] = Xi;
+  const [Y0, Y1] = Yi;
+  const out = [];
+  if (X0 > A.x + EPS) {
+    out.push({ x: A.x, y: A.y, width: X0 - A.x, height: A.height });
+  }
+  if (A.x + A.width > X1 + EPS) {
+    out.push({ x: X1, y: A.y, width: A.x + A.width - X1, height: A.height });
+  }
+  const midW = Math.max(0, X1 - X0);
+  if (midW > EPS && Y0 > A.y + EPS) {
+    out.push({ x: X0, y: A.y, width: midW, height: Y0 - A.y });
+  }
+  if (midW > EPS && A.y + A.height > Y1 + EPS) {
+    out.push({ x: X0, y: Y1, width: midW, height: A.y + A.height - Y1 });
+  }
+  return out.filter((r) => r.width > EPS && r.height > EPS);
+}
+
+// lib/solvers/AdjacentLayerContainmentMergeSolver/AdjacentLayerContainmentMergeSolver.ts
+var DEFAULT_MIN_FRAGMENT_AREA = 0.2 ** 2;
+var nodeToRect = (node) => ({
+  x: node.center.x - node.width / 2,
+  y: node.center.y - node.height / 2,
+  width: node.width,
+  height: node.height
+});
+var rectArea = (rect) => rect.width * rect.height;
+var cloneNode = (node) => ({
+  ...node,
+  center: { ...node.center },
+  availableZ: [...node.availableZ]
+});
+var cloneNodeWithRect = (node, rect, capacityMeshNodeId) => ({
+  ...node,
+  capacityMeshNodeId,
+  center: {
+    x: rect.x + rect.width / 2,
+    y: rect.y + rect.height / 2
+  },
+  width: rect.width,
+  height: rect.height,
+  availableZ: [...node.availableZ],
+  layer: `z${node.availableZ.join(",")}`
+});
+var clonePromotedNodeWithRect = (node, rect, capacityMeshNodeId, availableZ) => ({
+  ...node,
+  capacityMeshNodeId,
+  center: {
+    x: rect.x + rect.width / 2,
+    y: rect.y + rect.height / 2
+  },
+  width: rect.width,
+  height: rect.height,
+  availableZ: [...availableZ],
+  layer: `z${availableZ.join(",")}`
+});
+var isFreeNode = (node) => !node._containsObstacle && !node._containsTarget;
+var isSingletonNodeOnLayer = (node, z) => node.availableZ.length === 1 && node.availableZ[0] === z;
+var sameRect = (a, b) => Math.abs(a.x - b.x) <= EPS && Math.abs(a.y - b.y) <= EPS && Math.abs(a.width - b.width) <= EPS && Math.abs(a.height - b.height) <= EPS;
+var subtractRects = (target, cutters) => {
+  let remaining = [target];
+  for (const cutter of cutters) {
+    if (remaining.length === 0) return remaining;
+    const nextRemaining = [];
+    for (const piece of remaining) {
+      nextRemaining.push(...subtractRect2D(piece, cutter));
+    }
+    remaining = nextRemaining;
+  }
+  return remaining;
+};
+var isFullyCoveredByRects = (target, coveringRects) => {
+  return subtractRects(target, coveringRects).length === 0;
+};
+var sortAndDedupeCuts = (values) => {
+  const sorted = [...values].sort((a, b) => a - b);
+  const out = [];
+  for (const value of sorted) {
+    const last = out[out.length - 1];
+    if (last == null || Math.abs(last - value) > EPS) {
+      out.push(value);
+    }
+  }
+  return out;
+};
+var partitionRectByRects = (target, supportRects) => {
+  const xCuts = [target.x, target.x + target.width];
+  const yCuts = [target.y, target.y + target.height];
+  const targetMaxX = target.x + target.width;
+  const targetMaxY = target.y + target.height;
+  for (const rect of supportRects) {
+    const x0 = Math.max(target.x, rect.x);
+    const x1 = Math.min(targetMaxX, rect.x + rect.width);
+    const y0 = Math.max(target.y, rect.y);
+    const y1 = Math.min(targetMaxY, rect.y + rect.height);
+    if (x1 <= x0 + EPS || y1 <= y0 + EPS) continue;
+    xCuts.push(x0, x1);
+    yCuts.push(y0, y1);
+  }
+  const xs = sortAndDedupeCuts(xCuts);
+  const ys = sortAndDedupeCuts(yCuts);
+  const cells = [];
+  for (let xi = 0; xi < xs.length - 1; xi++) {
+    const x0 = xs[xi];
+    const x1 = xs[xi + 1];
+    if (x1 <= x0 + EPS) continue;
+    for (let yi = 0; yi < ys.length - 1; yi++) {
+      const y0 = ys[yi];
+      const y1 = ys[yi + 1];
+      if (y1 <= y0 + EPS) continue;
+      cells.push({
+        x: x0,
+        y: y0,
+        width: x1 - x0,
+        height: y1 - y0
+      });
+    }
+  }
+  return cells;
+};
+var canMergeHorizontally = (a, b) => Math.abs(a.y - b.y) <= EPS && Math.abs(a.height - b.height) <= EPS && Math.abs(a.x + a.width - b.x) <= EPS;
+var canMergeVertically = (a, b) => Math.abs(a.x - b.x) <= EPS && Math.abs(a.width - b.width) <= EPS && Math.abs(a.y + a.height - b.y) <= EPS;
+var mergeTouchingRects = (rects) => {
+  const out = rects.map((rect) => ({ ...rect }));
+  let changed = true;
+  while (changed) {
+    changed = false;
+    outer: for (let i = 0; i < out.length; i++) {
+      for (let j = i + 1; j < out.length; j++) {
+        const a = out[i];
+        const b = out[j];
+        if (canMergeHorizontally(a, b) || canMergeHorizontally(b, a)) {
+          const merged = {
+            x: Math.min(a.x, b.x),
+            y: a.y,
+            width: a.width + b.width,
+            height: a.height
+          };
+          out.splice(j, 1);
+          out.splice(i, 1, merged);
+          changed = true;
+          break outer;
+        }
+        if (canMergeVertically(a, b) || canMergeVertically(b, a)) {
+          const merged = {
+            x: a.x,
+            y: Math.min(a.y, b.y),
+            width: a.width,
+            height: a.height + b.height
+          };
+          out.splice(j, 1);
+          out.splice(i, 1, merged);
+          changed = true;
+          break outer;
+        }
+      }
+    }
+  }
+  return out;
+};
+var isPromotableRect = (params) => {
+  const { rect, viaMinSize, minFragmentArea } = params;
+  return rect.width > EPS && rect.height > EPS && rectArea(rect) + EPS >= minFragmentArea && rect.width + EPS >= viaMinSize && rect.height + EPS >= viaMinSize;
+};
+var isResidualRect = (rect, minFragmentArea) => rect.width > EPS && rect.height > EPS && rectArea(rect) + EPS >= minFragmentArea;
+var computePromotablePieces = (params) => {
+  const { target, supportRects, viaMinSize, minFragmentArea } = params;
+  const overlappingSupports = supportRects.filter(
+    (rect) => overlaps(rect, target)
+  );
+  if (overlappingSupports.length === 0) return [];
+  if (isFullyCoveredByRects(target, overlappingSupports) && isPromotableRect({ rect: target, viaMinSize, minFragmentArea })) {
+    return [target];
+  }
+  const partitioned = partitionRectByRects(target, overlappingSupports);
+  const coveredPieces = partitioned.filter(
+    (piece) => isFullyCoveredByRects(piece, overlappingSupports)
+  );
+  if (coveredPieces.length === 0) return [];
+  const mergedCoveredPieces = mergeTouchingRects(coveredPieces);
+  return mergedCoveredPieces.filter(
+    (piece) => isFullyCoveredByRects(piece, overlappingSupports) && isPromotableRect({ rect: piece, viaMinSize, minFragmentArea })
+  );
+};
+var AdjacentLayerContainmentMergeSolver = class extends BaseSolver {
+  constructor(input) {
+    super();
+    this.input = input;
+  }
+  input;
+  outputNodes = [];
+  promotedNodeIds = /* @__PURE__ */ new Set();
+  residualNodeIds = /* @__PURE__ */ new Set();
+  _setup() {
+    this.outputNodes = this.input.meshNodes.map(cloneNode);
+    this.promotedNodeIds.clear();
+    this.residualNodeIds.clear();
+  }
+  _step() {
+    this.outputNodes = this.processAdjacentLayerContainmentMerges();
+    this.solved = true;
+  }
+  processAdjacentLayerContainmentMerges() {
+    const srj = this.input.simpleRouteJson;
+    const layerCount = Math.max(1, srj.layerCount || 1);
+    if (layerCount < 2) {
+      return this.input.meshNodes.map(cloneNode);
+    }
+    const viaMinSize = Math.max(srj.minViaDiameter ?? 0, srj.minTraceWidth || 0);
+    const minFragmentArea = Math.max(
+      EPS,
+      this.input.minFragmentArea ?? DEFAULT_MIN_FRAGMENT_AREA
+    );
+    let workingNodes = this.input.meshNodes.map(cloneNode);
+    let nextResidualId = 0;
+    let nextPromotedId = 0;
+    for (let lowerZ = 0; lowerZ < layerCount - 1; lowerZ++) {
+      const upperZ = lowerZ + 1;
+      const mutableNodes = workingNodes.filter(
+        (node) => isFreeNode(node) && (isSingletonNodeOnLayer(node, lowerZ) || isSingletonNodeOnLayer(node, upperZ))
+      );
+      if (mutableNodes.length === 0) continue;
+      const immutableNodes = workingNodes.filter(
+        (node) => !mutableNodes.includes(node)
+      );
+      const supportRectsByLayer = /* @__PURE__ */ new Map();
+      supportRectsByLayer.set(
+        lowerZ,
+        mutableNodes.filter((node) => isSingletonNodeOnLayer(node, lowerZ)).map(nodeToRect)
+      );
+      supportRectsByLayer.set(
+        upperZ,
+        mutableNodes.filter((node) => isSingletonNodeOnLayer(node, upperZ)).map(nodeToRect)
+      );
+      const promotedRects = [];
+      const promotedNodes = [];
+      const candidateNodes = mutableNodes.filter(
+        (node) => isPromotableRect({
+          rect: nodeToRect(node),
+          viaMinSize,
+          minFragmentArea
+        })
+      ).sort((a, b) => rectArea(nodeToRect(b)) - rectArea(nodeToRect(a)));
+      for (const candidate of candidateNodes) {
+        const candidateRect = nodeToRect(candidate);
+        const candidatePieces = subtractRects(
+          candidateRect,
+          promotedRects
+        ).filter((piece) => isResidualRect(piece, minFragmentArea));
+        const candidateZ = candidate.availableZ[0];
+        const oppositeZ = candidateZ === lowerZ ? upperZ : lowerZ;
+        const supportRects = supportRectsByLayer.get(oppositeZ) ?? [];
+        for (const piece of candidatePieces) {
+          const promotablePieces = computePromotablePieces({
+            target: piece,
+            supportRects,
+            viaMinSize,
+            minFragmentArea
+          });
+          for (const promotablePiece of promotablePieces) {
+            promotedRects.push(promotablePiece);
+            const promotedNode = clonePromotedNodeWithRect(
+              candidate,
+              promotablePiece,
+              `${candidate.capacityMeshNodeId}-adjacent-merge-${nextPromotedId++}`,
+              [lowerZ, upperZ]
+            );
+            promotedNodes.push(promotedNode);
+            this.promotedNodeIds.add(promotedNode.capacityMeshNodeId);
+          }
+        }
+      }
+      const residualNodes = [];
+      for (const node of mutableNodes) {
+        const nodeRect = nodeToRect(node);
+        const remainingPieces = subtractRects(nodeRect, promotedRects).filter(
+          (piece) => isResidualRect(piece, minFragmentArea)
+        );
+        if (remainingPieces.length === 1 && sameRect(remainingPieces[0], nodeRect)) {
+          residualNodes.push(node);
+          continue;
+        }
+        for (const piece of remainingPieces) {
+          const residualNode = cloneNodeWithRect(
+            node,
+            piece,
+            `${node.capacityMeshNodeId}-adjacent-residual-${nextResidualId++}`
+          );
+          residualNodes.push(residualNode);
+          this.residualNodeIds.add(residualNode.capacityMeshNodeId);
+        }
+      }
+      workingNodes = [...immutableNodes, ...promotedNodes, ...residualNodes];
+    }
+    return workingNodes;
+  }
+  getOutput() {
+    return { outputNodes: this.outputNodes };
+  }
+  visualize() {
+    return {
+      title: "AdjacentLayerContainmentMergeSolver",
+      coordinateSystem: "cartesian",
+      rects: this.outputNodes.map((node) => {
+        const colors = getColorForZLayer(node.availableZ);
+        const isPromoted = this.promotedNodeIds.has(node.capacityMeshNodeId);
+        const isResidual = this.residualNodeIds.has(node.capacityMeshNodeId);
+        return {
+          center: node.center,
+          width: node.width,
+          height: node.height,
+          stroke: isPromoted ? "rgba(245, 158, 11, 0.95)" : isResidual ? "rgba(37, 99, 235, 0.95)" : colors.stroke,
+          fill: node._containsObstacle ? "rgba(239, 68, 68, 0.35)" : isPromoted ? "rgba(251, 191, 36, 0.28)" : isResidual ? "rgba(59, 130, 246, 0.18)" : colors.fill,
+          layer: `z${node.availableZ.join(",")}`,
+          label: [
+            `node ${node.capacityMeshNodeId}`,
+            `z:${node.availableZ.join(",")}`
+          ].join("\n")
+        };
+      }),
+      points: [],
+      lines: [],
+      texts: []
+    };
+  }
+};
+
 // lib/solvers/GapFillSolver/GapFillSolverPipeline.ts
 import {
   BasePipelineSolver,
@@ -11,14 +393,14 @@ import {
 } from "@tscircuit/solver-utils";
 
 // lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts
-import { BaseSolver } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
 import Flatbush from "flatbush";
 
 // lib/solvers/GapFillSolver/projectToUncoveredSegments.ts
-var EPS = 1e-4;
+var EPS2 = 1e-4;
 function projectToUncoveredSegments(primaryEdge, overlappingEdges) {
-  const isHorizontal = Math.abs(primaryEdge.start.y - primaryEdge.end.y) < EPS;
-  const isVertical = Math.abs(primaryEdge.start.x - primaryEdge.end.x) < EPS;
+  const isHorizontal = Math.abs(primaryEdge.start.y - primaryEdge.end.y) < EPS2;
+  const isVertical = Math.abs(primaryEdge.start.x - primaryEdge.end.x) < EPS2;
   if (!isHorizontal && !isVertical) return [];
   const axis = isHorizontal ? "x" : "y";
   const perp = isHorizontal ? "y" : "x";
@@ -31,16 +413,16 @@ function projectToUncoveredSegments(primaryEdge, overlappingEdges) {
   const intervals = [];
   for (const e of overlappingEdges) {
     if (e === primaryEdge) continue;
-    const eIsHorizontal = Math.abs(e.start.y - e.end.y) < EPS;
-    const eIsVertical = Math.abs(e.start.x - e.end.x) < EPS;
+    const eIsHorizontal = Math.abs(e.start.y - e.end.y) < EPS2;
+    const eIsVertical = Math.abs(e.start.x - e.end.x) < EPS2;
     if (axis === "x" && !eIsHorizontal) continue;
     if (axis === "y" && !eIsVertical) continue;
-    if (Math.abs(e.start[perp] - lineCoord) > EPS) continue;
+    if (Math.abs(e.start[perp] - lineCoord) > EPS2) continue;
     const eMin = Math.min(e.start[axis], e.end[axis]);
     const eMax = Math.max(e.start[axis], e.end[axis]);
     const s = clamp2(eMin);
     const t = clamp2(eMax);
-    if (t - s > EPS) intervals.push({ s, e: t });
+    if (t - s > EPS2) intervals.push({ s, e: t });
   }
   if (intervals.length === 0) {
     return [
@@ -55,19 +437,19 @@ function projectToUncoveredSegments(primaryEdge, overlappingEdges) {
   const merged = [];
   for (const it of intervals) {
     const last = merged[merged.length - 1];
-    if (!last || it.s > last.e + EPS) merged.push({ ...it });
+    if (!last || it.s > last.e + EPS2) merged.push({ ...it });
     else last.e = Math.max(last.e, it.e);
   }
   const uncovered = [];
   let cursor = pMin;
   for (const m of merged) {
-    if (m.s > cursor + EPS) uncovered.push({ s: cursor, e: m.s });
+    if (m.s > cursor + EPS2) uncovered.push({ s: cursor, e: m.s });
     cursor = Math.max(cursor, m.e);
-    if (cursor >= pMax - EPS) break;
+    if (cursor >= pMax - EPS2) break;
   }
-  if (pMax > cursor + EPS) uncovered.push({ s: cursor, e: pMax });
+  if (pMax > cursor + EPS2) uncovered.push({ s: cursor, e: pMax });
   if (uncovered.length === 0) return [];
-  return uncovered.filter((u) => u.e - u.s > EPS).map((u) => {
+  return uncovered.filter((u) => u.e - u.s > EPS2).map((u) => {
     const start = axis === "x" ? { x: u.s, y: lineCoord } : { x: lineCoord, y: u.s };
     const end = axis === "x" ? { x: u.e, y: lineCoord } : { x: lineCoord, y: u.e };
     return {
@@ -156,8 +538,8 @@ var visuallyOffsetLine = (line, options) => {
 
 // lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts
 import "@tscircuit/math-utils";
-var EPS2 = 1e-4;
-var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver {
+var EPS3 = 1e-4;
+var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver2 {
   constructor(input) {
     super();
     this.input = input;
@@ -175,7 +557,7 @@ var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver {
           ;
           [start, end] = [end, start];
         }
-        if (Math.abs(start.x - end.x) < EPS2 && start.y > end.y) {
+        if (Math.abs(start.x - end.x) < EPS3 && start.y > end.y) {
           ;
           [start, end] = [end, start];
         }
@@ -221,10 +603,10 @@ var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver {
     const candidateEdge = this.unprocessedEdges.shift();
     this.lastCandidateEdge = candidateEdge;
     const nearbyEdges = this.edgeSpatialIndex.search(
-      candidateEdge.start.x - EPS2,
-      candidateEdge.start.y - EPS2,
-      candidateEdge.end.x + EPS2,
-      candidateEdge.end.y + EPS2
+      candidateEdge.start.x - EPS3,
+      candidateEdge.start.y - EPS3,
+      candidateEdge.end.x + EPS3,
+      candidateEdge.end.y + EPS3
     );
     const overlappingEdges = nearbyEdges.map((i) => this.allEdges[i]).filter((e) => e.z === candidateEdge.z);
     this.lastOverlappingEdges = overlappingEdges;
@@ -310,7 +692,7 @@ var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver {
 };
 
 // lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts
-import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver3 } from "@tscircuit/solver-utils";
 import RBush from "rbush";
 
 // lib/solvers/GapFillSolver/getBoundsFromCorners.ts
@@ -325,8 +707,8 @@ var getBoundsFromCorners = (corners) => {
 
 // lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts
 import { segmentToBoxMinDistance } from "@tscircuit/math-utils";
-var EPS3 = 1e-4;
-var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver2 {
+var EPS4 = 1e-4;
+var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver3 {
   constructor(input) {
     super();
     this.input = input;
@@ -392,12 +774,12 @@ var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver2 {
     let collidingNodes = null;
     let searchDistance = 1;
     const searchCorner1 = {
-      x: segment.start.x + dx * EPS3 + normDeltaStartEnd.x * EPS3 * 10,
-      y: segment.start.y + dy * EPS3 + normDeltaStartEnd.y * EPS3 * 10
+      x: segment.start.x + dx * EPS4 + normDeltaStartEnd.x * EPS4 * 10,
+      y: segment.start.y + dy * EPS4 + normDeltaStartEnd.y * EPS4 * 10
     };
     const searchCorner2 = {
-      x: segment.end.x + dx * EPS3 - normDeltaStartEnd.x * EPS3 * 10,
-      y: segment.end.y + dy * EPS3 - normDeltaStartEnd.y * EPS3 * 10
+      x: segment.end.x + dx * EPS4 - normDeltaStartEnd.x * EPS4 * 10,
+      y: segment.end.y + dy * EPS4 - normDeltaStartEnd.y * EPS4 * 10
     };
     this.lastSearchCorner1 = searchCorner1;
     this.lastSearchCorner2 = searchCorner2;
@@ -462,7 +844,7 @@ var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver2 {
       }
     };
     this.lastExpandedSegment = expandedSegment;
-    if (nodeWidth < EPS3 || nodeHeight < EPS3) {
+    if (nodeWidth < EPS4 || nodeHeight < EPS4) {
       return;
     }
     this.expandedSegments.push(expandedSegment);
@@ -668,7 +1050,7 @@ var GapFillSolverPipeline = class extends BasePipelineSolver {
 };
 
 // lib/solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver.ts
-import { BaseSolver as BaseSolver3 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver4 } from "@tscircuit/solver-utils";
 
 // lib/solvers/RectDiffSeedingSolver/layers.ts
 function layerSortKey(n) {
@@ -745,76 +1127,6 @@ function obstacleToXYRect(ob) {
   return { x: ob.center.x - w / 2, y: ob.center.y - h / 2, width: w, height: h };
 }
 
-// lib/utils/getColorForZLayer.ts
-var getColorForZLayer = (zLayers) => {
-  const minZ = Math.min(...zLayers);
-  const colors = [
-    { fill: "#dbeafe", stroke: "#3b82f6" },
-    { fill: "#fef3c7", stroke: "#f59e0b" },
-    { fill: "#d1fae5", stroke: "#10b981" },
-    { fill: "#e9d5ff", stroke: "#a855f7" },
-    { fill: "#fed7aa", stroke: "#f97316" },
-    { fill: "#fecaca", stroke: "#ef4444" }
-  ];
-  return colors[minZ % colors.length];
-};
-
-// lib/utils/rectdiff-geometry.ts
-var EPS4 = 1e-9;
-var clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
-var gt = (a, b) => a > b + EPS4;
-var gte = (a, b) => a > b - EPS4;
-var lt = (a, b) => a < b - EPS4;
-var lte = (a, b) => a < b + EPS4;
-function overlaps(a, b) {
-  return !(a.x + a.width <= b.x + EPS4 || b.x + b.width <= a.x + EPS4 || a.y + a.height <= b.y + EPS4 || b.y + b.height <= a.y + EPS4);
-}
-function containsPoint(r, p) {
-  return p.x >= r.x - EPS4 && p.x <= r.x + r.width + EPS4 && p.y >= r.y - EPS4 && p.y <= r.y + r.height + EPS4;
-}
-function distancePointToRectEdges(p, r) {
-  const minX = r.x;
-  const maxX = r.x + r.width;
-  const minY = r.y;
-  const maxY = r.y + r.height;
-  if (p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY) {
-    return Math.min(p.x - minX, maxX - p.x, p.y - minY, maxY - p.y);
-  }
-  const dx = p.x < minX ? minX - p.x : p.x > maxX ? p.x - maxX : 0;
-  const dy = p.y < minY ? minY - p.y : p.y > maxY ? p.y - maxY : 0;
-  if (dx === 0) return dy;
-  if (dy === 0) return dx;
-  return Math.hypot(dx, dy);
-}
-function intersect1D(r1, r2) {
-  const lo = Math.max(r1[0], r2[0]);
-  const hi = Math.min(r1[1], r2[1]);
-  return hi > lo + EPS4 ? [lo, hi] : null;
-}
-function subtractRect2D(A, B) {
-  if (!overlaps(A, B)) return [A];
-  const Xi = intersect1D([A.x, A.x + A.width], [B.x, B.x + B.width]);
-  const Yi = intersect1D([A.y, A.y + A.height], [B.y, B.y + B.height]);
-  if (!Xi || !Yi) return [A];
-  const [X0, X1] = Xi;
-  const [Y0, Y1] = Yi;
-  const out = [];
-  if (X0 > A.x + EPS4) {
-    out.push({ x: A.x, y: A.y, width: X0 - A.x, height: A.height });
-  }
-  if (A.x + A.width > X1 + EPS4) {
-    out.push({ x: X1, y: A.y, width: A.x + A.width - X1, height: A.height });
-  }
-  const midW = Math.max(0, X1 - X0);
-  if (midW > EPS4 && Y0 > A.y + EPS4) {
-    out.push({ x: X0, y: A.y, width: midW, height: Y0 - A.y });
-  }
-  if (midW > EPS4 && A.y + A.height > Y1 + EPS4) {
-    out.push({ x: X0, y: Y1, width: midW, height: A.y + A.height - Y1 });
-  }
-  return out.filter((r) => r.width > EPS4 && r.height > EPS4);
-}
-
 // lib/utils/padRect.ts
 var padRect = (rect, clearance) => {
   if (!clearance || clearance <= 0) return rect;
@@ -827,19 +1139,20 @@ var padRect = (rect, clearance) => {
 };
 
 // lib/solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver.ts
-var nodeToRect = (node) => ({
+var nodeToRect2 = (node) => ({
   x: node.center.x - node.width / 2,
   y: node.center.y - node.height / 2,
   width: node.width,
   height: node.height
 });
-var rectArea = (rect) => rect.width * rect.height;
-var cloneNode = (node) => ({
+var rectArea2 = (rect) => rect.width * rect.height;
+var MIN_OUTER_LAYER_MERGE_AREA_MM2 = 1;
+var cloneNode2 = (node) => ({
   ...node,
   center: { ...node.center },
   availableZ: [...node.availableZ]
 });
-var cloneNodeWithRect = (node, rect, capacityMeshNodeId) => ({
+var cloneNodeWithRect2 = (node, rect, capacityMeshNodeId) => ({
   ...node,
   capacityMeshNodeId,
   center: {
@@ -851,10 +1164,10 @@ var cloneNodeWithRect = (node, rect, capacityMeshNodeId) => ({
   availableZ: [...node.availableZ],
   layer: `z${node.availableZ.join(",")}`
 });
-var isFreeNode = (node) => !node._containsObstacle && !node._containsTarget;
+var isFreeNode2 = (node) => !node._containsObstacle && !node._containsTarget;
 var isSingletonOuterNode = (node, outerZ) => node.availableZ.length === 1 && node.availableZ[0] === outerZ;
-var sameRect = (a, b) => Math.abs(a.x - b.x) <= EPS4 && Math.abs(a.y - b.y) <= EPS4 && Math.abs(a.width - b.width) <= EPS4 && Math.abs(a.height - b.height) <= EPS4;
-var subtractRects = (target, cutters) => {
+var sameRect2 = (a, b) => Math.abs(a.x - b.x) <= EPS && Math.abs(a.y - b.y) <= EPS && Math.abs(a.width - b.width) <= EPS && Math.abs(a.height - b.height) <= EPS;
+var subtractRects2 = (target, cutters) => {
   let remaining = [target];
   for (const cutter of cutters) {
     if (remaining.length === 0) return remaining;
@@ -866,10 +1179,10 @@ var subtractRects = (target, cutters) => {
   }
   return remaining;
 };
-var isFullyCoveredByRects = (target, coveringRects) => {
-  return subtractRects(target, coveringRects).length === 0;
+var isFullyCoveredByRects2 = (target, coveringRects) => {
+  return subtractRects2(target, coveringRects).length === 0;
 };
-var OuterLayerContainmentMergeSolver = class extends BaseSolver3 {
+var OuterLayerContainmentMergeSolver = class extends BaseSolver4 {
   constructor(input) {
     super();
     this.input = input;
@@ -879,7 +1192,7 @@ var OuterLayerContainmentMergeSolver = class extends BaseSolver3 {
   promotedNodeIds = /* @__PURE__ */ new Set();
   residualNodeIds = /* @__PURE__ */ new Set();
   _setup() {
-    this.outputNodes = this.input.meshNodes.map(cloneNode);
+    this.outputNodes = this.input.meshNodes.map(cloneNode2);
     this.promotedNodeIds.clear();
     this.residualNodeIds.clear();
   }
@@ -891,15 +1204,15 @@ var OuterLayerContainmentMergeSolver = class extends BaseSolver3 {
     const srj = this.input.simpleRouteJson;
     const layerCount = Math.max(1, srj.layerCount || 1);
     if (layerCount < 3) {
-      return this.input.meshNodes.map(cloneNode);
+      return this.input.meshNodes.map(cloneNode2);
     }
     const topZ = 0;
     const bottomZ = layerCount - 1;
     const viaMinSize = Math.max(srj.minViaDiameter ?? 0, srj.minTraceWidth || 0);
-    const originalNodes = this.input.meshNodes.map(cloneNode);
+    const originalNodes = this.input.meshNodes.map(cloneNode2);
     const obstaclesByLayer = this.buildObstaclesByLayer(layerCount);
     const mutableOuterNodes = originalNodes.filter(
-      (node) => isFreeNode(node) && (isSingletonOuterNode(node, topZ) || isSingletonOuterNode(node, bottomZ))
+      (node) => isFreeNode2(node) && (isSingletonOuterNode(node, topZ) || isSingletonOuterNode(node, bottomZ))
     );
     const immutableNodes = originalNodes.filter(
       (node) => !mutableOuterNodes.includes(node)
@@ -907,21 +1220,21 @@ var OuterLayerContainmentMergeSolver = class extends BaseSolver3 {
     const freeSupportRectsByOuterLayer = /* @__PURE__ */ new Map();
     freeSupportRectsByOuterLayer.set(
       topZ,
-      originalNodes.filter((node) => isFreeNode(node) && node.availableZ.includes(topZ)).map(nodeToRect)
+      originalNodes.filter((node) => isFreeNode2(node) && node.availableZ.includes(topZ)).map(nodeToRect2)
     );
     freeSupportRectsByOuterLayer.set(
       bottomZ,
-      originalNodes.filter((node) => isFreeNode(node) && node.availableZ.includes(bottomZ)).map(nodeToRect)
+      originalNodes.filter((node) => isFreeNode2(node) && node.availableZ.includes(bottomZ)).map(nodeToRect2)
     );
     const promotedNodes = [];
     const promotedRects = [];
     const candidateNodes = mutableOuterNodes.filter(
-      (node) => node.width + EPS4 >= viaMinSize && node.height + EPS4 >= viaMinSize
-    ).sort((a, b) => rectArea(nodeToRect(b)) - rectArea(nodeToRect(a)));
+      (node) => node.width + EPS >= viaMinSize && node.height + EPS >= viaMinSize && rectArea2(nodeToRect2(node)) > MIN_OUTER_LAYER_MERGE_AREA_MM2 + EPS
+    ).sort((a, b) => rectArea2(nodeToRect2(b)) - rectArea2(nodeToRect2(a)));
     for (const candidate of candidateNodes) {
       const candidateZ = candidate.availableZ[0];
       const oppositeZ = candidateZ === topZ ? bottomZ : topZ;
-      const candidateRect = nodeToRect(candidate);
+      const candidateRect = nodeToRect2(candidate);
       const oppositeSupportRects = freeSupportRectsByOuterLayer.get(oppositeZ) ?? [];
       if (!this.isTransitCompatibleAcrossIntermediateLayers({
         rect: candidateRect,
@@ -931,7 +1244,7 @@ var OuterLayerContainmentMergeSolver = class extends BaseSolver3 {
       })) {
         continue;
       }
-      if (!isFullyCoveredByRects(candidateRect, oppositeSupportRects)) {
+      if (!isFullyCoveredByRects2(candidateRect, oppositeSupportRects)) {
         continue;
       }
       promotedNodes.push({
@@ -948,14 +1261,14 @@ var OuterLayerContainmentMergeSolver = class extends BaseSolver3 {
       if (this.promotedNodeIds.has(node.capacityMeshNodeId)) {
         continue;
       }
-      const nodeRect = nodeToRect(node);
-      const remainingPieces = subtractRects(nodeRect, promotedRects);
-      if (remainingPieces.length === 1 && sameRect(remainingPieces[0], nodeRect)) {
+      const nodeRect = nodeToRect2(node);
+      const remainingPieces = subtractRects2(nodeRect, promotedRects);
+      if (remainingPieces.length === 1 && sameRect2(remainingPieces[0], nodeRect)) {
         residualNodes.push(node);
         continue;
       }
       for (const piece of remainingPieces) {
-        const residualNode = cloneNodeWithRect(
+        const residualNode = cloneNodeWithRect2(
           node,
           piece,
           `${node.capacityMeshNodeId}-outer-merge-${nextResidualId++}`
@@ -998,7 +1311,7 @@ var OuterLayerContainmentMergeSolver = class extends BaseSolver3 {
       );
       if (nonCopperOverlap) return false;
       const copperRects = overlapping.filter((entry) => entry.obstacle.isCopperPour).map((entry) => entry.rect);
-      if (!isFullyCoveredByRects(rect, copperRects)) {
+      if (!isFullyCoveredByRects2(rect, copperRects)) {
         return false;
       }
     }
@@ -1042,7 +1355,7 @@ import {
 } from "@tscircuit/solver-utils";
 
 // lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts
-import { BaseSolver as BaseSolver4 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver5 } from "@tscircuit/solver-utils";
 
 // lib/solvers/RectDiffSeedingSolver/isPointInPolygon.ts
 function isPointInPolygon(p, polygon) {
@@ -1105,7 +1418,7 @@ function computeInverseRects(bounds, polygon) {
   }
   const finalRects = [];
   rawRects.sort((a, b) => {
-    if (Math.abs(a.y - b.y) > EPS4) return a.y - b.y;
+    if (Math.abs(a.y - b.y) > EPS) return a.y - b.y;
     return a.x - b.x;
   });
   let current = null;
@@ -1114,9 +1427,9 @@ function computeInverseRects(bounds, polygon) {
       current = r;
       continue;
     }
-    const sameY = Math.abs(current.y - r.y) < EPS4;
-    const sameHeight = Math.abs(current.height - r.height) < EPS4;
-    const touchesX = Math.abs(current.x + current.width - r.x) < EPS4;
+    const sameY = Math.abs(current.y - r.y) < EPS;
+    const sameHeight = Math.abs(current.height - r.height) < EPS;
+    const touchesX = Math.abs(current.x + current.width - r.x) < EPS;
     if (sameY && sameHeight && touchesX) {
       current.width += r.width;
     } else {
@@ -1126,7 +1439,7 @@ function computeInverseRects(bounds, polygon) {
   }
   if (current) finalRects.push(current);
   finalRects.sort((a, b) => {
-    if (Math.abs(a.x - b.x) > EPS4) return a.x - b.x;
+    if (Math.abs(a.x - b.x) > EPS) return a.x - b.x;
     return a.y - b.y;
   });
   const mergedVertical = [];
@@ -1136,9 +1449,9 @@ function computeInverseRects(bounds, polygon) {
       current = r;
       continue;
     }
-    const sameX = Math.abs(current.x - r.x) < EPS4;
-    const sameWidth = Math.abs(current.width - r.width) < EPS4;
-    const touchesY = Math.abs(current.y + current.height - r.y) < EPS4;
+    const sameX = Math.abs(current.x - r.x) < EPS;
+    const sameWidth = Math.abs(current.width - r.width) < EPS;
+    const touchesY = Math.abs(current.y + current.height - r.y) < EPS;
     if (sameX && sameWidth && touchesY) {
       current.height += r.height;
     } else {
@@ -1204,11 +1517,11 @@ function maxExpandRight(params) {
   const { r, bounds, blockers, maxAspect } = params;
   let maxWidth = bounds.x + bounds.width - r.x;
   for (const b of blockers) {
-    const verticallyOverlaps = r.y + r.height > b.y + EPS4 && b.y + b.height > r.y + EPS4;
+    const verticallyOverlaps = r.y + r.height > b.y + EPS && b.y + b.height > r.y + EPS;
     if (verticallyOverlaps) {
       if (gte(b.x, r.x + r.width)) {
         maxWidth = Math.min(maxWidth, b.x - r.x);
-      } else if (b.x + b.width > r.x + r.width - EPS4 && b.x < r.x + r.width + EPS4) {
+      } else if (b.x + b.width > r.x + r.width - EPS && b.x < r.x + r.width + EPS) {
         return 0;
       }
     }
@@ -1225,11 +1538,11 @@ function maxExpandDown(params) {
   const { r, bounds, blockers, maxAspect } = params;
   let maxHeight = bounds.y + bounds.height - r.y;
   for (const b of blockers) {
-    const horizOverlaps = r.x + r.width > b.x + EPS4 && b.x + b.width > r.x + EPS4;
+    const horizOverlaps = r.x + r.width > b.x + EPS && b.x + b.width > r.x + EPS;
     if (horizOverlaps) {
       if (gte(b.y, r.y + r.height)) {
         maxHeight = Math.min(maxHeight, b.y - r.y);
-      } else if (b.y + b.height > r.y + r.height - EPS4 && b.y < r.y + r.height + EPS4) {
+      } else if (b.y + b.height > r.y + r.height - EPS && b.y < r.y + r.height + EPS) {
         return 0;
       }
     }
@@ -1246,11 +1559,11 @@ function maxExpandLeft(params) {
   const { r, bounds, blockers, maxAspect } = params;
   let minX = bounds.x;
   for (const b of blockers) {
-    const verticallyOverlaps = r.y + r.height > b.y + EPS4 && b.y + b.height > r.y + EPS4;
+    const verticallyOverlaps = r.y + r.height > b.y + EPS && b.y + b.height > r.y + EPS;
     if (verticallyOverlaps) {
       if (lte(b.x + b.width, r.x)) {
         minX = Math.max(minX, b.x + b.width);
-      } else if (b.x < r.x + EPS4 && b.x + b.width > r.x - EPS4) {
+      } else if (b.x < r.x + EPS && b.x + b.width > r.x - EPS) {
         return 0;
       }
     }
@@ -1267,11 +1580,11 @@ function maxExpandUp(params) {
   const { r, bounds, blockers, maxAspect } = params;
   let minY = bounds.y;
   for (const b of blockers) {
-    const horizOverlaps = r.x + r.width > b.x + EPS4 && b.x + b.width > r.x + EPS4;
+    const horizOverlaps = r.x + r.width > b.x + EPS && b.x + b.width > r.x + EPS;
     if (horizOverlaps) {
       if (lte(b.y + b.height, r.y)) {
         minY = Math.max(minY, b.y + b.height);
-      } else if (b.y < r.y + EPS4 && b.y + b.height > r.y - EPS4) {
+      } else if (b.y < r.y + EPS && b.y + b.height > r.y - EPS) {
         return 0;
       }
     }
@@ -1296,7 +1609,7 @@ var toQueryRect = (params) => {
   const minY = Math.max(bounds.y, rect.y);
   const maxX = Math.min(bounds.x + bounds.width, rect.x + rect.width);
   const maxY = Math.min(bounds.y + bounds.height, rect.y + rect.height);
-  if (maxX <= minX + EPS4 || maxY <= minY + EPS4) return null;
+  if (maxX <= minX + EPS || maxY <= minY + EPS) return null;
   return { minX, minY, maxX, maxY };
 };
 function expandRectFromSeed(params) {
@@ -1402,7 +1715,7 @@ function expandRectFromSeed(params) {
         improved = true;
       }
     }
-    if (r.width + EPS4 >= minReq.width && r.height + EPS4 >= minReq.height) {
+    if (r.width + EPS >= minReq.width && r.height + EPS >= minReq.height) {
       const area = r.width * r.height;
       if (area > bestArea) {
         best = quantizeRect(r);
@@ -1496,7 +1809,7 @@ function computeCandidates3D(params) {
   ]);
   for (let x = bounds.x; x < bounds.x + bounds.width; x += gridSize) {
     for (let y = bounds.y; y < bounds.y + bounds.height; y += gridSize) {
-      if (Math.abs(x - bounds.x) < EPS4 || Math.abs(y - bounds.y) < EPS4 || x > bounds.x + bounds.width - gridSize - EPS4 || y > bounds.y + bounds.height - gridSize - EPS4) {
+      if (Math.abs(x - bounds.x) < EPS || Math.abs(y - bounds.y) < EPS || x > bounds.x + bounds.width - gridSize - EPS || y > bounds.y + bounds.height - gridSize - EPS) {
         continue;
       }
       if (isFullyOccupiedAtPoint({
@@ -1568,7 +1881,7 @@ function computeUncoveredSegments(params) {
     const s = quantize3(i.start);
     const e = quantize3(i.end);
     return { start: Math.min(s, e), end: Math.max(s, e) };
-  }).filter((i) => i.end > i.start + EPS4);
+  }).filter((i) => i.end > i.start + EPS);
   if (normalizedIntervals.length === 0) {
     const center = (lineStartQ + lineEndQ) / 2;
     return [{ start: lineStartQ, end: lineEndQ, center }];
@@ -1578,7 +1891,7 @@ function computeUncoveredSegments(params) {
   let current = { ...sorted[0] };
   for (let i = 1; i < sorted.length; i++) {
     const interval = sorted[i];
-    if (interval.start <= current.end + EPS4) {
+    if (interval.start <= current.end + EPS) {
       current.end = Math.max(current.end, interval.end);
     } else {
       merged.push(current);
@@ -1587,7 +1900,7 @@ function computeUncoveredSegments(params) {
   }
   merged.push(current);
   const uncovered = [];
-  if (merged[0].start > lineStartQ + EPS4) {
+  if (merged[0].start > lineStartQ + EPS) {
     const start = lineStartQ;
     const end = merged[0].start;
     if (end - start >= minSegmentLength) {
@@ -1601,7 +1914,7 @@ function computeUncoveredSegments(params) {
       uncovered.push({ start, end, center: (start + end) / 2 });
     }
   }
-  if (merged[merged.length - 1].end < lineEndQ - EPS4) {
+  if (merged[merged.length - 1].end < lineEndQ - EPS) {
     const start = merged[merged.length - 1].end;
     const end = lineEndQ;
     if (end - start >= minSegmentLength) {
@@ -1620,7 +1933,7 @@ function computeEdgeCandidates3D(params) {
     hardPlacedByLayer
   } = params;
   const out = [];
-  const \u03B4 = Math.max(minSize * 0.15, EPS4 * 3);
+  const \u03B4 = Math.max(minSize * 0.15, EPS * 3);
   const dedup = /* @__PURE__ */ new Set();
   const hardRectsByLayer = Array.from(
     { length: layerCount },
@@ -1644,7 +1957,7 @@ function computeEdgeCandidates3D(params) {
     const { z } = p;
     const x = qx;
     const y = qy;
-    if (x < bounds.x + EPS4 || y < bounds.y + EPS4 || x > bounds.x + bounds.width - EPS4 || y > bounds.y + bounds.height - EPS4)
+    if (x < bounds.x + EPS || y < bounds.y + EPS || x > bounds.x + bounds.width - EPS || y > bounds.y + bounds.height - EPS)
       return;
     if (fullyOcc({ x, y })) return;
     const hard = hardRectsByLayer[z] ?? [];
@@ -1781,7 +2094,7 @@ function computeEdgeCandidates3D(params) {
     }
     for (const b of blockers) {
       const obLeftX = b.x - \u03B4;
-      if (obLeftX > bounds.x + EPS4 && obLeftX < bounds.x + bounds.width - EPS4) {
+      if (obLeftX > bounds.x + EPS && obLeftX < bounds.x + bounds.width - EPS) {
         const obLeftCovering = blockers.filter(
           (bl) => bl !== b && bl.x <= obLeftX && bl.x + bl.width >= obLeftX
         ).map((bl) => ({
@@ -1799,7 +2112,7 @@ function computeEdgeCandidates3D(params) {
         }
       }
       const obRightX = b.x + b.width + \u03B4;
-      if (obRightX > bounds.x + EPS4 && obRightX < bounds.x + bounds.width - EPS4) {
+      if (obRightX > bounds.x + EPS && obRightX < bounds.x + bounds.width - EPS) {
         const obRightCovering = blockers.filter(
           (bl) => bl !== b && bl.x <= obRightX && bl.x + bl.width >= obRightX
         ).map((bl) => ({
@@ -1817,7 +2130,7 @@ function computeEdgeCandidates3D(params) {
         }
       }
       const obTopY = b.y - \u03B4;
-      if (obTopY > bounds.y + EPS4 && obTopY < bounds.y + bounds.height - EPS4) {
+      if (obTopY > bounds.y + EPS && obTopY < bounds.y + bounds.height - EPS) {
         const obTopCovering = blockers.filter(
           (bl) => bl !== b && bl.y <= obTopY && bl.y + bl.height >= obTopY
         ).map((bl) => ({
@@ -1835,7 +2148,7 @@ function computeEdgeCandidates3D(params) {
         }
       }
       const obBottomY = b.y + b.height + \u03B4;
-      if (obBottomY > bounds.y + EPS4 && obBottomY < bounds.y + bounds.height - EPS4) {
+      if (obBottomY > bounds.y + EPS && obBottomY < bounds.y + bounds.height - EPS) {
         const obBottomCovering = blockers.filter(
           (bl) => bl !== b && bl.y <= obBottomY && bl.y + bl.height >= obBottomY
         ).map((bl) => ({
@@ -1910,12 +2223,12 @@ function resizeSoftOverlaps(params, newIndex) {
       params.options.minMulti.height
     );
     for (const p of parts) {
-      if (p.width + EPS4 >= minW && p.height + EPS4 >= minH) {
+      if (p.width + EPS >= minW && p.height + EPS >= minH) {
         toAdd.push({ rect: p, zLayers: sharedZ.slice() });
       }
     }
   }
-  const sameRect2 = (a, b) => a.minX === b.minX && a.minY === b.minY && a.maxX === b.maxX && a.maxY === b.maxY;
+  const sameRect3 = (a, b) => a.minX === b.minX && a.minY === b.minY && a.maxX === b.maxX && a.maxY === b.maxY;
   removeIdx.sort((a, b) => b - a).forEach((idx) => {
     const rem = params.placed.splice(idx, 1)[0];
     if (params.placedIndexByLayer) {
@@ -1924,7 +2237,7 @@ function resizeSoftOverlaps(params, newIndex) {
         if (tree)
           tree.remove(
             rectToTree(rem.rect, { zLayers: rem.zLayers }),
-            sameRect2
+            sameRect3
           );
       }
     }
@@ -1944,7 +2257,7 @@ function resizeSoftOverlaps(params, newIndex) {
 
 // lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts
 import RBush3 from "rbush";
-var RectDiffSeedingSolver = class extends BaseSolver4 {
+var RectDiffSeedingSolver = class extends BaseSolver5 {
   constructor(input) {
     super();
     this.input = input;
@@ -2303,7 +2616,7 @@ z:${placement.zLayers.join(",")}`
 };
 
 // lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts
-import { BaseSolver as BaseSolver5 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
 
 // lib/utils/finalizeRects.ts
 function finalizeRects(params) {
@@ -2375,7 +2688,7 @@ import RBush4 from "rbush";
 var sameTreeRect = (a, b) => a.minX === b.minX && a.minY === b.minY && a.maxX === b.maxX && a.maxY === b.maxY;
 
 // lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts
-var RectDiffExpansionSolver = class extends BaseSolver5 {
+var RectDiffExpansionSolver = class extends BaseSolver6 {
   constructor(input) {
     super();
     this.input = input;
@@ -2865,6 +3178,7 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
   rectDiffGridSolverPipeline;
   gapFillSolver;
   outerLayerContainmentMergeSolver;
+  adjacentLayerContainmentMergeSolver;
   boardVoidRects;
   zIndexByName;
   layerNames;
@@ -2912,6 +3226,16 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
           obstacleClearance: rectDiffPipeline.inputProblem.obstacleClearance
         }
       ]
+    ),
+    definePipelineStep3(
+      "adjacentLayerContainmentMergeSolver",
+      AdjacentLayerContainmentMergeSolver,
+      (rectDiffPipeline) => [
+        {
+          meshNodes: rectDiffPipeline.outerLayerContainmentMergeSolver?.getOutput().outputNodes ?? rectDiffPipeline.gapFillSolver?.getOutput().outputNodes ?? rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? [],
+          simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson
+        }
+      ]
     )
   ];
   _setup() {
@@ -2937,6 +3261,10 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
     return [this.inputProblem];
   }
   getOutput() {
+    const adjacentLayerMergeOutput = this.adjacentLayerContainmentMergeSolver?.getOutput();
+    if (adjacentLayerMergeOutput) {
+      return { meshNodes: adjacentLayerMergeOutput.outputNodes };
+    }
     const outerLayerMergeOutput = this.outerLayerContainmentMergeSolver?.getOutput();
     if (outerLayerMergeOutput) {
       return { meshNodes: outerLayerMergeOutput.outputNodes };