@tscircuit/rectdiff 0.0.12 → 0.0.14

package/lib/RectDiffPipeline.ts

@@ -4,12 +4,12 @@ import {
   type PipelineStep,
 } from "@tscircuit/solver-utils"
 import type { SimpleRouteJson } from "./types/srj-types"
-import type { GridFill3DOptions } from "./solvers/rectdiff/types"
-import { RectDiffSolver } from "./solvers/RectDiffSolver"
+import type { GridFill3DOptions } from "./rectdiff-types"
 import type { CapacityMeshNode } from "./types/capacity-mesh-types"
 import type { GraphicsObject } from "graphics-debug"
-import { createBaseVisualization } from "./solvers/rectdiff/visualization"
 import { GapFillSolverPipeline } from "./solvers/GapFillSolver/GapFillSolverPipeline"
+import { RectDiffGridSolverPipeline } from "./solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline"
+import { createBaseVisualization } from "./rectdiff-visualization"
 
 export interface RectDiffPipelineInput {
   simpleRouteJson: SimpleRouteJson
@@ -17,24 +17,19 @@ export interface RectDiffPipelineInput {
 }
 
 export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
-  rectDiffSolver?: RectDiffSolver
+  rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline
   gapFillSolver?: GapFillSolverPipeline
 
   override pipelineDef: PipelineStep<any>[] = [
     definePipelineStep(
-      "rectDiffSolver",
-      RectDiffSolver,
-      (rectDiffPipeline) => [
+      "rectDiffGridSolverPipeline",
+      RectDiffGridSolverPipeline,
+      (rectDiffPipeline: RectDiffPipeline) => [
         {
           simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
           gridOptions: rectDiffPipeline.inputProblem.gridOptions,
         },
       ],
-      {
-        onSolved: () => {
-          // RectDiff mesh generation completed
-        },
-      },
     ),
     definePipelineStep(
       "gapFillSolver",
@@ -42,7 +37,8 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
       (rectDiffPipeline: RectDiffPipeline) => [
         {
           meshNodes:
-            rectDiffPipeline.rectDiffSolver?.getOutput().meshNodes ?? [],
+            rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput()
+              .meshNodes ?? [],
         },
       ],
     ),
@@ -57,7 +53,10 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
     if (gapFillOutput) {
       return { meshNodes: gapFillOutput.outputNodes }
     }
-    return this.rectDiffSolver!.getOutput()
+    if (this.rectDiffGridSolverPipeline) {
+      return this.rectDiffGridSolverPipeline.getOutput()
+    }
+    return { meshNodes: [] }
   }
 
   override initialVisualize(): GraphicsObject {
@@ -67,8 +66,10 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
       "RectDiffPipeline - Initial",
     )
 
-    // Show initial mesh nodes from rectDiffSolver if available
-    const initialNodes = this.rectDiffSolver?.getOutput().meshNodes ?? []
+    // Show initial mesh nodes from grid pipeline if available
+    const initialNodes =
+      this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? []
+
     for (const node of initialNodes) {
       graphics.rects!.push({
         center: node.center,
@@ -95,7 +96,7 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
 
     const { meshNodes: outputNodes } = this.getOutput()
     const initialNodeIds = new Set(
-      (this.rectDiffSolver?.getOutput().meshNodes ?? []).map(
+      (this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? []).map(
         (n) => n.capacityMeshNodeId,
       ),
     )

package/lib/{solvers/rectdiff/types.ts → rectdiff-types.ts}

@@ -1,6 +1,4 @@
 // lib/solvers/rectdiff/types.ts
-import type { SimpleRouteJson } from "../../types/srj-types"
-
 export type XYRect = { x: number; y: number; width: number; height: number }
 
 export type Rect3d = {
@@ -33,35 +31,3 @@ export type Candidate3D = {
   isEdgeSeed?: boolean
 }
 export type Placed3D = { rect: XYRect; zLayers: number[] }
-
-export type Phase = "GRID" | "EXPANSION" | "GAP_FILL" | "DONE"
-
-export type RectDiffState = {
-  // static
-  srj: SimpleRouteJson
-  layerNames: string[]
-  layerCount: number
-  bounds: XYRect
-  options: Required<
-    Omit<GridFill3DOptions, "gridSizes" | "maxMultiLayerSpan">
-  > & {
-    gridSizes: number[]
-    maxMultiLayerSpan: number | undefined
-  }
-  obstaclesByLayer: XYRect[][]
-  boardVoidRects: XYRect[] // newly added for viz
-
-  // evolving
-  phase: Phase
-  gridIndex: number // index in gridSizes
-  candidates: Candidate3D[]
-  placed: Placed3D[]
-  placedByLayer: XYRect[][]
-  expansionIndex: number
-  /** Whether we've already run the edge-analysis seeding pass. */
-  edgeAnalysisDone: boolean
-
-  // progress bookkeeping
-  totalSeedsThisGrid: number
-  consumedSeedsThisGrid: number
-}

package/lib/{solvers/rectdiff/visualization.ts → rectdiff-visualization.ts}

@@ -1,5 +1,6 @@
 import type { GraphicsObject } from "graphics-debug"
-import type { SimpleRouteJson } from "../../types/srj-types"
+import type { SimpleRouteJson } from "./types/srj-types"
+import type { XYRect } from "./rectdiff-types"
 
 /**
  * Create basic visualization showing board bounds/outline and obstacles.

package/lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts

@@ -158,8 +158,7 @@ export class FindSegmentsWithAdjacentEmptySpaceSolver extends BaseSolver {
       graphics.lines.push({
         points: visuallyOffsetLine(
           [unprocessedEdge.start, unprocessedEdge.end],
-          unprocessedEdge.facingDirection,
-          -0.1,
+          { dir: unprocessedEdge.facingDirection, amt: -0.1 },
         ),
         strokeColor: "rgba(0, 0, 255, 0.5)",
         strokeDash: "5 5",
@@ -183,11 +182,10 @@ export class FindSegmentsWithAdjacentEmptySpaceSolver extends BaseSolver {
     if (this.lastOverlappingEdges) {
       for (const edge of this.lastOverlappingEdges) {
         graphics.lines.push({
-          points: visuallyOffsetLine(
-            [edge.start, edge.end],
-            edge.facingDirection,
-            0.05,
-          ),
+          points: visuallyOffsetLine([edge.start, edge.end], {
+            dir: edge.facingDirection,
+            amt: 0.05,
+          }),
           strokeColor: "red",
           strokeDash: "2 2",
         })
@@ -197,11 +195,10 @@ export class FindSegmentsWithAdjacentEmptySpaceSolver extends BaseSolver {
     if (this.lastUncoveredSegments) {
       for (const edge of this.lastUncoveredSegments) {
         graphics.lines.push({
-          points: visuallyOffsetLine(
-            [edge.start, edge.end],
-            edge.facingDirection,
-            -0.05,
-          ),
+          points: visuallyOffsetLine([edge.start, edge.end], {
+            dir: edge.facingDirection,
+            amt: -0.05,
+          }),
           strokeColor: "green",
           strokeDash: "2 2",
         })

package/lib/solvers/GapFillSolver/visuallyOffsetLine.ts

@@ -21,9 +21,12 @@ const OFFSET_DIR_MAP = {
  */
 export const visuallyOffsetLine = (
   line: Array<{ x: number; y: number }>,
-  dir: "x-" | "x+" | "y-" | "y+",
-  amt: number,
+  options: {
+    dir: "x-" | "x+" | "y-" | "y+"
+    amt: number
+  },
 ) => {
+  const { dir, amt } = options
   const offset = OFFSET_DIR_MAP[dir]
   return line.map((p) => ({
     x: p.x + offset.x * amt,

package/lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts

@@ -0,0 +1,252 @@
+import { BaseSolver } from "@tscircuit/solver-utils"
+import type { GraphicsObject } from "graphics-debug"
+import type { CapacityMeshNode, RTreeRect } from "lib/types/capacity-mesh-types"
+import { expandRectFromSeed } from "../../utils/expandRectFromSeed"
+import { finalizeRects } from "../../utils/finalizeRects"
+import { allLayerNode } from "../../utils/buildHardPlacedByLayer"
+import { resizeSoftOverlaps } from "../../utils/resizeSoftOverlaps"
+import { rectsToMeshNodes } from "./rectsToMeshNodes"
+import type { XYRect, Candidate3D, Placed3D } from "../../rectdiff-types"
+import type { SimpleRouteJson } from "lib/types/srj-types"
+import {
+  buildZIndexMap,
+  obstacleToXYRect,
+  obstacleZs,
+} from "../RectDiffSeedingSolver/layers"
+import RBush from "rbush"
+import { rectToTree } from "../../utils/rectToTree"
+import { sameTreeRect } from "../../utils/sameTreeRect"
+
+export type RectDiffExpansionSolverSnapshot = {
+  srj: SimpleRouteJson
+  layerNames: string[]
+  layerCount: number
+  bounds: XYRect
+  options: {
+    gridSizes: number[]
+    // the engine only uses gridSizes here, other options are ignored
+    [key: string]: any
+  }
+  boardVoidRects: XYRect[]
+  gridIndex: number
+  candidates: Candidate3D[]
+  placed: Placed3D[]
+  expansionIndex: number
+  edgeAnalysisDone: boolean
+  totalSeedsThisGrid: number
+  consumedSeedsThisGrid: number
+}
+
+export type RectDiffExpansionSolverInput = {
+  initialSnapshot: RectDiffExpansionSolverSnapshot
+  obstacleIndexByLayer: Array<RBush<RTreeRect>>
+}
+
+/**
+ * Second phase of RectDiff: expand placed rects to their maximal extents.
+ *
+ * This solver takes the intermediate data produced by RectDiffSeedingSolver
+ * and runs the EXPANSION phase, then finalizes to capacity mesh nodes.
+ */
+export class RectDiffExpansionSolver extends BaseSolver {
+  // Engine fields (same shape used by rectdiff/engine.ts)
+  private srj!: SimpleRouteJson
+  private layerNames!: string[]
+  private layerCount!: number
+  private bounds!: XYRect
+  private options!: {
+    gridSizes: number[]
+    // the engine only uses gridSizes here, other options are ignored
+    [key: string]: any
+  }
+  private boardVoidRects!: XYRect[]
+  private gridIndex!: number
+  private candidates!: Candidate3D[]
+  private placed!: Placed3D[]
+  private placedIndexByLayer!: Array<RBush<RTreeRect>>
+  private expansionIndex!: number
+  private edgeAnalysisDone!: boolean
+  private totalSeedsThisGrid!: number
+  private consumedSeedsThisGrid!: number
+
+  private _meshNodes: CapacityMeshNode[] = []
+
+  constructor(private input: RectDiffExpansionSolverInput) {
+    super()
+    // Copy engine snapshot fields directly onto this solver instance
+    Object.assign(this, this.input.initialSnapshot)
+  }
+
+  override _setup() {
+    this.stats = {
+      gridIndex: this.gridIndex,
+    }
+
+    if (this.input.obstacleIndexByLayer) {
+    } else {
+      const { zIndexByName } = buildZIndexMap(this.srj)
+      this.input.obstacleIndexByLayer = Array.from(
+        { length: this.layerCount },
+        () => new RBush<RTreeRect>(),
+      )
+      const insertObstacle = (rect: XYRect, z: number) => {
+        const tree = this.input.obstacleIndexByLayer[z]
+        if (tree) tree.insert(rectToTree(rect))
+      }
+      for (const voidRect of this.boardVoidRects ?? []) {
+        for (let z = 0; z < this.layerCount; z++) insertObstacle(voidRect, z)
+      }
+      for (const obstacle of this.srj.obstacles ?? []) {
+        const rect = obstacleToXYRect(obstacle as any)
+        if (!rect) continue
+        const zLayers =
+          obstacle.zLayers?.length && obstacle.zLayers.length > 0
+            ? obstacle.zLayers
+            : obstacleZs(obstacle as any, zIndexByName)
+        zLayers.forEach((z) => {
+          if (z >= 0 && z < this.layerCount) insertObstacle(rect, z)
+        })
+      }
+    }
+
+    this.placedIndexByLayer = Array.from(
+      { length: this.layerCount },
+      () => new RBush<RTreeRect>(),
+    )
+    for (const placement of this.placed ?? []) {
+      for (const z of placement.zLayers) {
+        const tree = this.placedIndexByLayer[z]
+        if (tree) tree.insert(rectToTree(placement.rect))
+      }
+    }
+  }
+
+  override _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()
+    }
+  }
+
+  private _stepExpansion(): void {
+    if (this.expansionIndex >= this.placed.length) {
+      return
+    }
+
+    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,
+    })
+
+    // HARD blockers only: obstacles on p.zLayers + full-stack nodes
+    const hardBlockers: XYRect[] = []
+    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) {
+      // Update placement + per-layer index (replace old rect object)
+      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))
+        }
+      }
+
+      // Carve overlapped soft neighbors (respect full-stack nodes)
+      resizeSoftOverlaps(
+        {
+          layerCount: this.layerCount,
+          placed: this.placed,
+          options: this.options,
+          placedIndexByLayer: this.placedIndexByLayer,
+        },
+        idx,
+      )
+    }
+
+    this.expansionIndex += 1
+  }
+
+  private 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(): number {
+    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)))
+  }
+
+  override getOutput(): { meshNodes: CapacityMeshNode[] } {
+    if (!this.solved && this._meshNodes.length === 0) {
+      this.finalizeIfNeeded()
+    }
+    return { meshNodes: this._meshNodes }
+  }
+
+  /** Simple visualization of expanded placements. */
+  override visualize(): GraphicsObject {
+    const rects: NonNullable<GraphicsObject["rects"]> = []
+
+    for (const placement of this.placed ?? []) {
+      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,
+        stroke: "rgba(37, 99, 235, 0.9)",
+        fill: "rgba(191, 219, 254, 0.5)",
+        layer: `z${placement.zLayers.join(",")}`,
+        label: `expanded\nz:${placement.zLayers.join(",")}`,
+      })
+    }
+
+    return {
+      title: "RectDiff Expansion",
+      coordinateSystem: "cartesian",
+      rects,
+      points: [],
+      lines: [],
+    }
+  }
+}

package/lib/solvers/{rectdiff → RectDiffExpansionSolver}/rectsToMeshNodes.ts

@@ -1,6 +1,5 @@
-// lib/solvers/rectdiff/rectsToMeshNodes.ts
-import type { Rect3d } from "./types"
 import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
+import type { Rect3d } from "../../rectdiff-types"
 
 export function rectsToMeshNodes(rects: Rect3d[]): CapacityMeshNode[] {
   let id = 0

package/lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts

@@ -0,0 +1,106 @@
+import {
+  BasePipelineSolver,
+  definePipelineStep,
+  type PipelineStep,
+} from "@tscircuit/solver-utils"
+import type { SimpleRouteJson } from "lib/types/srj-types"
+import type { GridFill3DOptions, XYRect } from "lib/rectdiff-types"
+import type { CapacityMeshNode, RTreeRect } from "lib/types/capacity-mesh-types"
+import { RectDiffSeedingSolver } from "lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver"
+import { RectDiffExpansionSolver } from "lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver"
+import type { GraphicsObject } from "graphics-debug"
+import RBush from "rbush"
+import { buildObstacleIndexes } from "./buildObstacleIndexes"
+
+export type RectDiffGridSolverPipelineInput = {
+  simpleRouteJson: SimpleRouteJson
+  gridOptions?: Partial<GridFill3DOptions>
+}
+
+export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridSolverPipelineInput> {
+  rectDiffSeedingSolver?: RectDiffSeedingSolver
+  rectDiffExpansionSolver?: RectDiffExpansionSolver
+  private boardVoidRects?: XYRect[]
+  private obstacleIndexByLayer: Array<RBush<RTreeRect>>
+
+  constructor(inputProblem: RectDiffGridSolverPipelineInput) {
+    super(inputProblem)
+    const { obstacleIndexByLayer, boardVoidRects } = buildObstacleIndexes(
+      inputProblem.simpleRouteJson,
+    )
+    this.obstacleIndexByLayer = obstacleIndexByLayer
+    this.boardVoidRects = boardVoidRects
+  }
+
+  override pipelineDef: PipelineStep<any>[] = [
+    definePipelineStep(
+      "rectDiffSeedingSolver",
+      RectDiffSeedingSolver,
+      (pipeline: RectDiffGridSolverPipeline) => [
+        {
+          simpleRouteJson: pipeline.inputProblem.simpleRouteJson,
+          gridOptions: pipeline.inputProblem.gridOptions,
+          obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
+          boardVoidRects: pipeline.boardVoidRects,
+        },
+      ],
+    ),
+    definePipelineStep(
+      "rectDiffExpansionSolver",
+      RectDiffExpansionSolver,
+      (pipeline: RectDiffGridSolverPipeline) => [
+        {
+          initialSnapshot: {
+            ...pipeline.rectDiffSeedingSolver!.getOutput(),
+            boardVoidRects: pipeline.boardVoidRects ?? [],
+          },
+          obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
+        },
+      ],
+    ),
+  ]
+
+  override getConstructorParams() {
+    return [this.inputProblem]
+  }
+
+  override getOutput(): { meshNodes: CapacityMeshNode[] } {
+    if (this.rectDiffExpansionSolver) {
+      return this.rectDiffExpansionSolver.getOutput()
+    }
+    if (this.rectDiffSeedingSolver) {
+      const snapshot = this.rectDiffSeedingSolver.getOutput()
+      const meshNodes: CapacityMeshNode[] = snapshot.placed.map(
+        (placement: any, idx: number) => ({
+          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 { meshNodes: [] }
+  }
+
+  override visualize(): GraphicsObject {
+    if (this.rectDiffExpansionSolver) {
+      return this.rectDiffExpansionSolver.visualize()
+    }
+    if (this.rectDiffSeedingSolver) {
+      return this.rectDiffSeedingSolver.visualize()
+    }
+    return {
+      title: "RectDiff Grid Pipeline",
+      coordinateSystem: "cartesian",
+      rects: [],
+      points: [],
+      lines: [],
+    }
+  }
+}

package/lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts

@@ -0,0 +1,70 @@
+import type { SimpleRouteJson } from "lib/types/srj-types"
+import RBush from "rbush"
+import { computeInverseRects } from "lib/solvers/RectDiffSeedingSolver/computeInverseRects"
+import {
+  buildZIndexMap,
+  obstacleToXYRect,
+  obstacleZs,
+} from "lib/solvers/RectDiffSeedingSolver/layers"
+import type { XYRect } from "lib/rectdiff-types"
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
+
+export const buildObstacleIndexes = (
+  srj: SimpleRouteJson,
+): {
+  obstacleIndexByLayer: Array<RBush<RTreeRect>>
+  boardVoidRects: XYRect[]
+} => {
+  const { layerNames, zIndexByName } = buildZIndexMap(srj)
+  const layerCount = Math.max(1, layerNames.length, srj.layerCount || 1)
+  const bounds: XYRect = {
+    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 RBush<RTreeRect>(),
+  )
+
+  const insertObstacle = (rect: XYRect, z: number) => {
+    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: XYRect[] = []
+  if (srj.outline && srj.outline.length > 2) {
+    boardVoidRects = computeInverseRects(bounds, srj.outline as any)
+    for (const voidRect of boardVoidRects) {
+      for (let z = 0; z < layerCount; z++) insertObstacle(voidRect, z)
+    }
+  }
+
+  for (const obstacle of srj.obstacles ?? []) {
+    const rect = obstacleToXYRect(obstacle as any)
+    if (!rect) continue
+    const zLayers = obstacleZs(obstacle as any, zIndexByName)
+    const invalidZs = zLayers.filter((z) => z < 0 || z >= layerCount)
+    if (invalidZs.length) {
+      throw new Error(
+        `RectDiff: obstacle uses z-layer indices ${invalidZs.join(",")} outside 0-${layerCount - 1}`,
+      )
+    }
+    if (
+      (!obstacle.zLayers || obstacle.zLayers.length === 0) &&
+      zLayers.length
+    ) {
+      obstacle.zLayers = zLayers
+    }
+    for (const z of zLayers) insertObstacle(rect, z)
+  }
+
+  return { obstacleIndexByLayer, boardVoidRects }
+}