@tscircuit/rectdiff 0.0.23 → 0.0.24

package/dist/index.js

@@ -960,6 +960,13 @@ var searchStripUp = ({
 });
 
 // lib/utils/expandRectFromSeed.ts
+var quantize = (value, precision = 1e-6) => Math.round(value / precision) * precision;
+var quantizeRect = (rect) => ({
+  x: quantize(rect.x),
+  y: quantize(rect.y),
+  width: quantize(rect.width),
+  height: quantize(rect.height)
+});
 function maxExpandRight(params) {
   const { r, bounds, blockers, maxAspect } = params;
   let maxWidth = bounds.x + bounds.width - r.x;
@@ -1173,7 +1180,7 @@ function expandRectFromSeed(params) {
     if (r.width + EPS4 >= minReq.width && r.height + EPS4 >= minReq.height) {
       const area = r.width * r.height;
       if (area > bestArea) {
-        best = r;
+        best = quantizeRect(r);
         bestArea = area;
       }
     }
@@ -1247,6 +1254,7 @@ function longestFreeSpanAroundZ(params) {
 }
 
 // lib/solvers/RectDiffSeedingSolver/computeCandidates3D.ts
+var quantize2 = (value, precision = 1e-6) => Math.round(value / precision) * precision;
 function computeCandidates3D(params) {
   const {
     bounds,
@@ -1296,12 +1304,13 @@ function computeCandidates3D(params) {
         distancePointToRectEdges({ x, y }, bounds),
         ...hardAtZ.length ? hardAtZ.map((b) => distancePointToRectEdges({ x, y }, b)) : [Infinity]
       );
+      const distance = quantize2(d);
       const k = `${x.toFixed(6)}|${y.toFixed(6)}`;
       const cand = {
         x,
         y,
         z: anchorZ,
-        distance: d,
+        distance,
         zSpanLen: bestSpan.length
       };
       const prev = out.get(k);
@@ -1311,18 +1320,28 @@ 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;
 }
 
 // lib/solvers/RectDiffSeedingSolver/computeEdgeCandidates3D.ts
+var quantize3 = (value, precision = 1e-6) => Math.round(value / precision) * precision;
 function computeUncoveredSegments(params) {
   const { lineStart, lineEnd, coveringIntervals, minSegmentLength } = params;
-  if (coveringIntervals.length === 0) {
-    const center = (lineStart + lineEnd) / 2;
-    return [{ start: lineStart, end: lineEnd, center }];
-  }
-  const sorted = [...coveringIntervals].sort((a, b) => a.start - b.start);
+  const lineStartQ = quantize3(lineStart);
+  const lineEndQ = quantize3(lineEnd);
+  const normalizedIntervals = coveringIntervals.map((i) => {
+    const s = quantize3(i.start);
+    const e = quantize3(i.end);
+    return { start: Math.min(s, e), end: Math.max(s, e) };
+  }).filter((i) => i.end > i.start + EPS4);
+  if (normalizedIntervals.length === 0) {
+    const center = (lineStartQ + lineEndQ) / 2;
+    return [{ start: lineStartQ, end: lineEndQ, center }];
+  }
+  const sorted = [...normalizedIntervals].sort((a, b) => a.start - b.start);
   const merged = [];
   let current = { ...sorted[0] };
   for (let i = 1; i < sorted.length; i++) {
@@ -1336,8 +1355,8 @@ function computeUncoveredSegments(params) {
   }
   merged.push(current);
   const uncovered = [];
-  if (merged[0].start > lineStart + EPS4) {
-    const start = lineStart;
+  if (merged[0].start > lineStartQ + EPS4) {
+    const start = lineStartQ;
     const end = merged[0].start;
     if (end - start >= minSegmentLength) {
       uncovered.push({ start, end, center: (start + end) / 2 });
@@ -1350,9 +1369,9 @@ function computeUncoveredSegments(params) {
       uncovered.push({ start, end, center: (start + end) / 2 });
     }
   }
-  if (merged[merged.length - 1].end < lineEnd - EPS4) {
+  if (merged[merged.length - 1].end < lineEndQ - EPS4) {
     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 });
     }
@@ -1381,18 +1400,28 @@ function computeEdgeCandidates3D(params) {
     });
   }
   function pushIfFree(p) {
-    const { x, y, z } = p;
+    const qx = quantize3(p.x);
+    const qy = quantize3(p.y);
+    const { z } = p;
+    const x = qx;
+    const y = qy;
     if (x < bounds.x + EPS4 || y < bounds.y + EPS4 || x > bounds.x + bounds.width - EPS4 || y > bounds.y + bounds.height - EPS4)
       return;
     if (fullyOcc({ x, y })) return;
     const hard = [
       ...obstacleIndexByLayer[z]?.all() ?? [],
       ...hardPlacedByLayer[z] ?? []
-    ];
+    ].map((b) => ({
+      x: quantize3(b.x),
+      y: quantize3(b.y),
+      width: quantize3(b.width),
+      height: quantize3(b.height)
+    }));
     const d = Math.min(
       distancePointToRectEdges({ x, y }, bounds),
       ...hard.length ? hard.map((b) => distancePointToRectEdges({ x, y }, b)) : [Infinity]
     );
+    const distance = quantize3(d);
     const k = key({ x, y, z });
     if (dedup.has(k)) return;
     dedup.add(k);
@@ -1406,13 +1435,25 @@ 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: quantize3(b.x),
+      y: quantize3(b.y),
+      width: quantize3(b.width),
+      height: quantize3(b.height)
+    }));
     const corners = [
       { x: bounds.x + \u03B4, y: bounds.y + \u03B4 },
       // top-left
@@ -1585,7 +1626,9 @@ function computeEdgeCandidates3D(params) {
       }
     }
   }
-  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;
 }
 
@@ -1976,29 +2019,6 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
         });
       }
     }
-    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"
-        });
-      }
-    }
     if (this.boardVoidRects) {
       let outlineBBox = null;
       if (srj.outline && srj.outline.length > 0) {
@@ -2524,6 +2544,42 @@ z:${layerLabel}`
   };
 }
 
+// lib/buildFinalRectDiffVisualization.ts
+import { mergeGraphics } from "graphics-debug";
+
+// lib/utils/buildOutlineGraphics.ts
+var buildOutlineGraphics = ({
+  srj
+}) => {
+  const hasOutline = srj.outline && srj.outline.length > 1;
+  const lines = hasOutline ? [
+    {
+      points: [...srj.outline, srj.outline[0]],
+      strokeColor: "#111827",
+      strokeWidth: 0.1,
+      label: "outline"
+    }
+  ] : [
+    {
+      points: [
+        { x: srj.bounds.minX, y: srj.bounds.minY },
+        { x: srj.bounds.maxX, y: srj.bounds.minY },
+        { x: srj.bounds.maxX, y: srj.bounds.maxY },
+        { x: srj.bounds.minX, y: srj.bounds.maxY },
+        { x: srj.bounds.minX, y: srj.bounds.minY }
+      ],
+      strokeColor: "#111827",
+      strokeWidth: 0.1,
+      label: "bounds"
+    }
+  ];
+  return {
+    title: "SimpleRoute Outline",
+    coordinateSystem: "cartesian",
+    lines
+  };
+};
+
 // lib/utils/renderObstacleClearance.ts
 var buildObstacleClearanceGraphics = (params) => {
   const { srj, clearance } = params;
@@ -2565,8 +2621,40 @@ z:${(obstacle.zLayers ?? []).join(",") || "all"}`
   };
 };
 
+// lib/buildFinalRectDiffVisualization.ts
+var buildFinalRectDiffVisualization = ({
+  srj,
+  meshNodes,
+  obstacleClearance
+}) => {
+  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}
+z:${node.availableZ.join(",")}`
+  }));
+  const nodesGraphic = {
+    title: "RectDiffPipeline - Final",
+    coordinateSystem: "cartesian",
+    rects,
+    lines: [],
+    points: [],
+    texts: []
+  };
+  return mergeGraphics(mergeGraphics(nodesGraphic, outline), clearance);
+};
+
 // lib/RectDiffPipeline.ts
-import { mergeGraphics } from "graphics-debug";
+import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
 var RectDiffPipeline = class extends BasePipelineSolver3 {
   rectDiffGridSolverPipeline;
   gapFillSolver;
@@ -2665,43 +2753,14 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
         ].join("\n")
       }))
     };
-    return mergeGraphics(mergeGraphics(base, clearance), nodeRects);
+    return mergeGraphics2(mergeGraphics2(base, clearance), nodeRects);
   }
   finalVisualize() {
-    const base = createBaseVisualization(
-      this.inputProblem.simpleRouteJson,
-      "RectDiffPipeline - Final"
-    );
-    const clearance = buildObstacleClearanceGraphics({
+    return buildFinalRectDiffVisualization({
       srj: this.inputProblem.simpleRouteJson,
-      clearance: this.inputProblem.obstacleClearance
+      meshNodes: this.getOutput().meshNodes,
+      obstacleClearance: this.inputProblem.obstacleClearance
     });
-    const { meshNodes: outputNodes } = this.getOutput();
-    const initialNodeIds = new Set(
-      (this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? []).map(
-        (n) => n.capacityMeshNodeId
-      )
-    );
-    const nodeRects = {
-      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 mergeGraphics(mergeGraphics(base, clearance), nodeRects);
   }
 };
 export {

package/lib/RectDiffPipeline.ts

@@ -10,6 +10,7 @@ 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"
@@ -144,44 +145,10 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
   }
 
   override finalVisualize(): GraphicsObject {
-    const base = createBaseVisualization(
-      this.inputProblem.simpleRouteJson,
-      "RectDiffPipeline - Final",
-    )
-    const clearance = buildObstacleClearanceGraphics({
+    return buildFinalRectDiffVisualization({
       srj: this.inputProblem.simpleRouteJson,
-      clearance: this.inputProblem.obstacleClearance,
+      meshNodes: this.getOutput().meshNodes,
+      obstacleClearance: this.inputProblem.obstacleClearance,
     })
-
-    const { meshNodes: outputNodes } = this.getOutput()
-    const initialNodeIds = new Set(
-      (this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? []).map(
-        (n) => n.capacityMeshNodeId,
-      ),
-    )
-
-    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 mergeGraphics(mergeGraphics(base, clearance), nodeRects)
   }
 }

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/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts

@@ -392,31 +392,6 @@ 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: {

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
 }

package/lib/utils/buildOutlineGraphics.ts

@@ -0,0 +1,39 @@
+import type { GraphicsObject, Line } from "graphics-debug"
+import type { SimpleRouteJson } from "../types/srj-types"
+
+export type BuildOutlineParams = { srj: SimpleRouteJson }
+
+export const buildOutlineGraphics = ({
+  srj,
+}: BuildOutlineParams): GraphicsObject => {
+  const hasOutline = srj.outline && srj.outline.length > 1
+  const lines: NonNullable<Line[]> = hasOutline
+    ? [
+        {
+          points: [...srj.outline!, srj.outline![0]!],
+          strokeColor: "#111827",
+          strokeWidth: 0.1,
+          label: "outline",
+        },
+      ]
+    : [
+        {
+          points: [
+            { x: srj.bounds.minX, y: srj.bounds.minY },
+            { x: srj.bounds.maxX, y: srj.bounds.minY },
+            { x: srj.bounds.maxX, y: srj.bounds.maxY },
+            { x: srj.bounds.minX, y: srj.bounds.maxY },
+            { x: srj.bounds.minX, y: srj.bounds.minY },
+          ],
+          strokeColor: "#111827",
+          strokeWidth: 0.1,
+          label: "bounds",
+        },
+      ]
+
+  return {
+    title: "SimpleRoute Outline",
+    coordinateSystem: "cartesian",
+    lines,
+  }
+}