@tscircuit/rectdiff 0.0.24 → 0.0.26

package/lib/RectDiffPipeline.ts

@@ -8,6 +8,7 @@ import type { GridFill3DOptions, XYRect } from "./rectdiff-types"
 import type { CapacityMeshNode } from "./types/capacity-mesh-types"
 import type { GraphicsObject } from "graphics-debug"
 import { GapFillSolverPipeline } from "./solvers/GapFillSolver/GapFillSolverPipeline"
+import { OuterLayerContainmentMergeSolver } from "./solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver"
 import { RectDiffGridSolverPipeline } from "./solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline"
 import { createBaseVisualization } from "./rectdiff-visualization"
 import { buildFinalRectDiffVisualization } from "./buildFinalRectDiffVisualization"
@@ -25,6 +26,7 @@ export interface RectDiffPipelineInput {
 export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
   rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline
   gapFillSolver?: GapFillSolverPipeline
+  outerLayerContainmentMergeSolver?: OuterLayerContainmentMergeSolver
   boardVoidRects: XYRect[] | undefined
   zIndexByName?: Map<string, number>
   layerNames?: string[]
@@ -69,6 +71,22 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
         },
       ],
     ),
+    definePipelineStep(
+      "outerLayerContainmentMergeSolver",
+      OuterLayerContainmentMergeSolver,
+      (rectDiffPipeline: RectDiffPipeline) => [
+        {
+          meshNodes:
+            rectDiffPipeline.gapFillSolver?.getOutput().outputNodes ??
+            rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput()
+              .meshNodes ??
+            [],
+          simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
+          zIndexByName: rectDiffPipeline.zIndexByName ?? new Map(),
+          obstacleClearance: rectDiffPipeline.inputProblem.obstacleClearance,
+        },
+      ],
+    ),
   ]
 
   override _setup(): void {
@@ -100,6 +118,11 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
   }
 
   override getOutput(): { meshNodes: CapacityMeshNode[] } {
+    const outerLayerMergeOutput =
+      this.outerLayerContainmentMergeSolver?.getOutput()
+    if (outerLayerMergeOutput) {
+      return { meshNodes: outerLayerMergeOutput.outputNodes }
+    }
     const gapFillOutput = this.gapFillSolver?.getOutput()
     if (gapFillOutput) {
       return { meshNodes: gapFillOutput.outputNodes }

package/lib/solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver.ts

@@ -0,0 +1,311 @@
+import { BaseSolver } from "@tscircuit/solver-utils"
+import type { GraphicsObject } from "graphics-debug"
+import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
+import type { XYRect } from "lib/rectdiff-types"
+import type { Obstacle, SimpleRouteJson } from "lib/types/srj-types"
+import { obstacleToXYRect, obstacleZs } from "../RectDiffSeedingSolver/layers"
+import { getColorForZLayer } from "lib/utils/getColorForZLayer"
+import { subtractRect2D, overlaps, EPS } from "lib/utils/rectdiff-geometry"
+import { padRect } from "lib/utils/padRect"
+
+type OuterLayerContainmentMergeSolverInput = {
+  meshNodes: CapacityMeshNode[]
+  simpleRouteJson: SimpleRouteJson
+  zIndexByName: Map<string, number>
+  obstacleClearance?: number
+}
+
+type ObstacleWithRect = {
+  obstacle: Obstacle
+  rect: XYRect
+}
+
+const nodeToRect = (node: CapacityMeshNode): XYRect => ({
+  x: node.center.x - node.width / 2,
+  y: node.center.y - node.height / 2,
+  width: node.width,
+  height: node.height,
+})
+
+const rectArea = (rect: XYRect) => rect.width * rect.height
+
+const cloneNode = (node: CapacityMeshNode): CapacityMeshNode => ({
+  ...node,
+  center: { ...node.center },
+  availableZ: [...node.availableZ],
+})
+
+const cloneNodeWithRect = (
+  node: CapacityMeshNode,
+  rect: XYRect,
+  capacityMeshNodeId: string,
+): CapacityMeshNode => ({
+  ...node,
+  capacityMeshNodeId,
+  center: {
+    x: rect.x + rect.width / 2,
+    y: rect.y + rect.height / 2,
+  },
+  width: rect.width,
+  height: rect.height,
+  availableZ: [...node.availableZ],
+  layer: `z${node.availableZ.join(",")}`,
+})
+
+const isFreeNode = (node: CapacityMeshNode) =>
+  !node._containsObstacle && !node._containsTarget
+
+const isSingletonOuterNode = (node: CapacityMeshNode, outerZ: number) =>
+  node.availableZ.length === 1 && node.availableZ[0] === outerZ
+
+const sameRect = (a: XYRect, b: XYRect) =>
+  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
+
+const subtractRects = (target: XYRect, cutters: XYRect[]) => {
+  let remaining: XYRect[] = [target]
+
+  for (const cutter of cutters) {
+    if (remaining.length === 0) return remaining
+
+    const nextRemaining: XYRect[] = []
+    for (const piece of remaining) {
+      nextRemaining.push(...subtractRect2D(piece, cutter))
+    }
+    remaining = nextRemaining
+  }
+
+  return remaining
+}
+
+const isFullyCoveredByRects = (target: XYRect, coveringRects: XYRect[]) => {
+  return subtractRects(target, coveringRects).length === 0
+}
+
+export class OuterLayerContainmentMergeSolver extends BaseSolver {
+  private outputNodes: CapacityMeshNode[] = []
+  private promotedNodeIds = new Set<string>()
+  private residualNodeIds = new Set<string>()
+
+  constructor(private input: OuterLayerContainmentMergeSolverInput) {
+    super()
+  }
+
+  override _setup() {
+    this.outputNodes = this.input.meshNodes.map(cloneNode)
+    this.promotedNodeIds.clear()
+    this.residualNodeIds.clear()
+  }
+
+  override _step() {
+    this.outputNodes = this.processOuterLayerContainmentMerges()
+    this.solved = true
+  }
+
+  private processOuterLayerContainmentMerges(): CapacityMeshNode[] {
+    const srj = this.input.simpleRouteJson
+    const layerCount = Math.max(1, srj.layerCount || 1)
+    if (layerCount < 3) {
+      return this.input.meshNodes.map(cloneNode)
+    }
+
+    const topZ = 0
+    const bottomZ = layerCount - 1
+    const viaMinSize = Math.max(srj.minViaDiameter ?? 0, srj.minTraceWidth || 0)
+    const originalNodes = this.input.meshNodes.map(cloneNode)
+    const obstaclesByLayer = this.buildObstaclesByLayer(layerCount)
+    const mutableOuterNodes = originalNodes.filter(
+      (node) =>
+        isFreeNode(node) &&
+        (isSingletonOuterNode(node, topZ) ||
+          isSingletonOuterNode(node, bottomZ)),
+    )
+    const immutableNodes = originalNodes.filter(
+      (node) => !mutableOuterNodes.includes(node),
+    )
+    const freeSupportRectsByOuterLayer = new Map<number, XYRect[]>()
+    freeSupportRectsByOuterLayer.set(
+      topZ,
+      originalNodes
+        .filter((node) => isFreeNode(node) && node.availableZ.includes(topZ))
+        .map(nodeToRect),
+    )
+    freeSupportRectsByOuterLayer.set(
+      bottomZ,
+      originalNodes
+        .filter((node) => isFreeNode(node) && node.availableZ.includes(bottomZ))
+        .map(nodeToRect),
+    )
+
+    const promotedNodes: CapacityMeshNode[] = []
+    const promotedRects: XYRect[] = []
+    const candidateNodes = mutableOuterNodes
+      .filter(
+        (node) =>
+          node.width + EPS >= viaMinSize && node.height + EPS >= viaMinSize,
+      )
+      .sort((a, b) => rectArea(nodeToRect(b)) - rectArea(nodeToRect(a)))
+
+    for (const candidate of candidateNodes) {
+      const candidateZ = candidate.availableZ[0]!
+      const oppositeZ = candidateZ === topZ ? bottomZ : topZ
+      const candidateRect = nodeToRect(candidate)
+      const oppositeSupportRects =
+        freeSupportRectsByOuterLayer.get(oppositeZ) ?? []
+
+      if (
+        !this.isTransitCompatibleAcrossIntermediateLayers({
+          rect: candidateRect,
+          fromZ: candidateZ,
+          toZ: oppositeZ,
+          obstaclesByLayer,
+        })
+      ) {
+        continue
+      }
+      if (!isFullyCoveredByRects(candidateRect, oppositeSupportRects)) {
+        continue
+      }
+
+      promotedNodes.push({
+        ...candidate,
+        availableZ: [topZ, bottomZ],
+        layer: `z${topZ},${bottomZ}`,
+      })
+      promotedRects.push(candidateRect)
+      this.promotedNodeIds.add(candidate.capacityMeshNodeId)
+    }
+
+    let nextResidualId = 0
+    const residualNodes: CapacityMeshNode[] = []
+
+    for (const node of mutableOuterNodes) {
+      if (this.promotedNodeIds.has(node.capacityMeshNodeId)) {
+        continue
+      }
+
+      const nodeRect = nodeToRect(node)
+      const remainingPieces = subtractRects(nodeRect, promotedRects)
+
+      if (
+        remainingPieces.length === 1 &&
+        sameRect(remainingPieces[0]!, nodeRect)
+      ) {
+        residualNodes.push(node)
+        continue
+      }
+
+      for (const piece of remainingPieces) {
+        const residualNode = cloneNodeWithRect(
+          node,
+          piece,
+          `${node.capacityMeshNodeId}-outer-merge-${nextResidualId++}`,
+        )
+        residualNodes.push(residualNode)
+        this.residualNodeIds.add(residualNode.capacityMeshNodeId)
+      }
+    }
+
+    return [...immutableNodes, ...promotedNodes, ...residualNodes]
+  }
+
+  private buildObstaclesByLayer(layerCount: number): ObstacleWithRect[][] {
+    const out = Array.from(
+      { length: layerCount },
+      () => [] as ObstacleWithRect[],
+    )
+
+    for (const obstacle of this.input.simpleRouteJson.obstacles ?? []) {
+      const baseRect = obstacleToXYRect(obstacle)
+      if (!baseRect) continue
+      const rect = padRect(baseRect, this.input.obstacleClearance ?? 0)
+      const zLayers = obstacleZs(obstacle, this.input.zIndexByName)
+
+      for (const z of zLayers) {
+        if (z < 0 || z >= layerCount) continue
+        out[z]!.push({ obstacle, rect })
+      }
+    }
+
+    return out
+  }
+
+  private isTransitCompatibleAcrossIntermediateLayers(params: {
+    rect: XYRect
+    fromZ: number
+    toZ: number
+    obstaclesByLayer: ObstacleWithRect[][]
+  }) {
+    const { rect, fromZ, toZ, obstaclesByLayer } = params
+    const lo = Math.min(fromZ, toZ)
+    const hi = Math.max(fromZ, toZ)
+
+    if (hi - lo < 2) return false
+
+    for (let z = lo + 1; z < hi; z++) {
+      const overlapping = (obstaclesByLayer[z] ?? []).filter((entry) =>
+        overlaps(entry.rect, rect),
+      )
+      if (overlapping.length === 0) return false
+
+      const nonCopperOverlap = overlapping.some(
+        (entry) => !entry.obstacle.isCopperPour,
+      )
+      if (nonCopperOverlap) return false
+
+      const copperRects = overlapping
+        .filter((entry) => entry.obstacle.isCopperPour)
+        .map((entry) => entry.rect)
+
+      if (!isFullyCoveredByRects(rect, copperRects)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  override getOutput(): { outputNodes: CapacityMeshNode[] } {
+    return { outputNodes: this.outputNodes }
+  }
+
+  override visualize(): GraphicsObject {
+    return {
+      title: "OuterLayerContainmentMergeSolver",
+      coordinateSystem: "cartesian",
+      rects: this.outputNodes.map((node) => {
+        const colors = getColorForZLayer(node.availableZ)
+        const isPromoted = this.promotedNodeIds.has(node.capacityMeshNodeId)
+        const isResidual = this.residualNodeIds.has(node.capacityMeshNodeId)
+
+        return {
+          center: node.center,
+          width: node.width,
+          height: node.height,
+          stroke: isPromoted
+            ? "rgba(22, 163, 74, 0.95)"
+            : isResidual
+              ? "rgba(37, 99, 235, 0.95)"
+              : colors.stroke,
+          fill: node._containsObstacle
+            ? "rgba(239, 68, 68, 0.35)"
+            : isPromoted
+              ? "rgba(34, 197, 94, 0.28)"
+              : isResidual
+                ? "rgba(59, 130, 246, 0.18)"
+                : colors.fill,
+          layer: `z${node.availableZ.join(",")}`,
+          label: [
+            `node ${node.capacityMeshNodeId}`,
+            `z:${node.availableZ.join(",")}`,
+          ].join("\n"),
+        }
+      }),
+      points: [],
+      lines: [],
+      texts: [],
+    }
+  }
+}

package/lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts

@@ -57,6 +57,7 @@ export class RectDiffSeedingSolver extends BaseSolver {
   private candidates!: Candidate3D[]
   private placed!: Placed3D[]
   private placedIndexByLayer!: Array<RBush<RTreeRect>>
+  private hardPlacedByLayer!: XYRect[][]
   private expansionIndex!: number
   private edgeAnalysisDone!: boolean
   private totalSeedsThisGrid!: number
@@ -131,6 +132,7 @@ export class RectDiffSeedingSolver extends BaseSolver {
       { length: layerCount },
       () => new RBush<RTreeRect>(),
     )
+    this.hardPlacedByLayer = Array.from({ length: layerCount }, () => [])
     this.expansionIndex = 0
     this.edgeAnalysisDone = false
     this.totalSeedsThisGrid = 0
@@ -164,19 +166,13 @@ export class RectDiffSeedingSolver extends BaseSolver {
     } = this.options
     const grid = gridSizes[this.gridIndex]!
 
-    // Build hard-placed map once per micro-step (cheap)
-    const hardPlacedByLayer = allLayerNode({
-      layerCount: this.layerCount,
-      placed: this.placed,
-    })
-
     // Ensure candidates exist for this grid
     if (this.candidates.length === 0 && this.consumedSeedsThisGrid === 0) {
       this.candidates = computeCandidates3D({
         bounds: this.bounds,
         gridSize: grid,
         layerCount: this.layerCount,
-        hardPlacedByLayer,
+        hardPlacedByLayer: this.hardPlacedByLayer,
         obstacleIndexByLayer: this.input.obstacleIndexByLayer,
         placedIndexByLayer: this.placedIndexByLayer,
       })
@@ -185,9 +181,10 @@ export class RectDiffSeedingSolver extends BaseSolver {
     }
 
     // If no candidates remain, advance grid or run edge pass or switch phase
-    if (this.candidates.length === 0) {
+    if (this.consumedSeedsThisGrid >= this.candidates.length) {
       if (this.gridIndex + 1 < gridSizes.length) {
         this.gridIndex += 1
+        this.candidates = []
         this.totalSeedsThisGrid = 0
         this.consumedSeedsThisGrid = 0
         return
@@ -200,13 +197,14 @@ export class RectDiffSeedingSolver extends BaseSolver {
             layerCount: this.layerCount,
             obstacleIndexByLayer: this.input.obstacleIndexByLayer,
             placedIndexByLayer: this.placedIndexByLayer,
-            hardPlacedByLayer,
+            hardPlacedByLayer: this.hardPlacedByLayer,
           })
           this.edgeAnalysisDone = true
           this.totalSeedsThisGrid = this.candidates.length
           this.consumedSeedsThisGrid = 0
           return
         }
+        this.candidates = []
         this.solved = true
         this.expansionIndex = 0
         return
@@ -214,8 +212,17 @@ export class RectDiffSeedingSolver extends BaseSolver {
     }
 
     // Consume exactly one candidate
-    const cand = this.candidates.shift()!
-    this.consumedSeedsThisGrid += 1
+    const cand = this.candidates[this.consumedSeedsThisGrid++]!
+    if (
+      isFullyOccupiedAtPoint({
+        layerCount: this.layerCount,
+        obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+        placedIndexByLayer: this.placedIndexByLayer,
+        point: { x: cand.x, y: cand.y },
+      })
+    ) {
+      return
+    }
 
     // Evaluate attempts — multi-layer span first (computed ignoring soft nodes)
     const span = longestFreeSpanAroundZ({
@@ -226,7 +233,7 @@ export class RectDiffSeedingSolver extends BaseSolver {
       minSpan: minMulti.minLayers,
       maxSpan: maxMultiLayerSpan,
       obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-      additionalBlockersByLayer: hardPlacedByLayer,
+      additionalBlockersByLayer: this.hardPlacedByLayer,
     })
 
     const attempts: Array<{
@@ -285,17 +292,10 @@ export class RectDiffSeedingSolver extends BaseSolver {
         },
         newIndex,
       )
-
-      // New: relax candidate culling — only drop seeds that became fully occupied
-      this.candidates = this.candidates.filter(
-        (c) =>
-          !isFullyOccupiedAtPoint({
-            layerCount: this.layerCount,
-            obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-            placedIndexByLayer: this.placedIndexByLayer,
-            point: { x: c.x, y: c.y },
-          }),
-      )
+      this.hardPlacedByLayer = allLayerNode({
+        layerCount: this.layerCount,
+        placed: this.placed,
+      })
 
       return // processed one candidate
     }

package/lib/solvers/RectDiffSeedingSolver/computeCandidates3D.ts

@@ -27,6 +27,10 @@ export function computeCandidates3D(params: {
     hardPlacedByLayer,
   } = params
   const out = new Map<string, Candidate3D>() // key by (x,y)
+  const hardRectsByLayer = Array.from({ length: layerCount }, (_, z) => [
+    ...(obstacleIndexByLayer[z]?.all() ?? []),
+    ...(hardPlacedByLayer[z] ?? []),
+  ])
 
   for (let x = bounds.x; x < bounds.x + bounds.width; x += gridSize) {
     for (let y = bounds.y; y < bounds.y + bounds.height; y += gridSize) {
@@ -75,16 +79,11 @@ export function computeCandidates3D(params: {
         : bestZ
 
       // Distance heuristic against hard blockers only (obstacles + full-stack)
-      const hardAtZ = [
-        ...(obstacleIndexByLayer[anchorZ]?.all() ?? []),
-        ...(hardPlacedByLayer[anchorZ] ?? []),
-      ]
-      const d = Math.min(
-        distancePointToRectEdges({ x, y }, bounds),
-        ...(hardAtZ.length
-          ? hardAtZ.map((b) => distancePointToRectEdges({ x, y }, b))
-          : [Infinity]),
-      )
+      const hardAtZ = hardRectsByLayer[anchorZ] ?? []
+      let d = distancePointToRectEdges({ x, y }, bounds)
+      for (const blocker of hardAtZ) {
+        d = Math.min(d, distancePointToRectEdges({ x, y }, blocker))
+      }
       const distance = quantize(d)
 
       const k = `${x.toFixed(6)}|${y.toFixed(6)}`

package/lib/solvers/RectDiffSeedingSolver/computeEdgeCandidates3D.ts

@@ -7,6 +7,16 @@ import type { RTreeRect } from "lib/types/capacity-mesh-types"
 const quantize = (value: number, precision = 1e-6) =>
   Math.round(value / precision) * precision
 
+const toRect = (rect: XYRect | RTreeRect): XYRect =>
+  "minX" in rect
+    ? {
+        x: rect.minX,
+        y: rect.minY,
+        width: rect.maxX - rect.minX,
+        height: rect.maxY - rect.minY,
+      }
+    : rect
+
 /**
  * Compute exact uncovered segments along a 1D line.
  */
@@ -109,6 +119,12 @@ 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 hardRectsByLayer = Array.from({ length: layerCount }, (_, z) =>
+    [
+      ...(obstacleIndexByLayer[z]?.all() ?? []),
+      ...(hardPlacedByLayer[z] ?? []),
+    ].map(toRect),
+  )
   const key = (p: { x: number; y: number; z: number }) =>
     `${p.z}|${p.x.toFixed(6)}|${p.y.toFixed(6)}`
 
@@ -137,21 +153,11 @@ export function computeEdgeCandidates3D(params: {
     if (fullyOcc({ x, y })) return // new rule: only drop if truly impossible
 
     // Distance uses obstacles + hard nodes (soft nodes ignored for ranking)
-    const hard = [
-      ...(obstacleIndexByLayer[z]?.all() ?? []),
-      ...(hardPlacedByLayer[z] ?? []),
-    ].map((b) => ({
-      x: quantize(b.x),
-      y: quantize(b.y),
-      width: quantize(b.width),
-      height: quantize(b.height),
-    }))
-    const d = Math.min(
-      distancePointToRectEdges({ x, y }, bounds),
-      ...(hard.length
-        ? hard.map((b) => distancePointToRectEdges({ x, y }, b))
-        : [Infinity]),
-    )
+    const hard = hardRectsByLayer[z] ?? []
+    let d = distancePointToRectEdges({ x, y }, bounds)
+    for (const blocker of hard) {
+      d = Math.min(d, distancePointToRectEdges({ x, y }, blocker))
+    }
     const distance = quantize(d)
 
     const k = key({ x, y, z })
@@ -180,10 +186,7 @@ export function computeEdgeCandidates3D(params: {
   }
 
   for (let z = 0; z < layerCount; z++) {
-    const blockers = [
-      ...(obstacleIndexByLayer[z]?.all() ?? []),
-      ...(hardPlacedByLayer[z] ?? []),
-    ].map((b) => ({
+    const blockers = (hardRectsByLayer[z] ?? []).map((b) => ({
       x: quantize(b.x),
       y: quantize(b.y),
       width: quantize(b.width),

package/lib/solvers/RectDiffSeedingSolver/longestFreeSpanAroundZ.ts

@@ -35,7 +35,7 @@ export function longestFreeSpanAroundZ(params: {
       maxY: y,
     }
     const obstacleIdx = obstacleIndexByLayer[layer]
-    if (obstacleIdx && obstacleIdx.search(query).length > 0) return false
+    if (obstacleIdx && obstacleIdx.collides(query)) return false
 
     const extras = additionalBlockersByLayer?.[layer] ?? []
     return !extras.some((b) => containsPoint(b, { x, y }))

package/lib/types/srj-types.ts

@@ -19,6 +19,7 @@ export interface Obstacle {
   height: number
   connectedTo: TraceId[]
   netIsAssignable?: boolean
+  isCopperPour?: boolean
   offBoardConnectsTo?: TraceId[]
 }
 

package/lib/utils/expandRectFromSeed.ts

@@ -175,14 +175,13 @@ const toRect = (tree: RTreeRect): XYRect => ({
 })
 
 const addBlocker = (params: {
-  rect: XYRect
-  seen: Set<string>
+  rect: RTreeRect
+  seen: Set<RTreeRect>
   blockers: XYRect[]
 }) => {
   const { rect, seen, blockers } = params
-  const key = `${rect.x}|${rect.y}|${rect.width}|${rect.height}`
-  if (seen.has(key)) return
-  seen.add(key)
+  if (seen.has(rect)) return
+  seen.add(rect)
   blockers.push(rect)
 }
 
@@ -225,7 +224,7 @@ export function expandRectFromSeed(params: {
   const initialW = Math.max(minSide, minReq.width)
   const initialH = Math.max(minSide, minReq.height)
   const blockers: XYRect[] = []
-  const seen = new Set<string>()
+  const seen = new Set<RTreeRect>()
   const totalLayers = placedIndexByLayer.length
 
   // Ignore the existing placement we are expanding so it doesn't self-block.
@@ -237,7 +236,7 @@ export function expandRectFromSeed(params: {
       const blockersIndex = obsticalIndexByLayer[z]
       if (blockersIndex) {
         for (const entry of blockersIndex.search(query))
-          addBlocker({ rect: toRect(entry), seen, blockers })
+          addBlocker({ rect: entry, seen, blockers })
       }
 
       const placedLayer = placedIndexByLayer[z]
@@ -245,10 +244,9 @@ export function expandRectFromSeed(params: {
         for (const entry of placedLayer.search(query)) {
           const isFullStack = entry.zLayers.length >= totalLayers
           if (!isFullStack) continue
-          const rect = toRect(entry)
           if (
             isSelfRect({
-              rect,
+              rect: entry,
               startX,
               startY,
               initialW,
@@ -256,7 +254,7 @@ export function expandRectFromSeed(params: {
             })
           )
             continue
-          addBlocker({ rect, seen, blockers })
+          addBlocker({ rect: entry, seen, blockers })
         }
       }
     }

package/lib/utils/isFullyOccupiedAtPoint.ts

@@ -17,10 +17,10 @@ export function isFullyOccupiedAtPoint(params: OccupancyParams): boolean {
   }
   for (let z = 0; z < params.layerCount; z++) {
     const obstacleIdx = params.obstacleIndexByLayer[z]
-    const hasObstacle = !!obstacleIdx && obstacleIdx.search(query).length > 0
+    const hasObstacle = !!obstacleIdx && obstacleIdx.collides(query)
 
     const placedIdx = params.placedIndexByLayer[z]
-    const hasPlaced = !!placedIdx && placedIdx.search(query).length > 0
+    const hasPlaced = !!placedIdx && placedIdx.collides(query)
 
     if (!hasObstacle && !hasPlaced) return false
   }