@tscircuit/rectdiff 0.0.12 → 0.0.14

package/dist/index.js

@@ -1,612 +1,721 @@
 // lib/RectDiffPipeline.ts
 import {
   BasePipelineSolver as BasePipelineSolver3,
-  definePipelineStep as definePipelineStep2
+  definePipelineStep as definePipelineStep3
+} from "@tscircuit/solver-utils";
+
+// lib/solvers/GapFillSolver/GapFillSolverPipeline.ts
+import {
+  BasePipelineSolver,
+  definePipelineStep
 } from "@tscircuit/solver-utils";
 
-// lib/solvers/RectDiffSolver.ts
+// lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts
 import { BaseSolver } from "@tscircuit/solver-utils";
+import Flatbush from "flatbush";
 
-// lib/solvers/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, x, y) {
-  return x >= r.x - EPS && x <= r.x + r.width + EPS && y >= r.y - EPS && y <= r.y + r.height + EPS;
-}
-function distancePointToRectEdges(px, py, 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 = px - x1, B = py - 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(px - xx, py - yy));
+// lib/solvers/GapFillSolver/projectToUncoveredSegments.ts
+var EPS = 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;
+  if (!isHorizontal && !isVertical) return [];
+  const axis = isHorizontal ? "x" : "y";
+  const perp = isHorizontal ? "y" : "x";
+  const lineCoord = primaryEdge.start[perp];
+  const p0 = primaryEdge.start[axis];
+  const p1 = primaryEdge.end[axis];
+  const pMin = Math.min(p0, p1);
+  const pMax = Math.max(p0, p1);
+  const clamp2 = (v) => Math.max(pMin, Math.min(pMax, v));
+  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;
+    if (axis === "x" && !eIsHorizontal) continue;
+    if (axis === "y" && !eIsVertical) continue;
+    if (Math.abs(e.start[perp] - lineCoord) > EPS) continue;
+    const eMin = Math.min(e.start[axis], e.end[axis]);
+    const eMax = Math.max(e.start[axis], e.end[axis]);
+    const s = clamp2(eMin);
+    const t = clamp2(eMax);
+    if (t - s > EPS) intervals.push({ s, e: t });
   }
-  return best;
-}
-function maxExpandRight(r, bounds, blockers, maxAspect) {
-  let maxWidth = bounds.x + bounds.width - r.x;
-  for (const b of blockers) {
-    const verticallyOverlaps = r.y + r.height > b.y + EPS && b.y + b.height > r.y + EPS;
-    if (verticallyOverlaps) {
-      if (gte(b.x, r.x + r.width)) {
-        maxWidth = Math.min(maxWidth, b.x - r.x);
-      } else if (b.x + b.width > r.x + r.width - EPS && b.x < r.x + r.width + EPS) {
-        return 0;
+  if (intervals.length === 0) {
+    return [
+      {
+        ...primaryEdge,
+        start: { ...primaryEdge.start },
+        end: { ...primaryEdge.end }
       }
-    }
-  }
-  let e = Math.max(0, maxWidth - r.width);
-  if (e <= 0) return 0;
-  if (maxAspect != null) {
-    const w = r.width, h = r.height;
-    if (w >= h) e = Math.min(e, maxAspect * h - w);
+    ];
   }
-  return Math.max(0, e);
-}
-function maxExpandDown(r, bounds, blockers, maxAspect) {
-  let maxHeight = bounds.y + bounds.height - r.y;
-  for (const b of blockers) {
-    const horizOverlaps = r.x + r.width > b.x + EPS && b.x + b.width > r.x + EPS;
-    if (horizOverlaps) {
-      if (gte(b.y, r.y + r.height)) {
-        maxHeight = Math.min(maxHeight, b.y - r.y);
-      } else if (b.y + b.height > r.y + r.height - EPS && b.y < r.y + r.height + EPS) {
-        return 0;
-      }
-    }
+  intervals.sort((a, b) => a.s - b.s);
+  const merged = [];
+  for (const it of intervals) {
+    const last = merged[merged.length - 1];
+    if (!last || it.s > last.e + EPS) merged.push({ ...it });
+    else last.e = Math.max(last.e, it.e);
   }
-  let e = Math.max(0, maxHeight - r.height);
-  if (e <= 0) return 0;
-  if (maxAspect != null) {
-    const w = r.width, h = r.height;
-    if (h >= w) e = Math.min(e, maxAspect * w - h);
+  const uncovered = [];
+  let cursor = pMin;
+  for (const m of merged) {
+    if (m.s > cursor + EPS) uncovered.push({ s: cursor, e: m.s });
+    cursor = Math.max(cursor, m.e);
+    if (cursor >= pMax - EPS) break;
   }
-  return Math.max(0, e);
+  if (pMax > cursor + EPS) uncovered.push({ s: cursor, e: pMax });
+  if (uncovered.length === 0) return [];
+  return uncovered.filter((u) => u.e - u.s > EPS).map((u) => {
+    const start = axis === "x" ? { x: u.s, y: lineCoord } : { x: lineCoord, y: u.s };
+    const end = axis === "x" ? { x: u.e, y: lineCoord } : { x: lineCoord, y: u.e };
+    return {
+      parent: primaryEdge.parent,
+      facingDirection: primaryEdge.facingDirection,
+      start,
+      end,
+      z: primaryEdge.z
+    };
+  });
 }
-function maxExpandLeft(r, bounds, blockers, maxAspect) {
-  let minX = bounds.x;
-  for (const b of blockers) {
-    const verticallyOverlaps = r.y + r.height > b.y + EPS && b.y + b.height > r.y + EPS;
-    if (verticallyOverlaps) {
-      if (lte(b.x + b.width, r.x)) {
-        minX = Math.max(minX, b.x + b.width);
-      } else if (b.x < r.x + EPS && b.x + b.width > r.x - EPS) {
-        return 0;
-      }
-    }
+
+// lib/solvers/GapFillSolver/edge-constants.ts
+var EDGES = [
+  {
+    facingDirection: "x-",
+    dx: -1,
+    dy: 0,
+    startX: -0.5,
+    startY: 0.5,
+    endX: -0.5,
+    endY: -0.5
+  },
+  {
+    facingDirection: "x+",
+    dx: 1,
+    dy: 0,
+    startX: 0.5,
+    startY: 0.5,
+    endX: 0.5,
+    endY: -0.5
+  },
+  {
+    facingDirection: "y-",
+    dx: 0,
+    dy: -1,
+    startX: -0.5,
+    startY: -0.5,
+    endX: 0.5,
+    endY: -0.5
+  },
+  {
+    facingDirection: "y+",
+    dx: 0,
+    dy: 1,
+    startX: 0.5,
+    startY: 0.5,
+    endX: -0.5,
+    endY: 0.5
   }
-  let e = Math.max(0, r.x - minX);
-  if (e <= 0) return 0;
-  if (maxAspect != null) {
-    const w = r.width, h = r.height;
-    if (w >= h) e = Math.min(e, maxAspect * h - w);
+];
+var EDGE_MAP = {
+  "x-": EDGES.find((e) => e.facingDirection === "x-"),
+  "x+": EDGES.find((e) => e.facingDirection === "x+"),
+  "y-": EDGES.find((e) => e.facingDirection === "y-"),
+  "y+": EDGES.find((e) => e.facingDirection === "y+")
+};
+
+// lib/solvers/GapFillSolver/visuallyOffsetLine.ts
+var OFFSET_DIR_MAP = {
+  "x-": {
+    x: -1,
+    y: 0
+  },
+  "x+": {
+    x: 1,
+    y: 0
+  },
+  "y-": {
+    x: 0,
+    y: -1
+  },
+  "y+": {
+    x: 0,
+    y: 1
   }
-  return Math.max(0, e);
-}
-function maxExpandUp(r, bounds, blockers, maxAspect) {
-  let minY = bounds.y;
-  for (const b of blockers) {
-    const horizOverlaps = r.x + r.width > b.x + EPS && b.x + b.width > r.x + EPS;
-    if (horizOverlaps) {
-      if (lte(b.y + b.height, r.y)) {
-        minY = Math.max(minY, b.y + b.height);
-      } else if (b.y < r.y + EPS && b.y + b.height > r.y - EPS) {
-        return 0;
+};
+var visuallyOffsetLine = (line, options) => {
+  const { dir, amt } = options;
+  const offset = OFFSET_DIR_MAP[dir];
+  return line.map((p) => ({
+    x: p.x + offset.x * amt,
+    y: p.y + offset.y * amt
+  }));
+};
+
+// lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts
+import "@tscircuit/math-utils";
+var EPS2 = 1e-4;
+var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver {
+  constructor(input) {
+    super();
+    this.input = input;
+    for (const node of this.input.meshNodes) {
+      for (const edge of EDGES) {
+        let start = {
+          x: node.center.x + node.width * edge.startX,
+          y: node.center.y + node.height * edge.startY
+        };
+        let end = {
+          x: node.center.x + node.width * edge.endX,
+          y: node.center.y + node.height * edge.endY
+        };
+        if (start.x > end.x) {
+          ;
+          [start, end] = [end, start];
+        }
+        if (Math.abs(start.x - end.x) < EPS2 && start.y > end.y) {
+          ;
+          [start, end] = [end, start];
+        }
+        for (const z of node.availableZ) {
+          this.unprocessedEdges.push({
+            parent: node,
+            start,
+            end,
+            facingDirection: edge.facingDirection,
+            z
+          });
+        }
       }
     }
+    this.allEdges = [...this.unprocessedEdges];
+    this.edgeSpatialIndex = new Flatbush(this.allEdges.length);
+    for (const edge of this.allEdges) {
+      this.edgeSpatialIndex.add(
+        edge.start.x,
+        edge.start.y,
+        edge.end.x,
+        edge.end.y
+      );
+    }
+    this.edgeSpatialIndex.finish();
   }
-  let e = Math.max(0, r.y - minY);
-  if (e <= 0) return 0;
-  if (maxAspect != null) {
-    const w = r.width, h = r.height;
-    if (h >= w) e = Math.min(e, maxAspect * w - h);
-  }
-  return Math.max(0, e);
-}
-function expandRectFromSeed(params) {
-  const {
-    startX,
-    startY,
-    gridSize,
-    bounds,
-    blockers,
-    initialCellRatio,
-    maxAspectRatio,
-    minReq
-  } = params;
-  const minSide = Math.max(1e-9, gridSize * initialCellRatio);
-  const initialW = Math.max(minSide, minReq.width);
-  const initialH = Math.max(minSide, minReq.height);
-  const strategies = [
-    { ox: 0, oy: 0 },
-    { ox: -initialW, oy: 0 },
-    { ox: 0, oy: -initialH },
-    { ox: -initialW, oy: -initialH },
-    { ox: -initialW / 2, oy: -initialH / 2 }
-  ];
-  let best = null;
-  let bestArea = 0;
-  STRATS: for (const s of strategies) {
-    let r = {
-      x: startX + s.ox,
-      y: startY + s.oy,
-      width: initialW,
-      height: initialH
+  allEdges;
+  unprocessedEdges = [];
+  segmentsWithAdjacentEmptySpace = [];
+  edgeSpatialIndex;
+  lastCandidateEdge = null;
+  lastOverlappingEdges = null;
+  lastUncoveredSegments = null;
+  _step() {
+    if (this.unprocessedEdges.length === 0) {
+      this.solved = true;
+      this.lastCandidateEdge = null;
+      this.lastOverlappingEdges = null;
+      this.lastUncoveredSegments = null;
+      return;
+    }
+    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
+    );
+    const overlappingEdges = nearbyEdges.map((i) => this.allEdges[i]).filter((e) => e.z === candidateEdge.z);
+    this.lastOverlappingEdges = overlappingEdges;
+    const uncoveredSegments = projectToUncoveredSegments(
+      candidateEdge,
+      overlappingEdges
+    );
+    this.lastUncoveredSegments = uncoveredSegments;
+    this.segmentsWithAdjacentEmptySpace.push(...uncoveredSegments);
+  }
+  getOutput() {
+    return {
+      segmentsWithAdjacentEmptySpace: this.segmentsWithAdjacentEmptySpace
     };
-    if (lt(r.x, bounds.x) || lt(r.y, bounds.y) || gt(r.x + r.width, bounds.x + bounds.width) || gt(r.y + r.height, bounds.y + bounds.height)) {
-      continue;
+  }
+  visualize() {
+    const graphics = {
+      title: "FindSegmentsWithAdjacentEmptySpace",
+      coordinateSystem: "cartesian",
+      rects: [],
+      points: [],
+      lines: [],
+      circles: [],
+      arrows: [],
+      texts: []
+    };
+    for (const node of this.input.meshNodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: node.width,
+        height: node.height,
+        stroke: "rgba(0, 0, 0, 0.1)"
+      });
     }
-    for (const b of blockers) if (overlaps(r, b)) continue STRATS;
-    let improved = true;
-    while (improved) {
-      improved = false;
-      const eR = maxExpandRight(r, bounds, blockers, maxAspectRatio);
-      if (eR > 0) {
-        r = { ...r, width: r.width + eR };
-        improved = true;
-      }
-      const eD = maxExpandDown(r, bounds, blockers, maxAspectRatio);
-      if (eD > 0) {
-        r = { ...r, height: r.height + eD };
-        improved = true;
-      }
-      const eL = maxExpandLeft(r, bounds, blockers, maxAspectRatio);
-      if (eL > 0) {
-        r = { x: r.x - eL, y: r.y, width: r.width + eL, height: r.height };
-        improved = true;
-      }
-      const eU = maxExpandUp(r, bounds, blockers, maxAspectRatio);
-      if (eU > 0) {
-        r = { x: r.x, y: r.y - eU, width: r.width, height: r.height + eU };
-        improved = true;
-      }
+    for (const unprocessedEdge of this.unprocessedEdges) {
+      graphics.lines.push({
+        points: visuallyOffsetLine(
+          [unprocessedEdge.start, unprocessedEdge.end],
+          { dir: unprocessedEdge.facingDirection, amt: -0.1 }
+        ),
+        strokeColor: "rgba(0, 0, 255, 0.5)",
+        strokeDash: "5 5"
+      });
     }
-    if (r.width + EPS >= minReq.width && r.height + EPS >= minReq.height) {
-      const area = r.width * r.height;
-      if (area > bestArea) {
-        best = r;
-        bestArea = area;
-      }
+    for (const edge of this.segmentsWithAdjacentEmptySpace) {
+      graphics.lines.push({
+        points: [edge.start, edge.end],
+        strokeColor: "rgba(0,255,0, 0.5)"
+      });
     }
-  }
-  return best;
-}
-function intersect1D(a0, a1, b0, b1) {
-  const lo = Math.max(a0, b0);
-  const hi = Math.min(a1, b1);
-  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/rectdiff/candidates.ts
-function isFullyOccupiedAllLayers(params) {
-  const { x, y, layerCount, obstaclesByLayer, placedByLayer } = params;
-  for (let z = 0; z < layerCount; z++) {
-    const obs = obstaclesByLayer[z] ?? [];
-    const placed = placedByLayer[z] ?? [];
-    const occ = obs.some((b) => containsPoint(b, x, y)) || placed.some((b) => containsPoint(b, x, y));
-    if (!occ) return false;
-  }
-  return true;
-}
-function computeCandidates3D(params) {
-  const {
-    bounds,
-    gridSize,
-    layerCount,
-    obstaclesByLayer,
-    placedByLayer,
-    hardPlacedByLayer
-  } = params;
-  const out = /* @__PURE__ */ new Map();
-  for (let x = bounds.x; x < bounds.x + bounds.width; x += gridSize) {
-    for (let y = bounds.y; y < bounds.y + bounds.height; y += gridSize) {
-      if (Math.abs(x - bounds.x) < EPS || Math.abs(y - bounds.y) < EPS || x > bounds.x + bounds.width - gridSize - EPS || y > bounds.y + bounds.height - gridSize - EPS) {
-        continue;
-      }
-      if (isFullyOccupiedAllLayers({
-        x,
-        y,
-        layerCount,
-        obstaclesByLayer,
-        placedByLayer
-      }))
-        continue;
-      let bestSpan = [];
-      let bestZ = 0;
-      for (let z = 0; z < layerCount; z++) {
-        const s = longestFreeSpanAroundZ({
-          x,
-          y,
-          z,
-          layerCount,
-          minSpan: 1,
-          maxSpan: void 0,
-          obstaclesByLayer,
-          placedByLayer: hardPlacedByLayer
+    if (this.lastCandidateEdge) {
+      graphics.lines.push({
+        points: [this.lastCandidateEdge.start, this.lastCandidateEdge.end],
+        strokeColor: "blue"
+      });
+    }
+    if (this.lastOverlappingEdges) {
+      for (const edge of this.lastOverlappingEdges) {
+        graphics.lines.push({
+          points: visuallyOffsetLine([edge.start, edge.end], {
+            dir: edge.facingDirection,
+            amt: 0.05
+          }),
+          strokeColor: "red",
+          strokeDash: "2 2"
         });
-        if (s.length > bestSpan.length) {
-          bestSpan = s;
-          bestZ = z;
-        }
       }
-      const anchorZ = bestSpan.length ? bestSpan[Math.floor(bestSpan.length / 2)] : bestZ;
-      const hardAtZ = [
-        ...obstaclesByLayer[anchorZ] ?? [],
-        ...hardPlacedByLayer[anchorZ] ?? []
-      ];
-      const d = Math.min(
-        distancePointToRectEdges(x, y, bounds),
-        ...hardAtZ.length ? hardAtZ.map((b) => distancePointToRectEdges(x, y, b)) : [Infinity]
-      );
-      const k = `${x.toFixed(6)}|${y.toFixed(6)}`;
-      const cand = {
-        x,
-        y,
-        z: anchorZ,
-        distance: d,
-        zSpanLen: bestSpan.length
-      };
-      const prev = out.get(k);
-      if (!prev || cand.zSpanLen > (prev.zSpanLen ?? 0) || cand.zSpanLen === prev.zSpanLen && cand.distance > prev.distance) {
-        out.set(k, cand);
+    }
+    if (this.lastUncoveredSegments) {
+      for (const edge of this.lastUncoveredSegments) {
+        graphics.lines.push({
+          points: visuallyOffsetLine([edge.start, edge.end], {
+            dir: edge.facingDirection,
+            amt: -0.05
+          }),
+          strokeColor: "green",
+          strokeDash: "2 2"
+        });
       }
     }
+    return graphics;
   }
-  const arr = Array.from(out.values());
-  arr.sort((a, b) => b.zSpanLen - a.zSpanLen || b.distance - a.distance);
-  return arr;
-}
-function longestFreeSpanAroundZ(params) {
-  const {
-    x,
-    y,
-    z,
-    layerCount,
-    minSpan,
-    maxSpan,
-    obstaclesByLayer,
-    placedByLayer
-  } = params;
-  const isFreeAt = (layer) => {
-    const blockers = [
-      ...obstaclesByLayer[layer] ?? [],
-      ...placedByLayer[layer] ?? []
-    ];
-    return !blockers.some((b) => containsPoint(b, x, y));
+};
+
+// lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts
+import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
+import RBush from "rbush";
+
+// lib/solvers/GapFillSolver/getBoundsFromCorners.ts
+var getBoundsFromCorners = (corners) => {
+  return {
+    minX: Math.min(...corners.map((c) => c.x)),
+    minY: Math.min(...corners.map((c) => c.y)),
+    maxX: Math.max(...corners.map((c) => c.x)),
+    maxY: Math.max(...corners.map((c) => c.y))
   };
-  let lo = z;
-  let hi = z;
-  while (lo - 1 >= 0 && isFreeAt(lo - 1)) lo--;
-  while (hi + 1 < layerCount && isFreeAt(hi + 1)) hi++;
-  if (typeof maxSpan === "number") {
-    const target = clamp(maxSpan, 1, layerCount);
-    while (hi - lo + 1 > target) {
-      if (z - lo > hi - z) lo++;
-      else hi--;
-    }
-  }
-  const res = [];
-  for (let i = lo; i <= hi; i++) res.push(i);
-  return res.length >= minSpan ? res : [];
-}
-function computeDefaultGridSizes(bounds) {
-  const ref = Math.max(bounds.width, bounds.height);
-  return [ref / 8, ref / 16, ref / 32];
-}
-function computeUncoveredSegments(params) {
-  const { lineStart, lineEnd, coveringIntervals, minSegmentLength } = params;
-  if (coveringIntervals.length === 0) {
-    const center = (lineStart + lineEnd) / 2;
-    return [{ start: lineStart, end: lineEnd, center }];
+};
+
+// lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts
+import { segmentToBoxMinDistance } from "@tscircuit/math-utils";
+var EPS3 = 1e-4;
+var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver2 {
+  constructor(input) {
+    super();
+    this.input = input;
+    this.unprocessedSegments = [...this.input.segmentsWithAdjacentEmptySpace];
+    this.rectSpatialIndex = new RBush();
+    this.rectSpatialIndex.load(
+      this.input.inputMeshNodes.map((n) => ({
+        ...n,
+        minX: n.center.x - n.width / 2,
+        minY: n.center.y - n.height / 2,
+        maxX: n.center.x + n.width / 2,
+        maxY: n.center.y + n.height / 2
+      }))
+    );
   }
-  const sorted = [...coveringIntervals].sort((a, b) => a.start - b.start);
-  const merged = [];
-  let current = { ...sorted[0] };
-  for (let i = 1; i < sorted.length; i++) {
-    const interval = sorted[i];
-    if (interval.start <= current.end + EPS) {
-      current.end = Math.max(current.end, interval.end);
-    } else {
-      merged.push(current);
-      current = { ...interval };
+  unprocessedSegments = [];
+  expandedSegments = [];
+  lastSegment = null;
+  lastSearchBounds = null;
+  lastCollidingNodes = null;
+  lastSearchCorner1 = null;
+  lastSearchCorner2 = null;
+  lastExpandedSegment = null;
+  rectSpatialIndex;
+  _step() {
+    if (this.unprocessedSegments.length === 0) {
+      this.solved = true;
+      return;
+    }
+    const segment = this.unprocessedSegments.shift();
+    this.lastSegment = segment;
+    const { dx, dy } = EDGE_MAP[segment.facingDirection];
+    const deltaStartEnd = {
+      x: segment.end.x - segment.start.x,
+      y: segment.end.y - segment.start.y
+    };
+    const segLength = Math.sqrt(deltaStartEnd.x ** 2 + deltaStartEnd.y ** 2);
+    const normDeltaStartEnd = {
+      x: deltaStartEnd.x / segLength,
+      y: deltaStartEnd.y / segLength
+    };
+    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
+    };
+    const searchCorner2 = {
+      x: segment.end.x + dx * EPS3 - normDeltaStartEnd.x * EPS3 * 10,
+      y: segment.end.y + dy * EPS3 - normDeltaStartEnd.y * EPS3 * 10
+    };
+    this.lastSearchCorner1 = searchCorner1;
+    this.lastSearchCorner2 = searchCorner2;
+    while ((!collidingNodes || collidingNodes.length === 0) && searchDistance < 1e3) {
+      const searchBounds = getBoundsFromCorners([
+        searchCorner1,
+        searchCorner2,
+        {
+          x: searchCorner1.x + dx * searchDistance,
+          y: searchCorner1.y + dy * searchDistance
+        },
+        {
+          x: searchCorner2.x + dx * searchDistance,
+          y: searchCorner2.y + dy * searchDistance
+        }
+      ]);
+      this.lastSearchBounds = searchBounds;
+      collidingNodes = this.rectSpatialIndex.search(searchBounds).filter((n) => n.availableZ.includes(segment.z)).filter(
+        (n) => n.capacityMeshNodeId !== segment.parent.capacityMeshNodeId
+      );
+      searchDistance *= 4;
     }
-  }
-  merged.push(current);
-  const uncovered = [];
-  if (merged[0].start > lineStart + EPS) {
-    const start = lineStart;
-    const end = merged[0].start;
-    if (end - start >= minSegmentLength) {
-      uncovered.push({ start, end, center: (start + end) / 2 });
+    if (!collidingNodes || collidingNodes.length === 0) {
+      return;
     }
-  }
-  for (let i = 0; i < merged.length - 1; i++) {
-    const start = merged[i].end;
-    const end = merged[i + 1].start;
-    if (end - start >= minSegmentLength) {
-      uncovered.push({ start, end, center: (start + end) / 2 });
+    this.lastCollidingNodes = collidingNodes;
+    let smallestDistance = Infinity;
+    for (const node of collidingNodes) {
+      const distance = segmentToBoxMinDistance(segment.start, segment.end, node);
+      if (distance < smallestDistance) {
+        smallestDistance = distance;
+      }
     }
-  }
-  if (merged[merged.length - 1].end < lineEnd - EPS) {
-    const start = merged[merged.length - 1].end;
-    const end = lineEnd;
-    if (end - start >= minSegmentLength) {
-      uncovered.push({ start, end, center: (start + end) / 2 });
+    const expandDistance = smallestDistance;
+    const nodeBounds = getBoundsFromCorners([
+      segment.start,
+      segment.end,
+      {
+        x: segment.start.x + dx * expandDistance,
+        y: segment.start.y + dy * expandDistance
+      },
+      {
+        x: segment.end.x + dx * expandDistance,
+        y: segment.end.y + dy * expandDistance
+      }
+    ]);
+    const nodeCenter = {
+      x: (nodeBounds.minX + nodeBounds.maxX) / 2,
+      y: (nodeBounds.minY + nodeBounds.maxY) / 2
+    };
+    const nodeWidth = nodeBounds.maxX - nodeBounds.minX;
+    const nodeHeight = nodeBounds.maxY - nodeBounds.minY;
+    const expandedSegment = {
+      segment,
+      newNode: {
+        capacityMeshNodeId: `new-${segment.parent.capacityMeshNodeId}-${this.expandedSegments.length}`,
+        center: nodeCenter,
+        width: nodeWidth,
+        height: nodeHeight,
+        availableZ: [segment.z],
+        layer: segment.parent.layer
+      }
+    };
+    this.lastExpandedSegment = expandedSegment;
+    if (nodeWidth < EPS3 || nodeHeight < EPS3) {
+      return;
     }
-  }
-  return uncovered;
-}
-function computeEdgeCandidates3D(params) {
-  const {
-    bounds,
-    minSize,
-    layerCount,
-    obstaclesByLayer,
-    placedByLayer,
-    hardPlacedByLayer
-  } = params;
-  const out = [];
-  const \u03B4 = Math.max(minSize * 0.15, EPS * 3);
-  const dedup = /* @__PURE__ */ new Set();
-  const key = (x, y, z) => `${z}|${x.toFixed(6)}|${y.toFixed(6)}`;
-  function fullyOcc(x, y) {
-    return isFullyOccupiedAllLayers({
-      x,
-      y,
-      layerCount,
-      obstaclesByLayer,
-      placedByLayer
+    this.expandedSegments.push(expandedSegment);
+    this.rectSpatialIndex.insert({
+      ...expandedSegment.newNode,
+      ...nodeBounds
     });
   }
-  function pushIfFree(x, y, z) {
-    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 = [
-      ...obstaclesByLayer[z] ?? [],
-      ...hardPlacedByLayer[z] ?? []
-    ];
-    const d = Math.min(
-      distancePointToRectEdges(x, y, bounds),
-      ...hard.length ? hard.map((b) => distancePointToRectEdges(x, y, b)) : [Infinity]
-    );
-    const k = key(x, y, z);
-    if (dedup.has(k)) return;
-    dedup.add(k);
-    const span = longestFreeSpanAroundZ({
-      x,
-      y,
-      z,
-      layerCount,
-      minSpan: 1,
-      maxSpan: void 0,
-      obstaclesByLayer,
-      placedByLayer: hardPlacedByLayer
-    });
-    out.push({ x, y, z, distance: d, zSpanLen: span.length, isEdgeSeed: true });
+  getOutput() {
+    return {
+      expandedSegments: this.expandedSegments
+    };
   }
-  for (let z = 0; z < layerCount; z++) {
-    const blockers = [
-      ...obstaclesByLayer[z] ?? [],
-      ...hardPlacedByLayer[z] ?? []
-    ];
-    const corners = [
-      { x: bounds.x + \u03B4, y: bounds.y + \u03B4 },
-      // top-left
-      { x: bounds.x + bounds.width - \u03B4, y: bounds.y + \u03B4 },
-      // top-right
-      { x: bounds.x + \u03B4, y: bounds.y + bounds.height - \u03B4 },
-      // bottom-left
-      { x: bounds.x + bounds.width - \u03B4, y: bounds.y + bounds.height - \u03B4 }
-      // bottom-right
-    ];
-    for (const corner of corners) {
-      pushIfFree(corner.x, corner.y, z);
+  visualize() {
+    const graphics = {
+      title: "ExpandEdgesToEmptySpace",
+      coordinateSystem: "cartesian",
+      rects: [],
+      points: [],
+      lines: [],
+      circles: [],
+      arrows: [],
+      texts: []
+    };
+    for (const node of this.input.inputMeshNodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: node.width,
+        height: node.height,
+        stroke: "rgba(0, 0, 0, 0.1)",
+        layer: `z${node.availableZ.join(",")}`,
+        label: [
+          `node ${node.capacityMeshNodeId}`,
+          `z:${node.availableZ.join(",")}`
+        ].join("\n")
+      });
     }
-    const topY = bounds.y + \u03B4;
-    const topCovering = blockers.filter((b) => b.y <= topY && b.y + b.height >= topY).map((b) => ({
-      start: Math.max(bounds.x, b.x),
-      end: Math.min(bounds.x + bounds.width, b.x + b.width)
-    }));
-    const topUncovered = computeUncoveredSegments({
-      lineStart: bounds.x + \u03B4,
-      lineEnd: bounds.x + bounds.width - \u03B4,
-      coveringIntervals: topCovering,
-      minSegmentLength: minSize * 0.5
-    });
-    for (const seg of topUncovered) {
-      const segLen = seg.end - seg.start;
-      if (segLen >= minSize) {
-        pushIfFree(seg.center, topY, z);
-        if (segLen > minSize * 1.5) {
-          pushIfFree(seg.start + minSize * 0.4, topY, z);
-          pushIfFree(seg.end - minSize * 0.4, topY, z);
-        }
-      }
+    for (const { newNode } of this.expandedSegments) {
+      graphics.rects.push({
+        center: newNode.center,
+        width: newNode.width,
+        height: newNode.height,
+        fill: "green",
+        label: `expandedSegment (z=${newNode.availableZ.join(",")})`,
+        layer: `z${newNode.availableZ.join(",")}`
+      });
     }
-    const bottomY = bounds.y + bounds.height - \u03B4;
-    const bottomCovering = blockers.filter((b) => b.y <= bottomY && b.y + b.height >= bottomY).map((b) => ({
-      start: Math.max(bounds.x, b.x),
-      end: Math.min(bounds.x + bounds.width, b.x + b.width)
-    }));
-    const bottomUncovered = computeUncoveredSegments({
-      lineStart: bounds.x + \u03B4,
-      lineEnd: bounds.x + bounds.width - \u03B4,
-      coveringIntervals: bottomCovering,
-      minSegmentLength: minSize * 0.5
-    });
-    for (const seg of bottomUncovered) {
-      const segLen = seg.end - seg.start;
-      if (segLen >= minSize) {
-        pushIfFree(seg.center, bottomY, z);
-        if (segLen > minSize * 1.5) {
-          pushIfFree(seg.start + minSize * 0.4, bottomY, z);
-          pushIfFree(seg.end - minSize * 0.4, bottomY, z);
-        }
-      }
+    if (this.lastSegment) {
+      graphics.lines.push({
+        points: [this.lastSegment.start, this.lastSegment.end],
+        strokeColor: "rgba(0, 0, 255, 0.5)"
+      });
     }
-    const leftX = bounds.x + \u03B4;
-    const leftCovering = blockers.filter((b) => b.x <= leftX && b.x + b.width >= leftX).map((b) => ({
-      start: Math.max(bounds.y, b.y),
-      end: Math.min(bounds.y + bounds.height, b.y + b.height)
-    }));
-    const leftUncovered = computeUncoveredSegments({
-      lineStart: bounds.y + \u03B4,
-      lineEnd: bounds.y + bounds.height - \u03B4,
-      coveringIntervals: leftCovering,
-      minSegmentLength: minSize * 0.5
-    });
-    for (const seg of leftUncovered) {
-      const segLen = seg.end - seg.start;
-      if (segLen >= minSize) {
-        pushIfFree(leftX, seg.center, z);
-        if (segLen > minSize * 1.5) {
-          pushIfFree(leftX, seg.start + minSize * 0.4, z);
-          pushIfFree(leftX, seg.end - minSize * 0.4, z);
-        }
-      }
+    if (this.lastSearchBounds) {
+      graphics.rects.push({
+        center: {
+          x: (this.lastSearchBounds.minX + this.lastSearchBounds.maxX) / 2,
+          y: (this.lastSearchBounds.minY + this.lastSearchBounds.maxY) / 2
+        },
+        width: this.lastSearchBounds.maxX - this.lastSearchBounds.minX,
+        height: this.lastSearchBounds.maxY - this.lastSearchBounds.minY,
+        fill: "rgba(0, 0, 255, 0.25)"
+      });
+    }
+    if (this.lastSearchCorner1 && this.lastSearchCorner2) {
+      graphics.points.push({
+        x: this.lastSearchCorner1.x,
+        y: this.lastSearchCorner1.y,
+        color: "rgba(0, 0, 255, 0.5)",
+        label: ["searchCorner1", `z=${this.lastSegment?.z}`].join("\n")
+      });
+      graphics.points.push({
+        x: this.lastSearchCorner2.x,
+        y: this.lastSearchCorner2.y,
+        color: "rgba(0, 0, 255, 0.5)",
+        label: ["searchCorner2", `z=${this.lastSegment?.z}`].join("\n")
+      });
     }
-    const rightX = bounds.x + bounds.width - \u03B4;
-    const rightCovering = blockers.filter((b) => b.x <= rightX && b.x + b.width >= rightX).map((b) => ({
-      start: Math.max(bounds.y, b.y),
-      end: Math.min(bounds.y + bounds.height, b.y + b.height)
-    }));
-    const rightUncovered = computeUncoveredSegments({
-      lineStart: bounds.y + \u03B4,
-      lineEnd: bounds.y + bounds.height - \u03B4,
-      coveringIntervals: rightCovering,
-      minSegmentLength: minSize * 0.5
-    });
-    for (const seg of rightUncovered) {
-      const segLen = seg.end - seg.start;
-      if (segLen >= minSize) {
-        pushIfFree(rightX, seg.center, z);
-        if (segLen > minSize * 1.5) {
-          pushIfFree(rightX, seg.start + minSize * 0.4, z);
-          pushIfFree(rightX, seg.end - minSize * 0.4, z);
-        }
-      }
+    if (this.lastExpandedSegment) {
+      graphics.rects.push({
+        center: this.lastExpandedSegment.newNode.center,
+        width: this.lastExpandedSegment.newNode.width,
+        height: this.lastExpandedSegment.newNode.height,
+        fill: "purple",
+        label: `expandedSegment (z=${this.lastExpandedSegment.segment.z})`
+      });
     }
-    for (const b of blockers) {
-      const obLeftX = b.x - \u03B4;
-      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) => ({
-          start: Math.max(b.y, bl.y),
-          end: Math.min(b.y + b.height, bl.y + bl.height)
-        }));
-        const obLeftUncovered = computeUncoveredSegments({
-          lineStart: b.y,
-          lineEnd: b.y + b.height,
-          coveringIntervals: obLeftCovering,
-          minSegmentLength: minSize * 0.5
+    if (this.lastCollidingNodes) {
+      for (const node of this.lastCollidingNodes) {
+        graphics.rects.push({
+          center: node.center,
+          width: node.width,
+          height: node.height,
+          fill: "rgba(255, 0, 0, 0.5)"
         });
-        for (const seg of obLeftUncovered) {
-          pushIfFree(obLeftX, seg.center, z);
-        }
       }
-      const obRightX = b.x + b.width + \u03B4;
-      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) => ({
-          start: Math.max(b.y, bl.y),
-          end: Math.min(b.y + b.height, bl.y + bl.height)
-        }));
-        const obRightUncovered = computeUncoveredSegments({
-          lineStart: b.y,
-          lineEnd: b.y + b.height,
-          coveringIntervals: obRightCovering,
-          minSegmentLength: minSize * 0.5
-        });
-        for (const seg of obRightUncovered) {
-          pushIfFree(obRightX, seg.center, z);
+    }
+    return graphics;
+  }
+};
+
+// lib/solvers/GapFillSolver/GapFillSolverPipeline.ts
+var GapFillSolverPipeline = class extends BasePipelineSolver {
+  findSegmentsWithAdjacentEmptySpaceSolver;
+  expandEdgesToEmptySpaceSolver;
+  pipelineDef = [
+    definePipelineStep(
+      "findSegmentsWithAdjacentEmptySpaceSolver",
+      FindSegmentsWithAdjacentEmptySpaceSolver,
+      (gapFillPipeline) => [
+        {
+          meshNodes: gapFillPipeline.inputProblem.meshNodes
         }
-      }
-      const obTopY = b.y - \u03B4;
-      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) => ({
-          start: Math.max(b.x, bl.x),
-          end: Math.min(b.x + b.width, bl.x + bl.width)
-        }));
-        const obTopUncovered = computeUncoveredSegments({
-          lineStart: b.x,
-          lineEnd: b.x + b.width,
-          coveringIntervals: obTopCovering,
-          minSegmentLength: minSize * 0.5
-        });
-        for (const seg of obTopUncovered) {
-          pushIfFree(seg.center, obTopY, z);
+      ],
+      {
+        onSolved: () => {
         }
       }
-      const obBottomY = b.y + b.height + \u03B4;
-      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) => ({
-          start: Math.max(b.x, bl.x),
-          end: Math.min(b.x + b.width, bl.x + bl.width)
-        }));
-        const obBottomUncovered = computeUncoveredSegments({
-          lineStart: b.x,
-          lineEnd: b.x + b.width,
-          coveringIntervals: obBottomCovering,
-          minSegmentLength: minSize * 0.5
-        });
-        for (const seg of obBottomUncovered) {
-          pushIfFree(seg.center, obBottomY, z);
+    ),
+    definePipelineStep(
+      "expandEdgesToEmptySpaceSolver",
+      ExpandEdgesToEmptySpaceSolver,
+      (gapFillPipeline) => [
+        {
+          inputMeshNodes: gapFillPipeline.inputProblem.meshNodes,
+          segmentsWithAdjacentEmptySpace: gapFillPipeline.findSegmentsWithAdjacentEmptySpaceSolver.getOutput().segmentsWithAdjacentEmptySpace
+        }
+      ],
+      {
+        onSolved: () => {
         }
       }
+    )
+  ];
+  getOutput() {
+    const expandedSegments = this.expandEdgesToEmptySpaceSolver?.getOutput().expandedSegments ?? [];
+    const expandedNodes = expandedSegments.map((es) => es.newNode);
+    return {
+      outputNodes: [...this.inputProblem.meshNodes, ...expandedNodes]
+    };
+  }
+  initialVisualize() {
+    const graphics = {
+      title: "GapFillSolverPipeline - Initial",
+      coordinateSystem: "cartesian",
+      rects: [],
+      points: [],
+      lines: [],
+      circles: [],
+      arrows: [],
+      texts: []
+    };
+    for (const node of this.inputProblem.meshNodes) {
+      graphics.rects.push({
+        center: node.center,
+        width: node.width,
+        height: node.height,
+        stroke: "rgba(0, 0, 0, 0.3)",
+        fill: "rgba(100, 100, 100, 0.1)",
+        layer: `z${node.availableZ.join(",")}`,
+        label: [
+          `node ${node.capacityMeshNodeId}`,
+          `z:${node.availableZ.join(",")}`
+        ].join("\n")
+      });
     }
+    return graphics;
   }
-  out.sort((a, b) => b.zSpanLen - a.zSpanLen || b.distance - a.distance);
-  return out;
+  finalVisualize() {
+    const graphics = {
+      title: "GapFillSolverPipeline - Final",
+      coordinateSystem: "cartesian",
+      rects: [],
+      points: [],
+      lines: [],
+      circles: [],
+      arrows: [],
+      texts: []
+    };
+    const { outputNodes } = this.getOutput();
+    const expandedSegments = this.expandEdgesToEmptySpaceSolver?.getOutput().expandedSegments ?? [];
+    const expandedNodeIds = new Set(
+      expandedSegments.map((es) => es.newNode.capacityMeshNodeId)
+    );
+    for (const node of outputNodes) {
+      const isExpanded = expandedNodeIds.has(node.capacityMeshNodeId);
+      graphics.rects.push({
+        center: node.center,
+        width: node.width,
+        height: node.height,
+        stroke: isExpanded ? "rgba(0, 128, 0, 0.8)" : "rgba(0, 0, 0, 0.3)",
+        fill: isExpanded ? "rgba(0, 200, 0, 0.3)" : "rgba(100, 100, 100, 0.1)",
+        layer: `z${node.availableZ.join(",")}`,
+        label: [
+          `${isExpanded ? "[expanded] " : ""}node ${node.capacityMeshNodeId}`,
+          `z:${node.availableZ.join(",")}`
+        ].join("\n")
+      });
+    }
+    return graphics;
+  }
+};
+
+// 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/utils/rectdiff-geometry.ts
+var EPS4 = 1e-9;
+var clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+var gt = (a, b) => a > b + EPS4;
+var gte = (a, b) => a > b - EPS4;
+var lt = (a, b) => a < b - EPS4;
+var lte = (a, b) => a < b + EPS4;
+function overlaps(a, b) {
+  return !(a.x + a.width <= b.x + EPS4 || b.x + b.width <= a.x + EPS4 || a.y + a.height <= b.y + EPS4 || b.y + b.height <= a.y + EPS4);
+}
+function 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;
+}
+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 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 });
+  }
+  if (A.x + A.width > X1 + EPS4) {
+    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 > EPS4 && Y0 > A.y + EPS4) {
+    out.push({ x: X0, y: A.y, width: midW, height: Y0 - A.y });
+  }
+  if (midW > EPS4 && A.y + A.height > Y1 + EPS4) {
+    out.push({ x: X0, y: Y1, width: midW, height: A.y + A.height - Y1 });
+  }
+  return out.filter((r) => r.width > EPS4 && r.height > EPS4);
 }
 
-// lib/solvers/rectdiff/geometry/isPointInPolygon.ts
+// lib/solvers/RectDiffSeedingSolver/isPointInPolygon.ts
 function isPointInPolygon(p, polygon) {
   let inside = false;
   for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
@@ -618,7 +727,7 @@ function isPointInPolygon(p, polygon) {
   return inside;
 }
 
-// lib/solvers/rectdiff/geometry/computeInverseRects.ts
+// lib/solvers/RectDiffSeedingSolver/computeInverseRects.ts
 function computeInverseRects(bounds, polygon) {
   if (!polygon || polygon.length < 3) return [];
   const xs = /* @__PURE__ */ new Set([bounds.x, bounds.x + bounds.width]);
@@ -647,7 +756,7 @@ function computeInverseRects(bounds, polygon) {
   }
   const finalRects = [];
   rawRects.sort((a, b) => {
-    if (Math.abs(a.y - b.y) > EPS) return a.y - b.y;
+    if (Math.abs(a.y - b.y) > EPS4) return a.y - b.y;
     return a.x - b.x;
   });
   let current = null;
@@ -656,9 +765,9 @@ function computeInverseRects(bounds, polygon) {
       current = r;
       continue;
     }
-    const sameY = Math.abs(current.y - r.y) < EPS;
-    const sameHeight = Math.abs(current.height - r.height) < EPS;
-    const touchesX = Math.abs(current.x + current.width - r.x) < EPS;
+    const sameY = Math.abs(current.y - r.y) < EPS4;
+    const sameHeight = Math.abs(current.height - r.height) < EPS4;
+    const touchesX = Math.abs(current.x + current.width - r.x) < EPS4;
     if (sameY && sameHeight && touchesX) {
       current.width += r.width;
     } else {
@@ -668,7 +777,7 @@ function computeInverseRects(bounds, polygon) {
   }
   if (current) finalRects.push(current);
   finalRects.sort((a, b) => {
-    if (Math.abs(a.x - b.x) > EPS) return a.x - b.x;
+    if (Math.abs(a.x - b.x) > EPS4) return a.x - b.x;
     return a.y - b.y;
   });
   const mergedVertical = [];
@@ -678,9 +787,9 @@ function computeInverseRects(bounds, polygon) {
       current = r;
       continue;
     }
-    const sameX = Math.abs(current.x - r.x) < EPS;
-    const sameWidth = Math.abs(current.width - r.width) < EPS;
-    const touchesY = Math.abs(current.y + current.height - r.y) < EPS;
+    const sameX = Math.abs(current.x - r.x) < EPS4;
+    const sameWidth = Math.abs(current.width - r.width) < EPS4;
+    const touchesY = Math.abs(current.y + current.height - r.y) < EPS4;
     if (sameX && sameWidth && touchesY) {
       current.height += r.height;
     } else {
@@ -692,7 +801,7 @@ function computeInverseRects(bounds, polygon) {
   return mergedVertical;
 }
 
-// lib/solvers/rectdiff/layers.ts
+// lib/solvers/RectDiffSeedingSolver/layers.ts
 function layerSortKey(n) {
   const L = n.toLowerCase();
   if (L === "top") return -1e6;
@@ -767,1252 +876,1480 @@ function obstacleToXYRect(ob) {
   return { x: ob.center.x - w / 2, y: ob.center.y - h / 2, width: w, height: h };
 }
 
-// lib/solvers/rectdiff/engine.ts
-function initState(srj, opts) {
-  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 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);
+// lib/utils/expandRectFromSeed.ts
+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;
+    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) {
+        return 0;
       }
     }
   }
-  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(
-        `RectDiffSolver: 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: computeDefaultGridSizes(bounds),
-    initialCellRatio: 0.2,
-    maxAspectRatio: 3,
-    minSingle: { width: 2 * trace, height: 2 * trace },
-    minMulti: {
-      width: 4 * trace,
-      height: 4 * trace,
-      minLayers: Math.min(2, Math.max(1, srj.layerCount || 1))
-    },
-    preferMultiLayer: true,
-    maxMultiLayerSpan: void 0
-  };
-  const options = {
-    ...defaults,
-    ...opts,
-    gridSizes: opts.gridSizes ?? defaults.gridSizes
-  };
-  const placedByLayer = Array.from({ length: layerCount }, () => []);
-  return {
-    srj,
-    layerNames,
-    layerCount,
-    bounds,
-    options,
-    obstaclesByLayer,
-    boardVoidRects,
-    phase: "GRID",
-    gridIndex: 0,
-    candidates: [],
-    placed: [],
-    placedByLayer,
-    expansionIndex: 0,
-    edgeAnalysisDone: false,
-    totalSeedsThisGrid: 0,
-    consumedSeedsThisGrid: 0
-  };
+  let e = Math.max(0, maxWidth - r.width);
+  if (e <= 0) return 0;
+  if (maxAspect != null) {
+    const w = r.width, h = r.height;
+    if (w >= h) e = Math.min(e, maxAspect * h - w);
+  }
+  return Math.max(0, e);
 }
-function buildHardPlacedByLayer(state) {
-  const out = Array.from({ length: state.layerCount }, () => []);
-  for (const p of state.placed) {
-    if (p.zLayers.length >= state.layerCount) {
-      for (const z of p.zLayers) out[z].push(p.rect);
+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;
+    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) {
+        return 0;
+      }
     }
   }
-  return out;
-}
-function isFullyOccupiedAtPoint(state, point) {
-  for (let z = 0; z < state.layerCount; z++) {
-    const obs = state.obstaclesByLayer[z] ?? [];
-    const placed = state.placedByLayer[z] ?? [];
-    const occ = obs.some((b) => containsPoint(b, point.x, point.y)) || placed.some((b) => containsPoint(b, point.x, point.y));
-    if (!occ) return false;
+  let e = Math.max(0, maxHeight - r.height);
+  if (e <= 0) return 0;
+  if (maxAspect != null) {
+    const w = r.width, h = r.height;
+    if (h >= w) e = Math.min(e, maxAspect * w - h);
   }
-  return true;
+  return Math.max(0, e);
 }
-function resizeSoftOverlaps(state, newIndex) {
-  const newcomer = state.placed[newIndex];
-  const { rect: newR, zLayers: newZs } = newcomer;
-  const layerCount = state.layerCount;
-  const removeIdx = [];
-  const toAdd = [];
-  for (let i = 0; i < state.placed.length; i++) {
-    if (i === newIndex) continue;
-    const old = state.placed[i];
-    if (old.zLayers.length >= layerCount) continue;
-    const sharedZ = old.zLayers.filter((z) => newZs.includes(z));
-    if (sharedZ.length === 0) continue;
-    if (!overlaps(old.rect, newR)) continue;
-    const parts = subtractRect2D(old.rect, newR);
-    removeIdx.push(i);
-    const unaffectedZ = old.zLayers.filter((z) => !newZs.includes(z));
-    if (unaffectedZ.length > 0) {
-      toAdd.push({ rect: old.rect, zLayers: unaffectedZ });
-    }
-    const minW = Math.min(
-      state.options.minSingle.width,
-      state.options.minMulti.width
-    );
-    const minH = Math.min(
-      state.options.minSingle.height,
-      state.options.minMulti.height
-    );
-    for (const p of parts) {
-      if (p.width + EPS >= minW && p.height + EPS >= minH) {
-        toAdd.push({ rect: p, zLayers: sharedZ.slice() });
+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;
+    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) {
+        return 0;
       }
     }
   }
-  removeIdx.sort((a, b) => b - a).forEach((idx) => {
-    const rem = state.placed.splice(idx, 1)[0];
-    for (const z of rem.zLayers) {
-      const arr = state.placedByLayer[z];
-      const j = arr.findIndex((r) => r === rem.rect);
-      if (j >= 0) arr.splice(j, 1);
+  let e = Math.max(0, r.x - minX);
+  if (e <= 0) return 0;
+  if (maxAspect != null) {
+    const w = r.width, h = r.height;
+    if (w >= h) e = Math.min(e, maxAspect * h - w);
+  }
+  return Math.max(0, e);
+}
+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;
+    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) {
+        return 0;
+      }
     }
-  });
-  for (const p of toAdd) {
-    state.placed.push(p);
-    for (const z of p.zLayers) state.placedByLayer[z].push(p.rect);
   }
+  let e = Math.max(0, r.y - minY);
+  if (e <= 0) return 0;
+  if (maxAspect != null) {
+    const w = r.width, h = r.height;
+    if (h >= w) e = Math.min(e, maxAspect * w - h);
+  }
+  return Math.max(0, e);
 }
-function stepGrid(state) {
+function expandRectFromSeed(params) {
   const {
-    gridSizes,
+    startX,
+    startY,
+    gridSize,
+    bounds,
+    blockers,
     initialCellRatio,
     maxAspectRatio,
-    minSingle,
-    minMulti,
-    preferMultiLayer,
-    maxMultiLayerSpan
-  } = state.options;
-  const grid = gridSizes[state.gridIndex];
-  const hardPlacedByLayer = buildHardPlacedByLayer(state);
-  if (state.candidates.length === 0 && state.consumedSeedsThisGrid === 0) {
-    state.candidates = computeCandidates3D({
-      bounds: state.bounds,
-      gridSize: grid,
-      layerCount: state.layerCount,
-      obstaclesByLayer: state.obstaclesByLayer,
-      placedByLayer: state.placedByLayer,
-      hardPlacedByLayer
-    });
-    state.totalSeedsThisGrid = state.candidates.length;
-    state.consumedSeedsThisGrid = 0;
-  }
-  if (state.candidates.length === 0) {
-    if (state.gridIndex + 1 < gridSizes.length) {
-      state.gridIndex += 1;
-      state.totalSeedsThisGrid = 0;
-      state.consumedSeedsThisGrid = 0;
-      return;
-    } else {
-      if (!state.edgeAnalysisDone) {
-        const minSize = Math.min(minSingle.width, minSingle.height);
-        state.candidates = computeEdgeCandidates3D({
-          bounds: state.bounds,
-          minSize,
-          layerCount: state.layerCount,
-          obstaclesByLayer: state.obstaclesByLayer,
-          placedByLayer: state.placedByLayer,
-          hardPlacedByLayer
-        });
-        state.edgeAnalysisDone = true;
-        state.totalSeedsThisGrid = state.candidates.length;
-        state.consumedSeedsThisGrid = 0;
-        return;
+    minReq
+  } = params;
+  const minSide = Math.max(1e-9, gridSize * initialCellRatio);
+  const initialW = Math.max(minSide, minReq.width);
+  const initialH = Math.max(minSide, minReq.height);
+  const strategies = [
+    { ox: 0, oy: 0 },
+    { ox: -initialW, oy: 0 },
+    { ox: 0, oy: -initialH },
+    { ox: -initialW, oy: -initialH },
+    { ox: -initialW / 2, oy: -initialH / 2 }
+  ];
+  let best = null;
+  let bestArea = 0;
+  STRATS: for (const s of strategies) {
+    let r = {
+      x: startX + s.ox,
+      y: startY + s.oy,
+      width: initialW,
+      height: initialH
+    };
+    if (lt(r.x, bounds.x) || lt(r.y, bounds.y) || gt(r.x + r.width, bounds.x + bounds.width) || gt(r.y + r.height, bounds.y + bounds.height)) {
+      continue;
+    }
+    for (const b of blockers) if (overlaps(r, b)) continue STRATS;
+    let improved = true;
+    while (improved) {
+      improved = false;
+      const commonParams = { bounds, blockers, maxAspect: maxAspectRatio };
+      const eR = maxExpandRight({ ...commonParams, r });
+      if (eR > 0) {
+        r = { ...r, width: r.width + eR };
+        improved = true;
+      }
+      const eD = maxExpandDown({ ...commonParams, r });
+      if (eD > 0) {
+        r = { ...r, height: r.height + eD };
+        improved = true;
+      }
+      const eL = maxExpandLeft({ ...commonParams, r });
+      if (eL > 0) {
+        r = { x: r.x - eL, y: r.y, width: r.width + eL, height: r.height };
+        improved = true;
+      }
+      const eU = maxExpandUp({ ...commonParams, r });
+      if (eU > 0) {
+        r = { x: r.x, y: r.y - eU, width: r.width, height: r.height + eU };
+        improved = true;
+      }
+    }
+    if (r.width + EPS4 >= minReq.width && r.height + EPS4 >= minReq.height) {
+      const area = r.width * r.height;
+      if (area > bestArea) {
+        best = r;
+        bestArea = area;
       }
-      state.phase = "EXPANSION";
-      state.expansionIndex = 0;
-      return;
     }
   }
-  const cand = state.candidates.shift();
-  state.consumedSeedsThisGrid += 1;
-  const span = longestFreeSpanAroundZ({
-    x: cand.x,
-    y: cand.y,
-    z: cand.z,
-    layerCount: state.layerCount,
-    minSpan: minMulti.minLayers,
-    maxSpan: maxMultiLayerSpan,
-    obstaclesByLayer: state.obstaclesByLayer,
-    placedByLayer: hardPlacedByLayer
-  });
-  const attempts = [];
-  if (span.length >= minMulti.minLayers) {
-    attempts.push({
-      kind: "multi",
-      layers: span,
-      minReq: { width: minMulti.width, height: minMulti.height }
-    });
+  return best;
+}
+
+// lib/solvers/RectDiffSeedingSolver/computeDefaultGridSizes.ts
+function computeDefaultGridSizes(bounds) {
+  const ref = Math.max(bounds.width, bounds.height);
+  return [ref / 8, ref / 16, ref / 32];
+}
+
+// lib/utils/isFullyOccupiedAtPoint.ts
+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 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;
   }
-  attempts.push({
-    kind: "single",
-    layers: [cand.z],
-    minReq: { width: minSingle.width, height: minSingle.height }
-  });
-  const ordered = preferMultiLayer ? attempts : attempts.reverse();
-  for (const attempt of ordered) {
-    const hardBlockers = [];
-    for (const z of attempt.layers) {
-      if (state.obstaclesByLayer[z])
-        hardBlockers.push(...state.obstaclesByLayer[z]);
-      if (hardPlacedByLayer[z]) hardBlockers.push(...hardPlacedByLayer[z]);
-    }
-    const rect = expandRectFromSeed({
-      startX: cand.x,
-      startY: cand.y,
-      gridSize: grid,
-      bounds: state.bounds,
-      blockers: hardBlockers,
-      initialCellRatio,
-      maxAspectRatio,
-      minReq: attempt.minReq
-    });
-    if (!rect) continue;
-    const placed = { rect, zLayers: [...attempt.layers] };
-    const newIndex = state.placed.push(placed) - 1;
-    for (const z of attempt.layers) state.placedByLayer[z].push(rect);
-    resizeSoftOverlaps(state, newIndex);
-    state.candidates = state.candidates.filter(
-      (c) => !isFullyOccupiedAtPoint(state, { x: c.x, y: c.y })
-    );
-    return;
+  return true;
+}
+
+// lib/solvers/RectDiffSeedingSolver/longestFreeSpanAroundZ.ts
+function longestFreeSpanAroundZ(params) {
+  const {
+    x,
+    y,
+    z,
+    layerCount,
+    minSpan,
+    maxSpan,
+    obstacleIndexByLayer,
+    additionalBlockersByLayer
+  } = params;
+  const isFreeAt = (layer) => {
+    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;
+  while (lo - 1 >= 0 && isFreeAt(lo - 1)) lo--;
+  while (hi + 1 < layerCount && isFreeAt(hi + 1)) hi++;
+  if (typeof maxSpan === "number") {
+    const target = clamp(maxSpan, 1, layerCount);
+    while (hi - lo + 1 > target) {
+      if (z - lo > hi - z) lo++;
+      else hi--;
+    }
+  }
+  const res = [];
+  for (let i = lo; i <= hi; i++) res.push(i);
+  return res.length >= minSpan ? res : [];
+}
+
+// lib/solvers/RectDiffSeedingSolver/computeCandidates3D.ts
+function computeCandidates3D(params) {
+  const {
+    bounds,
+    gridSize,
+    layerCount,
+    obstacleIndexByLayer,
+    placedIndexByLayer,
+    hardPlacedByLayer
+  } = params;
+  const out = /* @__PURE__ */ new Map();
+  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) {
+        continue;
+      }
+      if (isFullyOccupiedAtPoint({
+        layerCount,
+        obstacleIndexByLayer,
+        placedIndexByLayer,
+        point: { x, y }
+      }))
+        continue;
+      let bestSpan = [];
+      let bestZ = 0;
+      for (let z = 0; z < layerCount; z++) {
+        const s = longestFreeSpanAroundZ({
+          x,
+          y,
+          z,
+          layerCount,
+          minSpan: 1,
+          maxSpan: void 0,
+          obstacleIndexByLayer,
+          additionalBlockersByLayer: hardPlacedByLayer
+        });
+        if (s.length > bestSpan.length) {
+          bestSpan = s;
+          bestZ = z;
+        }
+      }
+      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 k = `${x.toFixed(6)}|${y.toFixed(6)}`;
+      const cand = {
+        x,
+        y,
+        z: anchorZ,
+        distance: d,
+        zSpanLen: bestSpan.length
+      };
+      const prev = out.get(k);
+      if (!prev || cand.zSpanLen > (prev.zSpanLen ?? 0) || cand.zSpanLen === prev.zSpanLen && cand.distance > prev.distance) {
+        out.set(k, cand);
+      }
+    }
   }
+  const arr = Array.from(out.values());
+  arr.sort((a, b) => b.zSpanLen - a.zSpanLen || b.distance - a.distance);
+  return arr;
 }
-function stepExpansion(state) {
-  if (state.expansionIndex >= state.placed.length) {
-    state.phase = "GAP_FILL";
-    return;
-  }
-  const idx = state.expansionIndex;
-  const p = state.placed[idx];
-  const lastGrid = state.options.gridSizes[state.options.gridSizes.length - 1];
-  const hardPlacedByLayer = buildHardPlacedByLayer(state);
-  const hardBlockers = [];
-  for (const z of p.zLayers) {
-    hardBlockers.push(...state.obstaclesByLayer[z] ?? []);
-    hardBlockers.push(...hardPlacedByLayer[z] ?? []);
-  }
-  const oldRect = p.rect;
-  const expanded = expandRectFromSeed({
-    startX: p.rect.x + p.rect.width / 2,
-    startY: p.rect.y + p.rect.height / 2,
-    gridSize: lastGrid,
-    bounds: state.bounds,
-    blockers: hardBlockers,
-    initialCellRatio: 0,
-    maxAspectRatio: null,
-    minReq: { width: p.rect.width, height: p.rect.height }
-  });
-  if (expanded) {
-    state.placed[idx] = { rect: expanded, zLayers: p.zLayers };
-    for (const z of p.zLayers) {
-      const arr = state.placedByLayer[z];
-      const j = arr.findIndex((r) => r === oldRect);
-      if (j >= 0) arr[j] = expanded;
+
+// lib/solvers/RectDiffSeedingSolver/computeEdgeCandidates3D.ts
+function computeUncoveredSegments(params) {
+  const { lineStart, lineEnd, coveringIntervals, minSegmentLength } = params;
+  if (coveringIntervals.length === 0) {
+    const center = (lineStart + lineEnd) / 2;
+    return [{ start: lineStart, end: lineEnd, center }];
+  }
+  const sorted = [...coveringIntervals].sort((a, b) => a.start - b.start);
+  const merged = [];
+  let current = { ...sorted[0] };
+  for (let i = 1; i < sorted.length; i++) {
+    const interval = sorted[i];
+    if (interval.start <= current.end + EPS4) {
+      current.end = Math.max(current.end, interval.end);
+    } else {
+      merged.push(current);
+      current = { ...interval };
     }
-    resizeSoftOverlaps(state, idx);
   }
-  state.expansionIndex += 1;
-}
-function finalizeRects(state) {
-  const out = state.placed.map((p) => ({
-    minX: p.rect.x,
-    minY: p.rect.y,
-    maxX: p.rect.x + p.rect.width,
-    maxY: p.rect.y + p.rect.height,
-    zLayers: [...p.zLayers].sort((a, b) => a - b)
-  }));
-  const layersByObstacleRect = /* @__PURE__ */ new Map();
-  state.obstaclesByLayer.forEach((layerObs, z) => {
-    for (const rect of layerObs) {
-      const layerIndices = layersByObstacleRect.get(rect) ?? [];
-      layerIndices.push(z);
-      layersByObstacleRect.set(rect, layerIndices);
+  merged.push(current);
+  const uncovered = [];
+  if (merged[0].start > lineStart + EPS4) {
+    const start = lineStart;
+    const end = merged[0].start;
+    if (end - start >= minSegmentLength) {
+      uncovered.push({ start, end, center: (start + end) / 2 });
     }
-  });
-  const voidSet = new Set(state.boardVoidRects || []);
-  for (const [rect, layerIndices] of layersByObstacleRect.entries()) {
-    if (voidSet.has(rect)) continue;
-    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),
-      isObstacle: true
-    });
   }
-  return out;
-}
-function computeProgress(state) {
-  const grids = state.options.gridSizes.length;
-  if (state.phase === "GRID") {
-    const g = state.gridIndex;
-    const base = g / (grids + 1);
-    const denom = Math.max(1, state.totalSeedsThisGrid);
-    const frac = denom ? state.consumedSeedsThisGrid / denom : 1;
-    return Math.min(0.999, base + frac * (1 / (grids + 1)));
+  for (let i = 0; i < merged.length - 1; i++) {
+    const start = merged[i].end;
+    const end = merged[i + 1].start;
+    if (end - start >= minSegmentLength) {
+      uncovered.push({ start, end, center: (start + end) / 2 });
+    }
   }
-  if (state.phase === "EXPANSION") {
-    const base = grids / (grids + 1);
-    const denom = Math.max(1, state.placed.length);
-    const frac = denom ? state.expansionIndex / denom : 1;
-    return Math.min(0.999, base + frac * (1 / (grids + 1)));
+  if (merged[merged.length - 1].end < lineEnd - EPS4) {
+    const start = merged[merged.length - 1].end;
+    const end = lineEnd;
+    if (end - start >= minSegmentLength) {
+      uncovered.push({ start, end, center: (start + end) / 2 });
+    }
   }
-  return 1;
+  return uncovered;
 }
-
-// lib/solvers/rectdiff/rectsToMeshNodes.ts
-function rectsToMeshNodes(rects) {
-  let id = 0;
+function computeEdgeCandidates3D(params) {
+  const {
+    bounds,
+    minSize,
+    layerCount,
+    obstacleIndexByLayer,
+    placedIndexByLayer,
+    hardPlacedByLayer
+  } = params;
   const out = [];
-  for (const r of rects) {
-    const w = Math.max(0, r.maxX - r.minX);
-    const h = Math.max(0, r.maxY - r.minY);
-    if (w <= 0 || h <= 0 || r.zLayers.length === 0) continue;
-    out.push({
-      capacityMeshNodeId: `cmn_${id++}`,
-      center: { x: (r.minX + r.maxX) / 2, y: (r.minY + r.maxY) / 2 },
-      width: w,
-      height: h,
-      layer: "top",
-      availableZ: r.zLayers.slice(),
-      _containsObstacle: r.isObstacle,
-      _containsTarget: r.isObstacle
+  const \u03B4 = Math.max(minSize * 0.15, EPS4 * 3);
+  const dedup = /* @__PURE__ */ new Set();
+  const key = (p) => `${p.z}|${p.x.toFixed(6)}|${p.y.toFixed(6)}`;
+  function fullyOcc(p) {
+    return isFullyOccupiedAtPoint({
+      layerCount,
+      obstacleIndexByLayer,
+      placedIndexByLayer,
+      point: p
     });
   }
-  return out;
-}
-
-// lib/solvers/RectDiffSolver.ts
-var RectDiffSolver = class extends BaseSolver {
-  srj;
-  gridOptions;
-  state;
-  _meshNodes = [];
-  constructor(opts) {
-    super();
-    this.srj = opts.simpleRouteJson;
-    this.gridOptions = opts.gridOptions ?? {};
-  }
-  _setup() {
-    this.state = initState(this.srj, this.gridOptions);
-    this.stats = {
-      phase: this.state.phase,
-      gridIndex: this.state.gridIndex
-    };
-  }
-  /** Exactly ONE small step per call. */
-  _step() {
-    if (this.state.phase === "GRID") {
-      stepGrid(this.state);
-    } else if (this.state.phase === "EXPANSION") {
-      stepExpansion(this.state);
-    } else if (this.state.phase === "GAP_FILL") {
-      this.state.phase = "DONE";
-    } else if (this.state.phase === "DONE") {
-      if (!this.solved) {
-        const rects = finalizeRects(this.state);
-        this._meshNodes = rectsToMeshNodes(rects);
-        this.solved = true;
-      }
+  function pushIfFree(p) {
+    const { x, y, z } = p;
+    if (x < bounds.x + EPS4 || y < bounds.y + EPS4 || x > bounds.x + bounds.width - EPS4 || y > bounds.y + bounds.height - EPS4)
       return;
-    }
-    this.stats.phase = this.state.phase;
-    this.stats.gridIndex = this.state.gridIndex;
-    this.stats.placed = this.state.placed.length;
-  }
-  /** Compute solver progress (0 to 1). */
-  computeProgress() {
-    if (this.solved || this.state.phase === "DONE") {
-      return 1;
-    }
-    return computeProgress(this.state);
-  }
-  getOutput() {
-    return { meshNodes: this._meshNodes };
-  }
-  /** Get color based on z layer for visualization. */
-  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" }
+    if (fullyOcc({ x, y })) return;
+    const hard = [
+      ...obstacleIndexByLayer[z]?.all() ?? [],
+      ...hardPlacedByLayer[z] ?? []
     ];
-    return colors[minZ % colors.length];
+    const d = Math.min(
+      distancePointToRectEdges({ x, y }, bounds),
+      ...hard.length ? hard.map((b) => distancePointToRectEdges({ x, y }, b)) : [Infinity]
+    );
+    const k = key({ x, y, z });
+    if (dedup.has(k)) return;
+    dedup.add(k);
+    const span = longestFreeSpanAroundZ({
+      x,
+      y,
+      z,
+      layerCount,
+      minSpan: 1,
+      maxSpan: void 0,
+      obstacleIndexByLayer,
+      additionalBlockersByLayer: hardPlacedByLayer
+    });
+    out.push({ x, y, z, distance: d, zSpanLen: span.length, isEdgeSeed: true });
   }
-  /** Streaming visualization: board + obstacles + current placements. */
-  visualize() {
-    const rects = [];
-    const points = [];
-    const lines = [];
-    const boardBounds = {
-      minX: this.srj.bounds.minX,
-      maxX: this.srj.bounds.maxX,
-      minY: this.srj.bounds.minY,
-      maxY: this.srj.bounds.maxY
-    };
-    if (this.srj.outline && this.srj.outline.length > 1) {
-      lines.push({
-        points: [...this.srj.outline, this.srj.outline[0]],
-        // Close the loop by adding the first point again
-        strokeColor: "#111827",
-        strokeWidth: 0.01,
-        label: "outline"
-      });
-    } else {
-      rects.push({
-        center: {
-          x: (boardBounds.minX + boardBounds.maxX) / 2,
-          y: (boardBounds.minY + boardBounds.maxY) / 2
-        },
-        width: boardBounds.maxX - boardBounds.minX,
-        height: boardBounds.maxY - boardBounds.minY,
-        fill: "none",
-        stroke: "#111827",
-        label: "board"
-      });
+  for (let z = 0; z < layerCount; z++) {
+    const blockers = [
+      ...obstacleIndexByLayer[z]?.all() ?? [],
+      ...hardPlacedByLayer[z] ?? []
+    ];
+    const corners = [
+      { x: bounds.x + \u03B4, y: bounds.y + \u03B4 },
+      // top-left
+      { x: bounds.x + bounds.width - \u03B4, y: bounds.y + \u03B4 },
+      // top-right
+      { x: bounds.x + \u03B4, y: bounds.y + bounds.height - \u03B4 },
+      // bottom-left
+      { x: bounds.x + bounds.width - \u03B4, y: bounds.y + bounds.height - \u03B4 }
+      // bottom-right
+    ];
+    for (const corner of corners) {
+      pushIfFree({ x: corner.x, y: corner.y, z });
     }
-    for (const obstacle of this.srj.obstacles ?? []) {
-      if (obstacle.type === "rect" || obstacle.type === "oval") {
-        rects.push({
-          center: { x: obstacle.center.x, y: obstacle.center.y },
-          width: obstacle.width,
-          height: obstacle.height,
-          fill: "#fee2e2",
-          stroke: "#ef4444",
-          layer: "obstacle",
-          label: "obstacle"
-        });
+    const topY = bounds.y + \u03B4;
+    const topCovering = blockers.filter((b) => b.y <= topY && b.y + b.height >= topY).map((b) => ({
+      start: Math.max(bounds.x, b.x),
+      end: Math.min(bounds.x + bounds.width, b.x + b.width)
+    }));
+    const topUncovered = computeUncoveredSegments({
+      lineStart: bounds.x + \u03B4,
+      lineEnd: bounds.x + bounds.width - \u03B4,
+      coveringIntervals: topCovering,
+      minSegmentLength: minSize * 0.5
+    });
+    for (const seg of topUncovered) {
+      const segLen = seg.end - seg.start;
+      if (segLen >= minSize) {
+        pushIfFree({ x: seg.center, y: topY, z });
+        if (segLen > minSize * 1.5) {
+          pushIfFree({ x: seg.start + minSize * 0.4, y: topY, z });
+          pushIfFree({ x: seg.end - minSize * 0.4, y: topY, z });
+        }
       }
     }
-    if (this.state?.boardVoidRects) {
-      let outlineBBox = null;
-      if (this.srj.outline && this.srj.outline.length > 0) {
-        const xs = this.srj.outline.map((p) => p.x);
-        const ys = this.srj.outline.map((p) => p.y);
-        const minX = Math.min(...xs);
-        const minY = Math.min(...ys);
-        outlineBBox = {
-          x: minX,
-          y: minY,
-          width: Math.max(...xs) - minX,
-          height: Math.max(...ys) - minY
-        };
+    const bottomY = bounds.y + bounds.height - \u03B4;
+    const bottomCovering = blockers.filter((b) => b.y <= bottomY && b.y + b.height >= bottomY).map((b) => ({
+      start: Math.max(bounds.x, b.x),
+      end: Math.min(bounds.x + bounds.width, b.x + b.width)
+    }));
+    const bottomUncovered = computeUncoveredSegments({
+      lineStart: bounds.x + \u03B4,
+      lineEnd: bounds.x + bounds.width - \u03B4,
+      coveringIntervals: bottomCovering,
+      minSegmentLength: minSize * 0.5
+    });
+    for (const seg of bottomUncovered) {
+      const segLen = seg.end - seg.start;
+      if (segLen >= minSize) {
+        pushIfFree({ x: seg.center, y: bottomY, z });
+        if (segLen > minSize * 1.5) {
+          pushIfFree({ x: seg.start + minSize * 0.4, y: bottomY, z });
+          pushIfFree({ x: seg.end - minSize * 0.4, y: bottomY, z });
+        }
+      }
+    }
+    const leftX = bounds.x + \u03B4;
+    const leftCovering = blockers.filter((b) => b.x <= leftX && b.x + b.width >= leftX).map((b) => ({
+      start: Math.max(bounds.y, b.y),
+      end: Math.min(bounds.y + bounds.height, b.y + b.height)
+    }));
+    const leftUncovered = computeUncoveredSegments({
+      lineStart: bounds.y + \u03B4,
+      lineEnd: bounds.y + bounds.height - \u03B4,
+      coveringIntervals: leftCovering,
+      minSegmentLength: minSize * 0.5
+    });
+    for (const seg of leftUncovered) {
+      const segLen = seg.end - seg.start;
+      if (segLen >= minSize) {
+        pushIfFree({ x: leftX, y: seg.center, z });
+        if (segLen > minSize * 1.5) {
+          pushIfFree({ x: leftX, y: seg.start + minSize * 0.4, z });
+          pushIfFree({ x: leftX, y: seg.end - minSize * 0.4, z });
+        }
+      }
+    }
+    const rightX = bounds.x + bounds.width - \u03B4;
+    const rightCovering = blockers.filter((b) => b.x <= rightX && b.x + b.width >= rightX).map((b) => ({
+      start: Math.max(bounds.y, b.y),
+      end: Math.min(bounds.y + bounds.height, b.y + b.height)
+    }));
+    const rightUncovered = computeUncoveredSegments({
+      lineStart: bounds.y + \u03B4,
+      lineEnd: bounds.y + bounds.height - \u03B4,
+      coveringIntervals: rightCovering,
+      minSegmentLength: minSize * 0.5
+    });
+    for (const seg of rightUncovered) {
+      const segLen = seg.end - seg.start;
+      if (segLen >= minSize) {
+        pushIfFree({ x: rightX, y: seg.center, z });
+        if (segLen > minSize * 1.5) {
+          pushIfFree({ x: rightX, y: seg.start + minSize * 0.4, z });
+          pushIfFree({ x: rightX, y: seg.end - minSize * 0.4, z });
+        }
       }
-      for (const r of this.state.boardVoidRects) {
-        if (outlineBBox && !overlaps(r, outlineBBox)) {
-          continue;
+    }
+    for (const b of blockers) {
+      const obLeftX = b.x - \u03B4;
+      if (obLeftX > bounds.x + EPS4 && obLeftX < bounds.x + bounds.width - EPS4) {
+        const obLeftCovering = blockers.filter(
+          (bl) => bl !== b && bl.x <= obLeftX && bl.x + bl.width >= obLeftX
+        ).map((bl) => ({
+          start: Math.max(b.y, bl.y),
+          end: Math.min(b.y + b.height, bl.y + bl.height)
+        }));
+        const obLeftUncovered = computeUncoveredSegments({
+          lineStart: b.y,
+          lineEnd: b.y + b.height,
+          coveringIntervals: obLeftCovering,
+          minSegmentLength: minSize * 0.5
+        });
+        for (const seg of obLeftUncovered) {
+          pushIfFree({ x: obLeftX, y: seg.center, z });
         }
-        rects.push({
-          center: { x: r.x + r.width / 2, y: r.y + r.height / 2 },
-          width: r.width,
-          height: r.height,
-          fill: "rgba(0, 0, 0, 0.5)",
-          stroke: "none",
-          label: "void"
+      }
+      const obRightX = b.x + b.width + \u03B4;
+      if (obRightX > bounds.x + EPS4 && obRightX < bounds.x + bounds.width - EPS4) {
+        const obRightCovering = blockers.filter(
+          (bl) => bl !== b && bl.x <= obRightX && bl.x + bl.width >= obRightX
+        ).map((bl) => ({
+          start: Math.max(b.y, bl.y),
+          end: Math.min(b.y + b.height, bl.y + bl.height)
+        }));
+        const obRightUncovered = computeUncoveredSegments({
+          lineStart: b.y,
+          lineEnd: b.y + b.height,
+          coveringIntervals: obRightCovering,
+          minSegmentLength: minSize * 0.5
         });
+        for (const seg of obRightUncovered) {
+          pushIfFree({ x: obRightX, y: seg.center, z });
+        }
       }
-    }
-    if (this.state?.candidates?.length) {
-      for (const cand of this.state.candidates) {
-        points.push({
-          x: cand.x,
-          y: cand.y,
-          fill: "#9333ea",
-          stroke: "#6b21a8",
-          label: `z:${cand.z}`
+      const obTopY = b.y - \u03B4;
+      if (obTopY > bounds.y + EPS4 && obTopY < bounds.y + bounds.height - EPS4) {
+        const obTopCovering = blockers.filter(
+          (bl) => bl !== b && bl.y <= obTopY && bl.y + bl.height >= obTopY
+        ).map((bl) => ({
+          start: Math.max(b.x, bl.x),
+          end: Math.min(b.x + b.width, bl.x + bl.width)
+        }));
+        const obTopUncovered = computeUncoveredSegments({
+          lineStart: b.x,
+          lineEnd: b.x + b.width,
+          coveringIntervals: obTopCovering,
+          minSegmentLength: minSize * 0.5
         });
+        for (const seg of obTopUncovered) {
+          pushIfFree({ x: seg.center, y: obTopY, z });
+        }
       }
-    }
-    if (this.state?.placed?.length) {
-      for (const p of this.state.placed) {
-        const colors = this.getColorForZLayer(p.zLayers);
-        rects.push({
-          center: {
-            x: p.rect.x + p.rect.width / 2,
-            y: p.rect.y + p.rect.height / 2
-          },
-          width: p.rect.width,
-          height: p.rect.height,
-          fill: colors.fill,
-          stroke: colors.stroke,
-          layer: `z${p.zLayers.join(",")}`,
-          label: `free
-z:${p.zLayers.join(",")}`
+      const obBottomY = b.y + b.height + \u03B4;
+      if (obBottomY > bounds.y + EPS4 && obBottomY < bounds.y + bounds.height - EPS4) {
+        const obBottomCovering = blockers.filter(
+          (bl) => bl !== b && bl.y <= obBottomY && bl.y + bl.height >= obBottomY
+        ).map((bl) => ({
+          start: Math.max(b.x, bl.x),
+          end: Math.min(b.x + b.width, bl.x + bl.width)
+        }));
+        const obBottomUncovered = computeUncoveredSegments({
+          lineStart: b.x,
+          lineEnd: b.x + b.width,
+          coveringIntervals: obBottomCovering,
+          minSegmentLength: minSize * 0.5
         });
+        for (const seg of obBottomUncovered) {
+          pushIfFree({ x: seg.center, y: obBottomY, z });
+        }
       }
     }
-    return {
-      title: `RectDiff (${this.state?.phase ?? "init"})`,
-      coordinateSystem: "cartesian",
-      rects,
-      points,
-      lines
-      // Include lines in the returned GraphicsObject
-    };
-  }
-};
-
-// lib/solvers/rectdiff/visualization.ts
-function createBaseVisualization(srj, title = "RectDiff") {
-  const rects = [];
-  const lines = [];
-  const boardBounds = {
-    minX: srj.bounds.minX,
-    maxX: srj.bounds.maxX,
-    minY: srj.bounds.minY,
-    maxY: srj.bounds.maxY
-  };
-  if (srj.outline && srj.outline.length > 1) {
-    lines.push({
-      points: [...srj.outline, srj.outline[0]],
-      strokeColor: "#111827",
-      strokeWidth: 0.01,
-      label: "outline"
-    });
-  } else {
-    rects.push({
-      center: {
-        x: (boardBounds.minX + boardBounds.maxX) / 2,
-        y: (boardBounds.minY + boardBounds.maxY) / 2
-      },
-      width: boardBounds.maxX - boardBounds.minX,
-      height: boardBounds.maxY - boardBounds.minY,
-      fill: "none",
-      stroke: "#111827",
-      label: "board"
-    });
-  }
-  for (const obstacle of srj.obstacles ?? []) {
-    if (obstacle.type === "rect" || obstacle.type === "oval") {
-      rects.push({
-        center: { x: obstacle.center.x, y: obstacle.center.y },
-        width: obstacle.width,
-        height: obstacle.height,
-        fill: "#fee2e2",
-        stroke: "#ef4444",
-        layer: "obstacle",
-        label: "obstacle"
-      });
-    }
-  }
-  return {
-    title,
-    coordinateSystem: "cartesian",
-    rects,
-    points: [],
-    lines
-  };
-}
-
-// lib/solvers/GapFillSolver/GapFillSolverPipeline.ts
-import {
-  BasePipelineSolver as BasePipelineSolver2,
-  definePipelineStep
-} from "@tscircuit/solver-utils";
-
-// lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts
-import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
-import Flatbush from "flatbush";
-
-// lib/solvers/GapFillSolver/projectToUncoveredSegments.ts
-var EPS2 = 1e-4;
-function projectToUncoveredSegments(primaryEdge, overlappingEdges) {
-  const isHorizontal = Math.abs(primaryEdge.start.y - primaryEdge.end.y) < EPS2;
-  const isVertical = Math.abs(primaryEdge.start.x - primaryEdge.end.x) < EPS2;
-  if (!isHorizontal && !isVertical) return [];
-  const axis = isHorizontal ? "x" : "y";
-  const perp = isHorizontal ? "y" : "x";
-  const lineCoord = primaryEdge.start[perp];
-  const p0 = primaryEdge.start[axis];
-  const p1 = primaryEdge.end[axis];
-  const pMin = Math.min(p0, p1);
-  const pMax = Math.max(p0, p1);
-  const clamp2 = (v) => Math.max(pMin, Math.min(pMax, v));
-  const intervals = [];
-  for (const e of overlappingEdges) {
-    if (e === primaryEdge) continue;
-    const eIsHorizontal = Math.abs(e.start.y - e.end.y) < EPS2;
-    const eIsVertical = Math.abs(e.start.x - e.end.x) < EPS2;
-    if (axis === "x" && !eIsHorizontal) continue;
-    if (axis === "y" && !eIsVertical) 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 > EPS2) intervals.push({ s, e: t });
-  }
-  if (intervals.length === 0) {
-    return [
-      {
-        ...primaryEdge,
-        start: { ...primaryEdge.start },
-        end: { ...primaryEdge.end }
-      }
-    ];
-  }
-  intervals.sort((a, b) => a.s - b.s);
-  const merged = [];
-  for (const it of intervals) {
-    const last = merged[merged.length - 1];
-    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 + EPS2) uncovered.push({ s: cursor, e: m.s });
-    cursor = Math.max(cursor, m.e);
-    if (cursor >= pMax - EPS2) break;
-  }
-  if (pMax > cursor + EPS2) uncovered.push({ s: cursor, e: pMax });
-  if (uncovered.length === 0) return [];
-  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 {
-      parent: primaryEdge.parent,
-      facingDirection: primaryEdge.facingDirection,
-      start,
-      end,
-      z: primaryEdge.z
-    };
-  });
-}
-
-// lib/solvers/GapFillSolver/edge-constants.ts
-var EDGES = [
-  {
-    facingDirection: "x-",
-    dx: -1,
-    dy: 0,
-    startX: -0.5,
-    startY: 0.5,
-    endX: -0.5,
-    endY: -0.5
-  },
-  {
-    facingDirection: "x+",
-    dx: 1,
-    dy: 0,
-    startX: 0.5,
-    startY: 0.5,
-    endX: 0.5,
-    endY: -0.5
-  },
-  {
-    facingDirection: "y-",
-    dx: 0,
-    dy: -1,
-    startX: -0.5,
-    startY: -0.5,
-    endX: 0.5,
-    endY: -0.5
-  },
-  {
-    facingDirection: "y+",
-    dx: 0,
-    dy: 1,
-    startX: 0.5,
-    startY: 0.5,
-    endX: -0.5,
-    endY: 0.5
   }
-];
-var EDGE_MAP = {
-  "x-": EDGES.find((e) => e.facingDirection === "x-"),
-  "x+": EDGES.find((e) => e.facingDirection === "x+"),
-  "y-": EDGES.find((e) => e.facingDirection === "y-"),
-  "y+": EDGES.find((e) => e.facingDirection === "y+")
-};
+  out.sort((a, b) => b.zSpanLen - a.zSpanLen || b.distance - a.distance);
+  return out;
+}
 
-// lib/solvers/GapFillSolver/visuallyOffsetLine.ts
-var OFFSET_DIR_MAP = {
-  "x-": {
-    x: -1,
-    y: 0
-  },
-  "x+": {
-    x: 1,
-    y: 0
-  },
-  "y-": {
-    x: 0,
-    y: -1
-  },
-  "y+": {
-    x: 0,
-    y: 1
+// lib/utils/buildHardPlacedByLayer.ts
+function allLayerNode(params) {
+  const out = Array.from({ length: params.layerCount }, () => []);
+  for (const p of params.placed) {
+    if (p.zLayers.length >= params.layerCount) {
+      for (const z of p.zLayers) out[z].push(p.rect);
+    }
   }
-};
-var visuallyOffsetLine = (line, dir, amt) => {
-  const offset = OFFSET_DIR_MAP[dir];
-  return line.map((p) => ({
-    x: p.x + offset.x * amt,
-    y: p.y + offset.y * amt
-  }));
-};
+  return out;
+}
 
-// lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts
-import "@tscircuit/math-utils";
-var EPS3 = 1e-4;
-var FindSegmentsWithAdjacentEmptySpaceSolver = class extends BaseSolver2 {
+// lib/utils/resizeSoftOverlaps.ts
+function resizeSoftOverlaps(params, newIndex) {
+  const newcomer = params.placed[newIndex];
+  const { rect: newR, zLayers: newZs } = newcomer;
+  const layerCount = params.layerCount;
+  const removeIdx = [];
+  const toAdd = [];
+  for (let i = 0; i < params.placed.length; i++) {
+    if (i === newIndex) continue;
+    const old = params.placed[i];
+    if (old.zLayers.length >= layerCount) continue;
+    const sharedZ = old.zLayers.filter((z) => newZs.includes(z));
+    if (sharedZ.length === 0) continue;
+    if (!overlaps(old.rect, newR)) continue;
+    const parts = subtractRect2D(old.rect, newR);
+    removeIdx.push(i);
+    const unaffectedZ = old.zLayers.filter((z) => !newZs.includes(z));
+    if (unaffectedZ.length > 0) {
+      toAdd.push({ rect: old.rect, zLayers: unaffectedZ });
+    }
+    const minW = Math.min(
+      params.options.minSingle.width,
+      params.options.minMulti.width
+    );
+    const minH = Math.min(
+      params.options.minSingle.height,
+      params.options.minMulti.height
+    );
+    for (const p of parts) {
+      if (p.width + EPS4 >= minW && p.height + EPS4 >= minH) {
+        toAdd.push({ rect: p, zLayers: sharedZ.slice() });
+      }
+    }
+  }
+  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];
+    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) {
+      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();
     this.input = input;
-    for (const node of this.input.meshNodes) {
-      for (const edge of EDGES) {
-        let start = {
-          x: node.center.x + node.width * edge.startX,
-          y: node.center.y + node.height * edge.startY
-        };
-        let end = {
-          x: node.center.x + node.width * edge.endX,
-          y: node.center.y + node.height * edge.endY
-        };
-        if (start.x > end.x) {
-          ;
-          [start, end] = [end, start];
-        }
-        if (Math.abs(start.x - end.x) < EPS3 && start.y > end.y) {
-          ;
-          [start, end] = [end, start];
-        }
-        for (const z of node.availableZ) {
-          this.unprocessedEdges.push({
-            parent: node,
-            start,
-            end,
-            facingDirection: edge.facingDirection,
-            z
+  }
+  // Engine fields (mirrors initState / engine.ts)
+  srj;
+  layerNames;
+  layerCount;
+  bounds;
+  options;
+  boardVoidRects;
+  gridIndex;
+  candidates;
+  placed;
+  placedIndexByLayer;
+  expansionIndex;
+  edgeAnalysisDone;
+  totalSeedsThisGrid;
+  consumedSeedsThisGrid;
+  _setup() {
+    const srj = this.input.simpleRouteJson;
+    const opts = this.input.gridOptions ?? {};
+    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 trace = Math.max(0.01, srj.minTraceWidth || 0.15);
+    const defaults = {
+      gridSizes: [],
+      initialCellRatio: 0.2,
+      maxAspectRatio: 3,
+      minSingle: { width: 2 * trace, height: 2 * trace },
+      minMulti: {
+        width: 4 * trace,
+        height: 4 * trace,
+        minLayers: Math.min(2, Math.max(1, srj.layerCount || 1))
+      },
+      preferMultiLayer: true,
+      maxMultiLayerSpan: void 0
+    };
+    const options = {
+      ...defaults,
+      ...opts,
+      gridSizes: opts.gridSizes ?? // re-use the helper that was previously in engine
+      computeDefaultGridSizes(bounds)
+    };
+    this.srj = srj;
+    this.layerNames = layerNames;
+    this.layerCount = layerCount;
+    this.bounds = bounds;
+    this.options = options;
+    this.boardVoidRects = this.input.boardVoidRects;
+    this.gridIndex = 0;
+    this.candidates = [];
+    this.placed = [];
+    this.placedIndexByLayer = Array.from(
+      { length: layerCount },
+      () => new RBush3()
+    );
+    this.expansionIndex = 0;
+    this.edgeAnalysisDone = false;
+    this.totalSeedsThisGrid = 0;
+    this.consumedSeedsThisGrid = 0;
+    this.stats = {
+      gridIndex: this.gridIndex
+    };
+  }
+  /** Exactly ONE grid candidate step per call. */
+  _step() {
+    this._stepGrid();
+    this.stats.gridIndex = this.gridIndex;
+    this.stats.placed = this.placed.length;
+  }
+  /**
+   * One micro-step during the GRID phase: handle exactly one candidate.
+   */
+  _stepGrid() {
+    const {
+      gridSizes,
+      initialCellRatio,
+      maxAspectRatio,
+      minSingle,
+      minMulti,
+      preferMultiLayer,
+      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,
+        obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+        placedIndexByLayer: this.placedIndexByLayer
+      });
+      this.totalSeedsThisGrid = this.candidates.length;
+      this.consumedSeedsThisGrid = 0;
+    }
+    if (this.candidates.length === 0) {
+      if (this.gridIndex + 1 < gridSizes.length) {
+        this.gridIndex += 1;
+        this.totalSeedsThisGrid = 0;
+        this.consumedSeedsThisGrid = 0;
+        return;
+      } else {
+        if (!this.edgeAnalysisDone) {
+          const minSize = Math.min(minSingle.width, minSingle.height);
+          this.candidates = computeEdgeCandidates3D({
+            bounds: this.bounds,
+            minSize,
+            layerCount: this.layerCount,
+            obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+            placedIndexByLayer: this.placedIndexByLayer,
+            hardPlacedByLayer
           });
+          this.edgeAnalysisDone = true;
+          this.totalSeedsThisGrid = this.candidates.length;
+          this.consumedSeedsThisGrid = 0;
+          return;
         }
+        this.solved = true;
+        this.expansionIndex = 0;
+        return;
       }
     }
-    this.allEdges = [...this.unprocessedEdges];
-    this.edgeSpatialIndex = new Flatbush(this.allEdges.length);
-    for (const edge of this.allEdges) {
-      this.edgeSpatialIndex.add(
-        edge.start.x,
-        edge.start.y,
-        edge.end.x,
-        edge.end.y
+    const cand = this.candidates.shift();
+    this.consumedSeedsThisGrid += 1;
+    const span = longestFreeSpanAroundZ({
+      x: cand.x,
+      y: cand.y,
+      z: cand.z,
+      layerCount: this.layerCount,
+      minSpan: minMulti.minLayers,
+      maxSpan: maxMultiLayerSpan,
+      obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+      additionalBlockersByLayer: hardPlacedByLayer
+    });
+    const attempts = [];
+    if (span.length >= minMulti.minLayers) {
+      attempts.push({
+        kind: "multi",
+        layers: span,
+        minReq: { width: minMulti.width, height: minMulti.height }
+      });
+    }
+    attempts.push({
+      kind: "single",
+      layers: [cand.z],
+      minReq: { width: minSingle.width, height: minSingle.height }
+    });
+    const ordered = preferMultiLayer ? attempts : attempts.reverse();
+    for (const attempt of ordered) {
+      const hardBlockers = [];
+      for (const z of attempt.layers) {
+        const obstacleLayer = this.input.obstacleIndexByLayer[z];
+        if (obstacleLayer) hardBlockers.push(...obstacleLayer.all());
+        if (hardPlacedByLayer[z]) hardBlockers.push(...hardPlacedByLayer[z]);
+      }
+      const rect = expandRectFromSeed({
+        startX: cand.x,
+        startY: cand.y,
+        gridSize: grid,
+        bounds: this.bounds,
+        blockers: hardBlockers,
+        initialCellRatio,
+        maxAspectRatio,
+        minReq: attempt.minReq
+      });
+      if (!rect) continue;
+      const placed = { rect, zLayers: [...attempt.layers] };
+      const newIndex = this.placed.push(placed) - 1;
+      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,
+          options: this.options,
+          placedIndexByLayer: this.placedIndexByLayer
+        },
+        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 }
+        })
       );
+      return;
     }
-    this.edgeSpatialIndex.finish();
   }
-  allEdges;
-  unprocessedEdges = [];
-  segmentsWithAdjacentEmptySpace = [];
-  edgeSpatialIndex;
-  lastCandidateEdge = null;
-  lastOverlappingEdges = null;
-  lastUncoveredSegments = null;
-  _step() {
-    if (this.unprocessedEdges.length === 0) {
-      this.solved = true;
-      this.lastCandidateEdge = null;
-      this.lastOverlappingEdges = null;
-      this.lastUncoveredSegments = null;
-      return;
+  /** Compute solver progress (0 to 1) during GRID phase. */
+  computeProgress() {
+    if (this.solved) {
+      return 1;
     }
-    const candidateEdge = this.unprocessedEdges.shift();
-    this.lastCandidateEdge = candidateEdge;
-    const nearbyEdges = this.edgeSpatialIndex.search(
-      candidateEdge.start.x - EPS3,
-      candidateEdge.start.y - EPS3,
-      candidateEdge.end.x + EPS3,
-      candidateEdge.end.y + EPS3
-    );
-    const overlappingEdges = nearbyEdges.map((i) => this.allEdges[i]).filter((e) => e.z === candidateEdge.z);
-    this.lastOverlappingEdges = overlappingEdges;
-    const uncoveredSegments = projectToUncoveredSegments(
-      candidateEdge,
-      overlappingEdges
-    );
-    this.lastUncoveredSegments = uncoveredSegments;
-    this.segmentsWithAdjacentEmptySpace.push(...uncoveredSegments);
+    const grids = this.options.gridSizes.length;
+    const g = this.gridIndex;
+    const base = g / (grids + 1);
+    const denom = Math.max(1, this.totalSeedsThisGrid);
+    const frac = denom ? this.consumedSeedsThisGrid / denom : 1;
+    return Math.min(0.999, base + frac * (1 / (grids + 1)));
   }
+  /**
+   * Output the intermediate RectDiff engine data to feed into the
+   * expansion phase solver.
+   */
   getOutput() {
     return {
-      segmentsWithAdjacentEmptySpace: this.segmentsWithAdjacentEmptySpace
+      srj: this.srj,
+      layerNames: this.layerNames,
+      layerCount: this.layerCount,
+      bounds: this.bounds,
+      options: this.options,
+      boardVoidRects: this.boardVoidRects,
+      gridIndex: this.gridIndex,
+      candidates: this.candidates,
+      placed: this.placed,
+      expansionIndex: this.expansionIndex,
+      edgeAnalysisDone: this.edgeAnalysisDone,
+      totalSeedsThisGrid: this.totalSeedsThisGrid,
+      consumedSeedsThisGrid: this.consumedSeedsThisGrid
     };
   }
+  /** Get color based on z layer for visualization. */
+  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];
+  }
+  /** Visualization focused on the grid seeding phase. */
   visualize() {
-    const graphics = {
-      title: "FindSegmentsWithAdjacentEmptySpace",
-      coordinateSystem: "cartesian",
-      rects: [],
-      points: [],
-      lines: [],
-      circles: [],
-      arrows: [],
-      texts: []
+    const rects = [];
+    const points = [];
+    const lines = [];
+    const srj = this.srj ?? this.input.simpleRouteJson;
+    const boardBounds = {
+      minX: srj.bounds.minX,
+      maxX: srj.bounds.maxX,
+      minY: srj.bounds.minY,
+      maxY: srj.bounds.maxY
     };
-    for (const node of this.input.meshNodes) {
-      graphics.rects.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        stroke: "rgba(0, 0, 0, 0.1)"
+    if (srj.outline && srj.outline.length > 1) {
+      lines.push({
+        points: [...srj.outline, srj.outline[0]],
+        strokeColor: "#111827",
+        strokeWidth: 0.01,
+        label: "outline"
       });
-    }
-    for (const unprocessedEdge of this.unprocessedEdges) {
-      graphics.lines.push({
-        points: visuallyOffsetLine(
-          [unprocessedEdge.start, unprocessedEdge.end],
-          unprocessedEdge.facingDirection,
-          -0.1
-        ),
-        strokeColor: "rgba(0, 0, 255, 0.5)",
-        strokeDash: "5 5"
+    } else {
+      rects.push({
+        center: {
+          x: (boardBounds.minX + boardBounds.maxX) / 2,
+          y: (boardBounds.minY + boardBounds.maxY) / 2
+        },
+        width: boardBounds.maxX - boardBounds.minX,
+        height: boardBounds.maxY - boardBounds.minY,
+        fill: "none",
+        stroke: "#111827",
+        label: "board"
       });
     }
-    for (const edge of this.segmentsWithAdjacentEmptySpace) {
-      graphics.lines.push({
-        points: [edge.start, edge.end],
-        strokeColor: "rgba(0,255,0, 0.5)"
-      });
+    for (const obstacle of srj.obstacles ?? []) {
+      if (obstacle.type === "rect" || obstacle.type === "oval") {
+        rects.push({
+          center: { x: obstacle.center.x, y: obstacle.center.y },
+          width: obstacle.width,
+          height: obstacle.height,
+          fill: "#fee2e2",
+          stroke: "#ef4444",
+          layer: "obstacle",
+          label: "obstacle"
+        });
+      }
     }
-    if (this.lastCandidateEdge) {
-      graphics.lines.push({
-        points: [this.lastCandidateEdge.start, this.lastCandidateEdge.end],
-        strokeColor: "blue"
-      });
+    if (this.boardVoidRects) {
+      let outlineBBox = null;
+      if (srj.outline && srj.outline.length > 0) {
+        const xs = srj.outline.map((p) => p.x);
+        const ys = srj.outline.map((p) => p.y);
+        const minX = Math.min(...xs);
+        const minY = Math.min(...ys);
+        outlineBBox = {
+          x: minX,
+          y: minY,
+          width: Math.max(...xs) - minX,
+          height: Math.max(...ys) - minY
+        };
+      }
+      for (const r of this.boardVoidRects) {
+        if (outlineBBox && !overlaps(r, outlineBBox)) {
+          continue;
+        }
+        rects.push({
+          center: { x: r.x + r.width / 2, y: r.y + r.height / 2 },
+          width: r.width,
+          height: r.height,
+          fill: "rgba(0, 0, 0, 0.5)",
+          stroke: "none",
+          label: "void"
+        });
+      }
     }
-    if (this.lastOverlappingEdges) {
-      for (const edge of this.lastOverlappingEdges) {
-        graphics.lines.push({
-          points: visuallyOffsetLine(
-            [edge.start, edge.end],
-            edge.facingDirection,
-            0.05
-          ),
-          strokeColor: "red",
-          strokeDash: "2 2"
+    if (this.candidates?.length) {
+      for (const cand of this.candidates) {
+        points.push({
+          x: cand.x,
+          y: cand.y,
+          fill: "#9333ea",
+          stroke: "#6b21a8",
+          label: `z:${cand.z}`
         });
       }
     }
-    if (this.lastUncoveredSegments) {
-      for (const edge of this.lastUncoveredSegments) {
-        graphics.lines.push({
-          points: visuallyOffsetLine(
-            [edge.start, edge.end],
-            edge.facingDirection,
-            -0.05
-          ),
-          strokeColor: "green",
-          strokeDash: "2 2"
+    if (this.placed?.length) {
+      for (const placement of this.placed) {
+        const colors = this.getColorForZLayer(placement.zLayers);
+        rects.push({
+          center: {
+            x: placement.rect.x + placement.rect.width / 2,
+            y: placement.rect.y + placement.rect.height / 2
+          },
+          width: placement.rect.width,
+          height: placement.rect.height,
+          fill: colors.fill,
+          stroke: colors.stroke,
+          layer: `z${placement.zLayers.join(",")}`,
+          label: `free
+z:${placement.zLayers.join(",")}`
         });
       }
     }
-    return graphics;
+    return {
+      title: "RectDiff Grid",
+      coordinateSystem: "cartesian",
+      rects,
+      points,
+      lines
+    };
   }
 };
 
-// lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts
-import { BaseSolver as BaseSolver3 } from "@tscircuit/solver-utils";
-import RBush from "rbush";
+// lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts
+import { BaseSolver as BaseSolver4 } from "@tscircuit/solver-utils";
 
-// lib/solvers/GapFillSolver/getBoundsFromCorners.ts
-var getBoundsFromCorners = (corners) => {
-  return {
-    minX: Math.min(...corners.map((c) => c.x)),
-    minY: Math.min(...corners.map((c) => c.y)),
-    maxX: Math.max(...corners.map((c) => c.x)),
-    maxY: Math.max(...corners.map((c) => c.y))
-  };
-};
+// lib/utils/finalizeRects.ts
+function finalizeRects(params) {
+  const out = params.placed.map((p) => ({
+    minX: p.rect.x,
+    minY: p.rect.y,
+    maxX: p.rect.x + p.rect.width,
+    maxY: p.rect.y + p.rect.height,
+    zLayers: [...p.zLayers].sort((a, b) => a - b)
+  }));
+  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: Array.from(layers).sort((a, b) => a - b),
+      isObstacle: true
+    });
+  }
+  return out;
+}
 
-// lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts
-import { segmentToBoxMinDistance } from "@tscircuit/math-utils";
-var EPS4 = 1e-4;
-var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver3 {
+// lib/solvers/RectDiffExpansionSolver/rectsToMeshNodes.ts
+function rectsToMeshNodes(rects) {
+  let id = 0;
+  const out = [];
+  for (const r of rects) {
+    const w = Math.max(0, r.maxX - r.minX);
+    const h = Math.max(0, r.maxY - r.minY);
+    if (w <= 0 || h <= 0 || r.zLayers.length === 0) continue;
+    out.push({
+      capacityMeshNodeId: `cmn_${id++}`,
+      center: { x: (r.minX + r.maxX) / 2, y: (r.minY + r.maxY) / 2 },
+      width: w,
+      height: h,
+      layer: "top",
+      availableZ: r.zLayers.slice(),
+      _containsObstacle: r.isObstacle,
+      _containsTarget: r.isObstacle
+    });
+  }
+  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) {
     super();
     this.input = input;
-    this.unprocessedSegments = [...this.input.segmentsWithAdjacentEmptySpace];
-    this.rectSpatialIndex = new RBush();
-    this.rectSpatialIndex.load(
-      this.input.inputMeshNodes.map((n) => ({
-        ...n,
-        minX: n.center.x - n.width / 2,
-        minY: n.center.y - n.height / 2,
-        maxX: n.center.x + n.width / 2,
-        maxY: n.center.y + n.height / 2
-      }))
-    );
+    Object.assign(this, this.input.initialSnapshot);
   }
-  unprocessedSegments = [];
-  expandedSegments = [];
-  lastSegment = null;
-  lastSearchBounds = null;
-  lastCollidingNodes = null;
-  lastSearchCorner1 = null;
-  lastSearchCorner2 = null;
-  lastExpandedSegment = null;
-  rectSpatialIndex;
-  _step() {
-    if (this.unprocessedSegments.length === 0) {
-      this.solved = true;
-      return;
-    }
-    const segment = this.unprocessedSegments.shift();
-    this.lastSegment = segment;
-    const { dx, dy } = EDGE_MAP[segment.facingDirection];
-    const deltaStartEnd = {
-      x: segment.end.x - segment.start.x,
-      y: segment.end.y - segment.start.y
-    };
-    const segLength = Math.sqrt(deltaStartEnd.x ** 2 + deltaStartEnd.y ** 2);
-    const normDeltaStartEnd = {
-      x: deltaStartEnd.x / segLength,
-      y: deltaStartEnd.y / segLength
-    };
-    let collidingNodes = null;
-    let searchDistance = 1;
-    const searchCorner1 = {
-      x: segment.start.x + dx * EPS4 + normDeltaStartEnd.x * EPS4 * 10,
-      y: segment.start.y + dy * EPS4 + normDeltaStartEnd.y * EPS4 * 10
-    };
-    const searchCorner2 = {
-      x: segment.end.x + dx * EPS4 - normDeltaStartEnd.x * EPS4 * 10,
-      y: segment.end.y + dy * EPS4 - normDeltaStartEnd.y * EPS4 * 10
+  // Engine fields (same shape used by rectdiff/engine.ts)
+  srj;
+  layerNames;
+  layerCount;
+  bounds;
+  options;
+  boardVoidRects;
+  gridIndex;
+  candidates;
+  placed;
+  placedIndexByLayer;
+  expansionIndex;
+  edgeAnalysisDone;
+  totalSeedsThisGrid;
+  consumedSeedsThisGrid;
+  _meshNodes = [];
+  _setup() {
+    this.stats = {
+      gridIndex: this.gridIndex
     };
-    this.lastSearchCorner1 = searchCorner1;
-    this.lastSearchCorner2 = searchCorner2;
-    while ((!collidingNodes || collidingNodes.length === 0) && searchDistance < 1e3) {
-      const searchBounds = getBoundsFromCorners([
-        searchCorner1,
-        searchCorner2,
-        {
-          x: searchCorner1.x + dx * searchDistance,
-          y: searchCorner1.y + dy * searchDistance
-        },
-        {
-          x: searchCorner2.x + dx * searchDistance,
-          y: searchCorner2.y + dy * searchDistance
-        }
-      ]);
-      this.lastSearchBounds = searchBounds;
-      collidingNodes = this.rectSpatialIndex.search(searchBounds).filter((n) => n.availableZ.includes(segment.z)).filter(
-        (n) => n.capacityMeshNodeId !== segment.parent.capacityMeshNodeId
+    if (this.input.obstacleIndexByLayer) {
+    } else {
+      const { zIndexByName } = buildZIndexMap(this.srj);
+      this.input.obstacleIndexByLayer = Array.from(
+        { length: this.layerCount },
+        () => new RBush4()
       );
-      searchDistance *= 4;
-    }
-    if (!collidingNodes || collidingNodes.length === 0) {
-      return;
-    }
-    this.lastCollidingNodes = collidingNodes;
-    let smallestDistance = Infinity;
-    for (const node of collidingNodes) {
-      const distance = segmentToBoxMinDistance(segment.start, segment.end, node);
-      if (distance < smallestDistance) {
-        smallestDistance = distance;
+      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);
       }
-    }
-    const expandDistance = smallestDistance;
-    const nodeBounds = getBoundsFromCorners([
-      segment.start,
-      segment.end,
-      {
-        x: segment.start.x + dx * expandDistance,
-        y: segment.start.y + dy * expandDistance
-      },
-      {
-        x: segment.end.x + dx * expandDistance,
-        y: segment.end.y + dy * expandDistance
+      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);
+        });
       }
-    ]);
-    const nodeCenter = {
-      x: (nodeBounds.minX + nodeBounds.maxX) / 2,
-      y: (nodeBounds.minY + nodeBounds.maxY) / 2
-    };
-    const nodeWidth = nodeBounds.maxX - nodeBounds.minX;
-    const nodeHeight = nodeBounds.maxY - nodeBounds.minY;
-    const expandedSegment = {
-      segment,
-      newNode: {
-        capacityMeshNodeId: `new-${segment.parent.capacityMeshNodeId}-${this.expandedSegments.length}`,
-        center: nodeCenter,
-        width: nodeWidth,
-        height: nodeHeight,
-        availableZ: [segment.z],
-        layer: segment.parent.layer
+    }
+    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));
       }
-    };
-    this.lastExpandedSegment = expandedSegment;
-    if (nodeWidth < EPS4 || nodeHeight < EPS4) {
-      return;
     }
-    this.expandedSegments.push(expandedSegment);
-    this.rectSpatialIndex.insert({
-      ...expandedSegment.newNode,
-      ...nodeBounds
-    });
   }
-  getOutput() {
-    return {
-      expandedSegments: this.expandedSegments
-    };
+  _step() {
+    if (this.solved) return;
+    this._stepExpansion();
+    this.stats.gridIndex = this.gridIndex;
+    this.stats.placed = this.placed.length;
+    if (this.expansionIndex >= this.placed.length) {
+      this.finalizeIfNeeded();
+    }
   }
-  visualize() {
-    const graphics = {
-      title: "ExpandEdgesToEmptySpace",
-      coordinateSystem: "cartesian",
-      rects: [],
-      points: [],
-      lines: [],
-      circles: [],
-      arrows: [],
-      texts: []
-    };
-    for (const node of this.input.inputMeshNodes) {
-      graphics.rects.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        stroke: "rgba(0, 0, 0, 0.1)",
-        layer: `z${node.availableZ.join(",")}`,
-        label: [
-          `node ${node.capacityMeshNodeId}`,
-          `z:${node.availableZ.join(",")}`
-        ].join("\n")
-      });
+  _stepExpansion() {
+    if (this.expansionIndex >= this.placed.length) {
+      return;
     }
-    for (const { newNode } of this.expandedSegments) {
-      graphics.rects.push({
-        center: newNode.center,
-        width: newNode.width,
-        height: newNode.height,
-        fill: "green",
-        label: `expandedSegment (z=${newNode.availableZ.join(",")})`,
-        layer: `z${newNode.availableZ.join(",")}`
-      });
+    const idx = this.expansionIndex;
+    const p = this.placed[idx];
+    const lastGrid = this.options.gridSizes[this.options.gridSizes.length - 1];
+    const hardPlacedByLayer = allLayerNode({
+      layerCount: this.layerCount,
+      placed: this.placed
+    });
+    const hardBlockers = [];
+    for (const z of p.zLayers) {
+      const obstacleTree = this.input.obstacleIndexByLayer[z];
+      if (obstacleTree) hardBlockers.push(...obstacleTree.all());
+      hardBlockers.push(...hardPlacedByLayer[z] ?? []);
+    }
+    const oldRect = p.rect;
+    const expanded = expandRectFromSeed({
+      startX: p.rect.x + p.rect.width / 2,
+      startY: p.rect.y + p.rect.height / 2,
+      gridSize: lastGrid,
+      bounds: this.bounds,
+      blockers: hardBlockers,
+      initialCellRatio: 0,
+      maxAspectRatio: null,
+      minReq: { width: p.rect.width, height: p.rect.height }
+    });
+    if (expanded) {
+      this.placed[idx] = { rect: expanded, zLayers: p.zLayers };
+      for (const z of p.zLayers) {
+        const tree = this.placedIndexByLayer[z];
+        if (tree) {
+          tree.remove(rectToTree(oldRect), sameTreeRect);
+          tree.insert(rectToTree(expanded));
+        }
+      }
+      resizeSoftOverlaps(
+        {
+          layerCount: this.layerCount,
+          placed: this.placed,
+          options: this.options,
+          placedIndexByLayer: this.placedIndexByLayer
+        },
+        idx
+      );
     }
-    if (this.lastSegment) {
-      graphics.lines.push({
-        points: [this.lastSegment.start, this.lastSegment.end],
-        strokeColor: "rgba(0, 0, 255, 0.5)"
-      });
+    this.expansionIndex += 1;
+  }
+  finalizeIfNeeded() {
+    if (this.solved) return;
+    const rects = finalizeRects({
+      placed: this.placed,
+      srj: this.srj,
+      boardVoidRects: this.boardVoidRects
+    });
+    this._meshNodes = rectsToMeshNodes(rects);
+    this.solved = true;
+  }
+  computeProgress() {
+    if (this.solved) return 1;
+    const grids = this.options.gridSizes.length;
+    const base = grids / (grids + 1);
+    const denom = Math.max(1, this.placed.length);
+    const frac = denom ? this.expansionIndex / denom : 1;
+    return Math.min(0.999, base + frac * (1 / (grids + 1)));
+  }
+  getOutput() {
+    if (!this.solved && this._meshNodes.length === 0) {
+      this.finalizeIfNeeded();
     }
-    if (this.lastSearchBounds) {
-      graphics.rects.push({
+    return { meshNodes: this._meshNodes };
+  }
+  /** Simple visualization of expanded placements. */
+  visualize() {
+    const rects = [];
+    for (const placement of this.placed ?? []) {
+      rects.push({
         center: {
-          x: (this.lastSearchBounds.minX + this.lastSearchBounds.maxX) / 2,
-          y: (this.lastSearchBounds.minY + this.lastSearchBounds.maxY) / 2
+          x: placement.rect.x + placement.rect.width / 2,
+          y: placement.rect.y + placement.rect.height / 2
         },
-        width: this.lastSearchBounds.maxX - this.lastSearchBounds.minX,
-        height: this.lastSearchBounds.maxY - this.lastSearchBounds.minY,
-        fill: "rgba(0, 0, 255, 0.25)"
+        width: placement.rect.width,
+        height: placement.rect.height,
+        stroke: "rgba(37, 99, 235, 0.9)",
+        fill: "rgba(191, 219, 254, 0.5)",
+        layer: `z${placement.zLayers.join(",")}`,
+        label: `expanded
+z:${placement.zLayers.join(",")}`
       });
     }
-    if (this.lastSearchCorner1 && this.lastSearchCorner2) {
-      graphics.points.push({
-        x: this.lastSearchCorner1.x,
-        y: this.lastSearchCorner1.y,
-        color: "rgba(0, 0, 255, 0.5)",
-        label: ["searchCorner1", `z=${this.lastSegment?.z}`].join("\n")
-      });
-      graphics.points.push({
-        x: this.lastSearchCorner2.x,
-        y: this.lastSearchCorner2.y,
-        color: "rgba(0, 0, 255, 0.5)",
-        label: ["searchCorner2", `z=${this.lastSegment?.z}`].join("\n")
-      });
+    return {
+      title: "RectDiff Expansion",
+      coordinateSystem: "cartesian",
+      rects,
+      points: [],
+      lines: []
+    };
+  }
+};
+
+// 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);
     }
-    if (this.lastExpandedSegment) {
-      graphics.rects.push({
-        center: this.lastExpandedSegment.newNode.center,
-        width: this.lastExpandedSegment.newNode.width,
-        height: this.lastExpandedSegment.newNode.height,
-        fill: "purple",
-        label: `expandedSegment (z=${this.lastExpandedSegment.segment.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 (this.lastCollidingNodes) {
-      for (const node of this.lastCollidingNodes) {
-        graphics.rects.push({
-          center: node.center,
-          width: node.width,
-          height: node.height,
-          fill: "rgba(255, 0, 0, 0.5)"
-        });
-      }
+    if ((!obstacle.zLayers || obstacle.zLayers.length === 0) && zLayers.length) {
+      obstacle.zLayers = zLayers;
     }
-    return graphics;
+    for (const z of zLayers) insertObstacle(rect, z);
   }
+  return { obstacleIndexByLayer, boardVoidRects };
 };
 
-// lib/solvers/GapFillSolver/GapFillSolverPipeline.ts
-var GapFillSolverPipeline = class extends BasePipelineSolver2 {
-  findSegmentsWithAdjacentEmptySpaceSolver;
-  expandEdgesToEmptySpaceSolver;
+// 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 = [
-    definePipelineStep(
-      "findSegmentsWithAdjacentEmptySpaceSolver",
-      FindSegmentsWithAdjacentEmptySpaceSolver,
-      (gapFillPipeline) => [
+    definePipelineStep2(
+      "rectDiffSeedingSolver",
+      RectDiffSeedingSolver,
+      (pipeline) => [
         {
-          meshNodes: gapFillPipeline.inputProblem.meshNodes
-        }
-      ],
-      {
-        onSolved: () => {
+          simpleRouteJson: pipeline.inputProblem.simpleRouteJson,
+          gridOptions: pipeline.inputProblem.gridOptions,
+          obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
+          boardVoidRects: pipeline.boardVoidRects
         }
-      }
+      ]
     ),
-    definePipelineStep(
-      "expandEdgesToEmptySpaceSolver",
-      ExpandEdgesToEmptySpaceSolver,
-      (gapFillPipeline) => [
+    definePipelineStep2(
+      "rectDiffExpansionSolver",
+      RectDiffExpansionSolver,
+      (pipeline) => [
         {
-          inputMeshNodes: gapFillPipeline.inputProblem.meshNodes,
-          segmentsWithAdjacentEmptySpace: gapFillPipeline.findSegmentsWithAdjacentEmptySpaceSolver.getOutput().segmentsWithAdjacentEmptySpace
-        }
-      ],
-      {
-        onSolved: () => {
+          initialSnapshot: {
+            ...pipeline.rectDiffSeedingSolver.getOutput(),
+            boardVoidRects: pipeline.boardVoidRects ?? []
+          },
+          obstacleIndexByLayer: pipeline.obstacleIndexByLayer
         }
-      }
+      ]
     )
   ];
-  getOutput() {
-    const expandedSegments = this.expandEdgesToEmptySpaceSolver?.getOutput().expandedSegments ?? [];
-    const expandedNodes = expandedSegments.map((es) => es.newNode);
-    return {
-      outputNodes: [...this.inputProblem.meshNodes, ...expandedNodes]
-    };
+  getConstructorParams() {
+    return [this.inputProblem];
   }
-  initialVisualize() {
-    const graphics = {
-      title: "GapFillSolverPipeline - Initial",
-      coordinateSystem: "cartesian",
-      rects: [],
-      points: [],
-      lines: [],
-      circles: [],
-      arrows: [],
-      texts: []
-    };
-    for (const node of this.inputProblem.meshNodes) {
-      graphics.rects.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        stroke: "rgba(0, 0, 0, 0.3)",
-        fill: "rgba(100, 100, 100, 0.1)",
-        layer: `z${node.availableZ.join(",")}`,
-        label: [
-          `node ${node.capacityMeshNodeId}`,
-          `z:${node.availableZ.join(",")}`
-        ].join("\n")
-      });
+  getOutput() {
+    if (this.rectDiffExpansionSolver) {
+      return this.rectDiffExpansionSolver.getOutput();
+    }
+    if (this.rectDiffSeedingSolver) {
+      const snapshot = this.rectDiffSeedingSolver.getOutput();
+      const meshNodes = snapshot.placed.map(
+        (placement, idx) => ({
+          capacityMeshNodeId: `grid-${idx}`,
+          center: {
+            x: placement.rect.x + placement.rect.width / 2,
+            y: placement.rect.y + placement.rect.height / 2
+          },
+          width: placement.rect.width,
+          height: placement.rect.height,
+          availableZ: placement.zLayers,
+          layer: `z${placement.zLayers.join(",")}`
+        })
+      );
+      return { meshNodes };
     }
-    return graphics;
+    return { meshNodes: [] };
   }
-  finalVisualize() {
-    const graphics = {
-      title: "GapFillSolverPipeline - Final",
+  visualize() {
+    if (this.rectDiffExpansionSolver) {
+      return this.rectDiffExpansionSolver.visualize();
+    }
+    if (this.rectDiffSeedingSolver) {
+      return this.rectDiffSeedingSolver.visualize();
+    }
+    return {
+      title: "RectDiff Grid Pipeline",
       coordinateSystem: "cartesian",
       rects: [],
       points: [],
-      lines: [],
-      circles: [],
-      arrows: [],
-      texts: []
+      lines: []
     };
-    const { outputNodes } = this.getOutput();
-    const expandedSegments = this.expandEdgesToEmptySpaceSolver?.getOutput().expandedSegments ?? [];
-    const expandedNodeIds = new Set(
-      expandedSegments.map((es) => es.newNode.capacityMeshNodeId)
-    );
-    for (const node of outputNodes) {
-      const isExpanded = expandedNodeIds.has(node.capacityMeshNodeId);
-      graphics.rects.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        stroke: isExpanded ? "rgba(0, 128, 0, 0.8)" : "rgba(0, 0, 0, 0.3)",
-        fill: isExpanded ? "rgba(0, 200, 0, 0.3)" : "rgba(100, 100, 100, 0.1)",
-        layer: `z${node.availableZ.join(",")}`,
-        label: [
-          `${isExpanded ? "[expanded] " : ""}node ${node.capacityMeshNodeId}`,
-          `z:${node.availableZ.join(",")}`
-        ].join("\n")
+  }
+};
+
+// lib/rectdiff-visualization.ts
+function createBaseVisualization(srj, title = "RectDiff") {
+  const rects = [];
+  const lines = [];
+  const boardBounds = {
+    minX: srj.bounds.minX,
+    maxX: srj.bounds.maxX,
+    minY: srj.bounds.minY,
+    maxY: srj.bounds.maxY
+  };
+  if (srj.outline && srj.outline.length > 1) {
+    lines.push({
+      points: [...srj.outline, srj.outline[0]],
+      strokeColor: "#111827",
+      strokeWidth: 0.01,
+      label: "outline"
+    });
+  } else {
+    rects.push({
+      center: {
+        x: (boardBounds.minX + boardBounds.maxX) / 2,
+        y: (boardBounds.minY + boardBounds.maxY) / 2
+      },
+      width: boardBounds.maxX - boardBounds.minX,
+      height: boardBounds.maxY - boardBounds.minY,
+      fill: "none",
+      stroke: "#111827",
+      label: "board"
+    });
+  }
+  for (const obstacle of srj.obstacles ?? []) {
+    if (obstacle.type === "rect" || obstacle.type === "oval") {
+      rects.push({
+        center: { x: obstacle.center.x, y: obstacle.center.y },
+        width: obstacle.width,
+        height: obstacle.height,
+        fill: "#fee2e2",
+        stroke: "#ef4444",
+        layer: "obstacle",
+        label: "obstacle"
       });
     }
-    return graphics;
   }
-};
+  return {
+    title,
+    coordinateSystem: "cartesian",
+    rects,
+    points: [],
+    lines
+  };
+}
 
 // lib/RectDiffPipeline.ts
 var RectDiffPipeline = class extends BasePipelineSolver3 {
-  rectDiffSolver;
+  rectDiffGridSolverPipeline;
   gapFillSolver;
   pipelineDef = [
-    definePipelineStep2(
-      "rectDiffSolver",
-      RectDiffSolver,
+    definePipelineStep3(
+      "rectDiffGridSolverPipeline",
+      RectDiffGridSolverPipeline,
       (rectDiffPipeline) => [
         {
           simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
           gridOptions: rectDiffPipeline.inputProblem.gridOptions
         }
-      ],
-      {
-        onSolved: () => {
-        }
-      }
+      ]
     ),
-    definePipelineStep2(
+    definePipelineStep3(
       "gapFillSolver",
       GapFillSolverPipeline,
       (rectDiffPipeline) => [
         {
-          meshNodes: rectDiffPipeline.rectDiffSolver?.getOutput().meshNodes ?? []
+          meshNodes: rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? []
         }
       ]
     )
@@ -2025,7 +2362,10 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
     if (gapFillOutput) {
       return { meshNodes: gapFillOutput.outputNodes };
     }
-    return this.rectDiffSolver.getOutput();
+    if (this.rectDiffGridSolverPipeline) {
+      return this.rectDiffGridSolverPipeline.getOutput();
+    }
+    return { meshNodes: [] };
   }
   initialVisualize() {
     console.log("RectDiffPipeline - initialVisualize");
@@ -2033,7 +2373,7 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
       this.inputProblem.simpleRouteJson,
       "RectDiffPipeline - Initial"
     );
-    const initialNodes = this.rectDiffSolver?.getOutput().meshNodes ?? [];
+    const initialNodes = this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? [];
     for (const node of initialNodes) {
       graphics.rects.push({
         center: node.center,
@@ -2057,7 +2397,7 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
     );
     const { meshNodes: outputNodes } = this.getOutput();
     const initialNodeIds = new Set(
-      (this.rectDiffSolver?.getOutput().meshNodes ?? []).map(
+      (this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? []).map(
         (n) => n.capacityMeshNodeId
       )
     );