@tscircuit/capacity-autorouter 0.0.20 → 0.0.22

package/dist/index.d.ts

@@ -18,6 +18,7 @@ interface SimpleRouteJson {
 interface Obstacle {
     type: "rect";
     layers: string[];
+    zLayers?: number[];
     center: {
         x: number;
         y: number;
@@ -72,6 +73,7 @@ interface CapacityMeshNode {
     _containsObstacle?: boolean;
     _containsTarget?: boolean;
     _targetConnectionName?: string;
+    _strawNode?: boolean;
     _parent?: CapacityMeshNode;
 }
 interface CapacityMeshEdge {
@@ -109,11 +111,11 @@ declare class CapacityMeshEdgeSolver extends BaseSolver {
     constructor(nodes: CapacityMeshNode[]);
     getNextCapacityMeshEdgeId(): string;
     step(): void;
-    private areNodesBordering;
+    private doNodesHaveSharedLayer;
     visualize(): GraphicsObject;
 }
 
-interface CapacityMeshNodeSolverOptions {
+interface CapacityMeshNodeSolverOptions$1 {
     capacityDepth?: number;
 }
 interface Target {
@@ -124,18 +126,20 @@ interface Target {
 }
 declare class CapacityMeshNodeSolver extends BaseSolver {
     srj: SimpleRouteJson;
-    opts: CapacityMeshNodeSolverOptions;
+    opts: CapacityMeshNodeSolverOptions$1;
     unfinishedNodes: CapacityMeshNode[];
     finishedNodes: CapacityMeshNode[];
-    nodeToOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle[]>;
+    nodeToXYOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle[]>;
+    layerCount: number;
     MAX_DEPTH: number;
     targets: Target[];
-    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions);
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions$1);
     _nextNodeCounter: number;
     getNextNodeId(): string;
     getCapacityFromDepth(depth: number): number;
     getTargetIfNodeContainsTarget(node: CapacityMeshNode): Target | null;
-    getOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
+    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.
@@ -146,7 +150,7 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
      */
     isNodeCompletelyInsideObstacle(node: CapacityMeshNode): boolean;
     getChildNodes(parent: CapacityMeshNode): CapacityMeshNode[];
-    shouldNodeBeSubdivided(node: CapacityMeshNode): boolean;
+    shouldNodeBeXYSubdivided(node: CapacityMeshNode): boolean;
     _step(): void;
     /**
      * Creates a GraphicsObject to visualize the mesh, its nodes, obstacles, and connection points.
@@ -161,6 +165,31 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+interface CapacityMeshNodeSolverOptions {
+    capacityDepth?: number;
+}
+declare class CapacityMeshNodeSolver2_NodeUnderObstacle extends CapacityMeshNodeSolver {
+    srj: SimpleRouteJson;
+    opts: CapacityMeshNodeSolverOptions;
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions);
+    isNodeCompletelyOutsideBounds(node: CapacityMeshNode): boolean;
+    isNodePartiallyOutsideBounds(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 CapacityHyperParameters {
     VIA_DIAMETER: number;
     TRACE_WIDTH: number;
@@ -191,6 +220,11 @@ declare class CapacityPathingSolver extends BaseSolver {
     colorMap: Record<string, string>;
     maxDepthOfNodes: number;
     activeCandidateStraightLineDistance?: number;
+    debug_lastNodeCostMap: Map<CapacityMeshNodeId, {
+        g: number;
+        h: number;
+        f: number;
+    }>;
     hyperParameters: Partial<CapacityHyperParameters>;
     constructor({ simpleRouteJson, nodes, edges, colorMap, MAX_ITERATIONS, hyperParameters, }: {
         simpleRouteJson: SimpleRouteJson;
@@ -635,29 +669,6 @@ declare class HighDensitySolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-declare class CapacityPathingSolver4_FlexibleNegativeCapacity extends CapacityPathingSolver {
-    NEGATIVE_CAPACITY_PENALTY_FACTOR: number;
-    REDUCED_CAPACITY_PENALTY_FACTOR: number;
-    get maxCapacityFactor(): number;
-    /**
-     * In the FlexibleNegativeCapacity mode, we allow negative capacity
-     */
-    doesNodeHaveCapacityForTrace(node: CapacityMeshNode): boolean;
-    getTotalCapacity(node: CapacityMeshNode): number;
-    /**
-     * Penalty you pay for using this node
-     */
-    getNodeCapacityPenalty(node: CapacityMeshNode): number;
-    /**
-     * We're rewarding travel into big nodes.
-     *
-     * To minimize shortest path, you'd want to comment this out.
-     */
-    getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
-    computeG(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    computeH(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-}
-
 /**
  * Merge targets that are close to each other into a single target
  */
@@ -1027,6 +1038,7 @@ type UnravelCandidate = {
 declare class UnravelSectionSolver extends BaseSolver {
     nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
     dedupedSegments: SegmentWithAssignedPoints[];
+    dedupedSegmentMap: Map<SegmentId, SegmentWithAssignedPoints>;
     MUTABLE_HOPS: number;
     unravelSection: UnravelSection;
     candidates: UnravelCandidate[];
@@ -1047,6 +1059,7 @@ declare class UnravelSectionSolver extends BaseSolver {
         MUTABLE_HOPS?: number;
         nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
         dedupedSegments: SegmentWithAssignedPoints[];
+        dedupedSegmentMap?: Map<SegmentId, SegmentWithAssignedPoints>;
         nodeIdToSegmentIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
         segmentIdToNodeIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
         segmentPointMap?: SegmentPointMap;
@@ -1076,6 +1089,7 @@ declare class UnravelSectionSolver extends BaseSolver {
 
 declare class UnravelMultiSectionSolver extends BaseSolver {
     nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    dedupedSegmentMap: Map<SegmentId, SegmentWithAssignedPoints>;
     dedupedSegments: SegmentWithAssignedPoints[];
     nodeIdToSegmentIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
     segmentIdToNodeIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
@@ -1107,6 +1121,75 @@ declare class UnravelMultiSectionSolver extends BaseSolver {
     getNodesWithPortPoints(): NodeWithPortPoints[];
 }
 
+declare class CapacityPathingSolver5 extends CapacityPathingSolver {
+    NEGATIVE_CAPACITY_PENALTY_FACTOR: number;
+    REDUCED_CAPACITY_PENALTY_FACTOR: number;
+    constructor(...args: ConstructorParameters<typeof CapacityPathingSolver>);
+    get maxCapacityFactor(): number;
+    getTotalCapacity(node: CapacityMeshNode): number;
+    /**
+     * Penalty you pay for using this node
+     */
+    getNodeCapacityPenalty(node: CapacityMeshNode): number;
+    /**
+     * We're rewarding travel into big nodes.
+     *
+     * To minimize shortest path, you'd want to comment this out.
+     */
+    getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
+    computeG(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+}
+
+declare class StrawSolver extends BaseSolver {
+    multiLayerNodes: CapacityMeshNode[];
+    strawNodes: CapacityMeshNode[];
+    skippedNodes: CapacityMeshNode[];
+    unprocessedNodes: CapacityMeshNode[];
+    strawSize: number;
+    nodeIdCounter: number;
+    constructor(params: {
+        nodes: CapacityMeshNode[];
+        strawSize?: number;
+    });
+    getCapacityOfMultiLayerNodesWithinBounds(bounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    }): number;
+    getSurroundingCapacities(node: CapacityMeshNode): {
+        leftSurroundingCapacity: number;
+        rightSurroundingCapacity: number;
+        topSurroundingCapacity: number;
+        bottomSurroundingCapacity: number;
+    };
+    /**
+     * Creates straw nodes from a single-layer node based on surrounding capacities
+     */
+    createStrawsForNode(node: CapacityMeshNode): CapacityMeshNode[];
+    getResultNodes(): CapacityMeshNode[];
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+/**
+ * Merges same layer nodes into larger nodes. Pre-processing stage necessary
+ * for "strawing".
+ */
+declare class SingleLayerNodeMergerSolver extends BaseSolver {
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    currentBatchNodeIds: CapacityMeshNodeId[];
+    absorbedNodeIds: Set<CapacityMeshNodeId>;
+    nextBatchNodeIds: CapacityMeshNodeId[];
+    batchHadModifications: boolean;
+    newNodes: CapacityMeshNode[];
+    constructor(nodes: CapacityMeshNode[]);
+    getAdjacentSameLayerUnprocessedNodes(rootNode: CapacityMeshNode): CapacityMeshNode[];
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
 interface CapacityMeshSolverOptions {
     capacityDepth?: number;
     targetMinCapacity?: number;
@@ -1132,13 +1215,16 @@ declare class CapacityMeshSolver extends BaseSolver {
     segmentToPointOptimizer?: CapacitySegmentPointOptimizer;
     highDensityRouteSolver?: HighDensitySolver;
     highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
+    singleLayerNodeMerger?: SingleLayerNodeMergerSolver;
+    strawSolver?: StrawSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
-    activeSolver?: BaseSolver | null;
+    activeSubSolver?: BaseSolver | null;
     connMap: ConnectivityMap;
     srjWithPointPairs?: SimpleRouteJson;
-    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver> | PipelineStep<typeof CapacityNodeTargetMerger> | PipelineStep<typeof CapacityMeshEdgeSolver> | PipelineStep<typeof CapacityPathingSolver4_FlexibleNegativeCapacity> | PipelineStep<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep<typeof CapacitySegmentToPointSolver> | PipelineStep<typeof UnravelMultiSectionSolver> | PipelineStep<typeof HighDensitySolver> | PipelineStep<typeof MultipleHighDensityRouteStitchSolver>)[];
+    capacityNodes: CapacityMeshNode[] | null;
+    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver2_NodeUnderObstacle> | PipelineStep<typeof SingleLayerNodeMergerSolver> | PipelineStep<typeof StrawSolver> | PipelineStep<typeof CapacityMeshEdgeSolver> | PipelineStep<typeof CapacityPathingSolver5> | PipelineStep<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep<typeof CapacitySegmentToPointSolver> | PipelineStep<typeof UnravelMultiSectionSolver> | PipelineStep<typeof HighDensitySolver> | PipelineStep<typeof MultipleHighDensityRouteStitchSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions);
     currentPipelineStepIndex: number;
     _step(): void;