@tscircuit/rectdiff 0.0.12 → 0.0.13

package/lib/solvers/{rectdiff/candidates.ts → RectDiffSeedingSolver/computeEdgeCandidates3D.ts}

@@ -1,190 +1,7 @@
-// lib/solvers/rectdiff/candidates.ts
-import type { Candidate3D, XYRect } from "./types"
-import { EPS, clamp, containsPoint, distancePointToRectEdges } from "./geometry"
-
-/**
- * Check if a point is occupied on all layers.
- */
-function isFullyOccupiedAllLayers(params: {
-  x: number
-  y: number
-  layerCount: number
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
-}): boolean {
-  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
-}
-
-/**
- * Compute candidate seed points for a given grid size.
- */
-export function computeCandidates3D(params: {
-  bounds: XYRect
-  gridSize: number
-  layerCount: number
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
-  hardPlacedByLayer: XYRect[][]
-}): Candidate3D[] {
-  const {
-    bounds,
-    gridSize,
-    layerCount,
-    obstaclesByLayer,
-    placedByLayer,
-    hardPlacedByLayer,
-  } = params
-  const out = new Map<string, Candidate3D>() // key by (x,y)
-
-  for (let x = bounds.x; x < bounds.x + bounds.width; x += gridSize) {
-    for (let y = bounds.y; y < bounds.y + bounds.height; y += gridSize) {
-      // Skip outermost row/col (stable with prior behavior)
-      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
-      }
-
-      // New rule: Only drop if EVERY layer is occupied (by obstacle or node)
-      if (
-        isFullyOccupiedAllLayers({
-          x,
-          y,
-          layerCount,
-          obstaclesByLayer,
-          placedByLayer,
-        })
-      )
-        continue
-
-      // Find the best (longest) free contiguous Z span at (x,y) ignoring soft nodes.
-      let bestSpan: number[] = []
-      let bestZ = 0
-      for (let z = 0; z < layerCount; z++) {
-        const s = longestFreeSpanAroundZ({
-          x,
-          y,
-          z,
-          layerCount,
-          minSpan: 1,
-          maxSpan: undefined,
-          obstaclesByLayer,
-          placedByLayer: hardPlacedByLayer,
-        })
-        if (s.length > bestSpan.length) {
-          bestSpan = s
-          bestZ = z
-        }
-      }
-      const anchorZ = bestSpan.length
-        ? bestSpan[Math.floor(bestSpan.length / 2)]!
-        : bestZ
-
-      // Distance heuristic against hard blockers only (obstacles + full-stack)
-      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: Candidate3D = {
-        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
-}
-
-/**
- * Find the longest contiguous free span around z (optionally capped).
- */
-export function longestFreeSpanAroundZ(params: {
-  x: number
-  y: number
-  z: number
-  layerCount: number
-  minSpan: number
-  maxSpan: number | undefined
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
-}): number[] {
-  const {
-    x,
-    y,
-    z,
-    layerCount,
-    minSpan,
-    maxSpan,
-    obstaclesByLayer,
-    placedByLayer,
-  } = params
-
-  const isFreeAt = (layer: number) => {
-    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)
-    // trim symmetrically (keeping z inside)
-    while (hi - lo + 1 > target) {
-      if (z - lo > hi - z) lo++
-      else hi--
-    }
-  }
-
-  const res: number[] = []
-  for (let i = lo; i <= hi; i++) res.push(i)
-  return res.length >= minSpan ? res : []
-}
-
-/**
- * Compute default grid sizes based on bounds.
- */
-export function computeDefaultGridSizes(bounds: XYRect): number[] {
-  const ref = Math.max(bounds.width, bounds.height)
-  return [ref / 8, ref / 16, ref / 32]
-}
+import type { Candidate3D, XYRect } from "../../rectdiff-types"
+import { EPS, distancePointToRectEdges } from "../../utils/rectdiff-geometry"
+import { isFullyOccupiedAtPoint } from "../../utils/isFullyOccupiedAtPoint"
+import { longestFreeSpanAroundZ } from "./longestFreeSpanAroundZ"
 
 /**
  * Compute exact uncovered segments along a 1D line.
@@ -279,20 +96,22 @@ export function computeEdgeCandidates3D(params: {
   // Use small inset from edges for placement
   const δ = Math.max(minSize * 0.15, EPS * 3)
   const dedup = new Set<string>()
-  const key = (x: number, y: number, z: number) =>
-    `${z}|${x.toFixed(6)}|${y.toFixed(6)}`
-
-  function fullyOcc(x: number, y: number) {
-    return isFullyOccupiedAllLayers({
-      x,
-      y,
-      layerCount,
-      obstaclesByLayer,
-      placedByLayer,
-    })
+  const key = (p: { x: number; y: number; z: number }) =>
+    `${p.z}|${p.x.toFixed(6)}|${p.y.toFixed(6)}`
+
+  function fullyOcc(p: { x: number; y: number }) {
+    return isFullyOccupiedAtPoint(
+      {
+        layerCount,
+        obstaclesByLayer,
+        placedByLayer,
+      },
+      p,
+    )
   }
 
-  function pushIfFree(x: number, y: number, z: number) {
+  function pushIfFree(p: { x: number; y: number; z: number }) {
+    const { x, y, z } = p
     if (
       x < bounds.x + EPS ||
       y < bounds.y + EPS ||
@@ -300,7 +119,7 @@ export function computeEdgeCandidates3D(params: {
       y > bounds.y + bounds.height - EPS
     )
       return
-    if (fullyOcc(x, y)) return // new rule: only drop if truly impossible
+    if (fullyOcc({ x, y })) return // new rule: only drop if truly impossible
 
     // Distance uses obstacles + hard nodes (soft nodes ignored for ranking)
     const hard = [
@@ -308,13 +127,13 @@ export function computeEdgeCandidates3D(params: {
       ...(hardPlacedByLayer[z] ?? []),
     ]
     const d = Math.min(
-      distancePointToRectEdges(x, y, bounds),
+      distancePointToRectEdges({ x, y }, bounds),
       ...(hard.length
-        ? hard.map((b) => distancePointToRectEdges(x, y, b))
+        ? hard.map((b) => distancePointToRectEdges({ x, y }, b))
         : [Infinity]),
     )
 
-    const k = key(x, y, z)
+    const k = key({ x, y, z })
     if (dedup.has(k)) return
     dedup.add(k)
 
@@ -348,7 +167,7 @@ export function computeEdgeCandidates3D(params: {
       { x: bounds.x + bounds.width - δ, y: bounds.y + bounds.height - δ }, // bottom-right
     ]
     for (const corner of corners) {
-      pushIfFree(corner.x, corner.y, z)
+      pushIfFree({ x: corner.x, y: corner.y, z })
     }
 
     // Top edge (y = bounds.y + δ)
@@ -370,10 +189,10 @@ export function computeEdgeCandidates3D(params: {
       const segLen = seg.end - seg.start
       if (segLen >= minSize) {
         // Seed center and a few strategic points
-        pushIfFree(seg.center, topY, z)
+        pushIfFree({ x: seg.center, y: topY, z })
         if (segLen > minSize * 1.5) {
-          pushIfFree(seg.start + minSize * 0.4, topY, z)
-          pushIfFree(seg.end - minSize * 0.4, topY, z)
+          pushIfFree({ x: seg.start + minSize * 0.4, y: topY, z })
+          pushIfFree({ x: seg.end - minSize * 0.4, y: topY, z })
         }
       }
     }
@@ -395,10 +214,10 @@ export function computeEdgeCandidates3D(params: {
     for (const seg of bottomUncovered) {
       const segLen = seg.end - seg.start
       if (segLen >= minSize) {
-        pushIfFree(seg.center, bottomY, z)
+        pushIfFree({ x: seg.center, y: bottomY, z })
         if (segLen > minSize * 1.5) {
-          pushIfFree(seg.start + minSize * 0.4, bottomY, z)
-          pushIfFree(seg.end - minSize * 0.4, bottomY, z)
+          pushIfFree({ x: seg.start + minSize * 0.4, y: bottomY, z })
+          pushIfFree({ x: seg.end - minSize * 0.4, y: bottomY, z })
         }
       }
     }
@@ -420,10 +239,10 @@ export function computeEdgeCandidates3D(params: {
     for (const seg of leftUncovered) {
       const segLen = seg.end - seg.start
       if (segLen >= minSize) {
-        pushIfFree(leftX, seg.center, z)
+        pushIfFree({ x: leftX, y: seg.center, z })
         if (segLen > minSize * 1.5) {
-          pushIfFree(leftX, seg.start + minSize * 0.4, z)
-          pushIfFree(leftX, seg.end - minSize * 0.4, z)
+          pushIfFree({ x: leftX, y: seg.start + minSize * 0.4, z })
+          pushIfFree({ x: leftX, y: seg.end - minSize * 0.4, z })
         }
       }
     }
@@ -445,10 +264,10 @@ export function computeEdgeCandidates3D(params: {
     for (const seg of rightUncovered) {
       const segLen = seg.end - seg.start
       if (segLen >= minSize) {
-        pushIfFree(rightX, seg.center, z)
+        pushIfFree({ x: rightX, y: seg.center, z })
         if (segLen > minSize * 1.5) {
-          pushIfFree(rightX, seg.start + minSize * 0.4, z)
-          pushIfFree(rightX, seg.end - minSize * 0.4, z)
+          pushIfFree({ x: rightX, y: seg.start + minSize * 0.4, z })
+          pushIfFree({ x: rightX, y: seg.end - minSize * 0.4, z })
         }
       }
     }
@@ -473,7 +292,7 @@ export function computeEdgeCandidates3D(params: {
           minSegmentLength: minSize * 0.5,
         })
         for (const seg of obLeftUncovered) {
-          pushIfFree(obLeftX, seg.center, z)
+          pushIfFree({ x: obLeftX, y: seg.center, z })
         }
       }
 
@@ -498,7 +317,7 @@ export function computeEdgeCandidates3D(params: {
           minSegmentLength: minSize * 0.5,
         })
         for (const seg of obRightUncovered) {
-          pushIfFree(obRightX, seg.center, z)
+          pushIfFree({ x: obRightX, y: seg.center, z })
         }
       }
 
@@ -520,7 +339,7 @@ export function computeEdgeCandidates3D(params: {
           minSegmentLength: minSize * 0.5,
         })
         for (const seg of obTopUncovered) {
-          pushIfFree(seg.center, obTopY, z)
+          pushIfFree({ x: seg.center, y: obTopY, z })
         }
       }
 
@@ -546,7 +365,7 @@ export function computeEdgeCandidates3D(params: {
           minSegmentLength: minSize * 0.5,
         })
         for (const seg of obBottomUncovered) {
-          pushIfFree(seg.center, obBottomY, z)
+          pushIfFree({ x: seg.center, y: obBottomY, z })
         }
       }
     }

package/lib/solvers/{rectdiff/geometry → RectDiffSeedingSolver}/computeInverseRects.ts

@@ -1,6 +1,10 @@
-import type { XYRect } from "../types"
+import type { XYRect } from "../../rectdiff-types"
+import {
+  containsPoint,
+  subtractRect2D,
+  EPS,
+} from "../../utils/rectdiff-geometry"
 import { isPointInPolygon } from "./isPointInPolygon"
-import { EPS } from "../geometry" // Import EPS from common geometry file
 
 /**
  * Decompose the empty space inside 'bounds' but outside 'polygon' into rectangles.

package/lib/solvers/{rectdiff → RectDiffSeedingSolver}/layers.ts

@@ -1,6 +1,7 @@
-// lib/solvers/rectdiff/layers.ts
-import type { SimpleRouteJson, Obstacle } from "../../types/srj-types"
-import type { XYRect } from "./types"
+import type { SimpleRouteJson } from "../../types/srj-types"
+import type { XYRect } from "../../rectdiff-types"
+
+type Obstacle = NonNullable<SimpleRouteJson["obstacles"]>[number]
 
 function layerSortKey(n: string) {
   const L = n.toLowerCase()

package/lib/solvers/RectDiffSeedingSolver/longestFreeSpanAroundZ.ts

@@ -0,0 +1,52 @@
+import type { XYRect } from "../../rectdiff-types"
+import { clamp, containsPoint } from "../../utils/rectdiff-geometry"
+
+/**
+ * Find the longest contiguous free span around z (optionally capped).
+ */
+export function longestFreeSpanAroundZ(params: {
+  x: number
+  y: number
+  z: number
+  layerCount: number
+  minSpan: number
+  maxSpan: number | undefined
+  obstaclesByLayer: XYRect[][]
+  placedByLayer: XYRect[][]
+}): number[] {
+  const {
+    x,
+    y,
+    z,
+    layerCount,
+    minSpan,
+    maxSpan,
+    obstaclesByLayer,
+    placedByLayer,
+  } = params
+
+  const isFreeAt = (layer: number) => {
+    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)
+    // trim symmetrically (keeping z inside)
+    while (hi - lo + 1 > target) {
+      if (z - lo > hi - z) lo++
+      else hi--
+    }
+  }
+
+  const res: number[] = []
+  for (let i = lo; i <= hi; i++) res.push(i)
+  return res.length >= minSpan ? res : []
+}

package/lib/utils/buildHardPlacedByLayer.ts

@@ -0,0 +1,14 @@
+import type { Placed3D, XYRect } from "../rectdiff-types"
+
+export function allLayerNode(params: {
+  layerCount: number
+  placed: Placed3D[]
+}): XYRect[][] {
+  const out: XYRect[][] = 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)
+    }
+  }
+  return out
+}

package/lib/{solvers/rectdiff/geometry.ts → utils/expandRectFromSeed.ts}

@@ -1,64 +1,15 @@
-// lib/solvers/rectdiff/geometry.ts
-import type { XYRect } from "./types"
+import type { XYRect } from "../rectdiff-types"
+import { EPS, gt, gte, lt, lte, overlaps } from "./rectdiff-geometry"
 
-export const EPS = 1e-9
-export const clamp = (v: number, lo: number, hi: number) =>
-  Math.max(lo, Math.min(hi, v))
-export const gt = (a: number, b: number) => a > b + EPS
-export const gte = (a: number, b: number) => a > b - EPS
-export const lt = (a: number, b: number) => a < b - EPS
-export const lte = (a: number, b: number) => a < b + EPS
-
-export function overlaps(a: XYRect, b: XYRect) {
-  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
-  )
-}
-
-export function containsPoint(r: XYRect, x: number, y: number) {
-  return (
-    x >= r.x - EPS &&
-    x <= r.x + r.width + EPS &&
-    y >= r.y - EPS &&
-    y <= r.y + r.height + EPS
-  )
-}
-
-export function distancePointToRectEdges(px: number, py: number, r: XYRect) {
-  const edges: [number, number, number, number][] = [
-    [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
+type ExpandDirectionParams = {
+  r: XYRect
+  bounds: XYRect
+  blockers: XYRect[]
+  maxAspect: number | null | undefined
 }
 
-// --- directional expansion caps (respect board + blockers + aspect) ---
-
-function maxExpandRight(
-  r: XYRect,
-  bounds: XYRect,
-  blockers: XYRect[],
-  maxAspect: number | null | undefined,
-) {
+function maxExpandRight(params: ExpandDirectionParams) {
+  const { r, bounds, blockers, maxAspect } = params
   // Start with board boundary
   let maxWidth = bounds.x + bounds.width - r.x
 
@@ -94,12 +45,8 @@ function maxExpandRight(
   return Math.max(0, e)
 }
 
-function maxExpandDown(
-  r: XYRect,
-  bounds: XYRect,
-  blockers: XYRect[],
-  maxAspect: number | null | undefined,
-) {
+function maxExpandDown(params: ExpandDirectionParams) {
+  const { r, bounds, blockers, maxAspect } = params
   // Start with board boundary
   let maxHeight = bounds.y + bounds.height - r.y
 
@@ -134,12 +81,8 @@ function maxExpandDown(
   return Math.max(0, e)
 }
 
-function maxExpandLeft(
-  r: XYRect,
-  bounds: XYRect,
-  blockers: XYRect[],
-  maxAspect: number | null | undefined,
-) {
+function maxExpandLeft(params: ExpandDirectionParams) {
+  const { r, bounds, blockers, maxAspect } = params
   // Start with board boundary
   let minX = bounds.x
 
@@ -172,12 +115,8 @@ function maxExpandLeft(
   return Math.max(0, e)
 }
 
-function maxExpandUp(
-  r: XYRect,
-  bounds: XYRect,
-  blockers: XYRect[],
-  maxAspect: number | null | undefined,
-) {
+function maxExpandUp(params: ExpandDirectionParams) {
+  const { r, bounds, blockers, maxAspect } = params
   // Start with board boundary
   let minY = bounds.y
 
@@ -271,25 +210,27 @@ export function expandRectFromSeed(params: {
     let improved = true
     while (improved) {
       improved = false
-      const eR = maxExpandRight(r, bounds, blockers, maxAspectRatio)
+      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(r, bounds, blockers, maxAspectRatio)
+      const eD = maxExpandDown({ ...commonParams, r })
       if (eD > 0) {
         r = { ...r, height: r.height + eD }
         improved = true
       }
 
-      const eL = maxExpandLeft(r, bounds, blockers, maxAspectRatio)
+      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(r, bounds, blockers, maxAspectRatio)
+      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
@@ -307,43 +248,3 @@ export function expandRectFromSeed(params: {
 
   return best
 }
-
-/** Find the intersection of two 1D intervals, or null if they don't overlap. */
-export function intersect1D(a0: number, a1: number, b0: number, b1: number) {
-  const lo = Math.max(a0, b0)
-  const hi = Math.min(a1, b1)
-  return hi > lo + EPS ? ([lo, hi] as const) : null
-}
-
-/** Return A \ B as up to 4 non-overlapping rectangles (or [A] if no overlap). */
-export function subtractRect2D(A: XYRect, B: XYRect): XYRect[] {
-  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: XYRect[] = []
-
-  // Left strip
-  if (X0 > A.x + EPS) {
-    out.push({ x: A.x, y: A.y, width: X0 - A.x, height: A.height })
-  }
-  // Right strip
-  if (A.x + A.width > X1 + EPS) {
-    out.push({ x: X1, y: A.y, width: A.x + A.width - X1, height: A.height })
-  }
-  // Top wedge in the middle band
-  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 })
-  }
-  // Bottom wedge in the middle band
-  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)
-}

package/lib/utils/finalizeRects.ts

@@ -0,0 +1,49 @@
+import type { Placed3D, Rect3d, XYRect } from "../rectdiff-types"
+
+export function finalizeRects(params: {
+  placed: Placed3D[]
+  obstaclesByLayer: XYRect[][]
+  boardVoidRects: XYRect[]
+}): Rect3d[] {
+  // Convert all placed (free space) nodes to output format
+  const out: Rect3d[] = 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),
+  }))
+
+  /**
+   * Recover obstacles as mesh nodes.
+   * Obstacles are stored per-layer in `obstaclesByLayer`, but we want to emit
+   * single 3D nodes for multi-layer obstacles if they share the same rect.
+   * We use the `XYRect` object reference identity to group layers.
+   */
+  const layersByObstacleRect = new Map<XYRect, number[]>()
+
+  params.obstaclesByLayer.forEach((layerObs, z) => {
+    for (const rect of layerObs) {
+      const layerIndices = layersByObstacleRect.get(rect) ?? []
+      layerIndices.push(z)
+      layersByObstacleRect.set(rect, layerIndices)
+    }
+  })
+
+  // Append obstacle nodes to the output
+  const voidSet = new Set(params.boardVoidRects || [])
+  for (const [rect, layerIndices] of layersByObstacleRect.entries()) {
+    if (voidSet.has(rect)) continue // Skip void rects
+
+    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
+}