@tscircuit/rectdiff 0.0.22 → 0.0.23

package/lib/RectDiffPipeline.ts

@@ -11,16 +11,22 @@ import { GapFillSolverPipeline } from "./solvers/GapFillSolver/GapFillSolverPipe
 import { RectDiffGridSolverPipeline } from "./solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline"
 import { createBaseVisualization } from "./rectdiff-visualization"
 import { computeInverseRects } from "./solvers/RectDiffSeedingSolver/computeInverseRects"
+import { buildZIndexMap } from "./solvers/RectDiffSeedingSolver/layers"
+import { buildObstacleClearanceGraphics } from "./utils/renderObstacleClearance"
+import { mergeGraphics } from "graphics-debug"
 
 export interface RectDiffPipelineInput {
   simpleRouteJson: SimpleRouteJson
   gridOptions?: Partial<GridFill3DOptions>
+  obstacleClearance?: number
 }
 
 export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
   rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline
   gapFillSolver?: GapFillSolverPipeline
   boardVoidRects: XYRect[] | undefined
+  zIndexByName?: Map<string, number>
+  layerNames?: string[]
 
   override pipelineDef: PipelineStep<any>[] = [
     definePipelineStep(
@@ -28,9 +34,21 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
       RectDiffGridSolverPipeline,
       (rectDiffPipeline: RectDiffPipeline) => [
         {
-          simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
+          bounds: rectDiffPipeline.inputProblem.simpleRouteJson.bounds,
+          obstacles: rectDiffPipeline.inputProblem.simpleRouteJson.obstacles,
+          connections:
+            rectDiffPipeline.inputProblem.simpleRouteJson.connections,
+          outline: rectDiffPipeline.inputProblem.simpleRouteJson.outline
+            ? { outline: rectDiffPipeline.inputProblem.simpleRouteJson.outline }
+            : undefined,
+          layerCount: rectDiffPipeline.inputProblem.simpleRouteJson.layerCount,
           gridOptions: rectDiffPipeline.inputProblem.gridOptions,
           boardVoidRects: rectDiffPipeline.boardVoidRects,
+          layerNames: rectDiffPipeline.layerNames,
+          zIndexByName: rectDiffPipeline.zIndexByName,
+          minTraceWidth:
+            rectDiffPipeline.inputProblem.simpleRouteJson.minTraceWidth,
+          obstacleClearance: rectDiffPipeline.inputProblem.obstacleClearance,
         },
       ],
     ),
@@ -53,6 +71,12 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
   ]
 
   override _setup(): void {
+    const { zIndexByName, layerNames } = buildZIndexMap({
+      obstacles: this.inputProblem.simpleRouteJson.obstacles,
+      layerCount: this.inputProblem.simpleRouteJson.layerCount,
+    })
+    this.zIndexByName = zIndexByName
+    this.layerNames = layerNames
     if (this.inputProblem.simpleRouteJson.outline) {
       this.boardVoidRects = computeInverseRects(
         {
@@ -86,17 +110,23 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
   }
 
   override initialVisualize(): GraphicsObject {
-    const graphics = createBaseVisualization(
+    const base = createBaseVisualization(
       this.inputProblem.simpleRouteJson,
       "RectDiffPipeline - Initial",
     )
+    const clearance = buildObstacleClearanceGraphics({
+      srj: this.inputProblem.simpleRouteJson,
+      clearance: this.inputProblem.obstacleClearance,
+    })
 
     // Show initial mesh nodes from grid pipeline if available
     const initialNodes =
       this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? []
 
-    for (const node of initialNodes) {
-      graphics.rects!.push({
+    const nodeRects: GraphicsObject = {
+      title: "Initial Nodes",
+      coordinateSystem: "cartesian",
+      rects: initialNodes.map((node) => ({
         center: node.center,
         width: node.width,
         height: node.height,
@@ -107,17 +137,21 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
           `node ${node.capacityMeshNodeId}`,
           `z:${node.availableZ.join(",")}`,
         ].join("\n"),
-      })
+      })),
     }
 
-    return graphics
+    return mergeGraphics(mergeGraphics(base, clearance), nodeRects)
   }
 
   override finalVisualize(): GraphicsObject {
-    const graphics = createBaseVisualization(
+    const base = createBaseVisualization(
       this.inputProblem.simpleRouteJson,
       "RectDiffPipeline - Final",
     )
+    const clearance = buildObstacleClearanceGraphics({
+      srj: this.inputProblem.simpleRouteJson,
+      clearance: this.inputProblem.obstacleClearance,
+    })
 
     const { meshNodes: outputNodes } = this.getOutput()
     const initialNodeIds = new Set(
@@ -126,22 +160,28 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
       ),
     )
 
-    for (const node of outputNodes) {
-      const isExpanded = !initialNodeIds.has(node.capacityMeshNodeId)
-      graphics.rects!.push({
-        center: node.center,
-        width: node.width,
-        height: node.height,
-        stroke: isExpanded ? "rgba(0, 128, 0, 0.8)" : "rgba(0, 0, 0, 0.3)",
-        fill: isExpanded ? "rgba(0, 200, 0, 0.3)" : "rgba(100, 100, 100, 0.1)",
-        layer: `z${node.availableZ.join(",")}`,
-        label: [
-          `${isExpanded ? "[expanded] " : ""}node ${node.capacityMeshNodeId}`,
-          `z:${node.availableZ.join(",")}`,
-        ].join("\n"),
-      })
+    const nodeRects: GraphicsObject = {
+      title: "Final Nodes",
+      coordinateSystem: "cartesian",
+      rects: outputNodes.map((node) => {
+        const isExpanded = !initialNodeIds.has(node.capacityMeshNodeId)
+        return {
+          center: node.center,
+          width: node.width,
+          height: node.height,
+          stroke: isExpanded ? "rgba(0, 128, 0, 0.8)" : "rgba(0, 0, 0, 0.3)",
+          fill: isExpanded
+            ? "rgba(0, 200, 0, 0.3)"
+            : "rgba(100, 100, 100, 0.1)",
+          layer: `z${node.availableZ.join(",")}`,
+          label: [
+            `${isExpanded ? "[expanded] " : ""}node ${node.capacityMeshNodeId}`,
+            `z:${node.availableZ.join(",")}`,
+          ].join("\n"),
+        }
+      }),
     }
 
-    return graphics
+    return mergeGraphics(mergeGraphics(base, clearance), nodeRects)
   }
 }

package/lib/fixtures/twoNodeExpansionFixture.ts

@@ -3,6 +3,7 @@ import type { RectDiffExpansionSolverInput } from "../solvers/RectDiffExpansionS
 import type { SimpleRouteJson } from "../types/srj-types"
 import type { XYRect } from "../rectdiff-types"
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
+import { buildZIndexMap } from "../solvers/RectDiffSeedingSolver/layers"
 
 /**
  * Builds a minimal RectDiffExpansionSolver snapshot with exactly two nodes
@@ -31,9 +32,13 @@ export const createTwoNodeExpansionInput = (): RectDiffExpansionSolverInput => {
   )
   // Start with all-empty obstacle indexes for a "clean" scenario
 
+  const { zIndexByName, layerNames } = buildZIndexMap({
+    obstacles: srj.obstacles,
+    layerCount: srj.layerCount,
+  })
+
   return {
-    srj,
-    layerNames: ["top"],
+    layerNames,
     layerCount,
     bounds,
     options: { gridSizes: [1] },
@@ -55,5 +60,8 @@ export const createTwoNodeExpansionInput = (): RectDiffExpansionSolverInput => {
     totalSeedsThisGrid: 0,
     consumedSeedsThisGrid: 0,
     obstacleIndexByLayer,
+    zIndexByName,
+    layerNamesCanonical: layerNames,
+    obstacles: srj.obstacles,
   }
 }

package/lib/rectdiff-visualization.ts

@@ -45,6 +45,7 @@ export function createBaseVisualization(
   // Draw obstacles
   for (const obstacle of srj.obstacles ?? []) {
     if (obstacle.type === "rect" || obstacle.type === "oval") {
+      const layerLabel = (obstacle.zLayers ?? []).join(",") || "all"
       rects.push({
         center: { x: obstacle.center.x, y: obstacle.center.y },
         width: obstacle.width,
@@ -52,7 +53,7 @@ export function createBaseVisualization(
         fill: "#fee2e2",
         stroke: "#ef4444",
         layer: "obstacle",
-        label: "obstacle",
+        label: `obstacle\nz:${layerLabel}`,
       })
     }
   }

package/lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts

@@ -6,13 +6,12 @@ import { finalizeRects } from "../../utils/finalizeRects"
 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 type { Obstacle } from "lib/types/srj-types"
 import RBush from "rbush"
 import { rectToTree } from "../../utils/rectToTree"
 import { sameTreeRect } from "../../utils/sameTreeRect"
 
 export type RectDiffExpansionSolverInput = {
-  srj: SimpleRouteJson
   layerNames: string[]
   layerCount: number
   bounds: XYRect
@@ -29,6 +28,10 @@ export type RectDiffExpansionSolverInput = {
   totalSeedsThisGrid: number
   consumedSeedsThisGrid: number
   obstacleIndexByLayer: Array<RBush<RTreeRect>>
+  zIndexByName: Map<string, number>
+  layerNamesCanonical: string[]
+  obstacles: Obstacle[]
+  obstacleClearance?: number
 }
 
 /**
@@ -132,8 +135,10 @@ export class RectDiffExpansionSolver extends BaseSolver {
 
     const rects = finalizeRects({
       placed: this.input.placed,
-      srj: this.input.srj,
+      obstacles: this.input.obstacles,
+      zIndexByName: this.input.zIndexByName,
       boardVoidRects: this.input.boardVoidRects,
+      obstacleClearance: this.input.obstacleClearance,
     })
     this._meshNodes = rectsToMeshNodes(rects)
     this.solved = true

package/lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts

@@ -3,7 +3,11 @@ import {
   definePipelineStep,
   type PipelineStep,
 } from "@tscircuit/solver-utils"
-import type { SimpleRouteJson } from "lib/types/srj-types"
+import type {
+  Obstacle,
+  SimpleRouteConnection,
+  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"
@@ -11,25 +15,47 @@ import { RectDiffExpansionSolver } from "lib/solvers/RectDiffExpansionSolver/Rec
 import type { GraphicsObject } from "graphics-debug"
 import RBush from "rbush"
 import { buildObstacleIndexesByLayer } from "./buildObstacleIndexes"
+import type { Bounds } from "@tscircuit/math-utils"
 
 export type RectDiffGridSolverPipelineInput = {
-  simpleRouteJson: SimpleRouteJson
+  bounds: Bounds
+  obstacles: Obstacle[]
+  connections: SimpleRouteConnection[]
+  outline?: Pick<SimpleRouteJson, "outline">
+  layerCount: number
+  minTraceWidth: number
+  obstacleClearance?: number
   gridOptions?: Partial<GridFill3DOptions>
   boardVoidRects?: XYRect[]
+  layerNames?: string[]
+  zIndexByName?: Map<string, number>
 }
 
 export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridSolverPipelineInput> {
   rectDiffSeedingSolver?: RectDiffSeedingSolver
   rectDiffExpansionSolver?: RectDiffExpansionSolver
   private obstacleIndexByLayer: Array<RBush<RTreeRect>>
+  private layerNames: string[]
+  private zIndexByName: Map<string, number>
 
   constructor(inputProblem: RectDiffGridSolverPipelineInput) {
     super(inputProblem)
-    const { obstacleIndexByLayer } = buildObstacleIndexesByLayer({
-      srj: inputProblem.simpleRouteJson,
-      boardVoidRects: inputProblem.boardVoidRects,
-    })
+    const { obstacleIndexByLayer, layerNames, zIndexByName } =
+      buildObstacleIndexesByLayer({
+        srj: {
+          bounds: inputProblem.bounds,
+          obstacles: inputProblem.obstacles,
+          connections: inputProblem.connections,
+          outline: inputProblem.outline?.outline,
+          layerCount: inputProblem.layerCount,
+          minTraceWidth: inputProblem.minTraceWidth,
+        },
+        boardVoidRects: inputProblem.boardVoidRects,
+        obstacleClearance: inputProblem.obstacleClearance,
+      })
     this.obstacleIndexByLayer = obstacleIndexByLayer
+    this.layerNames = inputProblem.layerNames ?? layerNames
+    this.zIndexByName = inputProblem.zIndexByName ?? zIndexByName
   }
 
   override pipelineDef: PipelineStep<any>[] = [
@@ -38,10 +64,20 @@ export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridS
       RectDiffSeedingSolver,
       (pipeline: RectDiffGridSolverPipeline) => [
         {
-          simpleRouteJson: pipeline.inputProblem.simpleRouteJson,
+          simpleRouteJson: {
+            bounds: pipeline.inputProblem.bounds,
+            obstacles: pipeline.inputProblem.obstacles,
+            connections: pipeline.inputProblem.connections,
+            outline: pipeline.inputProblem.outline?.outline,
+            layerCount: pipeline.inputProblem.layerCount,
+            minTraceWidth: pipeline.inputProblem.minTraceWidth,
+          },
           gridOptions: pipeline.inputProblem.gridOptions,
           obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
           boardVoidRects: pipeline.inputProblem.boardVoidRects,
+          layerNames: pipeline.layerNames,
+          zIndexByName: pipeline.zIndexByName,
+          obstacleClearance: pipeline.inputProblem.obstacleClearance,
         },
       ],
     ),
@@ -55,10 +91,9 @@ export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridS
         }
         return [
           {
-            srj: pipeline.inputProblem.simpleRouteJson,
             layerNames: output.layerNames ?? [],
             boardVoidRects: pipeline.inputProblem.boardVoidRects ?? [],
-            layerCount: pipeline.inputProblem.simpleRouteJson.layerCount,
+            layerCount: pipeline.inputProblem.layerCount,
             bounds: output.bounds!,
             candidates: output.candidates,
             consumedSeedsThisGrid: output.placed.length,
@@ -69,6 +104,10 @@ export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridS
             expansionIndex: output.expansionIndex,
             obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
             options: output.options,
+            zIndexByName: pipeline.zIndexByName,
+            layerNamesCanonical: pipeline.layerNames,
+            obstacles: pipeline.inputProblem.obstacles,
+            obstacleClearance: pipeline.inputProblem.obstacleClearance,
           },
         ]
       },

package/lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts

@@ -8,15 +8,22 @@ import {
 } from "lib/solvers/RectDiffSeedingSolver/layers"
 import type { XYRect } from "lib/rectdiff-types"
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
+import { padRect } from "lib/utils/padRect"
 
 export const buildObstacleIndexesByLayer = (params: {
   srj: SimpleRouteJson
   boardVoidRects?: XYRect[]
+  obstacleClearance?: number
 }): {
   obstacleIndexByLayer: Array<RBush<RTreeRect>>
+  layerNames: string[]
+  zIndexByName: Map<string, number>
 } => {
-  const { srj, boardVoidRects } = params
-  const { layerNames, zIndexByName } = buildZIndexMap(srj)
+  const { srj, boardVoidRects, obstacleClearance } = params
+  const { layerNames, zIndexByName } = buildZIndexMap({
+    obstacles: srj.obstacles,
+    layerCount: srj.layerCount,
+  })
   const layerCount = Math.max(1, layerNames.length, srj.layerCount || 1)
   const bounds: XYRect = {
     x: srj.bounds.minX,
@@ -48,9 +55,10 @@ export const buildObstacleIndexesByLayer = (params: {
   }
 
   for (const obstacle of srj.obstacles ?? []) {
-    const rect = obstacleToXYRect(obstacle as any)
-    if (!rect) continue
-    const zLayers = obstacleZs(obstacle as any, zIndexByName)
+    const rectBase = obstacleToXYRect(obstacle)
+    if (!rectBase) continue
+    const rect = padRect(rectBase, obstacleClearance ?? 0)
+    const zLayers = obstacleZs(obstacle, zIndexByName)
     const invalidZs = zLayers.filter((z) => z < 0 || z >= layerCount)
     if (invalidZs.length) {
       throw new Error(
@@ -66,5 +74,5 @@ export const buildObstacleIndexesByLayer = (params: {
     for (const z of zLayers) insertObstacle(rect, z)
   }
 
-  return { obstacleIndexByLayer }
+  return { obstacleIndexByLayer, layerNames, zIndexByName }
 }

package/lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts

@@ -28,6 +28,9 @@ export type RectDiffSeedingSolverInput = {
   obstacleIndexByLayer: Array<RBush<RTreeRect>>
   gridOptions?: Partial<GridFill3DOptions>
   boardVoidRects?: XYRect[]
+  layerNames: string[]
+  zIndexByName: Map<string, number>
+  obstacleClearance?: number
 }
 
 /**
@@ -67,7 +70,16 @@ export class RectDiffSeedingSolver extends BaseSolver {
     const srj = this.input.simpleRouteJson
     const opts = this.input.gridOptions ?? {}
 
-    const { layerNames, zIndexByName } = buildZIndexMap(srj)
+    const precomputed = this.input.layerNames && this.input.zIndexByName
+    const { layerNames, zIndexByName } = precomputed
+      ? {
+          layerNames: this.input.layerNames!,
+          zIndexByName: this.input.zIndexByName!,
+        }
+      : buildZIndexMap({
+          obstacles: srj.obstacles,
+          layerCount: srj.layerCount,
+        })
     const layerCount = Math.max(1, layerNames.length, srj.layerCount || 1)
 
     const bounds: XYRect = {
@@ -310,7 +322,6 @@ export class RectDiffSeedingSolver extends BaseSolver {
    */
   override getOutput() {
     return {
-      srj: this.srj,
       layerNames: this.layerNames,
       layerCount: this.layerCount,
       bounds: this.bounds,
@@ -323,6 +334,8 @@ export class RectDiffSeedingSolver extends BaseSolver {
       edgeAnalysisDone: this.edgeAnalysisDone,
       totalSeedsThisGrid: this.totalSeedsThisGrid,
       consumedSeedsThisGrid: this.consumedSeedsThisGrid,
+      obstacles: this.srj.obstacles,
+      obstacleClearance: this.input.obstacleClearance,
     }
   }
 
@@ -379,6 +392,31 @@ export class RectDiffSeedingSolver extends BaseSolver {
       }
     }
 
+    // obstacle clearance visualization (expanded)
+    if (this.input.obstacleClearance && this.input.obstacleClearance > 0) {
+      for (const obstacle of srj.obstacles ?? []) {
+        const pad = this.input.obstacleClearance
+        const expanded = {
+          x: obstacle.center.x - obstacle.width / 2 - pad,
+          y: obstacle.center.y - obstacle.height / 2 - pad,
+          width: obstacle.width + 2 * pad,
+          height: obstacle.height + 2 * pad,
+        }
+        rects.push({
+          center: {
+            x: expanded.x + expanded.width / 2,
+            y: expanded.y + expanded.height / 2,
+          },
+          width: expanded.width,
+          height: expanded.height,
+          fill: "rgba(234, 179, 8, 0.15)",
+          stroke: "rgba(202, 138, 4, 0.9)",
+          layer: "obstacle-clearance",
+          label: "clearance",
+        })
+      }
+    }
+
     // board void rects (early visualization of mask)
     if (this.boardVoidRects) {
       let outlineBBox: {
@@ -423,10 +461,8 @@ export class RectDiffSeedingSolver extends BaseSolver {
         points.push({
           x: cand.x,
           y: cand.y,
-          fill: "#9333ea",
-          stroke: "#6b21a8",
           label: `z:${cand.z}`,
-        } as any)
+        })
       }
     }
 

package/lib/solvers/RectDiffSeedingSolver/layers.ts

@@ -21,11 +21,15 @@ export function canonicalizeLayerOrder(names: string[]) {
   })
 }
 
-export function buildZIndexMap(srj: SimpleRouteJson) {
+// TODO: should not take a srj
+export function buildZIndexMap(params: {
+  obstacles?: Obstacle[]
+  layerCount?: number
+}) {
   const names = canonicalizeLayerOrder(
-    (srj.obstacles ?? []).flatMap((o) => o.layers ?? []),
+    (params.obstacles ?? []).flatMap((o) => o.layers ?? []),
   )
-  const declaredLayerCount = Math.max(1, srj.layerCount || names.length || 1)
+  const declaredLayerCount = Math.max(1, params.layerCount || names.length || 1)
   const fallback = Array.from({ length: declaredLayerCount }, (_, i) =>
     i === 0 ? "top" : i === declaredLayerCount - 1 ? "bottom" : `inner${i}`,
   )
@@ -78,8 +82,8 @@ export function obstacleZs(ob: Obstacle, zIndexByName: Map<string, number>) {
 }
 
 export function obstacleToXYRect(ob: Obstacle): XYRect | null {
-  const w = ob.width as any
-  const h = ob.height as any
+  const w = ob.width
+  const h = ob.height
   if (typeof w !== "number" || typeof h !== "number") return null
   return { x: ob.center.x - w / 2, y: ob.center.y - h / 2, width: w, height: h }
 }

package/lib/utils/finalizeRects.ts

@@ -1,15 +1,16 @@
+import type { Obstacle } from "lib/types/srj-types"
 import type { Placed3D, Rect3d, XYRect } from "../rectdiff-types"
-import type { SimpleRouteJson } from "../types/srj-types"
 import {
-  buildZIndexMap,
   obstacleToXYRect,
   obstacleZs,
 } from "../solvers/RectDiffSeedingSolver/layers"
 
 export function finalizeRects(params: {
   placed: Placed3D[]
-  srj: SimpleRouteJson
+  obstacles: Obstacle[]
   boardVoidRects: XYRect[]
+  zIndexByName: Map<string, number>
+  obstacleClearance?: number
 }): Rect3d[] {
   // Convert all placed (free space) nodes to output format
   const out: Rect3d[] = params.placed.map((p) => ({
@@ -20,23 +21,30 @@ export function finalizeRects(params: {
     zLayers: [...p.zLayers].sort((a, b) => a - b),
   }))
 
-  const { zIndexByName } = buildZIndexMap(params.srj)
   const layersByKey = new Map<string, { rect: XYRect; layers: Set<number> }>()
 
-  for (const obstacle of params.srj.obstacles ?? []) {
-    const rect = obstacleToXYRect(obstacle as any)
-    if (!rect) continue
+  for (const obstacle of params.obstacles ?? []) {
+    const baseRect = obstacleToXYRect(obstacle)
+    if (!baseRect) continue
+    const rect = params.obstacleClearance
+      ? {
+          x: baseRect.x - params.obstacleClearance,
+          y: baseRect.y - params.obstacleClearance,
+          width: baseRect.width + 2 * params.obstacleClearance,
+          height: baseRect.height + 2 * params.obstacleClearance,
+        }
+      : baseRect
     const zLayers =
       obstacle.zLayers?.length && obstacle.zLayers.length > 0
         ? obstacle.zLayers
-        : obstacleZs(obstacle as any, zIndexByName)
+        : obstacleZs(obstacle, params.zIndexByName)
     const key = `${rect.x}:${rect.y}:${rect.width}:${rect.height}`
     let entry = layersByKey.get(key)
     if (!entry) {
       entry = { rect, layers: new Set() }
       layersByKey.set(key, entry)
     }
-    zLayers.forEach((layer) => entry!.layers.add(layer))
+    zLayers.forEach((layer: number) => entry!.layers.add(layer))
   }
 
   for (const { rect, layers } of layersByKey.values()) {

package/lib/utils/padRect.ts

@@ -0,0 +1,11 @@
+import type { XYRect } from "../rectdiff-types"
+
+export const padRect = (rect: XYRect, clearance: number): XYRect => {
+  if (!clearance || clearance <= 0) return rect
+  return {
+    x: rect.x - clearance,
+    y: rect.y - clearance,
+    width: rect.width + 2 * clearance,
+    height: rect.height + 2 * clearance,
+  }
+}

package/lib/utils/renderObstacleClearance.ts

@@ -0,0 +1,50 @@
+import type { SimpleRouteJson } from "lib/types/srj-types"
+import type { GraphicsObject } from "graphics-debug"
+
+/**
+ * Pure helper that returns clearance rect graphics; does not mutate inputs.
+ */
+export const buildObstacleClearanceGraphics = (params: {
+  srj: SimpleRouteJson
+  clearance: number | undefined
+}): GraphicsObject => {
+  const { srj, clearance } = params
+  const c = clearance ?? 0
+  if (c <= 0) {
+    return {
+      title: "Obstacle Clearance",
+      coordinateSystem: "cartesian",
+      rects: [],
+    }
+  }
+
+  const rects: NonNullable<GraphicsObject["rects"]> = []
+
+  for (const obstacle of srj.obstacles ?? []) {
+    if (obstacle.type !== "rect" && obstacle.type !== "oval") continue
+    const expanded = {
+      x: obstacle.center.x - obstacle.width / 2 - c,
+      y: obstacle.center.y - obstacle.height / 2 - c,
+      width: obstacle.width + 2 * c,
+      height: obstacle.height + 2 * c,
+    }
+    rects.push({
+      center: {
+        x: expanded.x + expanded.width / 2,
+        y: expanded.y + expanded.height / 2,
+      },
+      width: expanded.width,
+      height: expanded.height,
+      stroke: "rgba(202, 138, 4, 0.9)",
+      fill: "rgba(234, 179, 8, 0.15)",
+      layer: "obstacle-clearance",
+      label: `clearance\nz:${(obstacle.zLayers ?? []).join(",") || "all"}`,
+    })
+  }
+
+  return {
+    title: "Obstacle Clearance",
+    coordinateSystem: "cartesian",
+    rects,
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/rectdiff",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "type": "module",
   "main": "dist/index.js",
   "scripts": {

package/pages/bugreport11.page.tsx

@@ -8,6 +8,7 @@ export default () => {
     () =>
       new RectDiffPipeline({
         simpleRouteJson: simpleRouteJson.simple_route_json,
+        obstacleClearance: 0.015,
       }),
     [],
   )

package/tests/board-outline.test.ts

@@ -6,7 +6,7 @@ import { makeCapacityMeshNodeWithLayerInfo } from "./fixtures/makeCapacityMeshNo
 
 test("board outline snapshot", async () => {
   const solver = new RectDiffPipeline({
-    simpleRouteJson: boardWithCutout as any,
+    simpleRouteJson: boardWithCutout,
   })
 
   // Run to completion