@tscircuit/rectdiff 0.0.33 → 0.0.35

package/components/SolverDebugger3d.tsx

@@ -2,6 +2,7 @@ import React, { useCallback, useEffect, useMemo, useRef, useState } from "react"
 import { GenericSolverDebugger } from "@tscircuit/solver-utils/react"
 import type { SimpleRouteJson } from "../lib/types/srj-types"
 import type { CapacityMeshNode } from "../lib/types/capacity-mesh-types"
+import { matchesExactZFilter, parseZFilterInput } from "../lib/utils/z-filter"
 import * as THREE from "three"
 import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js"
 import type { BaseSolver } from "@tscircuit/solver-utils"
@@ -168,6 +169,7 @@ const ThreeBoardView: React.FC<{
   shrinkBoxes: boolean
   boxShrinkAmount: number
   showBorders: boolean
+  selectedZValues: number[] | null
 }> = ({
   nodes,
   srj,
@@ -181,6 +183,7 @@ const ThreeBoardView: React.FC<{
   shrinkBoxes,
   boxShrinkAmount,
   showBorders,
+  selectedZValues,
 }) => {
   const containerRef = useRef<HTMLDivElement>(null)
   const destroyRef = useRef<() => void>(() => {})
@@ -203,9 +206,17 @@ const ThreeBoardView: React.FC<{
 
   const layerCount = layerNames.length || srj?.layerCount || 1
 
-  const prisms = useMemo(
-    () => buildPrismsFromNodes(nodes, layerCount),
-    [nodes, layerCount],
+  const filteredNodes = useMemo(
+    () =>
+      nodes.filter((node) =>
+        matchesExactZFilter(node.availableZ ?? [], selectedZValues),
+      ),
+    [nodes, selectedZValues],
+  )
+
+  const filteredPrisms = useMemo(
+    () => buildPrismsFromNodes(filteredNodes, layerCount),
+    [filteredNodes, layerCount],
   )
 
   useEffect(() => {
@@ -372,6 +383,8 @@ const ThreeBoardView: React.FC<{
                   .map((name) => zIndexByLayerName.get(name))
                   .filter((z): z is number => typeof z === "number")
 
+          if (!matchesExactZFilter(zs, selectedZValues)) continue
+
           for (const z of zs) {
             if (z < 0 || z >= layerCount) continue
             obstaclesGroup.add(
@@ -389,7 +402,7 @@ const ThreeBoardView: React.FC<{
 
       // Output prisms from nodes (wireframe toggle like the experiment)
       if (showOutput) {
-        for (const p of prisms) {
+        for (const p of filteredPrisms) {
           let box = p
           if (shrinkBoxes && boxShrinkAmount > 0) {
             const s = boxShrinkAmount
@@ -442,7 +455,7 @@ const ThreeBoardView: React.FC<{
             z1: layerCount,
           }
         : (() => {
-            if (prisms.length === 0) {
+            if (filteredPrisms.length === 0) {
               return {
                 minX: -10,
                 maxX: 10,
@@ -456,7 +469,7 @@ const ThreeBoardView: React.FC<{
               minY = Infinity,
               maxX = -Infinity,
               maxY = -Infinity
-            for (const p of prisms) {
+            for (const p of filteredPrisms) {
               minX = Math.min(minX, p.minX)
               maxX = Math.max(maxX, p.maxX)
               minY = Math.min(minY, p.minY)
@@ -517,7 +530,7 @@ const ThreeBoardView: React.FC<{
     }
   }, [
     srj,
-    prisms,
+    filteredPrisms,
     layerCount,
     layerThickness,
     height,
@@ -530,6 +543,7 @@ const ThreeBoardView: React.FC<{
     shrinkBoxes,
     boxShrinkAmount,
     showBorders,
+    selectedZValues,
   ])
 
   return (
@@ -572,10 +586,18 @@ export const SolverDebugger3d: React.FC<SolverDebugger3dProps> = ({
   const [shrinkBoxes, setShrinkBoxes] = useState(true)
   const [boxShrinkAmount, setBoxShrinkAmount] = useState(0.1)
   const [showBorders, setShowBorders] = useState(true)
+  const [zFilterInput, setZFilterInput] = useState("")
 
   // Mesh nodes state - updated when solver completes or during stepping
   const [meshNodes, setMeshNodes] = useState<CapacityMeshNode[]>([])
 
+  const selectedZValues = useMemo(
+    () => parseZFilterInput(zFilterInput),
+    [zFilterInput],
+  )
+  const hasInvalidZFilter =
+    zFilterInput.trim().length > 0 && selectedZValues === null
+
   // Update mesh nodes from solver output
   const updateMeshNodes = useCallback(() => {
     try {
@@ -601,11 +623,16 @@ export const SolverDebugger3d: React.FC<SolverDebugger3dProps> = ({
   // Poll for updates during stepping (GenericSolverDebugger doesn't have onStep)
   useEffect(() => {
     const interval = setInterval(() => {
-      // Only update if solver has output available
-      if (solver.solved || solver.stats?.placed > 0) {
+      if (solver.solved) {
         updateMeshNodes()
+        clearInterval(interval)
+        return
       }
-    }, 100) // Poll every 100ms during active solving
+
+      if (solver.stats?.placed > 0) {
+        updateMeshNodes()
+      }
+    }, 100)
 
     return () => clearInterval(interval)
   }, [updateMeshNodes, solver])
@@ -724,6 +751,32 @@ export const SolverDebugger3d: React.FC<SolverDebugger3dProps> = ({
                 />
                 Wireframe
               </label>
+
+              <label
+                style={{
+                  display: "inline-flex",
+                  gap: 8,
+                  alignItems: "center",
+                  fontSize: 13,
+                }}
+              >
+                <span>Z Filter</span>
+                <input
+                  type="text"
+                  value={zFilterInput}
+                  onChange={(e) => setZFilterInput(e.target.value)}
+                  placeholder="1 or 1,2,3"
+                  style={{
+                    width: 120,
+                    padding: "6px 10px",
+                    borderRadius: 6,
+                    border: `1px solid ${hasInvalidZFilter ? "#dc2626" : "#cbd5e1"}`,
+                    background: "white",
+                    fontSize: 13,
+                  }}
+                  title="Show only exact z matches. Example: 1 matches [1], 1,2,3 matches [1,2,3]."
+                />
+              </label>
             </>
           )}
         </div>
@@ -752,6 +805,7 @@ export const SolverDebugger3d: React.FC<SolverDebugger3dProps> = ({
             shrinkBoxes={shrinkBoxes}
             boxShrinkAmount={boxShrinkAmount}
             showBorders={showBorders}
+            selectedZValues={selectedZValues}
           />
         )}
       </div>

package/lib/RectDiffPipeline.ts

@@ -8,6 +8,7 @@ import type { GridFill3DOptions, XYRect } from "./rectdiff-types"
 import type { CapacityMeshNode } from "./types/capacity-mesh-types"
 import type { GraphicsObject } from "graphics-debug"
 import { GapFillSolverPipeline } from "./solvers/GapFillSolver/GapFillSolverPipeline"
+import { OuterLayerContainmentMergeSolver } from "./solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver"
 import { RectDiffGridSolverPipeline } from "./solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline"
 import { createBaseVisualization } from "./rectdiff-visualization"
 import { buildFinalRectDiffVisualization } from "./buildFinalRectDiffVisualization"
@@ -25,6 +26,7 @@ export interface RectDiffPipelineInput {
 export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput> {
   rectDiffGridSolverPipeline?: RectDiffGridSolverPipeline
   gapFillSolver?: GapFillSolverPipeline
+  outerLayerContainmentMergeSolver?: OuterLayerContainmentMergeSolver
   boardVoidRects: XYRect[] | undefined
   zIndexByName?: Map<string, number>
   layerNames?: string[]
@@ -69,6 +71,22 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
         },
       ],
     ),
+    definePipelineStep(
+      "outerLayerContainmentMergeSolver",
+      OuterLayerContainmentMergeSolver,
+      (rectDiffPipeline: RectDiffPipeline) => [
+        {
+          meshNodes:
+            rectDiffPipeline.gapFillSolver?.getOutput().outputNodes ??
+            rectDiffPipeline.rectDiffGridSolverPipeline?.getOutput()
+              .meshNodes ??
+            [],
+          simpleRouteJson: rectDiffPipeline.inputProblem.simpleRouteJson,
+          zIndexByName: rectDiffPipeline.zIndexByName ?? new Map(),
+          obstacleClearance: rectDiffPipeline.inputProblem.obstacleClearance,
+        },
+      ],
+    ),
   ]
 
   override _setup(): void {
@@ -100,6 +118,11 @@ export class RectDiffPipeline extends BasePipelineSolver<RectDiffPipelineInput>
   }
 
   override getOutput(): { meshNodes: CapacityMeshNode[] } {
+    const outerLayerMergeOutput =
+      this.outerLayerContainmentMergeSolver?.getOutput()
+    if (outerLayerMergeOutput) {
+      return { meshNodes: outerLayerMergeOutput.outputNodes }
+    }
     const gapFillOutput = this.gapFillSolver?.getOutput()
     if (gapFillOutput) {
       return { meshNodes: gapFillOutput.outputNodes }

package/lib/fixtures/twoNodeExpansionFixture.ts

@@ -2,7 +2,7 @@ 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"
+import type { RTreeRect } from "../types/capacity-mesh-types"
 import { buildZIndexMap } from "../solvers/RectDiffSeedingSolver/layers"
 
 /**

package/lib/solvers/GapFillSolver/ExpandEdgesToEmptySpaceSolver.ts

@@ -1,5 +1,5 @@
 import { BaseSolver } from "@tscircuit/solver-utils"
-import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
+import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
 import type { SegmentWithAdjacentEmptySpace } from "./FindSegmentsWithAdjacentEmptySpaceSolver"
 import type { GraphicsObject } from "graphics-debug"
 import RBush from "rbush"
@@ -7,7 +7,7 @@ import { EDGE_MAP, EDGES } from "./edge-constants"
 import { getBoundsFromCorners } from "./getBoundsFromCorners"
 import type { Bounds } from "@tscircuit/math-utils"
 import { midpoint, segmentToBoxMinDistance } from "@tscircuit/math-utils"
-import type { XYRect } from "lib/rectdiff-types"
+import type { XYRect } from "../../rectdiff-types"
 
 const EPS = 1e-4
 

package/lib/solvers/GapFillSolver/FindSegmentsWithAdjacentEmptySpaceSolver.ts

@@ -1,7 +1,7 @@
 import { BaseSolver } from "@tscircuit/solver-utils"
 import Flatbush from "flatbush"
 import type { GraphicsObject, NinePointAnchor } from "graphics-debug"
-import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
+import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
 import { projectToUncoveredSegments } from "./projectToUncoveredSegments"
 import { EDGES } from "./edge-constants"
 import { visuallyOffsetLine } from "./visuallyOffsetLine"

package/lib/solvers/GapFillSolver/GapFillSolverPipeline.ts

@@ -3,11 +3,11 @@ import {
   definePipelineStep,
   type PipelineStep,
 } from "@tscircuit/solver-utils"
-import type { CapacityMeshNode } from "lib/types/capacity-mesh-types"
+import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
 import type { GraphicsObject } from "graphics-debug"
 import { FindSegmentsWithAdjacentEmptySpaceSolver } from "./FindSegmentsWithAdjacentEmptySpaceSolver"
 import { ExpandEdgesToEmptySpaceSolver } from "./ExpandEdgesToEmptySpaceSolver"
-import type { XYRect } from "lib/rectdiff-types"
+import type { XYRect } from "../../rectdiff-types"
 
 type GapFillSolverInput = {
   meshNodes: CapacityMeshNode[]

package/lib/solvers/OuterLayerContainmentMergeSolver/OuterLayerContainmentMergeSolver.ts

@@ -0,0 +1,311 @@
+import { BaseSolver } from "@tscircuit/solver-utils"
+import type { GraphicsObject } from "graphics-debug"
+import type { CapacityMeshNode } from "../../types/capacity-mesh-types"
+import type { XYRect } from "../../rectdiff-types"
+import type { Obstacle, SimpleRouteJson } from "../../types/srj-types"
+import { obstacleToXYRect, obstacleZs } from "../RectDiffSeedingSolver/layers"
+import { getColorForZLayer } from "../../utils/getColorForZLayer"
+import { subtractRect2D, overlaps, EPS } from "../../utils/rectdiff-geometry"
+import { padRect } from "../../utils/padRect"
+
+type OuterLayerContainmentMergeSolverInput = {
+  meshNodes: CapacityMeshNode[]
+  simpleRouteJson: SimpleRouteJson
+  zIndexByName: Map<string, number>
+  obstacleClearance?: number
+}
+
+type ObstacleWithRect = {
+  obstacle: Obstacle
+  rect: XYRect
+}
+
+const nodeToRect = (node: CapacityMeshNode): XYRect => ({
+  x: node.center.x - node.width / 2,
+  y: node.center.y - node.height / 2,
+  width: node.width,
+  height: node.height,
+})
+
+const rectArea = (rect: XYRect) => rect.width * rect.height
+
+const cloneNode = (node: CapacityMeshNode): CapacityMeshNode => ({
+  ...node,
+  center: { ...node.center },
+  availableZ: [...node.availableZ],
+})
+
+const cloneNodeWithRect = (
+  node: CapacityMeshNode,
+  rect: XYRect,
+  capacityMeshNodeId: string,
+): CapacityMeshNode => ({
+  ...node,
+  capacityMeshNodeId,
+  center: {
+    x: rect.x + rect.width / 2,
+    y: rect.y + rect.height / 2,
+  },
+  width: rect.width,
+  height: rect.height,
+  availableZ: [...node.availableZ],
+  layer: `z${node.availableZ.join(",")}`,
+})
+
+const isFreeNode = (node: CapacityMeshNode) =>
+  !node._containsObstacle && !node._containsTarget
+
+const isSingletonOuterNode = (node: CapacityMeshNode, outerZ: number) =>
+  node.availableZ.length === 1 && node.availableZ[0] === outerZ
+
+const sameRect = (a: XYRect, b: XYRect) =>
+  Math.abs(a.x - b.x) <= EPS &&
+  Math.abs(a.y - b.y) <= EPS &&
+  Math.abs(a.width - b.width) <= EPS &&
+  Math.abs(a.height - b.height) <= EPS
+
+const subtractRects = (target: XYRect, cutters: XYRect[]) => {
+  let remaining: XYRect[] = [target]
+
+  for (const cutter of cutters) {
+    if (remaining.length === 0) return remaining
+
+    const nextRemaining: XYRect[] = []
+    for (const piece of remaining) {
+      nextRemaining.push(...subtractRect2D(piece, cutter))
+    }
+    remaining = nextRemaining
+  }
+
+  return remaining
+}
+
+const isFullyCoveredByRects = (target: XYRect, coveringRects: XYRect[]) => {
+  return subtractRects(target, coveringRects).length === 0
+}
+
+export class OuterLayerContainmentMergeSolver extends BaseSolver {
+  private outputNodes: CapacityMeshNode[] = []
+  private promotedNodeIds = new Set<string>()
+  private residualNodeIds = new Set<string>()
+
+  constructor(private input: OuterLayerContainmentMergeSolverInput) {
+    super()
+  }
+
+  override _setup() {
+    this.outputNodes = this.input.meshNodes.map(cloneNode)
+    this.promotedNodeIds.clear()
+    this.residualNodeIds.clear()
+  }
+
+  override _step() {
+    this.outputNodes = this.processOuterLayerContainmentMerges()
+    this.solved = true
+  }
+
+  private processOuterLayerContainmentMerges(): CapacityMeshNode[] {
+    const srj = this.input.simpleRouteJson
+    const layerCount = Math.max(1, srj.layerCount || 1)
+    if (layerCount < 3) {
+      return this.input.meshNodes.map(cloneNode)
+    }
+
+    const topZ = 0
+    const bottomZ = layerCount - 1
+    const viaMinSize = Math.max(srj.minViaDiameter ?? 0, srj.minTraceWidth || 0)
+    const originalNodes = this.input.meshNodes.map(cloneNode)
+    const obstaclesByLayer = this.buildObstaclesByLayer(layerCount)
+    const mutableOuterNodes = originalNodes.filter(
+      (node) =>
+        isFreeNode(node) &&
+        (isSingletonOuterNode(node, topZ) ||
+          isSingletonOuterNode(node, bottomZ)),
+    )
+    const immutableNodes = originalNodes.filter(
+      (node) => !mutableOuterNodes.includes(node),
+    )
+    const freeSupportRectsByOuterLayer = new Map<number, XYRect[]>()
+    freeSupportRectsByOuterLayer.set(
+      topZ,
+      originalNodes
+        .filter((node) => isFreeNode(node) && node.availableZ.includes(topZ))
+        .map(nodeToRect),
+    )
+    freeSupportRectsByOuterLayer.set(
+      bottomZ,
+      originalNodes
+        .filter((node) => isFreeNode(node) && node.availableZ.includes(bottomZ))
+        .map(nodeToRect),
+    )
+
+    const promotedNodes: CapacityMeshNode[] = []
+    const promotedRects: XYRect[] = []
+    const candidateNodes = mutableOuterNodes
+      .filter(
+        (node) =>
+          node.width + EPS >= viaMinSize && node.height + EPS >= viaMinSize,
+      )
+      .sort((a, b) => rectArea(nodeToRect(b)) - rectArea(nodeToRect(a)))
+
+    for (const candidate of candidateNodes) {
+      const candidateZ = candidate.availableZ[0]!
+      const oppositeZ = candidateZ === topZ ? bottomZ : topZ
+      const candidateRect = nodeToRect(candidate)
+      const oppositeSupportRects =
+        freeSupportRectsByOuterLayer.get(oppositeZ) ?? []
+
+      if (
+        !this.isTransitCompatibleAcrossIntermediateLayers({
+          rect: candidateRect,
+          fromZ: candidateZ,
+          toZ: oppositeZ,
+          obstaclesByLayer,
+        })
+      ) {
+        continue
+      }
+      if (!isFullyCoveredByRects(candidateRect, oppositeSupportRects)) {
+        continue
+      }
+
+      promotedNodes.push({
+        ...candidate,
+        availableZ: [topZ, bottomZ],
+        layer: `z${topZ},${bottomZ}`,
+      })
+      promotedRects.push(candidateRect)
+      this.promotedNodeIds.add(candidate.capacityMeshNodeId)
+    }
+
+    let nextResidualId = 0
+    const residualNodes: CapacityMeshNode[] = []
+
+    for (const node of mutableOuterNodes) {
+      if (this.promotedNodeIds.has(node.capacityMeshNodeId)) {
+        continue
+      }
+
+      const nodeRect = nodeToRect(node)
+      const remainingPieces = subtractRects(nodeRect, promotedRects)
+
+      if (
+        remainingPieces.length === 1 &&
+        sameRect(remainingPieces[0]!, nodeRect)
+      ) {
+        residualNodes.push(node)
+        continue
+      }
+
+      for (const piece of remainingPieces) {
+        const residualNode = cloneNodeWithRect(
+          node,
+          piece,
+          `${node.capacityMeshNodeId}-outer-merge-${nextResidualId++}`,
+        )
+        residualNodes.push(residualNode)
+        this.residualNodeIds.add(residualNode.capacityMeshNodeId)
+      }
+    }
+
+    return [...immutableNodes, ...promotedNodes, ...residualNodes]
+  }
+
+  private buildObstaclesByLayer(layerCount: number): ObstacleWithRect[][] {
+    const out = Array.from(
+      { length: layerCount },
+      () => [] as ObstacleWithRect[],
+    )
+
+    for (const obstacle of this.input.simpleRouteJson.obstacles ?? []) {
+      const baseRect = obstacleToXYRect(obstacle)
+      if (!baseRect) continue
+      const rect = padRect(baseRect, this.input.obstacleClearance ?? 0)
+      const zLayers = obstacleZs(obstacle, this.input.zIndexByName)
+
+      for (const z of zLayers) {
+        if (z < 0 || z >= layerCount) continue
+        out[z]!.push({ obstacle, rect })
+      }
+    }
+
+    return out
+  }
+
+  private isTransitCompatibleAcrossIntermediateLayers(params: {
+    rect: XYRect
+    fromZ: number
+    toZ: number
+    obstaclesByLayer: ObstacleWithRect[][]
+  }) {
+    const { rect, fromZ, toZ, obstaclesByLayer } = params
+    const lo = Math.min(fromZ, toZ)
+    const hi = Math.max(fromZ, toZ)
+
+    if (hi - lo < 2) return false
+
+    for (let z = lo + 1; z < hi; z++) {
+      const overlapping = (obstaclesByLayer[z] ?? []).filter((entry) =>
+        overlaps(entry.rect, rect),
+      )
+      if (overlapping.length === 0) return false
+
+      const nonCopperOverlap = overlapping.some(
+        (entry) => !entry.obstacle.isCopperPour,
+      )
+      if (nonCopperOverlap) return false
+
+      const copperRects = overlapping
+        .filter((entry) => entry.obstacle.isCopperPour)
+        .map((entry) => entry.rect)
+
+      if (!isFullyCoveredByRects(rect, copperRects)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  override getOutput(): { outputNodes: CapacityMeshNode[] } {
+    return { outputNodes: this.outputNodes }
+  }
+
+  override visualize(): GraphicsObject {
+    return {
+      title: "OuterLayerContainmentMergeSolver",
+      coordinateSystem: "cartesian",
+      rects: this.outputNodes.map((node) => {
+        const colors = getColorForZLayer(node.availableZ)
+        const isPromoted = this.promotedNodeIds.has(node.capacityMeshNodeId)
+        const isResidual = this.residualNodeIds.has(node.capacityMeshNodeId)
+
+        return {
+          center: node.center,
+          width: node.width,
+          height: node.height,
+          stroke: isPromoted
+            ? "rgba(22, 163, 74, 0.95)"
+            : isResidual
+              ? "rgba(37, 99, 235, 0.95)"
+              : colors.stroke,
+          fill: node._containsObstacle
+            ? "rgba(239, 68, 68, 0.35)"
+            : isPromoted
+              ? "rgba(34, 197, 94, 0.28)"
+              : isResidual
+                ? "rgba(59, 130, 246, 0.18)"
+                : colors.fill,
+          layer: `z${node.availableZ.join(",")}`,
+          label: [
+            `node ${node.capacityMeshNodeId}`,
+            `z:${node.availableZ.join(",")}`,
+          ].join("\n"),
+        }
+      }),
+      points: [],
+      lines: [],
+      texts: [],
+    }
+  }
+}

package/lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver.ts

@@ -1,12 +1,15 @@
 import { BaseSolver } from "@tscircuit/solver-utils"
 import type { GraphicsObject } from "graphics-debug"
-import type { CapacityMeshNode, RTreeRect } from "lib/types/capacity-mesh-types"
+import type {
+  CapacityMeshNode,
+  RTreeRect,
+} from "../../types/capacity-mesh-types"
 import { expandRectFromSeed } from "../../utils/expandRectFromSeed"
 import { finalizeRects } from "../../utils/finalizeRects"
 import { resizeSoftOverlaps } from "../../utils/resizeSoftOverlaps"
 import { rectsToMeshNodes } from "./rectsToMeshNodes"
 import type { XYRect, Candidate3D, Placed3D } from "../../rectdiff-types"
-import type { Obstacle } from "lib/types/srj-types"
+import type { Obstacle } from "../../types/srj-types"
 import RBush from "rbush"
 import { rectToTree } from "../../utils/rectToTree"
 import { sameTreeRect } from "../../utils/sameTreeRect"

package/lib/solvers/RectDiffGridSolverPipeline/RectDiffGridSolverPipeline.ts

@@ -7,11 +7,14 @@ import type {
   Obstacle,
   SimpleRouteConnection,
   SimpleRouteJson,
-} from "lib/types/srj-types"
-import type { GridFill3DOptions, XYRect } from "lib/rectdiff-types"
-import type { CapacityMeshNode, RTreeRect } from "lib/types/capacity-mesh-types"
-import { RectDiffSeedingSolver } from "lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver"
-import { RectDiffExpansionSolver } from "lib/solvers/RectDiffExpansionSolver/RectDiffExpansionSolver"
+} from "../../types/srj-types"
+import type { GridFill3DOptions, XYRect } from "../../rectdiff-types"
+import type {
+  CapacityMeshNode,
+  RTreeRect,
+} from "../../types/capacity-mesh-types"
+import { RectDiffSeedingSolver } from "../RectDiffSeedingSolver/RectDiffSeedingSolver"
+import { RectDiffExpansionSolver } from "../RectDiffExpansionSolver/RectDiffExpansionSolver"
 import type { GraphicsObject } from "graphics-debug"
 import RBush from "rbush"
 import { buildObstacleIndexesByLayer } from "./buildObstacleIndexes"

package/lib/solvers/RectDiffGridSolverPipeline/buildObstacleIndexes.ts

@@ -1,14 +1,14 @@
-import type { SimpleRouteJson } from "lib/types/srj-types"
+import type { SimpleRouteJson } from "../../types/srj-types"
 import RBush from "rbush"
-import { computeInverseRects } from "lib/solvers/RectDiffSeedingSolver/computeInverseRects"
+import { computeInverseRects } from "../RectDiffSeedingSolver/computeInverseRects"
 import {
   buildZIndexMap,
   obstacleToXYRect,
   obstacleZs,
-} from "lib/solvers/RectDiffSeedingSolver/layers"
-import type { XYRect } from "lib/rectdiff-types"
-import type { RTreeRect } from "lib/types/capacity-mesh-types"
-import { padRect } from "lib/utils/padRect"
+} from "../RectDiffSeedingSolver/layers"
+import type { XYRect } from "../../rectdiff-types"
+import type { RTreeRect } from "../../types/capacity-mesh-types"
+import { padRect } from "../../utils/padRect"
 
 export const buildObstacleIndexesByLayer = (params: {
   srj: SimpleRouteJson

package/lib/solvers/RectDiffSeedingSolver/RectDiffSeedingSolver.ts

@@ -16,12 +16,12 @@ import { computeCandidates3D } from "./computeCandidates3D"
 import { computeEdgeCandidates3D } from "./computeEdgeCandidates3D"
 import { longestFreeSpanAroundZ } from "./longestFreeSpanAroundZ"
 import { allLayerNode } from "../../utils/buildHardPlacedByLayer"
-import { isFullyOccupiedAtPoint } from "lib/utils/isFullyOccupiedAtPoint"
+import { isFullyOccupiedAtPoint } from "../../utils/isFullyOccupiedAtPoint"
 import { resizeSoftOverlaps } from "../../utils/resizeSoftOverlaps"
-import { getColorForZLayer } from "lib/utils/getColorForZLayer"
+import { getColorForZLayer } from "../../utils/getColorForZLayer"
 import RBush from "rbush"
-import type { RTreeRect } from "lib/types/capacity-mesh-types"
-import { rectToTree } from "lib/utils/rectToTree"
+import type { RTreeRect } from "../../types/capacity-mesh-types"
+import { rectToTree } from "../../utils/rectToTree"
 
 export type RectDiffSeedingSolverInput = {
   simpleRouteJson: SimpleRouteJson

package/lib/solvers/RectDiffSeedingSolver/computeCandidates3D.ts

@@ -3,7 +3,7 @@ import { EPS, distancePointToRectEdges } from "../../utils/rectdiff-geometry"
 import { isFullyOccupiedAtPoint } from "../../utils/isFullyOccupiedAtPoint"
 import { longestFreeSpanAroundZ } from "./longestFreeSpanAroundZ"
 import type RBush from "rbush"
-import type { RTreeRect } from "lib/types/capacity-mesh-types"
+import type { RTreeRect } from "../../types/capacity-mesh-types"
 const quantize = (value: number, precision = 1e-6) =>
   Math.round(value / precision) * precision