@tscircuit/rectdiff 0.0.18 → 0.0.19

package/lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts

@@ -3,28 +3,21 @@ import type { GraphicsObject } from "graphics-debug"
 import type { CapacityMeshNode, RTreeRect } from "lib/types/capacity-mesh-types"
 import { expandRectFromSeed } from "../../utils/expandRectFromSeed"
 import { finalizeRects } from "../../utils/finalizeRects"
-import { allLayerNode } from "../../utils/buildHardPlacedByLayer"
 import { resizeSoftOverlaps } from "../../utils/resizeSoftOverlaps"
 import { rectsToMeshNodes } from "./rectsToMeshNodes"
 import type { XYRect, Candidate3D, Placed3D } from "../../rectdiff-types"
 import type { SimpleRouteJson } from "lib/types/srj-types"
-import {
-  buildZIndexMap,
-  obstacleToXYRect,
-  obstacleZs,
-} from "../RectDiffSeedingSolver/layers"
 import RBush from "rbush"
 import { rectToTree } from "../../utils/rectToTree"
 import { sameTreeRect } from "../../utils/sameTreeRect"
 
-export type RectDiffExpansionSolverSnapshot = {
+export type RectDiffExpansionSolverInput = {
   srj: SimpleRouteJson
   layerNames: string[]
   layerCount: number
   bounds: XYRect
   options: {
     gridSizes: number[]
-    // the engine only uses gridSizes here, other options are ignored
     [key: string]: any
   }
   boardVoidRects: XYRect[]
@@ -35,10 +28,6 @@ export type RectDiffExpansionSolverSnapshot = {
   edgeAnalysisDone: boolean
   totalSeedsThisGrid: number
   consumedSeedsThisGrid: number
-}
-
-export type RectDiffExpansionSolverInput = {
-  initialSnapshot: RectDiffExpansionSolverSnapshot
   obstacleIndexByLayer: Array<RBush<RTreeRect>>
 }
 
@@ -49,74 +38,25 @@ export type RectDiffExpansionSolverInput = {
  * and runs the EXPANSION phase, then finalizes to capacity mesh nodes.
  */
 export class RectDiffExpansionSolver extends BaseSolver {
-  // Engine fields (same shape used by rectdiff/engine.ts)
-  private srj!: SimpleRouteJson
-  private layerNames!: string[]
-  private layerCount!: number
-  private bounds!: XYRect
-  private options!: {
-    gridSizes: number[]
-    // the engine only uses gridSizes here, other options are ignored
-    [key: string]: any
-  }
-  private boardVoidRects!: XYRect[]
-  private gridIndex!: number
-  private candidates!: Candidate3D[]
-  private placed!: Placed3D[]
-  private placedIndexByLayer!: Array<RBush<RTreeRect>>
-  private expansionIndex!: number
-  private edgeAnalysisDone!: boolean
-  private totalSeedsThisGrid!: number
-  private consumedSeedsThisGrid!: number
-
-  private _meshNodes: CapacityMeshNode[] = []
-
+  placedIndexByLayer: Array<RBush<RTreeRect>> = []
+  _meshNodes: CapacityMeshNode[] = []
   constructor(private input: RectDiffExpansionSolverInput) {
     super()
-    // Copy engine snapshot fields directly onto this solver instance
-    Object.assign(this, this.input.initialSnapshot)
   }
 
   override _setup() {
     this.stats = {
-      gridIndex: this.gridIndex,
-    }
-
-    if (this.input.obstacleIndexByLayer) {
-    } else {
-      const { zIndexByName } = buildZIndexMap(this.srj)
-      this.input.obstacleIndexByLayer = Array.from(
-        { length: this.layerCount },
-        () => new RBush<RTreeRect>(),
-      )
-      const insertObstacle = (rect: XYRect, z: number) => {
-        const tree = this.input.obstacleIndexByLayer[z]
-        if (tree) tree.insert(rectToTree(rect))
-      }
-      for (const voidRect of this.boardVoidRects ?? []) {
-        for (let z = 0; z < this.layerCount; z++) insertObstacle(voidRect, z)
-      }
-      for (const obstacle of this.srj.obstacles ?? []) {
-        const rect = obstacleToXYRect(obstacle as any)
-        if (!rect) continue
-        const zLayers =
-          obstacle.zLayers?.length && obstacle.zLayers.length > 0
-            ? obstacle.zLayers
-            : obstacleZs(obstacle as any, zIndexByName)
-        zLayers.forEach((z) => {
-          if (z >= 0 && z < this.layerCount) insertObstacle(rect, z)
-        })
-      }
+      gridIndex: this.input.gridIndex,
     }
 
     this.placedIndexByLayer = Array.from(
-      { length: this.layerCount },
+      { length: this.input.layerCount },
       () => new RBush<RTreeRect>(),
     )
-    for (const placement of this.placed ?? []) {
+    for (const placement of this.input.placed) {
       for (const z of placement.zLayers) {
-        const tree = this.placedIndexByLayer[z]
-        if (tree) tree.insert(rectToTree(placement.rect))
+        const placedIndex = this.placedIndexByLayer[z]
+        if (placedIndex) placedIndex.insert(rectToTree(placement.rect))
       }
     }
   }
@@ -126,51 +66,41 @@ export class RectDiffExpansionSolver extends BaseSolver {
 
     this._stepExpansion()
 
-    this.stats.gridIndex = this.gridIndex
-    this.stats.placed = this.placed.length
+    this.stats.gridIndex = this.input.gridIndex
+    this.stats.placed = this.input.placed.length
 
-    if (this.expansionIndex >= this.placed.length) {
+    if (this.input.expansionIndex >= this.input.placed.length) {
       this.finalizeIfNeeded()
     }
   }
 
   private _stepExpansion(): void {
-    if (this.expansionIndex >= this.placed.length) {
+    if (this.input.expansionIndex >= this.input.placed.length) {
       return
     }
 
-    const idx = this.expansionIndex
-    const p = this.placed[idx]!
-    const lastGrid = this.options.gridSizes[this.options.gridSizes.length - 1]!
-
-    const hardPlacedByLayer = allLayerNode({
-      layerCount: this.layerCount,
-      placed: this.placed,
-    })
-
-    // HARD blockers only: obstacles on p.zLayers + full-stack nodes
-    const hardBlockers: XYRect[] = []
-    for (const z of p.zLayers) {
-      const obstacleTree = this.input.obstacleIndexByLayer[z]
-      if (obstacleTree) hardBlockers.push(...obstacleTree.all())
-      hardBlockers.push(...(hardPlacedByLayer[z] ?? []))
-    }
+    const idx = this.input.expansionIndex
+    const p = this.input.placed[idx]!
+    const lastGrid =
+      this.input.options.gridSizes[this.input.options.gridSizes.length - 1]!
 
     const oldRect = p.rect
     const expanded = expandRectFromSeed({
       startX: p.rect.x + p.rect.width / 2,
       startY: p.rect.y + p.rect.height / 2,
       gridSize: lastGrid,
-      bounds: this.bounds,
-      blockers: hardBlockers,
+      bounds: this.input.bounds,
+      obsticalIndexByLayer: this.input.obstacleIndexByLayer,
+      placedIndexByLayer: this.placedIndexByLayer,
       initialCellRatio: 0,
       maxAspectRatio: null,
       minReq: { width: p.rect.width, height: p.rect.height },
+      zLayers: p.zLayers,
     })
 
     if (expanded) {
       // Update placement + per-layer index (replace old rect object)
-      this.placed[idx] = { rect: expanded, zLayers: p.zLayers }
+      this.input.placed[idx] = { rect: expanded, zLayers: p.zLayers }
       for (const z of p.zLayers) {
         const tree = this.placedIndexByLayer[z]
         if (tree) {
@@ -182,25 +112,25 @@ export class RectDiffExpansionSolver extends BaseSolver {
       // Carve overlapped soft neighbors (respect full-stack nodes)
       resizeSoftOverlaps(
         {
-          layerCount: this.layerCount,
-          placed: this.placed,
-          options: this.options,
+          layerCount: this.input.layerCount,
+          placed: this.input.placed,
+          options: this.input.options,
           placedIndexByLayer: this.placedIndexByLayer,
         },
         idx,
       )
     }
 
-    this.expansionIndex += 1
+    this.input.expansionIndex += 1
   }
 
   private finalizeIfNeeded() {
     if (this.solved) return
 
     const rects = finalizeRects({
-      placed: this.placed,
-      srj: this.srj,
-      boardVoidRects: this.boardVoidRects,
+      placed: this.input.placed,
+      srj: this.input.srj,
+      boardVoidRects: this.input.boardVoidRects,
     })
     this._meshNodes = rectsToMeshNodes(rects)
     this.solved = true
@@ -208,25 +138,39 @@ export class RectDiffExpansionSolver extends BaseSolver {
 
   computeProgress(): number {
     if (this.solved) return 1
-    const grids = this.options.gridSizes.length
+    const grids = this.input.options.gridSizes.length
     const base = grids / (grids + 1)
-    const denom = Math.max(1, this.placed.length)
-    const frac = denom ? this.expansionIndex / denom : 1
+    const denom = Math.max(1, this.input.placed.length)
+    const frac = denom ? this.input.expansionIndex / denom : 1
     return Math.min(0.999, base + frac * (1 / (grids + 1)))
   }
 
   override getOutput(): { meshNodes: CapacityMeshNode[] } {
-    if (!this.solved && this._meshNodes.length === 0) {
-      this.finalizeIfNeeded()
-    }
-    return { meshNodes: this._meshNodes }
+    if (this.solved) return { meshNodes: this._meshNodes }
+
+    // Provide a live preview of the placements before finalization so debuggers
+    // can inspect intermediary states without forcing the solver to finish.
+    const previewNodes: CapacityMeshNode[] = this.input.placed.map(
+      (placement, idx) => ({
+        capacityMeshNodeId: `expand-preview-${idx}`,
+        center: {
+          x: placement.rect.x + placement.rect.width / 2,
+          y: placement.rect.y + placement.rect.height / 2,
+        },
+        width: placement.rect.width,
+        height: placement.rect.height,
+        availableZ: placement.zLayers.slice(),
+        layer: `z${placement.zLayers.join(",")}`,
+      }),
+    )
+    return { meshNodes: previewNodes }
   }
 
   /** Simple visualization of expanded placements. */
   override visualize(): GraphicsObject {
     const rects: NonNullable<GraphicsObject["rects"]> = []
 
-    for (const placement of this.placed ?? []) {
+    for (const placement of this.input.placed ?? []) {
       rects.push({
         center: {
           x: placement.rect.x + placement.rect.width / 2,

package/lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts

@@ -48,15 +48,30 @@ export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridS
     definePipelineStep(
       "rectDiffExpansionSolver",
       RectDiffExpansionSolver,
-      (pipeline: RectDiffGridSolverPipeline) => [
-        {
-          initialSnapshot: {
-            ...pipeline.rectDiffSeedingSolver!.getOutput(),
+      (pipeline: RectDiffGridSolverPipeline) => {
+        const output = pipeline.rectDiffSeedingSolver?.getOutput()
+        if (!output) {
+          throw new Error("RectDiffSeedingSolver did not produce output")
+        }
+        return [
+          {
+            srj: pipeline.inputProblem.simpleRouteJson,
+            layerNames: output.layerNames ?? [],
             boardVoidRects: pipeline.inputProblem.boardVoidRects ?? [],
+            layerCount: pipeline.inputProblem.simpleRouteJson.layerCount,
+            bounds: output.bounds!,
+            candidates: output.candidates,
+            consumedSeedsThisGrid: output.placed.length,
+            totalSeedsThisGrid: output.candidates.length,
+            placed: output.placed,
+            edgeAnalysisDone: output.edgeAnalysisDone,
+            gridIndex: output.gridIndex,
+            expansionIndex: output.expansionIndex,
+            obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
+            options: output.options,
           },
-          obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
-        },
-      ],
+        ]
+      },
     ),
   ]
 

package/lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts

@@ -238,23 +238,17 @@ export class RectDiffSeedingSolver extends BaseSolver {
     const ordered = preferMultiLayer ? attempts : attempts.reverse()
 
     for (const attempt of ordered) {
-      // HARD blockers only: obstacles on those layers + full-stack nodes
-      const hardBlockers: XYRect[] = []
-      for (const z of attempt.layers) {
-        const obstacleLayer = this.input.obstacleIndexByLayer[z]
-        if (obstacleLayer) hardBlockers.push(...obstacleLayer.all())
-        if (hardPlacedByLayer[z]) hardBlockers.push(...hardPlacedByLayer[z]!)
-      }
-
       const rect = expandRectFromSeed({
         startX: cand.x,
         startY: cand.y,
         gridSize: grid,
         bounds: this.bounds,
-        blockers: hardBlockers,
+        obsticalIndexByLayer: this.input.obstacleIndexByLayer,
+        placedIndexByLayer: this.placedIndexByLayer,
         initialCellRatio,
         maxAspectRatio,
         minReq: attempt.minReq,
+        zLayers: attempt.layers,
       })
       if (!rect) continue
 

package/lib/utils/expandRectFromSeed.ts

@@ -1,5 +1,14 @@
+import type RBush from "rbush"
 import type { XYRect } from "../rectdiff-types"
 import { EPS, gt, gte, lt, lte, overlaps } from "./rectdiff-geometry"
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
+import { isSelfRect } from "./isSelfRect"
+import {
+  searchStripDown,
+  searchStripLeft,
+  searchStripRight,
+  searchStripUp,
+} from "./searchStrip"
 
 type ExpandDirectionParams = {
   r: XYRect
@@ -148,23 +157,55 @@ function maxExpandUp(params: ExpandDirectionParams) {
   return Math.max(0, e)
 }
 
+const toRect = (tree: RTreeRect): XYRect => ({
+  x: tree.minX,
+  y: tree.minY,
+  width: tree.maxX - tree.minX,
+  height: tree.maxY - tree.minY,
+})
+
+const addBlocker = (params: {
+  rect: XYRect
+  seen: Set<string>
+  blockers: XYRect[]
+}) => {
+  const { rect, seen, blockers } = params
+  const key = `${rect.x}|${rect.y}|${rect.width}|${rect.height}`
+  if (seen.has(key)) return
+  seen.add(key)
+  blockers.push(rect)
+}
+
+const toQueryRect = (params: { bounds: XYRect; rect: XYRect }) => {
+  const { bounds, rect } = params
+  const minX = Math.max(bounds.x, rect.x)
+  const minY = Math.max(bounds.y, rect.y)
+  const maxX = Math.min(bounds.x + bounds.width, rect.x + rect.width)
+  const maxY = Math.min(bounds.y + bounds.height, rect.y + rect.height)
+  if (maxX <= minX + EPS || maxY <= minY + EPS) return null
+  return { minX, minY, maxX, maxY }
+}
+
 /** Grow a rect around a seed point, honoring bounds/blockers/aspect/min sizes. */
 export function expandRectFromSeed(params: {
   startX: number
   startY: number
   gridSize: number
   bounds: XYRect
-  blockers: XYRect[]
+  obsticalIndexByLayer: Array<RBush<RTreeRect>>
+  placedIndexByLayer: Array<RBush<RTreeRect>>
   initialCellRatio: number
   maxAspectRatio: number | null | undefined
   minReq: { width: number; height: number }
+  zLayers: number[]
 }): XYRect | null {
   const {
     startX,
     startY,
     gridSize,
     bounds,
-    blockers,
+    obsticalIndexByLayer,
+    placedIndexByLayer,
     initialCellRatio,
     maxAspectRatio,
     minReq,
@@ -173,6 +214,40 @@ export function expandRectFromSeed(params: {
   const minSide = Math.max(1e-9, gridSize * initialCellRatio)
   const initialW = Math.max(minSide, minReq.width)
   const initialH = Math.max(minSide, minReq.height)
+  const blockers: XYRect[] = []
+  const seen = new Set<string>()
+
+  // Ignore the existing placement we are expanding so it doesn't self-block.
+
+  const collectBlockers = (searchRect: XYRect) => {
+    const query = toQueryRect({ bounds, rect: searchRect })
+    if (!query) return
+    for (const z of params.zLayers) {
+      const blockersIndex = obsticalIndexByLayer[z]
+      if (blockersIndex) {
+        for (const entry of blockersIndex.search(query))
+          addBlocker({ rect: toRect(entry), seen, blockers })
+      }
+
+      const placedLayer = placedIndexByLayer[z]
+      if (placedLayer) {
+        for (const entry of placedLayer.search(query)) {
+          const rect = toRect(entry)
+          if (
+            isSelfRect({
+              rect,
+              startX,
+              startY,
+              initialW,
+              initialH,
+            })
+          )
+            continue
+          addBlocker({ rect, seen, blockers })
+        }
+      }
+    }
+  }
 
   const strategies = [
     { ox: 0, oy: 0 },
@@ -192,6 +267,7 @@ export function expandRectFromSeed(params: {
       width: initialW,
       height: initialH,
     }
+    collectBlockers(r)
 
     // keep initial inside board
     if (
@@ -212,27 +288,35 @@ export function expandRectFromSeed(params: {
       improved = false
       const commonParams = { bounds, blockers, maxAspect: maxAspectRatio }
 
+      collectBlockers(searchStripRight({ rect: r, bounds }))
       const eR = maxExpandRight({ ...commonParams, r })
       if (eR > 0) {
         r = { ...r, width: r.width + eR }
+        collectBlockers(r)
         improved = true
       }
 
+      collectBlockers(searchStripDown({ rect: r, bounds }))
       const eD = maxExpandDown({ ...commonParams, r })
       if (eD > 0) {
         r = { ...r, height: r.height + eD }
+        collectBlockers(r)
         improved = true
       }
 
+      collectBlockers(searchStripLeft({ rect: r, bounds }))
       const eL = maxExpandLeft({ ...commonParams, r })
       if (eL > 0) {
         r = { x: r.x - eL, y: r.y, width: r.width + eL, height: r.height }
+        collectBlockers(r)
         improved = true
       }
 
+      collectBlockers(searchStripUp({ rect: r, bounds }))
       const eU = maxExpandUp({ ...commonParams, r })
       if (eU > 0) {
         r = { x: r.x, y: r.y - eU, width: r.width, height: r.height + eU }
+        collectBlockers(r)
         improved = true
       }
     }

package/lib/utils/isSelfRect.ts

@@ -0,0 +1,15 @@
+import type { XYRect } from "lib/rectdiff-types"
+
+const EPS = 1e-9
+
+export const isSelfRect = (params: {
+  rect: XYRect
+  startX: number
+  startY: number
+  initialW: number
+  initialH: number
+}) =>
+  Math.abs(params.rect.x + params.rect.width / 2 - params.startX) < EPS &&
+  Math.abs(params.rect.y + params.rect.height / 2 - params.startY) < EPS &&
+  Math.abs(params.rect.width - params.initialW) < EPS &&
+  Math.abs(params.rect.height - params.initialH) < EPS

package/lib/utils/searchStrip.ts

@@ -0,0 +1,50 @@
+import type { XYRect } from "lib/rectdiff-types"
+
+export const searchStripRight = ({
+  rect,
+  bounds,
+}: {
+  rect: XYRect
+  bounds: XYRect
+}): XYRect => ({
+  x: rect.x,
+  y: rect.y,
+  width: bounds.x + bounds.width - rect.x,
+  height: rect.height,
+})
+export const searchStripDown = ({
+  rect,
+  bounds,
+}: {
+  rect: XYRect
+  bounds: XYRect
+}): XYRect => ({
+  x: rect.x,
+  y: rect.y,
+  width: rect.width,
+  height: bounds.y + bounds.height - rect.y,
+})
+export const searchStripLeft = ({
+  rect,
+  bounds,
+}: {
+  rect: XYRect
+  bounds: XYRect
+}): XYRect => ({
+  x: bounds.x,
+  y: rect.y,
+  width: rect.x - bounds.x,
+  height: rect.height,
+})
+export const searchStripUp = ({
+  rect,
+  bounds,
+}: {
+  rect: XYRect
+  bounds: XYRect
+}): XYRect => ({
+  x: rect.x,
+  y: bounds.y,
+  width: rect.width,
+  height: rect.y - bounds.y,
+})

package/package.json

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

package/tests/__snapshots__/should-expand-node.snap.svg

@@ -1,4 +1,4 @@
-<svg width="640" height="480" viewBox="0 0 640 480" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="white"/><g><rect data-type="rect" data-label="node" data-x="1.5" data-y="2" x="40.000000000000014" y="163.63636363636363" width="101.8181818181818" height="152.72727272727275" fill="#dbeafe" stroke="black" stroke-width="0.019642857142857142"/></g><g><rect data-type="rect" data-label="node" data-x="10.5" data-y="2" x="498.1818181818182" y="163.63636363636363" width="101.81818181818181" height="152.72727272727275" fill="#dbeafe" stroke="black" stroke-width="0.019642857142857142"/></g><g id="crosshair" style="display: none"><line id="crosshair-h" y1="0" y2="480" stroke="#666" stroke-width="0.5"/><line id="crosshair-v" x1="0" x2="640" stroke="#666" stroke-width="0.5"/><text id="coordinates" font-family="monospace" font-size="12" fill="#666"></text></g><script><![CDATA[
+<svg width="640" height="480" viewBox="0 0 640 480" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="white"/><g><polyline data-points="0,0 12,0 12,4 0,4 0,0" data-type="line" data-label="bounds" points="40,333.3333333333333 600,333.3333333333333 600,146.66666666666666 40,146.66666666666666 40,333.3333333333333" fill="none" stroke="#111827" stroke-width="4.666666666666667"/></g><g><rect data-type="rect" data-label="node" data-x="4.75" data-y="2" x="40" y="146.66666666666666" width="443.3333333333333" height="186.66666666666666" fill="#dbeafe" stroke="black" stroke-width="0.02142857142857143"/></g><g><rect data-type="rect" data-label="node" data-x="10.75" data-y="2" x="483.3333333333333" y="146.66666666666666" width="116.66666666666669" height="186.66666666666666" fill="#dbeafe" stroke="black" stroke-width="0.02142857142857143"/></g><g id="crosshair" style="display: none"><line id="crosshair-h" y1="0" y2="480" stroke="#666" stroke-width="0.5"/><line id="crosshair-v" x1="0" x2="640" stroke="#666" stroke-width="0.5"/><text id="coordinates" font-family="monospace" font-size="12" fill="#666"></text></g><script><![CDATA[
               document.currentScript.parentElement.addEventListener('mousemove', (e) => {
                 const svg = e.currentTarget;
                 const rect = svg.getBoundingClientRect();
@@ -20,7 +20,7 @@
                 v.setAttribute('y2', '480');
 
                 // Calculate real coordinates using inverse transformation
-                const matrix = {"a":50.90909090909091,"c":0,"e":14.545454545454561,"b":0,"d":-50.90909090909091,"f":341.8181818181818};
+                const matrix = {"a":46.666666666666664,"c":0,"e":40,"b":0,"d":-46.666666666666664,"f":333.3333333333333};
                 // Manually invert and apply the affine transform
                 // Since we only use translate and scale, we can directly compute:
                 // x' = (x - tx) / sx

package/tests/fixtures/makeSimpleRouteOutlineGraphics.ts

@@ -0,0 +1,41 @@
+import type { GraphicsObject, Line } from "graphics-debug"
+import type { SimpleRouteJson } from "lib/types/srj-types"
+
+/**
+ * Creates a GraphicsObject that draws the SRJ outline (or bounds fallback).
+ */
+export const makeSimpleRouteOutlineGraphics = (
+  srj: SimpleRouteJson,
+): GraphicsObject => {
+  const lines: NonNullable<Line[]> = []
+
+  if (srj.outline && srj.outline.length > 1) {
+    lines.push({
+      points: [...srj.outline, srj.outline[0]!],
+      strokeColor: "#111827",
+      strokeWidth: 0.1,
+      label: "outline",
+    })
+  } else {
+    const { minX, maxX, minY, maxY } = srj.bounds
+    lines.push({
+      points: [
+        { x: minX, y: minY },
+        { x: maxX, y: minY },
+        { x: maxX, y: maxY },
+        { x: minX, y: maxY },
+        { x: minX, y: minY },
+      ],
+      strokeColor: "#111827",
+      strokeWidth: 0.1,
+      label: "bounds",
+    })
+  }
+
+  return {
+    title: "SimpleRoute Outline",
+    coordinateSystem: "cartesian",
+    lines,
+    points: [],
+  }
+}

package/tests/incremental-solver.test.ts

@@ -28,7 +28,7 @@ test("RectDiffSolver supports incremental stepping", () => {
 
   // Step advances one candidate at a time
   let stepCount = 0
-  const maxSteps = 1000 // safety limit
+  const maxSteps = 5000 // safety limit
 
   while (!pipeline.solved && stepCount < maxSteps) {
     pipeline.step()

package/tests/should-expand-node.test.ts

@@ -1,11 +1,13 @@
 import { expect, test } from "bun:test"
-import { getSvgFromGraphicsObject } from "graphics-debug"
+import { getSvgFromGraphicsObject, mergeGraphics } from "graphics-debug"
 import { RectDiffExpansionSolver } from "lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver"
 import { createTwoNodeExpansionInput } from "lib/fixtures/twoNodeExpansionFixture"
 import { makeCapacityMeshNodeWithLayerInfo } from "./fixtures/makeCapacityMeshNodeWithLayerInfo"
+import { makeSimpleRouteOutlineGraphics } from "./fixtures/makeSimpleRouteOutlineGraphics"
 
 test("RectDiff expansion reproduces the two-node gap fixture", async () => {
-  const solver = new RectDiffExpansionSolver(createTwoNodeExpansionInput())
+  const input = createTwoNodeExpansionInput()
+  const solver = new RectDiffExpansionSolver(input)
 
   solver.solve()
 
@@ -13,8 +15,9 @@ test("RectDiff expansion reproduces the two-node gap fixture", async () => {
   expect(meshNodes.length).toBeGreaterThanOrEqual(2)
 
   const finalGraphics = makeCapacityMeshNodeWithLayerInfo(meshNodes)
+  const outline = makeSimpleRouteOutlineGraphics(input.srj)
   const svg = getSvgFromGraphicsObject(
-    { rects: finalGraphics.values().toArray().flat() },
+    mergeGraphics({ rects: finalGraphics.values().toArray().flat() }, outline),
     {
       svgWidth: 640,
       svgHeight: 480,