@tscircuit/rectdiff 0.0.1

package/dist/index.js

@@ -0,0 +1,921 @@
+// lib/solvers/RectDiffSolver.ts
+import { BaseSolver } from "@tscircuit/solver-utils";
+
+// 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));
+  }
+  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;
+      }
+    }
+  }
+  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;
+      }
+    }
+  }
+  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 Math.max(0, e);
+}
+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;
+      }
+    }
+  }
+  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(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;
+      }
+    }
+  }
+  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(startX, startY, gridSize, bounds, blockers, initialCellRatio, maxAspectRatio, minReq) {
+  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 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;
+      }
+    }
+    if (r.width + EPS >= minReq.width && r.height + EPS >= minReq.height) {
+      const area = r.width * r.height;
+      if (area > bestArea) {
+        best = r;
+        bestArea = area;
+      }
+    }
+  }
+  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(x, y, layerCount, obstaclesByLayer, placedByLayer) {
+  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(bounds, gridSize, layerCount, obstaclesByLayer, placedByLayer, hardPlacedByLayer) {
+  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,
+          1,
+          void 0,
+          // no cap here
+          obstaclesByLayer,
+          hardPlacedByLayer
+          // IMPORTANT: ignore soft nodes
+        );
+        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);
+      }
+    }
+  }
+  const arr = Array.from(out.values());
+  arr.sort((a, b) => b.zSpanLen - a.zSpanLen || b.distance - a.distance);
+  return arr;
+}
+function longestFreeSpanAroundZ(x, y, z, layerCount, minSpan, maxSpan, obstaclesByLayer, placedByLayer) {
+  const isFreeAt = (layer) => {
+    const blockers = [...obstaclesByLayer[layer] ?? [], ...placedByLayer[layer] ?? []];
+    return !blockers.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 : [];
+}
+function computeDefaultGridSizes(bounds) {
+  const ref = Math.max(bounds.width, bounds.height);
+  return [ref / 8, ref / 16, ref / 32];
+}
+function computeUncoveredSegments(lineStart, lineEnd, coveringIntervals, minSegmentLength) {
+  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 + EPS) {
+      current.end = Math.max(current.end, interval.end);
+    } else {
+      merged.push(current);
+      current = { ...interval };
+    }
+  }
+  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 });
+    }
+  }
+  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 (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 });
+    }
+  }
+  return uncovered;
+}
+function computeEdgeCandidates3D(bounds, minSize, layerCount, obstaclesByLayer, placedByLayer, hardPlacedByLayer) {
+  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);
+  }
+  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, 1, void 0, obstaclesByLayer, hardPlacedByLayer);
+    out.push({ x, y, z, distance: d, zSpanLen: span.length, isEdgeSeed: true });
+  }
+  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);
+    }
+    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(bounds.x + \u03B4, bounds.x + bounds.width - \u03B4, topCovering, 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);
+        }
+      }
+    }
+    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(bounds.x + \u03B4, bounds.x + bounds.width - \u03B4, bottomCovering, 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);
+        }
+      }
+    }
+    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(bounds.y + \u03B4, bounds.y + bounds.height - \u03B4, leftCovering, 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);
+        }
+      }
+    }
+    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(bounds.y + \u03B4, bounds.y + bounds.height - \u03B4, rightCovering, 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);
+        }
+      }
+    }
+    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(b.y, b.y + b.height, obLeftCovering, minSize * 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(b.y, b.y + b.height, obRightCovering, minSize * 0.5);
+        for (const seg of obRightUncovered) {
+          pushIfFree(obRightX, seg.center, z);
+        }
+      }
+      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(b.x, b.x + b.width, obTopCovering, minSize * 0.5);
+        for (const seg of obTopUncovered) {
+          pushIfFree(seg.center, obTopY, z);
+        }
+      }
+      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(b.x, b.x + b.width, obBottomCovering, minSize * 0.5);
+        for (const seg of obBottomUncovered) {
+          pushIfFree(seg.center, obBottomY, z);
+        }
+      }
+    }
+  }
+  out.sort((a, b) => b.zSpanLen - a.zSpanLen || b.distance - a.distance);
+  return out;
+}
+
+// lib/solvers/rectdiff/layers.ts
+function layerSortKey(n) {
+  const L = n.toLowerCase();
+  if (L === "top") return -1e6;
+  if (L === "bottom") return 1e6;
+  const m = /^inner(\d+)$/i.exec(L);
+  if (m) return parseInt(m[1], 10) || 0;
+  return 100 + L.charCodeAt(0);
+}
+function canonicalizeLayerOrder(names) {
+  return Array.from(new Set(names)).sort((a, b) => {
+    const ka = layerSortKey(a);
+    const kb = layerSortKey(b);
+    if (ka !== kb) return ka - kb;
+    return a.localeCompare(b);
+  });
+}
+function buildZIndexMap(srj) {
+  const names = canonicalizeLayerOrder((srj.obstacles ?? []).flatMap((o) => o.layers ?? []));
+  const fallback = Array.from(
+    { length: Math.max(1, srj.layerCount || 1) },
+    (_, i) => i === 0 ? "top" : i === (srj.layerCount || 1) - 1 ? "bottom" : `inner${i}`
+  );
+  const layerNames = names.length ? names : fallback;
+  const map = /* @__PURE__ */ new Map();
+  layerNames.forEach((n, i) => map.set(n, i));
+  return { layerNames, zIndexByName: map };
+}
+function obstacleZs(ob, zIndexByName) {
+  if (ob.zLayers?.length) return Array.from(new Set(ob.zLayers)).sort((a, b) => a - b);
+  const fromNames = (ob.layers ?? []).map((n) => zIndexByName.get(n)).filter((v) => typeof v === "number");
+  return Array.from(new Set(fromNames)).sort((a, b) => a - b);
+}
+function obstacleToXYRect(ob) {
+  const w = ob.width;
+  const h = ob.height;
+  if (typeof w !== "number" || typeof h !== "number") return null;
+  return { x: ob.center.x - w / 2, y: ob.center.y - h / 2, width: w, height: h };
+}
+
+// lib/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 }, () => []);
+  for (const ob of srj.obstacles ?? []) {
+    const r = obstacleToXYRect(ob);
+    if (!r) continue;
+    const zs = obstacleZs(ob, zIndexByName);
+    for (const z of zs) if (z >= 0 && z < layerCount) obstaclesByLayer[z].push(r);
+  }
+  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,
+    phase: "GRID",
+    gridIndex: 0,
+    candidates: [],
+    placed: [],
+    placedByLayer,
+    expansionIndex: 0,
+    edgeAnalysisDone: false,
+    totalSeedsThisGrid: 0,
+    consumedSeedsThisGrid: 0
+  };
+}
+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);
+    }
+  }
+  return out;
+}
+function isFullyOccupiedAtPoint(state, x, y) {
+  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, x, y)) || placed.some((b) => containsPoint(b, x, y));
+    if (!occ) return false;
+  }
+  return true;
+}
+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() });
+      }
+    }
+  }
+  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);
+    }
+  });
+  for (const p of toAdd) {
+    state.placed.push(p);
+    for (const z of p.zLayers) state.placedByLayer[z].push(p.rect);
+  }
+}
+function stepGrid(state) {
+  const {
+    gridSizes,
+    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(
+      state.bounds,
+      grid,
+      state.layerCount,
+      state.obstaclesByLayer,
+      state.placedByLayer,
+      // all nodes (soft + hard) for fully-occupied test
+      hardPlacedByLayer
+      // hard blockers for ranking/span
+    );
+    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(
+          state.bounds,
+          minSize,
+          state.layerCount,
+          state.obstaclesByLayer,
+          state.placedByLayer,
+          // for fully-occupied test
+          hardPlacedByLayer
+        );
+        state.edgeAnalysisDone = true;
+        state.totalSeedsThisGrid = state.candidates.length;
+        state.consumedSeedsThisGrid = 0;
+        return;
+      }
+      state.phase = "EXPANSION";
+      state.expansionIndex = 0;
+      return;
+    }
+  }
+  const cand = state.candidates.shift();
+  state.consumedSeedsThisGrid += 1;
+  const span = longestFreeSpanAroundZ(
+    cand.x,
+    cand.y,
+    cand.z,
+    state.layerCount,
+    minMulti.minLayers,
+    maxMultiLayerSpan,
+    state.obstaclesByLayer,
+    hardPlacedByLayer
+    // ignore soft nodes for span
+  );
+  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) {
+      if (state.obstaclesByLayer[z]) hardBlockers.push(...state.obstaclesByLayer[z]);
+      if (hardPlacedByLayer[z]) hardBlockers.push(...hardPlacedByLayer[z]);
+    }
+    const rect = expandRectFromSeed(
+      cand.x,
+      cand.y,
+      grid,
+      state.bounds,
+      hardBlockers,
+      // soft nodes DO NOT block expansion
+      initialCellRatio,
+      maxAspectRatio,
+      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, c.x, c.y));
+    return;
+  }
+}
+function stepExpansion(state) {
+  if (state.expansionIndex >= state.placed.length) {
+    state.phase = "DONE";
+    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(
+    p.rect.x + p.rect.width / 2,
+    p.rect.y + p.rect.height / 2,
+    lastGrid,
+    state.bounds,
+    hardBlockers,
+    0,
+    // seed bias off
+    null,
+    // no aspect cap in expansion pass
+    { 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;
+    }
+    resizeSoftOverlaps(state, idx);
+  }
+  state.expansionIndex += 1;
+}
+function finalizeRects(state) {
+  return 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)
+  }));
+}
+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)));
+  }
+  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)));
+  }
+  return 1;
+}
+
+// lib/solvers/rectdiff/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()
+    });
+  }
+  return out;
+}
+
+// lib/solvers/RectDiffSolver.ts
+var RectDiffSolver = class extends BaseSolver {
+  srj;
+  mode;
+  gridOptions;
+  state;
+  _meshNodes = [];
+  constructor(opts) {
+    super();
+    this.srj = opts.simpleRouteJson;
+    this.mode = opts.mode ?? "grid";
+    this.gridOptions = opts.gridOptions ?? {};
+  }
+  _setup() {
+    this.state = initState(this.srj, this.gridOptions);
+    this.stats = {
+      phase: this.state.phase,
+      gridIndex: this.state.gridIndex
+    };
+  }
+  /** IMPORTANT: 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 === "DONE") {
+      if (!this.solved) {
+        const rects = finalizeRects(this.state);
+        this._meshNodes = rectsToMeshNodes(rects);
+        this.solved = true;
+      }
+      return;
+    }
+    this.stats.phase = this.state.phase;
+    this.stats.gridIndex = this.state.gridIndex;
+    this.stats.placed = this.state.placed.length;
+  }
+  // Let BaseSolver update this.progress automatically if present.
+  computeProgress() {
+    return computeProgress(this.state);
+  }
+  getOutput() {
+    return { meshNodes: this._meshNodes };
+  }
+  // Helper to get color based on z layer
+  getColorForZLayer(zLayers) {
+    const minZ = Math.min(...zLayers);
+    const colors = [
+      { fill: "#dbeafe", stroke: "#3b82f6" },
+      // blue (z=0)
+      { fill: "#fef3c7", stroke: "#f59e0b" },
+      // amber (z=1)
+      { fill: "#d1fae5", stroke: "#10b981" },
+      // green (z=2)
+      { fill: "#e9d5ff", stroke: "#a855f7" },
+      // purple (z=3)
+      { fill: "#fed7aa", stroke: "#f97316" },
+      // orange (z=4)
+      { fill: "#fecaca", stroke: "#ef4444" }
+      // red (z=5)
+    ];
+    return colors[minZ % colors.length];
+  }
+  // Streaming visualization: board + obstacles + current placements.
+  visualize() {
+    const rects = [];
+    const points = [];
+    rects.push({
+      center: {
+        x: (this.srj.bounds.minX + this.srj.bounds.maxX) / 2,
+        y: (this.srj.bounds.minY + this.srj.bounds.maxY) / 2
+      },
+      width: this.srj.bounds.maxX - this.srj.bounds.minX,
+      height: this.srj.bounds.maxY - this.srj.bounds.minY,
+      fill: "none",
+      stroke: "#111827",
+      label: "board"
+    });
+    for (const ob of this.srj.obstacles ?? []) {
+      if (ob.type === "rect" || ob.type === "oval") {
+        rects.push({
+          center: { x: ob.center.x, y: ob.center.y },
+          width: ob.width,
+          height: ob.height,
+          fill: "#fee2e2",
+          stroke: "#ef4444",
+          layer: "obstacle",
+          label: "obstacle"
+        });
+      }
+    }
+    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}`
+        });
+      }
+    }
+    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,
+          label: `free
+z:${p.zLayers.join(",")}`
+        });
+      }
+    }
+    return {
+      title: "RectDiff (incremental)",
+      coordinateSystem: "cartesian",
+      rects,
+      points
+    };
+  }
+};
+export {
+  RectDiffSolver
+};