@tscircuit/rectdiff 0.0.1 → 0.0.3

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

@@ -17,7 +17,7 @@ jobs:
       - name: Setup bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.1
 
       - name: Install dependencies
         run: bun install

package/.github/workflows/bun-pver-release.yml

@@ -21,13 +21,13 @@ jobs:
       - name: Setup bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.1
       - uses: actions/setup-node@v3
         with:
           node-version: 20
           registry-url: https://registry.npmjs.org/
       - run: npm install -g pver
-      - run: bun install --frozen-lockfile
+      - run: bun install
       - run: bun run build
       - run: pver release --no-push-main
         env:

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

@@ -22,7 +22,7 @@ jobs:
       - name: Setup bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.1
 
       - name: Install dependencies
         run: bun install

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

@@ -17,7 +17,7 @@ jobs:
       - name: Setup bun
         uses: oven-sh/setup-bun@v2
         with:
-          bun-version: latest
+          bun-version: 1.3.1
 
       - name: Install dependencies
         run: bun i

package/README.md

@@ -3,3 +3,142 @@
 This is a 3D rectangle diffing algorithm made to quickly break apart a circuit board
 into capacity nodes for the purpose of global routing.
 
+[Online Demo](https://rectdiff.tscircuit.com/?fixture=%7B%22path%22%3A%22pages%2Fexample01.page.tsx%22%7D)
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { RectDiffSolver } from "@tscircuit/rectdiff"
+import type { SimpleRouteJson } from "@tscircuit/rectdiff"
+
+// Define your circuit board layout
+const simpleRouteJson: SimpleRouteJson = {
+  bounds: {
+    minX: 0,
+    maxX: 10,
+    minY: 0,
+    maxY: 10,
+  },
+  obstacles: [
+    {
+      type: "rect",
+      layers: ["top"],
+      center: { x: 2.5, y: 2.5 },
+      width: 2,
+      height: 2,
+      connectedTo: [],
+    },
+  ],
+  connections: [],
+  layerCount: 2,
+  minTraceWidth: 0.15,
+}
+
+// Create and run the solver
+const solver = new RectDiffSolver({
+  simpleRouteJson,
+  mode: "grid",
+})
+
+solver.solve()
+
+// Get the capacity mesh nodes
+const output = solver.getOutput()
+console.log(`Generated ${output.meshNodes.length} capacity mesh nodes`)
+
+// Each mesh node contains:
+// - center: { x, y } - center point of the node
+// - width, height - dimensions
+// - availableZ - array of available z-layers (e.g., [0, 1, 2])
+```
+
+### Advanced Configuration with Grid Options
+
+```typescript
+const solver = new RectDiffSolver({
+  simpleRouteJson,
+  mode: "grid",
+  gridOptions: {
+    minSingle: { width: 0.4, height: 0.4 },
+    minMulti: { width: 1.0, height: 1.0, minLayers: 2 },
+    preferMultiLayer: true,
+  },
+})
+
+solver.solve()
+```
+
+### Incremental Solving with Visualization
+
+The solver supports incremental solving for visualization and progress tracking:
+
+```typescript
+const solver = new RectDiffSolver({ simpleRouteJson })
+
+solver.setup()
+
+// Step through the algorithm incrementally
+while (!solver.solved) {
+  solver.step()
+
+  // Get current progress
+  const progress = solver.computeProgress()
+  console.log(`Progress: ${(progress * 100).toFixed(1)}%`)
+
+  // Visualize current state
+  const graphicsObject = solver.visualize()
+  // Use graphicsObject with graphics-debug package
+}
+
+const output = solver.getOutput()
+```
+
+### Working with Results
+
+```typescript
+const output = solver.getOutput()
+
+// Iterate through mesh nodes
+for (const node of output.meshNodes) {
+  console.log(`Node at (${node.center.x}, ${node.center.y})`)
+  console.log(`  Size: ${node.width} x ${node.height}`)
+  console.log(`  Available layers: ${node.availableZ?.join(", ") || "none"}`)
+
+  // Use node for routing decisions
+  if (node.availableZ && node.availableZ.length >= 2) {
+    console.log("  This node spans multiple layers!")
+  }
+}
+```
+
+### API Reference
+
+#### Constructor Options
+
+- `simpleRouteJson` (required): The circuit board layout definition
+
+  - `bounds`: Board boundaries (minX, maxX, minY, maxY)
+  - `obstacles`: Array of rectangular obstacles on the board
+  - `connections`: Connection requirements between points
+  - `layerCount`: Number of layers in the board
+  - `minTraceWidth`: Minimum trace width for routing
+
+- `mode`: "grid" | "exact" (default: "grid")
+
+  - Currently only "grid" mode is implemented
+
+- `gridOptions`: Fine-tune the grid-based expansion algorithm
+  - `minSingle`: Minimum dimensions for single-layer nodes
+  - `minMulti`: Minimum dimensions and layer count for multi-layer nodes
+  - `preferMultiLayer`: Whether to prefer multi-layer spanning nodes
+
+#### Methods
+
+- `setup()`: Initialize the solver
+- `step()`: Execute one iteration step
+- `solve()`: Run solver to completion
+- `computeProgress()`: Get current progress (0.0 to 1.0)
+- `getOutput()`: Get the capacity mesh nodes result
+- `visualize()`: Get GraphicsObject for visualization with graphics-debug

package/dist/index.js

@@ -128,7 +128,12 @@ function expandRectFromSeed(startX, startY, gridSize, bounds, blockers, initialC
   let best = null;
   let bestArea = 0;
   STRATS: for (const s of strategies) {
-    let r = { x: startX + s.ox, y: startY + s.oy, width: initialW, height: initialH };
+    let r = {
+      x: startX + s.ox,
+      y: startY + s.oy,
+      width: initialW,
+      height: initialH
+    };
     if (lt(r.x, bounds.x) || lt(r.y, bounds.y) || gt(r.x + r.width, bounds.x + bounds.width) || gt(r.y + r.height, bounds.y + bounds.height)) {
       continue;
     }
@@ -213,7 +218,14 @@ function computeCandidates3D(bounds, gridSize, layerCount, obstaclesByLayer, pla
       if (Math.abs(x - bounds.x) < EPS || Math.abs(y - bounds.y) < EPS || x > bounds.x + bounds.width - gridSize - EPS || y > bounds.y + bounds.height - gridSize - EPS) {
         continue;
       }
-      if (isFullyOccupiedAllLayers(x, y, layerCount, obstaclesByLayer, placedByLayer)) continue;
+      if (isFullyOccupiedAllLayers(
+        x,
+        y,
+        layerCount,
+        obstaclesByLayer,
+        placedByLayer
+      ))
+        continue;
       let bestSpan = [];
       let bestZ = 0;
       for (let z = 0; z < layerCount; z++) {
@@ -263,7 +275,10 @@ function computeCandidates3D(bounds, gridSize, layerCount, obstaclesByLayer, pla
 }
 function longestFreeSpanAroundZ(x, y, z, layerCount, minSpan, maxSpan, obstaclesByLayer, placedByLayer) {
   const isFreeAt = (layer) => {
-    const blockers = [...obstaclesByLayer[layer] ?? [], ...placedByLayer[layer] ?? []];
+    const blockers = [
+      ...obstaclesByLayer[layer] ?? [],
+      ...placedByLayer[layer] ?? []
+    ];
     return !blockers.some((b) => containsPoint(b, x, y));
   };
   let lo = z;
@@ -333,10 +348,17 @@ function computeEdgeCandidates3D(bounds, minSize, layerCount, obstaclesByLayer,
   const dedup = /* @__PURE__ */ new Set();
   const key = (x, y, z) => `${z}|${x.toFixed(6)}|${y.toFixed(6)}`;
   function fullyOcc(x, y) {
-    return isFullyOccupiedAllLayers(x, y, layerCount, obstaclesByLayer, placedByLayer);
+    return isFullyOccupiedAllLayers(
+      x,
+      y,
+      layerCount,
+      obstaclesByLayer,
+      placedByLayer
+    );
   }
   function pushIfFree(x, y, z) {
-    if (x < bounds.x + EPS || y < bounds.y + EPS || x > bounds.x + bounds.width - EPS || y > bounds.y + bounds.height - EPS) return;
+    if (x < bounds.x + EPS || y < bounds.y + EPS || x > bounds.x + bounds.width - EPS || y > bounds.y + bounds.height - EPS)
+      return;
     if (fullyOcc(x, y)) return;
     const hard = [
       ...obstaclesByLayer[z] ?? [],
@@ -349,11 +371,23 @@ function computeEdgeCandidates3D(bounds, minSize, layerCount, obstaclesByLayer,
     const k = key(x, y, z);
     if (dedup.has(k)) return;
     dedup.add(k);
-    const span = longestFreeSpanAroundZ(x, y, z, layerCount, 1, void 0, obstaclesByLayer, hardPlacedByLayer);
+    const span = longestFreeSpanAroundZ(
+      x,
+      y,
+      z,
+      layerCount,
+      1,
+      void 0,
+      obstaclesByLayer,
+      hardPlacedByLayer
+    );
     out.push({ x, y, z, distance: d, zSpanLen: span.length, isEdgeSeed: true });
   }
   for (let z = 0; z < layerCount; z++) {
-    const blockers = [...obstaclesByLayer[z] ?? [], ...hardPlacedByLayer[z] ?? []];
+    const blockers = [
+      ...obstaclesByLayer[z] ?? [],
+      ...hardPlacedByLayer[z] ?? []
+    ];
     const corners = [
       { x: bounds.x + \u03B4, y: bounds.y + \u03B4 },
       // top-left
@@ -368,8 +402,16 @@ function computeEdgeCandidates3D(bounds, minSize, layerCount, obstaclesByLayer,
       pushIfFree(corner.x, corner.y, z);
     }
     const topY = bounds.y + \u03B4;
-    const topCovering = blockers.filter((b) => b.y <= topY && b.y + b.height >= topY).map((b) => ({ start: Math.max(bounds.x, b.x), end: Math.min(bounds.x + bounds.width, b.x + b.width) }));
-    const topUncovered = computeUncoveredSegments(bounds.x + \u03B4, bounds.x + bounds.width - \u03B4, topCovering, minSize * 0.5);
+    const topCovering = blockers.filter((b) => b.y <= topY && b.y + b.height >= topY).map((b) => ({
+      start: Math.max(bounds.x, b.x),
+      end: Math.min(bounds.x + bounds.width, b.x + b.width)
+    }));
+    const topUncovered = computeUncoveredSegments(
+      bounds.x + \u03B4,
+      bounds.x + bounds.width - \u03B4,
+      topCovering,
+      minSize * 0.5
+    );
     for (const seg of topUncovered) {
       const segLen = seg.end - seg.start;
       if (segLen >= minSize) {
@@ -381,8 +423,16 @@ function computeEdgeCandidates3D(bounds, minSize, layerCount, obstaclesByLayer,
       }
     }
     const bottomY = bounds.y + bounds.height - \u03B4;
-    const bottomCovering = blockers.filter((b) => b.y <= bottomY && b.y + b.height >= bottomY).map((b) => ({ start: Math.max(bounds.x, b.x), end: Math.min(bounds.x + bounds.width, b.x + b.width) }));
-    const bottomUncovered = computeUncoveredSegments(bounds.x + \u03B4, bounds.x + bounds.width - \u03B4, bottomCovering, minSize * 0.5);
+    const bottomCovering = blockers.filter((b) => b.y <= bottomY && b.y + b.height >= bottomY).map((b) => ({
+      start: Math.max(bounds.x, b.x),
+      end: Math.min(bounds.x + bounds.width, b.x + b.width)
+    }));
+    const bottomUncovered = computeUncoveredSegments(
+      bounds.x + \u03B4,
+      bounds.x + bounds.width - \u03B4,
+      bottomCovering,
+      minSize * 0.5
+    );
     for (const seg of bottomUncovered) {
       const segLen = seg.end - seg.start;
       if (segLen >= minSize) {
@@ -394,8 +444,16 @@ function computeEdgeCandidates3D(bounds, minSize, layerCount, obstaclesByLayer,
       }
     }
     const leftX = bounds.x + \u03B4;
-    const leftCovering = blockers.filter((b) => b.x <= leftX && b.x + b.width >= leftX).map((b) => ({ start: Math.max(bounds.y, b.y), end: Math.min(bounds.y + bounds.height, b.y + b.height) }));
-    const leftUncovered = computeUncoveredSegments(bounds.y + \u03B4, bounds.y + bounds.height - \u03B4, leftCovering, minSize * 0.5);
+    const leftCovering = blockers.filter((b) => b.x <= leftX && b.x + b.width >= leftX).map((b) => ({
+      start: Math.max(bounds.y, b.y),
+      end: Math.min(bounds.y + bounds.height, b.y + b.height)
+    }));
+    const leftUncovered = computeUncoveredSegments(
+      bounds.y + \u03B4,
+      bounds.y + bounds.height - \u03B4,
+      leftCovering,
+      minSize * 0.5
+    );
     for (const seg of leftUncovered) {
       const segLen = seg.end - seg.start;
       if (segLen >= minSize) {
@@ -407,8 +465,16 @@ function computeEdgeCandidates3D(bounds, minSize, layerCount, obstaclesByLayer,
       }
     }
     const rightX = bounds.x + bounds.width - \u03B4;
-    const rightCovering = blockers.filter((b) => b.x <= rightX && b.x + b.width >= rightX).map((b) => ({ start: Math.max(bounds.y, b.y), end: Math.min(bounds.y + bounds.height, b.y + b.height) }));
-    const rightUncovered = computeUncoveredSegments(bounds.y + \u03B4, bounds.y + bounds.height - \u03B4, rightCovering, minSize * 0.5);
+    const rightCovering = blockers.filter((b) => b.x <= rightX && b.x + b.width >= rightX).map((b) => ({
+      start: Math.max(bounds.y, b.y),
+      end: Math.min(bounds.y + bounds.height, b.y + b.height)
+    }));
+    const rightUncovered = computeUncoveredSegments(
+      bounds.y + \u03B4,
+      bounds.y + bounds.height - \u03B4,
+      rightCovering,
+      minSize * 0.5
+    );
     for (const seg of rightUncovered) {
       const segLen = seg.end - seg.start;
       if (segLen >= minSize) {
@@ -422,32 +488,72 @@ function computeEdgeCandidates3D(bounds, minSize, layerCount, obstaclesByLayer,
     for (const b of blockers) {
       const obLeftX = b.x - \u03B4;
       if (obLeftX > bounds.x + EPS && obLeftX < bounds.x + bounds.width - EPS) {
-        const obLeftCovering = blockers.filter((bl) => bl !== b && bl.x <= obLeftX && bl.x + bl.width >= obLeftX).map((bl) => ({ start: Math.max(b.y, bl.y), end: Math.min(b.y + b.height, bl.y + bl.height) }));
-        const obLeftUncovered = computeUncoveredSegments(b.y, b.y + b.height, obLeftCovering, minSize * 0.5);
+        const obLeftCovering = blockers.filter(
+          (bl) => bl !== b && bl.x <= obLeftX && bl.x + bl.width >= obLeftX
+        ).map((bl) => ({
+          start: Math.max(b.y, bl.y),
+          end: Math.min(b.y + b.height, bl.y + bl.height)
+        }));
+        const obLeftUncovered = computeUncoveredSegments(
+          b.y,
+          b.y + b.height,
+          obLeftCovering,
+          minSize * 0.5
+        );
         for (const seg of obLeftUncovered) {
           pushIfFree(obLeftX, seg.center, z);
         }
       }
       const obRightX = b.x + b.width + \u03B4;
       if (obRightX > bounds.x + EPS && obRightX < bounds.x + bounds.width - EPS) {
-        const obRightCovering = blockers.filter((bl) => bl !== b && bl.x <= obRightX && bl.x + bl.width >= obRightX).map((bl) => ({ start: Math.max(b.y, bl.y), end: Math.min(b.y + b.height, bl.y + bl.height) }));
-        const obRightUncovered = computeUncoveredSegments(b.y, b.y + b.height, obRightCovering, minSize * 0.5);
+        const obRightCovering = blockers.filter(
+          (bl) => bl !== b && bl.x <= obRightX && bl.x + bl.width >= obRightX
+        ).map((bl) => ({
+          start: Math.max(b.y, bl.y),
+          end: Math.min(b.y + b.height, bl.y + bl.height)
+        }));
+        const obRightUncovered = computeUncoveredSegments(
+          b.y,
+          b.y + b.height,
+          obRightCovering,
+          minSize * 0.5
+        );
         for (const seg of obRightUncovered) {
           pushIfFree(obRightX, seg.center, z);
         }
       }
       const obTopY = b.y - \u03B4;
       if (obTopY > bounds.y + EPS && obTopY < bounds.y + bounds.height - EPS) {
-        const obTopCovering = blockers.filter((bl) => bl !== b && bl.y <= obTopY && bl.y + bl.height >= obTopY).map((bl) => ({ start: Math.max(b.x, bl.x), end: Math.min(b.x + b.width, bl.x + bl.width) }));
-        const obTopUncovered = computeUncoveredSegments(b.x, b.x + b.width, obTopCovering, minSize * 0.5);
+        const obTopCovering = blockers.filter(
+          (bl) => bl !== b && bl.y <= obTopY && bl.y + bl.height >= obTopY
+        ).map((bl) => ({
+          start: Math.max(b.x, bl.x),
+          end: Math.min(b.x + b.width, bl.x + bl.width)
+        }));
+        const obTopUncovered = computeUncoveredSegments(
+          b.x,
+          b.x + b.width,
+          obTopCovering,
+          minSize * 0.5
+        );
         for (const seg of obTopUncovered) {
           pushIfFree(seg.center, obTopY, z);
         }
       }
       const obBottomY = b.y + b.height + \u03B4;
       if (obBottomY > bounds.y + EPS && obBottomY < bounds.y + bounds.height - EPS) {
-        const obBottomCovering = blockers.filter((bl) => bl !== b && bl.y <= obBottomY && bl.y + bl.height >= obBottomY).map((bl) => ({ start: Math.max(b.x, bl.x), end: Math.min(b.x + b.width, bl.x + bl.width) }));
-        const obBottomUncovered = computeUncoveredSegments(b.x, b.x + b.width, obBottomCovering, minSize * 0.5);
+        const obBottomCovering = blockers.filter(
+          (bl) => bl !== b && bl.y <= obBottomY && bl.y + bl.height >= obBottomY
+        ).map((bl) => ({
+          start: Math.max(b.x, bl.x),
+          end: Math.min(b.x + b.width, bl.x + bl.width)
+        }));
+        const obBottomUncovered = computeUncoveredSegments(
+          b.x,
+          b.x + b.width,
+          obBottomCovering,
+          minSize * 0.5
+        );
         for (const seg of obBottomUncovered) {
           pushIfFree(seg.center, obBottomY, z);
         }
@@ -476,19 +582,54 @@ function canonicalizeLayerOrder(names) {
   });
 }
 function buildZIndexMap(srj) {
-  const names = canonicalizeLayerOrder((srj.obstacles ?? []).flatMap((o) => o.layers ?? []));
+  const names = canonicalizeLayerOrder(
+    (srj.obstacles ?? []).flatMap((o) => o.layers ?? [])
+  );
+  const declaredLayerCount = Math.max(1, srj.layerCount || names.length || 1);
   const fallback = Array.from(
-    { length: Math.max(1, srj.layerCount || 1) },
-    (_, i) => i === 0 ? "top" : i === (srj.layerCount || 1) - 1 ? "bottom" : `inner${i}`
+    { length: declaredLayerCount },
+    (_, i) => i === 0 ? "top" : i === declaredLayerCount - 1 ? "bottom" : `inner${i}`
   );
-  const layerNames = names.length ? names : fallback;
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (n) => {
+    const key = n.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    ordered.push(n);
+  };
+  fallback.forEach(push);
+  names.forEach(push);
+  const layerNames = ordered.slice(0, declaredLayerCount);
+  const clampIndex = (nameLower) => {
+    if (layerNames.length <= 1) return 0;
+    if (nameLower === "top") return 0;
+    if (nameLower === "bottom") return layerNames.length - 1;
+    const m = /^inner(\d+)$/i.exec(nameLower);
+    if (m) {
+      if (layerNames.length <= 2) return layerNames.length - 1;
+      const parsed = parseInt(m[1], 10);
+      const maxInner = layerNames.length - 2;
+      const clampedInner = Math.min(
+        maxInner,
+        Math.max(1, Number.isFinite(parsed) ? parsed : 1)
+      );
+      return clampedInner;
+    }
+    return 0;
+  };
   const map = /* @__PURE__ */ new Map();
-  layerNames.forEach((n, i) => map.set(n, i));
+  layerNames.forEach((n, i) => map.set(n.toLowerCase(), i));
+  ordered.slice(layerNames.length).forEach((n) => {
+    const key = n.toLowerCase();
+    map.set(key, clampIndex(key));
+  });
   return { layerNames, zIndexByName: map };
 }
 function obstacleZs(ob, zIndexByName) {
-  if (ob.zLayers?.length) return Array.from(new Set(ob.zLayers)).sort((a, b) => a - b);
-  const fromNames = (ob.layers ?? []).map((n) => zIndexByName.get(n)).filter((v) => typeof v === "number");
+  if (ob.zLayers?.length)
+    return Array.from(new Set(ob.zLayers)).sort((a, b) => a - b);
+  const fromNames = (ob.layers ?? []).map((n) => zIndexByName.get(n.toLowerCase())).filter((v) => typeof v === "number");
   return Array.from(new Set(fromNames)).sort((a, b) => a - b);
 }
 function obstacleToXYRect(ob) {
@@ -508,12 +649,24 @@ function initState(srj, opts) {
     width: srj.bounds.maxX - srj.bounds.minX,
     height: srj.bounds.maxY - srj.bounds.minY
   };
-  const obstaclesByLayer = Array.from({ length: layerCount }, () => []);
+  const obstaclesByLayer = Array.from(
+    { length: layerCount },
+    () => []
+  );
   for (const ob of srj.obstacles ?? []) {
     const r = obstacleToXYRect(ob);
     if (!r) continue;
     const zs = obstacleZs(ob, zIndexByName);
-    for (const z of zs) if (z >= 0 && z < layerCount) obstaclesByLayer[z].push(r);
+    const invalidZs = zs.filter((z) => z < 0 || z >= layerCount);
+    if (invalidZs.length) {
+      throw new Error(
+        `RectDiffSolver: obstacle uses z-layer indices ${invalidZs.join(
+          ","
+        )} outside 0-${layerCount - 1}`
+      );
+    }
+    if ((!ob.zLayers || ob.zLayers.length === 0) && zs.length) ob.zLayers = zs;
+    for (const z of zs) obstaclesByLayer[z].push(r);
   }
   const trace = Math.max(0.01, srj.minTraceWidth || 0.15);
   const defaults = {
@@ -529,7 +682,11 @@ function initState(srj, opts) {
     preferMultiLayer: true,
     maxMultiLayerSpan: void 0
   };
-  const options = { ...defaults, ...opts, gridSizes: opts.gridSizes ?? defaults.gridSizes };
+  const options = {
+    ...defaults,
+    ...opts,
+    gridSizes: opts.gridSizes ?? defaults.gridSizes
+  };
   const placedByLayer = Array.from({ length: layerCount }, () => []);
   return {
     srj,
@@ -586,8 +743,14 @@ function resizeSoftOverlaps(state, newIndex) {
     if (unaffectedZ.length > 0) {
       toAdd.push({ rect: old.rect, zLayers: unaffectedZ });
     }
-    const minW = Math.min(state.options.minSingle.width, state.options.minMulti.width);
-    const minH = Math.min(state.options.minSingle.height, state.options.minMulti.height);
+    const minW = Math.min(
+      state.options.minSingle.width,
+      state.options.minMulti.width
+    );
+    const minH = Math.min(
+      state.options.minSingle.height,
+      state.options.minMulti.height
+    );
     for (const p of parts) {
       if (p.width + EPS >= minW && p.height + EPS >= minH) {
         toAdd.push({ rect: p, zLayers: sharedZ.slice() });
@@ -676,14 +839,23 @@ function stepGrid(state) {
   );
   const attempts = [];
   if (span.length >= minMulti.minLayers) {
-    attempts.push({ kind: "multi", layers: span, minReq: { width: minMulti.width, height: minMulti.height } });
+    attempts.push({
+      kind: "multi",
+      layers: span,
+      minReq: { width: minMulti.width, height: minMulti.height }
+    });
   }
-  attempts.push({ kind: "single", layers: [cand.z], minReq: { width: minSingle.width, height: minSingle.height } });
+  attempts.push({
+    kind: "single",
+    layers: [cand.z],
+    minReq: { width: minSingle.width, height: minSingle.height }
+  });
   const ordered = preferMultiLayer ? attempts : attempts.reverse();
   for (const attempt of ordered) {
     const hardBlockers = [];
     for (const z of attempt.layers) {
-      if (state.obstaclesByLayer[z]) hardBlockers.push(...state.obstaclesByLayer[z]);
+      if (state.obstaclesByLayer[z])
+        hardBlockers.push(...state.obstaclesByLayer[z]);
       if (hardPlacedByLayer[z]) hardBlockers.push(...hardPlacedByLayer[z]);
     }
     const rect = expandRectFromSeed(
@@ -702,7 +874,9 @@ function stepGrid(state) {
     const newIndex = state.placed.push(placed) - 1;
     for (const z of attempt.layers) state.placedByLayer[z].push(rect);
     resizeSoftOverlaps(state, newIndex);
-    state.candidates = state.candidates.filter((c) => !isFullyOccupiedAtPoint(state, c.x, c.y));
+    state.candidates = state.candidates.filter(
+      (c) => !isFullyOccupiedAtPoint(state, c.x, c.y)
+    );
     return;
   }
 }
@@ -745,13 +919,32 @@ function stepExpansion(state) {
   state.expansionIndex += 1;
 }
 function finalizeRects(state) {
-  return state.placed.map((p) => ({
+  const out = state.placed.map((p) => ({
     minX: p.rect.x,
     minY: p.rect.y,
     maxX: p.rect.x + p.rect.width,
     maxY: p.rect.y + p.rect.height,
     zLayers: [...p.zLayers].sort((a, b) => a - b)
   }));
+  const layersByObstacleRect = /* @__PURE__ */ new Map();
+  state.obstaclesByLayer.forEach((layerObs, z) => {
+    for (const rect of layerObs) {
+      const layerIndices = layersByObstacleRect.get(rect) ?? [];
+      layerIndices.push(z);
+      layersByObstacleRect.set(rect, layerIndices);
+    }
+  });
+  for (const [rect, layerIndices] of layersByObstacleRect.entries()) {
+    out.push({
+      minX: rect.x,
+      minY: rect.y,
+      maxX: rect.x + rect.width,
+      maxY: rect.y + rect.height,
+      zLayers: layerIndices.sort((a, b) => a - b),
+      isObstacle: true
+    });
+  }
+  return out;
 }
 function computeProgress(state) {
   const grids = state.options.gridSizes.length;
@@ -785,7 +978,9 @@ function rectsToMeshNodes(rects) {
       width: w,
       height: h,
       layer: "top",
-      availableZ: r.zLayers.slice()
+      availableZ: r.zLayers.slice(),
+      _containsObstacle: r.isObstacle,
+      _containsTarget: r.isObstacle
     });
   }
   return out;
@@ -898,7 +1093,10 @@ var RectDiffSolver = class extends BaseSolver {
       for (const p of this.state.placed) {
         const colors = this.getColorForZLayer(p.zLayers);
         rects.push({
-          center: { x: p.rect.x + p.rect.width / 2, y: p.rect.y + p.rect.height / 2 },
+          center: {
+            x: p.rect.x + p.rect.width / 2,
+            y: p.rect.y + p.rect.height / 2
+          },
           width: p.rect.width,
           height: p.rect.height,
           fill: colors.fill,

package/global.d.ts

@@ -1,4 +1,4 @@
 declare module "*.json" {
-  const value: any;
-  export default value;
+  const value: any
+  export default value
 }