@tscircuit/rectdiff 0.0.25 → 0.0.27

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];
         }
@@ -202,6 +584,7 @@ var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver {
     }
     this.edgeSpatialIndex.finish();
   }
+  input;
   allEdges;
   unprocessedEdges = [];
   segmentsWithAdjacentEmptySpace = [];
@@ -220,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;
@@ -309,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
@@ -324,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;
@@ -361,6 +744,7 @@ var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver2 {
       }))
     );
   }
+  input;
   unprocessedSegments = [];
   expandedSegments = [];
   lastSegment = null;
@@ -390,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;
@@ -460,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);
@@ -665,70 +1049,312 @@ var GapFillSolverPipeline = class extends BasePipelineSolver {
   }
 };
 
-// lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts
-import {
-  BasePipelineSolver as BasePipelineSolver2,
-  definePipelineStep as definePipelineStep2
-} from "@tscircuit/solver-utils";
-
-// lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts
-import { BaseSolver as BaseSolver3 } from "@tscircuit/solver-utils";
+// lib/solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver.ts
+import { BaseSolver as BaseSolver4 } 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);
+// 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 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 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 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 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 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 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 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 });
+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/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;
   }
-  if (A.x + A.width > X1 + EPS4) {
-    out.push({ x: X1, y: A.y, width: A.x + A.width - X1, height: A.height });
+  input;
+  outputNodes = [];
+  promotedNodeIds = /* @__PURE__ */ new Set();
+  residualNodeIds = /* @__PURE__ */ new Set();
+  _setup() {
+    this.outputNodes = this.input.meshNodes.map(cloneNode2);
+    this.promotedNodeIds.clear();
+    this.residualNodeIds.clear();
   }
-  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 });
+  _step() {
+    this.outputNodes = this.processOuterLayerContainmentMerges();
+    this.solved = true;
   }
-  if (midW > EPS4 && A.y + A.height > Y1 + EPS4) {
-    out.push({ x: X0, y: Y1, width: midW, height: A.y + A.height - Y1 });
+  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];
   }
-  return out.filter((r) => r.width > EPS4 && r.height > EPS4);
-}
+  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;
+  }
+  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;
+  }
+  getOutput() {
+    return { outputNodes: this.outputNodes };
+  }
+  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: []
+    };
+  }
+};
+
+// 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";
 
 // lib/solvers/RectDiffSeedingSolver/isPointInPolygon.ts
 function isPointInPolygon(p, polygon) {
@@ -791,7 +1417,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;
@@ -800,9 +1426,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 {
@@ -812,7 +1438,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 = [];
@@ -822,9 +1448,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 {
@@ -836,81 +1462,6 @@ 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;
@@ -965,11 +1516,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;
       }
     }
@@ -986,11 +1537,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;
       }
     }
@@ -1007,11 +1558,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;
       }
     }
@@ -1028,11 +1579,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;
       }
     }
@@ -1057,7 +1608,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) {
@@ -1163,7 +1714,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);
@@ -1257,7 +1808,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({
@@ -1329,7 +1880,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 }];
@@ -1339,7 +1890,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);
@@ -1348,7 +1899,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) {
@@ -1362,7 +1913,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) {
@@ -1381,7 +1932,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 },
@@ -1405,7 +1956,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] ?? [];
@@ -1542,7 +2093,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) => ({
@@ -1560,7 +2111,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) => ({
@@ -1578,7 +2129,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) => ({
@@ -1596,7 +2147,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) => ({
@@ -1671,12 +2222,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 sameRect = (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) {
@@ -1685,7 +2236,7 @@ function resizeSoftOverlaps(params, newIndex) {
         if (tree)
           tree.remove(
             rectToTree(rem.rect, { zLayers: rem.zLayers }),
-            sameRect
+            sameRect3
           );
       }
     }
@@ -1703,27 +2254,14 @@ 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 BaseSolver3 {
+var RectDiffSeedingSolver = class extends BaseSolver5 {
   constructor(input) {
     super();
     this.input = input;
   }
+  input;
   // Engine fields (mirrors initState / engine.ts)
   srj;
   layerNames;
@@ -2077,7 +2615,7 @@ z:${placement.zLayers.join(",")}`
 };
 
 // lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts
-import { BaseSolver as BaseSolver4 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
 
 // lib/utils/finalizeRects.ts
 function finalizeRects(params) {
@@ -2149,11 +2687,12 @@ 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 BaseSolver4 {
+var RectDiffExpansionSolver = class extends BaseSolver6 {
   constructor(input) {
     super();
     this.input = input;
   }
+  input;
   placedIndexByLayer = [];
   _meshNodes = [];
   _setup() {
@@ -2294,19 +2833,6 @@ 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({
@@ -2650,6 +3176,8 @@ import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
 var RectDiffPipeline = class extends BasePipelineSolver3 {
   rectDiffGridSolverPipeline;
   gapFillSolver;
+  outerLayerContainmentMergeSolver;
+  adjacentLayerContainmentMergeSolver;
   boardVoidRects;
   zIndexByName;
   layerNames;
@@ -2685,6 +3213,28 @@ 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() {
@@ -2710,6 +3260,14 @@ 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 };