@tscircuit/capacity-autorouter 0.0.138 → 0.0.139

package/dist/index.d.ts

@@ -191,7 +191,7 @@ declare class TargetTree {
     getTargetsInArea(centerX: number, centerY: number, width: number, height: number): Target$1[];
 }
 
-interface CapacityMeshNodeSolverOptions$1 {
+interface CapacityMeshNodeSolverOptions$2 {
     capacityDepth?: number;
 }
 interface Target {
@@ -208,7 +208,7 @@ interface Target {
 }
 declare class CapacityMeshNodeSolver extends BaseSolver {
     srj: SimpleRouteJson;
-    opts: CapacityMeshNodeSolverOptions$1;
+    opts: CapacityMeshNodeSolverOptions$2;
     unfinishedNodes: CapacityMeshNode[];
     finishedNodes: CapacityMeshNode[];
     nodeToXYOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle[]>;
@@ -218,7 +218,7 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
     targets: Target[];
     targetTree: TargetTree;
     obstacleTree: ObstacleSpatialHashIndex;
-    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions$1);
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions$2);
     computeTargets(): Target[];
     protected getNodeBounds(node: CapacityMeshNode): {
         minX: number;
@@ -265,12 +265,12 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface CapacityMeshNodeSolverOptions {
+interface CapacityMeshNodeSolverOptions$1 {
     capacityDepth?: number;
 }
 declare class CapacityMeshNodeSolver2_NodeUnderObstacle extends CapacityMeshNodeSolver {
     srj: SimpleRouteJson;
-    opts: CapacityMeshNodeSolverOptions;
+    opts: CapacityMeshNodeSolverOptions$1;
     VIA_DIAMETER: number;
     OBSTACLE_MARGIN: number;
     /**
@@ -278,7 +278,7 @@ declare class CapacityMeshNodeSolver2_NodeUnderObstacle extends CapacityMeshNode
      * covered by obstacles to be considered "under an obstacle"
      */
     OVERLAP_THRESHOLD_FOR_SINGLE_LAYER_NODES: number;
-    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions);
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions$1);
     isNodeCompletelyOutsideBounds(node: CapacityMeshNode): boolean;
     isNodePartiallyOutsideBounds(node: CapacityMeshNode): boolean;
     /**
@@ -1427,21 +1427,21 @@ interface CapacityHyperParameters {
     MAX_CAPACITY_FACTOR: number;
 }
 
-type Candidate$1 = {
-    prevCandidate: Candidate$1 | null;
+type Candidate$2 = {
+    prevCandidate: Candidate$2 | null;
     node: CapacityMeshNode;
     f: number;
     g: number;
     h: number;
 };
-type ConnectionPathWithNodes = {
+type ConnectionPathWithNodes$1 = {
     connection: SimpleRouteConnection;
     nodes: CapacityMeshNode[];
     path?: CapacityMeshNode[];
     straightLineDistance: number;
 };
 declare class CapacityPathingSolver extends BaseSolver {
-    connectionsWithNodes: Array<ConnectionPathWithNodes>;
+    connectionsWithNodes: Array<ConnectionPathWithNodes$1>;
     usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
     simpleRouteJson: SimpleRouteJson;
     nodes: CapacityMeshNode[];
@@ -1479,11 +1479,11 @@ declare class CapacityPathingSolver extends BaseSolver {
         connectionNameToGoalNodeIds: Map<string, string[]>;
     };
     currentConnectionIndex: number;
-    candidates?: Array<Candidate$1> | null;
+    candidates?: Array<Candidate$2> | null;
     visitedNodes?: Set<CapacityMeshNodeId> | null;
-    computeG(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    computeH(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    getBacktrackedPath(candidate: Candidate$1): CapacityMeshNode[];
+    computeG(prevCandidate: Candidate$2, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate$2, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    getBacktrackedPath(candidate: Candidate$2): CapacityMeshNode[];
     getNeighboringNodes(node: CapacityMeshNode): CapacityMeshNode[];
     getCapacityPaths(): CapacityPath[];
     doesNodeHaveCapacityForTrace(node: CapacityMeshNode, prevNode: CapacityMeshNode): boolean;
@@ -1513,8 +1513,8 @@ declare class CapacityPathingSolver5 extends CapacityPathingSolver {
      * To minimize shortest path, you'd want to comment this out.
      */
     getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
-    computeG(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    computeH(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeG(prevCandidate: Candidate$2, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate$2, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
 }
 
 declare class CapacityPathingGreedySolver extends CapacityPathingSolver5 {
@@ -1522,8 +1522,8 @@ declare class CapacityPathingGreedySolver extends CapacityPathingSolver5 {
     getNodeCapacityPenalty(node: CapacityMeshNode): number;
 }
 
-type Candidate = {
-    prevCandidate: Candidate | null;
+type Candidate$1 = {
+    prevCandidate: Candidate$1 | null;
     node: CapacityMeshNode;
     f: number;
     g: number;
@@ -1566,7 +1566,7 @@ declare class CapacityPathingSingleSectionSolver extends BaseSolver {
     private currentSectionScore;
     MAX_CANDIDATES_IN_MEMORY: number;
     currentConnectionIndex: number;
-    candidates?: Array<Candidate> | null;
+    candidates?: Array<Candidate$1> | null;
     visitedNodes?: Set<CapacityMeshNodeId> | null;
     queuedNodes?: Set<CapacityMeshNodeId> | null;
     activeCandidateStraightLineDistance?: number;
@@ -1580,10 +1580,10 @@ declare class CapacityPathingSingleSectionSolver extends BaseSolver {
     getTotalCapacity(node: CapacityMeshNode): number;
     getNodeCapacityPenalty(node: CapacityMeshNode): number;
     getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
-    computeG(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    computeH(prevCandidate: Candidate, // prevCandidate not strictly needed here
+    computeG(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate$1, // prevCandidate not strictly needed here
     node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    getBacktrackedPath(candidate: Candidate): CapacityMeshNode[];
+    getBacktrackedPath(candidate: Candidate$1): CapacityMeshNode[];
     getNeighboringNodes(node: CapacityMeshNode): CapacityMeshNode[];
     isConnectedToEndGoal(node: CapacityMeshNode, endGoal: CapacityMeshNode): boolean;
     doesNodeHaveCapacityForTrace(node: CapacityMeshNode, prevNode: CapacityMeshNode | null): boolean;
@@ -1644,7 +1644,7 @@ declare class CapacityPathingMultiSectionSolver extends BaseSolver {
     nodes: CapacityMeshNode[];
     edges: CapacityMeshEdge[];
     nodeEdgeMap: Map<CapacityMeshEdgeId, CapacityMeshEdge[]>;
-    connectionsWithNodes: Array<ConnectionPathWithNodes>;
+    connectionsWithNodes: Array<ConnectionPathWithNodes$1>;
     colorMap: Record<string, string>;
     initialSolver: CapacityPathingGreedySolver;
     cacheProvider?: CacheProvider | null;
@@ -1970,12 +1970,12 @@ declare class UselessViaRemovalSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface CapacityMeshSolverOptions {
+interface CapacityMeshSolverOptions$1 {
     capacityDepth?: number;
     targetMinCapacity?: number;
     cacheProvider?: CacheProvider | null;
 }
-type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
+type PipelineStep$1<T extends new (...args: any[]) => BaseSolver> = {
     solverName: string;
     solverClass: T;
     getConstructorParams: (instance: AutoroutingPipelineSolver) => ConstructorParameters<T>;
@@ -1983,7 +1983,7 @@ type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
 };
 declare class AutoroutingPipelineSolver extends BaseSolver {
     srj: SimpleRouteJson;
-    opts: CapacityMeshSolverOptions;
+    opts: CapacityMeshSolverOptions$1;
     netToPointPairsSolver?: NetToPointPairsSolver;
     nodeSolver?: CapacityMeshNodeSolver;
     nodeTargetMerger?: CapacityNodeTargetMerger;
@@ -2013,8 +2013,8 @@ declare class AutoroutingPipelineSolver extends BaseSolver {
     capacityNodes: CapacityMeshNode[] | null;
     capacityEdges: CapacityMeshEdge[] | null;
     cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver2_NodeUnderObstacle> | PipelineStep<typeof SingleLayerNodeMergerSolver> | PipelineStep<typeof StrawSolver> | PipelineStep<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep<typeof DeadEndSolver> | PipelineStep<typeof CapacityPathingGreedySolver> | PipelineStep<typeof CapacityPathingMultiSectionSolver> | PipelineStep<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep<typeof CapacitySegmentToPointSolver> | PipelineStep<typeof UnravelMultiSectionSolver> | PipelineStep<typeof HighDensitySolver> | PipelineStep<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep<typeof UselessViaRemovalSolver> | PipelineStep<typeof MultiSimplifiedPathSolver>)[];
-    constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions);
+    pipelineDef: (PipelineStep$1<typeof NetToPointPairsSolver> | PipelineStep$1<typeof CapacityMeshNodeSolver2_NodeUnderObstacle> | PipelineStep$1<typeof SingleLayerNodeMergerSolver> | PipelineStep$1<typeof StrawSolver> | PipelineStep$1<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$1<typeof DeadEndSolver> | PipelineStep$1<typeof CapacityPathingGreedySolver> | PipelineStep$1<typeof CapacityPathingMultiSectionSolver> | PipelineStep$1<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep$1<typeof CapacitySegmentToPointSolver> | PipelineStep$1<typeof UnravelMultiSectionSolver> | PipelineStep$1<typeof HighDensitySolver> | PipelineStep$1<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$1<typeof UselessViaRemovalSolver> | PipelineStep$1<typeof MultiSimplifiedPathSolver>)[];
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$1);
     currentPipelineStepIndex: number;
     _step(): void;
     solveUntilPhase(phase: string): void;
@@ -2171,6 +2171,270 @@ declare function getGlobalLocalStorageCache(): LocalStorageCache;
 declare function getGlobalInMemoryCache(): InMemoryCache;
 declare function setupGlobalCaches(): void;
 
+interface CapacityMeshNodeSolverOptions {
+    capacityDepth?: 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 obstacles, multi-layer nodes are *always* Z-split into single-layer nodes.
+ * - Inside an "assignable" obstacle (obstacle.netIsAssignable === true), we keep
+ *   exactly *one* multi-layer node (capacity ~ 1 via region), i.e. we do not Z-split it.
+ *   Further nodes completely inside the same assignable obstacle will be Z-split (one per layer).
+ * - Single-layer nodes that are larger than MAX_SIZE_FOR_SINGLE_LAYER_NODES are XY-subdivided.
+ * - IMPORTANT: the single multi-layer node inside an assignable obstacle is **traversable**,
+ *   so we mark `_containsObstacle = false` and `_completelyInsideObstacle = false` on it.
+ */
+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;
+    private isNodeCompletelyInsideSpecificObstacle;
+    private getAssignableContainer;
+    shouldNodeBeXYSubdivided(node: CapacityMeshNode): boolean;
+    /**
+     * Multi-layer nodes are filtered unless they are completely inside an
+     * assignable obstacle (the single allowed via region per obstacle).
+     * Single-layer nodes use the standard relaxed single-layer filtering.
+     */
+    shouldFilterNodeForObstacle(node: CapacityMeshNode): boolean;
+    _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;
+}
+
+/**
+ * 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;
+}
+
+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;
+    /**
+     * Bias toward greedier choices (f = g + GREEDY_MULTIPLIER * h)
+     */
+    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";
+    /**
+     * 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.
+     */
+    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;
+}
+
+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: AssignableViaAutoroutingPipelineSolver) => ConstructorParameters<T>;
+    onSolved?: (instance: AssignableViaAutoroutingPipelineSolver) => void;
+};
+declare class AssignableViaAutoroutingPipelineSolver extends BaseSolver {
+    srj: SimpleRouteJson;
+    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;
+    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 DeadEndSolver> | PipelineStep<typeof HyperAssignableViaCapacityPathingSolver> | PipelineStep<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep<typeof CapacitySegmentToPointSolver> | PipelineStep<typeof UnravelMultiSectionSolver> | PipelineStep<typeof HighDensitySolver> | PipelineStep<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep<typeof UselessViaRemovalSolver> | PipelineStep<typeof MultiSimplifiedPathSolver>)[];
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions);
+    currentPipelineStepIndex: number;
+    _step(): void;
+    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;
+    /**
+     * Get original connection name from connection name with MST suffix
+     * @param mstConnectionName The MST-suffixed connection name (e.g. "connection1_mst0")
+     * @returns The original connection name (e.g. "connection1")
+     */
+    private getOriginalConnectionName;
+    _getOutputHdRoutes(): HighDensityRoute$1[];
+    /**
+     * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
+     */
+    getOutputSimplifiedPcbTraces(): SimplifiedPcbTraces;
+    getOutputSimpleRouteJson(): SimpleRouteJson;
+}
+
 declare const convertSrjToGraphicsObject: (srj: SimpleRouteJson) => {
     rects: Rect[];
     circles: Circle[];
@@ -2178,4 +2442,4 @@ declare const convertSrjToGraphicsObject: (srj: SimpleRouteJson) => {
     points: Point$3[];
 };
 
-export { AutoroutingPipelineSolver, type CachableSolver, type CacheProvider, CapacityMeshSolver, InMemoryCache, LocalStorageCache, calculateOptimalCapacityDepth, convertSrjToGraphicsObject, getGlobalInMemoryCache, getGlobalLocalStorageCache, getTunedTotalCapacity1, setupGlobalCaches };
+export { AssignableViaAutoroutingPipelineSolver, AutoroutingPipelineSolver, type AutoroutingPipelineSolverOptions, type CachableSolver, type CacheProvider, CapacityMeshSolver, InMemoryCache, LocalStorageCache, calculateOptimalCapacityDepth, convertSrjToGraphicsObject, getGlobalInMemoryCache, getGlobalLocalStorageCache, getTunedTotalCapacity1, setupGlobalCaches };