@tscircuit/rectdiff 0.0.24 → 0.0.26

package/dist/index.js

@@ -202,6 +202,7 @@ var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver {
     }
     this.edgeSpatialIndex.finish();
   }
+  input;
   allEdges;
   unprocessedEdges = [];
   segmentsWithAdjacentEmptySpace = [];
@@ -361,6 +362,7 @@ var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver2 {
       }))
     );
   }
+  input;
   unprocessedSegments = [];
   expandedSegments = [];
   lastSegment = null;
@@ -665,15 +667,98 @@ 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
+// lib/solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver.ts
 import { BaseSolver as BaseSolver3 } 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);
+  });
+}
+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/getColorForZLayer.ts
+var getColorForZLayer = (zLayers) => {
+  const minZ = Math.min(...zLayers);
+  const colors = [
+    { fill: "#dbeafe", stroke: "#3b82f6" },
+    { fill: "#fef3c7", stroke: "#f59e0b" },
+    { fill: "#d1fae5", stroke: "#10b981" },
+    { fill: "#e9d5ff", stroke: "#a855f7" },
+    { fill: "#fed7aa", stroke: "#f97316" },
+    { fill: "#fecaca", stroke: "#ef4444" }
+  ];
+  return colors[minZ % colors.length];
+};
+
 // lib/utils/rectdiff-geometry.ts
 var EPS4 = 1e-9;
 var clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
@@ -688,24 +773,18 @@ function containsPoint(r, p) {
   return p.x >= r.x - EPS4 && p.x <= r.x + r.width + EPS4 && p.y >= r.y - EPS4 && p.y <= r.y + r.height + EPS4;
 }
 function distancePointToRectEdges(p, r) {
-  const edges = [
-    [r.x, r.y, r.x + r.width, r.y],
-    [r.x + r.width, r.y, r.x + r.width, r.y + r.height],
-    [r.x + r.width, r.y + r.height, r.x, r.y + r.height],
-    [r.x, r.y + r.height, r.x, r.y]
-  ];
-  let best = Infinity;
-  for (const [x1, y1, x2, y2] of edges) {
-    const A = p.x - x1, B = p.y - y1, C = x2 - x1, D = y2 - y1;
-    const dot = A * C + B * D;
-    const lenSq = C * C + D * D;
-    let t = lenSq !== 0 ? dot / lenSq : 0;
-    t = clamp(t, 0, 1);
-    const xx = x1 + t * C;
-    const yy = y1 + t * D;
-    best = Math.min(best, Math.hypot(p.x - xx, p.y - yy));
-  }
-  return best;
+  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]);
@@ -736,6 +815,235 @@ function subtractRect2D(A, B) {
   return out.filter((r) => r.width > EPS4 && r.height > EPS4);
 }
 
+// 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 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 isFreeNode = (node) => !node._containsObstacle && !node._containsTarget;
+var isSingletonOuterNode = (node, outerZ) => node.availableZ.length === 1 && node.availableZ[0] === outerZ;
+var sameRect = (a, b) => Math.abs(a.x - b.x) <= EPS4 && Math.abs(a.y - b.y) <= EPS4 && Math.abs(a.width - b.width) <= EPS4 && Math.abs(a.height - b.height) <= EPS4;
+var subtractRects = (target, cutters) => {
+  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 OuterLayerContainmentMergeSolver = class extends BaseSolver3 {
+  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.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(cloneNode);
+    }
+    const topZ = 0;
+    const bottomZ = layerCount - 1;
+    const viaMinSize = Math.max(srj.minViaDiameter ?? 0, srj.minTraceWidth || 0);
+    const originalNodes = this.input.meshNodes.map(cloneNode);
+    const obstaclesByLayer = this.buildObstaclesByLayer(layerCount);
+    const mutableOuterNodes = originalNodes.filter(
+      (node) => isFreeNode(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) => isFreeNode(node) && node.availableZ.includes(topZ)).map(nodeToRect)
+    );
+    freeSupportRectsByOuterLayer.set(
+      bottomZ,
+      originalNodes.filter((node) => isFreeNode(node) && node.availableZ.includes(bottomZ)).map(nodeToRect)
+    );
+    const promotedNodes = [];
+    const promotedRects = [];
+    const candidateNodes = mutableOuterNodes.filter(
+      (node) => node.width + EPS4 >= viaMinSize && node.height + EPS4 >= viaMinSize
+    ).sort((a, b) => rectArea(nodeToRect(b)) - rectArea(nodeToRect(a)));
+    for (const candidate of candidateNodes) {
+      const candidateZ = candidate.availableZ[0];
+      const oppositeZ = candidateZ === topZ ? bottomZ : topZ;
+      const candidateRect = nodeToRect(candidate);
+      const oppositeSupportRects = freeSupportRectsByOuterLayer.get(oppositeZ) ?? [];
+      if (!this.isTransitCompatibleAcrossIntermediateLayers({
+        rect: candidateRect,
+        fromZ: candidateZ,
+        toZ: oppositeZ,
+        obstaclesByLayer
+      })) {
+        continue;
+      }
+      if (!isFullyCoveredByRects(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 = nodeToRect(node);
+      const remainingPieces = subtractRects(nodeRect, promotedRects);
+      if (remainingPieces.length === 1 && sameRect(remainingPieces[0], nodeRect)) {
+        residualNodes.push(node);
+        continue;
+      }
+      for (const piece of remainingPieces) {
+        const residualNode = cloneNodeWithRect(
+          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;
+  }
+  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 (!isFullyCoveredByRects(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 BaseSolver4 } from "@tscircuit/solver-utils";
+
 // lib/solvers/RectDiffSeedingSolver/isPointInPolygon.ts
 function isPointInPolygon(p, polygon) {
   let inside = false;
@@ -842,81 +1150,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;
@@ -1051,17 +1284,10 @@ function maxExpandUp(params) {
   }
   return Math.max(0, e);
 }
-var toRect = (tree) => ({
-  x: tree.minX,
-  y: tree.minY,
-  width: tree.maxX - tree.minX,
-  height: tree.maxY - tree.minY
-});
 var addBlocker = (params) => {
   const { rect, seen, blockers } = params;
-  const key = `${rect.x}|${rect.y}|${rect.width}|${rect.height}`;
-  if (seen.has(key)) return;
-  seen.add(key);
+  if (seen.has(rect)) return;
+  seen.add(rect);
   blockers.push(rect);
 };
 var toQueryRect = (params) => {
@@ -1098,23 +1324,22 @@ function expandRectFromSeed(params) {
       const blockersIndex = obsticalIndexByLayer[z];
       if (blockersIndex) {
         for (const entry of blockersIndex.search(query))
-          addBlocker({ rect: toRect(entry), seen, blockers });
+          addBlocker({ rect: entry, seen, blockers });
       }
       const placedLayer = placedIndexByLayer[z];
       if (placedLayer) {
         for (const entry of placedLayer.search(query)) {
           const isFullStack = entry.zLayers.length >= totalLayers;
           if (!isFullStack) continue;
-          const rect = toRect(entry);
           if (isSelfRect({
-            rect,
+            rect: entry,
             startX,
             startY,
             initialW,
             initialH
           }))
             continue;
-          addBlocker({ rect, seen, blockers });
+          addBlocker({ rect: entry, seen, blockers });
         }
       }
     }
@@ -1205,9 +1430,9 @@ function isFullyOccupiedAtPoint(params) {
   };
   for (let z = 0; z < params.layerCount; z++) {
     const obstacleIdx = params.obstacleIndexByLayer[z];
-    const hasObstacle = !!obstacleIdx && obstacleIdx.search(query).length > 0;
+    const hasObstacle = !!obstacleIdx && obstacleIdx.collides(query);
     const placedIdx = params.placedIndexByLayer[z];
-    const hasPlaced = !!placedIdx && placedIdx.search(query).length > 0;
+    const hasPlaced = !!placedIdx && placedIdx.collides(query);
     if (!hasObstacle && !hasPlaced) return false;
   }
   return true;
@@ -1233,7 +1458,7 @@ function longestFreeSpanAroundZ(params) {
       maxY: y
     };
     const obstacleIdx = obstacleIndexByLayer[layer];
-    if (obstacleIdx && obstacleIdx.search(query).length > 0) return false;
+    if (obstacleIdx && obstacleIdx.collides(query)) return false;
     const extras = additionalBlockersByLayer?.[layer] ?? [];
     return !extras.some((b) => containsPoint(b, { x, y }));
   };
@@ -1265,6 +1490,10 @@ function computeCandidates3D(params) {
     hardPlacedByLayer
   } = params;
   const out = /* @__PURE__ */ new Map();
+  const hardRectsByLayer = Array.from({ length: layerCount }, (_, z) => [
+    ...obstacleIndexByLayer[z]?.all() ?? [],
+    ...hardPlacedByLayer[z] ?? []
+  ]);
   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) {
@@ -1296,14 +1525,11 @@ function computeCandidates3D(params) {
         }
       }
       const anchorZ = bestSpan.length ? bestSpan[Math.floor(bestSpan.length / 2)] : bestZ;
-      const hardAtZ = [
-        ...obstacleIndexByLayer[anchorZ]?.all() ?? [],
-        ...hardPlacedByLayer[anchorZ] ?? []
-      ];
-      const d = Math.min(
-        distancePointToRectEdges({ x, y }, bounds),
-        ...hardAtZ.length ? hardAtZ.map((b) => distancePointToRectEdges({ x, y }, b)) : [Infinity]
-      );
+      const hardAtZ = hardRectsByLayer[anchorZ] ?? [];
+      let d = distancePointToRectEdges({ x, y }, bounds);
+      for (const blocker of hardAtZ) {
+        d = Math.min(d, distancePointToRectEdges({ x, y }, blocker));
+      }
       const distance = quantize2(d);
       const k = `${x.toFixed(6)}|${y.toFixed(6)}`;
       const cand = {
@@ -1328,6 +1554,12 @@ function computeCandidates3D(params) {
 
 // lib/solvers/RectDiffSeedingSolver/computeEdgeCandidates3D.ts
 var quantize3 = (value, precision = 1e-6) => Math.round(value / precision) * precision;
+var toRect = (rect) => "minX" in rect ? {
+  x: rect.minX,
+  y: rect.minY,
+  width: rect.maxX - rect.minX,
+  height: rect.maxY - rect.minY
+} : rect;
 function computeUncoveredSegments(params) {
   const { lineStart, lineEnd, coveringIntervals, minSegmentLength } = params;
   const lineStartQ = quantize3(lineStart);
@@ -1390,6 +1622,13 @@ function computeEdgeCandidates3D(params) {
   const out = [];
   const \u03B4 = Math.max(minSize * 0.15, EPS4 * 3);
   const dedup = /* @__PURE__ */ new Set();
+  const hardRectsByLayer = Array.from(
+    { length: layerCount },
+    (_, z) => [
+      ...obstacleIndexByLayer[z]?.all() ?? [],
+      ...hardPlacedByLayer[z] ?? []
+    ].map(toRect)
+  );
   const key = (p) => `${p.z}|${p.x.toFixed(6)}|${p.y.toFixed(6)}`;
   function fullyOcc(p) {
     return isFullyOccupiedAtPoint({
@@ -1408,19 +1647,11 @@ function computeEdgeCandidates3D(params) {
     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 = [
-      ...obstacleIndexByLayer[z]?.all() ?? [],
-      ...hardPlacedByLayer[z] ?? []
-    ].map((b) => ({
-      x: quantize3(b.x),
-      y: quantize3(b.y),
-      width: quantize3(b.width),
-      height: quantize3(b.height)
-    }));
-    const d = Math.min(
-      distancePointToRectEdges({ x, y }, bounds),
-      ...hard.length ? hard.map((b) => distancePointToRectEdges({ x, y }, b)) : [Infinity]
-    );
+    const hard = hardRectsByLayer[z] ?? [];
+    let d = distancePointToRectEdges({ x, y }, bounds);
+    for (const blocker of hard) {
+      d = Math.min(d, distancePointToRectEdges({ x, y }, blocker));
+    }
     const distance = quantize3(d);
     const k = key({ x, y, z });
     if (dedup.has(k)) return;
@@ -1445,10 +1676,7 @@ function computeEdgeCandidates3D(params) {
     });
   }
   for (let z = 0; z < layerCount; z++) {
-    const blockers = [
-      ...obstacleIndexByLayer[z]?.all() ?? [],
-      ...hardPlacedByLayer[z] ?? []
-    ].map((b) => ({
+    const blockers = (hardRectsByLayer[z] ?? []).map((b) => ({
       x: quantize3(b.x),
       y: quantize3(b.y),
       width: quantize3(b.width),
@@ -1687,7 +1915,7 @@ function resizeSoftOverlaps(params, newIndex) {
       }
     }
   }
-  const sameRect = (a, b) => a.minX === b.minX && a.minY === b.minY && a.maxX === b.maxX && a.maxY === b.maxY;
+  const sameRect2 = (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) {
@@ -1696,7 +1924,7 @@ function resizeSoftOverlaps(params, newIndex) {
         if (tree)
           tree.remove(
             rectToTree(rem.rect, { zLayers: rem.zLayers }),
-            sameRect
+            sameRect2
           );
       }
     }
@@ -1714,27 +1942,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 BaseSolver4 {
   constructor(input) {
     super();
     this.input = input;
   }
+  input;
   // Engine fields (mirrors initState / engine.ts)
   srj;
   layerNames;
@@ -1746,6 +1961,7 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
   candidates;
   placed;
   placedIndexByLayer;
+  hardPlacedByLayer;
   expansionIndex;
   edgeAnalysisDone;
   totalSeedsThisGrid;
@@ -1801,6 +2017,7 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       { length: layerCount },
       () => new RBush3()
     );
+    this.hardPlacedByLayer = Array.from({ length: layerCount }, () => []);
     this.expansionIndex = 0;
     this.edgeAnalysisDone = false;
     this.totalSeedsThisGrid = 0;
@@ -1829,25 +2046,22 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       maxMultiLayerSpan
     } = this.options;
     const grid = gridSizes[this.gridIndex];
-    const hardPlacedByLayer = allLayerNode({
-      layerCount: this.layerCount,
-      placed: this.placed
-    });
     if (this.candidates.length === 0 && this.consumedSeedsThisGrid === 0) {
       this.candidates = computeCandidates3D({
         bounds: this.bounds,
         gridSize: grid,
         layerCount: this.layerCount,
-        hardPlacedByLayer,
+        hardPlacedByLayer: this.hardPlacedByLayer,
         obstacleIndexByLayer: this.input.obstacleIndexByLayer,
         placedIndexByLayer: this.placedIndexByLayer
       });
       this.totalSeedsThisGrid = this.candidates.length;
       this.consumedSeedsThisGrid = 0;
     }
-    if (this.candidates.length === 0) {
+    if (this.consumedSeedsThisGrid >= this.candidates.length) {
       if (this.gridIndex + 1 < gridSizes.length) {
         this.gridIndex += 1;
+        this.candidates = [];
         this.totalSeedsThisGrid = 0;
         this.consumedSeedsThisGrid = 0;
         return;
@@ -1860,20 +2074,28 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
             layerCount: this.layerCount,
             obstacleIndexByLayer: this.input.obstacleIndexByLayer,
             placedIndexByLayer: this.placedIndexByLayer,
-            hardPlacedByLayer
+            hardPlacedByLayer: this.hardPlacedByLayer
           });
           this.edgeAnalysisDone = true;
           this.totalSeedsThisGrid = this.candidates.length;
           this.consumedSeedsThisGrid = 0;
           return;
         }
+        this.candidates = [];
         this.solved = true;
         this.expansionIndex = 0;
         return;
       }
     }
-    const cand = this.candidates.shift();
-    this.consumedSeedsThisGrid += 1;
+    const cand = this.candidates[this.consumedSeedsThisGrid++];
+    if (isFullyOccupiedAtPoint({
+      layerCount: this.layerCount,
+      obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+      placedIndexByLayer: this.placedIndexByLayer,
+      point: { x: cand.x, y: cand.y }
+    })) {
+      return;
+    }
     const span = longestFreeSpanAroundZ({
       x: cand.x,
       y: cand.y,
@@ -1882,7 +2104,7 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       minSpan: minMulti.minLayers,
       maxSpan: maxMultiLayerSpan,
       obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-      additionalBlockersByLayer: hardPlacedByLayer
+      additionalBlockersByLayer: this.hardPlacedByLayer
     });
     const attempts = [];
     if (span.length >= minMulti.minLayers) {
@@ -1929,14 +2151,10 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
         },
         newIndex
       );
-      this.candidates = this.candidates.filter(
-        (c) => !isFullyOccupiedAtPoint({
-          layerCount: this.layerCount,
-          obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-          placedIndexByLayer: this.placedIndexByLayer,
-          point: { x: c.x, y: c.y }
-        })
-      );
+      this.hardPlacedByLayer = allLayerNode({
+        layerCount: this.layerCount,
+        placed: this.placed
+      });
       return;
     }
   }
@@ -2085,7 +2303,7 @@ z:${placement.zLayers.join(",")}`
 };
 
 // lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts
-import { BaseSolver as BaseSolver4 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver5 } from "@tscircuit/solver-utils";
 
 // lib/utils/finalizeRects.ts
 function finalizeRects(params) {
@@ -2157,11 +2375,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 BaseSolver5 {
   constructor(input) {
     super();
     this.input = input;
   }
+  input;
   placedIndexByLayer = [];
   _meshNodes = [];
   _setup() {
@@ -2302,19 +2521,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({
@@ -2658,6 +2864,7 @@ import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
 var RectDiffPipeline = class extends BasePipelineSolver3 {
   rectDiffGridSolverPipeline;
   gapFillSolver;
+  outerLayerContainmentMergeSolver;
   boardVoidRects;
   zIndexByName;
   layerNames;
@@ -2693,6 +2900,18 @@ 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
+        }
+      ]
     )
   ];
   _setup() {
@@ -2718,6 +2937,10 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
     return [this.inputProblem];
   }
   getOutput() {
+    const outerLayerMergeOutput = this.outerLayerContainmentMergeSolver?.getOutput();
+    if (outerLayerMergeOutput) {
+      return { meshNodes: outerLayerMergeOutput.outputNodes };
+    }
     const gapFillOutput = this.gapFillSolver?.getOutput();
     if (gapFillOutput) {
       return { meshNodes: gapFillOutput.outputNodes };