@tscircuit/rectdiff 0.0.13 → 0.0.14

package/dist/index.js

@@ -1038,12 +1038,20 @@ function computeDefaultGridSizes(bounds) {
 }
 
 // lib/utils/isFullyOccupiedAtPoint.ts
-function isFullyOccupiedAtPoint(params, point) {
+import "rbush";
+function isFullyOccupiedAtPoint(params) {
+  const query = {
+    minX: params.point.x,
+    minY: params.point.y,
+    maxX: params.point.x,
+    maxY: params.point.y
+  };
   for (let z = 0; z < params.layerCount; z++) {
-    const obs = params.obstaclesByLayer[z] ?? [];
-    const placed = params.placedByLayer[z] ?? [];
-    const occ = obs.some((b) => containsPoint(b, point)) || placed.some((b) => containsPoint(b, point));
-    if (!occ) return false;
+    const obstacleIdx = params.obstacleIndexByLayer[z];
+    const hasObstacle = !!obstacleIdx && obstacleIdx.search(query).length > 0;
+    const placedIdx = params.placedIndexByLayer[z];
+    const hasPlaced = !!placedIdx && placedIdx.search(query).length > 0;
+    if (!hasObstacle && !hasPlaced) return false;
   }
   return true;
 }
@@ -1057,15 +1065,20 @@ function longestFreeSpanAroundZ(params) {
     layerCount,
     minSpan,
     maxSpan,
-    obstaclesByLayer,
-    placedByLayer
+    obstacleIndexByLayer,
+    additionalBlockersByLayer
   } = params;
   const isFreeAt = (layer) => {
-    const blockers = [
-      ...obstaclesByLayer[layer] ?? [],
-      ...placedByLayer[layer] ?? []
-    ];
-    return !blockers.some((b) => containsPoint(b, { x, y }));
+    const query = {
+      minX: x,
+      minY: y,
+      maxX: x,
+      maxY: y
+    };
+    const obstacleIdx = obstacleIndexByLayer[layer];
+    if (obstacleIdx && obstacleIdx.search(query).length > 0) return false;
+    const extras = additionalBlockersByLayer?.[layer] ?? [];
+    return !extras.some((b) => containsPoint(b, { x, y }));
   };
   let lo = z;
   let hi = z;
@@ -1089,8 +1102,8 @@ function computeCandidates3D(params) {
     bounds,
     gridSize,
     layerCount,
-    obstaclesByLayer,
-    placedByLayer,
+    obstacleIndexByLayer,
+    placedIndexByLayer,
     hardPlacedByLayer
   } = params;
   const out = /* @__PURE__ */ new Map();
@@ -1099,14 +1112,12 @@ function computeCandidates3D(params) {
       if (Math.abs(x - bounds.x) < EPS4 || Math.abs(y - bounds.y) < EPS4 || x > bounds.x + bounds.width - gridSize - EPS4 || y > bounds.y + bounds.height - gridSize - EPS4) {
         continue;
       }
-      if (isFullyOccupiedAtPoint(
-        {
-          layerCount,
-          obstaclesByLayer,
-          placedByLayer
-        },
-        { x, y }
-      ))
+      if (isFullyOccupiedAtPoint({
+        layerCount,
+        obstacleIndexByLayer,
+        placedIndexByLayer,
+        point: { x, y }
+      }))
         continue;
       let bestSpan = [];
       let bestZ = 0;
@@ -1118,8 +1129,8 @@ function computeCandidates3D(params) {
           layerCount,
           minSpan: 1,
           maxSpan: void 0,
-          obstaclesByLayer,
-          placedByLayer: hardPlacedByLayer
+          obstacleIndexByLayer,
+          additionalBlockersByLayer: hardPlacedByLayer
         });
         if (s.length > bestSpan.length) {
           bestSpan = s;
@@ -1128,7 +1139,7 @@ function computeCandidates3D(params) {
       }
       const anchorZ = bestSpan.length ? bestSpan[Math.floor(bestSpan.length / 2)] : bestZ;
       const hardAtZ = [
-        ...obstaclesByLayer[anchorZ] ?? [],
+        ...obstacleIndexByLayer[anchorZ]?.all() ?? [],
         ...hardPlacedByLayer[anchorZ] ?? []
       ];
       const d = Math.min(
@@ -1203,8 +1214,8 @@ function computeEdgeCandidates3D(params) {
     bounds,
     minSize,
     layerCount,
-    obstaclesByLayer,
-    placedByLayer,
+    obstacleIndexByLayer,
+    placedIndexByLayer,
     hardPlacedByLayer
   } = params;
   const out = [];
@@ -1212,14 +1223,12 @@ function computeEdgeCandidates3D(params) {
   const dedup = /* @__PURE__ */ new Set();
   const key = (p) => `${p.z}|${p.x.toFixed(6)}|${p.y.toFixed(6)}`;
   function fullyOcc(p) {
-    return isFullyOccupiedAtPoint(
-      {
-        layerCount,
-        obstaclesByLayer,
-        placedByLayer
-      },
-      p
-    );
+    return isFullyOccupiedAtPoint({
+      layerCount,
+      obstacleIndexByLayer,
+      placedIndexByLayer,
+      point: p
+    });
   }
   function pushIfFree(p) {
     const { x, y, z } = p;
@@ -1227,7 +1236,7 @@ function computeEdgeCandidates3D(params) {
       return;
     if (fullyOcc({ x, y })) return;
     const hard = [
-      ...obstaclesByLayer[z] ?? [],
+      ...obstacleIndexByLayer[z]?.all() ?? [],
       ...hardPlacedByLayer[z] ?? []
     ];
     const d = Math.min(
@@ -1244,14 +1253,14 @@ function computeEdgeCandidates3D(params) {
       layerCount,
       minSpan: 1,
       maxSpan: void 0,
-      obstaclesByLayer,
-      placedByLayer: hardPlacedByLayer
+      obstacleIndexByLayer,
+      additionalBlockersByLayer: hardPlacedByLayer
     });
     out.push({ x, y, z, distance: d, zSpanLen: span.length, isEdgeSeed: true });
   }
   for (let z = 0; z < layerCount; z++) {
     const blockers = [
-      ...obstaclesByLayer[z] ?? [],
+      ...obstacleIndexByLayer[z]?.all() ?? [],
       ...hardPlacedByLayer[z] ?? []
     ];
     const corners = [
@@ -1475,21 +1484,44 @@ function resizeSoftOverlaps(params, newIndex) {
       }
     }
   }
+  const rectToTree2 = (rect) => ({
+    ...rect,
+    minX: rect.x,
+    minY: rect.y,
+    maxX: rect.x + rect.width,
+    maxY: rect.y + rect.height
+  });
+  const sameRect = (a, b) => a.minX === b.minX && a.minY === b.minY && a.maxX === b.maxX && a.maxY === b.maxY;
   removeIdx.sort((a, b) => b - a).forEach((idx) => {
     const rem = params.placed.splice(idx, 1)[0];
-    for (const z of rem.zLayers) {
-      const arr = params.placedByLayer[z];
-      const j = arr.findIndex((r) => r === rem.rect);
-      if (j >= 0) arr.splice(j, 1);
+    if (params.placedIndexByLayer) {
+      for (const z of rem.zLayers) {
+        const tree = params.placedIndexByLayer[z];
+        if (tree) tree.remove(rectToTree2(rem.rect), sameRect);
+      }
     }
   });
   for (const p of toAdd) {
     params.placed.push(p);
-    for (const z of p.zLayers) params.placedByLayer[z].push(p.rect);
+    for (const z of p.zLayers) {
+      if (params.placedIndexByLayer) {
+        const idx = params.placedIndexByLayer[z];
+        if (idx) {
+          idx.insert({
+            ...p.rect,
+            minX: p.rect.x,
+            minY: p.rect.y,
+            maxX: p.rect.x + p.rect.width,
+            maxY: p.rect.y + p.rect.height
+          });
+        }
+      }
+    }
   }
 }
 
 // lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts
+import RBush3 from "rbush";
 var RectDiffSeedingSolver = class extends BaseSolver3 {
   constructor(input) {
     super();
@@ -1501,12 +1533,11 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
   layerCount;
   bounds;
   options;
-  obstaclesByLayer;
   boardVoidRects;
   gridIndex;
   candidates;
   placed;
-  placedByLayer;
+  placedIndexByLayer;
   expansionIndex;
   edgeAnalysisDone;
   totalSeedsThisGrid;
@@ -1522,34 +1553,6 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       width: srj.bounds.maxX - srj.bounds.minX,
       height: srj.bounds.maxY - srj.bounds.minY
     };
-    const obstaclesByLayer = Array.from(
-      { length: layerCount },
-      () => []
-    );
-    let boardVoidRects = [];
-    if (srj.outline && srj.outline.length > 2) {
-      boardVoidRects = computeInverseRects(bounds, srj.outline);
-      for (const voidR of boardVoidRects) {
-        for (let z = 0; z < layerCount; z++) {
-          obstaclesByLayer[z].push(voidR);
-        }
-      }
-    }
-    for (const obstacle of srj.obstacles ?? []) {
-      const rect = obstacleToXYRect(obstacle);
-      if (!rect) continue;
-      const zLayers = obstacleZs(obstacle, zIndexByName);
-      const invalidZs = zLayers.filter((z) => z < 0 || z >= layerCount);
-      if (invalidZs.length) {
-        throw new Error(
-          `RectDiff: obstacle uses z-layer indices ${invalidZs.join(",")} outside 0-${layerCount - 1}`
-        );
-      }
-      if ((!obstacle.zLayers || obstacle.zLayers.length === 0) && zLayers.length) {
-        obstacle.zLayers = zLayers;
-      }
-      for (const z of zLayers) obstaclesByLayer[z].push(rect);
-    }
     const trace = Math.max(0.01, srj.minTraceWidth || 0.15);
     const defaults = {
       gridSizes: [],
@@ -1570,21 +1573,19 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       gridSizes: opts.gridSizes ?? // re-use the helper that was previously in engine
       computeDefaultGridSizes(bounds)
     };
-    const placedByLayer = Array.from(
-      { length: layerCount },
-      () => []
-    );
     this.srj = srj;
     this.layerNames = layerNames;
     this.layerCount = layerCount;
     this.bounds = bounds;
     this.options = options;
-    this.obstaclesByLayer = obstaclesByLayer;
-    this.boardVoidRects = boardVoidRects;
+    this.boardVoidRects = this.input.boardVoidRects;
     this.gridIndex = 0;
     this.candidates = [];
     this.placed = [];
-    this.placedByLayer = placedByLayer;
+    this.placedIndexByLayer = Array.from(
+      { length: layerCount },
+      () => new RBush3()
+    );
     this.expansionIndex = 0;
     this.edgeAnalysisDone = false;
     this.totalSeedsThisGrid = 0;
@@ -1622,9 +1623,9 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
         bounds: this.bounds,
         gridSize: grid,
         layerCount: this.layerCount,
-        obstaclesByLayer: this.obstaclesByLayer,
-        placedByLayer: this.placedByLayer,
-        hardPlacedByLayer
+        hardPlacedByLayer,
+        obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+        placedIndexByLayer: this.placedIndexByLayer
       });
       this.totalSeedsThisGrid = this.candidates.length;
       this.consumedSeedsThisGrid = 0;
@@ -1642,8 +1643,8 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
             bounds: this.bounds,
             minSize,
             layerCount: this.layerCount,
-            obstaclesByLayer: this.obstaclesByLayer,
-            placedByLayer: this.placedByLayer,
+            obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+            placedIndexByLayer: this.placedIndexByLayer,
             hardPlacedByLayer
           });
           this.edgeAnalysisDone = true;
@@ -1665,8 +1666,8 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       layerCount: this.layerCount,
       minSpan: minMulti.minLayers,
       maxSpan: maxMultiLayerSpan,
-      obstaclesByLayer: this.obstaclesByLayer,
-      placedByLayer: hardPlacedByLayer
+      obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+      additionalBlockersByLayer: hardPlacedByLayer
     });
     const attempts = [];
     if (span.length >= minMulti.minLayers) {
@@ -1685,8 +1686,8 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
     for (const attempt of ordered) {
       const hardBlockers = [];
       for (const z of attempt.layers) {
-        if (this.obstaclesByLayer[z])
-          hardBlockers.push(...this.obstaclesByLayer[z]);
+        const obstacleLayer = this.input.obstacleIndexByLayer[z];
+        if (obstacleLayer) hardBlockers.push(...obstacleLayer.all());
         if (hardPlacedByLayer[z]) hardBlockers.push(...hardPlacedByLayer[z]);
       }
       const rect = expandRectFromSeed({
@@ -1702,25 +1703,34 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       if (!rect) continue;
       const placed = { rect, zLayers: [...attempt.layers] };
       const newIndex = this.placed.push(placed) - 1;
-      for (const z of attempt.layers) this.placedByLayer[z].push(rect);
+      for (const z of attempt.layers) {
+        const idx = this.placedIndexByLayer[z];
+        if (idx) {
+          idx.insert({
+            ...rect,
+            minX: rect.x,
+            minY: rect.y,
+            maxX: rect.x + rect.width,
+            maxY: rect.y + rect.height
+          });
+        }
+      }
       resizeSoftOverlaps(
         {
           layerCount: this.layerCount,
           placed: this.placed,
-          placedByLayer: this.placedByLayer,
-          options: this.options
+          options: this.options,
+          placedIndexByLayer: this.placedIndexByLayer
         },
         newIndex
       );
       this.candidates = this.candidates.filter(
-        (c) => !isFullyOccupiedAtPoint(
-          {
-            layerCount: this.layerCount,
-            obstaclesByLayer: this.obstaclesByLayer,
-            placedByLayer: this.placedByLayer
-          },
-          { x: c.x, y: c.y }
-        )
+        (c) => !isFullyOccupiedAtPoint({
+          layerCount: this.layerCount,
+          obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+          placedIndexByLayer: this.placedIndexByLayer,
+          point: { x: c.x, y: c.y }
+        })
       );
       return;
     }
@@ -1748,12 +1758,10 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       layerCount: this.layerCount,
       bounds: this.bounds,
       options: this.options,
-      obstaclesByLayer: this.obstaclesByLayer,
       boardVoidRects: this.boardVoidRects,
       gridIndex: this.gridIndex,
       candidates: this.candidates,
       placed: this.placed,
-      placedByLayer: this.placedByLayer,
       expansionIndex: this.expansionIndex,
       edgeAnalysisDone: this.edgeAnalysisDone,
       totalSeedsThisGrid: this.totalSeedsThisGrid,
@@ -1897,23 +1905,27 @@ function finalizeRects(params) {
     maxY: p.rect.y + p.rect.height,
     zLayers: [...p.zLayers].sort((a, b) => a - b)
   }));
-  const layersByObstacleRect = /* @__PURE__ */ new Map();
-  params.obstaclesByLayer.forEach((layerObs, z) => {
-    for (const rect of layerObs) {
-      const layerIndices = layersByObstacleRect.get(rect) ?? [];
-      layerIndices.push(z);
-      layersByObstacleRect.set(rect, layerIndices);
-    }
-  });
-  const voidSet = new Set(params.boardVoidRects || []);
-  for (const [rect, layerIndices] of layersByObstacleRect.entries()) {
-    if (voidSet.has(rect)) continue;
+  const { zIndexByName } = buildZIndexMap(params.srj);
+  const layersByKey = /* @__PURE__ */ new Map();
+  for (const obstacle of params.srj.obstacles ?? []) {
+    const rect = obstacleToXYRect(obstacle);
+    if (!rect) continue;
+    const zLayers = obstacle.zLayers?.length && obstacle.zLayers.length > 0 ? obstacle.zLayers : obstacleZs(obstacle, zIndexByName);
+    const key = `${rect.x}:${rect.y}:${rect.width}:${rect.height}`;
+    let entry = layersByKey.get(key);
+    if (!entry) {
+      entry = { rect, layers: /* @__PURE__ */ new Set() };
+      layersByKey.set(key, entry);
+    }
+    zLayers.forEach((layer) => entry.layers.add(layer));
+  }
+  for (const { rect, layers } of layersByKey.values()) {
     out.push({
       minX: rect.x,
       minY: rect.y,
       maxX: rect.x + rect.width,
       maxY: rect.y + rect.height,
-      zLayers: layerIndices.sort((a, b) => a - b),
+      zLayers: Array.from(layers).sort((a, b) => a - b),
       isObstacle: true
     });
   }
@@ -1942,6 +1954,21 @@ function rectsToMeshNodes(rects) {
   return out;
 }
 
+// lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts
+import RBush4 from "rbush";
+
+// lib/utils/rectToTree.ts
+var rectToTree = (rect) => ({
+  ...rect,
+  minX: rect.x,
+  minY: rect.y,
+  maxX: rect.x + rect.width,
+  maxY: rect.y + rect.height
+});
+
+// lib/utils/sameTreeRect.ts
+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 {
   constructor(input) {
@@ -1955,12 +1982,11 @@ var RectDiffExpansionSolver = class extends BaseSolver4 {
   layerCount;
   bounds;
   options;
-  obstaclesByLayer;
   boardVoidRects;
   gridIndex;
   candidates;
   placed;
-  placedByLayer;
+  placedIndexByLayer;
   expansionIndex;
   edgeAnalysisDone;
   totalSeedsThisGrid;
@@ -1970,6 +1996,39 @@ var RectDiffExpansionSolver = class extends BaseSolver4 {
     this.stats = {
       gridIndex: this.gridIndex
     };
+    if (this.input.obstacleIndexByLayer) {
+    } else {
+      const { zIndexByName } = buildZIndexMap(this.srj);
+      this.input.obstacleIndexByLayer = Array.from(
+        { length: this.layerCount },
+        () => new RBush4()
+      );
+      const insertObstacle = (rect, z) => {
+        const tree = this.input.obstacleIndexByLayer[z];
+        if (tree) tree.insert(rectToTree(rect));
+      };
+      for (const voidRect of this.boardVoidRects ?? []) {
+        for (let z = 0; z < this.layerCount; z++) insertObstacle(voidRect, z);
+      }
+      for (const obstacle of this.srj.obstacles ?? []) {
+        const rect = obstacleToXYRect(obstacle);
+        if (!rect) continue;
+        const zLayers = obstacle.zLayers?.length && obstacle.zLayers.length > 0 ? obstacle.zLayers : obstacleZs(obstacle, zIndexByName);
+        zLayers.forEach((z) => {
+          if (z >= 0 && z < this.layerCount) insertObstacle(rect, z);
+        });
+      }
+    }
+    this.placedIndexByLayer = Array.from(
+      { length: this.layerCount },
+      () => new RBush4()
+    );
+    for (const placement of this.placed ?? []) {
+      for (const z of placement.zLayers) {
+        const tree = this.placedIndexByLayer[z];
+        if (tree) tree.insert(rectToTree(placement.rect));
+      }
+    }
   }
   _step() {
     if (this.solved) return;
@@ -1993,7 +2052,8 @@ var RectDiffExpansionSolver = class extends BaseSolver4 {
     });
     const hardBlockers = [];
     for (const z of p.zLayers) {
-      hardBlockers.push(...this.obstaclesByLayer[z] ?? []);
+      const obstacleTree = this.input.obstacleIndexByLayer[z];
+      if (obstacleTree) hardBlockers.push(...obstacleTree.all());
       hardBlockers.push(...hardPlacedByLayer[z] ?? []);
     }
     const oldRect = p.rect;
@@ -2010,16 +2070,18 @@ var RectDiffExpansionSolver = class extends BaseSolver4 {
     if (expanded) {
       this.placed[idx] = { rect: expanded, zLayers: p.zLayers };
       for (const z of p.zLayers) {
-        const arr = this.placedByLayer[z];
-        const j = arr.findIndex((r) => r === oldRect);
-        if (j >= 0) arr[j] = expanded;
+        const tree = this.placedIndexByLayer[z];
+        if (tree) {
+          tree.remove(rectToTree(oldRect), sameTreeRect);
+          tree.insert(rectToTree(expanded));
+        }
       }
       resizeSoftOverlaps(
         {
           layerCount: this.layerCount,
           placed: this.placed,
-          placedByLayer: this.placedByLayer,
-          options: this.options
+          options: this.options,
+          placedIndexByLayer: this.placedIndexByLayer
         },
         idx
       );
@@ -2030,7 +2092,7 @@ var RectDiffExpansionSolver = class extends BaseSolver4 {
     if (this.solved) return;
     const rects = finalizeRects({
       placed: this.placed,
-      obstaclesByLayer: this.obstaclesByLayer,
+      srj: this.srj,
       boardVoidRects: this.boardVoidRects
     });
     this._meshNodes = rectsToMeshNodes(rects);
@@ -2078,10 +2140,73 @@ z:${placement.zLayers.join(",")}`
   }
 };
 
+// lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts
+import "rbush";
+
+// lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts
+import RBush5 from "rbush";
+var buildObstacleIndexes = (srj) => {
+  const { layerNames, zIndexByName } = buildZIndexMap(srj);
+  const layerCount = Math.max(1, layerNames.length, srj.layerCount || 1);
+  const bounds = {
+    x: srj.bounds.minX,
+    y: srj.bounds.minY,
+    width: srj.bounds.maxX - srj.bounds.minX,
+    height: srj.bounds.maxY - srj.bounds.minY
+  };
+  const obstacleIndexByLayer = Array.from(
+    { length: layerCount },
+    () => new RBush5()
+  );
+  const insertObstacle = (rect, z) => {
+    const treeRect = {
+      ...rect,
+      minX: rect.x,
+      minY: rect.y,
+      maxX: rect.x + rect.width,
+      maxY: rect.y + rect.height
+    };
+    obstacleIndexByLayer[z]?.insert(treeRect);
+  };
+  let boardVoidRects = [];
+  if (srj.outline && srj.outline.length > 2) {
+    boardVoidRects = computeInverseRects(bounds, srj.outline);
+    for (const voidRect of boardVoidRects) {
+      for (let z = 0; z < layerCount; z++) insertObstacle(voidRect, z);
+    }
+  }
+  for (const obstacle of srj.obstacles ?? []) {
+    const rect = obstacleToXYRect(obstacle);
+    if (!rect) continue;
+    const zLayers = obstacleZs(obstacle, zIndexByName);
+    const invalidZs = zLayers.filter((z) => z < 0 || z >= layerCount);
+    if (invalidZs.length) {
+      throw new Error(
+        `RectDiff: obstacle uses z-layer indices ${invalidZs.join(",")} outside 0-${layerCount - 1}`
+      );
+    }
+    if ((!obstacle.zLayers || obstacle.zLayers.length === 0) && zLayers.length) {
+      obstacle.zLayers = zLayers;
+    }
+    for (const z of zLayers) insertObstacle(rect, z);
+  }
+  return { obstacleIndexByLayer, boardVoidRects };
+};
+
 // lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts
 var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
   rectDiffSeedingSolver;
   rectDiffExpansionSolver;
+  boardVoidRects;
+  obstacleIndexByLayer;
+  constructor(inputProblem) {
+    super(inputProblem);
+    const { obstacleIndexByLayer, boardVoidRects } = buildObstacleIndexes(
+      inputProblem.simpleRouteJson
+    );
+    this.obstacleIndexByLayer = obstacleIndexByLayer;
+    this.boardVoidRects = boardVoidRects;
+  }
   pipelineDef = [
     definePipelineStep2(
       "rectDiffSeedingSolver",
@@ -2089,7 +2214,9 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
       (pipeline) => [
         {
           simpleRouteJson: pipeline.inputProblem.simpleRouteJson,
-          gridOptions: pipeline.inputProblem.gridOptions
+          gridOptions: pipeline.inputProblem.gridOptions,
+          obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
+          boardVoidRects: pipeline.boardVoidRects
         }
       ]
     ),
@@ -2098,7 +2225,11 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
       RectDiffExpansionSolver,
       (pipeline) => [
         {
-          initialSnapshot: pipeline.rectDiffSeedingSolver.getOutput()
+          initialSnapshot: {
+            ...pipeline.rectDiffSeedingSolver.getOutput(),
+            boardVoidRects: pipeline.boardVoidRects ?? []
+          },
+          obstacleIndexByLayer: pipeline.obstacleIndexByLayer
         }
       ]
     )