@tscircuit/capacity-autorouter 0.0.259 → 0.0.261

package/dist/index.d.ts

@@ -2,10 +2,11 @@ import * as graphics_debug from 'graphics-debug';
 import { GraphicsObject, Rect, Circle, Line, Point as Point$5 } from 'graphics-debug';
 import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
 import { RectDiffPipeline } from '@tscircuit/rectdiff';
+import { BaseSolver as BaseSolver$1 } from '@tscircuit/solver-utils';
+import { Polygon } from '@tscircuit/math-utils';
 import { JumperGraphSolver, JRegion, JPort } from '@tscircuit/hypergraph';
 import { CurvyTraceSolver } from '@tscircuit/curvy-trace-solver';
 import { ConnectivityMap as ConnectivityMap$1 } from 'connectivity-map';
-import { Polygon } from '@tscircuit/math-utils';
 
 type TraceId = string;
 type NetId = string;
@@ -2042,6 +2043,52 @@ declare class MultiSectionPortPointOptimizer extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+type Side = "left" | "right" | "top" | "bottom";
+type Bounds = {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+};
+interface NodeAndSide {
+    nodeId: string;
+    side: Side;
+}
+type PortPointWithSide = PortPoint & {
+    side: Side;
+    ownerNodeId: string;
+};
+
+interface UniformPortDistributionSolverInput {
+    nodeWithPortPoints: NodeWithPortPoints[];
+    inputNodesWithPortPoints: InputNodeWithPortPoints[];
+    obstacles: Obstacle[];
+}
+/**
+ * Redistributes port points uniformly along the sides of nodes to optimize
+ * routing density and prevent congestion.
+ *
+ * This solver:
+ * 1. Classifies which side of a node each port point belongs to.
+ * 2. Determines the "owner" node for port points shared between nodes.
+ * 3. Evenly spaces port points along their assigned side.
+ */
+declare class UniformPortDistributionSolver extends BaseSolver$1 {
+    private input;
+    mapOfNodeIdToLengthOfEachSide: Map<string, Record<Side, number>>;
+    sidesToProcess: NodeAndSide[];
+    mapOfNodeIdToBounds: Map<string, Bounds>;
+    mapOfNodeAndSideToPortPoints: Map<string, PortPointWithSide[]>;
+    currentSideBeingProcessed: NodeAndSide | null;
+    redistributedNodes: NodeWithPortPoints[];
+    private getNodeAndSideKey;
+    constructor(input: UniformPortDistributionSolverInput);
+    step(): void;
+    rebuildNodes(): void;
+    getOutput: () => NodeWithPortPoints[];
+    visualize(): GraphicsObject;
+}
+
 interface CapacityMeshSolverOptions$4 {
     capacityDepth?: number;
     targetMinCapacity?: number;
@@ -2071,6 +2118,7 @@ declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
     availableSegmentPointSolver?: AvailableSegmentPointSolver;
     portPointPathingSolver?: HyperPortPointPathingSolver;
     multiSectionPortPointOptimizer?: MultiSectionPortPointOptimizer;
+    uniformPortDistributionSolver?: UniformPortDistributionSolver;
     viaDiameter: number;
     minTraceWidth: number;
     effort: number;
@@ -2082,8 +2130,9 @@ declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
     srjWithPointPairs?: SimpleRouteJson;
     capacityNodes: CapacityMeshNode[] | null;
     capacityEdges: CapacityMeshEdge[] | null;
+    inputNodeWithPortPoints: InputNodeWithPortPoints[];
     cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep$4<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$4<typeof RectDiffPipeline> | PipelineStep$4<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$4<typeof AvailableSegmentPointSolver> | PipelineStep$4<typeof HyperPortPointPathingSolver> | PipelineStep$4<typeof MultiSectionPortPointOptimizer> | PipelineStep$4<typeof HighDensitySolver> | PipelineStep$4<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$4<typeof TraceSimplificationSolver>)[];
+    pipelineDef: (PipelineStep$4<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$4<typeof RectDiffPipeline> | PipelineStep$4<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$4<typeof AvailableSegmentPointSolver> | PipelineStep$4<typeof HyperPortPointPathingSolver> | PipelineStep$4<typeof MultiSectionPortPointOptimizer> | PipelineStep$4<typeof UniformPortDistributionSolver> | PipelineStep$4<typeof HighDensitySolver> | PipelineStep$4<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$4<typeof TraceSimplificationSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$4);
     getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions$4];
     currentPipelineStepIndex: number;
@@ -2112,6 +2161,168 @@ declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
 declare const CapacityMeshSolver: typeof AutoroutingPipelineSolver2_PortPointPathing;
 type CapacityMeshSolver = AutoroutingPipelineSolver2_PortPointPathing;
 
+/**
+ * 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$1 = `${number}x${number}`;
+declare class TargetTree {
+    targets: Target$1[];
+    buckets: Map<BucketCoordinate$1, [Target$1, number][]>;
+    CELL_SIZE: number;
+    constructor(targets: Target$1[]);
+    getBucketKey(x: number, y: number): BucketCoordinate$1;
+    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;
@@ -2901,6 +3112,21 @@ declare class CapacityPathingMultiSectionSolver extends BaseSolver {
     visualize(): graphics_debug.GraphicsObject;
 }
 
+/**
+ * A simplified version of MultipleHighDensityRouteStitchSolver that doesn't handle
+ * off-board routing cases. It always uses the connection's pointsToConnect directly
+ * instead of analyzing possible endpoints from route islands.
+ */
+declare class NoOffBoardMultipleHighDensityRouteStitchSolver extends MultipleHighDensityRouteStitchSolver {
+    constructor(params: {
+        connections: SimpleRouteConnection[];
+        hdRoutes: any[];
+        colorMap?: Record<string, string>;
+        layerCount: number;
+        defaultViaDiameter?: number;
+    });
+}
+
 interface CapacityMeshSolverOptions$3 {
     capacityDepth?: number;
     targetMinCapacity?: number;
@@ -2916,7 +3142,7 @@ declare class AutoroutingPipeline1_OriginalUnravel extends BaseSolver {
     srj: SimpleRouteJson;
     opts: CapacityMeshSolverOptions$3;
     netToPointPairsSolver?: NetToPointPairsSolver;
-    nodeSolver?: RectDiffPipeline;
+    nodeSolver?: CapacityMeshNodeSolver;
     nodeTargetMerger?: CapacityNodeTargetMerger;
     edgeSolver?: CapacityMeshEdgeSolver;
     initialPathingSolver?: CapacityPathingGreedySolver;
@@ -2927,7 +3153,7 @@ declare class AutoroutingPipeline1_OriginalUnravel extends BaseSolver {
     unravelMultiSectionSolver?: UnravelMultiSectionSolver;
     segmentToPointOptimizer?: CapacitySegmentPointOptimizer;
     highDensityRouteSolver?: HighDensitySolver;
-    highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
+    highDensityStitchSolver?: NoOffBoardMultipleHighDensityRouteStitchSolver;
     singleLayerNodeMerger?: SingleLayerNodeMergerSolver;
     strawSolver?: StrawSolver;
     deadEndSolver?: DeadEndSolver;
@@ -2943,7 +3169,7 @@ declare class AutoroutingPipeline1_OriginalUnravel extends BaseSolver {
     capacityNodes: CapacityMeshNode[] | null;
     capacityEdges: CapacityMeshEdge[] | null;
     cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep$3<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$3<typeof RectDiffPipeline> | PipelineStep$3<typeof StrawSolver> | PipelineStep$3<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$3<typeof DeadEndSolver> | PipelineStep$3<typeof CapacityPathingGreedySolver> | PipelineStep$3<typeof CapacityPathingMultiSectionSolver> | PipelineStep$3<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep$3<typeof CapacitySegmentToPointSolver> | PipelineStep$3<typeof UnravelMultiSectionSolver> | PipelineStep$3<typeof HighDensitySolver> | PipelineStep$3<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$3<typeof TraceSimplificationSolver>)[];
+    pipelineDef: (PipelineStep$3<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$3<typeof CapacityMeshNodeSolver2_NodeUnderObstacle> | PipelineStep$3<typeof SingleLayerNodeMergerSolver> | PipelineStep$3<typeof StrawSolver> | PipelineStep$3<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$3<typeof DeadEndSolver> | PipelineStep$3<typeof CapacityPathingGreedySolver> | PipelineStep$3<typeof CapacityPathingMultiSectionSolver> | PipelineStep$3<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep$3<typeof CapacitySegmentToPointSolver> | PipelineStep$3<typeof UnravelMultiSectionSolver> | PipelineStep$3<typeof HighDensitySolver> | PipelineStep$3<typeof NoOffBoardMultipleHighDensityRouteStitchSolver> | PipelineStep$3<typeof TraceSimplificationSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$3);
     getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions$3];
     currentPipelineStepIndex: number;
@@ -3353,26 +3579,6 @@ declare class JumperHighDensitySolver 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$1 {
     x: number;
     y: number;
@@ -3744,13 +3950,13 @@ declare class PortPointOffboardPathFragmentSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-type BucketCoordinate$1 = `${number}x${number}`;
+type BucketCoordinate = `${number}x${number}`;
 declare class CapacityNodeTree {
     nodes: CapacityMeshNode[];
-    buckets: Map<BucketCoordinate$1, CapacityMeshNode[]>;
+    buckets: Map<BucketCoordinate, CapacityMeshNode[]>;
     CELL_SIZE: number;
     constructor(nodes: CapacityMeshNode[]);
-    getBucketKey(x: number, y: number): BucketCoordinate$1;
+    getBucketKey(x: number, y: number): BucketCoordinate;
     getNodesInArea(centerX: number, centerY: number, width: number, height: number): CapacityMeshNode[];
 }
 
@@ -4131,148 +4337,6 @@ 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;
 }