@tscircuit/rectdiff 0.0.22 → 0.0.24

package/lib/RectDiffPipeline.ts

@@ -10,17 +10,24 @@ import type { GraphicsObject } from "graphics-debug"
 import { GapFillSolverPipeline } from "./solvers/GapFillSolver/GapFillSolverPipeline"
 import { RectDiffGridSolverPipeline } from "./solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline"
 import { createBaseVisualization } from "./rectdiff-visualization"
+import { buildFinalRectDiffVisualization } from "./buildFinalRectDiffVisualization"
 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 +35,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 +72,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 +111,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,41 +138,17 @@ 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(
-      this.inputProblem.simpleRouteJson,
-      "RectDiffPipeline - Final",
-    )
-
-    const { meshNodes: outputNodes } = this.getOutput()
-    const initialNodeIds = new Set(
-      (this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? []).map(
-        (n) => n.capacityMeshNodeId,
-      ),
-    )
-
-    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"),
-      })
-    }
-
-    return graphics
+    return buildFinalRectDiffVisualization({
+      srj: this.inputProblem.simpleRouteJson,
+      meshNodes: this.getOutput().meshNodes,
+      obstacleClearance: this.inputProblem.obstacleClearance,
+    })
   }
 }

package/lib/buildFinalRectDiffVisualization.ts

@@ -0,0 +1,46 @@
+import { mergeGraphics, type GraphicsObject } from "graphics-debug"
+import type { CapacityMeshNode } from "./types/capacity-mesh-types"
+import type { SimpleRouteJson } from "./types/srj-types"
+import { getColorForZLayer } from "./utils/getColorForZLayer"
+import { buildOutlineGraphics } from "./utils/buildOutlineGraphics"
+import { buildObstacleClearanceGraphics } from "./utils/renderObstacleClearance"
+
+type BuildFinalVisualizationParams = {
+  srj: SimpleRouteJson
+  meshNodes: CapacityMeshNode[]
+  obstacleClearance?: number
+}
+
+export const buildFinalRectDiffVisualization = ({
+  srj,
+  meshNodes,
+  obstacleClearance,
+}: BuildFinalVisualizationParams): GraphicsObject => {
+  const outline = buildOutlineGraphics({ srj })
+  const clearance = buildObstacleClearanceGraphics({
+    srj,
+    clearance: obstacleClearance,
+  })
+  const rects = meshNodes.map((node) => ({
+    center: node.center,
+    width: node.width,
+    height: node.height,
+    stroke: getColorForZLayer(node.availableZ).stroke,
+    fill: node._containsObstacle
+      ? "#fca5a5"
+      : getColorForZLayer(node.availableZ).fill,
+    layer: `z${node.availableZ.join(",")}`,
+    label: `node ${node.capacityMeshNodeId}\nz:${node.availableZ.join(",")}`,
+  }))
+
+  const nodesGraphic: GraphicsObject = {
+    title: "RectDiffPipeline - Final",
+    coordinateSystem: "cartesian",
+    rects,
+    lines: [],
+    points: [],
+    texts: [],
+  }
+
+  return mergeGraphics(mergeGraphics(nodesGraphic, outline), clearance)
+}

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,
     }
   }
 
@@ -423,10 +436,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/computeCandidates3D.ts

@@ -4,6 +4,8 @@ import { isFullyOccupiedAtPoint } from "../../utils/isFullyOccupiedAtPoint"
 import { longestFreeSpanAroundZ } from "./longestFreeSpanAroundZ"
 import type RBush from "rbush"
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
+const quantize = (value: number, precision = 1e-6) =>
+  Math.round(value / precision) * precision
 
 /**
  * Compute candidate seed points for a given grid size.
@@ -83,13 +85,14 @@ export function computeCandidates3D(params: {
           ? hardAtZ.map((b) => distancePointToRectEdges({ x, y }, b))
           : [Infinity]),
       )
+      const distance = quantize(d)
 
       const k = `${x.toFixed(6)}|${y.toFixed(6)}`
       const cand: Candidate3D = {
         x,
         y,
         z: anchorZ,
-        distance: d,
+        distance,
         zSpanLen: bestSpan.length,
       }
       const prev = out.get(k)
@@ -104,6 +107,13 @@ export function computeCandidates3D(params: {
   }
 
   const arr = Array.from(out.values())
-  arr.sort((a, b) => b.zSpanLen! - a.zSpanLen! || b.distance - a.distance)
+  arr.sort(
+    (a, b) =>
+      b.zSpanLen! - a.zSpanLen! ||
+      b.distance - a.distance ||
+      a.z - b.z ||
+      a.x - b.x ||
+      a.y - b.y,
+  )
   return arr
 }

package/lib/solvers/RectDiffSeedingSolver/computeEdgeCandidates3D.ts

@@ -4,6 +4,8 @@ import { isFullyOccupiedAtPoint } from "../../utils/isFullyOccupiedAtPoint"
 import { longestFreeSpanAroundZ } from "./longestFreeSpanAroundZ"
 import type RBush from "rbush"
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
+const quantize = (value: number, precision = 1e-6) =>
+  Math.round(value / precision) * precision
 
 /**
  * Compute exact uncovered segments along a 1D line.
@@ -15,14 +17,23 @@ function computeUncoveredSegments(params: {
   minSegmentLength: number
 }): Array<{ start: number; end: number; center: number }> {
   const { lineStart, lineEnd, coveringIntervals, minSegmentLength } = params
+  const lineStartQ = quantize(lineStart)
+  const lineEndQ = quantize(lineEnd)
+  const normalizedIntervals = coveringIntervals
+    .map((i) => {
+      const s = quantize(i.start)
+      const e = quantize(i.end)
+      return { start: Math.min(s, e), end: Math.max(s, e) }
+    })
+    .filter((i) => i.end > i.start + EPS)
 
-  if (coveringIntervals.length === 0) {
-    const center = (lineStart + lineEnd) / 2
-    return [{ start: lineStart, end: lineEnd, center }]
+  if (normalizedIntervals.length === 0) {
+    const center = (lineStartQ + lineEndQ) / 2
+    return [{ start: lineStartQ, end: lineEndQ, center }]
   }
 
   // Sort intervals by start position
-  const sorted = [...coveringIntervals].sort((a, b) => a.start - b.start)
+  const sorted = [...normalizedIntervals].sort((a, b) => a.start - b.start)
 
   // Merge overlapping intervals
   const merged: Array<{ start: number; end: number }> = []
@@ -45,8 +56,8 @@ function computeUncoveredSegments(params: {
   const uncovered: Array<{ start: number; end: number; center: number }> = []
 
   // Check gap before first interval
-  if (merged[0]!.start > lineStart + EPS) {
-    const start = lineStart
+  if (merged[0]!.start > lineStartQ + EPS) {
+    const start = lineStartQ
     const end = merged[0]!.start
     if (end - start >= minSegmentLength) {
       uncovered.push({ start, end, center: (start + end) / 2 })
@@ -63,9 +74,9 @@ function computeUncoveredSegments(params: {
   }
 
   // Check gap after last interval
-  if (merged[merged.length - 1]!.end < lineEnd - EPS) {
+  if (merged[merged.length - 1]!.end < lineEndQ - EPS) {
     const start = merged[merged.length - 1]!.end
-    const end = lineEnd
+    const end = lineEndQ
     if (end - start >= minSegmentLength) {
       uncovered.push({ start, end, center: (start + end) / 2 })
     }
@@ -111,7 +122,11 @@ export function computeEdgeCandidates3D(params: {
   }
 
   function pushIfFree(p: { x: number; y: number; z: number }) {
-    const { x, y, z } = p
+    const qx = quantize(p.x)
+    const qy = quantize(p.y)
+    const { z } = p
+    const x = qx
+    const y = qy
     if (
       x < bounds.x + EPS ||
       y < bounds.y + EPS ||
@@ -125,13 +140,19 @@ export function computeEdgeCandidates3D(params: {
     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 distance = quantize(d)
 
     const k = key({ x, y, z })
     if (dedup.has(k)) return
@@ -148,14 +169,26 @@ export function computeEdgeCandidates3D(params: {
       obstacleIndexByLayer,
       additionalBlockersByLayer: hardPlacedByLayer,
     })
-    out.push({ x, y, z, distance: d, zSpanLen: span.length, isEdgeSeed: true })
+    out.push({
+      x,
+      y,
+      z,
+      distance,
+      zSpanLen: span.length,
+      isEdgeSeed: true,
+    })
   }
 
   for (let z = 0; z < layerCount; z++) {
     const blockers = [
       ...(obstacleIndexByLayer[z]?.all() ?? []),
       ...(hardPlacedByLayer[z] ?? []),
-    ]
+    ].map((b) => ({
+      x: quantize(b.x),
+      y: quantize(b.y),
+      width: quantize(b.width),
+      height: quantize(b.height),
+    }))
 
     // 1) Board edges — find exact uncovered segments along each edge
 
@@ -372,6 +405,13 @@ export function computeEdgeCandidates3D(params: {
   }
 
   // Strong multi-layer preference then distance.
-  out.sort((a, b) => b.zSpanLen! - a.zSpanLen! || b.distance - a.distance)
+  out.sort(
+    (a, b) =>
+      b.zSpanLen! - a.zSpanLen! ||
+      b.distance - a.distance ||
+      a.z - b.z ||
+      a.x - b.x ||
+      a.y - b.y,
+  )
   return out
 }