@tscircuit/capacity-autorouter 0.0.157 → 0.0.158

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as graphics_debug from 'graphics-debug';
 import { GraphicsObject, Rect, Circle, Line, Point as Point$3 } from 'graphics-debug';
-import { Polygon } from '@tscircuit/math-utils';
 import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
+import { RectDiffSolver } from '@tscircuit/rectdiff';
+import { Polygon } from '@tscircuit/math-utils';
 
 type TraceId = string;
 type NetId = string;
@@ -165,168 +166,6 @@ declare class CapacityMeshEdgeSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-/**
- * ObstacleTree wraps different spatial index implementations:
- * - 'native': original spatial-hash grid
- * - 'rbush': dynamic R-tree via rbush
- * - 'flatbush': static index via flatbush
- */
-declare class ObstacleSpatialHashIndex {
-    private idx;
-    private storage;
-    constructor(implementation?: "native" | "rbush" | "flatbush", obstacles?: Obstacle[]);
-    insert(o: Obstacle): void;
-    search(bbox: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    }): Obstacle[];
-    searchArea(centerX: number, centerY: number, width: number, height: number): Obstacle[];
-}
-
-interface Target$1 {
-    x: number;
-    y: number;
-    bounds: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    };
-    connectionName: string;
-    availableZ: number[];
-}
-type BucketCoordinate = `${number}x${number}`;
-declare class TargetTree {
-    targets: Target$1[];
-    buckets: Map<BucketCoordinate, [Target$1, number][]>;
-    CELL_SIZE: number;
-    constructor(targets: Target$1[]);
-    getBucketKey(x: number, y: number): BucketCoordinate;
-    getTargetsInArea(centerX: number, centerY: number, width: number, height: number): Target$1[];
-}
-
-interface CapacityMeshNodeSolverOptions$2 {
-    capacityDepth?: number;
-}
-interface Target {
-    x: number;
-    y: number;
-    bounds: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    };
-    connectionName: string;
-    availableZ: number[];
-}
-declare class CapacityMeshNodeSolver extends BaseSolver {
-    srj: SimpleRouteJson;
-    opts: CapacityMeshNodeSolverOptions$2;
-    unfinishedNodes: CapacityMeshNode[];
-    finishedNodes: CapacityMeshNode[];
-    nodeToXYOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle[]>;
-    layerCount: number;
-    protected outlinePolygon?: Polygon;
-    MAX_DEPTH: number;
-    targets: Target[];
-    targetTree: TargetTree;
-    obstacleTree: ObstacleSpatialHashIndex;
-    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions$2);
-    computeTargets(): Target[];
-    protected getNodeBounds(node: CapacityMeshNode): {
-        minX: number;
-        maxX: number;
-        minY: number;
-        maxY: number;
-    };
-    protected getNodeRect(node: CapacityMeshNode): {
-        center: {
-            x: number;
-            y: number;
-        };
-        width: number;
-        height: number;
-    };
-    _nextNodeCounter: number;
-    getNextNodeId(): string;
-    getCapacityFromDepth(depth: number): number;
-    getTargetIfNodeContainsTarget(node: CapacityMeshNode): Target | null;
-    getXYOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
-    getXYZOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
-    /**
-     * Checks if the given mesh node overlaps with any obstacle.
-     * We treat both obstacles and nodes as axis‐aligned rectangles.
-     */
-    doesNodeOverlapObstacle(node: CapacityMeshNode): boolean;
-    /**
-     * Checks if the entire node is contained within any obstacle.
-     */
-    isNodeCompletelyInsideObstacle(node: CapacityMeshNode): boolean;
-    getChildNodes(parent: CapacityMeshNode): CapacityMeshNode[];
-    shouldNodeBeXYSubdivided(node: CapacityMeshNode): boolean;
-    _step(): void;
-    /**
-     * Creates a GraphicsObject to visualize the mesh, its nodes, obstacles, and connection points.
-     *
-     * - Mesh nodes are rendered as rectangles.
-     *   - Nodes that have an obstacle intersection are outlined in red.
-     *   - Other nodes are outlined in green.
-     * - Lines are drawn from a node to its parent.
-     * - Obstacles are drawn as semi-transparent red rectangles.
-     * - Points for each connection’s pointsToConnect are drawn in a unique color.
-     */
-    visualize(): GraphicsObject;
-}
-
-interface CapacityMeshNodeSolverOptions$1 {
-    capacityDepth?: number;
-}
-declare class CapacityMeshNodeSolver2_NodeUnderObstacle extends CapacityMeshNodeSolver {
-    srj: SimpleRouteJson;
-    opts: CapacityMeshNodeSolverOptions$1;
-    VIA_DIAMETER: number;
-    OBSTACLE_MARGIN: number;
-    /**
-     * The threshold for the percentage of a single-layer node that must be
-     * covered by obstacles to be considered "under an obstacle"
-     */
-    OVERLAP_THRESHOLD_FOR_SINGLE_LAYER_NODES: number;
-    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions$1);
-    isNodeCompletelyOutsideBounds(node: CapacityMeshNode): boolean;
-    isNodePartiallyOutsideBounds(node: CapacityMeshNode): boolean;
-    /**
-     * Calculate the percentage of node area covered by obstacles
-     */
-    getObstacleCoveragePercentage(node: CapacityMeshNode): number;
-    /**
-     * Check if a single-layer node should be filtered due to obstacle coverage
-     */
-    shouldFilterSingleLayerNodeForObstacle(node: CapacityMeshNode): boolean;
-    /**
-     * Check if a node should be filtered due to obstacles.
-     * Single-layer nodes: filtered only if >20% covered
-     * Multi-layer nodes: filtered if any overlap
-     */
-    shouldFilterNodeForObstacle(node: CapacityMeshNode): boolean;
-    createChildNodeAtPosition(parent: CapacityMeshNode, opts: {
-        center: {
-            x: number;
-            y: number;
-        };
-        width: number;
-        height: number;
-        availableZ: number[];
-        _depth?: number;
-    }): CapacityMeshNode;
-    getZSubdivisionChildNodes(node: CapacityMeshNode): CapacityMeshNode[];
-    getChildNodes(parent: CapacityMeshNode): CapacityMeshNode[];
-    shouldNodeBeXYSubdivided(node: CapacityMeshNode): boolean;
-    _step(): void;
-}
-
 interface NodePortSegment {
     capacityMeshNodeId: string;
     nodePortSegmentId?: string;
@@ -1888,6 +1727,26 @@ declare class DeadEndSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+/**
+ * ObstacleTree wraps different spatial index implementations:
+ * - 'native': original spatial-hash grid
+ * - 'rbush': dynamic R-tree via rbush
+ * - 'flatbush': static index via flatbush
+ */
+declare class ObstacleSpatialHashIndex {
+    private idx;
+    private storage;
+    constructor(implementation?: "native" | "rbush" | "flatbush", obstacles?: Obstacle[]);
+    insert(o: Obstacle): void;
+    search(bbox: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    }): Obstacle[];
+    searchArea(centerX: number, centerY: number, width: number, height: number): Obstacle[];
+}
+
 interface Point {
     x: number;
     y: number;
@@ -2113,7 +1972,7 @@ declare class AutoroutingPipelineSolver extends BaseSolver {
     srj: SimpleRouteJson;
     opts: CapacityMeshSolverOptions$1;
     netToPointPairsSolver?: NetToPointPairsSolver;
-    nodeSolver?: CapacityMeshNodeSolver;
+    nodeSolver?: RectDiffSolver;
     nodeTargetMerger?: CapacityNodeTargetMerger;
     edgeSolver?: CapacityMeshEdgeSolver;
     initialPathingSolver?: CapacityPathingGreedySolver;
@@ -2144,7 +2003,7 @@ declare class AutoroutingPipelineSolver extends BaseSolver {
     capacityNodes: CapacityMeshNode[] | null;
     capacityEdges: CapacityMeshEdge[] | null;
     cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep$1<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$1<typeof CapacityMeshNodeSolver2_NodeUnderObstacle> | PipelineStep$1<typeof SingleLayerNodeMergerSolver> | PipelineStep$1<typeof StrawSolver> | PipelineStep$1<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$1<typeof DeadEndSolver> | PipelineStep$1<typeof CapacityPathingGreedySolver> | PipelineStep$1<typeof CapacityPathingMultiSectionSolver> | PipelineStep$1<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep$1<typeof CapacitySegmentToPointSolver> | PipelineStep$1<typeof UnravelMultiSectionSolver> | PipelineStep$1<typeof HighDensitySolver> | PipelineStep$1<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$1<typeof UselessViaRemovalSolver> | PipelineStep$1<typeof MultiSimplifiedPathSolver> | PipelineStep$1<typeof SameNetViaMergerSolver>)[];
+    pipelineDef: (PipelineStep$1<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$1<typeof RectDiffSolver> | PipelineStep$1<typeof StrawSolver> | PipelineStep$1<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$1<typeof DeadEndSolver> | PipelineStep$1<typeof CapacityPathingGreedySolver> | PipelineStep$1<typeof CapacityPathingMultiSectionSolver> | PipelineStep$1<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep$1<typeof CapacitySegmentToPointSolver> | PipelineStep$1<typeof UnravelMultiSectionSolver> | PipelineStep$1<typeof HighDensitySolver> | PipelineStep$1<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$1<typeof UselessViaRemovalSolver> | PipelineStep$1<typeof MultiSimplifiedPathSolver> | PipelineStep$1<typeof SameNetViaMergerSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$1);
     currentPipelineStepIndex: number;
     _step(): void;
@@ -2305,6 +2164,148 @@ declare function getGlobalLocalStorageCache(): LocalStorageCache;
 declare function getGlobalInMemoryCache(): InMemoryCache;
 declare function setupGlobalCaches(): void;
 
+interface Target$1 {
+    x: number;
+    y: number;
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    connectionName: string;
+    availableZ: number[];
+}
+type BucketCoordinate = `${number}x${number}`;
+declare class TargetTree {
+    targets: Target$1[];
+    buckets: Map<BucketCoordinate, [Target$1, number][]>;
+    CELL_SIZE: number;
+    constructor(targets: Target$1[]);
+    getBucketKey(x: number, y: number): BucketCoordinate;
+    getTargetsInArea(centerX: number, centerY: number, width: number, height: number): Target$1[];
+}
+
+interface CapacityMeshNodeSolverOptions$2 {
+    capacityDepth?: number;
+}
+interface Target {
+    x: number;
+    y: number;
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    connectionName: string;
+    availableZ: number[];
+}
+declare class CapacityMeshNodeSolver extends BaseSolver {
+    srj: SimpleRouteJson;
+    opts: CapacityMeshNodeSolverOptions$2;
+    unfinishedNodes: CapacityMeshNode[];
+    finishedNodes: CapacityMeshNode[];
+    nodeToXYOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle[]>;
+    layerCount: number;
+    protected outlinePolygon?: Polygon;
+    MAX_DEPTH: number;
+    targets: Target[];
+    targetTree: TargetTree;
+    obstacleTree: ObstacleSpatialHashIndex;
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions$2);
+    computeTargets(): Target[];
+    protected getNodeBounds(node: CapacityMeshNode): {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+    protected getNodeRect(node: CapacityMeshNode): {
+        center: {
+            x: number;
+            y: number;
+        };
+        width: number;
+        height: number;
+    };
+    _nextNodeCounter: number;
+    getNextNodeId(): string;
+    getCapacityFromDepth(depth: number): number;
+    getTargetIfNodeContainsTarget(node: CapacityMeshNode): Target | null;
+    getXYOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
+    getXYZOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
+    /**
+     * Checks if the given mesh node overlaps with any obstacle.
+     * We treat both obstacles and nodes as axis‐aligned rectangles.
+     */
+    doesNodeOverlapObstacle(node: CapacityMeshNode): boolean;
+    /**
+     * Checks if the entire node is contained within any obstacle.
+     */
+    isNodeCompletelyInsideObstacle(node: CapacityMeshNode): boolean;
+    getChildNodes(parent: CapacityMeshNode): CapacityMeshNode[];
+    shouldNodeBeXYSubdivided(node: CapacityMeshNode): boolean;
+    _step(): void;
+    /**
+     * Creates a GraphicsObject to visualize the mesh, its nodes, obstacles, and connection points.
+     *
+     * - Mesh nodes are rendered as rectangles.
+     *   - Nodes that have an obstacle intersection are outlined in red.
+     *   - Other nodes are outlined in green.
+     * - Lines are drawn from a node to its parent.
+     * - Obstacles are drawn as semi-transparent red rectangles.
+     * - Points for each connection’s pointsToConnect are drawn in a unique color.
+     */
+    visualize(): GraphicsObject;
+}
+
+interface CapacityMeshNodeSolverOptions$1 {
+    capacityDepth?: number;
+}
+declare class CapacityMeshNodeSolver2_NodeUnderObstacle extends CapacityMeshNodeSolver {
+    srj: SimpleRouteJson;
+    opts: CapacityMeshNodeSolverOptions$1;
+    VIA_DIAMETER: number;
+    OBSTACLE_MARGIN: number;
+    /**
+     * The threshold for the percentage of a single-layer node that must be
+     * covered by obstacles to be considered "under an obstacle"
+     */
+    OVERLAP_THRESHOLD_FOR_SINGLE_LAYER_NODES: number;
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions$1);
+    isNodeCompletelyOutsideBounds(node: CapacityMeshNode): boolean;
+    isNodePartiallyOutsideBounds(node: CapacityMeshNode): boolean;
+    /**
+     * Calculate the percentage of node area covered by obstacles
+     */
+    getObstacleCoveragePercentage(node: CapacityMeshNode): number;
+    /**
+     * Check if a single-layer node should be filtered due to obstacle coverage
+     */
+    shouldFilterSingleLayerNodeForObstacle(node: CapacityMeshNode): boolean;
+    /**
+     * Check if a node should be filtered due to obstacles.
+     * Single-layer nodes: filtered only if >20% covered
+     * Multi-layer nodes: filtered if any overlap
+     */
+    shouldFilterNodeForObstacle(node: CapacityMeshNode): boolean;
+    createChildNodeAtPosition(parent: CapacityMeshNode, opts: {
+        center: {
+            x: number;
+            y: number;
+        };
+        width: number;
+        height: number;
+        availableZ: number[];
+        _depth?: number;
+    }): CapacityMeshNode;
+    getZSubdivisionChildNodes(node: CapacityMeshNode): CapacityMeshNode[];
+    getChildNodes(parent: CapacityMeshNode): CapacityMeshNode[];
+    shouldNodeBeXYSubdivided(node: CapacityMeshNode): boolean;
+    _step(): void;
+}
+
 interface CapacityMeshNodeSolverOptions {
     capacityDepth?: number;
 }