@tscircuit/capacity-autorouter 0.0.52 → 0.0.54

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import * as graphics_debug from 'graphics-debug';
 import { GraphicsObject } from 'graphics-debug';
 import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
 
@@ -116,9 +117,11 @@ declare class BaseSolver {
 declare class CapacityMeshEdgeSolver extends BaseSolver {
     nodes: CapacityMeshNode[];
     edges: Array<CapacityMeshEdge>;
+    /** Only used for visualization, dynamically instantiated if necessary */
+    nodeMap?: Map<CapacityMeshNodeId, CapacityMeshNode>;
     constructor(nodes: CapacityMeshNode[]);
     getNextCapacityMeshEdgeId(): string;
-    step(): void;
+    _step(): void;
     handleTargetNodes(): void;
     doNodesHaveSharedLayer(node1: CapacityMeshNode, node2: CapacityMeshNode): boolean;
     visualize(): GraphicsObject;
@@ -242,80 +245,6 @@ declare class CapacityMeshNodeSolver2_NodeUnderObstacle extends CapacityMeshNode
     _step(): void;
 }
 
-interface CapacityHyperParameters {
-    VIA_DIAMETER: number;
-    TRACE_WIDTH: number;
-    MAX_CAPACITY_FACTOR: number;
-}
-
-type Candidate = {
-    prevCandidate: Candidate | null;
-    node: CapacityMeshNode;
-    f: number;
-    g: number;
-    h: number;
-};
-declare class CapacityPathingSolver extends BaseSolver {
-    connectionsWithNodes: Array<{
-        connection: SimpleRouteConnection;
-        nodes: CapacityMeshNode[];
-        path?: CapacityMeshNode[];
-        straightLineDistance: number;
-    }>;
-    usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
-    simpleRouteJson: SimpleRouteJson;
-    nodes: CapacityMeshNode[];
-    edges: CapacityMeshEdge[];
-    GREEDY_MULTIPLIER: number;
-    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
-    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
-    connectionNameToGoalNodeIds: Map<string, CapacityMeshNodeId[]>;
-    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;
-        nodes: CapacityMeshNode[];
-        edges: CapacityMeshEdge[];
-        colorMap?: Record<string, string>;
-        MAX_ITERATIONS?: number;
-        hyperParameters?: Partial<CapacityHyperParameters>;
-    });
-    getTotalCapacity(node: CapacityMeshNode): number;
-    getConnectionsWithNodes(): {
-        connectionsWithNodes: {
-            connection: SimpleRouteConnection;
-            nodes: CapacityMeshNode[];
-            pathFound: boolean;
-            straightLineDistance: number;
-        }[];
-        connectionNameToGoalNodeIds: Map<string, string[]>;
-    };
-    currentConnectionIndex: number;
-    candidates?: Array<Candidate> | null;
-    visitedNodes?: Set<CapacityMeshNodeId> | null;
-    computeG(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    computeH(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    getBacktrackedPath(candidate: Candidate): CapacityMeshNode[];
-    getNeighboringNodes(node: CapacityMeshNode): CapacityMeshNode[];
-    getCapacityPaths(): CapacityPath[];
-    doesNodeHaveCapacityForTrace(node: CapacityMeshNode, prevNode: CapacityMeshNode): boolean;
-    canTravelThroughObstacle(node: CapacityMeshNode, connectionName: string): boolean;
-    getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
-    reduceCapacityAlongPath(nextConnection: {
-        path?: CapacityMeshNode[];
-    }): void;
-    isConnectedToEndGoal(node: CapacityMeshNode, endGoal: CapacityMeshNode): boolean;
-    _step(): void;
-    visualize(): GraphicsObject;
-}
-
 interface NodePortSegment {
     capacityMeshNodeId: string;
     nodePortSegmentId?: string;
@@ -370,6 +299,7 @@ type NodeWithPortPoints = {
     width: number;
     height: number;
     portPoints: PortPoint[];
+    availableZ?: number[];
 };
 /**
  * A path for a wire in high-density intra-node routing.
@@ -471,6 +401,8 @@ interface HighDensityHyperParameters {
     SHUFFLE_SEED: number;
     CELL_SIZE_FACTOR: number;
     FLIP_TRACE_ALIGNMENT_DIRECTION: boolean;
+    MULTI_HEAD_POLYLINE_SOLVER: boolean;
+    SEGMENTS_PER_POLYLINE: number;
 }
 
 type Node = {
@@ -482,9 +414,9 @@ type Node = {
     f: number;
     parent: Node | null;
 };
-declare class SingleRouteCandidatePriorityQueue {
+declare class SingleRouteCandidatePriorityQueue<T extends Node = Node> {
     private heap;
-    constructor(nodes: Node[]);
+    constructor(nodes: T[]);
     private getLeftChildIndex;
     private getRightChildIndex;
     private getParentIndex;
@@ -495,9 +427,9 @@ declare class SingleRouteCandidatePriorityQueue {
     private rightChild;
     private parent;
     private swap;
-    dequeue(): Node | null;
-    peek(): Node | null;
-    enqueue(item: Node): void;
+    dequeue(): T | null;
+    peek(): T | null;
+    enqueue(item: T): void;
     heapifyUp(): void;
     heapifyDown(): void;
 }
@@ -700,6 +632,7 @@ declare class TwoCrossingRoutesHighDensitySolver extends BaseSolver {
         via1: Point$2;
         via2: Point$2;
     }[];
+    escapeLayer: number;
     solvedRoutes: HighDensityIntraNodeRoute$1[];
     bounds: {
         minX: number;
@@ -727,20 +660,14 @@ declare class TwoCrossingRoutesHighDensitySolver extends BaseSolver {
      */
     private doRoutesCross;
     private calculateViaPositions;
-    /**
-     * Create a route with properly placed vias
-     */
-    private createRoute;
     /**
      * Try to solve with routeA going over and routeB staying on layer 0
      */
     private trySolveAOverB;
-    private optimizeViaPositions;
-    /**
-     * Calculate the orthogonal route points for the second route
-     */
-    private calculateConservativeOrthogonalRoutePoints;
-    private calculateShortestOrthogonalRoutePoints;
+    private pushViasFromEndpoints;
+    private getMinDistanceBetweenViaCenters;
+    private moveViasAsCloseAsPossible;
+    handleRoutesDontCross(): void;
     /**
      * Main step method that attempts to solve the two crossing routes
      */
@@ -806,6 +733,12 @@ declare class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<
             CLOSED_FORM_TWO_TRACE_TRANSITION_CROSSING: boolean;
             CLOSED_FORM_TWO_TRACE_SAME_LAYER?: undefined;
         })[];
+    } | {
+        name: string;
+        possibleValues: {
+            MULTI_HEAD_POLYLINE_SOLVER: boolean;
+            SEGMENTS_PER_POLYLINE: number;
+        }[];
     })[];
     computeG(solver: IntraNodeRouteSolver): number;
     computeH(solver: IntraNodeRouteSolver): number;
@@ -1024,6 +957,7 @@ declare class SingleHighDensityRouteStitchSolver extends BaseSolver {
         y: number;
         z: number;
     };
+    colorMap: Record<string, string>;
     constructor(opts: {
         connectionName?: string;
         hdRoutes: HighDensityIntraNodeRoute$1[];
@@ -1037,6 +971,7 @@ declare class SingleHighDensityRouteStitchSolver extends BaseSolver {
             y: number;
             z: number;
         };
+        colorMap?: Record<string, string>;
     });
     _step(): void;
     visualize(): GraphicsObject;
@@ -1060,9 +995,11 @@ declare class MultipleHighDensityRouteStitchSolver extends BaseSolver {
     unsolvedRoutes: UnsolvedRoute[];
     activeSolver: SingleHighDensityRouteStitchSolver | null;
     mergedHdRoutes: HighDensityIntraNodeRoute$1[];
+    colorMap: Record<string, string>;
     constructor(opts: {
         connections: SimpleRouteConnection[];
         hdRoutes: HighDensityIntraNodeRoute$1[];
+        colorMap?: Record<string, string>;
         layerCount: number;
     });
     _step(): void;
@@ -1124,6 +1061,7 @@ interface UnravelSection {
     mutableSegmentIds: Set<string>;
     immutableNodeIds: CapacityMeshNodeId[];
     segmentPointMap: SegmentPointMap;
+    mutableSegmentPointIds: Set<SegmentPointId>;
     segmentPairsInNode: Map<CapacityMeshNodeId, Array<[SegmentPointId, SegmentPointId]>>;
     segmentPointsInNode: Map<CapacityMeshNodeId, SegmentPointId[]>;
     segmentPointsInSegment: Map<SegmentId, SegmentPointId[]>;
@@ -1186,6 +1124,19 @@ type SegmentPointMapAndReverseMaps = {
     segmentToSegmentPointMap: Map<SegmentId, SegmentPointId[]>;
 };
 
+interface UnravelSectionSolverParams {
+    rootNodeId: CapacityMeshNodeId;
+    colorMap?: Record<string, string>;
+    MUTABLE_HOPS?: number;
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    dedupedSegments: SegmentWithAssignedPoints[];
+    dedupedSegmentMap?: Map<SegmentId, SegmentWithAssignedPoints>;
+    nodeIdToSegmentIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
+    segmentIdToNodeIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
+    segmentPointMap?: SegmentPointMap;
+    nodeToSegmentPointMap?: Map<CapacityMeshNodeId, SegmentPointId[]>;
+    segmentToSegmentPointMap?: Map<SegmentId, SegmentPointId[]>;
+}
 /**
  * The UntangleSectionSolver optimizes a section of connected capacity nodes
  * with their deduplicated segments.
@@ -1232,19 +1183,9 @@ declare class UnravelSectionSolver extends BaseSolver {
     iterationsSinceImprovement: number;
     selectedCandidateIndex: number | "best" | "original" | null;
     queuedOrExploredCandidatePointModificationHashes: Set<string>;
-    constructor(params: {
-        rootNodeId: CapacityMeshNodeId;
-        colorMap?: Record<string, string>;
-        MUTABLE_HOPS?: number;
-        nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
-        dedupedSegments: SegmentWithAssignedPoints[];
-        dedupedSegmentMap?: Map<SegmentId, SegmentWithAssignedPoints>;
-        nodeIdToSegmentIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
-        segmentIdToNodeIds: Map<CapacityMeshNodeId, CapacityMeshNodeId[]>;
-        segmentPointMap?: SegmentPointMap;
-        nodeToSegmentPointMap?: Map<CapacityMeshNodeId, SegmentPointId[]>;
-        segmentToSegmentPointMap?: Map<SegmentId, SegmentPointId[]>;
-    });
+    constructorParams: UnravelSectionSolverParams;
+    constructor(params: UnravelSectionSolverParams);
+    getConstructorParams(): UnravelSectionSolverParams;
     createUnravelSection(largeSpMaps?: SegmentPointMapAndReverseMaps): UnravelSection;
     createInitialCandidate(): UnravelCandidate;
     get nextCandidate(): UnravelCandidate | null;
@@ -1281,12 +1222,13 @@ declare class UnravelMultiSectionSolver extends BaseSolver {
     MAX_NODE_ATTEMPTS: number;
     MUTABLE_HOPS: number;
     ACCEPTABLE_PF: number;
+    MAX_ITERATIONS_WITHOUT_IMPROVEMENT: number;
     /**
      * Probability of failure for each node
      */
     nodePfMap: Map<CapacityMeshNodeId, number>;
     attemptsToFixNode: Map<CapacityMeshNodeId, number>;
-    activeSolver: UnravelSectionSolver | null;
+    activeSubSolver: UnravelSectionSolver | null;
     segmentPointMap: SegmentPointMap;
     constructor({ assignedSegments, colorMap, nodes, }: {
         assignedSegments: NodePortSegment[];
@@ -1304,6 +1246,82 @@ declare class UnravelMultiSectionSolver extends BaseSolver {
     getNodesWithPortPoints(): NodeWithPortPoints[];
 }
 
+interface CapacityHyperParameters {
+    VIA_DIAMETER: number;
+    TRACE_WIDTH: number;
+    MAX_CAPACITY_FACTOR: number;
+}
+
+type Candidate$1 = {
+    prevCandidate: Candidate$1 | null;
+    node: CapacityMeshNode;
+    f: number;
+    g: number;
+    h: number;
+};
+type ConnectionPathWithNodes = {
+    connection: SimpleRouteConnection;
+    nodes: CapacityMeshNode[];
+    path?: CapacityMeshNode[];
+    straightLineDistance: number;
+};
+declare class CapacityPathingSolver extends BaseSolver {
+    connectionsWithNodes: Array<ConnectionPathWithNodes>;
+    usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    simpleRouteJson: SimpleRouteJson;
+    nodes: CapacityMeshNode[];
+    edges: CapacityMeshEdge[];
+    GREEDY_MULTIPLIER: number;
+    MAX_CANDIDATES_IN_MEMORY: number;
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
+    connectionNameToGoalNodeIds: Map<string, CapacityMeshNodeId[]>;
+    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;
+        nodes: CapacityMeshNode[];
+        edges: CapacityMeshEdge[];
+        colorMap?: Record<string, string>;
+        MAX_ITERATIONS?: number;
+        hyperParameters?: Partial<CapacityHyperParameters>;
+    });
+    getTotalCapacity(node: CapacityMeshNode): number;
+    getConnectionsWithNodes(): {
+        connectionsWithNodes: {
+            connection: SimpleRouteConnection;
+            nodes: CapacityMeshNode[];
+            pathFound: boolean;
+            straightLineDistance: number;
+        }[];
+        connectionNameToGoalNodeIds: Map<string, string[]>;
+    };
+    currentConnectionIndex: number;
+    candidates?: Array<Candidate$1> | null;
+    visitedNodes?: Set<CapacityMeshNodeId> | null;
+    computeG(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    getBacktrackedPath(candidate: Candidate$1): CapacityMeshNode[];
+    getNeighboringNodes(node: CapacityMeshNode): CapacityMeshNode[];
+    getCapacityPaths(): CapacityPath[];
+    doesNodeHaveCapacityForTrace(node: CapacityMeshNode, prevNode: CapacityMeshNode): boolean;
+    canTravelThroughObstacle(node: CapacityMeshNode, connectionName: string): boolean;
+    getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
+    reduceCapacityAlongPath(nextConnection: {
+        path?: CapacityMeshNode[];
+    }): void;
+    isConnectedToEndGoal(node: CapacityMeshNode, endGoal: CapacityMeshNode): boolean;
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
 declare class CapacityPathingSolver5 extends CapacityPathingSolver {
     NEGATIVE_CAPACITY_PENALTY_FACTOR: number;
     REDUCED_CAPACITY_PENALTY_FACTOR: number;
@@ -1320,8 +1338,159 @@ declare class CapacityPathingSolver5 extends CapacityPathingSolver {
      * To minimize shortest path, you'd want to comment this out.
      */
     getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
+    computeG(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+}
+
+declare class CapacityPathingGreedySolver extends CapacityPathingSolver5 {
+    doesNodeHaveCapacityForTrace(node: CapacityMeshNode, prevNode: CapacityMeshNode): boolean;
+    getNodeCapacityPenalty(node: CapacityMeshNode): number;
+}
+
+type Candidate = {
+    prevCandidate: Candidate | null;
+    node: CapacityMeshNode;
+    f: number;
+    g: number;
+    h: number;
+};
+interface CpssPathingSolverHyperParameters {
+    SHUFFLE_SEED?: number;
+    EXPANSION_DEGREES?: number;
+}
+interface CapacityPathingSingleSectionPathingSolverParams {
+    sectionNodes: CapacityMeshNode[];
+    sectionEdges: CapacityMeshEdge[];
+    sectionConnectionTerminals: Array<{
+        connectionName: string;
+        startNodeId: CapacityMeshNodeId;
+        endNodeId: CapacityMeshNodeId;
+    }>;
+    colorMap?: Record<string, string>;
+    hyperParameters?: CpssPathingSolverHyperParameters;
+}
+declare class CapacityPathingSingleSectionPathingSolver extends BaseSolver {
+    GREEDY_MULTIPLIER: number;
+    sectionNodes: CapacityMeshNode[];
+    sectionEdges: CapacityMeshEdge[];
+    sectionConnectionTerminals: Array<{
+        connectionName: string;
+        startNodeId: CapacityMeshNodeId;
+        endNodeId: CapacityMeshNodeId;
+        path?: CapacityMeshNode[];
+    }>;
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
+    colorMap: Record<string, string>;
+    usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    MAX_CANDIDATES_IN_MEMORY: number;
+    currentConnectionIndex: number;
+    candidates?: Array<Candidate> | null;
+    visitedNodes?: Set<CapacityMeshNodeId> | null;
+    queuedNodes?: Set<CapacityMeshNodeId> | null;
+    activeCandidateStraightLineDistance?: number;
+    debug_lastNodeCostMap: Map<CapacityMeshNodeId, {
+        g: number;
+        h: number;
+        f: number;
+    }>;
+    maxCapacityFactor: number;
+    constructor(params: CapacityPathingSingleSectionPathingSolverParams);
+    getTotalCapacity(node: CapacityMeshNode): number;
+    getNodeCapacityPenalty(node: CapacityMeshNode): number;
+    getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
     computeG(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    computeH(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate, // prevCandidate not strictly needed here
+    node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    getBacktrackedPath(candidate: Candidate): CapacityMeshNode[];
+    getNeighboringNodes(node: CapacityMeshNode): CapacityMeshNode[];
+    isConnectedToEndGoal(node: CapacityMeshNode, endGoal: CapacityMeshNode): boolean;
+    doesNodeHaveCapacityForTrace(node: CapacityMeshNode, prevNode: CapacityMeshNode | null): boolean;
+    reduceCapacityAlongPath(path: CapacityMeshNode[]): void;
+    _step(): void;
+    private _setupAStar;
+    private _handleCandidatesExhausted;
+    private _handleGoalReached;
+    visualize(): GraphicsObject;
+}
+
+interface CapacityPathingSingleSectionSolverInput {
+    centerNodeId: CapacityMeshNodeId;
+    connectionsWithNodes: Array<ConnectionPathWithNodes>;
+    nodes: CapacityMeshNode[];
+    edges: CapacityMeshEdge[];
+    colorMap: Record<string, string>;
+    hyperParameters?: CpssPathingSolverHyperParameters;
+}
+declare class CapacityPathingSingleSectionSolver extends BaseSolver {
+    centerNodeId: CapacityMeshNodeId;
+    connectionsWithNodes: Array<ConnectionPathWithNodes>;
+    nodes: CapacityMeshNode[];
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    edges: CapacityMeshEdge[];
+    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
+    expansionDegrees: number;
+    colorMap: Record<string, string>;
+    sectionNodes: CapacityMeshNode[];
+    sectionEdges: CapacityMeshEdge[];
+    sectionConnectionTerminals: Array<{
+        connectionName: string;
+        startNodeId: CapacityMeshNodeId;
+        endNodeId: CapacityMeshNodeId;
+    }>;
+    activeSubSolver?: CapacityPathingSingleSectionPathingSolver | null | undefined;
+    constructor(params: CapacityPathingSingleSectionSolverInput);
+    private computeSectionNodesTerminalsAndEdges;
+    _step(): void;
+    getConstructorParams(): readonly [{
+        readonly centerNodeId: string;
+        readonly connectionsWithNodes: ConnectionPathWithNodes[];
+        readonly nodes: CapacityMeshNode[];
+        readonly edges: CapacityMeshEdge[];
+        readonly expansionDegrees: number;
+    }];
+    visualize(): GraphicsObject;
+}
+
+/**
+ * This solver solves for capacity paths by first solving with negative
+ * capacities allowed, then re-solving problematic sections with a section
+ * solver.
+ */
+declare class CapacityPathingMultiSectionSolver extends BaseSolver {
+    simpleRouteJson: SimpleRouteJson;
+    nodes: CapacityMeshNode[];
+    edges: CapacityMeshEdge[];
+    connectionsWithNodes: Array<ConnectionPathWithNodes>;
+    colorMap: Record<string, string>;
+    initialSolver: CapacityPathingGreedySolver;
+    stage: "initialization" | "section-optimization";
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    totalNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    nodeCapacityPercentMap: Map<CapacityMeshNodeId, number>;
+    nodeOptimizationAttemptCountMap: Map<CapacityMeshNodeId, number>;
+    sectionSolver?: CapacityPathingSingleSectionSolver | null;
+    MAX_ATTEMPTS_PER_NODE: number;
+    MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: number;
+    MAX_EXPANSION_DEGREES: number;
+    constructor(params: ConstructorParameters<typeof CapacityPathingSolver>[0]);
+    _stepInitialization(): void;
+    _getNextNodeToOptimize(): CapacityMeshNodeId | null;
+    _stepSectionOptimization(): void;
+    /**
+     * Merges the paths found by a successful section solver back into the main
+     * connectionsWithNodes list.
+     */
+    private _mergeSolvedSectionPaths;
+    /**
+     * Recalculates node capacity usage based on the current connectionsWithNodes
+     * and updates the nodeCapacityPercentMap.
+     */
+    private _recalculateNodeCapacityUsage;
+    getCapacityPaths(): CapacityPath[];
+    _step(): void;
+    visualize(): graphics_debug.GraphicsObject;
 }
 
 declare class StrawSolver extends BaseSolver {
@@ -1430,7 +1599,12 @@ declare class MultiSimplifiedPathSolver extends BaseSolver {
 }
 
 declare class CapacityMeshEdgeSolver2_NodeTreeOptimization extends CapacityMeshEdgeSolver {
-    step(): void;
+    nodes: CapacityMeshNode[];
+    private nodeTree;
+    private currentNodeIndex;
+    private edgeSet;
+    constructor(nodes: CapacityMeshNode[]);
+    _step(): void;
 }
 
 interface Point {
@@ -1514,6 +1688,11 @@ declare class SingleRouteUselessViaRemovalSolver extends BaseSolver {
         currentSection: RouteSection;
         targetZ: number;
     }): boolean;
+    getConstructorParams(): {
+        obstacleSHI: ObstacleSpatialHashIndex;
+        hdRouteSHI: HighDensityRouteSpatialIndex;
+        unsimplifiedRoute: HighDensityIntraNodeRoute;
+    };
     getOptimizedHdRoute(): HighDensityRoute;
     visualize(): GraphicsObject;
 }
@@ -1555,7 +1734,7 @@ declare class AutoroutingPipelineSolver extends BaseSolver {
     nodeSolver?: CapacityMeshNodeSolver;
     nodeTargetMerger?: CapacityNodeTargetMerger;
     edgeSolver?: CapacityMeshEdgeSolver;
-    pathingSolver?: CapacityPathingSolver;
+    pathingSolver?: CapacityPathingMultiSectionSolver;
     edgeToPortSegmentSolver?: CapacityEdgeToPortSegmentSolver;
     colorMap: Record<string, string>;
     segmentToPointSolver?: CapacitySegmentToPointSolver;
@@ -1565,8 +1744,10 @@ declare class AutoroutingPipelineSolver extends BaseSolver {
     highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
     singleLayerNodeMerger?: SingleLayerNodeMergerSolver;
     strawSolver?: StrawSolver;
-    uselessViaRemovalSolver?: UselessViaRemovalSolver;
-    multiSimplifiedPathSolver?: MultiSimplifiedPathSolver;
+    uselessViaRemovalSolver1?: UselessViaRemovalSolver;
+    uselessViaRemovalSolver2?: UselessViaRemovalSolver;
+    multiSimplifiedPathSolver1?: MultiSimplifiedPathSolver;
+    multiSimplifiedPathSolver2?: MultiSimplifiedPathSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
@@ -1574,7 +1755,7 @@ declare class AutoroutingPipelineSolver extends BaseSolver {
     connMap: ConnectivityMap;
     srjWithPointPairs?: SimpleRouteJson;
     capacityNodes: CapacityMeshNode[] | null;
-    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver2_NodeUnderObstacle> | PipelineStep<typeof SingleLayerNodeMergerSolver> | PipelineStep<typeof StrawSolver> | PipelineStep<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep<typeof CapacityPathingSolver5> | PipelineStep<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep<typeof CapacitySegmentToPointSolver> | PipelineStep<typeof UnravelMultiSectionSolver> | PipelineStep<typeof HighDensitySolver> | PipelineStep<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep<typeof UselessViaRemovalSolver> | PipelineStep<typeof MultiSimplifiedPathSolver>)[];
+    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver2_NodeUnderObstacle> | PipelineStep<typeof SingleLayerNodeMergerSolver> | PipelineStep<typeof StrawSolver> | PipelineStep<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep<typeof CapacityPathingMultiSectionSolver> | PipelineStep<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep<typeof CapacitySegmentToPointSolver> | PipelineStep<typeof UnravelMultiSectionSolver> | PipelineStep<typeof HighDensitySolver> | PipelineStep<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep<typeof UselessViaRemovalSolver> | PipelineStep<typeof MultiSimplifiedPathSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions);
     currentPipelineStepIndex: number;
     _step(): void;
@@ -1620,6 +1801,7 @@ type CapacityMeshSolver = AutoroutingPipelineSolver;
  */
 declare const getTunedTotalCapacity1: (nodeOrWidth: CapacityMeshNode | {
     width: number;
+    availableZ?: number[];
 }, maxCapacityFactor?: number) => number;
 /**
  * Calculate the optimal subdivision depth to reach a target minimum capacity