@tscircuit/rectdiff 0.0.6 → 0.0.7

package/dist/index.js

@@ -1,5 +1,5 @@
 // lib/solvers/RectDiffSolver.ts
-import { BaseSolver as BaseSolver2 } from "@tscircuit/solver-utils";
+import { BaseSolver } from "@tscircuit/solver-utils";
 
 // lib/solvers/rectdiff/geometry.ts
 var EPS = 1e-9;
@@ -600,6 +600,92 @@ function computeEdgeCandidates3D(params) {
   return out;
 }
 
+// lib/solvers/rectdiff/geometry/isPointInPolygon.ts
+function isPointInPolygon(p, polygon) {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const xi = polygon[i].x, yi = polygon[i].y;
+    const xj = polygon[j].x, yj = polygon[j].y;
+    const intersect = yi > p.y !== yj > p.y && p.x < (xj - xi) * (p.y - yi) / (yj - yi) + xi;
+    if (intersect) inside = !inside;
+  }
+  return inside;
+}
+
+// lib/solvers/rectdiff/geometry/computeInverseRects.ts
+function computeInverseRects(bounds, polygon) {
+  if (!polygon || polygon.length < 3) return [];
+  const xs = /* @__PURE__ */ new Set([bounds.x, bounds.x + bounds.width]);
+  const ys = /* @__PURE__ */ new Set([bounds.y, bounds.y + bounds.height]);
+  for (const p of polygon) {
+    xs.add(p.x);
+    ys.add(p.y);
+  }
+  const xSorted = Array.from(xs).sort((a, b) => a - b);
+  const ySorted = Array.from(ys).sort((a, b) => a - b);
+  const rawRects = [];
+  for (let i = 0; i < xSorted.length - 1; i++) {
+    for (let j = 0; j < ySorted.length - 1; j++) {
+      const x0 = xSorted[i];
+      const x1 = xSorted[i + 1];
+      const y0 = ySorted[j];
+      const y1 = ySorted[j + 1];
+      const cx = (x0 + x1) / 2;
+      const cy = (y0 + y1) / 2;
+      if (cx >= bounds.x && cx <= bounds.x + bounds.width && cy >= bounds.y && cy <= bounds.y + bounds.height) {
+        if (!isPointInPolygon({ x: cx, y: cy }, polygon)) {
+          rawRects.push({ x: x0, y: y0, width: x1 - x0, height: y1 - y0 });
+        }
+      }
+    }
+  }
+  const finalRects = [];
+  rawRects.sort((a, b) => {
+    if (Math.abs(a.y - b.y) > EPS) return a.y - b.y;
+    return a.x - b.x;
+  });
+  let current = null;
+  for (const r of rawRects) {
+    if (!current) {
+      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;
+    if (sameY && sameHeight && touchesX) {
+      current.width += r.width;
+    } else {
+      finalRects.push(current);
+      current = r;
+    }
+  }
+  if (current) finalRects.push(current);
+  finalRects.sort((a, b) => {
+    if (Math.abs(a.x - b.x) > EPS) return a.x - b.x;
+    return a.y - b.y;
+  });
+  const mergedVertical = [];
+  current = null;
+  for (const r of finalRects) {
+    if (!current) {
+      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;
+    if (sameX && sameWidth && touchesY) {
+      current.height += r.height;
+    } else {
+      mergedVertical.push(current);
+      current = r;
+    }
+  }
+  if (current) mergedVertical.push(current);
+  return mergedVertical;
+}
+
 // lib/solvers/rectdiff/layers.ts
 function layerSortKey(n) {
   const L = n.toLowerCase();
@@ -689,11 +775,20 @@ function initState(srj, opts) {
     { length: layerCount },
     () => []
   );
-  for (const ob of srj.obstacles ?? []) {
-    const r = obstacleToXYRect(ob);
-    if (!r) continue;
-    const zs = obstacleZs(ob, zIndexByName);
-    const invalidZs = zs.filter((z) => z < 0 || z >= layerCount);
+  let boardVoidRects = [];
+  if (srj.outline && srj.outline.length > 2) {
+    boardVoidRects = computeInverseRects(bounds, srj.outline);
+    for (const voidR of boardVoidRects) {
+      for (let z = 0; z < layerCount; z++) {
+        obstaclesByLayer[z].push(voidR);
+      }
+    }
+  }
+  for (const obstacle of srj.obstacles ?? []) {
+    const rect = obstacleToXYRect(obstacle);
+    if (!rect) continue;
+    const zLayers = obstacleZs(obstacle, zIndexByName);
+    const invalidZs = zLayers.filter((z) => z < 0 || z >= layerCount);
     if (invalidZs.length) {
       throw new Error(
         `RectDiffSolver: obstacle uses z-layer indices ${invalidZs.join(
@@ -701,8 +796,9 @@ function initState(srj, opts) {
         )} outside 0-${layerCount - 1}`
       );
     }
-    if ((!ob.zLayers || ob.zLayers.length === 0) && zs.length) ob.zLayers = zs;
-    for (const z of zs) obstaclesByLayer[z].push(r);
+    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 = {
@@ -731,6 +827,7 @@ function initState(srj, opts) {
     bounds,
     options,
     obstaclesByLayer,
+    boardVoidRects,
     phase: "GRID",
     gridIndex: 0,
     candidates: [],
@@ -963,7 +1060,9 @@ function finalizeRects(state) {
       layersByObstacleRect.set(rect, layerIndices);
     }
   });
+  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,
@@ -1059,603 +1158,16 @@ function findUncoveredPoints({ sampleResolution = 0.05 }, ctx) {
   return uncovered;
 }
 
-// lib/solvers/rectdiff/gapfill/engine/getGapFillProgress.ts
-function getGapFillProgress(state) {
-  if (state.done) return 1;
-  const iterationProgress = state.iteration / state.options.maxIterations;
-  const gapProgress = state.gapsFound.length > 0 ? state.gapIndex / state.gapsFound.length : 0;
-  let stageProgress = 0;
-  switch (state.stage) {
-    case "scan":
-      stageProgress = 0;
-      break;
-    case "select":
-      stageProgress = 0.25;
-      break;
-    case "expand":
-      stageProgress = 0.5;
-      break;
-    case "place":
-      stageProgress = 0.75;
-      break;
-  }
-  const gapStageProgress = state.gapsFound.length > 0 ? stageProgress / (state.gapsFound.length * 4) : 0;
-  return Math.min(
-    0.999,
-    iterationProgress + (gapProgress + gapStageProgress) / state.options.maxIterations
-  );
-}
-
-// lib/solvers/rectdiff/gapfill/engine/initGapFillState.ts
-var DEFAULT_OPTIONS = {
-  minWidth: 0.1,
-  minHeight: 0.1,
-  maxIterations: 10,
-  targetCoverage: 0.999,
-  scanResolution: 0.5
-};
-function initGapFillState({
-  placed,
-  options
-}, ctx) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const placedCopy = placed.map((p) => ({
-    rect: { ...p.rect },
-    zLayers: [...p.zLayers]
-  }));
-  const placedByLayerCopy = ctx.placedByLayer.map(
-    (layer) => layer.map((r) => ({ ...r }))
-  );
-  return {
-    bounds: { ...ctx.bounds },
-    layerCount: ctx.layerCount,
-    obstaclesByLayer: ctx.obstaclesByLayer,
-    placed: placedCopy,
-    placedByLayer: placedByLayerCopy,
-    options: opts,
-    iteration: 0,
-    gapsFound: [],
-    gapIndex: 0,
-    done: false,
-    initialGapCount: 0,
-    filledCount: 0,
-    // Four-stage visualization state
-    stage: "scan",
-    currentGap: null,
-    currentSeed: null,
-    expandedRect: null
-  };
-}
-
-// lib/solvers/rectdiff/gapfill/detection/mergeUncoveredCells.ts
-function mergeUncoveredCells(cells) {
-  if (cells.length === 0) return [];
-  const byXW = /* @__PURE__ */ new Map();
-  for (const c of cells) {
-    const key = `${c.x.toFixed(9)}|${c.w.toFixed(9)}`;
-    const arr = byXW.get(key) ?? [];
-    arr.push(c);
-    byXW.set(key, arr);
-  }
-  const verticalStrips = [];
-  for (const stripCells of byXW.values()) {
-    stripCells.sort((a, b) => a.y - b.y);
-    let current = null;
-    for (const c of stripCells) {
-      if (!current) {
-        current = { x: c.x, y: c.y, width: c.w, height: c.h };
-      } else if (Math.abs(current.y + current.height - c.y) < EPS) {
-        current.height += c.h;
-      } else {
-        verticalStrips.push(current);
-        current = { x: c.x, y: c.y, width: c.w, height: c.h };
-      }
-    }
-    if (current) verticalStrips.push(current);
-  }
-  const byYH = /* @__PURE__ */ new Map();
-  for (const r of verticalStrips) {
-    const key = `${r.y.toFixed(9)}|${r.height.toFixed(9)}`;
-    const arr = byYH.get(key) ?? [];
-    arr.push(r);
-    byYH.set(key, arr);
-  }
-  const merged = [];
-  for (const rowRects of byYH.values()) {
-    rowRects.sort((a, b) => a.x - b.x);
-    let current = null;
-    for (const r of rowRects) {
-      if (!current) {
-        current = { ...r };
-      } else if (Math.abs(current.x + current.width - r.x) < EPS) {
-        current.width += r.width;
-      } else {
-        merged.push(current);
-        current = { ...r };
-      }
-    }
-    if (current) merged.push(current);
-  }
-  return merged;
-}
-
-// lib/solvers/rectdiff/gapfill/detection/findGapsOnLayer.ts
-function findGapsOnLayer({
-  bounds,
-  obstacles,
-  placed,
-  scanResolution
-}) {
-  const blockers = [...obstacles, ...placed];
-  const xCoords = /* @__PURE__ */ new Set();
-  xCoords.add(bounds.x);
-  xCoords.add(bounds.x + bounds.width);
-  for (const b of blockers) {
-    if (b.x > bounds.x && b.x < bounds.x + bounds.width) {
-      xCoords.add(b.x);
-    }
-    if (b.x + b.width > bounds.x && b.x + b.width < bounds.x + bounds.width) {
-      xCoords.add(b.x + b.width);
-    }
-  }
-  for (let x = bounds.x; x <= bounds.x + bounds.width; x += scanResolution) {
-    xCoords.add(x);
-  }
-  const sortedX = Array.from(xCoords).sort((a, b) => a - b);
-  const yCoords = /* @__PURE__ */ new Set();
-  yCoords.add(bounds.y);
-  yCoords.add(bounds.y + bounds.height);
-  for (const b of blockers) {
-    if (b.y > bounds.y && b.y < bounds.y + bounds.height) {
-      yCoords.add(b.y);
-    }
-    if (b.y + b.height > bounds.y && b.y + b.height < bounds.y + bounds.height) {
-      yCoords.add(b.y + b.height);
-    }
-  }
-  for (let y = bounds.y; y <= bounds.y + bounds.height; y += scanResolution) {
-    yCoords.add(y);
-  }
-  const sortedY = Array.from(yCoords).sort((a, b) => a - b);
-  const uncoveredCells = [];
-  for (let i = 0; i < sortedX.length - 1; i++) {
-    for (let j = 0; j < sortedY.length - 1; j++) {
-      const cellX = sortedX[i];
-      const cellY = sortedY[j];
-      const cellW = sortedX[i + 1] - cellX;
-      const cellH = sortedY[j + 1] - cellY;
-      if (cellW <= EPS || cellH <= EPS) continue;
-      const cellCenterX = cellX + cellW / 2;
-      const cellCenterY = cellY + cellH / 2;
-      const isCovered = blockers.some(
-        (b) => cellCenterX >= b.x - EPS && cellCenterX <= b.x + b.width + EPS && cellCenterY >= b.y - EPS && cellCenterY <= b.y + b.height + EPS
-      );
-      if (!isCovered) {
-        uncoveredCells.push({ x: cellX, y: cellY, w: cellW, h: cellH });
-      }
-    }
-  }
-  return mergeUncoveredCells(uncoveredCells);
-}
-
-// utils/rectsOverlap.ts
-function rectsOverlap(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);
-}
-
-// utils/rectsEqual.ts
-function rectsEqual(a, b) {
-  return Math.abs(a.x - b.x) < EPS && Math.abs(a.y - b.y) < EPS && Math.abs(a.width - b.width) < EPS && Math.abs(a.height - b.height) < EPS;
-}
-
-// lib/solvers/rectdiff/gapfill/detection/deduplicateGaps.ts
-function deduplicateGaps(gaps) {
-  const result = [];
-  for (const gap of gaps) {
-    const existing = result.find(
-      (g) => rectsEqual(g.rect, gap.rect) || rectsOverlap(g.rect, gap.rect) && gap.zLayers.some((z) => g.zLayers.includes(z))
-    );
-    if (!existing) {
-      result.push(gap);
-    } else if (gap.zLayers.length > existing.zLayers.length) {
-      const idx = result.indexOf(existing);
-      result[idx] = gap;
-    }
-  }
-  return result;
-}
-
-// lib/solvers/rectdiff/gapfill/detection/findAllGaps.ts
-function findAllGaps({
-  scanResolution,
-  minWidth,
-  minHeight
-}, ctx) {
-  const { bounds, layerCount, obstaclesByLayer, placedByLayer } = ctx;
-  const gapsByLayer = [];
-  for (let z = 0; z < layerCount; z++) {
-    const obstacles = obstaclesByLayer[z] ?? [];
-    const placed = placedByLayer[z] ?? [];
-    const gaps = findGapsOnLayer({ bounds, obstacles, placed, scanResolution });
-    gapsByLayer.push(gaps);
-  }
-  const allGaps = [];
-  for (let z = 0; z < layerCount; z++) {
-    for (const gap of gapsByLayer[z]) {
-      if (gap.width < minWidth - EPS || gap.height < minHeight - EPS) continue;
-      const zLayers = [z];
-      for (let zu = z + 1; zu < layerCount; zu++) {
-        const hasOverlap = gapsByLayer[zu].some((g) => rectsOverlap(g, gap));
-        if (hasOverlap) zLayers.push(zu);
-        else break;
-      }
-      for (let zd = z - 1; zd >= 0; zd--) {
-        const hasOverlap = gapsByLayer[zd].some((g) => rectsOverlap(g, gap));
-        if (hasOverlap && !zLayers.includes(zd)) zLayers.unshift(zd);
-        else break;
-      }
-      allGaps.push({
-        rect: gap,
-        zLayers: zLayers.sort((a, b) => a - b),
-        centerX: gap.x + gap.width / 2,
-        centerY: gap.y + gap.height / 2,
-        area: gap.width * gap.height
-      });
-    }
-  }
-  const deduped = deduplicateGaps(allGaps);
-  deduped.sort((a, b) => {
-    const layerDiff = b.zLayers.length - a.zLayers.length;
-    if (layerDiff !== 0) return layerDiff;
-    return b.area - a.area;
-  });
-  return deduped;
-}
-
-// lib/solvers/rectdiff/gapfill/engine/tryExpandGap.ts
-function tryExpandGap(state, {
-  gap,
-  seed
-}) {
-  const blockers = [];
-  for (const z of gap.zLayers) {
-    blockers.push(...state.obstaclesByLayer[z] ?? []);
-    blockers.push(...state.placedByLayer[z] ?? []);
-  }
-  const rect = expandRectFromSeed({
-    startX: seed.x,
-    startY: seed.y,
-    gridSize: Math.min(gap.rect.width, gap.rect.height),
-    bounds: state.bounds,
-    blockers,
-    initialCellRatio: 0,
-    maxAspectRatio: null,
-    minReq: { width: state.options.minWidth, height: state.options.minHeight }
-  });
-  if (!rect) {
-    const seeds = [
-      { x: gap.rect.x + state.options.minWidth / 2, y: gap.centerY },
-      {
-        x: gap.rect.x + gap.rect.width - state.options.minWidth / 2,
-        y: gap.centerY
-      },
-      { x: gap.centerX, y: gap.rect.y + state.options.minHeight / 2 },
-      {
-        x: gap.centerX,
-        y: gap.rect.y + gap.rect.height - state.options.minHeight / 2
-      }
-    ];
-    for (const altSeed of seeds) {
-      const altRect = expandRectFromSeed({
-        startX: altSeed.x,
-        startY: altSeed.y,
-        gridSize: Math.min(gap.rect.width, gap.rect.height),
-        bounds: state.bounds,
-        blockers,
-        initialCellRatio: 0,
-        maxAspectRatio: null,
-        minReq: {
-          width: state.options.minWidth,
-          height: state.options.minHeight
-        }
-      });
-      if (altRect) {
-        return altRect;
-      }
-    }
-    return null;
-  }
-  return rect;
-}
-
-// lib/solvers/rectdiff/gapfill/engine/addPlacement.ts
-function addPlacement(state, {
-  rect,
-  zLayers
-}) {
-  const placed = { rect, zLayers: [...zLayers] };
-  state.placed.push(placed);
-  for (const z of zLayers) {
-    if (!state.placedByLayer[z]) {
-      state.placedByLayer[z] = [];
-    }
-    state.placedByLayer[z].push(rect);
-  }
-}
-
-// lib/solvers/rectdiff/gapfill/engine/stepGapFill.ts
-function stepGapFill(state) {
-  if (state.done) return false;
-  switch (state.stage) {
-    case "scan": {
-      if (state.gapsFound.length === 0 || state.gapIndex >= state.gapsFound.length) {
-        if (state.iteration >= state.options.maxIterations) {
-          state.done = true;
-          return false;
-        }
-        state.gapsFound = findAllGaps(
-          {
-            scanResolution: state.options.scanResolution,
-            minWidth: state.options.minWidth,
-            minHeight: state.options.minHeight
-          },
-          {
-            bounds: state.bounds,
-            layerCount: state.layerCount,
-            obstaclesByLayer: state.obstaclesByLayer,
-            placedByLayer: state.placedByLayer
-          }
-        );
-        if (state.iteration === 0) {
-          state.initialGapCount = state.gapsFound.length;
-        }
-        state.gapIndex = 0;
-        state.iteration++;
-        if (state.gapsFound.length === 0) {
-          state.done = true;
-          return false;
-        }
-      }
-      state.stage = "select";
-      return true;
-    }
-    case "select": {
-      if (state.gapIndex >= state.gapsFound.length) {
-        state.stage = "scan";
-        return true;
-      }
-      state.currentGap = state.gapsFound[state.gapIndex];
-      state.currentSeed = {
-        x: state.currentGap.centerX,
-        y: state.currentGap.centerY
-      };
-      state.expandedRect = null;
-      state.stage = "expand";
-      return true;
-    }
-    case "expand": {
-      if (!state.currentGap) {
-        state.stage = "select";
-        return true;
-      }
-      const expandedRect = tryExpandGap(state, {
-        gap: state.currentGap,
-        seed: state.currentSeed
-      });
-      state.expandedRect = expandedRect;
-      state.stage = "place";
-      return true;
-    }
-    case "place": {
-      if (state.expandedRect && state.currentGap) {
-        addPlacement(state, {
-          rect: state.expandedRect,
-          zLayers: state.currentGap.zLayers
-        });
-        state.filledCount++;
-      }
-      state.gapIndex++;
-      state.currentGap = null;
-      state.currentSeed = null;
-      state.expandedRect = null;
-      state.stage = "select";
-      return true;
-    }
-    default:
-      state.stage = "scan";
-      return true;
-  }
-}
-
-// lib/solvers/rectdiff/subsolvers/GapFillSubSolver.ts
-import { BaseSolver } from "@tscircuit/solver-utils";
-var GapFillSubSolver = class extends BaseSolver {
-  state;
-  layerCtx;
-  constructor(params) {
-    super();
-    this.layerCtx = params.layerCtx;
-    this.state = initGapFillState(
-      {
-        placed: params.placed,
-        options: params.options
-      },
-      params.layerCtx
-    );
-  }
-  /**
-   * Execute one step of the gap fill algorithm.
-   * Each gap goes through four stages: scan for gaps, select a target gap,
-   * expand a rectangle from seed point, then place the final result.
-   */
-  _step() {
-    const stillWorking = stepGapFill(this.state);
-    if (!stillWorking) {
-      this.solved = true;
-    }
-  }
-  /**
-   * Calculate progress as a value between 0 and 1.
-   * Accounts for iterations, gaps processed, and current stage within each gap.
-   */
-  computeProgress() {
-    return getGapFillProgress(this.state);
-  }
-  /**
-   * Get all placed rectangles including original ones plus newly created gap-fill rectangles.
-   */
-  getPlaced() {
-    return this.state.placed;
-  }
-  /**
-   * Get placed rectangles organized by Z-layer for efficient layer-based operations.
-   */
-  getPlacedByLayer() {
-    return this.state.placedByLayer;
-  }
-  getOutput() {
-    return {
-      placed: this.state.placed,
-      placedByLayer: this.state.placedByLayer,
-      filledCount: this.state.filledCount
-    };
-  }
-  /** Zen visualization: show four-stage gap filling process. */
-  visualize() {
-    const rects = [];
-    const points = [];
-    rects.push({
-      center: {
-        x: this.layerCtx.bounds.x + this.layerCtx.bounds.width / 2,
-        y: this.layerCtx.bounds.y + this.layerCtx.bounds.height / 2
-      },
-      width: this.layerCtx.bounds.width,
-      height: this.layerCtx.bounds.height,
-      fill: "none",
-      stroke: "#e5e7eb",
-      label: ""
-    });
-    switch (this.state.stage) {
-      case "scan": {
-        rects.push({
-          center: {
-            x: this.layerCtx.bounds.x + this.layerCtx.bounds.width / 2,
-            y: this.layerCtx.bounds.y + this.layerCtx.bounds.height / 2
-          },
-          width: this.layerCtx.bounds.width,
-          height: this.layerCtx.bounds.height,
-          fill: "#dbeafe",
-          stroke: "#3b82f6",
-          label: "scanning"
-        });
-        break;
-      }
-      case "select": {
-        if (this.state.currentGap) {
-          rects.push({
-            center: {
-              x: this.state.currentGap.rect.x + this.state.currentGap.rect.width / 2,
-              y: this.state.currentGap.rect.y + this.state.currentGap.rect.height / 2
-            },
-            width: this.state.currentGap.rect.width,
-            height: this.state.currentGap.rect.height,
-            fill: "#fecaca",
-            stroke: "#ef4444",
-            label: "target gap"
-          });
-          if (this.state.currentSeed) {
-            points.push({
-              x: this.state.currentSeed.x,
-              y: this.state.currentSeed.y,
-              color: "#dc2626",
-              label: "seed"
-            });
-          }
-        }
-        break;
-      }
-      case "expand": {
-        if (this.state.currentGap) {
-          rects.push({
-            center: {
-              x: this.state.currentGap.rect.x + this.state.currentGap.rect.width / 2,
-              y: this.state.currentGap.rect.y + this.state.currentGap.rect.height / 2
-            },
-            width: this.state.currentGap.rect.width,
-            height: this.state.currentGap.rect.height,
-            fill: "none",
-            stroke: "#f87171",
-            label: ""
-          });
-        }
-        if (this.state.currentSeed) {
-          points.push({
-            x: this.state.currentSeed.x,
-            y: this.state.currentSeed.y,
-            color: "#f59e0b",
-            label: "expanding"
-          });
-        }
-        if (this.state.expandedRect) {
-          rects.push({
-            center: {
-              x: this.state.expandedRect.x + this.state.expandedRect.width / 2,
-              y: this.state.expandedRect.y + this.state.expandedRect.height / 2
-            },
-            width: this.state.expandedRect.width,
-            height: this.state.expandedRect.height,
-            fill: "#fef3c7",
-            stroke: "#f59e0b",
-            label: "expanding"
-          });
-        }
-        break;
-      }
-      case "place": {
-        if (this.state.expandedRect) {
-          rects.push({
-            center: {
-              x: this.state.expandedRect.x + this.state.expandedRect.width / 2,
-              y: this.state.expandedRect.y + this.state.expandedRect.height / 2
-            },
-            width: this.state.expandedRect.width,
-            height: this.state.expandedRect.height,
-            fill: "#bbf7d0",
-            stroke: "#22c55e",
-            label: "placed"
-          });
-        }
-        break;
-      }
-    }
-    const stageNames = {
-      scan: "scanning",
-      select: "selecting",
-      expand: "expanding",
-      place: "placing"
-    };
-    return {
-      title: `GapFill (${stageNames[this.state.stage]}): ${this.state.filledCount} filled`,
-      coordinateSystem: "cartesian",
-      rects,
-      points
-    };
-  }
-};
-
 // lib/solvers/RectDiffSolver.ts
-var RectDiffSolver = class extends BaseSolver2 {
+var RectDiffSolver = class extends BaseSolver {
   srj;
   gridOptions;
-  gapFillOptions;
   state;
   _meshNodes = [];
   constructor(opts) {
     super();
     this.srj = opts.simpleRouteJson;
     this.gridOptions = opts.gridOptions ?? {};
-    this.gapFillOptions = opts.gapFillOptions ?? {};
-    this.activeSubSolver = null;
   }
   _setup() {
     this.state = initState(this.srj, this.gridOptions);
@@ -1671,37 +1183,7 @@ var RectDiffSolver = class extends BaseSolver2 {
     } else if (this.state.phase === "EXPANSION") {
       stepExpansion(this.state);
     } else if (this.state.phase === "GAP_FILL") {
-      if (!this.activeSubSolver || !(this.activeSubSolver instanceof GapFillSubSolver)) {
-        const minTrace = this.srj.minTraceWidth || 0.15;
-        const minGapSize = Math.max(0.01, minTrace / 10);
-        const boundsSize = Math.min(
-          this.state.bounds.width,
-          this.state.bounds.height
-        );
-        this.activeSubSolver = new GapFillSubSolver({
-          placed: this.state.placed,
-          options: {
-            minWidth: minGapSize,
-            minHeight: minGapSize,
-            scanResolution: Math.max(0.05, boundsSize / 100),
-            ...this.gapFillOptions
-          },
-          layerCtx: {
-            bounds: this.state.bounds,
-            layerCount: this.state.layerCount,
-            obstaclesByLayer: this.state.obstaclesByLayer,
-            placedByLayer: this.state.placedByLayer
-          }
-        });
-      }
-      this.activeSubSolver.step();
-      if (this.activeSubSolver.solved) {
-        const output = this.activeSubSolver.getOutput();
-        this.state.placed = output.placed;
-        this.state.placedByLayer = output.placedByLayer;
-        this.activeSubSolver = null;
-        this.state.phase = "DONE";
-      }
+      this.state.phase = "DONE";
     } else if (this.state.phase === "DONE") {
       if (!this.solved) {
         const rects = finalizeRects(this.state);
@@ -1713,20 +1195,13 @@ var RectDiffSolver = class extends BaseSolver2 {
     this.stats.phase = this.state.phase;
     this.stats.gridIndex = this.state.gridIndex;
     this.stats.placed = this.state.placed.length;
-    if (this.activeSubSolver instanceof GapFillSubSolver) {
-      const output = this.activeSubSolver.getOutput();
-      this.stats.gapsFilled = output.filledCount;
-    }
   }
   /** Compute solver progress (0 to 1). */
   computeProgress() {
     if (this.solved || this.state.phase === "DONE") {
       return 1;
     }
-    if (this.state.phase === "GAP_FILL" && this.activeSubSolver instanceof GapFillSubSolver) {
-      return 0.85 + 0.1 * this.activeSubSolver.computeProgress();
-    }
-    return computeProgress(this.state) * 0.85;
+    return computeProgress(this.state);
   }
   getOutput() {
     return { meshNodes: this._meshNodes };
@@ -1770,34 +1245,42 @@ var RectDiffSolver = class extends BaseSolver2 {
   }
   /** Streaming visualization: board + obstacles + current placements. */
   visualize() {
-    if (this.activeSubSolver) {
-      return this.activeSubSolver.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
     };
-    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 ob of this.srj.obstacles ?? []) {
-      if (ob.type === "rect" || ob.type === "oval") {
+    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 (const obstacle of this.srj.obstacles ?? []) {
+      if (obstacle.type === "rect" || obstacle.type === "oval") {
         rects.push({
-          center: { x: ob.center.x, y: ob.center.y },
-          width: ob.width,
-          height: ob.height,
+          center: { x: obstacle.center.x, y: obstacle.center.y },
+          width: obstacle.width,
+          height: obstacle.height,
           fill: "#fee2e2",
           stroke: "#ef4444",
           layer: "obstacle",
@@ -1805,6 +1288,34 @@ var RectDiffSolver = class extends BaseSolver2 {
         });
       }
     }
+    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
+        };
+      }
+      for (const r of this.state.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.state?.candidates?.length) {
       for (const cand of this.state.candidates) {
         points.push({
@@ -1837,7 +1348,9 @@ z:${p.zLayers.join(",")}`
       title: `RectDiff (${this.state?.phase ?? "init"})`,
       coordinateSystem: "cartesian",
       rects,
-      points
+      points,
+      lines
+      // Include lines in the returned GraphicsObject
     };
   }
 };