@tscircuit/rectdiff 0.0.22 → 0.0.24

package/dist/index.js

@@ -859,11 +859,11 @@ function canonicalizeLayerOrder(names) {
     return a.localeCompare(b);
   });
 }
-function buildZIndexMap(srj) {
+function buildZIndexMap(params) {
   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}`
@@ -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;
 }
 
@@ -1710,7 +1753,14 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
   _setup() {
     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 = {
       x: srj.bounds.minX,
@@ -1908,7 +1958,6 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
    */
   getOutput() {
     return {
-      srj: this.srj,
       layerNames: this.layerNames,
       layerCount: this.layerCount,
       bounds: this.bounds,
@@ -1920,7 +1969,9 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       expansionIndex: this.expansionIndex,
       edgeAnalysisDone: this.edgeAnalysisDone,
       totalSeedsThisGrid: this.totalSeedsThisGrid,
-      consumedSeedsThisGrid: this.consumedSeedsThisGrid
+      consumedSeedsThisGrid: this.consumedSeedsThisGrid,
+      obstacles: this.srj.obstacles,
+      obstacleClearance: this.input.obstacleClearance
     };
   }
   /** Visualization focused on the grid seeding phase. */
@@ -2001,8 +2052,6 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
         points.push({
           x: cand.x,
           y: cand.y,
-          fill: "#9333ea",
-          stroke: "#6b21a8",
           label: `z:${cand.z}`
         });
       }
@@ -2047,12 +2096,17 @@ function finalizeRects(params) {
     maxY: p.rect.y + p.rect.height,
     zLayers: [...p.zLayers].sort((a, b) => a - b)
   }));
-  const { zIndexByName } = buildZIndexMap(params.srj);
   const layersByKey = /* @__PURE__ */ new Map();
-  for (const obstacle of params.srj.obstacles ?? []) {
-    const rect = obstacleToXYRect(obstacle);
-    if (!rect) continue;
-    const zLayers = obstacle.zLayers?.length && obstacle.zLayers.length > 0 ? obstacle.zLayers : obstacleZs(obstacle, zIndexByName);
+  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, params.zIndexByName);
     const key = `${rect.x}:${rect.y}:${rect.width}:${rect.height}`;
     let entry = layersByKey.get(key);
     if (!entry) {
@@ -2182,8 +2236,10 @@ var RectDiffExpansionSolver = class extends BaseSolver4 {
     if (this.solved) return;
     const rects = finalizeRects({
       placed: this.input.placed,
-      srj: this.input.srj,
-      boardVoidRects: this.input.boardVoidRects
+      obstacles: this.input.obstacles,
+      zIndexByName: this.input.zIndexByName,
+      boardVoidRects: this.input.boardVoidRects,
+      obstacleClearance: this.input.obstacleClearance
     });
     this._meshNodes = rectsToMeshNodes(rects);
     this.solved = true;
@@ -2246,9 +2302,25 @@ import "rbush";
 
 // lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts
 import RBush5 from "rbush";
+
+// lib/utils/padRect.ts
+var padRect = (rect, clearance) => {
+  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
+  };
+};
+
+// lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts
 var buildObstacleIndexesByLayer = (params) => {
-  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 = {
     x: srj.bounds.minX,
@@ -2277,8 +2349,9 @@ var buildObstacleIndexesByLayer = (params) => {
     }
   }
   for (const obstacle of srj.obstacles ?? []) {
-    const rect = obstacleToXYRect(obstacle);
-    if (!rect) continue;
+    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) {
@@ -2291,7 +2364,7 @@ var buildObstacleIndexesByLayer = (params) => {
     }
     for (const z of zLayers) insertObstacle(rect, z);
   }
-  return { obstacleIndexByLayer };
+  return { obstacleIndexByLayer, layerNames, zIndexByName };
 };
 
 // lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts
@@ -2299,13 +2372,25 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
   rectDiffSeedingSolver;
   rectDiffExpansionSolver;
   obstacleIndexByLayer;
+  layerNames;
+  zIndexByName;
   constructor(inputProblem) {
     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;
   }
   pipelineDef = [
     definePipelineStep2(
@@ -2313,10 +2398,20 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
       RectDiffSeedingSolver,
       (pipeline) => [
         {
-          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
+          boardVoidRects: pipeline.inputProblem.boardVoidRects,
+          layerNames: pipeline.layerNames,
+          zIndexByName: pipeline.zIndexByName,
+          obstacleClearance: pipeline.inputProblem.obstacleClearance
         }
       ]
     ),
@@ -2330,10 +2425,9 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
         }
         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,
@@ -2343,7 +2437,11 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
             gridIndex: output.gridIndex,
             expansionIndex: output.expansionIndex,
             obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
-            options: output.options
+            options: output.options,
+            zIndexByName: pipeline.zIndexByName,
+            layerNamesCanonical: pipeline.layerNames,
+            obstacles: pipeline.inputProblem.obstacles,
+            obstacleClearance: pipeline.inputProblem.obstacleClearance
           }
         ];
       }
@@ -2424,6 +2522,7 @@ function createBaseVisualization(srj, title = "RectDiff") {
   }
   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,
@@ -2431,7 +2530,8 @@ function createBaseVisualization(srj, title = "RectDiff") {
         fill: "#fee2e2",
         stroke: "#ef4444",
         layer: "obstacle",
-        label: "obstacle"
+        label: `obstacle
+z:${layerLabel}`
       });
     }
   }
@@ -2444,20 +2544,140 @@ function createBaseVisualization(srj, title = "RectDiff") {
   };
 }
 
+// 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;
+  const c = clearance ?? 0;
+  if (c <= 0) {
+    return {
+      title: "Obstacle Clearance",
+      coordinateSystem: "cartesian",
+      rects: []
+    };
+  }
+  const 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
+z:${(obstacle.zLayers ?? []).join(",") || "all"}`
+    });
+  }
+  return {
+    title: "Obstacle Clearance",
+    coordinateSystem: "cartesian",
+    rects
+  };
+};
+
+// 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 as mergeGraphics2 } from "graphics-debug";
 var RectDiffPipeline = class extends BasePipelineSolver3 {
   rectDiffGridSolverPipeline;
   gapFillSolver;
   boardVoidRects;
+  zIndexByName;
+  layerNames;
   pipelineDef = [
     definePipelineStep3(
       "rectDiffGridSolverPipeline",
       RectDiffGridSolverPipeline,
       (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 } : void 0,
+          layerCount: rectDiffPipeline.inputProblem.simpleRouteJson.layerCount,
           gridOptions: rectDiffPipeline.inputProblem.gridOptions,
-          boardVoidRects: rectDiffPipeline.boardVoidRects
+          boardVoidRects: rectDiffPipeline.boardVoidRects,
+          layerNames: rectDiffPipeline.layerNames,
+          zIndexByName: rectDiffPipeline.zIndexByName,
+          minTraceWidth: rectDiffPipeline.inputProblem.simpleRouteJson.minTraceWidth,
+          obstacleClearance: rectDiffPipeline.inputProblem.obstacleClearance
         }
       ]
     ),
@@ -2476,6 +2696,12 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
     )
   ];
   _setup() {
+    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(
         {
@@ -2502,13 +2728,19 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
     return { meshNodes: [] };
   }
   initialVisualize() {
-    const graphics = createBaseVisualization(
+    const base = createBaseVisualization(
       this.inputProblem.simpleRouteJson,
       "RectDiffPipeline - Initial"
     );
+    const clearance = buildObstacleClearanceGraphics({
+      srj: this.inputProblem.simpleRouteJson,
+      clearance: this.inputProblem.obstacleClearance
+    });
     const initialNodes = this.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? [];
-    for (const node of initialNodes) {
-      graphics.rects.push({
+    const nodeRects = {
+      title: "Initial Nodes",
+      coordinateSystem: "cartesian",
+      rects: initialNodes.map((node) => ({
         center: node.center,
         width: node.width,
         height: node.height,
@@ -2519,37 +2751,16 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
           `node ${node.capacityMeshNodeId}`,
           `z:${node.availableZ.join(",")}`
         ].join("\n")
-      });
-    }
-    return graphics;
+      }))
+    };
+    return mergeGraphics2(mergeGraphics2(base, clearance), nodeRects);
   }
   finalVisualize() {
-    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
+    });
   }
 };
 export {