@tscircuit/capacity-autorouter 0.0.237 → 0.0.238

package/dist/index.d.ts

@@ -2,6 +2,7 @@ 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 { JumperGraphSolver } from '@tscircuit/hypergraph';
 import { ConnectivityMap as ConnectivityMap$1 } from 'connectivity-map';
 import { Polygon } from '@tscircuit/math-utils';
 
@@ -32,7 +33,7 @@ interface SimpleRouteJson {
     nominalTraceWidth?: number;
     minViaDiameter?: number;
     defaultObstacleMargin?: number;
-    obstacles: Obstacle$1[];
+    obstacles: Obstacle[];
     connections: Array<SimpleRouteConnection>;
     bounds: {
         minX: number;
@@ -47,7 +48,7 @@ interface SimpleRouteJson {
     traces?: SimplifiedPcbTraces;
     allowJumpers?: boolean;
 }
-interface Obstacle$1 {
+interface Obstacle {
     obstacleId?: string;
     type: "rect";
     layers: string[];
@@ -102,7 +103,7 @@ interface SimplifiedPcbTrace {
             y: number;
         };
         /** Footprint size, typically "0603" */
-        footprint: "0603" | "1206";
+        footprint: "0603" | "1206" | "1206x4_pair";
         layer: string;
     }>;
 }
@@ -253,7 +254,9 @@ type HighDensityIntraNodeRoute$1 = {
 type HighDensityRoute$1 = HighDensityIntraNodeRoute$1;
 /**
  * A jumper component used to allow traces to cross on single-layer PCBs.
- * Uses a 0603 footprint
+ * - "0603": Single 0603 jumper
+ * - "1206": Single 1206 jumper
+ * - "1206x4_pair": One of 4 internal jumper pairs in a 1206x4 resistor array
  */
 type Jumper = {
     route_type: "jumper";
@@ -267,8 +270,8 @@ type Jumper = {
         x: number;
         y: number;
     };
-    /** Footprint size, typically "0603" */
-    footprint: "0603" | "1206";
+    /** Footprint size */
+    footprint: "0603" | "1206" | "1206x4_pair";
 };
 /**
  * An intra-node route that uses jumpers instead of vias for single-layer PCBs.
@@ -898,10 +901,10 @@ declare class HighDensitySolver extends BaseSolver {
 declare class CapacityNodeTargetMerger extends BaseSolver {
     nodes: CapacityMeshNode[];
     connMap: ConnectivityMap;
-    unprocessedObstacles: Obstacle$1[];
+    unprocessedObstacles: Obstacle[];
     newNodes: CapacityMeshNode[];
     removedNodeIds: Set<string>;
-    constructor(nodes: CapacityMeshNode[], obstacles: Obstacle$1[], connMap: ConnectivityMap);
+    constructor(nodes: CapacityMeshNode[], obstacles: Obstacle[], connMap: ConnectivityMap);
     _step(): void;
     visualize(): GraphicsObject;
 }
@@ -1178,7 +1181,7 @@ declare class TraceSimplificationSolver extends BaseSolver {
      */
     constructor(simplificationConfig: {
         hdRoutes: HighDensityRoute$1[];
-        obstacles: Obstacle$1[];
+        obstacles: Obstacle[];
         connMap: ConnectivityMap;
         colorMap: Record<string, string>;
         outline?: Array<{
@@ -1996,7 +1999,7 @@ interface CapacityMeshSolverOptions$3 {
     cacheProvider?: CacheProvider | null;
     effort?: number;
 }
-type PipelineStep$4<T extends new (...args: any[]) => BaseSolver> = {
+type PipelineStep$3<T extends new (...args: any[]) => BaseSolver> = {
     solverName: string;
     solverClass: T;
     getConstructorParams: (instance: AutoroutingPipelineSolver2_PortPointPathing) => ConstructorParameters<T>;
@@ -2031,7 +2034,7 @@ declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
     capacityNodes: CapacityMeshNode[] | null;
     capacityEdges: CapacityMeshEdge[] | null;
     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$3<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$3<typeof RectDiffPipeline> | PipelineStep$3<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$3<typeof AvailableSegmentPointSolver> | PipelineStep$3<typeof HyperPortPointPathingSolver> | PipelineStep$3<typeof MultiSectionPortPointOptimizer> | PipelineStep$3<typeof HighDensitySolver> | PipelineStep$3<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$3<typeof TraceSimplificationSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$3);
     getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions$3];
     currentPipelineStepIndex: number;
@@ -2854,7 +2857,7 @@ interface CapacityMeshSolverOptions$2 {
     targetMinCapacity?: number;
     cacheProvider?: CacheProvider | null;
 }
-type PipelineStep$3<T extends new (...args: any[]) => BaseSolver> = {
+type PipelineStep$2<T extends new (...args: any[]) => BaseSolver> = {
     solverName: string;
     solverClass: T;
     getConstructorParams: (instance: AutoroutingPipeline1_OriginalUnravel) => ConstructorParameters<T>;
@@ -2891,7 +2894,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$2<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$2<typeof RectDiffPipeline> | PipelineStep$2<typeof StrawSolver> | PipelineStep$2<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$2<typeof DeadEndSolver> | PipelineStep$2<typeof CapacityPathingGreedySolver> | PipelineStep$2<typeof CapacityPathingMultiSectionSolver> | PipelineStep$2<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep$2<typeof CapacitySegmentToPointSolver> | PipelineStep$2<typeof UnravelMultiSectionSolver> | PipelineStep$2<typeof HighDensitySolver> | PipelineStep$2<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$2<typeof TraceSimplificationSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$2);
     getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions$2];
     currentPipelineStepIndex: number;
@@ -2991,419 +2994,503 @@ declare class SimpleHighDensitySolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-type FutureConnection = {
-    connectionName: string;
-    points: {
+type HyperGraphPatternType = "single_1206x4" | "1x2_1206x4" | "2x2_1206x4";
+interface JumperPrepatternSolver2HyperParameters {
+    /** Pattern type for jumper placement - "single_1206x4" (~8x8mm) or "2x2_1206x4" (~14x14mm) */
+    PATTERN_TYPE?: HyperGraphPatternType;
+    /** Orientation of jumpers - "horizontal" or "vertical" */
+    ORIENTATION?: "horizontal" | "vertical";
+}
+interface JumperPrepatternSolver2Params {
+    nodeWithPortPoints: NodeWithPortPoints;
+    colorMap?: Record<string, string>;
+    traceWidth?: number;
+    hyperParameters?: JumperPrepatternSolver2HyperParameters;
+    connMap?: ConnectivityMap;
+}
+interface XYConnection {
+    start: {
         x: number;
         y: number;
-        z: number;
-    }[];
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    connectionId: string;
+}
+declare class JumperPrepatternSolver2_HyperGraph extends BaseSolver {
+    constructorParams: JumperPrepatternSolver2Params;
+    nodeWithPortPoints: NodeWithPortPoints;
+    colorMap: Record<string, string>;
+    traceWidth: number;
+    hyperParameters: JumperPrepatternSolver2HyperParameters;
+    jumperGraphSolver: JumperGraphSolver | null;
+    xyConnections: XYConnection[];
+    graphBounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    } | null;
+    solvedRoutes: HighDensityIntraNodeRouteWithJumpers[];
+    constructor(params: JumperPrepatternSolver2Params);
+    getConstructorParams(): JumperPrepatternSolver2Params;
+    private _buildColorMap;
+    private _getPatternConfig;
+    private _initializeGraph;
+    _step(): void;
+    private _processResults;
+    getOutput(): HighDensityIntraNodeRouteWithJumpers[];
+    visualize(): GraphicsObject;
+    private _drawJumperPads;
+}
+
+interface HyperJumperPrepatternSolver2Params {
+    nodeWithPortPoints: NodeWithPortPoints;
+    colorMap?: Record<string, string>;
+    traceWidth?: number;
+    connMap?: ConnectivityMap;
+    hyperParameters?: JumperPrepatternSolver2HyperParameters;
+}
+type VariantHyperParameters = {
+    PATTERN_TYPE: HyperGraphPatternType;
+    ORIENTATION: "horizontal" | "vertical";
 };
 /**
- * Components that make up the g (cost so far) calculation
+ * HyperJumperPrepatternSolver2 runs multiple variants of JumperPrepatternSolver2_HyperGraph
+ * with different pattern types and orientations, then picks the best solution.
+ *
+ * Variants:
+ * - single_1206x4_vertical
+ * - single_1206x4_horizontal
+ * - 2x2_1206x4_vertical (only if node is large enough, ~14x14mm)
+ * - 2x2_1206x4_horizontal (only if node is large enough, ~14x14mm)
  */
-type GComponents = {
-    /** Total path distance traveled from start */
-    distFromStart: number;
-    /** Cumulative weighted penalty for being near obstacles */
-    weightedMmNearObstacle: number;
-    /** Cumulative weighted penalty for being near edges */
-    weightedMmNearEdge: number;
-    /** Cumulative weighted penalty for being near future connection start/end points */
-    weightedMmNearFutureConnectionStartEnd: number;
-    /** Cumulative weighted penalty for being near future connection lines */
-    weightedMmNearFutureConnectionLine: number;
-    /** Cumulative jumper penalty (includes jumper distance + penalty factor) */
-    jumperPenalty: number;
-    /** Cumulative penalty for jumper pads near future connections */
-    jumperPadFutureConnectionPenalty: number;
-    /** Total g value (sum of all components) */
-    total: number;
-};
+declare class HyperJumperPrepatternSolver2 extends HyperParameterSupervisorSolver<JumperPrepatternSolver2_HyperGraph> {
+    constructorParams: HyperJumperPrepatternSolver2Params;
+    nodeWithPortPoints: NodeWithPortPoints;
+    colorMap: Record<string, string>;
+    traceWidth: number;
+    connMap?: ConnectivityMap;
+    baseHyperParameters?: JumperPrepatternSolver2HyperParameters;
+    solvedRoutes: HighDensityIntraNodeRouteWithJumpers[];
+    constructor(params: HyperJumperPrepatternSolver2Params);
+    getConstructorParams(): HyperJumperPrepatternSolver2Params;
+    getHyperParameterDefs(): ({
+        name: string;
+        possibleValues: {
+            PATTERN_TYPE: HyperGraphPatternType;
+        }[];
+    } | {
+        name: string;
+        possibleValues: {
+            ORIENTATION: string;
+        }[];
+    })[];
+    getCombinationDefs(): string[][];
+    generateSolver(hyperParameters: VariantHyperParameters): JumperPrepatternSolver2_HyperGraph;
+    computeG(solver: JumperPrepatternSolver2_HyperGraph): number;
+    computeH(solver: JumperPrepatternSolver2_HyperGraph): number;
+    onSolve(solver: SupervisedSolver<JumperPrepatternSolver2_HyperGraph>): void;
+    getOutput(): HighDensityIntraNodeRouteWithJumpers[];
+    visualize(): GraphicsObject;
+}
+
+interface NodeAnalysis {
+    node: NodeWithPortPoints;
+    hasCrossings: boolean;
+    numSameLayerCrossings: number;
+}
 /**
- * Components that make up the h (heuristic) calculation
+ * HighDensitySolver intelligently selects the appropriate solver for each node:
+ * - SimpleHighDensitySolver for nodes without crossings (faster, force-directed)
+ * - IntraNodeSolverWithJumpers for single-layer nodes with crossings (uses 0603 jumpers)
+ *
+ * This solver processes nodes in batches based on their characteristics.
  */
-type HComponents = {
-    distanceToGoal: number;
-    obstacleProximity: number;
-    edgeProximity: number;
-    futureConnectionStartEndProximityPenalty: number;
-    futureConnectionLine: number;
-    total: number;
-    /** Stored rates (penalty per mm) for derivative computation */
-    obstacleProximityRate: number;
-    edgeProximityRate: number;
-    futureConnectionStartEndProximityRate: number;
-    futureConnectionLineRate: number;
-};
+declare class JumperHighDensitySolver extends BaseSolver {
+    allNodes: NodeWithPortPoints[];
+    nodeAnalyses: NodeAnalysis[];
+    routes: HighDensityIntraNodeRoute$1[];
+    colorMap: Record<string, string>;
+    traceWidth: number;
+    viaDiameter: number;
+    connMap?: ConnectivityMap;
+    hyperParameters?: Partial<HighDensityHyperParameters>;
+    nodesWithoutCrossings: NodeWithPortPoints[];
+    nodesWithCrossings: NodeWithPortPoints[];
+    simpleHighDensitySolver?: SimpleHighDensitySolver;
+    jumperSolvers: HyperJumperPrepatternSolver2[];
+    currentJumperSolverIndex: number;
+    phase: "analyzing" | "simple" | "jumpers" | "done";
+    constructor({ nodePortPoints, colorMap, traceWidth, viaDiameter, connMap, hyperParameters, }: {
+        nodePortPoints: NodeWithPortPoints[];
+        colorMap?: Record<string, string>;
+        traceWidth?: number;
+        viaDiameter?: number;
+        connMap?: ConnectivityMap;
+        hyperParameters?: Partial<HighDensityHyperParameters>;
+    });
+    /**
+     * Analyze all nodes to determine which solver to use for each
+     */
+    _analyzeNodes(): void;
+    _step(): void;
+    _stepSimpleSolver(): void;
+    _initializeJumperSolvers(): void;
+    _stepJumperSolvers(): void;
+    computeProgress(): number;
+    getConstructorParams(): {
+        nodePortPoints: NodeWithPortPoints[];
+        colorMap: Record<string, string>;
+        traceWidth: number;
+        viaDiameter: number;
+        connMap: ConnectivityMap | undefined;
+        hyperParameters: Partial<HighDensityHyperParameters> | undefined;
+    };
+    visualize(): GraphicsObject;
+}
+
 /**
- * Extended node type that tracks jumper usage
+ * ObstacleTree wraps different spatial index implementations:
+ * - 'native': original spatial-hash grid
+ * - 'rbush': dynamic R-tree via rbush
+ * - 'flatbush': static index via flatbush
  */
-type JumperNode = Node & {
-    /** If this node was reached via a jumper, this contains jumper info */
-    jumperEntry?: {
-        x: number;
-        y: number;
-    };
-    /** Track if this movement is the exit of a jumper */
-    isJumperExit?: boolean;
-    /** Count of jumpers used to reach this node */
-    jumperCount?: number;
-    /** Stored g components for debugging/visualization */
-    gComponents?: GComponents;
-    /** Stored h components for debugging/visualization */
-    hComponents?: HComponents;
-};
-declare class SingleHighDensityRouteWithJumpersSolver extends BaseSolver {
-    obstacleRoutes: HighDensityIntraNodeRouteWithJumpers[];
-    bounds: {
+declare class ObstacleSpatialHashIndex {
+    private idx;
+    private storage;
+    constructor(implementation?: "native" | "rbush" | "flatbush", obstacles?: Obstacle[]);
+    insert(o: Obstacle): void;
+    search(bbox: {
         minX: number;
-        maxX: number;
         minY: number;
+        maxX: number;
         maxY: number;
-    };
-    boundsSize: {
-        width: number;
-        height: number;
-    };
-    boundsCenter: {
-        x: number;
-        y: number;
-    };
-    A: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    B: {
+    }): Obstacle[];
+    searchArea(centerX: number, centerY: number, width: number, height: number): Obstacle[];
+}
+
+interface Point$1 {
+    x: number;
+    y: number;
+    z: number;
+}
+type Point2D$3 = {
+    x: number;
+    y: number;
+};
+type HighDensityIntraNodeRoute = {
+    connectionName: string;
+    rootConnectionName?: string;
+    traceThickness: number;
+    viaDiameter: number;
+    route: Array<{
         x: number;
         y: number;
         z: number;
-    };
-    roundedGoalPosition: {
+    }>;
+    vias: Array<{
         x: number;
         y: number;
-        z: number;
-    };
-    straightLineDistance: number;
-    traceThickness: number;
-    obstacleMargin: number;
-    minCellSize: number;
-    cellStep: number;
-    GREEDY_MULTIPLER: number;
-    numRoutes: number;
-    /** Penalty factor for using a jumper (relative to distance) */
-    JUMPER_PENALTY_FACTOR: number;
-    /** Future connection proximity parameters */
-    FUTURE_CONNECTION_START_END_PENALTY: number;
-    FUTURE_CONNECTION_START_END_PROXIMITY: number;
-    /** Future connection jumper pad penalty parameters */
-    FUTURE_CONNECTION_JUMPER_PAD_PROXIMITY: number;
-    FUTURE_CONNECTION_JUMPER_PAD_PENALTY: number;
-    /** Jumper-to-jumper pad proximity penalty parameters */
-    JUMPER_JUMPER_PAD_PROXIMITY: number;
-    JUMPER_JUMPER_PAD_PENALTY: number;
-    /** Future connection line proximity penalty parameters */
-    FUTURE_CONNECTION_LINE_PROXIMITY: number;
-    FUTURE_CONNECTION_LINE_PENALTY: number;
-    /** Obstacle proximity penalty parameters (repulsive field) */
-    OBSTACLE_PROX_PENALTY_FACTOR: number;
-    OBSTACLE_PROX_SIGMA: number;
-    /** Edge proximity penalty parameters */
-    EDGE_PROX_PENALTY_FACTOR: number;
-    EDGE_PROX_SIGMA: number;
-    /** Whether to allow diagonal movement in pathfinding */
-    ALLOW_DIAGONAL: boolean;
-    /** Minimum distance traveled before allowing jumper neighbors */
-    MIN_TRAVEL_BEFORE_JUMPER: number;
-    CELL_SIZE_FACTOR: number;
-    exploredNodes: Set<string>;
-    candidates: SingleRouteCandidatePriorityQueue<JumperNode>;
-    connectionName: string;
-    rootConnectionName?: string;
-    solvedPath: HighDensityIntraNodeRouteWithJumpers | null;
-    futureConnections: FutureConnection[];
-    hyperParameters: Partial<HighDensityHyperParameters>;
-    connMap?: ConnectivityMap;
-    /** For debugging/animating the exploration */
-    debug_exploredNodesOrdered: string[];
-    debug_exploredNodeValues: Map<string, {
-        g: number;
-        h: number;
-        f: number;
-        gComponents?: GComponents;
-        hComponents?: HComponents;
     }>;
-    debug_nodesTooCloseToObstacle: Set<string>;
-    debug_nodePathToParentIntersectsObstacle: Set<string>;
-    debugEnabled: boolean;
-    initialNodeGridOffset: {
-        x: number;
-        y: number;
-    };
-    /** Existing jumpers that act as obstacles */
-    existingJumpers: Jumper[];
-    constructor(opts: {
-        connectionName: string;
-        rootConnectionName?: string;
-        obstacleRoutes: HighDensityIntraNodeRouteWithJumpers[];
-        minDistBetweenEnteringPoints: number;
-        bounds: {
-            minX: number;
-            maxX: number;
-            minY: number;
-            maxY: number;
-        };
-        A: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        B: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        traceThickness?: number;
-        obstacleMargin?: number;
-        futureConnections?: FutureConnection[];
-        hyperParameters?: Partial<HighDensityHyperParameters>;
-        connMap?: ConnectivityMap;
-    });
-    handleSimpleCases(): void;
-    get jumperPenaltyDistance(): number;
-    /**
-     * Check if a node is too close to an obstacle trace or jumper
-     */
-    isNodeTooCloseToObstacle(node: JumperNode, margin?: number): boolean;
-    /**
-     * Check if a node is too close to a jumper's pads
-     * Traces CAN route under the body of the jumper, just not under the pads
-     */
-    isNodeTooCloseToJumper(node: {
-        x: number;
-        y: number;
-    }, jumper: Jumper, margin: number): boolean;
-    isNodeTooCloseToEdge(node: JumperNode): boolean;
-    doesPathToParentIntersectObstacle(node: JumperNode): boolean;
-    /**
-     * Check if a line segment intersects with a jumper's pads
-     * Segments CAN pass under the jumper body, just not through the pads
-     */
-    doesSegmentIntersectJumperPads(p1: {
-        x: number;
-        y: number;
-    }, p2: {
-        x: number;
-        y: number;
-    }, jumper: Jumper): boolean;
-    /**
-     * Check if a line segment intersects with an axis-aligned rectangle
-     */
-    doesSegmentIntersectRect(p1: {
-        x: number;
-        y: number;
-    }, p2: {
-        x: number;
-        y: number;
-    }, center: {
-        x: number;
-        y: number;
-    }, halfWidth: number, halfHeight: number): boolean;
+    jumpers?: Jumper[];
+};
+type HighDensityRoute = HighDensityIntraNodeRoute;
+declare class HighDensityRouteSpatialIndex {
+    private segmentBuckets;
+    private viaBuckets;
+    private CELL_SIZE;
+    constructor(routes: HighDensityRoute[], cellSize?: number);
     /**
-     * Find obstacles between current node and a target position
-     * Returns the obstacle segment(s) that block the direct path
+     * Finds routes that potentially conflict with a given line segment within a margin.
+     * Checks both segments and vias.
+     * @param segmentStart Start point of the query segment.
+     * @param segmentEnd End point of the query segment.
+     * @param margin The minimum required clearance distance from the query segment's centerline.
+     * @returns An array of conflicting routes and their minimum distance to the segment.
      */
-    findObstaclesBetween(from: {
-        x: number;
-        y: number;
-    }, to: {
-        x: number;
-        y: number;
-    }): Array<{
-        A: {
-            x: number;
-            y: number;
-        };
-        B: {
-            x: number;
-            y: number;
-        };
+    getConflictingRoutesForSegment(segmentStart: Point$1, // Keep Point for original Z data if needed elsewhere
+    segmentEnd: Point$1, margin: number): Array<{
+        conflictingRoute: HighDensityRoute;
+        distance: number;
     }>;
-    computeHComponents(node: JumperNode): HComponents;
-    computeH(node: JumperNode): number;
-    computeGComponents(node: JumperNode): GComponents;
-    computeG(node: JumperNode): number;
-    computeF(g: number, h: number): number;
-    getClosestFutureConnectionPoint(node: JumperNode): {
-        x: number;
-        y: number;
-        z: number;
-    } | null;
-    getFutureConnectionStartEndPenalty(node: JumperNode): number;
-    /**
-     * Calculate penalty for being close to future connection line segments.
-     * This penalty is computed by summing the segment-to-point distance between
-     * the node and all unrouted future connection start-to-end segments.
-     * The penalty helps routes avoid crossing directly over future connection paths.
-     */
-    getFutureConnectionLinePenalty(node: JumperNode): number;
     /**
-     * Calculate penalty for jumper pads placed near future connection start/end points.
-     * This disincentivizes placing jumper pads in areas that will be needed for future routing.
-     * The distance is calculated as the minimum distance from either jumper pad to any future connection point.
-     */
-    getJumperPadFutureConnectionPenalty(node: JumperNode): number;
-    /**
-     * Compute the minimum distance from a node to any obstacle (trace segments and jumper pads)
+     * Finds routes that pass near a given point within a margin.
+     * Checks both segments and vias.
+     * @param point The query point {x, y}. Z is ignored.
+     * @param margin The minimum required clearance distance from the query point.
+     * @returns An array of conflicting routes and their minimum distance to the point.
      */
-    getClearanceToObstacles(node: {
-        x: number;
-        y: number;
-    }): number;
+    getConflictingRoutesNearPoint(point: Point2D$3, margin: number): Array<{
+        conflictingRoute: HighDensityRoute;
+        distance: number;
+    }>;
+}
+
+interface Point2D$2 {
+    x: number;
+    y: number;
+}
+interface Segment {
+    start: Point2D$2;
+    end: Point2D$2;
+}
+
+interface Point2D$1 {
+    x: number;
+    y: number;
+}
+interface Point3D$1 extends Point2D$1 {
+    z: number;
+}
+interface TraceKeepoutSolverInput {
+    hdRoutes: HighDensityRoute$1[];
+    obstacles: Obstacle[];
+    connMap: ConnectivityMap;
+    colorMap: Record<string, string>;
+    keepoutRadiusSchedule?: number[];
+    srj?: Pick<SimpleRouteJson, "outline" | "bounds" | "layerCount">;
+}
+/**
+ * TraceKeepoutSolver adjusts traces to maintain keepout distance from obstacles
+ * and non-connected traces. It works by walking along each trace with a cursor,
+ * detecting obstacles within a keepout radius, and pushing the draw position
+ * orthogonally to avoid them.
+ *
+ * The solver processes traces through multiple passes with decreasing keepout
+ * radii as defined by KEEPOUT_RADIUS_SCHEDULE.
+ */
+declare class TraceKeepoutSolver extends BaseSolver {
+    private input;
+    originalHdRoutes: HighDensityRoute$1[];
+    hdRoutes: HighDensityRoute$1[];
+    redrawnHdRoutes: HighDensityRoute$1[];
+    KEEPOUT_RADIUS_SCHEDULE: number[];
+    currentScheduleIndex: number;
+    currentKeepoutRadius: number;
+    unprocessedRoutes: HighDensityRoute$1[];
+    smoothedCursorRoutes: HighDensityRoute$1[];
+    processedRoutes: HighDensityRoute$1[];
+    currentTrace: HighDensityRoute$1 | null;
+    cursorPosition: Point3D$1 | null;
+    lastCursorPosition: Point3D$1 | null;
+    drawPosition: Point2D$1 | null;
+    currentTraceSegmentIndex: number;
+    currentTraceSegmentT: number;
+    recordedDrawPositions: Point3D$1[];
+    lastCollidingSegments: Segment[];
+    obstacleSHI: ObstacleSpatialHashIndex;
+    hdRouteSHI: HighDensityRouteSpatialIndex;
+    boardOutlineRoutes: HighDensityRoute$1[];
+    constructor(input: TraceKeepoutSolverInput);
+    getSmoothDistance(): number;
+    _step(): void;
+    getStepDistance(): number;
     /**
-     * Compute distance from a point to the nearest jumper pad
+     * Steps the cursor forward by CURSOR_STEP_DISTANCE along the trace
+     * Returns false if we've reached the end of the trace
      */
-    distanceToJumperPads(p: {
-        x: number;
-        y: number;
-    }, j: Jumper): number;
+    private stepCursorForward;
     /**
-     * Compute distance from a point to an axis-aligned rectangle (0 if inside)
+     * Gets all colliding segments (obstacle edges and trace outlines) within the keepout radius
      */
-    pointToRectDistance(p: {
-        x: number;
-        y: number;
-    }, c: {
+    private getCollidingSegments;
+    positionHasCollision(position: {
         x: number;
         y: number;
-    }, halfW: number, halfH: number): number;
+        z: number;
+    }, margin?: number): boolean;
     /**
-     * Compute minimum distance from a node to the nearest boundary edge
+     * Finalizes the current trace with the recorded draw positions
      */
-    getClearanceToEdge(node: {
-        x: number;
-        y: number;
-    }): number;
+    private finalizeCurrentTrace;
     /**
-     * Compute the obstacle proximity penalty (repulsive field)
-     * Returns a high value near obstacles, ~0 far away
+     * Simplifies the route by removing collinear points
      */
-    getObstacleProximityPenalty(node: JumperNode): number;
+    private simplifyRoute;
     /**
-     * Compute the edge proximity penalty (repulsive field near boundaries)
-     * Returns a high value near edges, ~0 far away
-     * Penalty is reduced as we approach the goal (which is always on an edge)
+     * Creates artificial hdRoutes representing the board outline.
+     * These routes act as obstacles to prevent traces from being pushed outside the board.
      */
-    getEdgeProximityPenalty(node: JumperNode): number;
-    getNodeKey(node: JumperNode): string;
-    /**
-     * Calculate potential jumper positions to cross an obstacle
-     */
-    getJumperNeighbors(node: JumperNode): JumperNode[];
-    /**
-     * Calculate the exit position for a jumper that clears an obstacle
-     */
-    calculateJumperExit(entry: JumperNode, obstacle: {
-        A: {
-            x: number;
-            y: number;
-        };
-        B: {
-            x: number;
-            y: number;
-        };
-    }, direction: {
-        dx: number;
-        dy: number;
-    }): JumperNode | null;
-    /**
-     * Check if a jumper's pads are too close to obstacle traces
-     */
-    isJumperTooCloseToTraces(entry: {
-        x: number;
-        y: number;
-    }, exit: {
-        x: number;
-        y: number;
-    }): boolean;
+    private createBoardOutlineRoutes;
+    visualize(): GraphicsObject;
+    /** Returns the redrawn routes. This is the primary output of the solver. */
+    getRedrawnHdRoutes(): HighDensityRoute$1[];
+}
+
+interface Point2D {
+    x: number;
+    y: number;
+}
+interface Point3D extends Point2D {
+    z: number;
+}
+interface TraceWidthSolverInput {
+    hdRoutes: HighDensityRoute$1[];
+    obstacles?: Obstacle[];
+    connMap?: ConnectivityMap;
+    colorMap?: Record<string, string>;
+    nominalTraceWidth?: number;
+    minTraceWidth: number;
+    obstacleMargin?: number;
+}
+/**
+ * TraceWidthSolver determines the optimal trace width for each route.
+ * It uses a TRACE_WIDTH_SCHEDULE to try progressively narrower widths:
+ * [nominalTraceWidth, (nominalTraceWidth + minTraceWidth)/2, minTraceWidth]
+ *
+ * For each trace, it walks along with a cursor checking clearance.
+ * If clearance is insufficient for the current width, it tries the next
+ * narrower width in the schedule.
+ *
+ * nominalTraceWidth defaults to minTraceWidth * 2 if not specified.
+ */
+declare class TraceWidthSolver extends BaseSolver {
+    hdRoutes: HighDensityRoute$1[];
+    hdRoutesWithWidths: HighDensityRoute$1[];
+    nominalTraceWidth: number;
+    minTraceWidth: number;
+    obstacleMargin: number;
+    TRACE_WIDTH_SCHEDULE: number[];
+    unprocessedRoutes: HighDensityRoute$1[];
+    processedRoutes: HighDensityRoute$1[];
+    currentTrace: HighDensityRoute$1 | null;
+    cursorPosition: Point3D | null;
+    currentTraceSegmentIndex: number;
+    currentTraceSegmentT: number;
+    currentScheduleIndex: number;
+    currentTargetWidth: number;
+    hasInsufficientClearance: boolean;
+    currentWalkMinClearance: number;
+    bestMinClearance: number;
+    bestWidth: number;
+    lastCollidingObstacles: Obstacle[];
+    lastCollidingRoutes: HighDensityRoute$1[];
+    lastClearance: number;
+    obstacles: Obstacle[];
+    obstacleSHI?: ObstacleSpatialHashIndex;
+    hdRouteSHI: HighDensityRouteSpatialIndex;
+    connMap?: ConnectivityMap;
+    colorMap?: Record<string, string>;
+    constructor(input: TraceWidthSolverInput);
+    _step(): void;
     /**
-     * Verify that a jumper placement is valid (doesn't overlap with existing jumpers or traces)
+     * Initializes/resets the cursor for processing a trace
      */
-    isJumperPlacementValid(entry: JumperNode, exit: JumperNode): boolean;
+    private initializeCursor;
     /**
-     * Check if two jumpers overlap
+     * Steps the cursor forward by CURSOR_STEP_DISTANCE along the trace
+     * Returns false if we've reached the end of the trace
      */
-    doJumpersOverlap(j1: Jumper, j2: Jumper): boolean;
+    private stepCursorForward;
     /**
-     * Get all jumpers in the path to a node
+     * Gets the minimum clearance at a given position from obstacles and other traces
+     * Also updates lastCollidingObstacles and lastCollidingRoutes for visualization
      */
-    getJumpersInPath(node: JumperNode): Jumper[];
-    getNeighbors(node: JumperNode): JumperNode[];
-    getNodePath(node: JumperNode): JumperNode[];
-    setSolvedPath(node: JumperNode): void;
-    computeProgress(currentNode: JumperNode, goalDist: number): number;
-    _step(): void;
+    private getClearanceAtPosition;
     /**
-     * Draw the two pads of an 0603 jumper
-     * Pad dimensions are rotated based on jumper orientation
+     * Finalizes the current trace with the given width
      */
-    private drawJumperPads;
+    private finalizeCurrentTrace;
     visualize(): GraphicsObject;
+    /** Returns the routes with determined widths. This is the primary output of the solver. */
+    getHdRoutesWithWidths(): HighDensityRoute$1[];
 }
 
+interface OffboardPortPoint {
+    portPointId: string;
+    x: number;
+    y: number;
+    /** The obstacle this port point is at the center of */
+    obstacleIndex: number;
+    /** The offBoardConnectsTo ids this port point is associated with */
+    offBoardConnectionIds: OffBoardConnectionId[];
+    /** Available Z layers for this port point based on obstacle layers */
+    availableZ: number[];
+}
+interface OffboardPathFragment {
+    pathFragmentId: string;
+    /** The shared offBoardConnectsTo id that connects these port points */
+    offBoardConnectionId: OffBoardConnectionId;
+    /** The two port points connected by this path fragment */
+    portPointIds: [string, string];
+    /** Endpoints of this edge */
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+}
+type Phase = "finding_obstacles" | "creating_fragments" | "done";
+interface PendingFragment {
+    offBoardId: OffBoardConnectionId;
+    pp1: OffboardPortPoint;
+    pp2: OffboardPortPoint;
+}
 /**
- * IntraNodeSolverWithJumpers is designed for single-layer nodes that use
- * 0603 jumpers to allow traces to jump over each other.
+ * PortPointOffboardPathFragmentSolver finds obstacles with offBoardConnectsTo
+ * defined and creates port points at their centers. It then creates path
+ * fragments (edges) connecting port points that share the same offBoardConnectsTo
+ * ids.
  *
- * Unlike the standard IntraNodeRouteSolver which uses vias to change layers,
- * this solver operates on a single layer and uses physical jumper components
- * to handle trace crossings.
+ * This enables routing through off-board connections like flex cables or
+ * external connectors.
+ *
+ * The solver iterates step-by-step:
+ * 1. Phase "finding_obstacles": Process one obstacle per step, creating port points
+ * 2. Phase "creating_fragments": Create one path fragment per step
+ * 3. Phase "done": Solver complete
  */
-declare class IntraNodeSolverWithJumpers extends BaseSolver {
-    nodeWithPortPoints: NodeWithPortPoints;
+declare class PortPointOffboardPathFragmentSolver extends BaseSolver {
+    srj: SimpleRouteJson;
     colorMap: Record<string, string>;
-    unsolvedConnections: {
-        connectionName: string;
-        rootConnectionName?: string;
-        points: {
-            x: number;
-            y: number;
-            z: number;
-        }[];
-    }[];
-    totalConnections: number;
-    solvedRoutes: HighDensityIntraNodeRouteWithJumpers[];
-    failedSubSolvers: SingleHighDensityRouteWithJumpersSolver[];
-    hyperParameters: Partial<HighDensityHyperParameters>;
-    minDistBetweenEnteringPoints: number;
-    traceWidth: number;
-    activeSubSolver: SingleHighDensityRouteWithJumpersSolver | null;
-    lastActiveSubSolver: SingleHighDensityRouteWithJumpersSolver | null;
-    connMap?: ConnectivityMap;
-    get failedSolvers(): SingleHighDensityRouteWithJumpersSolver[];
-    get activeSolver(): SingleHighDensityRouteWithJumpersSolver | null;
-    constructor(params: {
-        nodeWithPortPoints: NodeWithPortPoints;
+    /** Current phase of the solver */
+    phase: Phase;
+    /** Index of the current obstacle being processed */
+    currentObstacleIndex: number;
+    /** Obstacles that have offBoardConnectsTo defined */
+    offboardObstacles: Array<{
+        obstacle: Obstacle;
+        index: number;
+    }>;
+    /** Port points created at obstacle centers */
+    portPoints: OffboardPortPoint[];
+    /** Map from portPointId to OffboardPortPoint */
+    portPointMap: Map<string, OffboardPortPoint>;
+    /** Path fragments connecting port points with shared offBoardConnectsTo */
+    pathFragments: OffboardPathFragment[];
+    /** Map from offBoardConnectionId to port points that share it */
+    offBoardConnectionToPortPoints: Map<OffBoardConnectionId, OffboardPortPoint[]>;
+    /** Pending path fragments to create (computed after obstacle phase) */
+    pendingFragments: PendingFragment[];
+    /** Index of current fragment being created */
+    currentFragmentIndex: number;
+    /** Last processed obstacle (for visualization) */
+    lastProcessedObstacle: {
+        obstacle: Obstacle;
+        index: number;
+    } | null;
+    /** Last created port point (for visualization) */
+    lastCreatedPortPoint: OffboardPortPoint | null;
+    /** Last created path fragment (for visualization) */
+    lastCreatedFragment: OffboardPathFragment | null;
+    /** Color map for offBoardConnectionIds */
+    offBoardColorMap: Record<string, string>;
+    constructor({ srj, colorMap, }: {
+        srj: SimpleRouteJson;
         colorMap?: Record<string, string>;
-        hyperParameters?: Partial<HighDensityHyperParameters>;
-        connMap?: ConnectivityMap;
-        traceWidth?: number;
     });
-    getConstructorParams(): {
-        nodeWithPortPoints: NodeWithPortPoints;
-        colorMap: Record<string, string>;
-        hyperParameters: Partial<HighDensityHyperParameters>;
-        connMap: ConnectivityMap | undefined;
-        traceWidth: number;
-    };
-    computeProgress(): number;
     _step(): void;
-    /**
-     * Draw the two pads of an 0603 jumper
-     * Pad dimensions are rotated based on jumper orientation
-     */
-    private drawJumperPads;
+    private stepFindingObstacles;
+    private computePendingFragments;
+    private stepCreatingFragments;
+    private layerToZ;
+    computeProgress(): number;
     visualize(): GraphicsObject;
 }
 
@@ -3427,11 +3514,11 @@ declare class RelateNodesToOffBoardConnectionsSolver extends BaseSolver {
         capacityMeshNodes: CapacityMeshNode[];
         srj: SimpleRouteJson;
     };
-    unprocessedObstacles: Obstacle$1[];
+    unprocessedObstacles: Obstacle[];
     nodeTree: CapacityNodeTree;
     offBoardConnMap: ConnectivityMap$1;
     nodesInNet: Map<OffBoardConnectionId, CapacityMeshNode[]>;
-    lastProcessedObstacle?: Obstacle$1;
+    lastProcessedObstacle?: Obstacle;
     constructor(input: {
         capacityMeshNodes: CapacityMeshNode[];
         srj: SimpleRouteJson;
@@ -3443,1426 +3530,1248 @@ declare class RelateNodesToOffBoardConnectionsSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-type JumperFootprint = "0603" | "1206";
-
-interface Obstacle {
-    type: "rect";
-    obstacleId: string;
-    layers: string[];
-    center: {
-        x: number;
-        y: number;
-    };
-    width: number;
-    height: number;
-    connectedTo: string[];
-    offBoardConnectsTo?: string[];
+interface CapacityMeshSolverOptions$1 {
+    capacityDepth?: number;
+    targetMinCapacity?: number;
+    cacheProvider?: CacheProvider | null;
+    effort?: number;
 }
-interface PrepatternJumper {
-    jumperId: string;
-    start: {
-        x: number;
-        y: number;
-    };
-    end: {
-        x: number;
-        y: number;
-    };
-    footprint: JumperFootprint;
-    offBoardConnectionId: string;
-}
-interface PatternResult {
-    jumperPadObstacles: Obstacle[];
-    prepatternJumpers: PrepatternJumper[];
-}
-
-interface RemoveUnnecessaryJumpersSolverParams {
-    /**
-     * Input nodes from the PortPointPathingSolver
-     */
-    inputNodes: InputNodeWithPortPoints[];
-    /**
-     * Set of jumper off-board connection IDs that were actually used by routes
-     */
-    usedJumperOffBoardObstacleIds: Set<string>;
-    /**
-     * Connectivity map for off-board obstacles (used to check if a jumper net was used)
-     */
-    offBoardConnMap?: ConnectivityMap | null;
-}
-/**
- * RemoveUnnecessaryJumpersSolver removes jumpers that aren't needed because
- * there are no traces between the pads. It converts unused jumper nodes back
- * to regular nodes so the high density solver can route through them normally.
- *
- * This solver runs after PortPointPathingSolver and before HighDensitySolver.
- */
-declare class RemoveUnnecessaryJumpersSolver extends BaseSolver {
-    inputNodes: InputNodeWithPortPoints[];
-    usedJumperOffBoardObstacleIds: Set<string>;
-    offBoardConnMap: ConnectivityMap | null;
-    /**
-     * Output nodes with unused jumper nodes converted to regular nodes
-     */
-    outputNodes: InputNodeWithPortPoints[];
-    /**
-     * Set of off-board connection IDs that were removed
-     */
-    removedOffBoardConnectionIds: Set<string>;
-    constructor(params: RemoveUnnecessaryJumpersSolverParams);
-    /**
-     * Check if a jumper off-board connection ID was used
-     */
-    private isJumperUsed;
-    _step(): void;
-    getOutput(): InputNodeWithPortPoints[];
-    visualize(): GraphicsObject;
-}
-
-type PatternType = "alternating_grid" | "staggered_grid";
-interface JumperPrepatternSolverHyperParameters {
-    /** Orientation of jumpers - "horizontal" or "vertical" */
-    FIRST_ORIENTATION?: "horizontal" | "vertical";
-    /** Jumper footprint size - defaults to "0603" */
-    JUMPER_FOOTPRINT?: JumperFootprint;
-    /** Pattern type for jumper placement - defaults to "alternating_grid" */
-    PATTERN_TYPE?: PatternType;
-}
-interface JumperPrepatternSolverParams {
-    nodeWithPortPoints: NodeWithPortPoints;
-    colorMap?: Record<string, string>;
-    traceWidth?: number;
-    jumperFootprint?: JumperFootprint;
-    hyperParameters?: JumperPrepatternSolverHyperParameters;
-    connMap?: ConnectivityMap;
-}
-type PipelineStep$2<T extends new (...args: any[]) => BaseSolver> = {
+type PipelineStep$1<T extends new (...args: any[]) => BaseSolver> = {
     solverName: string;
     solverClass: T;
-    getConstructorParams: (instance: JumperPrepatternSolver) => ConstructorParameters<T>;
-    onSolved?: (instance: JumperPrepatternSolver) => void;
+    getConstructorParams: (instance: AssignableAutoroutingPipeline2) => ConstructorParameters<T>;
+    onSolved?: (instance: AssignableAutoroutingPipeline2) => void;
 };
-declare class JumperPrepatternSolver extends BaseSolver {
-    nodeWithPortPoints: NodeWithPortPoints;
-    colorMap: Record<string, string>;
-    traceWidth: number;
-    jumperFootprint: JumperFootprint;
-    hyperParameters: JumperPrepatternSolverHyperParameters;
-    connMap: ConnectivityMap;
-    prepatternJumpers: PrepatternJumper[];
-    patternResult: PatternResult | null;
-    capacityNodes: CapacityMeshNode[];
-    capacityEdges: CapacityMeshEdge[];
-    inputNodes: InputNodeWithPortPoints[];
-    connections: SimpleRouteConnection[];
-    srjWithPointPairs: SimpleRouteJson;
+declare class AssignableAutoroutingPipeline2 extends BaseSolver {
+    srj: SimpleRouteJson;
+    opts: CapacityMeshSolverOptions$1;
+    netToPointPairsSolver?: NetToPointPairsSolver;
     nodeSolver?: RectDiffPipeline;
+    nodeTargetMerger?: CapacityNodeTargetMerger;
+    edgeSolver?: CapacityMeshEdgeSolver;
     relateNodesToOffBoardConnections?: RelateNodesToOffBoardConnectionsSolver;
-    edgeSolver?: CapacityMeshEdgeSolver2_NodeTreeOptimization;
+    colorMap: Record<string, string>;
+    highDensityRouteSolver?: HighDensitySolver;
+    /** @deprecated Use highDensitySolver instead */
+    simpleHighDensityRouteSolver?: SimpleHighDensitySolver;
+    highDensitySolver?: JumperHighDensitySolver;
+    highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
+    singleLayerNodeMerger?: SingleLayerNodeMergerSolver;
+    offboardPathFragmentSolver?: PortPointOffboardPathFragmentSolver;
+    strawSolver?: StrawSolver;
+    deadEndSolver?: DeadEndSolver;
+    traceSimplificationSolver?: TraceSimplificationSolver;
+    traceKeepoutSolver?: TraceKeepoutSolver;
+    traceWidthSolver?: TraceWidthSolver;
     availableSegmentPointSolver?: AvailableSegmentPointSolver;
-    portPointPathingSolver?: HyperPortPointPathingSolver;
+    portPointPathingSolver?: PortPointPathingSolver;
     multiSectionPortPointOptimizer?: MultiSectionPortPointOptimizer;
-    removeUnnecessaryJumpersSolver?: RemoveUnnecessaryJumpersSolver;
-    highDensitySolver?: SimpleHighDensitySolver;
-    highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
-    activeSubSolver?: BaseSolver | null;
-    currentPipelineStepIndex: number;
+    viaDiameter: number;
+    minTraceWidth: number;
+    effort: number;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
-    solvedRoutes: HighDensityIntraNodeRouteWithJumpers[];
-    usedJumperOffBoardObstacleIds: Set<string>;
-    allUsedJumperOffBoardIds: Set<string>;
-    offBoardConnMap: ConnectivityMap | null;
-    pipelineDef: (PipelineStep$2<typeof RectDiffPipeline> | PipelineStep$2<typeof RelateNodesToOffBoardConnectionsSolver> | PipelineStep$2<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$2<typeof AvailableSegmentPointSolver> | PipelineStep$2<typeof HyperPortPointPathingSolver> | PipelineStep$2<typeof RemoveUnnecessaryJumpersSolver> | PipelineStep$2<typeof SimpleHighDensitySolver> | PipelineStep$2<typeof MultipleHighDensityRouteStitchSolver>)[];
-    constructor(params: JumperPrepatternSolverParams);
-    getCurrentStageName(): string;
+    activeSubSolver?: BaseSolver | null;
+    connMap: ConnectivityMap;
+    srjWithPointPairs?: SimpleRouteJson;
+    capacityNodes: CapacityMeshNode[] | null;
+    capacityEdges: CapacityMeshEdge[] | null;
+    cacheProvider: CacheProvider | null;
+    pipelineDef: (PipelineStep$1<typeof NetToPointPairsSolver> | PipelineStep$1<typeof RectDiffPipeline> | PipelineStep$1<typeof RelateNodesToOffBoardConnectionsSolver> | PipelineStep$1<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$1<typeof AvailableSegmentPointSolver> | PipelineStep$1<typeof HyperPortPointPathingSolver> | PipelineStep$1<typeof MultiSectionPortPointOptimizer> | PipelineStep$1<typeof SimpleHighDensitySolver> | PipelineStep$1<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$1<typeof TraceSimplificationSolver> | PipelineStep$1<typeof TraceKeepoutSolver> | PipelineStep$1<typeof TraceWidthSolver>)[];
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$1);
+    getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions$1];
+    currentPipelineStepIndex: number;
     _step(): void;
+    solveUntilPhase(phase: string): void;
     getCurrentPhase(): string;
-    _createSimpleRouteJson(): SimpleRouteJson;
-    _createJumperPadObstacles(): SimpleRouteJson["obstacles"];
-    _addPortPointObstacles(obstacles: SimpleRouteJson["obstacles"]): void;
-    _combineResults(): void;
+    visualize(): GraphicsObject;
     /**
-     * Get all used jumpers converted to the Jumper type format
+     * A lightweight version of the visualize method that can be used to stream
+     * progress
+     *
+     * We return the most relevant graphic for the stage:
+     * 1. netToPointPairs output
+     * 2. Capacity Planning Output
+     * 3. High Density Route Solver Output, max 200 lines
      */
-    _getUsedJumpers(): Jumper[];
-    getOutput(): HighDensityIntraNodeRouteWithJumpers[];
+    preview(): GraphicsObject;
+    _getOutputHdRoutes(): HighDensityRoute$1[];
+    getConnectedOffboardObstacles(): Record<ObstacleId, RootConnectionName>;
     /**
-     * Draw the two pads of a jumper
+     * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
      */
-    private _drawJumperPads;
-    visualize(): GraphicsObject;
-}
-
-type JumperSolver = IntraNodeSolverWithJumpers | JumperPrepatternSolver;
-declare class HyperIntraNodeSolverWithJumpers extends HyperParameterSupervisorSolver<JumperSolver> {
-    constructorParams: ConstructorParameters<typeof IntraNodeSolverWithJumpers>[0];
-    solvedRoutes: HighDensityIntraNodeRouteWithJumpers[];
-    nodeWithPortPoints: NodeWithPortPoints;
-    connMap?: ConnectivityMap;
-    constructor(opts: ConstructorParameters<typeof IntraNodeSolverWithJumpers>[0]);
-    getConstructorParams(): {
-        nodeWithPortPoints: NodeWithPortPoints;
-        colorMap?: Record<string, string>;
-        hyperParameters?: Partial<HighDensityHyperParameters>;
-        connMap?: ConnectivityMap;
-        traceWidth?: number;
-    };
-    getHyperParameterDefs(): ({
-        name: string;
-        possibleValues: {
-            SHUFFLE_SEED: number;
-        }[];
-    } | {
-        name: string;
-        possibleValues: Array<{
-            USE_JUMPER_PREPATTERN: true;
-        } & JumperPrepatternSolverHyperParameters>;
-    } | {
-        name: string;
-        possibleValues: {
-            USE_JUMPER_PREPATTERN: boolean;
-            FIRST_ORIENTATION: string;
-            PATTERN_TYPE: string;
-        }[];
-    })[];
-    getCombinationDefs(): string[][];
-    _step(): void;
-    computeG(solver: JumperSolver): number;
-    computeH(solver: JumperSolver): number;
-    generateSolver(hyperParameters: Partial<HighDensityHyperParameters> & {
-        USE_JUMPER_PREPATTERN?: boolean;
-        FIRST_ORIENTATION?: "horizontal" | "vertical";
-        PATTERN_TYPE?: "alternating_grid" | "staggered_grid";
-    }): JumperSolver;
-    onSolve(solver: SupervisedSolver<JumperSolver>): void;
-    visualize(): GraphicsObject;
+    getOutputSimplifiedPcbTraces(): SimplifiedPcbTraces;
+    getOutputSimpleRouteJson(): SimpleRouteJson;
 }
 
-interface NodeAnalysis {
-    node: NodeWithPortPoints;
-    hasCrossings: boolean;
-    numSameLayerCrossings: number;
-}
 /**
- * HighDensitySolver intelligently selects the appropriate solver for each node:
- * - SimpleHighDensitySolver for nodes without crossings (faster, force-directed)
- * - IntraNodeSolverWithJumpers for single-layer nodes with crossings (uses 0603 jumpers)
+ * Calculate the capacity of a node based on its width
  *
- * This solver processes nodes in batches based on their characteristics.
+ * This capacity corresponds to how many vias the node can fit, tuned for two
+ * layers.
+ *
+ * @param nodeOrWidth The node or width to calculate capacity for
+ * @param maxCapacityFactor Optional multiplier to adjust capacity
+ * @returns The calculated capacity
  */
-declare class JumperHighDensitySolver extends BaseSolver {
-    allNodes: NodeWithPortPoints[];
-    nodeAnalyses: NodeAnalysis[];
-    routes: HighDensityIntraNodeRoute$1[];
-    colorMap: Record<string, string>;
-    traceWidth: number;
-    viaDiameter: number;
-    connMap?: ConnectivityMap;
-    hyperParameters?: Partial<HighDensityHyperParameters>;
-    nodesWithoutCrossings: NodeWithPortPoints[];
-    nodesWithCrossings: NodeWithPortPoints[];
-    simpleHighDensitySolver?: SimpleHighDensitySolver;
-    jumperSolvers: HyperIntraNodeSolverWithJumpers[];
-    currentJumperSolverIndex: number;
-    phase: "analyzing" | "simple" | "jumpers" | "done";
-    constructor({ nodePortPoints, colorMap, traceWidth, viaDiameter, connMap, hyperParameters, }: {
-        nodePortPoints: NodeWithPortPoints[];
-        colorMap?: Record<string, string>;
-        traceWidth?: number;
-        viaDiameter?: number;
-        connMap?: ConnectivityMap;
-        hyperParameters?: Partial<HighDensityHyperParameters>;
-    });
+declare const getTunedTotalCapacity1: (nodeOrWidth: CapacityMeshNode | {
+    width: number;
+    availableZ?: number[];
+}, maxCapacityFactor?: number, opts?: {
+    viaDiameter?: number;
+    obstacleMargin?: number;
+}) => number;
+/**
+ * Calculate the optimal subdivision depth to reach a target minimum capacity
+ * @param initialWidth The initial width of the top-level node
+ * @param targetMinCapacity The minimum capacity target (default 0.5)
+ * @param maxDepth Maximum allowed depth (default 10)
+ * @returns The optimal capacity depth
+ */
+declare const calculateOptimalCapacityDepth: (initialWidth: number, targetMinCapacity?: number, maxDepth?: number) => number;
+
+/**
+ * An in-memory implementation of the CacheProvider interface.
+ * Useful for testing or scenarios where persistence is not required.
+ */
+declare class InMemoryCache implements CacheProvider {
+    cacheHitsByPrefix: Record<string, number>;
+    cacheMissesByPrefix: Record<string, number>;
+    isSyncCache: boolean;
+    cacheHits: number;
+    cacheMisses: number;
+    cache: Map<string, any>;
     /**
-     * Analyze all nodes to determine which solver to use for each
+     * Retrieves a cached solution synchronously based on the cache key.
+     * Increments cache hit/miss counters.
+     * @param cacheKey The key to look up in the cache.
+     * @returns The cached solution if found, otherwise undefined.
      */
-    _analyzeNodes(): void;
-    _step(): void;
-    _stepSimpleSolver(): void;
-    _initializeJumperSolvers(): void;
-    _stepJumperSolvers(): void;
-    computeProgress(): number;
-    getConstructorParams(): {
-        nodePortPoints: NodeWithPortPoints[];
-        colorMap: Record<string, string>;
-        traceWidth: number;
-        viaDiameter: number;
-        connMap: ConnectivityMap | undefined;
-        hyperParameters: Partial<HighDensityHyperParameters> | undefined;
-    };
-    visualize(): GraphicsObject;
+    getCachedSolutionSync(cacheKey: string): any;
+    /**
+     * Retrieves a cached solution asynchronously. Wraps the synchronous method.
+     * @param cacheKey The key to look up in the cache.
+     * @returns A promise that resolves with the cached solution or undefined.
+     */
+    getCachedSolution(cacheKey: string): Promise<any>;
+    /**
+     * Stores a solution in the cache synchronously.
+     * Uses structured cloning to store a copy, preventing external modifications.
+     * @param cacheKey The key under which to store the solution.
+     * @param cachedSolution The solution data to cache.
+     */
+    setCachedSolutionSync(cacheKey: string, cachedSolution: any): void;
+    /**
+     * Stores a solution in the cache asynchronously. Wraps the synchronous method.
+     * @param cacheKey The key under which to store the solution.
+     * @param cachedSolution The solution data to cache.
+     * @returns A promise that resolves when the solution is cached.
+     */
+    setCachedSolution(cacheKey: string, cachedSolution: any): Promise<void>;
+    /**
+     * Clears the entire cache and resets hit/miss counters.
+     */
+    clearCache(): void;
+    getAllCacheKeys(): string[];
 }
 
 /**
- * ObstacleTree wraps different spatial index implementations:
- * - 'native': original spatial-hash grid
- * - 'rbush': dynamic R-tree via rbush
- * - 'flatbush': static index via flatbush
+ * A CacheProvider implementation using the browser's localStorage.
+ * Note: localStorage has size limits (typically 5-10MB) and stores data as strings.
+ * Complex objects will be JSON serialized/deserialized.
  */
-declare class ObstacleSpatialHashIndex {
-    private idx;
-    private storage;
-    constructor(implementation?: "native" | "rbush" | "flatbush", obstacles?: Obstacle$1[]);
-    insert(o: Obstacle$1): void;
-    search(bbox: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    }): Obstacle$1[];
-    searchArea(centerX: number, centerY: number, width: number, height: number): Obstacle$1[];
-}
-
-interface Point$1 {
-    x: number;
-    y: number;
-    z: number;
-}
-type Point2D$3 = {
-    x: number;
-    y: number;
-};
-type HighDensityIntraNodeRoute = {
-    connectionName: string;
-    rootConnectionName?: string;
-    traceThickness: number;
-    viaDiameter: number;
-    route: Array<{
-        x: number;
-        y: number;
-        z: number;
-    }>;
-    vias: Array<{
-        x: number;
-        y: number;
-    }>;
-    jumpers?: Jumper[];
-};
-type HighDensityRoute = HighDensityIntraNodeRoute;
-declare class HighDensityRouteSpatialIndex {
-    private segmentBuckets;
-    private viaBuckets;
-    private CELL_SIZE;
-    constructor(routes: HighDensityRoute[], cellSize?: number);
+declare class LocalStorageCache implements CacheProvider {
+    isSyncCache: boolean;
+    cacheHits: number;
+    cacheMisses: number;
+    cacheHitsByPrefix: Record<string, number>;
+    cacheMissesByPrefix: Record<string, number>;
+    constructor();
+    private getKey;
     /**
-     * Finds routes that potentially conflict with a given line segment within a margin.
-     * Checks both segments and vias.
-     * @param segmentStart Start point of the query segment.
-     * @param segmentEnd End point of the query segment.
-     * @param margin The minimum required clearance distance from the query segment's centerline.
-     * @returns An array of conflicting routes and their minimum distance to the segment.
+     * Retrieves a cached solution synchronously from localStorage.
+     * Increments cache hit/miss counters.
+     * @param cacheKey The key to look up in the cache.
+     * @returns The cached solution if found and parsed correctly, otherwise undefined.
      */
-    getConflictingRoutesForSegment(segmentStart: Point$1, // Keep Point for original Z data if needed elsewhere
-    segmentEnd: Point$1, margin: number): Array<{
-        conflictingRoute: HighDensityRoute;
-        distance: number;
-    }>;
+    getCachedSolutionSync(cacheKey: string): any;
     /**
-     * Finds routes that pass near a given point within a margin.
-     * Checks both segments and vias.
-     * @param point The query point {x, y}. Z is ignored.
-     * @param margin The minimum required clearance distance from the query point.
-     * @returns An array of conflicting routes and their minimum distance to the point.
+     * Retrieves a cached solution asynchronously. Wraps the synchronous method.
+     * @param cacheKey The key to look up in the cache.
+     * @returns A promise that resolves with the cached solution or undefined.
      */
-    getConflictingRoutesNearPoint(point: Point2D$3, margin: number): Array<{
-        conflictingRoute: HighDensityRoute;
-        distance: number;
-    }>;
+    getCachedSolution(cacheKey: string): Promise<any>;
+    /**
+     * Stores a solution in localStorage synchronously.
+     * The solution is JSON stringified before storing.
+     * @param cacheKey The key under which to store the solution.
+     * @param cachedSolution The solution data to cache.
+     */
+    setCachedSolutionSync(cacheKey: string, cachedSolution: any): void;
+    /**
+     * Stores a solution in the cache asynchronously. Wraps the synchronous method.
+     * @param cacheKey The key under which to store the solution.
+     * @param cachedSolution The solution data to cache.
+     * @returns A promise that resolves when the solution is cached.
+     */
+    setCachedSolution(cacheKey: string, cachedSolution: any): Promise<void>;
+    /**
+     * Clears all cache entries created by this instance from localStorage
+     * and resets hit/miss counters.
+     */
+    clearCache(): void;
+    getAllCacheKeys(): string[];
 }
 
-interface Point2D$2 {
+declare global {
+    var TSCIRCUIT_AUTOROUTER_LOCAL_STORAGE_CACHE: LocalStorageCache;
+    var TSCIRCUIT_AUTOROUTER_IN_MEMORY_CACHE: InMemoryCache;
+}
+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[];
 }
-interface Segment {
-    start: Point2D$2;
-    end: Point2D$2;
+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 Point2D$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[];
 }
-interface Point3D$1 extends Point2D$1 {
-    z: number;
-}
-interface TraceKeepoutSolverInput {
-    hdRoutes: HighDensityRoute$1[];
-    obstacles: Obstacle$1[];
-    connMap: ConnectivityMap;
-    colorMap: Record<string, string>;
-    keepoutRadiusSchedule?: number[];
-    srj?: Pick<SimpleRouteJson, "outline" | "bounds" | "layerCount">;
-}
-/**
- * TraceKeepoutSolver adjusts traces to maintain keepout distance from obstacles
- * and non-connected traces. It works by walking along each trace with a cursor,
- * detecting obstacles within a keepout radius, and pushing the draw position
- * orthogonally to avoid them.
- *
- * The solver processes traces through multiple passes with decreasing keepout
- * radii as defined by KEEPOUT_RADIUS_SCHEDULE.
- */
-declare class TraceKeepoutSolver extends BaseSolver {
-    private input;
-    originalHdRoutes: HighDensityRoute$1[];
-    hdRoutes: HighDensityRoute$1[];
-    redrawnHdRoutes: HighDensityRoute$1[];
-    KEEPOUT_RADIUS_SCHEDULE: number[];
-    currentScheduleIndex: number;
-    currentKeepoutRadius: number;
-    unprocessedRoutes: HighDensityRoute$1[];
-    smoothedCursorRoutes: HighDensityRoute$1[];
-    processedRoutes: HighDensityRoute$1[];
-    currentTrace: HighDensityRoute$1 | null;
-    cursorPosition: Point3D$1 | null;
-    lastCursorPosition: Point3D$1 | null;
-    drawPosition: Point2D$1 | null;
-    currentTraceSegmentIndex: number;
-    currentTraceSegmentT: number;
-    recordedDrawPositions: Point3D$1[];
-    lastCollidingSegments: Segment[];
-    obstacleSHI: ObstacleSpatialHashIndex;
-    hdRouteSHI: HighDensityRouteSpatialIndex;
-    boardOutlineRoutes: HighDensityRoute$1[];
-    constructor(input: TraceKeepoutSolverInput);
-    getSmoothDistance(): number;
-    _step(): void;
-    getStepDistance(): number;
-    /**
-     * Steps the cursor forward by CURSOR_STEP_DISTANCE along the trace
-     * Returns false if we've reached the end of the trace
-     */
-    private stepCursorForward;
-    /**
-     * Gets all colliding segments (obstacle edges and trace outlines) within the keepout radius
-     */
-    private getCollidingSegments;
-    positionHasCollision(position: {
-        x: number;
-        y: number;
-        z: number;
-    }, margin?: number): boolean;
+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[];
     /**
-     * Finalizes the current trace with the recorded draw positions
+     * Checks if the given mesh node overlaps with any obstacle.
+     * We treat both obstacles and nodes as axis‐aligned rectangles.
      */
-    private finalizeCurrentTrace;
+    doesNodeOverlapObstacle(node: CapacityMeshNode): boolean;
     /**
-     * Simplifies the route by removing collinear points
+     * Checks if the entire node is contained within any obstacle.
      */
-    private simplifyRoute;
+    isNodeCompletelyInsideObstacle(node: CapacityMeshNode): boolean;
+    getChildNodes(parent: CapacityMeshNode): CapacityMeshNode[];
+    shouldNodeBeXYSubdivided(node: CapacityMeshNode): boolean;
+    _step(): void;
     /**
-     * Creates artificial hdRoutes representing the board outline.
-     * These routes act as obstacles to prevent traces from being pushed outside the board.
+     * 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.
      */
-    private createBoardOutlineRoutes;
     visualize(): GraphicsObject;
-    /** Returns the redrawn routes. This is the primary output of the solver. */
-    getRedrawnHdRoutes(): HighDensityRoute$1[];
 }
 
-interface Point2D {
-    x: number;
-    y: number;
+interface CapacityMeshNodeSolverOptions$1 {
+    capacityDepth?: number;
 }
-interface Point3D extends Point2D {
-    z: 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 TraceWidthSolverInput {
-    hdRoutes: HighDensityRoute$1[];
-    obstacles?: Obstacle$1[];
-    connMap?: ConnectivityMap;
-    colorMap?: Record<string, string>;
-    nominalTraceWidth?: number;
-    minTraceWidth: number;
-    obstacleMargin?: number;
+
+interface CapacityMeshNodeSolverOptions {
+    capacityDepth?: number;
 }
 /**
- * TraceWidthSolver determines the optimal trace width for each route.
- * It uses a TRACE_WIDTH_SCHEDULE to try progressively narrower widths:
- * [nominalTraceWidth, (nominalTraceWidth + minTraceWidth)/2, minTraceWidth]
- *
- * For each trace, it walks along with a cursor checking clearance.
- * If clearance is insufficient for the current width, it tries the next
- * narrower width in the schedule.
+ * This capacity mesh node solver is meant to be used in contexts where vias
+ * aren't allowed, but there may be assignable vias on the PCB as obstacles.
  *
- * nominalTraceWidth defaults to minTraceWidth * 2 if not specified.
+ * Behavior:
+ * - Outside assignable obstacles, multi-layer nodes are *always* Z-split into single-layer nodes.
+ * - During mesh subdivision, nodes overlapping with "assignable" obstacles
+ *   (obstacle.netIsAssignable === true) are NOT filtered, allowing normal subdivision.
+ * - After the main mesh subdivision is complete:
+ *   1. All nodes overlapping with assignable obstacles are removed
+ *   2. Each assignable obstacle is replaced with a single multi-layer node spanning all layers
+ * - Single-layer nodes that are larger than MAX_SIZE_FOR_SINGLE_LAYER_NODES are XY-subdivided.
+ * - IMPORTANT: the multi-layer nodes created from assignable obstacles are **traversable**,
+ *   so we mark `_containsObstacle = false` and `_completelyInsideObstacle = false` on them.
  */
-declare class TraceWidthSolver extends BaseSolver {
-    hdRoutes: HighDensityRoute$1[];
-    hdRoutesWithWidths: HighDensityRoute$1[];
-    nominalTraceWidth: number;
-    minTraceWidth: number;
-    obstacleMargin: number;
-    TRACE_WIDTH_SCHEDULE: number[];
-    unprocessedRoutes: HighDensityRoute$1[];
-    processedRoutes: HighDensityRoute$1[];
-    currentTrace: HighDensityRoute$1 | null;
-    cursorPosition: Point3D | null;
-    currentTraceSegmentIndex: number;
-    currentTraceSegmentT: number;
-    currentScheduleIndex: number;
-    currentTargetWidth: number;
-    hasInsufficientClearance: boolean;
-    currentWalkMinClearance: number;
-    bestMinClearance: number;
-    bestWidth: number;
-    lastCollidingObstacles: Obstacle$1[];
-    lastCollidingRoutes: HighDensityRoute$1[];
-    lastClearance: number;
-    obstacles: Obstacle$1[];
-    obstacleSHI?: ObstacleSpatialHashIndex;
-    hdRouteSHI: HighDensityRouteSpatialIndex;
-    connMap?: ConnectivityMap;
-    colorMap?: Record<string, string>;
-    constructor(input: TraceWidthSolverInput);
-    _step(): void;
-    /**
-     * Initializes/resets the cursor for processing a trace
-     */
-    private initializeCursor;
-    /**
-     * Steps the cursor forward by CURSOR_STEP_DISTANCE along the trace
-     * Returns false if we've reached the end of the trace
-     */
-    private stepCursorForward;
+declare class CapacityMeshNodeSolver_OnlyTraverseLayersInAssignableObstacles extends CapacityMeshNodeSolver2_NodeUnderObstacle {
+    srj: SimpleRouteJson;
+    opts: CapacityMeshNodeSolverOptions;
+    MAX_SIZE_FOR_SINGLE_LAYER_NODES: number;
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions);
+    private isObstacleAssignable;
+    private getOverlappingAssignableObstacles;
+    shouldNodeBeXYSubdivided(node: CapacityMeshNode): boolean;
     /**
-     * Gets the minimum clearance at a given position from obstacles and other traces
-     * Also updates lastCollidingObstacles and lastCollidingRoutes for visualization
+     * Filter nodes for obstacles, but skip filtering for assignable obstacles.
+     * Assignable obstacles will be handled separately at the end.
      */
-    private getClearanceAtPosition;
+    shouldFilterNodeForObstacle(node: CapacityMeshNode): boolean;
     /**
-     * Finalizes the current trace with the given width
+     * Remove nodes inside assignable obstacles and replace with single multi-layer nodes.
+     * The new node's bounds are extended to cover all removed nodes' XY space.
      */
-    private finalizeCurrentTrace;
+    private insertAssignableObstaclesAsNodes;
+    _step(): void;
+}
+
+/**
+ * Variant of SingleLayerNodeMergerSolver that only merges nodes containing targets.
+ * Nodes without targets are passed through unchanged.
+ */
+declare class SingleLayerNodeMergerSolver_OnlyMergeTargets extends BaseSolver {
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    currentBatchNodeIds: CapacityMeshNodeId[];
+    absorbedNodeIds: Set<CapacityMeshNodeId>;
+    nextBatchNodeIds: CapacityMeshNodeId[];
+    batchHadModifications: boolean;
+    hasComputedAdjacentNodeIds: boolean;
+    newNodes: CapacityMeshNode[];
+    constructor(nodes: CapacityMeshNode[]);
+    computeAdjacentNodeIdsForFirstBatch(nodes: CapacityMeshNode[]): void;
+    getAdjacentSameLayerUnprocessedNodes(rootNode: CapacityMeshNode): CapacityMeshNode[];
+    _step(): void;
     visualize(): GraphicsObject;
-    /** Returns the routes with determined widths. This is the primary output of the solver. */
-    getHdRoutesWithWidths(): HighDensityRoute$1[];
 }
 
-interface OffboardPortPoint {
-    portPointId: string;
+/**
+ * This solver merges nodes that represent the same assignable obstacle into a single node.
+ *
+ * For each assignable obstacle:
+ * - Finds all nodes that have _assignedViaObstacle pointing to that obstacle
+ * - Replaces them with a single node representing the bounding box of all removed nodes
+ * - Each step handles one assignable obstacle
+ */
+declare class AssignableViaNodeMergerSolver extends BaseSolver {
+    newNodes: CapacityMeshNode[];
+    obstacleToNodesMap: Map<Obstacle, CapacityMeshNode[]>;
+    obstaclesToProcess: Obstacle[];
+    mergedNodeIds: Set<CapacityMeshNodeId>;
+    constructor(nodes: CapacityMeshNode[]);
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+interface Point {
     x: number;
     y: number;
-    /** The obstacle this port point is at the center of */
-    obstacleIndex: number;
-    /** The offBoardConnectsTo ids this port point is associated with */
-    offBoardConnectionIds: OffBoardConnectionId[];
-    /** Available Z layers for this port point based on obstacle layers */
-    availableZ: number[];
+    z: number;
 }
-interface OffboardPathFragment {
-    pathFragmentId: string;
-    /** The shared offBoardConnectsTo id that connects these port points */
-    offBoardConnectionId: OffBoardConnectionId;
-    /** The two port points connected by this path fragment */
-    portPointIds: [string, string];
-    /** Endpoints of this edge */
-    start: {
+declare class SingleSimplifiedPathSolver extends BaseSolver {
+    newRoute: HighDensityIntraNodeRoute$1["route"];
+    newVias: HighDensityIntraNodeRoute$1["vias"];
+    headIndex: number;
+    tailIndex: number;
+    inputRoute: HighDensityIntraNodeRoute$1;
+    otherHdRoutes: HighDensityIntraNodeRoute$1[];
+    obstacles: Obstacle[];
+    connMap: ConnectivityMap;
+    colorMap: Record<string, string>;
+    outline?: Array<{
         x: number;
         y: number;
+    }>;
+    constructor(params: {
+        inputRoute: HighDensityIntraNodeRoute$1;
+        otherHdRoutes: HighDensityIntraNodeRoute$1[];
+        obstacles: Obstacle[];
+        connMap: ConnectivityMap;
+        colorMap: Record<string, string>;
+        outline?: Array<{
+            x: number;
+            y: number;
+        }>;
+    });
+    getConstructorParams(): {
+        inputRoute: HighDensityIntraNodeRoute$1;
+        otherHdRoutes: HighDensityIntraNodeRoute$1[];
+        obstacles: Obstacle[];
+        connMap: Record<string, string[]>;
+        colorMap: Record<string, string>;
+        outline: {
+            x: number;
+            y: number;
+        }[] | undefined;
     };
-    end: {
+    get simplifiedRoute(): HighDensityIntraNodeRoute$1;
+    isValidPath(pointsInRoute: Point[]): boolean;
+    _step(): void;
+    getVisualsForNewRouteAndObstacles(): GraphicsObject & Pick<Required<GraphicsObject>, "points" | "lines" | "rects" | "circles">;
+}
+
+declare class MultiSimplifiedPathSolver extends BaseSolver {
+    simplifiedHdRoutes: HighDensityIntraNodeRoute$1[];
+    currentUnsimplifiedHdRouteIndex: number;
+    activeSubSolver: SingleSimplifiedPathSolver | null;
+    unsimplifiedHdRoutes: HighDensityIntraNodeRoute$1[];
+    obstacles: Obstacle[];
+    connMap: ConnectivityMap;
+    colorMap: Record<string, string>;
+    outline?: Array<{
         x: number;
         y: number;
-    };
+    }>;
+    defaultViaDiameter: number;
+    constructor(params: {
+        unsimplifiedHdRoutes: HighDensityIntraNodeRoute$1[];
+        obstacles: Obstacle[];
+        connMap?: ConnectivityMap;
+        colorMap?: Record<string, string>;
+        outline?: Array<{
+            x: number;
+            y: number;
+        }>;
+        defaultViaDiameter?: number;
+    });
+    _step(): void;
+    visualize(): GraphicsObject;
 }
-type Phase = "finding_obstacles" | "creating_fragments" | "done";
-interface PendingFragment {
-    offBoardId: OffBoardConnectionId;
-    pp1: OffboardPortPoint;
-    pp2: OffboardPortPoint;
+
+interface RouteSection {
+    startIndex: number;
+    endIndex: number;
+    z: number;
+    points: HighDensityRoute["route"];
 }
-/**
- * PortPointOffboardPathFragmentSolver finds obstacles with offBoardConnectsTo
- * defined and creates port points at their centers. It then creates path
- * fragments (edges) connecting port points that share the same offBoardConnectsTo
- * ids.
- *
- * This enables routing through off-board connections like flex cables or
- * external connectors.
- *
- * The solver iterates step-by-step:
- * 1. Phase "finding_obstacles": Process one obstacle per step, creating port points
- * 2. Phase "creating_fragments": Create one path fragment per step
- * 3. Phase "done": Solver complete
- */
-declare class PortPointOffboardPathFragmentSolver extends BaseSolver {
-    srj: SimpleRouteJson;
-    colorMap: Record<string, string>;
-    /** Current phase of the solver */
-    phase: Phase;
-    /** Index of the current obstacle being processed */
-    currentObstacleIndex: number;
-    /** Obstacles that have offBoardConnectsTo defined */
-    offboardObstacles: Array<{
-        obstacle: Obstacle$1;
-        index: number;
-    }>;
-    /** Port points created at obstacle centers */
-    portPoints: OffboardPortPoint[];
-    /** Map from portPointId to OffboardPortPoint */
-    portPointMap: Map<string, OffboardPortPoint>;
-    /** Path fragments connecting port points with shared offBoardConnectsTo */
-    pathFragments: OffboardPathFragment[];
-    /** Map from offBoardConnectionId to port points that share it */
-    offBoardConnectionToPortPoints: Map<OffBoardConnectionId, OffboardPortPoint[]>;
-    /** Pending path fragments to create (computed after obstacle phase) */
-    pendingFragments: PendingFragment[];
-    /** Index of current fragment being created */
-    currentFragmentIndex: number;
-    /** Last processed obstacle (for visualization) */
-    lastProcessedObstacle: {
-        obstacle: Obstacle$1;
-        index: number;
-    } | null;
-    /** Last created port point (for visualization) */
-    lastCreatedPortPoint: OffboardPortPoint | null;
-    /** Last created path fragment (for visualization) */
-    lastCreatedFragment: OffboardPathFragment | null;
-    /** Color map for offBoardConnectionIds */
-    offBoardColorMap: Record<string, string>;
-    constructor({ srj, colorMap, }: {
-        srj: SimpleRouteJson;
-        colorMap?: Record<string, string>;
+declare class SingleRouteUselessViaRemovalSolver extends BaseSolver {
+    obstacleSHI: ObstacleSpatialHashIndex;
+    hdRouteSHI: HighDensityRouteSpatialIndex;
+    unsimplifiedRoute: HighDensityRoute;
+    routeSections: Array<RouteSection>;
+    currentSectionIndex: number;
+    TRACE_THICKNESS: number;
+    OBSTACLE_MARGIN: number;
+    constructor(params: {
+        obstacleSHI: ObstacleSpatialHashIndex;
+        hdRouteSHI: HighDensityRouteSpatialIndex;
+        unsimplifiedRoute: HighDensityRoute;
     });
+    breakRouteIntoSections(route: HighDensityRoute): never[] | this["routeSections"];
     _step(): void;
-    private stepFindingObstacles;
-    private computePendingFragments;
-    private stepCreatingFragments;
-    private layerToZ;
-    computeProgress(): number;
+    /**
+     * Check if an endpoint (first or last point of the route) can connect
+     * to a different layer. This is only allowed if the obstacles the endpoint
+     * connects to support that layer.
+     */
+    canEndpointConnectOnLayer(endpointX: number, endpointY: number, targetZ: number): boolean;
+    canSectionMoveToLayer({ currentSection, targetZ, }: {
+        currentSection: RouteSection;
+        targetZ: number;
+    }): boolean;
+    getConstructorParams(): {
+        obstacleSHI: ObstacleSpatialHashIndex;
+        hdRouteSHI: HighDensityRouteSpatialIndex;
+        unsimplifiedRoute: HighDensityIntraNodeRoute;
+    };
+    getOptimizedHdRoute(): HighDensityRoute;
     visualize(): GraphicsObject;
 }
 
-interface CapacityMeshSolverOptions$1 {
-    capacityDepth?: number;
-    targetMinCapacity?: number;
-    cacheProvider?: CacheProvider | null;
-    effort?: number;
-}
-type PipelineStep$1<T extends new (...args: any[]) => BaseSolver> = {
-    solverName: string;
-    solverClass: T;
-    getConstructorParams: (instance: AssignableAutoroutingPipeline2) => ConstructorParameters<T>;
-    onSolved?: (instance: AssignableAutoroutingPipeline2) => void;
-};
-declare class AssignableAutoroutingPipeline2 extends BaseSolver {
-    srj: SimpleRouteJson;
-    opts: CapacityMeshSolverOptions$1;
-    netToPointPairsSolver?: NetToPointPairsSolver;
-    nodeSolver?: RectDiffPipeline;
-    nodeTargetMerger?: CapacityNodeTargetMerger;
-    edgeSolver?: CapacityMeshEdgeSolver;
-    relateNodesToOffBoardConnections?: RelateNodesToOffBoardConnectionsSolver;
+interface UselessViaRemovalSolverInput {
+    unsimplifiedHdRoutes: HighDensityRoute$1[];
+    obstacles: Obstacle[];
     colorMap: Record<string, string>;
-    highDensityRouteSolver?: HighDensitySolver;
-    /** @deprecated Use highDensitySolver instead */
-    simpleHighDensityRouteSolver?: SimpleHighDensitySolver;
-    highDensitySolver?: JumperHighDensitySolver;
-    highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
-    singleLayerNodeMerger?: SingleLayerNodeMergerSolver;
-    offboardPathFragmentSolver?: PortPointOffboardPathFragmentSolver;
-    strawSolver?: StrawSolver;
-    deadEndSolver?: DeadEndSolver;
-    traceSimplificationSolver?: TraceSimplificationSolver;
-    traceKeepoutSolver?: TraceKeepoutSolver;
-    traceWidthSolver?: TraceWidthSolver;
-    availableSegmentPointSolver?: AvailableSegmentPointSolver;
-    portPointPathingSolver?: PortPointPathingSolver;
-    multiSectionPortPointOptimizer?: MultiSectionPortPointOptimizer;
-    viaDiameter: number;
-    minTraceWidth: number;
-    effort: number;
-    startTimeOfPhase: Record<string, number>;
-    endTimeOfPhase: Record<string, number>;
-    timeSpentOnPhase: Record<string, number>;
-    activeSubSolver?: BaseSolver | null;
-    connMap: ConnectivityMap;
-    srjWithPointPairs?: SimpleRouteJson;
-    capacityNodes: CapacityMeshNode[] | null;
-    capacityEdges: CapacityMeshEdge[] | null;
-    cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep$1<typeof NetToPointPairsSolver> | PipelineStep$1<typeof RectDiffPipeline> | PipelineStep$1<typeof RelateNodesToOffBoardConnectionsSolver> | PipelineStep$1<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$1<typeof AvailableSegmentPointSolver> | PipelineStep$1<typeof HyperPortPointPathingSolver> | PipelineStep$1<typeof MultiSectionPortPointOptimizer> | PipelineStep$1<typeof SimpleHighDensitySolver> | PipelineStep$1<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$1<typeof TraceSimplificationSolver> | PipelineStep$1<typeof TraceKeepoutSolver> | PipelineStep$1<typeof TraceWidthSolver>)[];
-    constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$1);
-    getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions$1];
-    currentPipelineStepIndex: number;
+    layerCount: number;
+}
+declare class UselessViaRemovalSolver extends BaseSolver {
+    private input;
+    unsimplifiedHdRoutes: HighDensityRoute$1[];
+    optimizedHdRoutes: HighDensityRoute$1[];
+    unprocessedRoutes: HighDensityRoute$1[];
+    activeSubSolver?: SingleRouteUselessViaRemovalSolver | null | undefined;
+    obstacleSHI: ObstacleSpatialHashIndex | null;
+    hdRouteSHI: HighDensityRouteSpatialIndex | null;
+    constructor(input: UselessViaRemovalSolverInput);
     _step(): void;
-    solveUntilPhase(phase: string): void;
-    getCurrentPhase(): string;
+    getOptimizedHdRoutes(): HighDensityRoute$1[] | null;
     visualize(): GraphicsObject;
-    /**
-     * A lightweight version of the visualize method that can be used to stream
-     * progress
-     *
-     * We return the most relevant graphic for the stage:
-     * 1. netToPointPairs output
-     * 2. Capacity Planning Output
-     * 3. High Density Route Solver Output, max 200 lines
-     */
-    preview(): GraphicsObject;
-    _getOutputHdRoutes(): HighDensityRoute$1[];
-    getConnectedOffboardObstacles(): Record<ObstacleId, RootConnectionName>;
-    /**
-     * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
-     */
-    getOutputSimplifiedPcbTraces(): SimplifiedPcbTraces;
-    getOutputSimpleRouteJson(): SimpleRouteJson;
 }
 
+type Candidate = {
+    prevCandidate: Candidate | null;
+    node: CapacityMeshNode;
+    f: number;
+    g: number;
+    h: number;
+};
+type AssignableViaCapacityHyperParameters = Partial<CapacityHyperParameters> & {
+    SHUFFLE_SEED?: number;
+    DIRECTIVE_SEED?: number;
+    FORCE_VIA_TRAVEL_CHANCE?: number;
+    FAR_VIA_MIN_DISTANCE?: number;
+    MAX_CLOSEST_VIA_SKIP?: number;
+    MAX_FURTHEST_VIA_SKIP?: number;
+};
+type ConnectionNodePair = {
+    start: CapacityMeshNode;
+    end: CapacityMeshNode;
+    connection: SimpleRouteConnection;
+};
+type SubpathNodePair = {
+    start: CapacityMeshNode;
+    end: CapacityMeshNode;
+    solved: boolean;
+    path?: CapacityMeshNode[];
+    layer: number;
+};
+type ConnectionPathWithNodes = {
+    connection: SimpleRouteConnection;
+    path: CapacityMeshNode[];
+};
 /**
- * Calculate the capacity of a node based on its width
- *
- * This capacity corresponds to how many vias the node can fit, tuned for two
- * layers.
- *
- * @param nodeOrWidth The node or width to calculate capacity for
- * @param maxCapacityFactor Optional multiplier to adjust capacity
- * @returns The calculated capacity
- */
-declare const getTunedTotalCapacity1: (nodeOrWidth: CapacityMeshNode | {
-    width: number;
-    availableZ?: number[];
-}, maxCapacityFactor?: number, opts?: {
-    viaDiameter?: number;
-    obstacleMargin?: number;
-}) => number;
-/**
- * Calculate the optimal subdivision depth to reach a target minimum capacity
- * @param initialWidth The initial width of the top-level node
- * @param targetMinCapacity The minimum capacity target (default 0.5)
- * @param maxDepth Maximum allowed depth (default 10)
- * @returns The optimal capacity depth
- */
-declare const calculateOptimalCapacityDepth: (initialWidth: number, targetMinCapacity?: number, maxDepth?: number) => number;
-
-/**
- * An in-memory implementation of the CacheProvider interface.
- * Useful for testing or scenarios where persistence is not required.
+ * See description in the prompt
  */
-declare class InMemoryCache implements CacheProvider {
-    cacheHitsByPrefix: Record<string, number>;
-    cacheMissesByPrefix: Record<string, number>;
-    isSyncCache: boolean;
-    cacheHits: number;
-    cacheMisses: number;
-    cache: Map<string, any>;
-    /**
-     * Retrieves a cached solution synchronously based on the cache key.
-     * Increments cache hit/miss counters.
-     * @param cacheKey The key to look up in the cache.
-     * @returns The cached solution if found, otherwise undefined.
-     */
-    getCachedSolutionSync(cacheKey: string): any;
-    /**
-     * Retrieves a cached solution asynchronously. Wraps the synchronous method.
-     * @param cacheKey The key to look up in the cache.
-     * @returns A promise that resolves with the cached solution or undefined.
-     */
-    getCachedSolution(cacheKey: string): Promise<any>;
+declare class AssignableViaCapacityPathingSolver_DirectiveSubOptimal extends BaseSolver {
+    private inputParams;
     /**
-     * Stores a solution in the cache synchronously.
-     * Uses structured cloning to store a copy, preventing external modifications.
-     * @param cacheKey The key under which to store the solution.
-     * @param cachedSolution The solution data to cache.
+     * Bias toward greedier choices (f = g + GREEDY_MULTIPLIER * h)
      */
-    setCachedSolutionSync(cacheKey: string, cachedSolution: any): void;
-    /**
-     * Stores a solution in the cache asynchronously. Wraps the synchronous method.
-     * @param cacheKey The key under which to store the solution.
-     * @param cachedSolution The solution data to cache.
-     * @returns A promise that resolves when the solution is cached.
-     */
-    setCachedSolution(cacheKey: string, cachedSolution: any): Promise<void>;
+    GREEDY_MULTIPLIER: number;
+    simpleRouteJson: SimpleRouteJson;
+    nodes: CapacityMeshNode[];
+    edges: CapacityMeshEdge[];
+    colorMap: Record<string, string>;
+    MAX_ITERATIONS: number;
+    hyperParameters: Partial<AssignableViaCapacityHyperParameters>;
+    usedNodeMap: Map<CapacityMeshNodeId, true>;
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
+    unprocessedConnectionPairs: ConnectionNodePair[];
+    solvedRoutes: ConnectionPathWithNodes[];
+    activeConnectionPair: ConnectionNodePair | null;
+    ogUnprocessedSubpaths: SubpathNodePair[] | null;
+    unprocessedSubpaths: SubpathNodePair[] | null;
+    solvedSubpaths: SubpathNodePair[] | null;
+    activeSubpath: SubpathNodePair | null;
+    viaNodes: CapacityMeshNode[];
+    closestViaForConnectionStartMap: Map<ConnectionNodePair, CapacityMeshNode>;
+    closestViaForConnectionEndMap: Map<ConnectionNodePair, CapacityMeshNode>;
+    constructor(inputParams: {
+        simpleRouteJson: SimpleRouteJson;
+        nodes: CapacityMeshNode[];
+        edges: CapacityMeshEdge[];
+        colorMap?: Record<string, string>;
+        MAX_ITERATIONS?: number;
+        hyperParameters?: Partial<AssignableViaCapacityHyperParameters>;
+    });
+    getConstructorParams(): typeof this.inputParams;
+    lastStepOperation: "none" | "dequeueConnectionPair" | "breakConnectionPairIntoSubpaths" | "dequeueSubpath" | "stepSolveSubpath" | "finishedSolvingSubpath" | "finishedSolvingConnectionPair";
     /**
-     * Clears the entire cache and resets hit/miss counters.
+     * Computes and stores the closest via for both start and end of each unprocessed connection pair.
+     * This is used to ensure we don't "steal" a via that's closest to another connection.
      */
-    clearCache(): void;
-    getAllCacheKeys(): string[];
+    computeClosestViaForAllConnections(): void;
+    _step(): void;
+    queuedCandidateNodes: Candidate[];
+    visitedNodes: Set<CapacityMeshNodeId>;
+    private _dist;
+    stepSolveSubpath(subpath: SubpathNodePair): void;
+    getNeighbors(node: CapacityMeshNode): CapacityMeshNode[];
+    clearCandidateNodes(): void;
+    computeG(prevCandidate: Candidate, node: CapacityMeshNode, _endGoal: CapacityMeshNode): number;
+    computeH(_prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    createSolvedRoute(subpaths: SubpathNodePair[], connectionPair: ConnectionNodePair): ConnectionPathWithNodes;
+    breakConnectionPairIntoSubpaths(connectionPair: ConnectionNodePair): SubpathNodePair[];
+    getClosestVia(node: CapacityMeshNode): CapacityMeshNode;
+    getFarVia(closestVia: CapacityMeshNode, end: CapacityMeshNode): CapacityMeshNode;
+    getCapacityPaths(): CapacityPath[];
+    visualize(): GraphicsObject;
 }
 
-/**
- * A CacheProvider implementation using the browser's localStorage.
- * Note: localStorage has size limits (typically 5-10MB) and stores data as strings.
- * Complex objects will be JSON serialized/deserialized.
- */
-declare class LocalStorageCache implements CacheProvider {
-    isSyncCache: boolean;
-    cacheHits: number;
-    cacheMisses: number;
-    cacheHitsByPrefix: Record<string, number>;
-    cacheMissesByPrefix: Record<string, number>;
-    constructor();
-    private getKey;
-    /**
-     * Retrieves a cached solution synchronously from localStorage.
-     * Increments cache hit/miss counters.
-     * @param cacheKey The key to look up in the cache.
-     * @returns The cached solution if found and parsed correctly, otherwise undefined.
-     */
-    getCachedSolutionSync(cacheKey: string): any;
-    /**
-     * Retrieves a cached solution asynchronously. Wraps the synchronous method.
-     * @param cacheKey The key to look up in the cache.
-     * @returns A promise that resolves with the cached solution or undefined.
-     */
-    getCachedSolution(cacheKey: string): Promise<any>;
-    /**
-     * Stores a solution in localStorage synchronously.
-     * The solution is JSON stringified before storing.
-     * @param cacheKey The key under which to store the solution.
-     * @param cachedSolution The solution data to cache.
-     */
-    setCachedSolutionSync(cacheKey: string, cachedSolution: any): void;
-    /**
-     * Stores a solution in the cache asynchronously. Wraps the synchronous method.
-     * @param cacheKey The key under which to store the solution.
-     * @param cachedSolution The solution data to cache.
-     * @returns A promise that resolves when the solution is cached.
-     */
-    setCachedSolution(cacheKey: string, cachedSolution: any): Promise<void>;
-    /**
-     * Clears all cache entries created by this instance from localStorage
-     * and resets hit/miss counters.
-     */
-    clearCache(): void;
-    getAllCacheKeys(): string[];
+type AssignableViaCapacityPathingParams = ConstructorParameters<typeof AssignableViaCapacityPathingSolver_DirectiveSubOptimal>[0];
+type HyperParameterOverrides = Partial<CapacityHyperParameters> & {
+    TRACE_ORDERING_SEED?: number;
+    LAYER_TRAVERSAL_REWARD?: number;
+};
+declare class HyperAssignableViaCapacityPathingSolver extends HyperParameterSupervisorSolver<AssignableViaCapacityPathingSolver_DirectiveSubOptimal> {
+    constructorParams: AssignableViaCapacityPathingParams;
+    constructor(opts: AssignableViaCapacityPathingParams);
+    getHyperParameterDefs(): ({
+        name: string;
+        possibleValues: {
+            SHUFFLE_SEED: number;
+        }[];
+    } | {
+        name: string;
+        possibleValues: {
+            FORCE_VIA_TRAVEL_CHANCE: number;
+        }[];
+    })[];
+    computeG(solver: AssignableViaCapacityPathingSolver_DirectiveSubOptimal): number;
+    computeH(solver: AssignableViaCapacityPathingSolver_DirectiveSubOptimal): number;
+    generateSolver(hyperParameters: HyperParameterOverrides): AssignableViaCapacityPathingSolver_DirectiveSubOptimal;
 }
 
-declare global {
-    var TSCIRCUIT_AUTOROUTER_LOCAL_STORAGE_CACHE: LocalStorageCache;
-    var TSCIRCUIT_AUTOROUTER_IN_MEMORY_CACHE: InMemoryCache;
+/**
+ * Creates offboard edges between assignable via obstacles that share
+ * the same `offBoardConnectsTo` net name. These obstacles represent off-board
+ * connection points (like edge connectors) that are logically connected
+ * through external wiring.
+ *
+ * The solver finds all capacity nodes with `_assignedViaObstacle.offBoardConnectsTo`,
+ * groups them by net name, and creates zero-cost offboard edges between
+ * matching nodes. This allows the pathing solver to route through these virtual
+ * connections as if the obstacles were directly connected.
+ */
+declare class OffboardCapacityNodeSolver extends BaseSolver {
+    capacityNodes: CapacityMeshNode[];
+    capacityEdges: CapacityMeshEdge[];
+    enhancedEdges: CapacityMeshEdge[];
+    private animationState;
+    private assignableNodes;
+    private shownNodes;
+    private pendingEdges;
+    private createdEdges;
+    private nextEdgeId;
+    private nodeMap;
+    constructor(solverParams: {
+        capacityNodes: CapacityMeshNode[];
+        capacityEdges: CapacityMeshEdge[];
+    });
+    private initializeAssignableNodes;
+    private initializePendingEdges;
+    _step(): void;
+    private createOffboardEdge;
+    visualize(): GraphicsObject;
+    getVirtualOffboardNodes(): CapacityMeshNode[];
+    getOffboardEdges(): CapacityMeshEdge[];
 }
-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[];
+/**
+ * Splits capacity paths at offboard edges into separate fragments.
+ * When a path crosses an offboard edge (created by OffboardCapacityNodeSolver),
+ * this solver breaks it into independent path segments.
+ *
+ * Each fragment becomes a separate connection with its own `connectionName`
+ * (e.g., `AD_NET_frag_0`, `AD_NET_frag_1`). The solver also creates new
+ * `SimpleRouteConnection` entries with appropriate `pointsToConnect` - the
+ * original pad location plus a synthetic point at the offboard node.
+ *
+ * This enables downstream solvers to route each fragment independently,
+ * treating them as separate traces that terminate at off-board connection points.
+ */
+declare class OffboardPathFragmentSolver extends BaseSolver {
+    private inputPaths;
+    private capacityEdges;
+    private originalConnections;
+    fragmentedPaths: CapacityPath[];
+    fragmentedConnections: SimpleRouteConnection[];
+    fragmentedOriginalConnectionNames: Set<string>;
+    private nextFragmentId;
+    private animationState;
+    private currentPath;
+    private currentFragments;
+    private currentFragmentIndex;
+    private nodeMap;
+    constructor({ capacityPaths, capacityEdges, capacityNodes, connections, }: {
+        capacityPaths: CapacityPath[];
+        capacityEdges: CapacityMeshEdge[];
+        capacityNodes: CapacityMeshNode[];
+        connections: SimpleRouteConnection[];
+    });
+    _step(): void;
+    private createFragmentConnections;
+    private splitPath;
+    getFragmentedPaths(): CapacityPath[];
+    getFragmentedConnections(): SimpleRouteConnection[];
+    getFragmentedOriginalConnectionNames(): Set<string>;
+    visualize(): GraphicsObject;
+    private drawPath;
 }
 
-interface CapacityMeshNodeSolverOptions$2 {
+interface CapacityMeshSolverOptions {
     capacityDepth?: number;
+    targetMinCapacity?: number;
+    cacheProvider?: CacheProvider | null;
 }
-interface Target {
-    x: number;
-    y: number;
-    bounds: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    };
-    connectionName: string;
-    availableZ: number[];
-}
-declare class CapacityMeshNodeSolver extends BaseSolver {
+type AutoroutingPipelineSolverOptions = CapacityMeshSolverOptions;
+type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
+    solverName: string;
+    solverClass: T;
+    getConstructorParams: (instance: AssignableAutoroutingPipeline1Solver) => ConstructorParameters<T>;
+    onSolved?: (instance: AssignableAutoroutingPipeline1Solver) => void;
+};
+declare class AssignableAutoroutingPipeline1Solver extends BaseSolver {
     srj: SimpleRouteJson;
-    opts: CapacityMeshNodeSolverOptions$2;
-    unfinishedNodes: CapacityMeshNode[];
-    finishedNodes: CapacityMeshNode[];
-    nodeToXYOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle$1[]>;
-    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$1[];
-    getXYZOverlappingObstacles(node: CapacityMeshNode): Obstacle$1[];
-    /**
-     * 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;
+    opts: CapacityMeshSolverOptions;
+    netToPointPairsSolver?: NetToPointPairsSolver;
+    nodeSolver?: CapacityMeshNodeSolver;
+    nodeTargetMerger?: CapacityNodeTargetMerger;
+    edgeSolver?: CapacityMeshEdgeSolver;
+    initialPathingSolver?: AssignableViaCapacityPathingSolver_DirectiveSubOptimal;
+    initialPathingHyperSolver?: HyperAssignableViaCapacityPathingSolver;
+    pathingOptimizer?: CapacityPathingMultiSectionSolver;
+    edgeToPortSegmentSolver?: CapacityEdgeToPortSegmentSolver;
+    colorMap: Record<string, string>;
+    segmentToPointSolver?: CapacitySegmentToPointSolver;
+    unravelMultiSectionSolver?: UnravelMultiSectionSolver;
+    segmentToPointOptimizer?: CapacitySegmentPointOptimizer;
+    highDensityRouteSolver?: HighDensitySolver;
+    highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
+    singleLayerNodeMerger?: SingleLayerNodeMergerSolver_OnlyMergeTargets;
+    mergeAssignableViaNodes?: AssignableViaNodeMergerSolver;
+    offboardCapacityNodeSolver?: OffboardCapacityNodeSolver;
+    offboardPathFragmentSolver?: OffboardPathFragmentSolver;
+    strawSolver?: StrawSolver;
+    deadEndSolver?: DeadEndSolver;
+    uselessViaRemovalSolver1?: UselessViaRemovalSolver;
+    uselessViaRemovalSolver2?: UselessViaRemovalSolver;
+    multiSimplifiedPathSolver1?: MultiSimplifiedPathSolver;
+    multiSimplifiedPathSolver2?: MultiSimplifiedPathSolver;
+    startTimeOfPhase: Record<string, number>;
+    endTimeOfPhase: Record<string, number>;
+    timeSpentOnPhase: Record<string, number>;
+    activeSubSolver?: BaseSolver | null;
+    connMap: ConnectivityMap;
+    srjWithPointPairs?: SimpleRouteJson;
+    capacityNodes: CapacityMeshNode[] | null;
+    capacityEdges: CapacityMeshEdge[] | null;
+    cacheProvider: CacheProvider | null;
+    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver_OnlyTraverseLayersInAssignableObstacles> | PipelineStep<typeof AssignableViaNodeMergerSolver> | PipelineStep<typeof SingleLayerNodeMergerSolver_OnlyMergeTargets> | PipelineStep<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep<typeof OffboardCapacityNodeSolver> | PipelineStep<typeof DeadEndSolver> | PipelineStep<typeof HyperAssignableViaCapacityPathingSolver> | PipelineStep<typeof OffboardPathFragmentSolver> | 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);
+    getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions];
+    currentPipelineStepIndex: number;
     _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.
-     */
+    solveUntilPhase(phase: string): void;
+    getCurrentPhase(): string;
     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
+     * A lightweight version of the visualize method that can be used to stream
+     * progress
+     *
+     * We return the most relevant graphic for the stage:
+     * 1. netToPointPairs output
+     * 2. Capacity Planning Output
+     * 3. High Density Route Solver Output, max 200 lines
      */
-    shouldFilterSingleLayerNodeForObstacle(node: CapacityMeshNode): boolean;
+    preview(): GraphicsObject;
+    _getOutputHdRoutes(): HighDensityRoute$1[];
     /**
-     * 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
+     * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
      */
-    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;
+    getOutputSimplifiedPcbTraces(): SimplifiedPcbTraces;
+    getOutputSimpleRouteJson(): SimpleRouteJson;
 }
 
-interface CapacityMeshNodeSolverOptions {
-    capacityDepth?: number;
-}
+declare const convertSrjToGraphicsObject: (srj: SimpleRouteJson) => {
+    rects: Rect[];
+    circles: Circle[];
+    lines: Line[];
+    points: Point$5[];
+};
+
+type FutureConnection = {
+    connectionName: string;
+    points: {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+};
 /**
- * This capacity mesh node solver is meant to be used in contexts where vias
- * aren't allowed, but there may be assignable vias on the PCB as obstacles.
- *
- * Behavior:
- * - Outside assignable obstacles, multi-layer nodes are *always* Z-split into single-layer nodes.
- * - During mesh subdivision, nodes overlapping with "assignable" obstacles
- *   (obstacle.netIsAssignable === true) are NOT filtered, allowing normal subdivision.
- * - After the main mesh subdivision is complete:
- *   1. All nodes overlapping with assignable obstacles are removed
- *   2. Each assignable obstacle is replaced with a single multi-layer node spanning all layers
- * - Single-layer nodes that are larger than MAX_SIZE_FOR_SINGLE_LAYER_NODES are XY-subdivided.
- * - IMPORTANT: the multi-layer nodes created from assignable obstacles are **traversable**,
- *   so we mark `_containsObstacle = false` and `_completelyInsideObstacle = false` on them.
+ * Components that make up the g (cost so far) calculation
  */
-declare class CapacityMeshNodeSolver_OnlyTraverseLayersInAssignableObstacles extends CapacityMeshNodeSolver2_NodeUnderObstacle {
-    srj: SimpleRouteJson;
-    opts: CapacityMeshNodeSolverOptions;
-    MAX_SIZE_FOR_SINGLE_LAYER_NODES: number;
-    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions);
-    private isObstacleAssignable;
-    private getOverlappingAssignableObstacles;
-    shouldNodeBeXYSubdivided(node: CapacityMeshNode): boolean;
-    /**
-     * Filter nodes for obstacles, but skip filtering for assignable obstacles.
-     * Assignable obstacles will be handled separately at the end.
-     */
-    shouldFilterNodeForObstacle(node: CapacityMeshNode): boolean;
-    /**
-     * Remove nodes inside assignable obstacles and replace with single multi-layer nodes.
-     * The new node's bounds are extended to cover all removed nodes' XY space.
-     */
-    private insertAssignableObstaclesAsNodes;
-    _step(): void;
-}
-
+type GComponents = {
+    /** Total path distance traveled from start */
+    distFromStart: number;
+    /** Cumulative weighted penalty for being near obstacles */
+    weightedMmNearObstacle: number;
+    /** Cumulative weighted penalty for being near edges */
+    weightedMmNearEdge: number;
+    /** Cumulative weighted penalty for being near future connection start/end points */
+    weightedMmNearFutureConnectionStartEnd: number;
+    /** Cumulative weighted penalty for being near future connection lines */
+    weightedMmNearFutureConnectionLine: number;
+    /** Cumulative jumper penalty (includes jumper distance + penalty factor) */
+    jumperPenalty: number;
+    /** Cumulative penalty for jumper pads near future connections */
+    jumperPadFutureConnectionPenalty: number;
+    /** Total g value (sum of all components) */
+    total: number;
+};
 /**
- * Variant of SingleLayerNodeMergerSolver that only merges nodes containing targets.
- * Nodes without targets are passed through unchanged.
+ * Components that make up the h (heuristic) calculation
  */
-declare class SingleLayerNodeMergerSolver_OnlyMergeTargets extends BaseSolver {
-    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
-    currentBatchNodeIds: CapacityMeshNodeId[];
-    absorbedNodeIds: Set<CapacityMeshNodeId>;
-    nextBatchNodeIds: CapacityMeshNodeId[];
-    batchHadModifications: boolean;
-    hasComputedAdjacentNodeIds: boolean;
-    newNodes: CapacityMeshNode[];
-    constructor(nodes: CapacityMeshNode[]);
-    computeAdjacentNodeIdsForFirstBatch(nodes: CapacityMeshNode[]): void;
-    getAdjacentSameLayerUnprocessedNodes(rootNode: CapacityMeshNode): CapacityMeshNode[];
-    _step(): void;
-    visualize(): GraphicsObject;
-}
-
+type HComponents = {
+    distanceToGoal: number;
+    obstacleProximity: number;
+    edgeProximity: number;
+    futureConnectionStartEndProximityPenalty: number;
+    futureConnectionLine: number;
+    total: number;
+    /** Stored rates (penalty per mm) for derivative computation */
+    obstacleProximityRate: number;
+    edgeProximityRate: number;
+    futureConnectionStartEndProximityRate: number;
+    futureConnectionLineRate: number;
+};
 /**
- * This solver merges nodes that represent the same assignable obstacle into a single node.
- *
- * For each assignable obstacle:
- * - Finds all nodes that have _assignedViaObstacle pointing to that obstacle
- * - Replaces them with a single node representing the bounding box of all removed nodes
- * - Each step handles one assignable obstacle
+ * Extended node type that tracks jumper usage
  */
-declare class AssignableViaNodeMergerSolver extends BaseSolver {
-    newNodes: CapacityMeshNode[];
-    obstacleToNodesMap: Map<Obstacle$1, CapacityMeshNode[]>;
-    obstaclesToProcess: Obstacle$1[];
-    mergedNodeIds: Set<CapacityMeshNodeId>;
-    constructor(nodes: CapacityMeshNode[]);
-    _step(): void;
-    visualize(): GraphicsObject;
-}
-
-interface Point {
-    x: number;
-    y: number;
-    z: number;
-}
-declare class SingleSimplifiedPathSolver extends BaseSolver {
-    newRoute: HighDensityIntraNodeRoute$1["route"];
-    newVias: HighDensityIntraNodeRoute$1["vias"];
-    headIndex: number;
-    tailIndex: number;
-    inputRoute: HighDensityIntraNodeRoute$1;
-    otherHdRoutes: HighDensityIntraNodeRoute$1[];
-    obstacles: Obstacle$1[];
-    connMap: ConnectivityMap;
-    colorMap: Record<string, string>;
-    outline?: Array<{
+type JumperNode = Node & {
+    /** If this node was reached via a jumper, this contains jumper info */
+    jumperEntry?: {
         x: number;
         y: number;
+    };
+    /** Track if this movement is the exit of a jumper */
+    isJumperExit?: boolean;
+    /** Count of jumpers used to reach this node */
+    jumperCount?: number;
+    /** Stored g components for debugging/visualization */
+    gComponents?: GComponents;
+    /** Stored h components for debugging/visualization */
+    hComponents?: HComponents;
+};
+declare class SingleHighDensityRouteWithJumpersSolver extends BaseSolver {
+    obstacleRoutes: HighDensityIntraNodeRouteWithJumpers[];
+    bounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+    boundsSize: {
+        width: number;
+        height: number;
+    };
+    boundsCenter: {
+        x: number;
+        y: number;
+    };
+    A: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    B: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    roundedGoalPosition: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    straightLineDistance: number;
+    traceThickness: number;
+    obstacleMargin: number;
+    minCellSize: number;
+    cellStep: number;
+    GREEDY_MULTIPLER: number;
+    numRoutes: number;
+    /** Penalty factor for using a jumper (relative to distance) */
+    JUMPER_PENALTY_FACTOR: number;
+    /** Future connection proximity parameters */
+    FUTURE_CONNECTION_START_END_PENALTY: number;
+    FUTURE_CONNECTION_START_END_PROXIMITY: number;
+    /** Future connection jumper pad penalty parameters */
+    FUTURE_CONNECTION_JUMPER_PAD_PROXIMITY: number;
+    FUTURE_CONNECTION_JUMPER_PAD_PENALTY: number;
+    /** Jumper-to-jumper pad proximity penalty parameters */
+    JUMPER_JUMPER_PAD_PROXIMITY: number;
+    JUMPER_JUMPER_PAD_PENALTY: number;
+    /** Future connection line proximity penalty parameters */
+    FUTURE_CONNECTION_LINE_PROXIMITY: number;
+    FUTURE_CONNECTION_LINE_PENALTY: number;
+    /** Obstacle proximity penalty parameters (repulsive field) */
+    OBSTACLE_PROX_PENALTY_FACTOR: number;
+    OBSTACLE_PROX_SIGMA: number;
+    /** Edge proximity penalty parameters */
+    EDGE_PROX_PENALTY_FACTOR: number;
+    EDGE_PROX_SIGMA: number;
+    /** Whether to allow diagonal movement in pathfinding */
+    ALLOW_DIAGONAL: boolean;
+    /** Minimum distance traveled before allowing jumper neighbors */
+    MIN_TRAVEL_BEFORE_JUMPER: number;
+    CELL_SIZE_FACTOR: number;
+    exploredNodes: Set<string>;
+    candidates: SingleRouteCandidatePriorityQueue<JumperNode>;
+    connectionName: string;
+    rootConnectionName?: string;
+    solvedPath: HighDensityIntraNodeRouteWithJumpers | null;
+    futureConnections: FutureConnection[];
+    hyperParameters: Partial<HighDensityHyperParameters>;
+    connMap?: ConnectivityMap;
+    /** For debugging/animating the exploration */
+    debug_exploredNodesOrdered: string[];
+    debug_exploredNodeValues: Map<string, {
+        g: number;
+        h: number;
+        f: number;
+        gComponents?: GComponents;
+        hComponents?: HComponents;
     }>;
-    constructor(params: {
-        inputRoute: HighDensityIntraNodeRoute$1;
-        otherHdRoutes: HighDensityIntraNodeRoute$1[];
-        obstacles: Obstacle$1[];
-        connMap: ConnectivityMap;
-        colorMap: Record<string, string>;
-        outline?: Array<{
+    debug_nodesTooCloseToObstacle: Set<string>;
+    debug_nodePathToParentIntersectsObstacle: Set<string>;
+    debugEnabled: boolean;
+    initialNodeGridOffset: {
+        x: number;
+        y: number;
+    };
+    /** Existing jumpers that act as obstacles */
+    existingJumpers: Jumper[];
+    constructor(opts: {
+        connectionName: string;
+        rootConnectionName?: string;
+        obstacleRoutes: HighDensityIntraNodeRouteWithJumpers[];
+        minDistBetweenEnteringPoints: number;
+        bounds: {
+            minX: number;
+            maxX: number;
+            minY: number;
+            maxY: number;
+        };
+        A: {
             x: number;
             y: number;
-        }>;
-    });
-    getConstructorParams(): {
-        inputRoute: HighDensityIntraNodeRoute$1;
-        otherHdRoutes: HighDensityIntraNodeRoute$1[];
-        obstacles: Obstacle$1[];
-        connMap: Record<string, string[]>;
-        colorMap: Record<string, string>;
-        outline: {
+            z: number;
+        };
+        B: {
             x: number;
             y: number;
-        }[] | undefined;
-    };
-    get simplifiedRoute(): HighDensityIntraNodeRoute$1;
-    isValidPath(pointsInRoute: Point[]): boolean;
-    _step(): void;
-    getVisualsForNewRouteAndObstacles(): GraphicsObject & Pick<Required<GraphicsObject>, "points" | "lines" | "rects" | "circles">;
-}
-
-declare class MultiSimplifiedPathSolver extends BaseSolver {
-    simplifiedHdRoutes: HighDensityIntraNodeRoute$1[];
-    currentUnsimplifiedHdRouteIndex: number;
-    activeSubSolver: SingleSimplifiedPathSolver | null;
-    unsimplifiedHdRoutes: HighDensityIntraNodeRoute$1[];
-    obstacles: Obstacle$1[];
-    connMap: ConnectivityMap;
-    colorMap: Record<string, string>;
-    outline?: Array<{
+            z: number;
+        };
+        traceThickness?: number;
+        obstacleMargin?: number;
+        futureConnections?: FutureConnection[];
+        hyperParameters?: Partial<HighDensityHyperParameters>;
+        connMap?: ConnectivityMap;
+    });
+    handleSimpleCases(): void;
+    get jumperPenaltyDistance(): number;
+    /**
+     * Check if a node is too close to an obstacle trace or jumper
+     */
+    isNodeTooCloseToObstacle(node: JumperNode, margin?: number): boolean;
+    /**
+     * Check if a node is too close to a jumper's pads
+     * Traces CAN route under the body of the jumper, just not under the pads
+     */
+    isNodeTooCloseToJumper(node: {
         x: number;
         y: number;
-    }>;
-    defaultViaDiameter: number;
-    constructor(params: {
-        unsimplifiedHdRoutes: HighDensityIntraNodeRoute$1[];
-        obstacles: Obstacle$1[];
-        connMap?: ConnectivityMap;
-        colorMap?: Record<string, string>;
-        outline?: Array<{
+    }, jumper: Jumper, margin: number): boolean;
+    isNodeTooCloseToEdge(node: JumperNode): boolean;
+    doesPathToParentIntersectObstacle(node: JumperNode): boolean;
+    /**
+     * Check if a line segment intersects with a jumper's pads
+     * Segments CAN pass under the jumper body, just not through the pads
+     */
+    doesSegmentIntersectJumperPads(p1: {
+        x: number;
+        y: number;
+    }, p2: {
+        x: number;
+        y: number;
+    }, jumper: Jumper): boolean;
+    /**
+     * Check if a line segment intersects with an axis-aligned rectangle
+     */
+    doesSegmentIntersectRect(p1: {
+        x: number;
+        y: number;
+    }, p2: {
+        x: number;
+        y: number;
+    }, center: {
+        x: number;
+        y: number;
+    }, halfWidth: number, halfHeight: number): boolean;
+    /**
+     * Find obstacles between current node and a target position
+     * Returns the obstacle segment(s) that block the direct path
+     */
+    findObstaclesBetween(from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }): Array<{
+        A: {
             x: number;
             y: number;
-        }>;
-        defaultViaDiameter?: number;
-    });
-    _step(): void;
-    visualize(): GraphicsObject;
-}
-
-interface RouteSection {
-    startIndex: number;
-    endIndex: number;
-    z: number;
-    points: HighDensityRoute["route"];
-}
-declare class SingleRouteUselessViaRemovalSolver extends BaseSolver {
-    obstacleSHI: ObstacleSpatialHashIndex;
-    hdRouteSHI: HighDensityRouteSpatialIndex;
-    unsimplifiedRoute: HighDensityRoute;
-    routeSections: Array<RouteSection>;
-    currentSectionIndex: number;
-    TRACE_THICKNESS: number;
-    OBSTACLE_MARGIN: number;
-    constructor(params: {
-        obstacleSHI: ObstacleSpatialHashIndex;
-        hdRouteSHI: HighDensityRouteSpatialIndex;
-        unsimplifiedRoute: HighDensityRoute;
-    });
-    breakRouteIntoSections(route: HighDensityRoute): never[] | this["routeSections"];
-    _step(): void;
+        };
+        B: {
+            x: number;
+            y: number;
+        };
+    }>;
+    computeHComponents(node: JumperNode): HComponents;
+    computeH(node: JumperNode): number;
+    computeGComponents(node: JumperNode): GComponents;
+    computeG(node: JumperNode): number;
+    computeF(g: number, h: number): number;
+    getClosestFutureConnectionPoint(node: JumperNode): {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+    getFutureConnectionStartEndPenalty(node: JumperNode): number;
     /**
-     * Check if an endpoint (first or last point of the route) can connect
-     * to a different layer. This is only allowed if the obstacles the endpoint
-     * connects to support that layer.
+     * Calculate penalty for being close to future connection line segments.
+     * This penalty is computed by summing the segment-to-point distance between
+     * the node and all unrouted future connection start-to-end segments.
+     * The penalty helps routes avoid crossing directly over future connection paths.
      */
-    canEndpointConnectOnLayer(endpointX: number, endpointY: number, targetZ: number): boolean;
-    canSectionMoveToLayer({ currentSection, targetZ, }: {
-        currentSection: RouteSection;
-        targetZ: number;
-    }): boolean;
-    getConstructorParams(): {
-        obstacleSHI: ObstacleSpatialHashIndex;
-        hdRouteSHI: HighDensityRouteSpatialIndex;
-        unsimplifiedRoute: HighDensityIntraNodeRoute;
-    };
-    getOptimizedHdRoute(): HighDensityRoute;
-    visualize(): GraphicsObject;
-}
-
-interface UselessViaRemovalSolverInput {
-    unsimplifiedHdRoutes: HighDensityRoute$1[];
-    obstacles: Obstacle$1[];
-    colorMap: Record<string, string>;
-    layerCount: number;
-}
-declare class UselessViaRemovalSolver extends BaseSolver {
-    private input;
-    unsimplifiedHdRoutes: HighDensityRoute$1[];
-    optimizedHdRoutes: HighDensityRoute$1[];
-    unprocessedRoutes: HighDensityRoute$1[];
-    activeSubSolver?: SingleRouteUselessViaRemovalSolver | null | undefined;
-    obstacleSHI: ObstacleSpatialHashIndex | null;
-    hdRouteSHI: HighDensityRouteSpatialIndex | null;
-    constructor(input: UselessViaRemovalSolverInput);
-    _step(): void;
-    getOptimizedHdRoutes(): HighDensityRoute$1[] | null;
-    visualize(): GraphicsObject;
-}
-
-type Candidate = {
-    prevCandidate: Candidate | null;
-    node: CapacityMeshNode;
-    f: number;
-    g: number;
-    h: number;
-};
-type AssignableViaCapacityHyperParameters = Partial<CapacityHyperParameters> & {
-    SHUFFLE_SEED?: number;
-    DIRECTIVE_SEED?: number;
-    FORCE_VIA_TRAVEL_CHANCE?: number;
-    FAR_VIA_MIN_DISTANCE?: number;
-    MAX_CLOSEST_VIA_SKIP?: number;
-    MAX_FURTHEST_VIA_SKIP?: number;
-};
-type ConnectionNodePair = {
-    start: CapacityMeshNode;
-    end: CapacityMeshNode;
-    connection: SimpleRouteConnection;
-};
-type SubpathNodePair = {
-    start: CapacityMeshNode;
-    end: CapacityMeshNode;
-    solved: boolean;
-    path?: CapacityMeshNode[];
-    layer: number;
-};
-type ConnectionPathWithNodes = {
-    connection: SimpleRouteConnection;
-    path: CapacityMeshNode[];
-};
-/**
- * See description in the prompt
- */
-declare class AssignableViaCapacityPathingSolver_DirectiveSubOptimal extends BaseSolver {
-    private inputParams;
+    getFutureConnectionLinePenalty(node: JumperNode): number;
     /**
-     * Bias toward greedier choices (f = g + GREEDY_MULTIPLIER * h)
+     * Calculate penalty for jumper pads placed near future connection start/end points.
+     * This disincentivizes placing jumper pads in areas that will be needed for future routing.
+     * The distance is calculated as the minimum distance from either jumper pad to any future connection point.
      */
-    GREEDY_MULTIPLIER: number;
-    simpleRouteJson: SimpleRouteJson;
-    nodes: CapacityMeshNode[];
-    edges: CapacityMeshEdge[];
-    colorMap: Record<string, string>;
-    MAX_ITERATIONS: number;
-    hyperParameters: Partial<AssignableViaCapacityHyperParameters>;
-    usedNodeMap: Map<CapacityMeshNodeId, true>;
-    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
-    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
-    unprocessedConnectionPairs: ConnectionNodePair[];
-    solvedRoutes: ConnectionPathWithNodes[];
-    activeConnectionPair: ConnectionNodePair | null;
-    ogUnprocessedSubpaths: SubpathNodePair[] | null;
-    unprocessedSubpaths: SubpathNodePair[] | null;
-    solvedSubpaths: SubpathNodePair[] | null;
-    activeSubpath: SubpathNodePair | null;
-    viaNodes: CapacityMeshNode[];
-    closestViaForConnectionStartMap: Map<ConnectionNodePair, CapacityMeshNode>;
-    closestViaForConnectionEndMap: Map<ConnectionNodePair, CapacityMeshNode>;
-    constructor(inputParams: {
-        simpleRouteJson: SimpleRouteJson;
-        nodes: CapacityMeshNode[];
-        edges: CapacityMeshEdge[];
-        colorMap?: Record<string, string>;
-        MAX_ITERATIONS?: number;
-        hyperParameters?: Partial<AssignableViaCapacityHyperParameters>;
-    });
-    getConstructorParams(): typeof this.inputParams;
-    lastStepOperation: "none" | "dequeueConnectionPair" | "breakConnectionPairIntoSubpaths" | "dequeueSubpath" | "stepSolveSubpath" | "finishedSolvingSubpath" | "finishedSolvingConnectionPair";
+    getJumperPadFutureConnectionPenalty(node: JumperNode): number;
+    /**
+     * Compute the minimum distance from a node to any obstacle (trace segments and jumper pads)
+     */
+    getClearanceToObstacles(node: {
+        x: number;
+        y: number;
+    }): number;
+    /**
+     * Compute distance from a point to the nearest jumper pad
+     */
+    distanceToJumperPads(p: {
+        x: number;
+        y: number;
+    }, j: Jumper): number;
+    /**
+     * Compute distance from a point to an axis-aligned rectangle (0 if inside)
+     */
+    pointToRectDistance(p: {
+        x: number;
+        y: number;
+    }, c: {
+        x: number;
+        y: number;
+    }, halfW: number, halfH: number): number;
+    /**
+     * Compute minimum distance from a node to the nearest boundary edge
+     */
+    getClearanceToEdge(node: {
+        x: number;
+        y: number;
+    }): number;
+    /**
+     * Compute the obstacle proximity penalty (repulsive field)
+     * Returns a high value near obstacles, ~0 far away
+     */
+    getObstacleProximityPenalty(node: JumperNode): number;
+    /**
+     * Compute the edge proximity penalty (repulsive field near boundaries)
+     * Returns a high value near edges, ~0 far away
+     * Penalty is reduced as we approach the goal (which is always on an edge)
+     */
+    getEdgeProximityPenalty(node: JumperNode): number;
+    getNodeKey(node: JumperNode): string;
+    /**
+     * Calculate potential jumper positions to cross an obstacle
+     */
+    getJumperNeighbors(node: JumperNode): JumperNode[];
+    /**
+     * Calculate the exit position for a jumper that clears an obstacle
+     */
+    calculateJumperExit(entry: JumperNode, obstacle: {
+        A: {
+            x: number;
+            y: number;
+        };
+        B: {
+            x: number;
+            y: number;
+        };
+    }, direction: {
+        dx: number;
+        dy: number;
+    }): JumperNode | null;
+    /**
+     * Check if a jumper's pads are too close to obstacle traces
+     */
+    isJumperTooCloseToTraces(entry: {
+        x: number;
+        y: number;
+    }, exit: {
+        x: number;
+        y: number;
+    }): boolean;
     /**
-     * Computes and stores the closest via for both start and end of each unprocessed connection pair.
-     * This is used to ensure we don't "steal" a via that's closest to another connection.
+     * Verify that a jumper placement is valid (doesn't overlap with existing jumpers or traces)
      */
-    computeClosestViaForAllConnections(): void;
-    _step(): void;
-    queuedCandidateNodes: Candidate[];
-    visitedNodes: Set<CapacityMeshNodeId>;
-    private _dist;
-    stepSolveSubpath(subpath: SubpathNodePair): void;
-    getNeighbors(node: CapacityMeshNode): CapacityMeshNode[];
-    clearCandidateNodes(): void;
-    computeG(prevCandidate: Candidate, node: CapacityMeshNode, _endGoal: CapacityMeshNode): number;
-    computeH(_prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    createSolvedRoute(subpaths: SubpathNodePair[], connectionPair: ConnectionNodePair): ConnectionPathWithNodes;
-    breakConnectionPairIntoSubpaths(connectionPair: ConnectionNodePair): SubpathNodePair[];
-    getClosestVia(node: CapacityMeshNode): CapacityMeshNode;
-    getFarVia(closestVia: CapacityMeshNode, end: CapacityMeshNode): CapacityMeshNode;
-    getCapacityPaths(): CapacityPath[];
-    visualize(): GraphicsObject;
-}
-
-type AssignableViaCapacityPathingParams = ConstructorParameters<typeof AssignableViaCapacityPathingSolver_DirectiveSubOptimal>[0];
-type HyperParameterOverrides = Partial<CapacityHyperParameters> & {
-    TRACE_ORDERING_SEED?: number;
-    LAYER_TRAVERSAL_REWARD?: number;
-};
-declare class HyperAssignableViaCapacityPathingSolver extends HyperParameterSupervisorSolver<AssignableViaCapacityPathingSolver_DirectiveSubOptimal> {
-    constructorParams: AssignableViaCapacityPathingParams;
-    constructor(opts: AssignableViaCapacityPathingParams);
-    getHyperParameterDefs(): ({
-        name: string;
-        possibleValues: {
-            SHUFFLE_SEED: number;
-        }[];
-    } | {
-        name: string;
-        possibleValues: {
-            FORCE_VIA_TRAVEL_CHANCE: number;
-        }[];
-    })[];
-    computeG(solver: AssignableViaCapacityPathingSolver_DirectiveSubOptimal): number;
-    computeH(solver: AssignableViaCapacityPathingSolver_DirectiveSubOptimal): number;
-    generateSolver(hyperParameters: HyperParameterOverrides): AssignableViaCapacityPathingSolver_DirectiveSubOptimal;
-}
-
-/**
- * Creates offboard edges between assignable via obstacles that share
- * the same `offBoardConnectsTo` net name. These obstacles represent off-board
- * connection points (like edge connectors) that are logically connected
- * through external wiring.
- *
- * The solver finds all capacity nodes with `_assignedViaObstacle.offBoardConnectsTo`,
- * groups them by net name, and creates zero-cost offboard edges between
- * matching nodes. This allows the pathing solver to route through these virtual
- * connections as if the obstacles were directly connected.
- */
-declare class OffboardCapacityNodeSolver extends BaseSolver {
-    capacityNodes: CapacityMeshNode[];
-    capacityEdges: CapacityMeshEdge[];
-    enhancedEdges: CapacityMeshEdge[];
-    private animationState;
-    private assignableNodes;
-    private shownNodes;
-    private pendingEdges;
-    private createdEdges;
-    private nextEdgeId;
-    private nodeMap;
-    constructor(solverParams: {
-        capacityNodes: CapacityMeshNode[];
-        capacityEdges: CapacityMeshEdge[];
-    });
-    private initializeAssignableNodes;
-    private initializePendingEdges;
+    isJumperPlacementValid(entry: JumperNode, exit: JumperNode): boolean;
+    /**
+     * Check if two jumpers overlap
+     */
+    doJumpersOverlap(j1: Jumper, j2: Jumper): boolean;
+    /**
+     * Get all jumpers in the path to a node
+     */
+    getJumpersInPath(node: JumperNode): Jumper[];
+    getNeighbors(node: JumperNode): JumperNode[];
+    getNodePath(node: JumperNode): JumperNode[];
+    setSolvedPath(node: JumperNode): void;
+    computeProgress(currentNode: JumperNode, goalDist: number): number;
     _step(): void;
-    private createOffboardEdge;
+    /**
+     * Draw the two pads of an 0603 jumper
+     * Pad dimensions are rotated based on jumper orientation
+     */
+    private drawJumperPads;
     visualize(): GraphicsObject;
-    getVirtualOffboardNodes(): CapacityMeshNode[];
-    getOffboardEdges(): CapacityMeshEdge[];
 }
 
 /**
- * Splits capacity paths at offboard edges into separate fragments.
- * When a path crosses an offboard edge (created by OffboardCapacityNodeSolver),
- * this solver breaks it into independent path segments.
- *
- * Each fragment becomes a separate connection with its own `connectionName`
- * (e.g., `AD_NET_frag_0`, `AD_NET_frag_1`). The solver also creates new
- * `SimpleRouteConnection` entries with appropriate `pointsToConnect` - the
- * original pad location plus a synthetic point at the offboard node.
+ * IntraNodeSolverWithJumpers is designed for single-layer nodes that use
+ * 0603 jumpers to allow traces to jump over each other.
  *
- * This enables downstream solvers to route each fragment independently,
- * treating them as separate traces that terminate at off-board connection points.
+ * Unlike the standard IntraNodeRouteSolver which uses vias to change layers,
+ * this solver operates on a single layer and uses physical jumper components
+ * to handle trace crossings.
  */
-declare class OffboardPathFragmentSolver extends BaseSolver {
-    private inputPaths;
-    private capacityEdges;
-    private originalConnections;
-    fragmentedPaths: CapacityPath[];
-    fragmentedConnections: SimpleRouteConnection[];
-    fragmentedOriginalConnectionNames: Set<string>;
-    private nextFragmentId;
-    private animationState;
-    private currentPath;
-    private currentFragments;
-    private currentFragmentIndex;
-    private nodeMap;
-    constructor({ capacityPaths, capacityEdges, capacityNodes, connections, }: {
-        capacityPaths: CapacityPath[];
-        capacityEdges: CapacityMeshEdge[];
-        capacityNodes: CapacityMeshNode[];
-        connections: SimpleRouteConnection[];
-    });
-    _step(): void;
-    private createFragmentConnections;
-    private splitPath;
-    getFragmentedPaths(): CapacityPath[];
-    getFragmentedConnections(): SimpleRouteConnection[];
-    getFragmentedOriginalConnectionNames(): Set<string>;
-    visualize(): GraphicsObject;
-    private drawPath;
-}
-
-interface CapacityMeshSolverOptions {
-    capacityDepth?: number;
-    targetMinCapacity?: number;
-    cacheProvider?: CacheProvider | null;
-}
-type AutoroutingPipelineSolverOptions = CapacityMeshSolverOptions;
-type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
-    solverName: string;
-    solverClass: T;
-    getConstructorParams: (instance: AssignableAutoroutingPipeline1Solver) => ConstructorParameters<T>;
-    onSolved?: (instance: AssignableAutoroutingPipeline1Solver) => void;
-};
-declare class AssignableAutoroutingPipeline1Solver extends BaseSolver {
-    srj: SimpleRouteJson;
-    opts: CapacityMeshSolverOptions;
-    netToPointPairsSolver?: NetToPointPairsSolver;
-    nodeSolver?: CapacityMeshNodeSolver;
-    nodeTargetMerger?: CapacityNodeTargetMerger;
-    edgeSolver?: CapacityMeshEdgeSolver;
-    initialPathingSolver?: AssignableViaCapacityPathingSolver_DirectiveSubOptimal;
-    initialPathingHyperSolver?: HyperAssignableViaCapacityPathingSolver;
-    pathingOptimizer?: CapacityPathingMultiSectionSolver;
-    edgeToPortSegmentSolver?: CapacityEdgeToPortSegmentSolver;
+declare class IntraNodeSolverWithJumpers extends BaseSolver {
+    nodeWithPortPoints: NodeWithPortPoints;
     colorMap: Record<string, string>;
-    segmentToPointSolver?: CapacitySegmentToPointSolver;
-    unravelMultiSectionSolver?: UnravelMultiSectionSolver;
-    segmentToPointOptimizer?: CapacitySegmentPointOptimizer;
-    highDensityRouteSolver?: HighDensitySolver;
-    highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
-    singleLayerNodeMerger?: SingleLayerNodeMergerSolver_OnlyMergeTargets;
-    mergeAssignableViaNodes?: AssignableViaNodeMergerSolver;
-    offboardCapacityNodeSolver?: OffboardCapacityNodeSolver;
-    offboardPathFragmentSolver?: OffboardPathFragmentSolver;
-    strawSolver?: StrawSolver;
-    deadEndSolver?: DeadEndSolver;
-    uselessViaRemovalSolver1?: UselessViaRemovalSolver;
-    uselessViaRemovalSolver2?: UselessViaRemovalSolver;
-    multiSimplifiedPathSolver1?: MultiSimplifiedPathSolver;
-    multiSimplifiedPathSolver2?: MultiSimplifiedPathSolver;
-    startTimeOfPhase: Record<string, number>;
-    endTimeOfPhase: Record<string, number>;
-    timeSpentOnPhase: Record<string, number>;
-    activeSubSolver?: BaseSolver | null;
-    connMap: ConnectivityMap;
-    srjWithPointPairs?: SimpleRouteJson;
-    capacityNodes: CapacityMeshNode[] | null;
-    capacityEdges: CapacityMeshEdge[] | null;
-    cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver_OnlyTraverseLayersInAssignableObstacles> | PipelineStep<typeof AssignableViaNodeMergerSolver> | PipelineStep<typeof SingleLayerNodeMergerSolver_OnlyMergeTargets> | PipelineStep<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep<typeof OffboardCapacityNodeSolver> | PipelineStep<typeof DeadEndSolver> | PipelineStep<typeof HyperAssignableViaCapacityPathingSolver> | PipelineStep<typeof OffboardPathFragmentSolver> | 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);
-    getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions];
-    currentPipelineStepIndex: number;
+    unsolvedConnections: {
+        connectionName: string;
+        rootConnectionName?: string;
+        points: {
+            x: number;
+            y: number;
+            z: number;
+        }[];
+    }[];
+    totalConnections: number;
+    solvedRoutes: HighDensityIntraNodeRouteWithJumpers[];
+    failedSubSolvers: SingleHighDensityRouteWithJumpersSolver[];
+    hyperParameters: Partial<HighDensityHyperParameters>;
+    minDistBetweenEnteringPoints: number;
+    traceWidth: number;
+    activeSubSolver: SingleHighDensityRouteWithJumpersSolver | null;
+    lastActiveSubSolver: SingleHighDensityRouteWithJumpersSolver | null;
+    connMap?: ConnectivityMap;
+    get failedSolvers(): SingleHighDensityRouteWithJumpersSolver[];
+    get activeSolver(): SingleHighDensityRouteWithJumpersSolver | null;
+    constructor(params: {
+        nodeWithPortPoints: NodeWithPortPoints;
+        colorMap?: Record<string, string>;
+        hyperParameters?: Partial<HighDensityHyperParameters>;
+        connMap?: ConnectivityMap;
+        traceWidth?: number;
+    });
+    getConstructorParams(): {
+        nodeWithPortPoints: NodeWithPortPoints;
+        colorMap: Record<string, string>;
+        hyperParameters: Partial<HighDensityHyperParameters>;
+        connMap: ConnectivityMap | undefined;
+        traceWidth: number;
+    };
+    computeProgress(): number;
     _step(): void;
-    solveUntilPhase(phase: string): void;
-    getCurrentPhase(): string;
-    visualize(): GraphicsObject;
-    /**
-     * A lightweight version of the visualize method that can be used to stream
-     * progress
-     *
-     * We return the most relevant graphic for the stage:
-     * 1. netToPointPairs output
-     * 2. Capacity Planning Output
-     * 3. High Density Route Solver Output, max 200 lines
-     */
-    preview(): GraphicsObject;
-    _getOutputHdRoutes(): HighDensityRoute$1[];
     /**
-     * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
+     * Draw the two pads of an 0603 jumper
+     * Pad dimensions are rotated based on jumper orientation
      */
-    getOutputSimplifiedPcbTraces(): SimplifiedPcbTraces;
-    getOutputSimpleRouteJson(): SimpleRouteJson;
+    private drawJumperPads;
+    visualize(): GraphicsObject;
 }
 
-declare const convertSrjToGraphicsObject: (srj: SimpleRouteJson) => {
-    rects: Rect[];
-    circles: Circle[];
-    lines: Line[];
-    points: Point$5[];
-};
-
 export { AssignableAutoroutingPipeline1Solver, AssignableAutoroutingPipeline2, AutoroutingPipeline1_OriginalUnravel, AutoroutingPipelineSolver2_PortPointPathing as AutoroutingPipelineSolver, type AutoroutingPipelineSolverOptions, type CachableSolver, type CacheProvider, CapacityMeshSolver, type HighDensityIntraNodeRouteWithJumpers, JumperHighDensitySolver as HighDensitySolver, InMemoryCache, IntraNodeSolverWithJumpers, type Jumper, LocalStorageCache, SingleHighDensityRouteWithJumpersSolver, calculateOptimalCapacityDepth, convertSrjToGraphicsObject, getGlobalInMemoryCache, getGlobalLocalStorageCache, getTunedTotalCapacity1, setupGlobalCaches };