@tscircuit/rectdiff 0.0.18 → 0.0.20

package/lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts

@@ -3,28 +3,21 @@ import type { GraphicsObject } from "graphics-debug"
 import type { CapacityMeshNode, RTreeRect } from "lib/types/capacity-mesh-types"
 import { expandRectFromSeed } from "../../utils/expandRectFromSeed"
 import { finalizeRects } from "../../utils/finalizeRects"
-import { allLayerNode } from "../../utils/buildHardPlacedByLayer"
 import { resizeSoftOverlaps } from "../../utils/resizeSoftOverlaps"
 import { rectsToMeshNodes } from "./rectsToMeshNodes"
 import type { XYRect, Candidate3D, Placed3D } from "../../rectdiff-types"
 import type { SimpleRouteJson } from "lib/types/srj-types"
-import {
-  buildZIndexMap,
-  obstacleToXYRect,
-  obstacleZs,
-} from "../RectDiffSeedingSolver/layers"
 import RBush from "rbush"
 import { rectToTree } from "../../utils/rectToTree"
 import { sameTreeRect } from "../../utils/sameTreeRect"
 
-export type RectDiffExpansionSolverSnapshot = {
+export type RectDiffExpansionSolverInput = {
   srj: SimpleRouteJson
   layerNames: string[]
   layerCount: number
   bounds: XYRect
   options: {
     gridSizes: number[]
-    // the engine only uses gridSizes here, other options are ignored
     [key: string]: any
   }
   boardVoidRects: XYRect[]
@@ -35,10 +28,6 @@ export type RectDiffExpansionSolverSnapshot = {
   edgeAnalysisDone: boolean
   totalSeedsThisGrid: number
   consumedSeedsThisGrid: number
-}
-
-export type RectDiffExpansionSolverInput = {
-  initialSnapshot: RectDiffExpansionSolverSnapshot
   obstacleIndexByLayer: Array<RBush<RTreeRect>>
 }
 
@@ -49,74 +38,28 @@ export type RectDiffExpansionSolverInput = {
  * and runs the EXPANSION phase, then finalizes to capacity mesh nodes.
  */
 export class RectDiffExpansionSolver extends BaseSolver {
-  // Engine fields (same shape used by rectdiff/engine.ts)
-  private srj!: SimpleRouteJson
-  private layerNames!: string[]
-  private layerCount!: number
-  private bounds!: XYRect
-  private options!: {
-    gridSizes: number[]
-    // the engine only uses gridSizes here, other options are ignored
-    [key: string]: any
-  }
-  private boardVoidRects!: XYRect[]
-  private gridIndex!: number
-  private candidates!: Candidate3D[]
-  private placed!: Placed3D[]
-  private placedIndexByLayer!: Array<RBush<RTreeRect>>
-  private expansionIndex!: number
-  private edgeAnalysisDone!: boolean
-  private totalSeedsThisGrid!: number
-  private consumedSeedsThisGrid!: number
-
-  private _meshNodes: CapacityMeshNode[] = []
-
+  placedIndexByLayer: Array<RBush<RTreeRect>> = []
+  _meshNodes: CapacityMeshNode[] = []
   constructor(private input: RectDiffExpansionSolverInput) {
     super()
-    // Copy engine snapshot fields directly onto this solver instance
-    Object.assign(this, this.input.initialSnapshot)
   }
 
   override _setup() {
     this.stats = {
-      gridIndex: this.gridIndex,
-    }
-
-    if (this.input.obstacleIndexByLayer) {
-    } else {
-      const { zIndexByName } = buildZIndexMap(this.srj)
-      this.input.obstacleIndexByLayer = Array.from(
-        { length: this.layerCount },
-        () => new RBush<RTreeRect>(),
-      )
-      const insertObstacle = (rect: XYRect, z: number) => {
-        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 as any)
-        if (!rect) continue
-        const zLayers =
-          obstacle.zLayers?.length && obstacle.zLayers.length > 0
-            ? obstacle.zLayers
-            : obstacleZs(obstacle as any, zIndexByName)
-        zLayers.forEach((z) => {
-          if (z >= 0 && z < this.layerCount) insertObstacle(rect, z)
-        })
-      }
+      gridIndex: this.input.gridIndex,
     }
 
     this.placedIndexByLayer = Array.from(
-      { length: this.layerCount },
+      { length: this.input.layerCount },
       () => new RBush<RTreeRect>(),
     )
-    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, { zLayers: placement.zLayers }),
+          )
       }
     }
   }
@@ -126,81 +69,71 @@ export class RectDiffExpansionSolver extends BaseSolver {
 
     this._stepExpansion()
 
-    this.stats.gridIndex = this.gridIndex
-    this.stats.placed = this.placed.length
+    this.stats.gridIndex = this.input.gridIndex
+    this.stats.placed = this.input.placed.length
 
-    if (this.expansionIndex >= this.placed.length) {
+    if (this.input.expansionIndex >= this.input.placed.length) {
       this.finalizeIfNeeded()
     }
   }
 
   private _stepExpansion(): void {
-    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,
-    })
-
-    // HARD blockers only: obstacles on p.zLayers + full-stack nodes
-    const hardBlockers: XYRect[] = []
-    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 },
+      zLayers: p.zLayers,
     })
 
     if (expanded) {
       // Update placement + per-layer index (replace old rect object)
-      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) {
-          tree.remove(rectToTree(oldRect), sameTreeRect)
-          tree.insert(rectToTree(expanded))
+          tree.remove(rectToTree(oldRect, { zLayers: p.zLayers }), sameTreeRect)
+          tree.insert(rectToTree(expanded, { zLayers: p.zLayers }))
         }
       }
 
       // Carve overlapped soft neighbors (respect full-stack nodes)
       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
   }
 
   private 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
@@ -208,25 +141,39 @@ export class RectDiffExpansionSolver extends BaseSolver {
 
   computeProgress(): number {
     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)))
   }
 
   override getOutput(): { meshNodes: CapacityMeshNode[] } {
-    if (!this.solved && this._meshNodes.length === 0) {
-      this.finalizeIfNeeded()
-    }
-    return { meshNodes: this._meshNodes }
+    if (this.solved) return { meshNodes: this._meshNodes }
+
+    // Provide a live preview of the placements before finalization so debuggers
+    // can inspect intermediary states without forcing the solver to finish.
+    const previewNodes: CapacityMeshNode[] = 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. */
   override visualize(): GraphicsObject {
     const rects: NonNullable<GraphicsObject["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,

package/lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts

@@ -48,15 +48,30 @@ export class RectDiffGridSolverPipeline extends BasePipelineSolver<RectDiffGridS
     definePipelineStep(
       "rectDiffExpansionSolver",
       RectDiffExpansionSolver,
-      (pipeline: RectDiffGridSolverPipeline) => [
-        {
-          initialSnapshot: {
-            ...pipeline.rectDiffSeedingSolver!.getOutput(),
+      (pipeline: RectDiffGridSolverPipeline) => {
+        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,
           },
-          obstacleIndexByLayer: pipeline.obstacleIndexByLayer,
-        },
-      ],
+        ]
+      },
     ),
   ]
 

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
@@ -238,23 +239,17 @@ export class RectDiffSeedingSolver extends BaseSolver {
     const ordered = preferMultiLayer ? attempts : attempts.reverse()
 
     for (const attempt of ordered) {
-      // HARD blockers only: obstacles on those layers + full-stack nodes
-      const hardBlockers: XYRect[] = []
-      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,
+        zLayers: attempt.layers,
       })
       if (!rect) continue
 
@@ -264,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

@@ -1,5 +1,14 @@
+import type RBush from "rbush"
 import type { XYRect } from "../rectdiff-types"
 import { EPS, gt, gte, lt, lte, overlaps } from "./rectdiff-geometry"
+import type { RTreeRect } from "lib/types/capacity-mesh-types"
+import { isSelfRect } from "./isSelfRect"
+import {
+  searchStripDown,
+  searchStripLeft,
+  searchStripRight,
+  searchStripUp,
+} from "./searchStrip"
 
 type ExpandDirectionParams = {
   r: XYRect
@@ -148,23 +157,55 @@ function maxExpandUp(params: ExpandDirectionParams) {
   return Math.max(0, e)
 }
 
+const toRect = (tree: RTreeRect): XYRect => ({
+  x: tree.minX,
+  y: tree.minY,
+  width: tree.maxX - tree.minX,
+  height: tree.maxY - tree.minY,
+})
+
+const addBlocker = (params: {
+  rect: XYRect
+  seen: Set<string>
+  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)
+  blockers.push(rect)
+}
+
+const toQueryRect = (params: { bounds: XYRect; rect: XYRect }) => {
+  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 + EPS || maxY <= minY + EPS) return null
+  return { minX, minY, maxX, maxY }
+}
+
 /** Grow a rect around a seed point, honoring bounds/blockers/aspect/min sizes. */
 export function expandRectFromSeed(params: {
   startX: number
   startY: number
   gridSize: number
   bounds: XYRect
-  blockers: XYRect[]
+  obsticalIndexByLayer: Array<RBush<RTreeRect>>
+  placedIndexByLayer: Array<RBush<RTreeRect>>
   initialCellRatio: number
   maxAspectRatio: number | null | undefined
   minReq: { width: number; height: number }
+  zLayers: number[]
 }): XYRect | null {
   const {
     startX,
     startY,
     gridSize,
     bounds,
-    blockers,
+    obsticalIndexByLayer,
+    placedIndexByLayer,
     initialCellRatio,
     maxAspectRatio,
     minReq,
@@ -173,6 +214,43 @@ export 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: XYRect[] = []
+  const seen = new Set<string>()
+  const totalLayers = placedIndexByLayer.length
+
+  // Ignore the existing placement we are expanding so it doesn't self-block.
+
+  const collectBlockers = (searchRect: XYRect) => {
+    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 isFullStack = entry.zLayers.length >= totalLayers
+          if (!isFullStack) continue
+          const rect = toRect(entry)
+          if (
+            isSelfRect({
+              rect,
+              startX,
+              startY,
+              initialW,
+              initialH,
+            })
+          )
+            continue
+          addBlocker({ rect, seen, blockers })
+        }
+      }
+    }
+  }
 
   const strategies = [
     { ox: 0, oy: 0 },
@@ -192,6 +270,7 @@ export function expandRectFromSeed(params: {
       width: initialW,
       height: initialH,
     }
+    collectBlockers(r)
 
     // keep initial inside board
     if (
@@ -212,27 +291,35 @@ export function expandRectFromSeed(params: {
       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
       }
     }

package/lib/utils/isSelfRect.ts

@@ -0,0 +1,15 @@
+import type { XYRect } from "lib/rectdiff-types"
+
+const EPS = 1e-9
+
+export const isSelfRect = (params: {
+  rect: XYRect
+  startX: number
+  startY: number
+  initialW: number
+  initialH: number
+}) =>
+  Math.abs(params.rect.x + params.rect.width / 2 - params.startX) < EPS &&
+  Math.abs(params.rect.y + params.rect.height / 2 - params.startY) < EPS &&
+  Math.abs(params.rect.width - params.initialW) < EPS &&
+  Math.abs(params.rect.height - params.initialH) < EPS

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/lib/utils/searchStrip.ts

@@ -0,0 +1,50 @@
+import type { XYRect } from "lib/rectdiff-types"
+
+export const searchStripRight = ({
+  rect,
+  bounds,
+}: {
+  rect: XYRect
+  bounds: XYRect
+}): XYRect => ({
+  x: rect.x,
+  y: rect.y,
+  width: bounds.x + bounds.width - rect.x,
+  height: rect.height,
+})
+export const searchStripDown = ({
+  rect,
+  bounds,
+}: {
+  rect: XYRect
+  bounds: XYRect
+}): XYRect => ({
+  x: rect.x,
+  y: rect.y,
+  width: rect.width,
+  height: bounds.y + bounds.height - rect.y,
+})
+export const searchStripLeft = ({
+  rect,
+  bounds,
+}: {
+  rect: XYRect
+  bounds: XYRect
+}): XYRect => ({
+  x: bounds.x,
+  y: rect.y,
+  width: rect.x - bounds.x,
+  height: rect.height,
+})
+export const searchStripUp = ({
+  rect,
+  bounds,
+}: {
+  rect: XYRect
+  bounds: XYRect
+}): XYRect => ({
+  x: rect.x,
+  y: bounds.y,
+  width: rect.width,
+  height: rect.y - bounds.y,
+})

package/package.json

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