@tscircuit/rectdiff 0.0.13 → 0.0.14

package/lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts

@@ -1,13 +1,21 @@
 import { BaseSolver } from "@tscircuit/solver-utils"
 import type { GraphicsObject } from "graphics-debug"
-import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
+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 "../../types/srj-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
@@ -19,12 +27,10 @@ export type RectDiffExpansionSolverSnapshot = {
     // the engine only uses gridSizes here, other options are ignored
     [key: string]: any
   }
-  obstaclesByLayer: XYRect[][]
   boardVoidRects: XYRect[]
   gridIndex: number
   candidates: Candidate3D[]
   placed: Placed3D[]
-  placedByLayer: XYRect[][]
   expansionIndex: number
   edgeAnalysisDone: boolean
   totalSeedsThisGrid: number
@@ -33,6 +39,7 @@ export type RectDiffExpansionSolverSnapshot = {
 
 export type RectDiffExpansionSolverInput = {
   initialSnapshot: RectDiffExpansionSolverSnapshot
+  obstacleIndexByLayer: Array<RBush<RTreeRect>>
 }
 
 /**
@@ -52,12 +59,11 @@ export class RectDiffExpansionSolver extends BaseSolver {
     // the engine only uses gridSizes here, other options are ignored
     [key: string]: any
   }
-  private obstaclesByLayer!: XYRect[][]
   private boardVoidRects!: XYRect[]
   private gridIndex!: number
   private candidates!: Candidate3D[]
   private placed!: Placed3D[]
-  private placedByLayer!: XYRect[][]
+  private placedIndexByLayer!: Array<RBush<RTreeRect>>
   private expansionIndex!: number
   private edgeAnalysisDone!: boolean
   private totalSeedsThisGrid!: number
@@ -75,6 +81,44 @@ export class RectDiffExpansionSolver extends BaseSolver {
     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() {
@@ -107,7 +151,8 @@ export class RectDiffExpansionSolver extends BaseSolver {
     // HARD blockers only: obstacles on p.zLayers + full-stack nodes
     const hardBlockers: XYRect[] = []
     for (const z of p.zLayers) {
-      hardBlockers.push(...(this.obstaclesByLayer[z] ?? []))
+      const obstacleTree = this.input.obstacleIndexByLayer[z]
+      if (obstacleTree) hardBlockers.push(...obstacleTree.all())
       hardBlockers.push(...(hardPlacedByLayer[z] ?? []))
     }
 
@@ -127,9 +172,11 @@ export class RectDiffExpansionSolver extends BaseSolver {
       // Update placement + per-layer index (replace old rect object)
       this.placed[idx] = { rect: expanded, zLayers: p.zLayers }
       for (const z of p.zLayers) {
-        const arr = this.placedByLayer[z]!
-        const j = arr.findIndex((r) => r === oldRect)
-        if (j >= 0) arr[j] = expanded
+        const tree = this.placedIndexByLayer[z]
+        if (tree) {
+          tree.remove(rectToTree(oldRect), sameTreeRect)
+          tree.insert(rectToTree(expanded))
+        }
       }
 
       // Carve overlapped soft neighbors (respect full-stack nodes)
@@ -137,8 +184,8 @@ export class RectDiffExpansionSolver extends BaseSolver {
         {
           layerCount: this.layerCount,
           placed: this.placed,
-          placedByLayer: this.placedByLayer,
           options: this.options,
+          placedIndexByLayer: this.placedIndexByLayer,
         },
         idx,
       )
@@ -152,7 +199,7 @@ export class RectDiffExpansionSolver extends BaseSolver {
 
     const rects = finalizeRects({
       placed: this.placed,
-      obstaclesByLayer: this.obstaclesByLayer,
+      srj: this.srj,
       boardVoidRects: this.boardVoidRects,
     })
     this._meshNodes = rectsToMeshNodes(rects)

package/lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts

@@ -3,12 +3,14 @@ import {
   definePipelineStep,
   type PipelineStep,
 } from "@tscircuit/solver-utils"
-import type { SimpleRouteJson } from "../../types/srj-types"
-import type { GridFill3DOptions } from "../../rectdiff-types"
-import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
-import { RectDiffSeedingSolver } from "../RectDiffSeedingSolver/RectDiffSeedingSolver"
-import { RectDiffExpansionSolver } from "../RectDiffExpansionSolver/RectDiffExpansionSolver"
+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
@@ -18,6 +20,17 @@ export type RectDiffGridSolverPipelineInput = {
 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(
@@ -27,6 +40,8 @@ export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridS
         {
           simpleRouteJson: pipeline.inputProblem.simpleRouteJson,
           gridOptions: pipeline.inputProblem.gridOptions,
+          obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
+          boardVoidRects: pipeline.boardVoidRects,
         },
       ],
     ),
@@ -35,7 +50,11 @@ export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridS
       RectDiffExpansionSolver,
       (pipeline: RectDiffGridSolverPipeline) => [
         {
-          initialSnapshot: pipeline.rectDiffSeedingSolver!.getOutput(),
+          initialSnapshot: {
+            ...pipeline.rectDiffSeedingSolver!.getOutput(),
+            boardVoidRects: pipeline.boardVoidRects ?? [],
+          },
+          obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
         },
       ],
     ),

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 }
+}

package/lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts

@@ -16,12 +16,16 @@ import { computeCandidates3D } from "./computeCandidates3D"
 import { computeEdgeCandidates3D } from "./computeEdgeCandidates3D"
 import { longestFreeSpanAroundZ } from "./longestFreeSpanAroundZ"
 import { allLayerNode } from "../../utils/buildHardPlacedByLayer"
-import { isFullyOccupiedAtPoint } from "../../utils/isFullyOccupiedAtPoint"
+import { isFullyOccupiedAtPoint } from "lib/utils/isFullyOccupiedAtPoint"
 import { resizeSoftOverlaps } from "../../utils/resizeSoftOverlaps"
+import RBush from "rbush"
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
 
 export type RectDiffSeedingSolverInput = {
   simpleRouteJson: SimpleRouteJson
+  obstacleIndexByLayer: Array<RBush<RTreeRect>>
   gridOptions?: Partial<GridFill3DOptions>
+  boardVoidRects?: XYRect[]
 }
 
 /**
@@ -43,12 +47,11 @@ export class RectDiffSeedingSolver extends BaseSolver {
     gridSizes: number[]
     maxMultiLayerSpan: number | undefined
   }
-  private obstaclesByLayer!: XYRect[][]
-  private boardVoidRects!: XYRect[]
+  private boardVoidRects?: XYRect[]
   private gridIndex!: number
   private candidates!: Candidate3D[]
   private placed!: Placed3D[]
-  private placedByLayer!: XYRect[][]
+  private placedIndexByLayer!: Array<RBush<RTreeRect>>
   private expansionIndex!: number
   private edgeAnalysisDone!: boolean
   private totalSeedsThisGrid!: number
@@ -72,42 +75,6 @@ export class RectDiffSeedingSolver extends BaseSolver {
       height: srj.bounds.maxY - srj.bounds.minY,
     }
 
-    const obstaclesByLayer: XYRect[][] = Array.from(
-      { length: layerCount },
-      () => [],
-    )
-
-    let boardVoidRects: XYRect[] = []
-    if (srj.outline && srj.outline.length > 2) {
-      boardVoidRects = computeInverseRects(bounds, srj.outline as any)
-      for (const voidR of boardVoidRects) {
-        for (let z = 0; z < layerCount; z++) {
-          obstaclesByLayer[z]!.push(voidR)
-        }
-      }
-    }
-
-    for (const obstacle of srj.obstacles ?? []) {
-      const rect = obstacleToXYRect(obstacle 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) obstaclesByLayer[z]!.push(rect)
-    }
-
     const trace = Math.max(0.01, srj.minTraceWidth || 0.15)
     const defaults: Required<
       Omit<GridFill3DOptions, "gridSizes" | "maxMultiLayerSpan">
@@ -137,22 +104,19 @@ export class RectDiffSeedingSolver extends BaseSolver {
         computeDefaultGridSizes(bounds),
     }
 
-    const placedByLayer: XYRect[][] = Array.from(
-      { length: layerCount },
-      () => [],
-    )
-
     this.srj = srj
     this.layerNames = layerNames
     this.layerCount = layerCount
     this.bounds = bounds
     this.options = options
-    this.obstaclesByLayer = obstaclesByLayer
-    this.boardVoidRects = boardVoidRects
+    this.boardVoidRects = this.input.boardVoidRects
     this.gridIndex = 0
     this.candidates = []
     this.placed = []
-    this.placedByLayer = placedByLayer
+    this.placedIndexByLayer = Array.from(
+      { length: layerCount },
+      () => new RBush<RTreeRect>(),
+    )
     this.expansionIndex = 0
     this.edgeAnalysisDone = false
     this.totalSeedsThisGrid = 0
@@ -198,9 +162,9 @@ export class RectDiffSeedingSolver extends BaseSolver {
         bounds: this.bounds,
         gridSize: grid,
         layerCount: this.layerCount,
-        obstaclesByLayer: this.obstaclesByLayer,
-        placedByLayer: this.placedByLayer,
         hardPlacedByLayer,
+        obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+        placedIndexByLayer: this.placedIndexByLayer,
       })
       this.totalSeedsThisGrid = this.candidates.length
       this.consumedSeedsThisGrid = 0
@@ -220,8 +184,8 @@ export class RectDiffSeedingSolver extends BaseSolver {
             bounds: this.bounds,
             minSize,
             layerCount: this.layerCount,
-            obstaclesByLayer: this.obstaclesByLayer,
-            placedByLayer: this.placedByLayer,
+            obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+            placedIndexByLayer: this.placedIndexByLayer,
             hardPlacedByLayer,
           })
           this.edgeAnalysisDone = true
@@ -247,8 +211,8 @@ export class RectDiffSeedingSolver extends BaseSolver {
       layerCount: this.layerCount,
       minSpan: minMulti.minLayers,
       maxSpan: maxMultiLayerSpan,
-      obstaclesByLayer: this.obstaclesByLayer,
-      placedByLayer: hardPlacedByLayer,
+      obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+      additionalBlockersByLayer: hardPlacedByLayer,
     })
 
     const attempts: Array<{
@@ -276,8 +240,8 @@ export class RectDiffSeedingSolver extends BaseSolver {
       // HARD blockers only: obstacles on those layers + full-stack nodes
       const hardBlockers: XYRect[] = []
       for (const z of attempt.layers) {
-        if (this.obstaclesByLayer[z])
-          hardBlockers.push(...this.obstaclesByLayer[z]!)
+        const obstacleLayer = this.input.obstacleIndexByLayer[z]
+        if (obstacleLayer) hardBlockers.push(...obstacleLayer.all())
         if (hardPlacedByLayer[z]) hardBlockers.push(...hardPlacedByLayer[z]!)
       }
 
@@ -296,15 +260,26 @@ export class RectDiffSeedingSolver extends BaseSolver {
       // Place the new node
       const placed: Placed3D = { rect, zLayers: [...attempt.layers] }
       const newIndex = this.placed.push(placed) - 1
-      for (const z of attempt.layers) this.placedByLayer[z]!.push(rect)
+      for (const z of attempt.layers) {
+        const idx = this.placedIndexByLayer[z]
+        if (idx) {
+          idx.insert({
+            ...rect,
+            minX: rect.x,
+            minY: rect.y,
+            maxX: rect.x + rect.width,
+            maxY: rect.y + rect.height,
+          })
+        }
+      }
 
       // New: carve overlapped soft nodes
       resizeSoftOverlaps(
         {
           layerCount: this.layerCount,
           placed: this.placed,
-          placedByLayer: this.placedByLayer,
           options: this.options,
+          placedIndexByLayer: this.placedIndexByLayer,
         },
         newIndex,
       )
@@ -312,14 +287,12 @@ export class RectDiffSeedingSolver extends BaseSolver {
       // New: relax candidate culling — only drop seeds that became fully occupied
       this.candidates = this.candidates.filter(
         (c) =>
-          !isFullyOccupiedAtPoint(
-            {
-              layerCount: this.layerCount,
-              obstaclesByLayer: this.obstaclesByLayer,
-              placedByLayer: this.placedByLayer,
-            },
-            { x: c.x, y: c.y },
-          ),
+          !isFullyOccupiedAtPoint({
+            layerCount: this.layerCount,
+            obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+            placedIndexByLayer: this.placedIndexByLayer,
+            point: { x: c.x, y: c.y },
+          }),
       )
 
       return // processed one candidate
@@ -352,12 +325,10 @@ export class RectDiffSeedingSolver extends BaseSolver {
       layerCount: this.layerCount,
       bounds: this.bounds,
       options: this.options,
-      obstaclesByLayer: this.obstaclesByLayer,
       boardVoidRects: this.boardVoidRects,
       gridIndex: this.gridIndex,
       candidates: this.candidates,
       placed: this.placed,
-      placedByLayer: this.placedByLayer,
       expansionIndex: this.expansionIndex,
       edgeAnalysisDone: this.edgeAnalysisDone,
       totalSeedsThisGrid: this.totalSeedsThisGrid,

package/lib/solvers/RectDiffSeedingSolver/computeCandidates3D.ts

@@ -2,6 +2,8 @@ import type { Candidate3D, XYRect } from "../../rectdiff-types"
 import { EPS, distancePointToRectEdges } from "../../utils/rectdiff-geometry"
 import { isFullyOccupiedAtPoint } from "../../utils/isFullyOccupiedAtPoint"
 import { longestFreeSpanAroundZ } from "./longestFreeSpanAroundZ"
+import type RBush from "rbush"
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
 
 /**
  * Compute candidate seed points for a given grid size.
@@ -10,16 +12,16 @@ export function computeCandidates3D(params: {
   bounds: XYRect
   gridSize: number
   layerCount: number
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
+  obstacleIndexByLayer: Array<RBush<RTreeRect> | undefined>
+  placedIndexByLayer: Array<RBush<RTreeRect> | undefined>
   hardPlacedByLayer: XYRect[][]
 }): Candidate3D[] {
   const {
     bounds,
     gridSize,
     layerCount,
-    obstaclesByLayer,
-    placedByLayer,
+    obstacleIndexByLayer,
+    placedIndexByLayer,
     hardPlacedByLayer,
   } = params
   const out = new Map<string, Candidate3D>() // key by (x,y)
@@ -38,14 +40,12 @@ export function computeCandidates3D(params: {
 
       // New rule: Only drop if EVERY layer is occupied (by obstacle or node)
       if (
-        isFullyOccupiedAtPoint(
-          {
-            layerCount,
-            obstaclesByLayer,
-            placedByLayer,
-          },
-          { x, y },
-        )
+        isFullyOccupiedAtPoint({
+          layerCount,
+          obstacleIndexByLayer,
+          placedIndexByLayer,
+          point: { x, y },
+        })
       )
         continue
 
@@ -60,8 +60,8 @@ export function computeCandidates3D(params: {
           layerCount,
           minSpan: 1,
           maxSpan: undefined,
-          obstaclesByLayer,
-          placedByLayer: hardPlacedByLayer,
+          obstacleIndexByLayer,
+          additionalBlockersByLayer: hardPlacedByLayer,
         })
         if (s.length > bestSpan.length) {
           bestSpan = s
@@ -74,7 +74,7 @@ export function computeCandidates3D(params: {
 
       // Distance heuristic against hard blockers only (obstacles + full-stack)
       const hardAtZ = [
-        ...(obstaclesByLayer[anchorZ] ?? []),
+        ...(obstacleIndexByLayer[anchorZ]?.all() ?? []),
         ...(hardPlacedByLayer[anchorZ] ?? []),
       ]
       const d = Math.min(

package/lib/solvers/RectDiffSeedingSolver/computeEdgeCandidates3D.ts

@@ -2,6 +2,8 @@ import type { Candidate3D, XYRect } from "../../rectdiff-types"
 import { EPS, distancePointToRectEdges } from "../../utils/rectdiff-geometry"
 import { isFullyOccupiedAtPoint } from "../../utils/isFullyOccupiedAtPoint"
 import { longestFreeSpanAroundZ } from "./longestFreeSpanAroundZ"
+import type RBush from "rbush"
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
 
 /**
  * Compute exact uncovered segments along a 1D line.
@@ -79,16 +81,16 @@ export function computeEdgeCandidates3D(params: {
   bounds: XYRect
   minSize: number
   layerCount: number
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
+  obstacleIndexByLayer: Array<RBush<RTreeRect> | undefined>
+  placedIndexByLayer: Array<RBush<RTreeRect> | undefined>
   hardPlacedByLayer: XYRect[][]
 }): Candidate3D[] {
   const {
     bounds,
     minSize,
     layerCount,
-    obstaclesByLayer,
-    placedByLayer,
+    obstacleIndexByLayer,
+    placedIndexByLayer,
     hardPlacedByLayer,
   } = params
 
@@ -100,14 +102,12 @@ export function computeEdgeCandidates3D(params: {
     `${p.z}|${p.x.toFixed(6)}|${p.y.toFixed(6)}`
 
   function fullyOcc(p: { x: number; y: number }) {
-    return isFullyOccupiedAtPoint(
-      {
-        layerCount,
-        obstaclesByLayer,
-        placedByLayer,
-      },
-      p,
-    )
+    return isFullyOccupiedAtPoint({
+      layerCount,
+      obstacleIndexByLayer,
+      placedIndexByLayer,
+      point: p,
+    })
   }
 
   function pushIfFree(p: { x: number; y: number; z: number }) {
@@ -123,7 +123,7 @@ export function computeEdgeCandidates3D(params: {
 
     // Distance uses obstacles + hard nodes (soft nodes ignored for ranking)
     const hard = [
-      ...(obstaclesByLayer[z] ?? []),
+      ...(obstacleIndexByLayer[z]?.all() ?? []),
       ...(hardPlacedByLayer[z] ?? []),
     ]
     const d = Math.min(
@@ -145,15 +145,15 @@ export function computeEdgeCandidates3D(params: {
       layerCount,
       minSpan: 1,
       maxSpan: undefined,
-      obstaclesByLayer,
-      placedByLayer: hardPlacedByLayer,
+      obstacleIndexByLayer,
+      additionalBlockersByLayer: hardPlacedByLayer,
     })
     out.push({ x, y, z, distance: d, zSpanLen: span.length, isEdgeSeed: true })
   }
 
   for (let z = 0; z < layerCount; z++) {
     const blockers = [
-      ...(obstaclesByLayer[z] ?? []),
+      ...(obstacleIndexByLayer[z]?.all() ?? []),
       ...(hardPlacedByLayer[z] ?? []),
     ]
 

package/lib/solvers/RectDiffSeedingSolver/longestFreeSpanAroundZ.ts

@@ -1,5 +1,7 @@
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
 import type { XYRect } from "../../rectdiff-types"
 import { clamp, containsPoint } from "../../utils/rectdiff-geometry"
+import type RBush from "rbush"
 
 /**
  * Find the longest contiguous free span around z (optionally capped).
@@ -11,8 +13,8 @@ export function longestFreeSpanAroundZ(params: {
   layerCount: number
   minSpan: number
   maxSpan: number | undefined
-  obstaclesByLayer: XYRect[][]
-  placedByLayer: XYRect[][]
+  obstacleIndexByLayer: Array<RBush<RTreeRect> | undefined>
+  additionalBlockersByLayer?: XYRect[][]
 }): number[] {
   const {
     x,
@@ -21,16 +23,22 @@ export function longestFreeSpanAroundZ(params: {
     layerCount,
     minSpan,
     maxSpan,
-    obstaclesByLayer,
-    placedByLayer,
+    obstacleIndexByLayer,
+    additionalBlockersByLayer,
   } = params
 
   const isFreeAt = (layer: number) => {
-    const blockers = [
-      ...(obstaclesByLayer[layer] ?? []),
-      ...(placedByLayer[layer] ?? []),
-    ]
-    return !blockers.some((b) => containsPoint(b, { x, y }))
+    const query = {
+      minX: x,
+      minY: y,
+      maxX: x,
+      maxY: y,
+    }
+    const obstacleIdx = obstacleIndexByLayer[layer]
+    if (obstacleIdx && obstacleIdx.search(query).length > 0) return false
+
+    const extras = additionalBlockersByLayer?.[layer] ?? []
+    return !extras.some((b) => containsPoint(b, { x, y }))
   }
   let lo = z
   let hi = z