@tscircuit/rectdiff 0.0.25 → 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));
@@ -730,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;
@@ -836,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;
@@ -1676,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) {
@@ -1685,7 +1924,7 @@ function resizeSoftOverlaps(params, newIndex) {
         if (tree)
           tree.remove(
             rectToTree(rem.rect, { zLayers: rem.zLayers }),
-            sameRect
+            sameRect2
           );
       }
     }
@@ -1703,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;
@@ -2077,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) {
@@ -2149,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() {
@@ -2294,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({
@@ -2650,6 +2864,7 @@ import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
 var RectDiffPipeline = class extends BasePipelineSolver3 {
   rectDiffGridSolverPipeline;
   gapFillSolver;
+  outerLayerContainmentMergeSolver;
   boardVoidRects;
   zIndexByName;
   layerNames;
@@ -2685,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() {
@@ -2710,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 };

package/lib/RectDiffPipeline.ts

@@ -8,6 +8,7 @@ import type { GridFill3DOptions, XYRect } from "./rectdiff-types"
 import type { CapacityMeshNode } from "./types/capacity-mesh-types"
 import type { GraphicsObject } from "graphics-debug"
 import { GapFillSolverPipeline } from "./solvers/GapFillSolver/GapFillSolverPipeline"
+import { OuterLayerContainmentMergeSolver } from "./solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver"
 import { RectDiffGridSolverPipeline } from "./solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline"
 import { createBaseVisualization } from "./rectdiff-visualization"
 import { buildFinalRectDiffVisualization } from "./buildFinalRectDiffVisualization"
@@ -25,6 +26,7 @@ export interface RectDiffPipelineInput {
 export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
   rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline
   gapFillSolver?: GapFillSolverPipeline
+  outerLayerContainmentMergeSolver?: OuterLayerContainmentMergeSolver
   boardVoidRects: XYRect[] | undefined
   zIndexByName?: Map<string, number>
   layerNames?: string[]
@@ -69,6 +71,22 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
         },
       ],
     ),
+    definePipelineStep(
+      "outerLayerContainmentMergeSolver",
+      OuterLayerContainmentMergeSolver,
+      (rectDiffPipeline: RectDiffPipeline) => [
+        {
+          meshNodes:
+            rectDiffPipeline.gapFillSolver?.getOutput().outputNodes ??
+            rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput()
+              .meshNodes ??
+            [],
+          simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
+          zIndexByName: rectDiffPipeline.zIndexByName ?? new Map(),
+          obstacleClearance: rectDiffPipeline.inputProblem.obstacleClearance,
+        },
+      ],
+    ),
   ]
 
   override _setup(): void {
@@ -100,6 +118,11 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
   }
 
   override getOutput(): { meshNodes: CapacityMeshNode[] } {
+    const outerLayerMergeOutput =
+      this.outerLayerContainmentMergeSolver?.getOutput()
+    if (outerLayerMergeOutput) {
+      return { meshNodes: outerLayerMergeOutput.outputNodes }
+    }
     const gapFillOutput = this.gapFillSolver?.getOutput()
     if (gapFillOutput) {
       return { meshNodes: gapFillOutput.outputNodes }