@tscircuit/rectdiff 0.0.27 → 0.0.29

package/dist/index.js

@@ -4,388 +4,6 @@ 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,
@@ -393,14 +11,14 @@ import {
 } from "@tscircuit/solver-utils";
 
 // lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts
-import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
+import { BaseSolver } from "@tscircuit/solver-utils";
 import Flatbush from "flatbush";
 
 // lib/solvers/GapFillSolver/projectToUncoveredSegments.ts
-var EPS2 = 1e-4;
+var EPS = 1e-4;
 function projectToUncoveredSegments(primaryEdge, overlappingEdges) {
-  const isHorizontal = Math.abs(primaryEdge.start.y - primaryEdge.end.y) < EPS2;
-  const isVertical = Math.abs(primaryEdge.start.x - primaryEdge.end.x) < EPS2;
+  const isHorizontal = Math.abs(primaryEdge.start.y - primaryEdge.end.y) < EPS;
+  const isVertical = Math.abs(primaryEdge.start.x - primaryEdge.end.x) < EPS;
   if (!isHorizontal && !isVertical) return [];
   const axis = isHorizontal ? "x" : "y";
   const perp = isHorizontal ? "y" : "x";
@@ -413,16 +31,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) < EPS2;
-    const eIsVertical = Math.abs(e.start.x - e.end.x) < EPS2;
+    const eIsHorizontal = Math.abs(e.start.y - e.end.y) < EPS;
+    const eIsVertical = Math.abs(e.start.x - e.end.x) < EPS;
     if (axis === "x" && !eIsHorizontal) continue;
     if (axis === "y" && !eIsVertical) continue;
-    if (Math.abs(e.start[perp] - lineCoord) > EPS2) continue;
+    if (Math.abs(e.start[perp] - lineCoord) > EPS) 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 > EPS2) intervals.push({ s, e: t });
+    if (t - s > EPS) intervals.push({ s, e: t });
   }
   if (intervals.length === 0) {
     return [
@@ -437,19 +55,19 @@ function projectToUncoveredSegments(primaryEdge, overlappingEdges) {
   const merged = [];
   for (const it of intervals) {
     const last = merged[merged.length - 1];
-    if (!last || it.s > last.e + EPS2) merged.push({ ...it });
+    if (!last || it.s > last.e + EPS) 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 + EPS2) uncovered.push({ s: cursor, e: m.s });
+    if (m.s > cursor + EPS) uncovered.push({ s: cursor, e: m.s });
     cursor = Math.max(cursor, m.e);
-    if (cursor >= pMax - EPS2) break;
+    if (cursor >= pMax - EPS) break;
   }
-  if (pMax > cursor + EPS2) uncovered.push({ s: cursor, e: pMax });
+  if (pMax > cursor + EPS) uncovered.push({ s: cursor, e: pMax });
   if (uncovered.length === 0) return [];
-  return uncovered.filter((u) => u.e - u.s > EPS2).map((u) => {
+  return uncovered.filter((u) => u.e - u.s > EPS).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 {
@@ -538,8 +156,8 @@ var visuallyOffsetLine = (line, options) => {
 
 // lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts
 import "@tscircuit/math-utils";
-var EPS3 = 1e-4;
-var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver2 {
+var EPS2 = 1e-4;
+var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver {
   constructor(input) {
     super();
     this.input = input;
@@ -557,7 +175,7 @@ var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver2 {
           ;
           [start, end] = [end, start];
         }
-        if (Math.abs(start.x - end.x) < EPS3 && start.y > end.y) {
+        if (Math.abs(start.x - end.x) < EPS2 && start.y > end.y) {
           ;
           [start, end] = [end, start];
         }
@@ -603,10 +221,10 @@ var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver2 {
     const candidateEdge = this.unprocessedEdges.shift();
     this.lastCandidateEdge = candidateEdge;
     const nearbyEdges = this.edgeSpatialIndex.search(
-      candidateEdge.start.x - EPS3,
-      candidateEdge.start.y - EPS3,
-      candidateEdge.end.x + EPS3,
-      candidateEdge.end.y + EPS3
+      candidateEdge.start.x - EPS2,
+      candidateEdge.start.y - EPS2,
+      candidateEdge.end.x + EPS2,
+      candidateEdge.end.y + EPS2
     );
     const overlappingEdges = nearbyEdges.map((i) => this.allEdges[i]).filter((e) => e.z === candidateEdge.z);
     this.lastOverlappingEdges = overlappingEdges;
@@ -692,7 +310,7 @@ var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver2 {
 };
 
 // lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts
-import { BaseSolver as BaseSolver3 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
 import RBush from "rbush";
 
 // lib/solvers/GapFillSolver/getBoundsFromCorners.ts
@@ -707,8 +325,8 @@ var getBoundsFromCorners = (corners) => {
 
 // lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts
 import { segmentToBoxMinDistance } from "@tscircuit/math-utils";
-var EPS4 = 1e-4;
-var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver3 {
+var EPS3 = 1e-4;
+var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver2 {
   constructor(input) {
     super();
     this.input = input;
@@ -774,12 +392,12 @@ var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver3 {
     let collidingNodes = null;
     let searchDistance = 1;
     const searchCorner1 = {
-      x: segment.start.x + dx * EPS4 + normDeltaStartEnd.x * EPS4 * 10,
-      y: segment.start.y + dy * EPS4 + normDeltaStartEnd.y * EPS4 * 10
+      x: segment.start.x + dx * EPS3 + normDeltaStartEnd.x * EPS3 * 10,
+      y: segment.start.y + dy * EPS3 + normDeltaStartEnd.y * EPS3 * 10
     };
     const searchCorner2 = {
-      x: segment.end.x + dx * EPS4 - normDeltaStartEnd.x * EPS4 * 10,
-      y: segment.end.y + dy * EPS4 - normDeltaStartEnd.y * EPS4 * 10
+      x: segment.end.x + dx * EPS3 - normDeltaStartEnd.x * EPS3 * 10,
+      y: segment.end.y + dy * EPS3 - normDeltaStartEnd.y * EPS3 * 10
     };
     this.lastSearchCorner1 = searchCorner1;
     this.lastSearchCorner2 = searchCorner2;
@@ -844,7 +462,7 @@ var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver3 {
       }
     };
     this.lastExpandedSegment = expandedSegment;
-    if (nodeWidth < EPS4 || nodeHeight < EPS4) {
+    if (nodeWidth < EPS3 || nodeHeight < EPS3) {
       return;
     }
     this.expandedSegments.push(expandedSegment);
@@ -1049,312 +667,70 @@ var GapFillSolverPipeline = class extends BasePipelineSolver {
   }
 };
 
-// lib/solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver.ts
-import { BaseSolver as BaseSolver4 } from "@tscircuit/solver-utils";
+// lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts
+import {
+  BasePipelineSolver as BasePipelineSolver2,
+  definePipelineStep as definePipelineStep2
+} from "@tscircuit/solver-utils";
 
-// lib/solvers/RectDiffSeedingSolver/layers.ts
-function layerSortKey(n) {
-  const L = n.toLowerCase();
-  if (L === "top") return -1e6;
-  if (L === "bottom") return 1e6;
-  const m = /^inner(\d+)$/i.exec(L);
-  if (m) return parseInt(m[1], 10) || 0;
-  return 100 + L.charCodeAt(0);
-}
-function canonicalizeLayerOrder(names) {
-  return Array.from(new Set(names)).sort((a, b) => {
-    const ka = layerSortKey(a);
-    const kb = layerSortKey(b);
-    if (ka !== kb) return ka - kb;
-    return a.localeCompare(b);
-  });
+// lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts
+import { BaseSolver as BaseSolver3 } from "@tscircuit/solver-utils";
+
+// 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 buildZIndexMap(params) {
-  const names = canonicalizeLayerOrder(
-    (params.obstacles ?? []).flatMap((o) => o.layers ?? [])
-  );
-  const declaredLayerCount = Math.max(1, params.layerCount || names.length || 1);
-  const fallback = Array.from(
-    { length: declaredLayerCount },
-    (_, i) => i === 0 ? "top" : i === declaredLayerCount - 1 ? "bottom" : `inner${i}`
-  );
-  const ordered = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (n) => {
-    const key = n.toLowerCase();
-    if (seen.has(key)) return;
-    seen.add(key);
-    ordered.push(n);
-  };
-  fallback.forEach(push);
-  names.forEach(push);
-  const layerNames = ordered.slice(0, declaredLayerCount);
-  const clampIndex = (nameLower) => {
-    if (layerNames.length <= 1) return 0;
-    if (nameLower === "top") return 0;
-    if (nameLower === "bottom") return layerNames.length - 1;
-    const m = /^inner(\d+)$/i.exec(nameLower);
-    if (m) {
-      if (layerNames.length <= 2) return layerNames.length - 1;
-      const parsed = parseInt(m[1], 10);
-      const maxInner = layerNames.length - 2;
-      const clampedInner = Math.min(
-        maxInner,
-        Math.max(1, Number.isFinite(parsed) ? parsed : 1)
-      );
-      return clampedInner;
-    }
-    return 0;
-  };
-  const map = /* @__PURE__ */ new Map();
-  layerNames.forEach((n, i) => map.set(n.toLowerCase(), i));
-  ordered.slice(layerNames.length).forEach((n) => {
-    const key = n.toLowerCase();
-    map.set(key, clampIndex(key));
-  });
-  return { layerNames, zIndexByName: map };
+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 obstacleZs(ob, zIndexByName) {
-  if (ob.zLayers?.length)
-    return Array.from(new Set(ob.zLayers)).sort((a, b) => a - b);
-  const fromNames = (ob.layers ?? []).map((n) => zIndexByName.get(n.toLowerCase())).filter((v) => typeof v === "number");
-  return Array.from(new Set(fromNames)).sort((a, b) => a - b);
+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 obstacleToXYRect(ob) {
-  const w = ob.width;
-  const h = ob.height;
-  if (typeof w !== "number" || typeof h !== "number") return null;
-  return { x: ob.center.x - w / 2, y: ob.center.y - h / 2, width: w, height: h };
+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;
 }
-
-// lib/utils/padRect.ts
-var padRect = (rect, clearance) => {
-  if (!clearance || clearance <= 0) return rect;
-  return {
-    x: rect.x - clearance,
-    y: rect.y - clearance,
-    width: rect.width + 2 * clearance,
-    height: rect.height + 2 * clearance
-  };
-};
-
-// lib/solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver.ts
-var nodeToRect2 = (node) => ({
-  x: node.center.x - node.width / 2,
-  y: node.center.y - node.height / 2,
-  width: node.width,
-  height: node.height
-});
-var rectArea2 = (rect) => rect.width * rect.height;
-var cloneNode2 = (node) => ({
-  ...node,
-  center: { ...node.center },
-  availableZ: [...node.availableZ]
-});
-var cloneNodeWithRect2 = (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 isFreeNode2 = (node) => !node._containsObstacle && !node._containsTarget;
-var isSingletonOuterNode = (node, outerZ) => node.availableZ.length === 1 && node.availableZ[0] === outerZ;
-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;
-    const nextRemaining = [];
-    for (const piece of remaining) {
-      nextRemaining.push(...subtractRect2D(piece, cutter));
-    }
-    remaining = nextRemaining;
-  }
-  return remaining;
-};
-var isFullyCoveredByRects2 = (target, coveringRects) => {
-  return subtractRects2(target, coveringRects).length === 0;
-};
-var OuterLayerContainmentMergeSolver = class extends BaseSolver4 {
-  constructor(input) {
-    super();
-    this.input = input;
-  }
-  input;
-  outputNodes = [];
-  promotedNodeIds = /* @__PURE__ */ new Set();
-  residualNodeIds = /* @__PURE__ */ new Set();
-  _setup() {
-    this.outputNodes = this.input.meshNodes.map(cloneNode2);
-    this.promotedNodeIds.clear();
-    this.residualNodeIds.clear();
-  }
-  _step() {
-    this.outputNodes = this.processOuterLayerContainmentMerges();
-    this.solved = true;
-  }
-  processOuterLayerContainmentMerges() {
-    const srj = this.input.simpleRouteJson;
-    const layerCount = Math.max(1, srj.layerCount || 1);
-    if (layerCount < 3) {
-      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(cloneNode2);
-    const obstaclesByLayer = this.buildObstaclesByLayer(layerCount);
-    const mutableOuterNodes = originalNodes.filter(
-      (node) => isFreeNode2(node) && (isSingletonOuterNode(node, topZ) || isSingletonOuterNode(node, bottomZ))
-    );
-    const immutableNodes = originalNodes.filter(
-      (node) => !mutableOuterNodes.includes(node)
-    );
-    const freeSupportRectsByOuterLayer = /* @__PURE__ */ new Map();
-    freeSupportRectsByOuterLayer.set(
-      topZ,
-      originalNodes.filter((node) => isFreeNode2(node) && node.availableZ.includes(topZ)).map(nodeToRect2)
-    );
-    freeSupportRectsByOuterLayer.set(
-      bottomZ,
-      originalNodes.filter((node) => isFreeNode2(node) && node.availableZ.includes(bottomZ)).map(nodeToRect2)
-    );
-    const promotedNodes = [];
-    const promotedRects = [];
-    const candidateNodes = mutableOuterNodes.filter(
-      (node) => node.width + EPS >= viaMinSize && node.height + EPS >= viaMinSize
-    ).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 = nodeToRect2(candidate);
-      const oppositeSupportRects = freeSupportRectsByOuterLayer.get(oppositeZ) ?? [];
-      if (!this.isTransitCompatibleAcrossIntermediateLayers({
-        rect: candidateRect,
-        fromZ: candidateZ,
-        toZ: oppositeZ,
-        obstaclesByLayer
-      })) {
-        continue;
-      }
-      if (!isFullyCoveredByRects2(candidateRect, oppositeSupportRects)) {
-        continue;
-      }
-      promotedNodes.push({
-        ...candidate,
-        availableZ: [topZ, bottomZ],
-        layer: `z${topZ},${bottomZ}`
-      });
-      promotedRects.push(candidateRect);
-      this.promotedNodeIds.add(candidate.capacityMeshNodeId);
-    }
-    let nextResidualId = 0;
-    const residualNodes = [];
-    for (const node of mutableOuterNodes) {
-      if (this.promotedNodeIds.has(node.capacityMeshNodeId)) {
-        continue;
-      }
-      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 = cloneNodeWithRect2(
-          node,
-          piece,
-          `${node.capacityMeshNodeId}-outer-merge-${nextResidualId++}`
-        );
-        residualNodes.push(residualNode);
-        this.residualNodeIds.add(residualNode.capacityMeshNodeId);
-      }
-    }
-    return [...immutableNodes, ...promotedNodes, ...residualNodes];
-  }
-  buildObstaclesByLayer(layerCount) {
-    const out = Array.from(
-      { length: layerCount },
-      () => []
-    );
-    for (const obstacle of this.input.simpleRouteJson.obstacles ?? []) {
-      const baseRect = obstacleToXYRect(obstacle);
-      if (!baseRect) continue;
-      const rect = padRect(baseRect, this.input.obstacleClearance ?? 0);
-      const zLayers = obstacleZs(obstacle, this.input.zIndexByName);
-      for (const z of zLayers) {
-        if (z < 0 || z >= layerCount) continue;
-        out[z].push({ obstacle, rect });
-      }
-    }
-    return out;
+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 });
   }
-  isTransitCompatibleAcrossIntermediateLayers(params) {
-    const { rect, fromZ, toZ, obstaclesByLayer } = params;
-    const lo = Math.min(fromZ, toZ);
-    const hi = Math.max(fromZ, toZ);
-    if (hi - lo < 2) return false;
-    for (let z = lo + 1; z < hi; z++) {
-      const overlapping = (obstaclesByLayer[z] ?? []).filter(
-        (entry) => overlaps(entry.rect, rect)
-      );
-      if (overlapping.length === 0) return false;
-      const nonCopperOverlap = overlapping.some(
-        (entry) => !entry.obstacle.isCopperPour
-      );
-      if (nonCopperOverlap) return false;
-      const copperRects = overlapping.filter((entry) => entry.obstacle.isCopperPour).map((entry) => entry.rect);
-      if (!isFullyCoveredByRects2(rect, copperRects)) {
-        return false;
-      }
-    }
-    return true;
+  if (A.x + A.width > X1 + EPS4) {
+    out.push({ x: X1, y: A.y, width: A.x + A.width - X1, height: A.height });
   }
-  getOutput() {
-    return { outputNodes: this.outputNodes };
+  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 });
   }
-  visualize() {
-    return {
-      title: "OuterLayerContainmentMergeSolver",
-      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(22, 163, 74, 0.95)" : isResidual ? "rgba(37, 99, 235, 0.95)" : colors.stroke,
-          fill: node._containsObstacle ? "rgba(239, 68, 68, 0.35)" : isPromoted ? "rgba(34, 197, 94, 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: []
-    };
+  if (midW > EPS4 && A.y + A.height > Y1 + EPS4) {
+    out.push({ x: X0, y: Y1, width: midW, height: A.y + A.height - Y1 });
   }
-};
-
-// lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts
-import {
-  BasePipelineSolver as BasePipelineSolver2,
-  definePipelineStep as definePipelineStep2
-} from "@tscircuit/solver-utils";
-
-// lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts
-import { BaseSolver as BaseSolver5 } from "@tscircuit/solver-utils";
+  return out.filter((r) => r.width > EPS4 && r.height > EPS4);
+}
 
 // lib/solvers/RectDiffSeedingSolver/isPointInPolygon.ts
 function isPointInPolygon(p, polygon) {
@@ -1417,7 +793,7 @@ function computeInverseRects(bounds, polygon) {
   }
   const finalRects = [];
   rawRects.sort((a, b) => {
-    if (Math.abs(a.y - b.y) > EPS) return a.y - b.y;
+    if (Math.abs(a.y - b.y) > EPS4) return a.y - b.y;
     return a.x - b.x;
   });
   let current = null;
@@ -1426,9 +802,9 @@ function computeInverseRects(bounds, polygon) {
       current = r;
       continue;
     }
-    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;
+    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;
     if (sameY && sameHeight && touchesX) {
       current.width += r.width;
     } else {
@@ -1438,7 +814,7 @@ function computeInverseRects(bounds, polygon) {
   }
   if (current) finalRects.push(current);
   finalRects.sort((a, b) => {
-    if (Math.abs(a.x - b.x) > EPS) return a.x - b.x;
+    if (Math.abs(a.x - b.x) > EPS4) return a.x - b.x;
     return a.y - b.y;
   });
   const mergedVertical = [];
@@ -1448,9 +824,9 @@ function computeInverseRects(bounds, polygon) {
       current = r;
       continue;
     }
-    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;
+    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;
     if (sameX && sameWidth && touchesY) {
       current.height += r.height;
     } else {
@@ -1462,6 +838,81 @@ function computeInverseRects(bounds, polygon) {
   return mergedVertical;
 }
 
+// lib/solvers/RectDiffSeedingSolver/layers.ts
+function layerSortKey(n) {
+  const L = n.toLowerCase();
+  if (L === "top") return -1e6;
+  if (L === "bottom") return 1e6;
+  const m = /^inner(\d+)$/i.exec(L);
+  if (m) return parseInt(m[1], 10) || 0;
+  return 100 + L.charCodeAt(0);
+}
+function canonicalizeLayerOrder(names) {
+  return Array.from(new Set(names)).sort((a, b) => {
+    const ka = layerSortKey(a);
+    const kb = layerSortKey(b);
+    if (ka !== kb) return ka - kb;
+    return a.localeCompare(b);
+  });
+}
+function buildZIndexMap(params) {
+  const names = canonicalizeLayerOrder(
+    (params.obstacles ?? []).flatMap((o) => o.layers ?? [])
+  );
+  const declaredLayerCount = Math.max(1, params.layerCount || names.length || 1);
+  const fallback = Array.from(
+    { length: declaredLayerCount },
+    (_, i) => i === 0 ? "top" : i === declaredLayerCount - 1 ? "bottom" : `inner${i}`
+  );
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (n) => {
+    const key = n.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    ordered.push(n);
+  };
+  fallback.forEach(push);
+  names.forEach(push);
+  const layerNames = ordered.slice(0, declaredLayerCount);
+  const clampIndex = (nameLower) => {
+    if (layerNames.length <= 1) return 0;
+    if (nameLower === "top") return 0;
+    if (nameLower === "bottom") return layerNames.length - 1;
+    const m = /^inner(\d+)$/i.exec(nameLower);
+    if (m) {
+      if (layerNames.length <= 2) return layerNames.length - 1;
+      const parsed = parseInt(m[1], 10);
+      const maxInner = layerNames.length - 2;
+      const clampedInner = Math.min(
+        maxInner,
+        Math.max(1, Number.isFinite(parsed) ? parsed : 1)
+      );
+      return clampedInner;
+    }
+    return 0;
+  };
+  const map = /* @__PURE__ */ new Map();
+  layerNames.forEach((n, i) => map.set(n.toLowerCase(), i));
+  ordered.slice(layerNames.length).forEach((n) => {
+    const key = n.toLowerCase();
+    map.set(key, clampIndex(key));
+  });
+  return { layerNames, zIndexByName: map };
+}
+function obstacleZs(ob, zIndexByName) {
+  if (ob.zLayers?.length)
+    return Array.from(new Set(ob.zLayers)).sort((a, b) => a - b);
+  const fromNames = (ob.layers ?? []).map((n) => zIndexByName.get(n.toLowerCase())).filter((v) => typeof v === "number");
+  return Array.from(new Set(fromNames)).sort((a, b) => a - b);
+}
+function obstacleToXYRect(ob) {
+  const w = ob.width;
+  const h = ob.height;
+  if (typeof w !== "number" || typeof h !== "number") return null;
+  return { x: ob.center.x - w / 2, y: ob.center.y - h / 2, width: w, height: h };
+}
+
 // lib/utils/isSelfRect.ts
 var EPS5 = 1e-9;
 var isSelfRect = (params) => Math.abs(params.rect.x + params.rect.width / 2 - params.startX) < EPS5 && Math.abs(params.rect.y + params.rect.height / 2 - params.startY) < EPS5 && Math.abs(params.rect.width - params.initialW) < EPS5 && Math.abs(params.rect.height - params.initialH) < EPS5;
@@ -1516,11 +967,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 + EPS && b.y + b.height > r.y + EPS;
+    const verticallyOverlaps = r.y + r.height > b.y + EPS4 && b.y + b.height > r.y + EPS4;
     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 - EPS && b.x < r.x + r.width + EPS) {
+      } else if (b.x + b.width > r.x + r.width - EPS4 && b.x < r.x + r.width + EPS4) {
         return 0;
       }
     }
@@ -1537,11 +988,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 + EPS && b.x + b.width > r.x + EPS;
+    const horizOverlaps = r.x + r.width > b.x + EPS4 && b.x + b.width > r.x + EPS4;
     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 - EPS && b.y < r.y + r.height + EPS) {
+      } else if (b.y + b.height > r.y + r.height - EPS4 && b.y < r.y + r.height + EPS4) {
         return 0;
       }
     }
@@ -1558,11 +1009,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 + EPS && b.y + b.height > r.y + EPS;
+    const verticallyOverlaps = r.y + r.height > b.y + EPS4 && b.y + b.height > r.y + EPS4;
     if (verticallyOverlaps) {
       if (lte(b.x + b.width, r.x)) {
         minX = Math.max(minX, b.x + b.width);
-      } else if (b.x < r.x + EPS && b.x + b.width > r.x - EPS) {
+      } else if (b.x < r.x + EPS4 && b.x + b.width > r.x - EPS4) {
         return 0;
       }
     }
@@ -1579,11 +1030,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 + EPS && b.x + b.width > r.x + EPS;
+    const horizOverlaps = r.x + r.width > b.x + EPS4 && b.x + b.width > r.x + EPS4;
     if (horizOverlaps) {
       if (lte(b.y + b.height, r.y)) {
         minY = Math.max(minY, b.y + b.height);
-      } else if (b.y < r.y + EPS && b.y + b.height > r.y - EPS) {
+      } else if (b.y < r.y + EPS4 && b.y + b.height > r.y - EPS4) {
         return 0;
       }
     }
@@ -1608,7 +1059,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 + EPS || maxY <= minY + EPS) return null;
+  if (maxX <= minX + EPS4 || maxY <= minY + EPS4) return null;
   return { minX, minY, maxX, maxY };
 };
 function expandRectFromSeed(params) {
@@ -1714,7 +1165,7 @@ function expandRectFromSeed(params) {
         improved = true;
       }
     }
-    if (r.width + EPS >= minReq.width && r.height + EPS >= minReq.height) {
+    if (r.width + EPS4 >= minReq.width && r.height + EPS4 >= minReq.height) {
       const area = r.width * r.height;
       if (area > bestArea) {
         best = quantizeRect(r);
@@ -1808,7 +1259,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) < EPS || Math.abs(y - bounds.y) < EPS || x > bounds.x + bounds.width - gridSize - EPS || y > bounds.y + bounds.height - gridSize - EPS) {
+      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) {
         continue;
       }
       if (isFullyOccupiedAtPoint({
@@ -1880,7 +1331,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 + EPS);
+  }).filter((i) => i.end > i.start + EPS4);
   if (normalizedIntervals.length === 0) {
     const center = (lineStartQ + lineEndQ) / 2;
     return [{ start: lineStartQ, end: lineEndQ, center }];
@@ -1890,7 +1341,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 + EPS) {
+    if (interval.start <= current.end + EPS4) {
       current.end = Math.max(current.end, interval.end);
     } else {
       merged.push(current);
@@ -1899,7 +1350,7 @@ function computeUncoveredSegments(params) {
   }
   merged.push(current);
   const uncovered = [];
-  if (merged[0].start > lineStartQ + EPS) {
+  if (merged[0].start > lineStartQ + EPS4) {
     const start = lineStartQ;
     const end = merged[0].start;
     if (end - start >= minSegmentLength) {
@@ -1913,7 +1364,7 @@ function computeUncoveredSegments(params) {
       uncovered.push({ start, end, center: (start + end) / 2 });
     }
   }
-  if (merged[merged.length - 1].end < lineEndQ - EPS) {
+  if (merged[merged.length - 1].end < lineEndQ - EPS4) {
     const start = merged[merged.length - 1].end;
     const end = lineEndQ;
     if (end - start >= minSegmentLength) {
@@ -1932,7 +1383,7 @@ function computeEdgeCandidates3D(params) {
     hardPlacedByLayer
   } = params;
   const out = [];
-  const \u03B4 = Math.max(minSize * 0.15, EPS * 3);
+  const \u03B4 = Math.max(minSize * 0.15, EPS4 * 3);
   const dedup = /* @__PURE__ */ new Set();
   const hardRectsByLayer = Array.from(
     { length: layerCount },
@@ -1956,7 +1407,7 @@ function computeEdgeCandidates3D(params) {
     const { z } = p;
     const x = qx;
     const y = qy;
-    if (x < bounds.x + EPS || y < bounds.y + EPS || x > bounds.x + bounds.width - EPS || y > bounds.y + bounds.height - EPS)
+    if (x < bounds.x + EPS4 || y < bounds.y + EPS4 || x > bounds.x + bounds.width - EPS4 || y > bounds.y + bounds.height - EPS4)
       return;
     if (fullyOcc({ x, y })) return;
     const hard = hardRectsByLayer[z] ?? [];
@@ -2093,7 +1544,7 @@ function computeEdgeCandidates3D(params) {
     }
     for (const b of blockers) {
       const obLeftX = b.x - \u03B4;
-      if (obLeftX > bounds.x + EPS && obLeftX < bounds.x + bounds.width - EPS) {
+      if (obLeftX > bounds.x + EPS4 && obLeftX < bounds.x + bounds.width - EPS4) {
         const obLeftCovering = blockers.filter(
           (bl) => bl !== b && bl.x <= obLeftX && bl.x + bl.width >= obLeftX
         ).map((bl) => ({
@@ -2111,7 +1562,7 @@ function computeEdgeCandidates3D(params) {
         }
       }
       const obRightX = b.x + b.width + \u03B4;
-      if (obRightX > bounds.x + EPS && obRightX < bounds.x + bounds.width - EPS) {
+      if (obRightX > bounds.x + EPS4 && obRightX < bounds.x + bounds.width - EPS4) {
         const obRightCovering = blockers.filter(
           (bl) => bl !== b && bl.x <= obRightX && bl.x + bl.width >= obRightX
         ).map((bl) => ({
@@ -2129,7 +1580,7 @@ function computeEdgeCandidates3D(params) {
         }
       }
       const obTopY = b.y - \u03B4;
-      if (obTopY > bounds.y + EPS && obTopY < bounds.y + bounds.height - EPS) {
+      if (obTopY > bounds.y + EPS4 && obTopY < bounds.y + bounds.height - EPS4) {
         const obTopCovering = blockers.filter(
           (bl) => bl !== b && bl.y <= obTopY && bl.y + bl.height >= obTopY
         ).map((bl) => ({
@@ -2147,7 +1598,7 @@ function computeEdgeCandidates3D(params) {
         }
       }
       const obBottomY = b.y + b.height + \u03B4;
-      if (obBottomY > bounds.y + EPS && obBottomY < bounds.y + bounds.height - EPS) {
+      if (obBottomY > bounds.y + EPS4 && obBottomY < bounds.y + bounds.height - EPS4) {
         const obBottomCovering = blockers.filter(
           (bl) => bl !== b && bl.y <= obBottomY && bl.y + bl.height >= obBottomY
         ).map((bl) => ({
@@ -2222,12 +1673,12 @@ function resizeSoftOverlaps(params, newIndex) {
       params.options.minMulti.height
     );
     for (const p of parts) {
-      if (p.width + EPS >= minW && p.height + EPS >= minH) {
+      if (p.width + EPS4 >= minW && p.height + EPS4 >= minH) {
         toAdd.push({ rect: p, zLayers: sharedZ.slice() });
       }
     }
   }
-  const sameRect3 = (a, b) => a.minX === b.minX && a.minY === b.minY && a.maxX === b.maxX && a.maxY === b.maxY;
+  const sameRect = (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) {
@@ -2236,7 +1687,7 @@ function resizeSoftOverlaps(params, newIndex) {
         if (tree)
           tree.remove(
             rectToTree(rem.rect, { zLayers: rem.zLayers }),
-            sameRect3
+            sameRect
           );
       }
     }
@@ -2254,9 +1705,23 @@ function resizeSoftOverlaps(params, newIndex) {
   }
 }
 
+// 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/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts
 import RBush3 from "rbush";
-var RectDiffSeedingSolver = class extends BaseSolver5 {
+var RectDiffSeedingSolver = class extends BaseSolver3 {
   constructor(input) {
     super();
     this.input = input;
@@ -2615,7 +2080,7 @@ z:${placement.zLayers.join(",")}`
 };
 
 // lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts
-import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver4 } from "@tscircuit/solver-utils";
 
 // lib/utils/finalizeRects.ts
 function finalizeRects(params) {
@@ -2687,7 +2152,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 BaseSolver6 {
+var RectDiffExpansionSolver = class extends BaseSolver4 {
   constructor(input) {
     super();
     this.input = input;
@@ -2833,6 +2298,19 @@ import "rbush";
 
 // lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts
 import RBush5 from "rbush";
+
+// lib/utils/padRect.ts
+var padRect = (rect, clearance) => {
+  if (!clearance || clearance <= 0) return rect;
+  return {
+    x: rect.x - clearance,
+    y: rect.y - clearance,
+    width: rect.width + 2 * clearance,
+    height: rect.height + 2 * clearance
+  };
+};
+
+// lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts
 var buildObstacleIndexesByLayer = (params) => {
   const { srj, boardVoidRects, obstacleClearance } = params;
   const { layerNames, zIndexByName } = buildZIndexMap({
@@ -3176,8 +2654,6 @@ import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
 var RectDiffPipeline = class extends BasePipelineSolver3 {
   rectDiffGridSolverPipeline;
   gapFillSolver;
-  outerLayerContainmentMergeSolver;
-  adjacentLayerContainmentMergeSolver;
   boardVoidRects;
   zIndexByName;
   layerNames;
@@ -3213,28 +2689,6 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
           }
         }
       ]
-    ),
-    definePipelineStep3(
-      "outerLayerContainmentMergeSolver",
-      OuterLayerContainmentMergeSolver,
-      (rectDiffPipeline) => [
-        {
-          meshNodes: rectDiffPipeline.gapFillSolver?.getOutput().outputNodes ?? rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? [],
-          simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
-          zIndexByName: rectDiffPipeline.zIndexByName ?? /* @__PURE__ */ new Map(),
-          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() {
@@ -3260,14 +2714,6 @@ 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 };
-    }
     const gapFillOutput = this.gapFillSolver?.getOutput();
     if (gapFillOutput) {
       return { meshNodes: gapFillOutput.outputNodes };