@tscircuit/rectdiff 0.0.17 → 0.0.19

package/dist/index.d.ts

@@ -278,7 +278,7 @@ declare class RectDiffSeedingSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-type RectDiffExpansionSolverSnapshot = {
+type RectDiffExpansionSolverInput = {
     srj: SimpleRouteJson;
     layerNames: string[];
     layerCount: number;
@@ -295,9 +295,6 @@ type RectDiffExpansionSolverSnapshot = {
     edgeAnalysisDone: boolean;
     totalSeedsThisGrid: number;
     consumedSeedsThisGrid: number;
-};
-type RectDiffExpansionSolverInput = {
-    initialSnapshot: RectDiffExpansionSolverSnapshot;
     obstacleIndexByLayer: Array<RBush<RTreeRect>>;
 };
 /**
@@ -308,21 +305,8 @@ type RectDiffExpansionSolverInput = {
  */
 declare class RectDiffExpansionSolver extends BaseSolver {
     private input;
-    private srj;
-    private layerNames;
-    private layerCount;
-    private bounds;
-    private options;
-    private boardVoidRects;
-    private gridIndex;
-    private candidates;
-    private placed;
-    private placedIndexByLayer;
-    private expansionIndex;
-    private edgeAnalysisDone;
-    private totalSeedsThisGrid;
-    private consumedSeedsThisGrid;
-    private _meshNodes;
+    placedIndexByLayer: Array<RBush<RTreeRect>>;
+    _meshNodes: CapacityMeshNode[];
     constructor(input: RectDiffExpansionSolverInput);
     _setup(): void;
     _step(): void;

package/dist/index.js

@@ -897,6 +897,48 @@ function obstacleToXYRect(ob) {
   return { x: ob.center.x - w / 2, y: ob.center.y - h / 2, width: w, height: h };
 }
 
+// lib/utils/isSelfRect.ts
+var EPS5 = 1e-9;
+var isSelfRect = (params) => Math.abs(params.rect.x + params.rect.width / 2 - params.startX) < EPS5 && Math.abs(params.rect.y + params.rect.height / 2 - params.startY) < EPS5 && Math.abs(params.rect.width - params.initialW) < EPS5 && Math.abs(params.rect.height - params.initialH) < EPS5;
+
+// lib/utils/searchStrip.ts
+var searchStripRight = ({
+  rect,
+  bounds
+}) => ({
+  x: rect.x,
+  y: rect.y,
+  width: bounds.x + bounds.width - rect.x,
+  height: rect.height
+});
+var searchStripDown = ({
+  rect,
+  bounds
+}) => ({
+  x: rect.x,
+  y: rect.y,
+  width: rect.width,
+  height: bounds.y + bounds.height - rect.y
+});
+var searchStripLeft = ({
+  rect,
+  bounds
+}) => ({
+  x: bounds.x,
+  y: rect.y,
+  width: rect.x - bounds.x,
+  height: rect.height
+});
+var searchStripUp = ({
+  rect,
+  bounds
+}) => ({
+  x: rect.x,
+  y: bounds.y,
+  width: rect.width,
+  height: rect.y - bounds.y
+});
+
 // lib/utils/expandRectFromSeed.ts
 function maxExpandRight(params) {
   const { r, bounds, blockers, maxAspect } = params;
@@ -982,13 +1024,36 @@ 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);
+  blockers.push(rect);
+};
+var toQueryRect = (params) => {
+  const { bounds, rect } = params;
+  const minX = Math.max(bounds.x, rect.x);
+  const minY = Math.max(bounds.y, rect.y);
+  const maxX = Math.min(bounds.x + bounds.width, rect.x + rect.width);
+  const maxY = Math.min(bounds.y + bounds.height, rect.y + rect.height);
+  if (maxX <= minX + EPS4 || maxY <= minY + EPS4) return null;
+  return { minX, minY, maxX, maxY };
+};
 function expandRectFromSeed(params) {
   const {
     startX,
     startY,
     gridSize,
     bounds,
-    blockers,
+    obsticalIndexByLayer,
+    placedIndexByLayer,
     initialCellRatio,
     maxAspectRatio,
     minReq
@@ -996,6 +1061,34 @@ function expandRectFromSeed(params) {
   const minSide = Math.max(1e-9, gridSize * initialCellRatio);
   const initialW = Math.max(minSide, minReq.width);
   const initialH = Math.max(minSide, minReq.height);
+  const blockers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const collectBlockers = (searchRect) => {
+    const query = toQueryRect({ bounds, rect: searchRect });
+    if (!query) return;
+    for (const z of params.zLayers) {
+      const blockersIndex = obsticalIndexByLayer[z];
+      if (blockersIndex) {
+        for (const entry of blockersIndex.search(query))
+          addBlocker({ rect: toRect(entry), seen, blockers });
+      }
+      const placedLayer = placedIndexByLayer[z];
+      if (placedLayer) {
+        for (const entry of placedLayer.search(query)) {
+          const rect = toRect(entry);
+          if (isSelfRect({
+            rect,
+            startX,
+            startY,
+            initialW,
+            initialH
+          }))
+            continue;
+          addBlocker({ rect, seen, blockers });
+        }
+      }
+    }
+  };
   const strategies = [
     { ox: 0, oy: 0 },
     { ox: -initialW, oy: 0 },
@@ -1012,6 +1105,7 @@ function expandRectFromSeed(params) {
       width: initialW,
       height: initialH
     };
+    collectBlockers(r);
     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;
     }
@@ -1020,24 +1114,32 @@ function expandRectFromSeed(params) {
     while (improved) {
       improved = false;
       const commonParams = { bounds, blockers, maxAspect: maxAspectRatio };
+      collectBlockers(searchStripRight({ rect: r, bounds }));
       const eR = maxExpandRight({ ...commonParams, r });
       if (eR > 0) {
         r = { ...r, width: r.width + eR };
+        collectBlockers(r);
         improved = true;
       }
+      collectBlockers(searchStripDown({ rect: r, bounds }));
       const eD = maxExpandDown({ ...commonParams, r });
       if (eD > 0) {
         r = { ...r, height: r.height + eD };
+        collectBlockers(r);
         improved = true;
       }
+      collectBlockers(searchStripLeft({ rect: r, bounds }));
       const eL = maxExpandLeft({ ...commonParams, r });
       if (eL > 0) {
         r = { x: r.x - eL, y: r.y, width: r.width + eL, height: r.height };
+        collectBlockers(r);
         improved = true;
       }
+      collectBlockers(searchStripUp({ rect: r, bounds }));
       const eU = maxExpandUp({ ...commonParams, r });
       if (eU > 0) {
         r = { x: r.x, y: r.y - eU, width: r.width, height: r.height + eU };
+        collectBlockers(r);
         improved = true;
       }
     }
@@ -1719,21 +1821,17 @@ var RectDiffSeedingSolver = class extends BaseSolver3 {
     });
     const ordered = preferMultiLayer ? attempts : attempts.reverse();
     for (const attempt of ordered) {
-      const hardBlockers = [];
-      for (const z of attempt.layers) {
-        const obstacleLayer = this.input.obstacleIndexByLayer[z];
-        if (obstacleLayer) hardBlockers.push(...obstacleLayer.all());
-        if (hardPlacedByLayer[z]) hardBlockers.push(...hardPlacedByLayer[z]);
-      }
       const rect = expandRectFromSeed({
         startX: cand.x,
         startY: cand.y,
         gridSize: grid,
         bounds: this.bounds,
-        blockers: hardBlockers,
+        obsticalIndexByLayer: this.input.obstacleIndexByLayer,
+        placedIndexByLayer: this.placedIndexByLayer,
         initialCellRatio,
         maxAspectRatio,
-        minReq: attempt.minReq
+        minReq: attempt.minReq,
+        zLayers: attempt.layers
       });
       if (!rect) continue;
       const placed = { rect, zLayers: [...attempt.layers] };
@@ -1996,101 +2094,55 @@ var RectDiffExpansionSolver = class extends BaseSolver4 {
   constructor(input) {
     super();
     this.input = input;
-    Object.assign(this, this.input.initialSnapshot);
   }
-  // Engine fields (same shape used by rectdiff/engine.ts)
-  srj;
-  layerNames;
-  layerCount;
-  bounds;
-  options;
-  boardVoidRects;
-  gridIndex;
-  candidates;
-  placed;
-  placedIndexByLayer;
-  expansionIndex;
-  edgeAnalysisDone;
-  totalSeedsThisGrid;
-  consumedSeedsThisGrid;
+  placedIndexByLayer = [];
   _meshNodes = [];
   _setup() {
     this.stats = {
-      gridIndex: this.gridIndex
+      gridIndex: this.input.gridIndex
     };
-    if (this.input.obstacleIndexByLayer) {
-    } else {
-      const { zIndexByName } = buildZIndexMap(this.srj);
-      this.input.obstacleIndexByLayer = Array.from(
-        { length: this.layerCount },
-        () => new RBush4()
-      );
-      const insertObstacle = (rect, z) => {
-        const tree = this.input.obstacleIndexByLayer[z];
-        if (tree) tree.insert(rectToTree(rect));
-      };
-      for (const voidRect of this.boardVoidRects ?? []) {
-        for (let z = 0; z < this.layerCount; z++) insertObstacle(voidRect, z);
-      }
-      for (const obstacle of this.srj.obstacles ?? []) {
-        const rect = obstacleToXYRect(obstacle);
-        if (!rect) continue;
-        const zLayers = obstacle.zLayers?.length && obstacle.zLayers.length > 0 ? obstacle.zLayers : obstacleZs(obstacle, zIndexByName);
-        zLayers.forEach((z) => {
-          if (z >= 0 && z < this.layerCount) insertObstacle(rect, z);
-        });
-      }
-    }
     this.placedIndexByLayer = Array.from(
-      { length: this.layerCount },
+      { length: this.input.layerCount },
       () => new RBush4()
     );
-    for (const placement of this.placed ?? []) {
+    for (const placement of this.input.placed) {
       for (const z of placement.zLayers) {
-        const tree = this.placedIndexByLayer[z];
-        if (tree) tree.insert(rectToTree(placement.rect));
+        const placedIndex = this.placedIndexByLayer[z];
+        if (placedIndex) placedIndex.insert(rectToTree(placement.rect));
       }
     }
   }
   _step() {
     if (this.solved) return;
     this._stepExpansion();
-    this.stats.gridIndex = this.gridIndex;
-    this.stats.placed = this.placed.length;
-    if (this.expansionIndex >= this.placed.length) {
+    this.stats.gridIndex = this.input.gridIndex;
+    this.stats.placed = this.input.placed.length;
+    if (this.input.expansionIndex >= this.input.placed.length) {
       this.finalizeIfNeeded();
     }
   }
   _stepExpansion() {
-    if (this.expansionIndex >= this.placed.length) {
+    if (this.input.expansionIndex >= this.input.placed.length) {
       return;
     }
-    const idx = this.expansionIndex;
-    const p = this.placed[idx];
-    const lastGrid = this.options.gridSizes[this.options.gridSizes.length - 1];
-    const hardPlacedByLayer = allLayerNode({
-      layerCount: this.layerCount,
-      placed: this.placed
-    });
-    const hardBlockers = [];
-    for (const z of p.zLayers) {
-      const obstacleTree = this.input.obstacleIndexByLayer[z];
-      if (obstacleTree) hardBlockers.push(...obstacleTree.all());
-      hardBlockers.push(...hardPlacedByLayer[z] ?? []);
-    }
+    const idx = this.input.expansionIndex;
+    const p = this.input.placed[idx];
+    const lastGrid = this.input.options.gridSizes[this.input.options.gridSizes.length - 1];
     const oldRect = p.rect;
     const expanded = expandRectFromSeed({
       startX: p.rect.x + p.rect.width / 2,
       startY: p.rect.y + p.rect.height / 2,
       gridSize: lastGrid,
-      bounds: this.bounds,
-      blockers: hardBlockers,
+      bounds: this.input.bounds,
+      obsticalIndexByLayer: this.input.obstacleIndexByLayer,
+      placedIndexByLayer: this.placedIndexByLayer,
       initialCellRatio: 0,
       maxAspectRatio: null,
-      minReq: { width: p.rect.width, height: p.rect.height }
+      minReq: { width: p.rect.width, height: p.rect.height },
+      zLayers: p.zLayers
     });
     if (expanded) {
-      this.placed[idx] = { rect: expanded, zLayers: p.zLayers };
+      this.input.placed[idx] = { rect: expanded, zLayers: p.zLayers };
       for (const z of p.zLayers) {
         const tree = this.placedIndexByLayer[z];
         if (tree) {
@@ -2100,44 +2152,55 @@ var RectDiffExpansionSolver = class extends BaseSolver4 {
       }
       resizeSoftOverlaps(
         {
-          layerCount: this.layerCount,
-          placed: this.placed,
-          options: this.options,
+          layerCount: this.input.layerCount,
+          placed: this.input.placed,
+          options: this.input.options,
           placedIndexByLayer: this.placedIndexByLayer
         },
         idx
       );
     }
-    this.expansionIndex += 1;
+    this.input.expansionIndex += 1;
   }
   finalizeIfNeeded() {
     if (this.solved) return;
     const rects = finalizeRects({
-      placed: this.placed,
-      srj: this.srj,
-      boardVoidRects: this.boardVoidRects
+      placed: this.input.placed,
+      srj: this.input.srj,
+      boardVoidRects: this.input.boardVoidRects
     });
     this._meshNodes = rectsToMeshNodes(rects);
     this.solved = true;
   }
   computeProgress() {
     if (this.solved) return 1;
-    const grids = this.options.gridSizes.length;
+    const grids = this.input.options.gridSizes.length;
     const base = grids / (grids + 1);
-    const denom = Math.max(1, this.placed.length);
-    const frac = denom ? this.expansionIndex / denom : 1;
+    const denom = Math.max(1, this.input.placed.length);
+    const frac = denom ? this.input.expansionIndex / denom : 1;
     return Math.min(0.999, base + frac * (1 / (grids + 1)));
   }
   getOutput() {
-    if (!this.solved && this._meshNodes.length === 0) {
-      this.finalizeIfNeeded();
-    }
-    return { meshNodes: this._meshNodes };
+    if (this.solved) return { meshNodes: this._meshNodes };
+    const previewNodes = this.input.placed.map(
+      (placement, idx) => ({
+        capacityMeshNodeId: `expand-preview-${idx}`,
+        center: {
+          x: placement.rect.x + placement.rect.width / 2,
+          y: placement.rect.y + placement.rect.height / 2
+        },
+        width: placement.rect.width,
+        height: placement.rect.height,
+        availableZ: placement.zLayers.slice(),
+        layer: `z${placement.zLayers.join(",")}`
+      })
+    );
+    return { meshNodes: previewNodes };
   }
   /** Simple visualization of expanded placements. */
   visualize() {
     const rects = [];
-    for (const placement of this.placed ?? []) {
+    for (const placement of this.input.placed ?? []) {
       rects.push({
         center: {
           x: placement.rect.x + placement.rect.width / 2,
@@ -2243,15 +2306,30 @@ var RectDiffGridSolverPipeline = class extends BasePipelineSolver2 {
     definePipelineStep2(
       "rectDiffExpansionSolver",
       RectDiffExpansionSolver,
-      (pipeline) => [
-        {
-          initialSnapshot: {
-            ...pipeline.rectDiffSeedingSolver.getOutput(),
-            boardVoidRects: pipeline.inputProblem.boardVoidRects ?? []
-          },
-          obstacleIndexByLayer: pipeline.obstacleIndexByLayer
+      (pipeline) => {
+        const output = pipeline.rectDiffSeedingSolver?.getOutput();
+        if (!output) {
+          throw new Error("RectDiffSeedingSolver did not produce output");
         }
-      ]
+        return [
+          {
+            srj: pipeline.inputProblem.simpleRouteJson,
+            layerNames: output.layerNames ?? [],
+            boardVoidRects: pipeline.inputProblem.boardVoidRects ?? [],
+            layerCount: pipeline.inputProblem.simpleRouteJson.layerCount,
+            bounds: output.bounds,
+            candidates: output.candidates,
+            consumedSeedsThisGrid: output.placed.length,
+            totalSeedsThisGrid: output.candidates.length,
+            placed: output.placed,
+            edgeAnalysisDone: output.edgeAnalysisDone,
+            gridIndex: output.gridIndex,
+            expansionIndex: output.expansionIndex,
+            obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
+            options: output.options
+          }
+        ];
+      }
     )
   ];
   getConstructorParams() {

package/lib/fixtures/twoNodeExpansionFixture.ts

@@ -0,0 +1,59 @@
+import RBush from "rbush"
+import type { RectDiffExpansionSolverInput } from "../solvers/RectDiffExpansionSolver/RectDiffExpansionSolver"
+import type { SimpleRouteJson } from "../types/srj-types"
+import type { XYRect } from "../rectdiff-types"
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
+
+/**
+ * Builds a minimal RectDiffExpansionSolver snapshot with exactly two nodes
+ * separated by empty space. This keeps the data close to the solver’s real
+ * input shape so we can reuse it for demos/tests that reproduce the gap issue.
+ */
+export const createTwoNodeExpansionInput = (): RectDiffExpansionSolverInput => {
+  const srj: SimpleRouteJson = {
+    bounds: { minX: 0, maxX: 12, minY: 0, maxY: 4 },
+    layerCount: 1,
+    minTraceWidth: 0.2,
+    obstacles: [],
+    connections: [],
+  }
+  const layerCount = srj.layerCount ?? 1
+  const bounds: XYRect = {
+    x: srj.bounds.minX,
+    y: srj.bounds.minY,
+    width: srj.bounds.maxX - srj.bounds.minX,
+    height: srj.bounds.maxY - srj.bounds.minY,
+  }
+
+  const obstacleIndexByLayer = Array.from(
+    { length: layerCount },
+    () => new RBush<RTreeRect>(),
+  )
+  // Start with all-empty obstacle indexes for a "clean" scenario
+
+  return {
+    srj,
+    layerNames: ["top"],
+    layerCount,
+    bounds,
+    options: { gridSizes: [1] },
+    boardVoidRects: [],
+    gridIndex: 0,
+    candidates: [],
+    placed: [
+      {
+        rect: { x: 0.5, y: 0.5, width: 2, height: 3 },
+        zLayers: [0],
+      },
+      {
+        rect: { x: 9.5, y: 0.5, width: 2, height: 3 },
+        zLayers: [0],
+      },
+    ],
+    expansionIndex: 0,
+    edgeAnalysisDone: true,
+    totalSeedsThisGrid: 0,
+    consumedSeedsThisGrid: 0,
+    obstacleIndexByLayer,
+  }
+}