@tscircuit/rectdiff 0.0.24 → 0.0.25

package/AGENTS.md

@@ -0,0 +1,23 @@
+This is an algorithm solver repo designed to be integrated into the tscircuit
+autorouter.
+
+It uses the SimpleRouteJson type as input (see lib/types/srj-types.ts)
+
+We use svg snapshots to create visual snapshots as our primary method of
+ensuring the algorithm works correctly. We use `export BUN_UPDATE_SNAPSHOTS=1`
+and `bun test path/to/test.test.ts` to update the snapshots.
+
+We use the `graphics-debug` package to turn `GraphicsObject` into SVGs using
+
+```tsx
+import { getSvgFromGraphicsObject } from "graphics-debug"
+```
+
+We use `cosmos` `*.page.tsx` files inside the `pages` directory to create
+examples that can be debugged for a human.
+
+We discovered the algorithm via `experiments/rect3d_visualizer.html` and we're
+now formalizing it into a solver pattern and binding to our normal types.
+
+The `test-assets` directory contains assets for test, typically simple route
+json files with test cases that can be importing into pages or tests.

package/dist/index.d.ts

@@ -242,6 +242,7 @@ declare class RectDiffSeedingSolver extends BaseSolver {
     private candidates;
     private placed;
     private placedIndexByLayer;
+    private hardPlacedByLayer;
     private expansionIndex;
     private edgeAnalysisDone;
     private totalSeedsThisGrid;

package/dist/index.js

@@ -688,24 +688,18 @@ function containsPoint(r, p) {
   return p.x >= r.x - EPS4 && p.x <= r.x + r.width + EPS4 && p.y >= r.y - EPS4 && p.y <= r.y + r.height + EPS4;
 }
 function distancePointToRectEdges(p, r) {
-  const edges = [
-    [r.x, r.y, r.x + r.width, r.y],
-    [r.x + r.width, r.y, r.x + r.width, r.y + r.height],
-    [r.x + r.width, r.y + r.height, r.x, r.y + r.height],
-    [r.x, r.y + r.height, r.x, r.y]
-  ];
-  let best = Infinity;
-  for (const [x1, y1, x2, y2] of edges) {
-    const A = p.x - x1, B = p.y - y1, C = x2 - x1, D = y2 - y1;
-    const dot = A * C + B * D;
-    const lenSq = C * C + D * D;
-    let t = lenSq !== 0 ? dot / lenSq : 0;
-    t = clamp(t, 0, 1);
-    const xx = x1 + t * C;
-    const yy = y1 + t * D;
-    best = Math.min(best, Math.hypot(p.x - xx, p.y - yy));
-  }
-  return best;
+  const minX = r.x;
+  const maxX = r.x + r.width;
+  const minY = r.y;
+  const maxY = r.y + r.height;
+  if (p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY) {
+    return Math.min(p.x - minX, maxX - p.x, p.y - minY, maxY - p.y);
+  }
+  const dx = p.x < minX ? minX - p.x : p.x > maxX ? p.x - maxX : 0;
+  const dy = p.y < minY ? minY - p.y : p.y > maxY ? p.y - maxY : 0;
+  if (dx === 0) return dy;
+  if (dy === 0) return dx;
+  return Math.hypot(dx, dy);
 }
 function intersect1D(r1, r2) {
   const lo = Math.max(r1[0], r2[0]);
@@ -1051,17 +1045,10 @@ function maxExpandUp(params) {
   }
   return Math.max(0, e);
 }
-var toRect = (tree) => ({
-  x: tree.minX,
-  y: tree.minY,
-  width: tree.maxX - tree.minX,
-  height: tree.maxY - tree.minY
-});
 var addBlocker = (params) => {
   const { rect, seen, blockers } = params;
-  const key = `${rect.x}|${rect.y}|${rect.width}|${rect.height}`;
-  if (seen.has(key)) return;
-  seen.add(key);
+  if (seen.has(rect)) return;
+  seen.add(rect);
   blockers.push(rect);
 };
 var toQueryRect = (params) => {
@@ -1098,23 +1085,22 @@ function expandRectFromSeed(params) {
       const blockersIndex = obsticalIndexByLayer[z];
       if (blockersIndex) {
         for (const entry of blockersIndex.search(query))
-          addBlocker({ rect: toRect(entry), seen, blockers });
+          addBlocker({ rect: entry, seen, blockers });
       }
       const placedLayer = placedIndexByLayer[z];
       if (placedLayer) {
         for (const entry of placedLayer.search(query)) {
           const isFullStack = entry.zLayers.length >= totalLayers;
           if (!isFullStack) continue;
-          const rect = toRect(entry);
           if (isSelfRect({
-            rect,
+            rect: entry,
             startX,
             startY,
             initialW,
             initialH
           }))
             continue;
-          addBlocker({ rect, seen, blockers });
+          addBlocker({ rect: entry, seen, blockers });
         }
       }
     }
@@ -1205,9 +1191,9 @@ function isFullyOccupiedAtPoint(params) {
   };
   for (let z = 0; z < params.layerCount; z++) {
     const obstacleIdx = params.obstacleIndexByLayer[z];
-    const hasObstacle = !!obstacleIdx && obstacleIdx.search(query).length > 0;
+    const hasObstacle = !!obstacleIdx && obstacleIdx.collides(query);
     const placedIdx = params.placedIndexByLayer[z];
-    const hasPlaced = !!placedIdx && placedIdx.search(query).length > 0;
+    const hasPlaced = !!placedIdx && placedIdx.collides(query);
     if (!hasObstacle && !hasPlaced) return false;
   }
   return true;
@@ -1233,7 +1219,7 @@ function longestFreeSpanAroundZ(params) {
       maxY: y
     };
     const obstacleIdx = obstacleIndexByLayer[layer];
-    if (obstacleIdx && obstacleIdx.search(query).length > 0) return false;
+    if (obstacleIdx && obstacleIdx.collides(query)) return false;
     const extras = additionalBlockersByLayer?.[layer] ?? [];
     return !extras.some((b) => containsPoint(b, { x, y }));
   };
@@ -1265,6 +1251,10 @@ function computeCandidates3D(params) {
     hardPlacedByLayer
   } = params;
   const out = /* @__PURE__ */ new Map();
+  const hardRectsByLayer = Array.from({ length: layerCount }, (_, z) => [
+    ...obstacleIndexByLayer[z]?.all() ?? [],
+    ...hardPlacedByLayer[z] ?? []
+  ]);
   for (let x = bounds.x; x < bounds.x + bounds.width; x += gridSize) {
     for (let y = bounds.y; y < bounds.y + bounds.height; y += gridSize) {
       if (Math.abs(x - bounds.x) < EPS4 || Math.abs(y - bounds.y) < EPS4 || x > bounds.x + bounds.width - gridSize - EPS4 || y > bounds.y + bounds.height - gridSize - EPS4) {
@@ -1296,14 +1286,11 @@ function computeCandidates3D(params) {
         }
       }
       const anchorZ = bestSpan.length ? bestSpan[Math.floor(bestSpan.length / 2)] : bestZ;
-      const hardAtZ = [
-        ...obstacleIndexByLayer[anchorZ]?.all() ?? [],
-        ...hardPlacedByLayer[anchorZ] ?? []
-      ];
-      const d = Math.min(
-        distancePointToRectEdges({ x, y }, bounds),
-        ...hardAtZ.length ? hardAtZ.map((b) => distancePointToRectEdges({ x, y }, b)) : [Infinity]
-      );
+      const hardAtZ = hardRectsByLayer[anchorZ] ?? [];
+      let d = distancePointToRectEdges({ x, y }, bounds);
+      for (const blocker of hardAtZ) {
+        d = Math.min(d, distancePointToRectEdges({ x, y }, blocker));
+      }
       const distance = quantize2(d);
       const k = `${x.toFixed(6)}|${y.toFixed(6)}`;
       const cand = {
@@ -1328,6 +1315,12 @@ function computeCandidates3D(params) {
 
 // lib/solvers/RectDiffSeedingSolver/computeEdgeCandidates3D.ts
 var quantize3 = (value, precision = 1e-6) => Math.round(value / precision) * precision;
+var toRect = (rect) => "minX" in rect ? {
+  x: rect.minX,
+  y: rect.minY,
+  width: rect.maxX - rect.minX,
+  height: rect.maxY - rect.minY
+} : rect;
 function computeUncoveredSegments(params) {
   const { lineStart, lineEnd, coveringIntervals, minSegmentLength } = params;
   const lineStartQ = quantize3(lineStart);
@@ -1390,6 +1383,13 @@ function computeEdgeCandidates3D(params) {
   const out = [];
   const \u03B4 = Math.max(minSize * 0.15, EPS4 * 3);
   const dedup = /* @__PURE__ */ new Set();
+  const hardRectsByLayer = Array.from(
+    { length: layerCount },
+    (_, z) => [
+      ...obstacleIndexByLayer[z]?.all() ?? [],
+      ...hardPlacedByLayer[z] ?? []
+    ].map(toRect)
+  );
   const key = (p) => `${p.z}|${p.x.toFixed(6)}|${p.y.toFixed(6)}`;
   function fullyOcc(p) {
     return isFullyOccupiedAtPoint({
@@ -1408,19 +1408,11 @@ function computeEdgeCandidates3D(params) {
     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 hard = hardRectsByLayer[z] ?? [];
+    let d = distancePointToRectEdges({ x, y }, bounds);
+    for (const blocker of hard) {
+      d = Math.min(d, distancePointToRectEdges({ x, y }, blocker));
+    }
     const distance = quantize3(d);
     const k = key({ x, y, z });
     if (dedup.has(k)) return;
@@ -1445,10 +1437,7 @@ function computeEdgeCandidates3D(params) {
     });
   }
   for (let z = 0; z < layerCount; z++) {
-    const blockers = [
-      ...obstacleIndexByLayer[z]?.all() ?? [],
-      ...hardPlacedByLayer[z] ?? []
-    ].map((b) => ({
+    const blockers = (hardRectsByLayer[z] ?? []).map((b) => ({
       x: quantize3(b.x),
       y: quantize3(b.y),
       width: quantize3(b.width),
@@ -1746,6 +1735,7 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
   candidates;
   placed;
   placedIndexByLayer;
+  hardPlacedByLayer;
   expansionIndex;
   edgeAnalysisDone;
   totalSeedsThisGrid;
@@ -1801,6 +1791,7 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       { length: layerCount },
       () => new RBush3()
     );
+    this.hardPlacedByLayer = Array.from({ length: layerCount }, () => []);
     this.expansionIndex = 0;
     this.edgeAnalysisDone = false;
     this.totalSeedsThisGrid = 0;
@@ -1829,25 +1820,22 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       maxMultiLayerSpan
     } = this.options;
     const grid = gridSizes[this.gridIndex];
-    const hardPlacedByLayer = allLayerNode({
-      layerCount: this.layerCount,
-      placed: this.placed
-    });
     if (this.candidates.length === 0 && this.consumedSeedsThisGrid === 0) {
       this.candidates = computeCandidates3D({
         bounds: this.bounds,
         gridSize: grid,
         layerCount: this.layerCount,
-        hardPlacedByLayer,
+        hardPlacedByLayer: this.hardPlacedByLayer,
         obstacleIndexByLayer: this.input.obstacleIndexByLayer,
         placedIndexByLayer: this.placedIndexByLayer
       });
       this.totalSeedsThisGrid = this.candidates.length;
       this.consumedSeedsThisGrid = 0;
     }
-    if (this.candidates.length === 0) {
+    if (this.consumedSeedsThisGrid >= this.candidates.length) {
       if (this.gridIndex + 1 < gridSizes.length) {
         this.gridIndex += 1;
+        this.candidates = [];
         this.totalSeedsThisGrid = 0;
         this.consumedSeedsThisGrid = 0;
         return;
@@ -1860,20 +1848,28 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
             layerCount: this.layerCount,
             obstacleIndexByLayer: this.input.obstacleIndexByLayer,
             placedIndexByLayer: this.placedIndexByLayer,
-            hardPlacedByLayer
+            hardPlacedByLayer: this.hardPlacedByLayer
           });
           this.edgeAnalysisDone = true;
           this.totalSeedsThisGrid = this.candidates.length;
           this.consumedSeedsThisGrid = 0;
           return;
         }
+        this.candidates = [];
         this.solved = true;
         this.expansionIndex = 0;
         return;
       }
     }
-    const cand = this.candidates.shift();
-    this.consumedSeedsThisGrid += 1;
+    const cand = this.candidates[this.consumedSeedsThisGrid++];
+    if (isFullyOccupiedAtPoint({
+      layerCount: this.layerCount,
+      obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+      placedIndexByLayer: this.placedIndexByLayer,
+      point: { x: cand.x, y: cand.y }
+    })) {
+      return;
+    }
     const span = longestFreeSpanAroundZ({
       x: cand.x,
       y: cand.y,
@@ -1882,7 +1878,7 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       minSpan: minMulti.minLayers,
       maxSpan: maxMultiLayerSpan,
       obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-      additionalBlockersByLayer: hardPlacedByLayer
+      additionalBlockersByLayer: this.hardPlacedByLayer
     });
     const attempts = [];
     if (span.length >= minMulti.minLayers) {
@@ -1929,14 +1925,10 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
         },
         newIndex
       );
-      this.candidates = this.candidates.filter(
-        (c) => !isFullyOccupiedAtPoint({
-          layerCount: this.layerCount,
-          obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-          placedIndexByLayer: this.placedIndexByLayer,
-          point: { x: c.x, y: c.y }
-        })
-      );
+      this.hardPlacedByLayer = allLayerNode({
+        layerCount: this.layerCount,
+        placed: this.placed
+      });
       return;
     }
   }

package/lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts

@@ -57,6 +57,7 @@ export class RectDiffSeedingSolver extends BaseSolver {
   private candidates!: Candidate3D[]
   private placed!: Placed3D[]
   private placedIndexByLayer!: Array<RBush<RTreeRect>>
+  private hardPlacedByLayer!: XYRect[][]
   private expansionIndex!: number
   private edgeAnalysisDone!: boolean
   private totalSeedsThisGrid!: number
@@ -131,6 +132,7 @@ export class RectDiffSeedingSolver extends BaseSolver {
       { length: layerCount },
       () => new RBush<RTreeRect>(),
     )
+    this.hardPlacedByLayer = Array.from({ length: layerCount }, () => [])
     this.expansionIndex = 0
     this.edgeAnalysisDone = false
     this.totalSeedsThisGrid = 0
@@ -164,19 +166,13 @@ export class RectDiffSeedingSolver extends BaseSolver {
     } = this.options
     const grid = gridSizes[this.gridIndex]!
 
-    // Build hard-placed map once per micro-step (cheap)
-    const hardPlacedByLayer = allLayerNode({
-      layerCount: this.layerCount,
-      placed: this.placed,
-    })
-
     // Ensure candidates exist for this grid
     if (this.candidates.length === 0 && this.consumedSeedsThisGrid === 0) {
       this.candidates = computeCandidates3D({
         bounds: this.bounds,
         gridSize: grid,
         layerCount: this.layerCount,
-        hardPlacedByLayer,
+        hardPlacedByLayer: this.hardPlacedByLayer,
         obstacleIndexByLayer: this.input.obstacleIndexByLayer,
         placedIndexByLayer: this.placedIndexByLayer,
       })
@@ -185,9 +181,10 @@ export class RectDiffSeedingSolver extends BaseSolver {
     }
 
     // If no candidates remain, advance grid or run edge pass or switch phase
-    if (this.candidates.length === 0) {
+    if (this.consumedSeedsThisGrid >= this.candidates.length) {
       if (this.gridIndex + 1 < gridSizes.length) {
         this.gridIndex += 1
+        this.candidates = []
         this.totalSeedsThisGrid = 0
         this.consumedSeedsThisGrid = 0
         return
@@ -200,13 +197,14 @@ export class RectDiffSeedingSolver extends BaseSolver {
             layerCount: this.layerCount,
             obstacleIndexByLayer: this.input.obstacleIndexByLayer,
             placedIndexByLayer: this.placedIndexByLayer,
-            hardPlacedByLayer,
+            hardPlacedByLayer: this.hardPlacedByLayer,
           })
           this.edgeAnalysisDone = true
           this.totalSeedsThisGrid = this.candidates.length
           this.consumedSeedsThisGrid = 0
           return
         }
+        this.candidates = []
         this.solved = true
         this.expansionIndex = 0
         return
@@ -214,8 +212,17 @@ export class RectDiffSeedingSolver extends BaseSolver {
     }
 
     // Consume exactly one candidate
-    const cand = this.candidates.shift()!
-    this.consumedSeedsThisGrid += 1
+    const cand = this.candidates[this.consumedSeedsThisGrid++]!
+    if (
+      isFullyOccupiedAtPoint({
+        layerCount: this.layerCount,
+        obstacleIndexByLayer: this.input.obstacleIndexByLayer,
+        placedIndexByLayer: this.placedIndexByLayer,
+        point: { x: cand.x, y: cand.y },
+      })
+    ) {
+      return
+    }
 
     // Evaluate attempts — multi-layer span first (computed ignoring soft nodes)
     const span = longestFreeSpanAroundZ({
@@ -226,7 +233,7 @@ export class RectDiffSeedingSolver extends BaseSolver {
       minSpan: minMulti.minLayers,
       maxSpan: maxMultiLayerSpan,
       obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-      additionalBlockersByLayer: hardPlacedByLayer,
+      additionalBlockersByLayer: this.hardPlacedByLayer,
     })
 
     const attempts: Array<{
@@ -285,17 +292,10 @@ export class RectDiffSeedingSolver extends BaseSolver {
         },
         newIndex,
       )
-
-      // New: relax candidate culling — only drop seeds that became fully occupied
-      this.candidates = this.candidates.filter(
-        (c) =>
-          !isFullyOccupiedAtPoint({
-            layerCount: this.layerCount,
-            obstacleIndexByLayer: this.input.obstacleIndexByLayer,
-            placedIndexByLayer: this.placedIndexByLayer,
-            point: { x: c.x, y: c.y },
-          }),
-      )
+      this.hardPlacedByLayer = allLayerNode({
+        layerCount: this.layerCount,
+        placed: this.placed,
+      })
 
       return // processed one candidate
     }

package/lib/solvers/RectDiffSeedingSolver/computeCandidates3D.ts

@@ -27,6 +27,10 @@ export function computeCandidates3D(params: {
     hardPlacedByLayer,
   } = params
   const out = new Map<string, Candidate3D>() // key by (x,y)
+  const hardRectsByLayer = Array.from({ length: layerCount }, (_, z) => [
+    ...(obstacleIndexByLayer[z]?.all() ?? []),
+    ...(hardPlacedByLayer[z] ?? []),
+  ])
 
   for (let x = bounds.x; x < bounds.x + bounds.width; x += gridSize) {
     for (let y = bounds.y; y < bounds.y + bounds.height; y += gridSize) {
@@ -75,16 +79,11 @@ export function computeCandidates3D(params: {
         : bestZ
 
       // Distance heuristic against hard blockers only (obstacles + full-stack)
-      const hardAtZ = [
-        ...(obstacleIndexByLayer[anchorZ]?.all() ?? []),
-        ...(hardPlacedByLayer[anchorZ] ?? []),
-      ]
-      const d = Math.min(
-        distancePointToRectEdges({ x, y }, bounds),
-        ...(hardAtZ.length
-          ? hardAtZ.map((b) => distancePointToRectEdges({ x, y }, b))
-          : [Infinity]),
-      )
+      const hardAtZ = hardRectsByLayer[anchorZ] ?? []
+      let d = distancePointToRectEdges({ x, y }, bounds)
+      for (const blocker of hardAtZ) {
+        d = Math.min(d, distancePointToRectEdges({ x, y }, blocker))
+      }
       const distance = quantize(d)
 
       const k = `${x.toFixed(6)}|${y.toFixed(6)}`

package/lib/solvers/RectDiffSeedingSolver/computeEdgeCandidates3D.ts

@@ -7,6 +7,16 @@ import type { RTreeRect } from "lib/types/capacity-mesh-types"
 const quantize = (value: number, precision = 1e-6) =>
   Math.round(value / precision) * precision
 
+const toRect = (rect: XYRect | RTreeRect): XYRect =>
+  "minX" in rect
+    ? {
+        x: rect.minX,
+        y: rect.minY,
+        width: rect.maxX - rect.minX,
+        height: rect.maxY - rect.minY,
+      }
+    : rect
+
 /**
  * Compute exact uncovered segments along a 1D line.
  */
@@ -109,6 +119,12 @@ export function computeEdgeCandidates3D(params: {
   // Use small inset from edges for placement
   const δ = Math.max(minSize * 0.15, EPS * 3)
   const dedup = new Set<string>()
+  const hardRectsByLayer = Array.from({ length: layerCount }, (_, z) =>
+    [
+      ...(obstacleIndexByLayer[z]?.all() ?? []),
+      ...(hardPlacedByLayer[z] ?? []),
+    ].map(toRect),
+  )
   const key = (p: { x: number; y: number; z: number }) =>
     `${p.z}|${p.x.toFixed(6)}|${p.y.toFixed(6)}`
 
@@ -137,21 +153,11 @@ export function computeEdgeCandidates3D(params: {
     if (fullyOcc({ x, y })) return // new rule: only drop if truly impossible
 
     // Distance uses obstacles + hard nodes (soft nodes ignored for ranking)
-    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 hard = hardRectsByLayer[z] ?? []
+    let d = distancePointToRectEdges({ x, y }, bounds)
+    for (const blocker of hard) {
+      d = Math.min(d, distancePointToRectEdges({ x, y }, blocker))
+    }
     const distance = quantize(d)
 
     const k = key({ x, y, z })
@@ -180,10 +186,7 @@ export function computeEdgeCandidates3D(params: {
   }
 
   for (let z = 0; z < layerCount; z++) {
-    const blockers = [
-      ...(obstacleIndexByLayer[z]?.all() ?? []),
-      ...(hardPlacedByLayer[z] ?? []),
-    ].map((b) => ({
+    const blockers = (hardRectsByLayer[z] ?? []).map((b) => ({
       x: quantize(b.x),
       y: quantize(b.y),
       width: quantize(b.width),

package/lib/solvers/RectDiffSeedingSolver/longestFreeSpanAroundZ.ts

@@ -35,7 +35,7 @@ export function longestFreeSpanAroundZ(params: {
       maxY: y,
     }
     const obstacleIdx = obstacleIndexByLayer[layer]
-    if (obstacleIdx && obstacleIdx.search(query).length > 0) return false
+    if (obstacleIdx && obstacleIdx.collides(query)) return false
 
     const extras = additionalBlockersByLayer?.[layer] ?? []
     return !extras.some((b) => containsPoint(b, { x, y }))

package/lib/utils/expandRectFromSeed.ts

@@ -175,14 +175,13 @@ const toRect = (tree: RTreeRect): XYRect => ({
 })
 
 const addBlocker = (params: {
-  rect: XYRect
-  seen: Set<string>
+  rect: RTreeRect
+  seen: Set<RTreeRect>
   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)
+  if (seen.has(rect)) return
+  seen.add(rect)
   blockers.push(rect)
 }
 
@@ -225,7 +224,7 @@ export function expandRectFromSeed(params: {
   const initialW = Math.max(minSide, minReq.width)
   const initialH = Math.max(minSide, minReq.height)
   const blockers: XYRect[] = []
-  const seen = new Set<string>()
+  const seen = new Set<RTreeRect>()
   const totalLayers = placedIndexByLayer.length
 
   // Ignore the existing placement we are expanding so it doesn't self-block.
@@ -237,7 +236,7 @@ export function expandRectFromSeed(params: {
       const blockersIndex = obsticalIndexByLayer[z]
       if (blockersIndex) {
         for (const entry of blockersIndex.search(query))
-          addBlocker({ rect: toRect(entry), seen, blockers })
+          addBlocker({ rect: entry, seen, blockers })
       }
 
       const placedLayer = placedIndexByLayer[z]
@@ -245,10 +244,9 @@ export function expandRectFromSeed(params: {
         for (const entry of placedLayer.search(query)) {
           const isFullStack = entry.zLayers.length >= totalLayers
           if (!isFullStack) continue
-          const rect = toRect(entry)
           if (
             isSelfRect({
-              rect,
+              rect: entry,
               startX,
               startY,
               initialW,
@@ -256,7 +254,7 @@ export function expandRectFromSeed(params: {
             })
           )
             continue
-          addBlocker({ rect, seen, blockers })
+          addBlocker({ rect: entry, seen, blockers })
         }
       }
     }

package/lib/utils/isFullyOccupiedAtPoint.ts

@@ -17,10 +17,10 @@ export function isFullyOccupiedAtPoint(params: OccupancyParams): boolean {
   }
   for (let z = 0; z < params.layerCount; z++) {
     const obstacleIdx = params.obstacleIndexByLayer[z]
-    const hasObstacle = !!obstacleIdx && obstacleIdx.search(query).length > 0
+    const hasObstacle = !!obstacleIdx && obstacleIdx.collides(query)
 
     const placedIdx = params.placedIndexByLayer[z]
-    const hasPlaced = !!placedIdx && placedIdx.search(query).length > 0
+    const hasPlaced = !!placedIdx && placedIdx.collides(query)
 
     if (!hasObstacle && !hasPlaced) return false
   }

package/lib/utils/rectdiff-geometry.ts

@@ -30,27 +30,20 @@ export function distancePointToRectEdges(
   p: { x: number; y: number },
   r: XYRect,
 ) {
-  const edges: [number, number, number, number][] = [
-    [r.x, r.y, r.x + r.width, r.y],
-    [r.x + r.width, r.y, r.x + r.width, r.y + r.height],
-    [r.x + r.width, r.y + r.height, r.x, r.y + r.height],
-    [r.x, r.y + r.height, r.x, r.y],
-  ]
-  let best = Infinity
-  for (const [x1, y1, x2, y2] of edges) {
-    const A = p.x - x1,
-      B = p.y - y1,
-      C = x2 - x1,
-      D = y2 - y1
-    const dot = A * C + B * D
-    const lenSq = C * C + D * D
-    let t = lenSq !== 0 ? dot / lenSq : 0
-    t = clamp(t, 0, 1)
-    const xx = x1 + t * C
-    const yy = y1 + t * D
-    best = Math.min(best, Math.hypot(p.x - xx, p.y - yy))
+  const minX = r.x
+  const maxX = r.x + r.width
+  const minY = r.y
+  const maxY = r.y + r.height
+
+  if (p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY) {
+    return Math.min(p.x - minX, maxX - p.x, p.y - minY, maxY - p.y)
   }
-  return best
+
+  const dx = p.x < minX ? minX - p.x : p.x > maxX ? p.x - maxX : 0
+  const dy = p.y < minY ? minY - p.y : p.y > maxY ? p.y - maxY : 0
+  if (dx === 0) return dy
+  if (dy === 0) return dx
+  return Math.hypot(dx, dy)
 }
 
 /** Find the intersection of two 1D intervals, or null if they don't overlap. */