@tscircuit/rectdiff 0.0.15 → 0.0.17

package/dist/index.d.ts

@@ -159,6 +159,14 @@ declare class FindSegmentsWithAdjacentEmptySpaceSolver extends BaseSolver {
     visualize(): Required<GraphicsObject>;
 }
 
+type ExpandEdgesToEmptySpaceSolverInput = {
+    inputMeshNodes: CapacityMeshNode[];
+    segmentsWithAdjacentEmptySpace: Array<SegmentWithAdjacentEmptySpace>;
+    boardVoid?: {
+        boardVoidRects: XYRect[];
+        layerCount: number;
+    };
+};
 interface ExpandedSegment {
     segment: SegmentWithAdjacentEmptySpace;
     newNode: CapacityMeshNode;
@@ -180,10 +188,7 @@ declare class ExpandEdgesToEmptySpaceSolver extends BaseSolver {
     } | null;
     lastExpandedSegment: ExpandedSegment | null;
     rectSpatialIndex: RBush<CapacityMeshNode>;
-    constructor(input: {
-        inputMeshNodes: CapacityMeshNode[];
-        segmentsWithAdjacentEmptySpace: Array<SegmentWithAdjacentEmptySpace>;
-    });
+    constructor(input: ExpandEdgesToEmptySpaceSolverInput);
     _step(): void;
     getOutput(): {
         expandedSegments: ExpandedSegment[];
@@ -191,9 +196,14 @@ declare class ExpandEdgesToEmptySpaceSolver extends BaseSolver {
     visualize(): Required<GraphicsObject>;
 }
 
-declare class GapFillSolverPipeline extends BasePipelineSolver<{
+type GapFillSolverInput = {
     meshNodes: CapacityMeshNode[];
-}> {
+    boardVoid?: {
+        boardVoidRects: XYRect[];
+        layerCount: number;
+    };
+};
+declare class GapFillSolverPipeline extends BasePipelineSolver<GapFillSolverInput> {
     findSegmentsWithAdjacentEmptySpaceSolver?: FindSegmentsWithAdjacentEmptySpaceSolver;
     expandEdgesToEmptySpaceSolver?: ExpandEdgesToEmptySpaceSolver;
     pipelineDef: PipelineStep<any>[];
@@ -329,11 +339,11 @@ declare class RectDiffExpansionSolver extends BaseSolver {
 type RectDiffGridSolverPipelineInput = {
     simpleRouteJson: SimpleRouteJson;
     gridOptions?: Partial<GridFill3DOptions>;
+    boardVoidRects?: XYRect[];
 };
 declare class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridSolverPipelineInput> {
     rectDiffSeedingSolver?: RectDiffSeedingSolver;
     rectDiffExpansionSolver?: RectDiffExpansionSolver;
-    private boardVoidRects?;
     private obstacleIndexByLayer;
     constructor(inputProblem: RectDiffGridSolverPipelineInput);
     pipelineDef: PipelineStep<any>[];
@@ -351,7 +361,9 @@ interface RectDiffPipelineInput {
 declare class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
     rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline;
     gapFillSolver?: GapFillSolverPipeline;
+    boardVoidRects: XYRect[] | undefined;
     pipelineDef: PipelineStep<any>[];
+    _setup(): void;
     getConstructorParams(): RectDiffPipelineInput[];
     getOutput(): {
         meshNodes: CapacityMeshNode[];

package/dist/index.js

@@ -331,6 +331,26 @@ var ExpandEdgesToEmptySpaceSolver = class extends BaseSolver2 {
     this.input = input;
     this.unprocessedSegments = [...this.input.segmentsWithAdjacentEmptySpace];
     this.rectSpatialIndex = new RBush();
+    this.rectSpatialIndex.load(
+      this.input.boardVoid?.boardVoidRects.map((rect, index) => ({
+        capacityMeshNodeId: `void-rect-${index}`,
+        center: {
+          x: rect.x + rect.width / 2,
+          y: rect.y + rect.height / 2
+        },
+        width: rect.width,
+        height: rect.height,
+        availableZ: Array.from(
+          { length: this.input.boardVoid?.layerCount || 0 },
+          (_, i) => i
+        ),
+        layer: "void",
+        minX: rect.x,
+        minY: rect.y,
+        maxX: rect.x + rect.width,
+        maxY: rect.y + rect.height
+      })) || []
+    );
     this.rectSpatialIndex.load(
       this.input.inputMeshNodes.map((n) => ({
         ...n,
@@ -566,7 +586,8 @@ var GapFillSolverPipeline = class extends BasePipelineSolver {
       (gapFillPipeline) => [
         {
           inputMeshNodes: gapFillPipeline.inputProblem.meshNodes,
-          segmentsWithAdjacentEmptySpace: gapFillPipeline.findSegmentsWithAdjacentEmptySpaceSolver.getOutput().segmentsWithAdjacentEmptySpace
+          segmentsWithAdjacentEmptySpace: gapFillPipeline.findSegmentsWithAdjacentEmptySpaceSolver.getOutput().segmentsWithAdjacentEmptySpace,
+          boardVoid: gapFillPipeline.inputProblem.boardVoid
         }
       ],
       {
@@ -2146,7 +2167,8 @@ import "rbush";
 
 // lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts
 import RBush5 from "rbush";
-var buildObstacleIndexes = (srj) => {
+var buildObstacleIndexesByLayer = (params) => {
+  const { srj, boardVoidRects } = params;
   const { layerNames, zIndexByName } = buildZIndexMap(srj);
   const layerCount = Math.max(1, layerNames.length, srj.layerCount || 1);
   const bounds = {
@@ -2169,10 +2191,8 @@ var buildObstacleIndexes = (srj) => {
     };
     obstacleIndexByLayer[z]?.insert(treeRect);
   };
-  let boardVoidRects = [];
   if (srj.outline && srj.outline.length > 2) {
-    boardVoidRects = computeInverseRects(bounds, srj.outline);
-    for (const voidRect of boardVoidRects) {
+    for (const voidRect of boardVoidRects ?? []) {
       for (let z = 0; z < layerCount; z++) insertObstacle(voidRect, z);
     }
   }
@@ -2191,22 +2211,21 @@ var buildObstacleIndexes = (srj) => {
     }
     for (const z of zLayers) insertObstacle(rect, z);
   }
-  return { obstacleIndexByLayer, boardVoidRects };
+  return { obstacleIndexByLayer };
 };
 
 // lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts
 var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
   rectDiffSeedingSolver;
   rectDiffExpansionSolver;
-  boardVoidRects;
   obstacleIndexByLayer;
   constructor(inputProblem) {
     super(inputProblem);
-    const { obstacleIndexByLayer, boardVoidRects } = buildObstacleIndexes(
-      inputProblem.simpleRouteJson
-    );
+    const { obstacleIndexByLayer } = buildObstacleIndexesByLayer({
+      srj: inputProblem.simpleRouteJson,
+      boardVoidRects: inputProblem.boardVoidRects
+    });
     this.obstacleIndexByLayer = obstacleIndexByLayer;
-    this.boardVoidRects = boardVoidRects;
   }
   pipelineDef = [
     definePipelineStep2(
@@ -2217,7 +2236,7 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
           simpleRouteJson: pipeline.inputProblem.simpleRouteJson,
           gridOptions: pipeline.inputProblem.gridOptions,
           obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
-          boardVoidRects: pipeline.boardVoidRects
+          boardVoidRects: pipeline.inputProblem.boardVoidRects
         }
       ]
     ),
@@ -2228,7 +2247,7 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
         {
           initialSnapshot: {
             ...pipeline.rectDiffSeedingSolver.getOutput(),
-            boardVoidRects: pipeline.boardVoidRects ?? []
+            boardVoidRects: pipeline.inputProblem.boardVoidRects ?? []
           },
           obstacleIndexByLayer: pipeline.obstacleIndexByLayer
         }
@@ -2334,6 +2353,7 @@ function createBaseVisualization(srj, title = "RectDiff") {
 var RectDiffPipeline = class extends BasePipelineSolver3 {
   rectDiffGridSolverPipeline;
   gapFillSolver;
+  boardVoidRects;
   pipelineDef = [
     definePipelineStep3(
       "rectDiffGridSolverPipeline",
@@ -2341,7 +2361,8 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
       (rectDiffPipeline) => [
         {
           simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
-          gridOptions: rectDiffPipeline.inputProblem.gridOptions
+          gridOptions: rectDiffPipeline.inputProblem.gridOptions,
+          boardVoidRects: rectDiffPipeline.boardVoidRects
         }
       ]
     ),
@@ -2350,11 +2371,28 @@ var RectDiffPipeline = class extends BasePipelineSolver3 {
       GapFillSolverPipeline,
       (rectDiffPipeline) => [
         {
-          meshNodes: rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? []
+          meshNodes: rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput().meshNodes ?? [],
+          boardVoid: {
+            boardVoidRects: rectDiffPipeline.boardVoidRects || [],
+            layerCount: rectDiffPipeline.inputProblem.simpleRouteJson.layerCount || 0
+          }
         }
       ]
     )
   ];
+  _setup() {
+    if (this.inputProblem.simpleRouteJson.outline) {
+      this.boardVoidRects = computeInverseRects(
+        {
+          x: this.inputProblem.simpleRouteJson.bounds.minX,
+          y: this.inputProblem.simpleRouteJson.bounds.minY,
+          width: this.inputProblem.simpleRouteJson.bounds.maxX - this.inputProblem.simpleRouteJson.bounds.minX,
+          height: this.inputProblem.simpleRouteJson.bounds.maxY - this.inputProblem.simpleRouteJson.bounds.minY
+        },
+        this.inputProblem.simpleRouteJson.outline ?? []
+      );
+    }
+  }
   getConstructorParams() {
     return [this.inputProblem];
   }

package/lib/RectDiffPipeline.ts

@@ -4,12 +4,13 @@ import {
   type PipelineStep,
 } from "@tscircuit/solver-utils"
 import type { SimpleRouteJson } from "./types/srj-types"
-import type { GridFill3DOptions } from "./rectdiff-types"
+import type { GridFill3DOptions, XYRect } from "./rectdiff-types"
 import type { CapacityMeshNode } from "./types/capacity-mesh-types"
 import type { GraphicsObject } from "graphics-debug"
 import { GapFillSolverPipeline } from "./solvers/GapFillSolver/GapFillSolverPipeline"
 import { RectDiffGridSolverPipeline } from "./solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline"
 import { createBaseVisualization } from "./rectdiff-visualization"
+import { computeInverseRects } from "./solvers/RectDiffSeedingSolver/computeInverseRects"
 
 export interface RectDiffPipelineInput {
   simpleRouteJson: SimpleRouteJson
@@ -19,6 +20,7 @@ export interface RectDiffPipelineInput {
 export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
   rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline
   gapFillSolver?: GapFillSolverPipeline
+  boardVoidRects: XYRect[] | undefined
 
   override pipelineDef: PipelineStep<any>[] = [
     definePipelineStep(
@@ -28,6 +30,7 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
         {
           simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
           gridOptions: rectDiffPipeline.inputProblem.gridOptions,
+          boardVoidRects: rectDiffPipeline.boardVoidRects,
         },
       ],
     ),
@@ -39,11 +42,34 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
           meshNodes:
             rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput()
               .meshNodes ?? [],
+          boardVoid: {
+            boardVoidRects: rectDiffPipeline.boardVoidRects || [],
+            layerCount:
+              rectDiffPipeline.inputProblem.simpleRouteJson.layerCount || 0,
+          },
         },
       ],
     ),
   ]
 
+  override _setup(): void {
+    if (this.inputProblem.simpleRouteJson.outline) {
+      this.boardVoidRects = computeInverseRects(
+        {
+          x: this.inputProblem.simpleRouteJson.bounds.minX,
+          y: this.inputProblem.simpleRouteJson.bounds.minY,
+          width:
+            this.inputProblem.simpleRouteJson.bounds.maxX -
+            this.inputProblem.simpleRouteJson.bounds.minX,
+          height:
+            this.inputProblem.simpleRouteJson.bounds.maxY -
+            this.inputProblem.simpleRouteJson.bounds.minY,
+        },
+        this.inputProblem.simpleRouteJson.outline ?? [],
+      )
+    }
+  }
+
   override getConstructorParams() {
     return [this.inputProblem]
   }

package/lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts

@@ -7,9 +7,19 @@ import { EDGE_MAP, EDGES } from "./edge-constants"
 import { getBoundsFromCorners } from "./getBoundsFromCorners"
 import type { Bounds } from "@tscircuit/math-utils"
 import { midpoint, segmentToBoxMinDistance } from "@tscircuit/math-utils"
+import type { XYRect } from "lib/rectdiff-types"
 
 const EPS = 1e-4
 
+export type ExpandEdgesToEmptySpaceSolverInput = {
+  inputMeshNodes: CapacityMeshNode[]
+  segmentsWithAdjacentEmptySpace: Array<SegmentWithAdjacentEmptySpace>
+  boardVoid?: {
+    boardVoidRects: XYRect[]
+    layerCount: number
+  }
+}
+
 export interface ExpandedSegment {
   segment: SegmentWithAdjacentEmptySpace
   newNode: CapacityMeshNode
@@ -28,15 +38,31 @@ export class ExpandEdgesToEmptySpaceSolver extends BaseSolver {
 
   rectSpatialIndex: RBush<CapacityMeshNode>
 
-  constructor(
-    private input: {
-      inputMeshNodes: CapacityMeshNode[]
-      segmentsWithAdjacentEmptySpace: Array<SegmentWithAdjacentEmptySpace>
-    },
-  ) {
+  constructor(private input: ExpandEdgesToEmptySpaceSolverInput) {
     super()
     this.unprocessedSegments = [...this.input.segmentsWithAdjacentEmptySpace]
     this.rectSpatialIndex = new RBush<CapacityMeshNode>()
+    // create fake bound for the boardVoidRects
+    this.rectSpatialIndex.load(
+      this.input.boardVoid?.boardVoidRects.map((rect, index) => ({
+        capacityMeshNodeId: `void-rect-${index}`,
+        center: {
+          x: rect.x + rect.width / 2,
+          y: rect.y + rect.height / 2,
+        },
+        width: rect.width,
+        height: rect.height,
+        availableZ: Array.from(
+          { length: this.input.boardVoid?.layerCount || 0 },
+          (_, i) => i,
+        ),
+        layer: "void",
+        minX: rect.x,
+        minY: rect.y,
+        maxX: rect.x + rect.width,
+        maxY: rect.y + rect.height,
+      })) || [],
+    )
     this.rectSpatialIndex.load(
       this.input.inputMeshNodes.map((n) => ({
         ...n,

package/lib/solvers/GapFillSolver/GapFillSolverPipeline.ts

@@ -3,15 +3,21 @@ import {
   definePipelineStep,
   type PipelineStep,
 } from "@tscircuit/solver-utils"
-import type { SimpleRouteJson } from "lib/types/srj-types"
 import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
 import type { GraphicsObject } from "graphics-debug"
 import { FindSegmentsWithAdjacentEmptySpaceSolver } from "./FindSegmentsWithAdjacentEmptySpaceSolver"
 import { ExpandEdgesToEmptySpaceSolver } from "./ExpandEdgesToEmptySpaceSolver"
+import type { XYRect } from "lib/rectdiff-types"
 
-export class GapFillSolverPipeline extends BasePipelineSolver<{
+type GapFillSolverInput = {
   meshNodes: CapacityMeshNode[]
-}> {
+  boardVoid?: {
+    boardVoidRects: XYRect[]
+    layerCount: number
+  }
+}
+
+export class GapFillSolverPipeline extends BasePipelineSolver<GapFillSolverInput> {
   findSegmentsWithAdjacentEmptySpaceSolver?: FindSegmentsWithAdjacentEmptySpaceSolver
   expandEdgesToEmptySpaceSolver?: ExpandEdgesToEmptySpaceSolver
 
@@ -39,6 +45,7 @@ export class GapFillSolverPipeline extends BasePipelineSolver<{
           segmentsWithAdjacentEmptySpace:
             gapFillPipeline.findSegmentsWithAdjacentEmptySpaceSolver!.getOutput()
               .segmentsWithAdjacentEmptySpace,
+          boardVoid: gapFillPipeline.inputProblem.boardVoid,
         },
       ],
       {

package/lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts

@@ -10,26 +10,26 @@ import { RectDiffSeedingSolver } from "lib/solvers/RectDiffSeedingSolver/RectDif
 import { RectDiffExpansionSolver } from "lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver"
 import type { GraphicsObject } from "graphics-debug"
 import RBush from "rbush"
-import { buildObstacleIndexes } from "./buildObstacleIndexes"
+import { buildObstacleIndexesByLayer } from "./buildObstacleIndexes"
 
 export type RectDiffGridSolverPipelineInput = {
   simpleRouteJson: SimpleRouteJson
   gridOptions?: Partial<GridFill3DOptions>
+  boardVoidRects?: XYRect[]
 }
 
 export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridSolverPipelineInput> {
   rectDiffSeedingSolver?: RectDiffSeedingSolver
   rectDiffExpansionSolver?: RectDiffExpansionSolver
-  private boardVoidRects?: XYRect[]
   private obstacleIndexByLayer: Array<RBush<RTreeRect>>
 
   constructor(inputProblem: RectDiffGridSolverPipelineInput) {
     super(inputProblem)
-    const { obstacleIndexByLayer, boardVoidRects } = buildObstacleIndexes(
-      inputProblem.simpleRouteJson,
-    )
+    const { obstacleIndexByLayer } = buildObstacleIndexesByLayer({
+      srj: inputProblem.simpleRouteJson,
+      boardVoidRects: inputProblem.boardVoidRects,
+    })
     this.obstacleIndexByLayer = obstacleIndexByLayer
-    this.boardVoidRects = boardVoidRects
   }
 
   override pipelineDef: PipelineStep<any>[] = [
@@ -41,7 +41,7 @@ export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridS
           simpleRouteJson: pipeline.inputProblem.simpleRouteJson,
           gridOptions: pipeline.inputProblem.gridOptions,
           obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
-          boardVoidRects: pipeline.boardVoidRects,
+          boardVoidRects: pipeline.inputProblem.boardVoidRects,
         },
       ],
     ),
@@ -52,7 +52,7 @@ export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridS
         {
           initialSnapshot: {
             ...pipeline.rectDiffSeedingSolver!.getOutput(),
-            boardVoidRects: pipeline.boardVoidRects ?? [],
+            boardVoidRects: pipeline.inputProblem.boardVoidRects ?? [],
           },
           obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
         },

package/lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts

@@ -9,12 +9,13 @@ import {
 import type { XYRect } from "lib/rectdiff-types"
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
 
-export const buildObstacleIndexes = (
-  srj: SimpleRouteJson,
-): {
+export const buildObstacleIndexesByLayer = (params: {
+  srj: SimpleRouteJson
+  boardVoidRects?: XYRect[]
+}): {
   obstacleIndexByLayer: Array<RBush<RTreeRect>>
-  boardVoidRects: XYRect[]
 } => {
+  const { srj, boardVoidRects } = params
   const { layerNames, zIndexByName } = buildZIndexMap(srj)
   const layerCount = Math.max(1, layerNames.length, srj.layerCount || 1)
   const bounds: XYRect = {
@@ -39,10 +40,8 @@ export const buildObstacleIndexes = (
     obstacleIndexByLayer[z]?.insert(treeRect)
   }
 
-  let boardVoidRects: XYRect[] = []
   if (srj.outline && srj.outline.length > 2) {
-    boardVoidRects = computeInverseRects(bounds, srj.outline as any)
-    for (const voidRect of boardVoidRects) {
+    for (const voidRect of boardVoidRects ?? []) {
       for (let z = 0; z < layerCount; z++) insertObstacle(voidRect, z)
     }
   }
@@ -66,5 +65,5 @@ export const buildObstacleIndexes = (
     for (const z of zLayers) insertObstacle(rect, z)
   }
 
-  return { obstacleIndexByLayer, boardVoidRects }
+  return { obstacleIndexByLayer }
 }

package/package.json

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

package/pages/gap-fill-h-shape-should-expand-node.page.tsx

@@ -0,0 +1,23 @@
+import fixture from "../test-assets/gap-fill-h-shape-should-expand-node.json"
+import { GapFillSolverPipeline } from "../lib/solvers/GapFillSolver/GapFillSolverPipeline"
+import type { CapacityMeshNode } from "../lib/types/capacity-mesh-types"
+import { useMemo } from "react"
+import { SolverDebugger3d } from "../components/SolverDebugger3d"
+
+export default () => {
+  const solver = useMemo(
+    () =>
+      new GapFillSolverPipeline({
+        meshNodes: fixture.meshNodes as CapacityMeshNode[],
+      }),
+    [],
+  )
+
+  return (
+    <SolverDebugger3d
+      solver={solver}
+      defaultShowOutput={true}
+      defaultShowRoot={true}
+    />
+  )
+}

package/test-assets/gap-fill-h-shape-should-expand-node.json

@@ -0,0 +1,72 @@
+{
+  "description": "H-shaped configuration - two vertical nodes with a horizontal connector in the middle",
+  "expectedBehavior": "Should detect segments on all exposed edges and expand into empty spaces around the H shape",
+  "meshNodes": [
+    {
+      "capacityMeshNodeId": "node-left-vertical",
+      "center": { "x": -3, "y": 0 },
+      "width": 1,
+      "height": 6,
+      "layer": "top",
+      "availableZ": [0]
+    },
+    {
+      "capacityMeshNodeId": "node-right-vertical",
+      "center": { "x": 3, "y": 0 },
+      "width": 1,
+      "height": 6,
+      "layer": "top",
+      "availableZ": [0]
+    },
+    {
+      "capacityMeshNodeId": "node-middle-horizontal",
+      "center": { "x": 0, "y": 0 },
+      "width": 2,
+      "height": 1,
+      "layer": "top",
+      "availableZ": [0]
+    }
+  ],
+  "expectedSegments": [
+    {
+      "description": "Left vertical - left edge",
+      "parentNodeId": "node-left-vertical",
+      "facingDirection": "x-"
+    },
+    {
+      "description": "Left vertical - top edge (above horizontal)",
+      "parentNodeId": "node-left-vertical",
+      "facingDirection": "y+"
+    },
+    {
+      "description": "Left vertical - bottom edge (below horizontal)",
+      "parentNodeId": "node-left-vertical",
+      "facingDirection": "y-"
+    },
+    {
+      "description": "Right vertical - right edge",
+      "parentNodeId": "node-right-vertical",
+      "facingDirection": "x+"
+    },
+    {
+      "description": "Right vertical - top edge (above horizontal)",
+      "parentNodeId": "node-right-vertical",
+      "facingDirection": "y+"
+    },
+    {
+      "description": "Right vertical - bottom edge (below horizontal)",
+      "parentNodeId": "node-right-vertical",
+      "facingDirection": "y-"
+    },
+    {
+      "description": "Middle horizontal - top edge",
+      "parentNodeId": "node-middle-horizontal",
+      "facingDirection": "y+"
+    },
+    {
+      "description": "Middle horizontal - bottom edge",
+      "parentNodeId": "node-middle-horizontal",
+      "facingDirection": "y-"
+    }
+  ]
+}

package/tests/__snapshots__/board-outline.snap.svg

@@ -1,19 +1,4 @@
-<svg width="640" height="640" viewBox="0 0 640 640" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="white"/><g><polyline data-points="-8,-6 -2,-6 -2,2 2,2 2,-6 8,-6 8,6 -8,6 -8,-6" data-type="line" data-label="outline" points="40,530 250,530 250,250.00000000000006 390,250.00000000000006 390,530 600,530 600,110.00000000000006 40,110.00000000000006 40,530" fill="none" stroke="#111827" stroke-width="0.35000000000000003"/></g><g><rect data-type="rect" data-label="obstacle" data-x="-5.51" data-y="-4" x="117.70000000000002" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="#fee2e2" stroke="#ef4444" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="obstacle" data-x="-4.49" data-y="-4" x="153.4" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="#fee2e2" stroke="#ef4444" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="obstacle" data-x="4.49" data-y="-4" x="467.70000000000005" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="#fee2e2" stroke="#ef4444" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="obstacle" data-x="5.51" data-y="-4" x="503.4" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="#fee2e2" stroke="#ef4444" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="void" data-x="0" data-y="-2" x="250" y="250.00000000000006" width="140" height="279.99999999999994" fill="rgba(0, 0, 0, 0.5)" stroke="none" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0,1" data-x="-5" data-y="1.1600000000000006" x="40" y="110" width="210" height="338.80000000000007" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0,1" data-x="5" data-y="1.1600000000000006" x="390" y="110" width="210" height="338.80000000000007" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0,1" data-x="0" data-y="4" x="250" y="110.00000000000006" width="140" height="140" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0,1" data-x="-5.48" data-y="-5.16" x="40" y="471.20000000000005" width="176.39999999999998" height="58.799999999999955" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0,1" data-x="5.48" data-y="-5.16" x="423.6" y="471.20000000000005" width="176.39999999999998" height="58.799999999999955" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0,1" data-x="-2.4800000000000004" data-y="-4.84" x="216.39999999999998" y="448.80000000000007" width="33.60000000000002" height="81.19999999999993" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0,1" data-x="2.4800000000000004" data-y="-4.84" x="390" y="448.80000000000007" width="33.60000000000002" height="81.19999999999993" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:1" data-x="-5.48" data-y="-4" x="40" y="448.80000000000007" width="176.39999999999998" height="22.399999999999977" fill="#fef3c7" stroke="#f59e0b" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:1" data-x="5.48" data-y="-4" x="423.6" y="448.80000000000007" width="176.39999999999998" height="22.399999999999977" fill="#fef3c7" stroke="#f59e0b" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0" data-x="6.890000000000001" data-y="-4" x="522.3" y="448.80000000000007" width="77.70000000000005" height="22.399999999999977" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0" data-x="-6.89" data-y="-4" x="40" y="448.80000000000007" width="77.70000000000002" height="22.399999999999977" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0" data-x="-5" data-y="-4" x="136.6" y="448.80000000000007" width="16.80000000000001" height="22.399999999999977" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0" data-x="-3.5900000000000003" data-y="-4" x="172.3" y="448.80000000000007" width="44.099999999999966" height="22.399999999999977" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0" data-x="3.5900000000000007" data-y="-4" x="423.6" y="448.80000000000007" width="44.10000000000002" height="22.399999999999977" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="free
-z:0" data-x="5" data-y="-4" x="486.6" y="448.80000000000007" width="16.799999999999955" height="22.399999999999977" fill="#dbeafe" stroke="#3b82f6" stroke-width="0.02857142857142857"/></g><g id="crosshair" style="display: none"><line id="crosshair-h" y1="0" y2="640" 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="640" viewBox="0 0 640 640" xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" fill="white"/><g><rect data-type="rect" data-label="node" data-x="-5" data-y="1.1600000000000008" x="40" y="110" width="210" height="338.80000000000007" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5" data-y="1.1600000000000008" x="390" y="110" width="210" height="338.80000000000007" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="0" data-y="4" x="250" y="110.00000000000006" width="140" height="140" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5.48" data-y="-5.16" x="40" y="471.20000000000005" width="176.39999999999998" height="58.799999999999955" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5.48" data-y="-5.16" x="423.6" y="471.20000000000005" width="176.39999999999998" height="58.799999999999955" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-2.4800000000000004" data-y="-4.84" x="216.39999999999998" y="448.80000000000007" width="33.60000000000002" height="81.19999999999993" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="2.4800000000000004" data-y="-4.84" x="390" y="448.80000000000007" width="33.60000000000002" height="81.19999999999993" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5.48" data-y="-4" x="40" y="448.80000000000007" width="176.39999999999998" height="22.399999999999977" fill="#fef3c7" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5.48" data-y="-4" x="423.6" y="448.80000000000007" width="176.39999999999998" height="22.399999999999977" fill="#fef3c7" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="6.890000000000001" data-y="-4" x="522.3000000000001" y="448.80000000000007" width="77.69999999999993" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-6.89" data-y="-4" x="40" y="448.80000000000007" width="77.70000000000002" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5" data-y="-4" x="136.6" y="448.80000000000007" width="16.80000000000001" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-3.5900000000000003" data-y="-4" x="172.3" y="448.80000000000007" width="44.099999999999966" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="3.5900000000000007" data-y="-4" x="423.6" y="448.80000000000007" width="44.10000000000002" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5" data-y="-4" x="486.6" y="448.80000000000007" width="16.799999999999955" height="22.399999999999977" fill="#dbeafe" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-5.51" data-y="-4" x="117.70000000000002" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="-4.49" data-y="-4" x="153.4" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="4.49" data-y="-4" x="467.70000000000005" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g><rect data-type="rect" data-label="node" data-x="5.51" data-y="-4" x="503.4" y="448.80000000000007" width="18.899999999999977" height="22.399999999999977" fill="red" stroke="black" stroke-width="0.02857142857142857"/></g><g id="crosshair" style="display: none"><line id="crosshair-h" y1="0" y2="640" 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();

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

@@ -0,0 +1,44 @@
+<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="-3" data-y="0" x="86.66666666666666" y="40" width="66.66666666666666" height="400" fill="#dbeafe" stroke="black" stroke-width="0.015"/></g><g><rect data-type="rect" data-label="node" data-x="3" data-y="0" x="486.6666666666667" y="40" width="66.66666666666669" height="400" fill="#dbeafe" stroke="black" stroke-width="0.015"/></g><g><rect data-type="rect" data-label="node" data-x="0" data-y="0" x="253.33333333333331" y="206.66666666666666" width="133.33333333333337" height="66.66666666666666" fill="#dbeafe" stroke="black" stroke-width="0.015"/></g><g><rect data-type="rect" data-label="node" data-x="-1.75" data-y="0" x="153.33333333333331" y="40" width="100" height="400" fill="#dbeafe" stroke="black" stroke-width="0.015"/></g><g><rect data-type="rect" data-label="node" data-x="1.75" data-y="0" x="386.6666666666667" y="40" width="100" height="400" fill="#dbeafe" stroke="black" stroke-width="0.015"/></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();
+                const x = e.clientX - rect.left;
+                const y = e.clientY - rect.top;
+                const crosshair = svg.getElementById('crosshair');
+                const h = svg.getElementById('crosshair-h');
+                const v = svg.getElementById('crosshair-v');
+                const coords = svg.getElementById('coordinates');
+                
+                crosshair.style.display = 'block';
+                h.setAttribute('x1', '0');
+                h.setAttribute('x2', '640');
+                h.setAttribute('y1', y);
+                h.setAttribute('y2', y);
+                v.setAttribute('x1', x);
+                v.setAttribute('x2', x);
+                v.setAttribute('y1', '0');
+                v.setAttribute('y2', '480');
+
+                // Calculate real coordinates using inverse transformation
+                const matrix = {"a":66.66666666666667,"c":0,"e":320,"b":0,"d":-66.66666666666667,"f":240};
+                // Manually invert and apply the affine transform
+                // Since we only use translate and scale, we can directly compute:
+                // x' = (x - tx) / sx
+                // y' = (y - ty) / sy
+                const sx = matrix.a;
+                const sy = matrix.d;
+                const tx = matrix.e; 
+                const ty = matrix.f;
+                const realPoint = {
+                  x: (x - tx) / sx,
+                  y: (y - ty) / sy // Flip y back since we used negative scale
+                }
+                
+                coords.textContent = `(${realPoint.x.toFixed(2)}, ${realPoint.y.toFixed(2)})`;
+                coords.setAttribute('x', (x + 5).toString());
+                coords.setAttribute('y', (y - 5).toString());
+              });
+              document.currentScript.parentElement.addEventListener('mouseleave', () => {
+                document.currentScript.parentElement.getElementById('crosshair').style.display = 'none';
+              });
+            ]]></script></svg>

package/tests/board-outline.test.ts

@@ -2,6 +2,7 @@ import { expect, test } from "bun:test"
 import boardWithCutout from "../test-assets/board-with-cutout.json"
 import { RectDiffPipeline } from "../lib/RectDiffPipeline"
 import { getSvgFromGraphicsObject } from "graphics-debug"
+import { makeCapacityMeshNodeWithLayerInfo } from "./fixtures/makeCapacityMeshNodeWithLayerInfo"
 
 test("board outline snapshot", async () => {
   const solver = new RectDiffPipeline({
@@ -11,9 +12,15 @@ test("board outline snapshot", async () => {
   // Run to completion
   solver.solve()
 
-  const viz =
-    solver.rectDiffGridSolverPipeline!.rectDiffSeedingSolver!.visualize()
-  const svg = getSvgFromGraphicsObject(viz)
+  const meshNodesGraphics = makeCapacityMeshNodeWithLayerInfo(
+    solver?.getOutput().meshNodes || [],
+  )
+    .values()
+    .toArray()
+    .flat()
+  const svg = getSvgFromGraphicsObject({
+    rects: meshNodesGraphics,
+  })
 
   await expect(svg).toMatchSvgSnapshot(import.meta.path)
 })

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

@@ -0,0 +1,34 @@
+import { expect, test } from "bun:test"
+import middleGapFixture from "test-assets/gap-fill-h-shape-should-expand-node.json"
+import { getSvgFromGraphicsObject } from "graphics-debug"
+import { GapFillSolverPipeline } from "lib/solvers/GapFillSolver/GapFillSolverPipeline"
+import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
+import { makeCapacityMeshNodeWithLayerInfo } from "./fixtures/makeCapacityMeshNodeWithLayerInfo"
+
+test("should expand capacityMeshNode to fill the gap", async () => {
+  const solver = new GapFillSolverPipeline({
+    meshNodes: middleGapFixture.meshNodes as CapacityMeshNode[],
+  })
+
+  solver.solve()
+
+  const { outputNodes } = solver.getOutput()
+
+  expect(outputNodes.length).toBeGreaterThanOrEqual(
+    middleGapFixture.meshNodes.length,
+  )
+
+  const finalGraphics = makeCapacityMeshNodeWithLayerInfo(outputNodes)
+  const svg = getSvgFromGraphicsObject(
+    { rects: finalGraphics.values().toArray().flat() },
+    {
+      svgWidth: 640,
+      svgHeight: 480,
+    },
+  )
+
+  // More means we have added new nodes to fill the gap
+  // expect(outputNodes.length).toEqual(3)
+
+  await expect(svg).toMatchSvgSnapshot(import.meta.path)
+})

package/tests/fixtures/getPerLayerVisualizations.ts

@@ -1,130 +0,0 @@
-import type { GraphicsObject, Line, Point, Rect } from "graphics-debug"
-
-export function getPerLayerVisualizations(
-  graphics: GraphicsObject,
-): Map<string, GraphicsObject> {
-  const rects = (graphics.rects ?? []) as NonNullable<Rect[]>
-  const lines = (graphics.lines ?? []) as NonNullable<Line[]>
-  const points = (graphics.points ?? []) as NonNullable<Point[]>
-
-  const zValues = new Set<number>()
-
-  const addZValuesFromLayer = (layer: string) => {
-    if (!layer.startsWith("z")) return
-    const rest = layer.slice(1)
-    if (!rest) return
-    for (const part of rest.split(",")) {
-      const value = Number.parseInt(part, 10)
-      if (!Number.isNaN(value)) zValues.add(value)
-    }
-  }
-
-  for (const rect of rects) addZValuesFromLayer(rect.layer!)
-  for (const line of lines) addZValuesFromLayer(line.layer!)
-  for (const point of points) addZValuesFromLayer(point.layer!)
-
-  const result = new Map<string, GraphicsObject>()
-  if (!zValues.size) return result
-
-  const sortedZ = Array.from(zValues).sort((a, b) => a - b)
-
-  const commonRects: NonNullable<Rect[]> = []
-  const perLayerRects: { layers: number[]; rect: Rect }[] = []
-
-  for (const rect of rects) {
-    const layer = rect.layer!
-    if (layer.startsWith("z")) {
-      const rest = layer.slice(1)
-      if (rest) {
-        const layers = rest
-          .split(",")
-          .map((part) => Number.parseInt(part, 10))
-          .filter((value) => !Number.isNaN(value))
-        if (layers.length) {
-          perLayerRects.push({ layers, rect })
-          continue
-        }
-      }
-    }
-    commonRects.push(rect)
-  }
-
-  const commonLines: NonNullable<Line[]> = []
-  const perLayerLines: { layers: number[]; line: Line }[] = []
-
-  for (const line of lines) {
-    const layer = line.layer!
-    if (layer.startsWith("z")) {
-      const rest = layer.slice(1)
-      if (rest) {
-        const layers = rest
-          .split(",")
-          .map((part) => Number.parseInt(part, 10))
-          .filter((value) => !Number.isNaN(value))
-        if (layers.length) {
-          perLayerLines.push({ layers, line })
-          continue
-        }
-      }
-    }
-    commonLines.push(line)
-  }
-
-  const commonPoints: NonNullable<Point[]> = []
-  const perLayerPoints: { layers: number[]; point: Point }[] = []
-
-  for (const point of points) {
-    const layer = point.layer!
-    if (layer.startsWith("z")) {
-      const rest = layer.slice(1)
-      if (rest) {
-        const layers = rest
-          .split(",")
-          .map((part) => Number.parseInt(part, 10))
-          .filter((value) => !Number.isNaN(value))
-        if (layers.length) {
-          perLayerPoints.push({ layers, point })
-          continue
-        }
-      }
-    }
-    commonPoints.push(point)
-  }
-
-  const allCombos: number[][] = [[]]
-  for (const z of sortedZ) {
-    const withZ = allCombos.map((combo) => [...combo, z])
-    allCombos.push(...withZ)
-  }
-
-  for (const combo of allCombos.filter((c) => c.length > 0)) {
-    const key = `z${combo.join(",")}`
-
-    const layerRects: NonNullable<Rect[]> = [...commonRects]
-    const layerLines: NonNullable<Line[]> = [...commonLines]
-    const layerPoints: NonNullable<Point[]> = [...commonPoints]
-
-    const intersects = (layers: number[]) =>
-      layers.some((layer) => combo.includes(layer))
-
-    for (const { layers, rect } of perLayerRects) {
-      if (intersects(layers)) layerRects.push(rect)
-    }
-    for (const { layers, line } of perLayerLines) {
-      if (intersects(layers)) layerLines.push(line)
-    }
-    for (const { layers, point } of perLayerPoints) {
-      if (intersects(layers)) layerPoints.push(point)
-    }
-
-    result.set(key, {
-      title: `${graphics.title ?? ""} - z${combo.join(",")}`,
-      coordinateSystem: graphics.coordinateSystem,
-      rects: layerRects,
-      lines: layerLines,
-      points: layerPoints,
-    })
-  }
-
-  return result
-}