@tscircuit/rectdiff 0.0.19 → 0.0.21

package/.github/workflows/bun-test.yml

@@ -28,4 +28,4 @@ jobs:
         run: bun install
 
       - name: Run tests
-        run: bun test
+        run: bun test --timeout 9999

package/dist/index.d.ts

@@ -113,6 +113,7 @@ type RTreeRect = XYRect & {
     minY: number;
     maxX: number;
     maxY: number;
+    zLayers: number[];
 };
 
 interface SegmentWithAdjacentEmptySpace {

package/dist/index.js

@@ -1063,6 +1063,7 @@ function expandRectFromSeed(params) {
   const initialH = Math.max(minSide, minReq.height);
   const blockers = [];
   const seen = /* @__PURE__ */ new Set();
+  const totalLayers = placedIndexByLayer.length;
   const collectBlockers = (searchRect) => {
     const query = toQueryRect({ bounds, rect: searchRect });
     if (!query) return;
@@ -1075,6 +1076,8 @@ function expandRectFromSeed(params) {
       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,
@@ -1573,6 +1576,16 @@ function allLayerNode(params) {
   return out;
 }
 
+// lib/utils/rectToTree.ts
+var rectToTree = (rect, opts) => ({
+  ...rect,
+  minX: rect.x,
+  minY: rect.y,
+  maxX: rect.x + rect.width,
+  maxY: rect.y + rect.height,
+  zLayers: opts.zLayers
+});
+
 // lib/utils/resizeSoftOverlaps.ts
 function resizeSoftOverlaps(params, newIndex) {
   const newcomer = params.placed[newIndex];
@@ -1607,20 +1620,17 @@ function resizeSoftOverlaps(params, newIndex) {
       }
     }
   }
-  const rectToTree2 = (rect) => ({
-    ...rect,
-    minX: rect.x,
-    minY: rect.y,
-    maxX: rect.x + rect.width,
-    maxY: rect.y + rect.height
-  });
   const sameRect = (a, b) => a.minX === b.minX && a.minY === b.minY && a.maxX === b.maxX && a.maxY === b.maxY;
   removeIdx.sort((a, b) => b - a).forEach((idx) => {
     const rem = params.placed.splice(idx, 1)[0];
     if (params.placedIndexByLayer) {
       for (const z of rem.zLayers) {
         const tree = params.placedIndexByLayer[z];
-        if (tree) tree.remove(rectToTree2(rem.rect), sameRect);
+        if (tree)
+          tree.remove(
+            rectToTree(rem.rect, { zLayers: rem.zLayers }),
+            sameRect
+          );
       }
     }
   });
@@ -1630,13 +1640,7 @@ function resizeSoftOverlaps(params, newIndex) {
       if (params.placedIndexByLayer) {
         const idx = params.placedIndexByLayer[z];
         if (idx) {
-          idx.insert({
-            ...p.rect,
-            minX: p.rect.x,
-            minY: p.rect.y,
-            maxX: p.rect.x + p.rect.width,
-            maxY: p.rect.y + p.rect.height
-          });
+          idx.insert(rectToTree(p.rect, { zLayers: p.zLayers.slice() }));
         }
       }
     }
@@ -1839,13 +1843,7 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
       for (const z of attempt.layers) {
         const idx = this.placedIndexByLayer[z];
         if (idx) {
-          idx.insert({
-            ...rect,
-            minX: rect.x,
-            minY: rect.y,
-            maxX: rect.x + rect.width,
-            maxY: rect.y + rect.height
-          });
+          idx.insert(rectToTree(rect, { zLayers: placed.zLayers }));
         }
       }
       resizeSoftOverlaps(
@@ -2077,15 +2075,6 @@ function rectsToMeshNodes(rects) {
 // lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts
 import RBush4 from "rbush";
 
-// lib/utils/rectToTree.ts
-var rectToTree = (rect) => ({
-  ...rect,
-  minX: rect.x,
-  minY: rect.y,
-  maxX: rect.x + rect.width,
-  maxY: rect.y + rect.height
-});
-
 // lib/utils/sameTreeRect.ts
 var sameTreeRect = (a, b) => a.minX === b.minX && a.minY === b.minY && a.maxX === b.maxX && a.maxY === b.maxY;
 
@@ -2108,7 +2097,10 @@ var RectDiffExpansionSolver = class extends BaseSolver4 {
     for (const placement of this.input.placed) {
       for (const z of placement.zLayers) {
         const placedIndex = this.placedIndexByLayer[z];
-        if (placedIndex) placedIndex.insert(rectToTree(placement.rect));
+        if (placedIndex)
+          placedIndex.insert(
+            rectToTree(placement.rect, { zLayers: placement.zLayers })
+          );
       }
     }
   }
@@ -2146,8 +2138,8 @@ var RectDiffExpansionSolver = class extends BaseSolver4 {
       for (const z of p.zLayers) {
         const tree = this.placedIndexByLayer[z];
         if (tree) {
-          tree.remove(rectToTree(oldRect), sameTreeRect);
-          tree.insert(rectToTree(expanded));
+          tree.remove(rectToTree(oldRect, { zLayers: p.zLayers }), sameTreeRect);
+          tree.insert(rectToTree(expanded, { zLayers: p.zLayers }));
         }
       }
       resizeSoftOverlaps(
@@ -2250,7 +2242,8 @@ var buildObstacleIndexesByLayer = (params) => {
       minX: rect.x,
       minY: rect.y,
       maxX: rect.x + rect.width,
-      maxY: rect.y + rect.height
+      maxY: rect.y + rect.height,
+      zLayers: [z]
     };
     obstacleIndexByLayer[z]?.insert(treeRect);
   };

package/lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts

@@ -56,7 +56,10 @@ export class RectDiffExpansionSolver extends BaseSolver {
     for (const placement of this.input.placed) {
       for (const z of placement.zLayers) {
         const placedIndex = this.placedIndexByLayer[z]
-        if (placedIndex) placedIndex.insert(rectToTree(placement.rect))
+        if (placedIndex)
+          placedIndex.insert(
+            rectToTree(placement.rect, { zLayers: placement.zLayers }),
+          )
       }
     }
   }
@@ -104,8 +107,8 @@ export class RectDiffExpansionSolver extends BaseSolver {
       for (const z of p.zLayers) {
         const tree = this.placedIndexByLayer[z]
         if (tree) {
-          tree.remove(rectToTree(oldRect), sameTreeRect)
-          tree.insert(rectToTree(expanded))
+          tree.remove(rectToTree(oldRect, { zLayers: p.zLayers }), sameTreeRect)
+          tree.insert(rectToTree(expanded, { zLayers: p.zLayers }))
         }
       }
 

package/lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts

@@ -30,12 +30,13 @@ export const buildObstacleIndexesByLayer = (params: {
   )
 
   const insertObstacle = (rect: XYRect, z: number) => {
-    const treeRect = {
+    const treeRect: RTreeRect = {
       ...rect,
       minX: rect.x,
       minY: rect.y,
       maxX: rect.x + rect.width,
       maxY: rect.y + rect.height,
+      zLayers: [z],
     }
     obstacleIndexByLayer[z]?.insert(treeRect)
   }

package/lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts

@@ -21,6 +21,7 @@ import { resizeSoftOverlaps } from "../../utils/resizeSoftOverlaps"
 import { getColorForZLayer } from "lib/utils/getColorForZLayer"
 import RBush from "rbush"
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
+import { rectToTree } from "lib/utils/rectToTree"
 
 export type RectDiffSeedingSolverInput = {
   simpleRouteJson: SimpleRouteJson
@@ -258,13 +259,7 @@ export class RectDiffSeedingSolver extends BaseSolver {
       for (const z of attempt.layers) {
         const idx = this.placedIndexByLayer[z]
         if (idx) {
-          idx.insert({
-            ...rect,
-            minX: rect.x,
-            minY: rect.y,
-            maxX: rect.x + rect.width,
-            maxY: rect.y + rect.height,
-          })
+          idx.insert(rectToTree(rect, { zLayers: placed.zLayers }))
         }
       }
 

package/lib/types/capacity-mesh-types.ts

@@ -39,4 +39,5 @@ export type RTreeRect = XYRect & {
   minY: number
   maxX: number
   maxY: number
+  zLayers: number[]
 }

package/lib/utils/expandRectFromSeed.ts

@@ -216,6 +216,7 @@ export function expandRectFromSeed(params: {
   const initialH = Math.max(minSide, minReq.height)
   const blockers: XYRect[] = []
   const seen = new Set<string>()
+  const totalLayers = placedIndexByLayer.length
 
   // Ignore the existing placement we are expanding so it doesn't self-block.
 
@@ -232,6 +233,8 @@ export function expandRectFromSeed(params: {
       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({

package/lib/utils/rectToTree.ts

@@ -1,10 +1,14 @@
 import type { XYRect } from "lib/rectdiff-types"
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
 
-export const rectToTree = (rect: XYRect): RTreeRect => ({
+export const rectToTree = (
+  rect: XYRect,
+  opts: { zLayers: number[] },
+): RTreeRect => ({
   ...rect,
   minX: rect.x,
   minY: rect.y,
   maxX: rect.x + rect.width,
   maxY: rect.y + rect.height,
+  zLayers: opts.zLayers,
 })

package/lib/utils/resizeSoftOverlaps.ts

@@ -1,7 +1,8 @@
 import type { RTreeRect } from "lib/types/capacity-mesh-types"
-import type { Placed3D, XYRect } from "../rectdiff-types"
+import type { Placed3D } from "../rectdiff-types"
 import { overlaps, subtractRect2D, EPS } from "./rectdiff-geometry"
 import type RBush from "rbush"
+import { rectToTree } from "./rectToTree"
 
 export function resizeSoftOverlaps(
   params: {
@@ -57,13 +58,6 @@ export function resizeSoftOverlaps(
   }
 
   // Remove fully overlapped nodes and keep indexes in sync
-  const rectToTree = (rect: XYRect): RTreeRect => ({
-    ...rect,
-    minX: rect.x,
-    minY: rect.y,
-    maxX: rect.x + rect.width,
-    maxY: rect.y + rect.height,
-  })
   const sameRect = (a: RTreeRect, b: RTreeRect) =>
     a.minX === b.minX &&
     a.minY === b.minY &&
@@ -77,7 +71,11 @@ export function resizeSoftOverlaps(
       if (params.placedIndexByLayer) {
         for (const z of rem.zLayers) {
           const tree = params.placedIndexByLayer[z]
-          if (tree) tree.remove(rectToTree(rem.rect), sameRect)
+          if (tree)
+            tree.remove(
+              rectToTree(rem.rect, { zLayers: rem.zLayers }),
+              sameRect,
+            )
         }
       }
     })
@@ -89,13 +87,7 @@ export function resizeSoftOverlaps(
       if (params.placedIndexByLayer) {
         const idx = params.placedIndexByLayer[z]
         if (idx) {
-          idx.insert({
-            ...p.rect,
-            minX: p.rect.x,
-            minY: p.rect.y,
-            maxX: p.rect.x + p.rect.width,
-            maxY: p.rect.y + p.rect.height,
-          })
+          idx.insert(rectToTree(p.rect, { zLayers: p.zLayers.slice() }))
         }
       }
     }

package/package.json

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