@tscircuit/capacity-autorouter 0.0.183 → 0.0.185

package/dist/index.d.ts

@@ -177,46 +177,6 @@ declare class CapacityMeshEdgeSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface NodePortSegment {
-    capacityMeshNodeId: string;
-    nodePortSegmentId?: string;
-    start: {
-        x: number;
-        y: number;
-    };
-    end: {
-        x: number;
-        y: number;
-    };
-    availableZ: number[];
-    connectionNames: string[];
-    rootConnectionNames?: string[];
-}
-
-/**
- * Each Node is a square. The capacity paths indicate the nodes the trace will
- * travel through. We want to find the "Port Segment" that each capacity path
- * will take for each node.
- */
-declare class CapacityEdgeToPortSegmentSolver extends BaseSolver {
-    nodes: CapacityMeshNode[];
-    edges: CapacityMeshEdge[];
-    capacityPaths: CapacityPath[];
-    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
-    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
-    unprocessedNodeIds: CapacityMeshNodeId[];
-    nodePortSegments: Map<CapacityMeshNodeId, NodePortSegment[]>;
-    colorMap: Record<string, string>;
-    constructor({ nodes, edges, capacityPaths, colorMap, }: {
-        nodes: CapacityMeshNode[];
-        edges: CapacityMeshEdge[];
-        capacityPaths: CapacityPath[];
-        colorMap?: Record<string, string>;
-    });
-    step(): void;
-    visualize(): GraphicsObject;
-}
-
 type PortPoint = {
     connectionName: string;
     rootConnectionName?: string;
@@ -266,69 +226,6 @@ type HighDensityIntraNodeRoute$1 = {
 };
 type HighDensityRoute$1 = HighDensityIntraNodeRoute$1;
 
-interface SegmentWithAssignedPoints extends NodePortSegment {
-    assignedPoints?: {
-        connectionName: string;
-        rootConnectionName?: string;
-        point: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    }[];
-}
-/**
- * CapacitySegmentToPointSolver:
- *
- * In each step, the solver iterates over all unsolved segments (segments
- * without points assigned for each connection). For each segment:
- *
- * - If there is only one connection, it assigns the center as the point.
- * - If there are two connections, it attempts to determine the ordering using
- *   other segments within the node. If no ordering can be determined, it does nothing.
- *
- * If an iteration produces no new assignments, the solver picks the segment with
- * the fewest connections and assigns points evenly spaced along the segment,
- * ordering them alphabetically.
- */
-declare class CapacitySegmentToPointSolver extends BaseSolver {
-    unsolvedSegments: SegmentWithAssignedPoints[];
-    solvedSegments: (NodePortSegment & {
-        assignedPoints: {
-            connectionName: string;
-            rootConnectionName?: string;
-            point: {
-                x: number;
-                y: number;
-                z: number;
-            };
-        }[];
-    })[];
-    nodeMap: Record<string, CapacityMeshNode>;
-    colorMap: Record<string, string>;
-    constructor({ segments, colorMap, nodes, }: {
-        segments: NodePortSegment[];
-        colorMap?: Record<string, string>;
-        /**
-         * This isn't used by the algorithm, but allows associating metadata
-         * for the result datatype (the center, width, height of the node)
-         */
-        nodes: CapacityMeshNode[];
-    });
-    /**
-     * Perform one iteration step.
-     */
-    _step(): void;
-    /**
-     * Return the assigned points for each segment.
-     */
-    getNodesWithPortPoints(): NodeWithPortPoints[];
-    /**
-     * Return a GraphicsObject that visualizes the segments with assigned points.
-     */
-    visualize(): GraphicsObject;
-}
-
 interface HighDensityHyperParameters {
     FUTURE_CONNECTION_PROX_TRACE_PENALTY_FACTOR: number;
     FUTURE_CONNECTION_PROX_VIA_PENALTY_FACTOR: number;
@@ -815,145 +712,6 @@ declare class CapacityNodeTargetMerger extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-type NodePortSegmentId = string;
-interface ChangeLayerOperation {
-    op: "changeLayer";
-    segmentId: string;
-    pointIndex: number;
-    newLayer: number;
-    /** Operation is mutated and oldLayer is added to allow reversal */
-    oldLayer?: number;
-    cost?: number;
-}
-interface SwitchOperation {
-    op: "switch";
-    segmentId: string;
-    point1Index: number;
-    point2Index: number;
-    cost?: number;
-}
-interface CombinedOperation {
-    op: "combined";
-    subOperations: Array<SwitchOperation | ChangeLayerOperation>;
-    cost?: number;
-}
-type Operation = ChangeLayerOperation | SwitchOperation | CombinedOperation;
-/**
- * Use simulated annealing to try to improve the placement of points (via
- * swapping with points on the same segment) or changing the layer.
- *
- * We have the following pieces of information:
- * - NodePortSegment with nodePortSegmentId
- * - A "neighbor" NodePortSegmentWithAssignedPoints has one change
- *    - A change can be flipping a point to the opposite layer
- *    - A change can also be switching the position of two points
- * - We represent the operations used to change from an original scene
- *   with a list of operations [SEG1_CL(1, 1), SEG1_SW(1, 2), SEG2_CL(2, 0)]
- *    - CN indicates the capacity node to edit
- *    - The SW operation "switches" the x/y location of two points
- *    - The CL operation changes the layer of the point
- * - When choosing edits to make, we are biased to operate on nodes that have a
- *   high cost and biased against operating on nodes we've operated on a lot
- * - Each step, we generate an operation and use the standard simulated
- *   annealing function to determine if we should perform the operation
- */
-declare class CapacitySegmentPointOptimizer extends BaseSolver {
-    assignedSegments: SegmentWithAssignedPoints[];
-    colorMap: Record<string, string>;
-    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
-    nodeIdToSegmentIds: Map<string, string[]>;
-    segmentIdToNodeIds: Map<string, string[]>;
-    currentMutatedSegments: Map<NodePortSegmentId, SegmentWithAssignedPoints>;
-    allSegmentIds: string[];
-    lastAppliedOperation: Operation | null;
-    lastCreatedOperation: Operation | null;
-    currentNodeCosts: Map<CapacityMeshNodeId, number>;
-    lastAcceptedIteration: number;
-    currentCost: number;
-    randomSeed: number;
-    numNodes: number;
-    probabilityOfFailure: number;
-    nodesThatCantFitVias: Set<CapacityMeshNodeId>;
-    mutableSegments: Set<NodePortSegmentId>;
-    VIA_DIAMETER: number;
-    OBSTACLE_MARGIN: number;
-    MAX_OPERATIONS_PER_MUTATION: number;
-    MAX_NODE_CHAIN_PER_MUTATION: number;
-    NOOP_ITERATIONS_BEFORE_EARLY_STOP: number;
-    constructor({ assignedSegments, colorMap, nodes, viaDiameter, }: {
-        assignedSegments: NodePortSegment[];
-        colorMap?: Record<string, string>;
-        /**
-         * This isn't used by the algorithm, but allows associating metadata
-         * for the result datatype (the center, width, height of the node)
-         */
-        nodes: CapacityMeshNode[];
-        viaDiameter?: number;
-    });
-    random(): number;
-    /**
-     * The cost is the "probability of failure" of the node.
-     */
-    computeNodeCost(nodeId: CapacityMeshNodeId): number;
-    /**
-     * Number of traces that can go through this node if they are completely
-     * straight without crossings
-     */
-    getUsedTraceCapacity(nodeId: CapacityMeshNodeId): number;
-    /**
-     * Granular via capacity is a consideration of capacity that includes...
-     * - The number of traces
-     * - The number of trace crossings (0-2 vias per trace crossing)
-     *   - Empirically, each crossing typically results in 0.82 vias
-     *   - e.g. 17 traces would typically have 51 crossings & 42 vias
-     * - The number of layer changes (at least 1 via per layer change)
-     *   - We don't know how a entry/exit being on separated layers effects
-     *     the capacity/number of vias yet
-     *
-     * - Generally minimizing the number of crossings is pretty good, if there
-     *   is no trace crossing you basically don't have any used capacity
-     * - If the entry/exit layer is different, you're guaranteed to have at least
-     *   one via
-     *
-     * - Total capacity is computed by estimating the number of vias that could
-     *   be created using the formula (viaFitAcross / 2) ** 1.1
-     */
-    getUsedViaCapacity(nodeId: CapacityMeshNodeId): number;
-    getRandomWeightedNodeId(): CapacityMeshNodeId;
-    getRandomWeightedSegmentId(): string;
-    getMutableSegments(): Set<string>;
-    isSegmentMutable(segmentId: string): boolean;
-    getRandomOperationForSegment(randomSegmentId: string): SwitchOperation | ChangeLayerOperation | null;
-    getNodesNearNode(nodeId: CapacityMeshNodeId, hops?: number): CapacityMeshNodeId[];
-    getRandomCombinedOperationNearNode(nodeId: CapacityMeshNodeId): CombinedOperation;
-    /**
-     * A combined operation can perform multiple operations on a single node, this
-     * allows it to reach outcomes that may not be beneficial with since
-     * operations
-     */
-    getRandomCombinedOperationOnSingleNode(max?: number): CombinedOperation;
-    getRandomOperation(): Operation;
-    /**
-     * We compute "overall probability of failure" as our overall cost, then
-     * linearize it to make it easier to work with
-     */
-    computeCurrentCost(): {
-        cost: number;
-        nodeCosts: Map<CapacityMeshNodeId, number>;
-        probabilityOfFailure: number;
-        linearizedCost: number;
-    };
-    applyOperation(op: Operation): void;
-    reverseOperation(op: Operation): void;
-    isNewCostAcceptable(oldPf: number, newPf: number): boolean;
-    /**
-     * FOR OUTPUT: Return the assigned points for each segment.
-     */
-    getNodesWithPortPoints(): NodeWithPortPoints[];
-    _step(): void;
-    visualize(): GraphicsObject;
-}
-
 /**
  * Converts a net containing many points to connect into an array of point pair
  * connections.
@@ -1055,20 +813,1043 @@ declare class MultipleHighDensityRouteStitchSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-type SegmentPointId = string;
-type SegmentId = string;
-interface BaseUnravelIssue {
-    probabilityOfFailure: number;
-}
-interface UnravelTransitionViaIssue extends BaseUnravelIssue {
-    type: "transition_via";
-    capacityMeshNodeId: CapacityMeshNodeId;
-    segmentPoints: SegmentPointId[];
-}
-interface UnravelSameLayerCrossingIssue extends BaseUnravelIssue {
-    type: "same_layer_crossing";
-    capacityMeshNodeId: CapacityMeshNodeId;
-    crossingLine1: [SegmentPointId, SegmentPointId];
+declare class StrawSolver extends BaseSolver {
+    multiLayerNodes: CapacityMeshNode[];
+    strawNodes: CapacityMeshNode[];
+    skippedNodes: CapacityMeshNode[];
+    unprocessedNodes: CapacityMeshNode[];
+    strawSize: number;
+    nodeIdCounter: number;
+    constructor(params: {
+        nodes: CapacityMeshNode[];
+        strawSize?: number;
+    });
+    getCapacityOfMultiLayerNodesWithinBounds(bounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    }): number;
+    getSurroundingCapacities(node: CapacityMeshNode): {
+        leftSurroundingCapacity: number;
+        rightSurroundingCapacity: number;
+        topSurroundingCapacity: number;
+        bottomSurroundingCapacity: number;
+    };
+    /**
+     * Creates straw nodes from a single-layer node based on surrounding capacities
+     */
+    createStrawsForNode(node: CapacityMeshNode): CapacityMeshNode[];
+    getResultNodes(): CapacityMeshNode[];
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+/**
+ * Merges same layer nodes into larger nodes. Pre-processing stage necessary
+ * for "strawing".
+ */
+declare class SingleLayerNodeMergerSolver extends BaseSolver {
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    currentBatchNodeIds: CapacityMeshNodeId[];
+    absorbedNodeIds: Set<CapacityMeshNodeId>;
+    nextBatchNodeIds: CapacityMeshNodeId[];
+    batchHadModifications: boolean;
+    hasComputedAdjacentNodeIds: boolean;
+    newNodes: CapacityMeshNode[];
+    constructor(nodes: CapacityMeshNode[]);
+    computeAdjacentNodeIdsForFirstBatch(nodes: CapacityMeshNode[]): void;
+    getAdjacentSameLayerUnprocessedNodes(rootNode: CapacityMeshNode): CapacityMeshNode[];
+    getAdjacentSameLayerUnprocessedNodes2(rootNode: CapacityMeshNode): CapacityMeshNode[];
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+declare class CapacityMeshEdgeSolver2_NodeTreeOptimization extends CapacityMeshEdgeSolver {
+    nodes: CapacityMeshNode[];
+    private nodeTree;
+    private currentNodeIndex;
+    private edgeSet;
+    constructor(nodes: CapacityMeshNode[]);
+    _step(): void;
+}
+
+declare class DeadEndSolver extends BaseSolver {
+    removedNodeIds: Set<string>;
+    private targetNodeIds;
+    private leaves;
+    private leavesIndex;
+    private adjacencyList;
+    /** Only used for visualization, dynamically instantiated if necessary */
+    nodeMap?: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    private nodes;
+    private edges;
+    constructor({ nodes, edges, }: {
+        nodes: CapacityMeshNode[];
+        edges: CapacityMeshEdge[];
+    });
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+/**
+ * A Disjoint Set Union (DSU) or Union-Find data structure.
+ * It tracks a collection of disjoint sets and can efficiently merge them.
+ */
+declare class DSU {
+    private parent;
+    /**
+     * Creates a new DSU instance.
+     * Each ID is initially in its own set.
+     */
+    constructor(ids: string[]);
+    /**
+     * Finds the representative of the set containing the given ID.
+     * Uses path compression.
+     */
+    find(id: string): string;
+    /**
+     * Merges the sets containing the two given IDs.
+     */
+    union(id1: string, id2: string): void;
+    /**
+     * Gets all IDs in the same set as the given ID.
+     */
+    getGroup(id: string): string[];
+}
+
+/**
+ * Extends the base NetToPointPairsSolver with an optimization that utilizes
+ * off-board connections to find shorter routing paths.
+ *
+ * This solver preprocesses all connections to identify points that are
+ * electrically connected off-board (via the `isOffBoard` flag). It builds
+ * "equivalence groups" of these points using a Disjoint Set Union (DSU)
+ * data structure.
+ *
+ * When the solver processes an on-board connection or a segment from a
+ * Minimum Spanning Tree (MST), it checks if either of the connection's
+ * endpoints has an off-board equivalent. If so, it calculates the distance
+ * to all possible substitutes and chooses the pair that results in the
+ * shortest path, potentially rerouting the connection to a more optimal
+ * equivalent point.
+ */
+declare class NetToPointPairsSolver2_OffBoardConnection extends NetToPointPairsSolver {
+    ogSrj: SimpleRouteJson;
+    colorMap: Record<string, string>;
+    connectionPointDsu: DSU;
+    connectionPointMap: Map<string, ConnectionPoint>;
+    constructor(ogSrj: SimpleRouteJson, colorMap?: Record<string, string>);
+    _findBestConnectionPointsFromDisjointSets(sourcePoint: ConnectionPoint, targetPoint: ConnectionPoint): {
+        pointsToConnect: [ConnectionPoint, ConnectionPoint];
+    };
+    _step(): void;
+}
+
+type Phase = "via_removal" | "via_merging" | "path_simplification";
+/**
+ * TraceSimplificationSolver consolidates trace optimization by iteratively applying
+ * via removal, via merging, and path simplification phases. It reduces redundant vias
+ * and simplifies routing paths through configurable iterations.
+ *
+ * The solver operates in three alternating phases per iteration:
+ * 1. "via_removal" - Removes unnecessary vias from routes using UselessViaRemovalSolver
+ * 2. "via_merging" - Merges redundant vias on the same net using SameNetViaMergerSolver
+ * 3. "path_simplification" - Simplifies routing paths using MultiSimplifiedPathSolver
+ *
+ * Each iteration consists of all phases executed sequentially.
+ */
+declare class TraceSimplificationSolver extends BaseSolver {
+    private simplificationConfig;
+    hdRoutes: HighDensityRoute$1[];
+    simplificationPipelineLoops: number;
+    MAX_SIMPLIFICATION_PIPELINE_LOOPS: number;
+    PHASE_ORDER: Phase[];
+    currentPhase: Phase;
+    /** Callback to extract results from the active sub-solver */
+    extractResult: ((solver: BaseSolver) => HighDensityRoute$1[]) | null;
+    /** Returns the simplified routes. This is the primary output of the solver. */
+    get simplifiedHdRoutes(): HighDensityRoute$1[];
+    /**
+     * Creates a new TraceSimplificationSolver
+     * @param simplificationConfig Configuration object containing:
+     *   - hdRoutes: Initial high-density routes to simplify
+     *   - obstacles: Board obstacles to avoid during simplification
+     *   - connMap: Connectivity map for routing validation
+     *   - colorMap: Mapping of net names to colors for visualization
+     *   - outline: Optional board outline boundary
+     *   - defaultViaDiameter: Default diameter for vias
+     *   - layerCount: Number of routing layers
+     *   - iterations: Number of complete simplification iterations (default: 2)
+     */
+    constructor(simplificationConfig: {
+        hdRoutes: HighDensityRoute$1[];
+        obstacles: Obstacle[];
+        connMap: ConnectivityMap;
+        colorMap: Record<string, string>;
+        outline?: Array<{
+            x: number;
+            y: number;
+        }>;
+        defaultViaDiameter: number;
+        layerCount: number;
+    });
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+interface SegmentPortPoint {
+    segmentPortPointId: string;
+    x: number;
+    y: number;
+    availableZ: number[];
+    nodeIds: [CapacityMeshNodeId, CapacityMeshNodeId];
+    edgeId: string;
+    /** The connection name currently using this port point, or null if unused */
+    connectionName: string | null;
+    rootConnectionName?: string;
+    /** XY distance to the centermost port on this Z level (centermost port has distance 0) */
+    distToCentermostPortOnZ: number;
+}
+interface SharedEdgeSegment {
+    edgeId: string;
+    nodeIds: [CapacityMeshNodeId, CapacityMeshNodeId];
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    availableZ: number[];
+    portPoints: SegmentPortPoint[];
+}
+/**
+ * AvailableSegmentPointSolver computes port points on shared edges between
+ * capacity mesh nodes. These points can be used for routing traces through
+ * the capacity mesh.
+ *
+ * For each edge shared between two nodes:
+ * 1. Computes the shared edge segment
+ * 2. Determines how many port points can fit based on traceWidth
+ * 3. Creates port points evenly spaced along the segment
+ *
+ * Port points start as unused (connectionName = null) and are assigned
+ * as paths are routed through them.
+ */
+declare class AvailableSegmentPointSolver extends BaseSolver {
+    nodes: CapacityMeshNode[];
+    edges: CapacityMeshEdge[];
+    traceWidth: number;
+    obstacleMargin: number;
+    minPortSpacing: number;
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
+    /** All shared edge segments with their port points */
+    sharedEdgeSegments: SharedEdgeSegment[];
+    /** Map from edgeId to SharedEdgeSegment for quick lookup */
+    edgeSegmentMap: Map<string, SharedEdgeSegment>;
+    /** Map from segmentPortPointId to SegmentPortPoint */
+    portPointMap: Map<string, SegmentPortPoint>;
+    colorMap: Record<string, string>;
+    constructor({ nodes, edges, traceWidth, obstacleMargin, colorMap, }: {
+        nodes: CapacityMeshNode[];
+        edges: CapacityMeshEdge[];
+        traceWidth: number;
+        obstacleMargin?: number;
+        colorMap?: Record<string, string>;
+    });
+    _step(): void;
+    private computeAllSharedEdgeSegments;
+    private computeSharedEdgeSegment;
+    private findOverlappingSegment;
+    /**
+     * Find available port points for traveling between two nodes
+     */
+    getAvailablePortPointsBetweenNodes(nodeId1: CapacityMeshNodeId, nodeId2: CapacityMeshNodeId): SegmentPortPoint[];
+    /**
+     * Get all port points (both assigned and unassigned) for an edge between nodes
+     */
+    getPortPointsForEdge(nodeId1: CapacityMeshNodeId, nodeId2: CapacityMeshNodeId): SegmentPortPoint[];
+    /**
+     * Assign a port point to a connection
+     */
+    assignPortPoint(segmentPortPointId: string, connectionName: string, rootConnectionName?: string): boolean;
+    /**
+     * Release a port point (make it available again)
+     */
+    releasePortPoint(segmentPortPointId: string): boolean;
+    /**
+     * Get the count of available port points on an edge
+     */
+    getAvailablePortCountForEdge(nodeId1: CapacityMeshNodeId, nodeId2: CapacityMeshNodeId): number;
+    visualize(): GraphicsObject;
+}
+
+interface PortPointPathingHyperParameters {
+    SHUFFLE_SEED?: number;
+    CENTER_OFFSET_DIST_PENALTY_FACTOR?: number;
+    CENTER_OFFSET_FOCUS_SHIFT?: number;
+    GREEDY_MULTIPLIER?: number;
+    NODE_PF_FACTOR?: number;
+    RANDOM_COST_MAGNITUDE?: number;
+    MEMORY_PF_FACTOR?: number;
+    BASE_CANDIDATE_COST?: number;
+    REWARD_LOW_TRAVEL_PF_MAGNITUDE?: number;
+    MAX_ITERATIONS_PER_PATH?: number;
+}
+/**
+ * An input port point without connectionName assigned yet.
+ * These are pre-computed points on node edges where traces can cross.
+ */
+interface InputPortPoint {
+    portPointId: string;
+    x: number;
+    y: number;
+    z: number;
+    /** The node IDs that this port point connects (on the shared edge) */
+    connectionNodeIds: [CapacityMeshNodeId, CapacityMeshNodeId];
+    /** XY distance to the centermost port on this Z level (centermost port has distance 0) */
+    distToCentermostPortOnZ: number;
+}
+/**
+ * A node with pre-computed port points (without connectionName assigned).
+ * This is the input format for PortPointPathingSolver.
+ */
+interface InputNodeWithPortPoints {
+    capacityMeshNodeId: CapacityMeshNodeId;
+    center: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    /** Port points on this node's edges (without connectionName) */
+    portPoints: InputPortPoint[];
+    availableZ: number[];
+    /** If true, this node is a target node (contains a connection endpoint) */
+    _containsTarget?: boolean;
+    /** If true, this node contains an obstacle */
+    _containsObstacle?: boolean;
+}
+/**
+ * A candidate in the A* search. Represents being at a port point,
+ * having entered from a specific node.
+ */
+interface PortPointCandidate {
+    prevCandidate: PortPointCandidate | null;
+    /** The port point we're at (null for start/end target points) */
+    portPoint: InputPortPoint | null;
+    /** The node we're currently in (entered via portPoint) */
+    currentNodeId: CapacityMeshNodeId;
+    /** The physical point location (entry point within currentNodeId) */
+    point: {
+        x: number;
+        y: number;
+    };
+    /** The z layer this candidate is on */
+    z: number;
+    f: number;
+    g: number;
+    h: number;
+}
+interface ConnectionPathResult {
+    connection: SimpleRouteConnection;
+    /** Start and end node IDs */
+    nodeIds: [CapacityMeshNodeId, CapacityMeshNodeId];
+    /** The path of candidates found by the pathing algorithm */
+    path?: PortPointCandidate[];
+    /** Port points used by this connection (with connectionName assigned) */
+    portPoints?: PortPoint[];
+    straightLineDistance: number;
+}
+/**
+ * PortPointPathingSolver finds paths through the capacity mesh by visiting
+ * pre-computed port points on shared edges. It considers layer information
+ * when routing and uses a Pf-based cost function.
+ *
+ * Improvements in this implementation:
+ *  - g is now an *exact* accumulated path cost (incremental delta Pf per node, computed only when a node is "closed")
+ *  - node Pf contribution is charged when you *leave* a node (entry+exit known), not when entering the next node
+ *  - uses a log-success style cost: cost(pf) = -log(1 - pf), and delta = cost(after) - cost(before)
+ *  - caches base node costs and segment delta costs to avoid repeated crossing computations
+ *  - computeH uses memoryPf + distance to approximate remaining cost (and can be tuned)
+ *  - closes the end node when connecting to the final end target point
+ *  - prevents node cycles in a candidate chain (keeps Pf math correct without needing per-node multi-visit tracking)
+ */
+declare class PortPointPathingSolver extends BaseSolver {
+    hyperParameters: Partial<PortPointPathingHyperParameters>;
+    simpleRouteJson: SimpleRouteJson;
+    inputNodes: InputNodeWithPortPoints[];
+    nodeMap: Map<CapacityMeshNodeId, InputNodeWithPortPoints>;
+    /** Map from nodeId to list of port points accessible from that node */
+    nodePortPointsMap: Map<CapacityMeshNodeId, InputPortPoint[]>;
+    /** Map from portPointId to InputPortPoint */
+    portPointMap: Map<string, InputPortPoint>;
+    connectionsWithResults: ConnectionPathResult[];
+    /** Tracks port points that have been assigned to connections */
+    assignedPortPoints: Map<string, {
+        connectionName: string;
+        rootConnectionName?: string;
+    }>;
+    /** Tracks port points assigned to each node for crossing calculations */
+    nodeAssignedPortPoints: Map<CapacityMeshNodeId, PortPoint[]>;
+    /** Factor applied to port point reuse penalty */
+    PORT_POINT_REUSE_FACTOR: number;
+    /** Multiplied by Pf delta cost (in -log(1-pf) space) */
+    get NODE_PF_FACTOR(): number;
+    /** Used only in heuristic (h) to "look ahead" into known-congested regions */
+    get MEMORY_PF_FACTOR(): number;
+    get CENTER_OFFSET_FOCUS_SHIFT(): number;
+    /** Used as a *tie-breaker* in f (not part of g) */
+    get RANDOM_COST_MAGNITUDE(): number;
+    /** Optional heuristic reward for stepping into low-memoryPf nodes */
+    get REWARD_LOW_TRAVEL_PF_MAGNITUDE(): number;
+    /** Cost of adding a candidate to the path */
+    get BASE_CANDIDATE_COST(): number;
+    /** Cost penalty for changing layers (used in heuristic) */
+    Z_DIST_COST: number;
+    /** Penalty factor for port points that are far from the center of the segment */
+    get CENTER_OFFSET_DIST_PENALTY_FACTOR(): number;
+    colorMap: Record<string, string>;
+    get GREEDY_MULTIPLIER(): number;
+    MAX_CANDIDATES_IN_MEMORY: number;
+    get MAX_ITERATIONS_PER_PATH(): number;
+    nodeMemoryPfMap: Map<CapacityMeshNodeId, number>;
+    currentConnectionIndex: number;
+    currentPathIterations: number;
+    candidates?: PortPointCandidate[] | null;
+    /** Tracks visited port point IDs to avoid revisiting */
+    visitedPortPoints?: Set<string> | null;
+    connectionNameToGoalNodeIds: Map<string, CapacityMeshNodeId[]>;
+    capacityMeshNodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    /** Heuristic scaling: an estimate of "node pitch" used to estimate remaining hops */
+    avgNodePitch: number;
+    /** Cache of base node cost (cost of node in current committed state) */
+    private baseNodeCostCache;
+    /** Cache of delta cost for a specific node segment (entry->exit) for a specific connection */
+    private segmentDeltaCostCache;
+    constructor({ simpleRouteJson, inputNodes, capacityMeshNodes, colorMap, nodeMemoryPfMap, hyperParameters, }: {
+        simpleRouteJson: SimpleRouteJson;
+        capacityMeshNodes: CapacityMeshNode[];
+        inputNodes: InputNodeWithPortPoints[];
+        colorMap?: Record<string, string>;
+        nodeMemoryPfMap?: Map<CapacityMeshNodeId, number>;
+        hyperParameters?: Partial<PortPointPathingHyperParameters>;
+    });
+    private clearCostCaches;
+    private clampPf;
+    /** Convert Pf into an additive "failure cost" */
+    private pfToFailureCost;
+    private round3;
+    private pointKey;
+    /** Base node cost with the currently-committed port points (no candidate additions) */
+    private getBaseNodeFailureCost;
+    /**
+     * Exact delta cost of routing this connection through `nodeId`
+     * for the segment defined by entry->exit.
+     *
+     * This is computed as:
+     *   delta = (-log(1-pfAfter)) - (-log(1-pfBefore))
+     * and then scaled by NODE_PF_FACTOR.
+     */
+    private getNodeDeltaFailureCostForSegment;
+    getConnectionsWithNodes(): {
+        connectionsWithResults: ConnectionPathResult[];
+        connectionNameToGoalNodeIds: Map<string, string[]>;
+    };
+    /**
+     * Build a NodeWithPortPoints structure for crossing calculation.
+     */
+    buildNodeWithPortPointsForCrossing(node: InputNodeWithPortPoints, additionalPortPoints?: PortPoint[]): NodeWithPortPoints;
+    /**
+     * Compute probability of failure for a node using getIntraNodeCrossings.
+     */
+    computeNodePf(node: InputNodeWithPortPoints, additionalPortPoints?: PortPoint[]): number;
+    /**
+     * Get penalty for reusing a port point that's already assigned.
+     * No penalty if the port point is assigned to a connection with the same rootConnectionName.
+     */
+    getPortPointReusePenalty(portPointId: string, rootConnectionName?: string): number;
+    /**
+     * Get the node on the "other side" of a port point from the given node
+     */
+    getOtherNodeId(portPoint: InputPortPoint, currentNodeId: CapacityMeshNodeId): CapacityMeshNodeId | null;
+    /**
+     * Exact step cost from prevCandidate to exiting current node via `exitPortPoint`.
+     *
+     * IMPORTANT: This charges Pf delta for the node we are *leaving* (prevCandidate.currentNodeId),
+     * because only then we know both entry and exit points inside that node.
+     */
+    computeG(prevCandidate: PortPointCandidate, exitPortPoint: InputPortPoint, _targetNodeId: CapacityMeshNodeId, connectionName: string, rootConnectionName?: string): number;
+    /**
+     * Final "close" cost when you're already in the end node and you connect to the end target point.
+     * This ensures the last node's segment is accounted for in g.
+     */
+    private computeGToEndTarget;
+    /**
+     * Heuristic: approximate remaining cost.
+     *
+     * Uses:
+     *  - distance to goal
+     *  - estimated remaining hops (distance / avgNodePitch)
+     *  - memoryPfMap to bias away from historically high Pf regions
+     */
+    computeH(point: {
+        x: number;
+        y: number;
+    }, currentNodeId: CapacityMeshNodeId, endGoalNodeId: CapacityMeshNodeId, currentZ: number): number;
+    /**
+     * Get available port points to exit from a node, but *do not* return all.
+     *
+     * Rule:
+     * - For each (neighborNodeId, z) group, return the centermost (smallest dist).
+     * - If that centermost port point is already assigned, also return some next-closest
+     *   unassigned offsets as backups.
+     */
+    getAvailableExitPortPointsWithOmissions(nodeId: CapacityMeshNodeId, _endGoalNodeId: CapacityMeshNodeId): InputPortPoint[];
+    canTravelThroughObstacle(node: InputNodeWithPortPoints, connectionName: string): boolean;
+    /**
+     * Check if we've reached the end goal node
+     */
+    isAtEndGoal(currentNodeId: CapacityMeshNodeId, endGoalNodeId: CapacityMeshNodeId): boolean;
+    getBacktrackedPath(candidate: PortPointCandidate): PortPointCandidate[];
+    /**
+     * Assign port points along a path and record which connections use them.
+     */
+    assignPortPointsForPath(path: PortPointCandidate[], connectionName: string, rootConnectionName?: string): PortPoint[];
+    /**
+     * Add start/end target points to nodes for crossing calculations.
+     */
+    addTargetPointsToNodes(path: PortPointCandidate[], connection: SimpleRouteConnection): void;
+    /**
+     * Check if a port point is already in the candidate's path chain.
+     */
+    isPortPointInPathChain(candidate: PortPointCandidate | null, portPointId: string): boolean;
+    /**
+     * Prevent node cycles in a single candidate chain.
+     * This is important for correctness because we charge node cost as "one segment per node".
+     */
+    isNodeInPathChain(candidate: PortPointCandidate | null, nodeId: CapacityMeshNodeId): boolean;
+    _step(): void;
+    /**
+     * Get the nodes with port points for the HighDensitySolver
+     */
+    getNodesWithPortPoints(): NodeWithPortPoints[];
+    visualize(): GraphicsObject;
+}
+
+interface PortPointSectionParams {
+    centerOfSectionCapacityNodeId: CapacityMeshNodeId;
+    expansionDegrees: number;
+}
+/**
+ * A path segment that has been "cut" to fit within a section.
+ * Contains the portion of the path that passes through section nodes,
+ * plus entry/exit information for later reattachment.
+ */
+interface SectionPath {
+    /** The connection name this path belongs to */
+    connectionName: string;
+    /** Root connection name if applicable */
+    rootConnectionName?: string;
+    /** The cut path points (only the portion within the section) */
+    points: Array<{
+        x: number;
+        y: number;
+        z: number;
+        nodeId: CapacityMeshNodeId;
+    }>;
+    /** Index in original path where this segment starts */
+    originalStartIndex: number;
+    /** Index in original path where this segment ends */
+    originalEndIndex: number;
+    /** True if path enters from outside the section */
+    hasEntryFromOutside: boolean;
+    /** True if path exits to outside the section */
+    hasExitToOutside: boolean;
+}
+interface PortPointSection {
+    /** The center node ID for this section */
+    centerNodeId: CapacityMeshNodeId;
+    /** How many hops from center this section covers */
+    expansionDegrees: number;
+    /** All node IDs included in this section */
+    nodeIds: Set<CapacityMeshNodeId>;
+    /** Input nodes filtered to just those in this section */
+    inputNodes: InputNodeWithPortPoints[];
+    /** Capacity mesh nodes filtered to just those in this section */
+    capacityMeshNodes: CapacityMeshNode[];
+    /** Edges that connect nodes within this section */
+    internalEdges: CapacityMeshEdge[];
+    /** Edges that connect section nodes to external nodes (boundary edges) */
+    boundaryEdges: CapacityMeshEdge[];
+    /** Paths that pass through this section, cut to fit within section bounds */
+    sectionPaths: SectionPath[];
+}
+interface CreatePortPointSectionInput {
+    /** All input nodes with port points from PortPointPathingSolver */
+    inputNodes: InputNodeWithPortPoints[];
+    /** All capacity mesh nodes */
+    capacityMeshNodes: CapacityMeshNode[];
+    /** All capacity mesh edges */
+    capacityMeshEdges: CapacityMeshEdge[];
+    /** Map from node ID to input node for quick lookup */
+    nodeMap: Map<CapacityMeshNodeId, InputNodeWithPortPoints>;
+    /** Connection path results from PortPointPathingSolver */
+    connectionResults?: ConnectionPathResult[];
+}
+
+interface MultiSectionPortPointOptimizerParams {
+    simpleRouteJson: SimpleRouteJson;
+    inputNodes: InputNodeWithPortPoints[];
+    capacityMeshNodes: CapacityMeshNode[];
+    capacityMeshEdges: CapacityMeshEdge[];
+    colorMap?: Record<string, string>;
+    /** Results from the initial PortPointPathingSolver run */
+    initialConnectionResults: ConnectionPathResult[];
+    /** Assigned port points from initial run */
+    initialAssignedPortPoints: Map<string, {
+        connectionName: string;
+        rootConnectionName?: string;
+    }>;
+    /** Node assigned port points from initial run */
+    initialNodeAssignedPortPoints: Map<CapacityMeshNodeId, PortPoint[]>;
+}
+/**
+ * MultiSectionPortPointOptimizer runs local optimization on sections of the
+ * port point graph. It takes the output of PortPointPathingSolver and attempts
+ * to improve routing by re-running the solver on localized sections.
+ *
+ * This phase runs after portPointPathingSolver to refine routes in problematic areas.
+ */
+declare class MultiSectionPortPointOptimizer extends BaseSolver {
+    simpleRouteJson: SimpleRouteJson;
+    inputNodes: InputNodeWithPortPoints[];
+    capacityMeshNodes: CapacityMeshNode[];
+    capacityMeshEdges: CapacityMeshEdge[];
+    colorMap: Record<string, string>;
+    nodeMap: Map<CapacityMeshNodeId, InputNodeWithPortPoints>;
+    capacityMeshNodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    /** Current connection results (updated as sections are optimized) */
+    connectionResults: ConnectionPathResult[];
+    /** Current assigned port points */
+    assignedPortPoints: Map<string, {
+        connectionName: string;
+        rootConnectionName?: string;
+    }>;
+    /** Current node assigned port points */
+    nodeAssignedPortPoints: Map<CapacityMeshNodeId, PortPoint[]>;
+    /** Sections that have been created for optimization */
+    sections: PortPointSection[];
+    /** Section solver currently running */
+    activeSubSolver: PortPointPathingSolver | null;
+    /** Current section being optimized */
+    currentSection: PortPointSection | null;
+    /** Score before optimization (for comparison) */
+    sectionScoreBeforeOptimization: number;
+    /** Node ID of the center of the current section */
+    currentSectionCenterNodeId: CapacityMeshNodeId | null;
+    /** Current index in the optimization schedule */
+    currentScheduleIndex: number;
+    /** Probability of failure for each node */
+    nodePfMap: Map<CapacityMeshNodeId, number>;
+    /** Number of attempts to fix each node */
+    attemptsToFixNode: Map<CapacityMeshNodeId, number>;
+    /** Total number of section optimization attempts made */
+    sectionAttempts: number;
+    /** Maximum number of attempts per node */
+    MAX_ATTEMPTS_PER_NODE: number;
+    /** Maximum total number of section optimization attempts */
+    MAX_SECTION_ATTEMPTS: number;
+    /** Acceptable probability of failure threshold */
+    ACCEPTABLE_PF: number;
+    constructor(params: MultiSectionPortPointOptimizerParams);
+    /**
+     * Compute initial Pf map for all nodes
+     */
+    computeInitialPfMap(): Map<CapacityMeshNodeId, number>;
+    /**
+     * Compute the score for the ENTIRE board (all nodes with port points).
+     */
+    computeBoardScore(): number;
+    /**
+     * Recompute Pf for nodes in a section
+     */
+    recomputePfForNodes(nodeIds: Set<CapacityMeshNodeId>): void;
+    /**
+     * Create input for createPortPointSection from current state
+     */
+    getCreatePortPointSectionInput(): CreatePortPointSectionInput;
+    /**
+     * Create a section for optimization
+     */
+    createSection(params: PortPointSectionParams): PortPointSection;
+    /**
+     * Get nodes with port points for a section (for scoring)
+     */
+    getSectionNodesWithPortPoints(section: PortPointSection): NodeWithPortPoints[];
+    /**
+     * Get nodes with port points for the section (for HighDensitySolver)
+     */
+    getNodesWithPortPoints(): NodeWithPortPoints[];
+    /**
+     * Find the node with the highest probability of failure
+     */
+    findHighestPfNode(): CapacityMeshNodeId | null;
+    /** Cut path info for tracking during reattachment */
+    currentSectionCutPathInfo: Map<string, {
+        sectionPath: SectionPath;
+        originalConnectionResult: ConnectionPathResult;
+    }>;
+    /**
+     * Create a SimpleRouteJson for just the section's connections.
+     * Includes both fully contained connections AND cut paths (partial connections
+     * that pass through the section).
+     */
+    createSectionSimpleRouteJson(section: PortPointSection): SimpleRouteJson;
+    /**
+     * Prepare section input nodes for routing cut paths.
+     * Marks nodes containing cut path endpoints as targets so the solver can route to/from them.
+     */
+    prepareSectionInputNodesForCutPaths(section: PortPointSection): InputNodeWithPortPoints[];
+    getHyperParametersForAttempt(attempt: number): PortPointPathingHyperParameters;
+    /**
+     * Reattach the optimized section results back to the main state.
+     * Handles both fully contained connections AND cut paths.
+     */
+    reattachSection(_section: PortPointSection, newConnectionResults: ConnectionPathResult[], newAssignedPortPoints: Map<string, {
+        connectionName: string;
+        rootConnectionName?: string;
+    }>, newNodeAssignedPortPoints: Map<CapacityMeshNodeId, PortPoint[]>): void;
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+interface CapacityMeshSolverOptions$2 {
+    capacityDepth?: number;
+    targetMinCapacity?: number;
+    cacheProvider?: CacheProvider | null;
+}
+type PipelineStep$2<T extends new (...args: any[]) => BaseSolver> = {
+    solverName: string;
+    solverClass: T;
+    getConstructorParams: (instance: AutoroutingPipelineSolver2_PortPointPathing) => ConstructorParameters<T>;
+    onSolved?: (instance: AutoroutingPipelineSolver2_PortPointPathing) => void;
+};
+declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
+    srj: SimpleRouteJson;
+    opts: CapacityMeshSolverOptions$2;
+    netToPointPairsSolver?: NetToPointPairsSolver;
+    nodeSolver?: RectDiffSolver;
+    nodeTargetMerger?: CapacityNodeTargetMerger;
+    edgeSolver?: CapacityMeshEdgeSolver;
+    colorMap: Record<string, string>;
+    highDensityRouteSolver?: HighDensitySolver;
+    highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
+    singleLayerNodeMerger?: SingleLayerNodeMergerSolver;
+    strawSolver?: StrawSolver;
+    deadEndSolver?: DeadEndSolver;
+    traceSimplificationSolver?: TraceSimplificationSolver;
+    availableSegmentPointSolver?: AvailableSegmentPointSolver;
+    portPointPathingSolver?: PortPointPathingSolver;
+    multiSectionPortPointOptimizer?: MultiSectionPortPointOptimizer;
+    viaDiameter: number;
+    minTraceWidth: 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$2<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$2<typeof RectDiffSolver> | PipelineStep$2<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$2<typeof AvailableSegmentPointSolver> | PipelineStep$2<typeof PortPointPathingSolver> | PipelineStep$2<typeof MultiSectionPortPointOptimizer> | PipelineStep$2<typeof HighDensitySolver> | PipelineStep$2<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$2<typeof TraceSimplificationSolver>)[];
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$2);
+    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;
+    _getOutputHdRoutes(): HighDensityRoute$1[];
+    /**
+     * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
+     */
+    getOutputSimplifiedPcbTraces(): SimplifiedPcbTraces;
+    getOutputSimpleRouteJson(): SimpleRouteJson;
+}
+/** @deprecated Use AutoroutingPipelineSolver instead */
+declare const CapacityMeshSolver: typeof AutoroutingPipelineSolver2_PortPointPathing;
+type CapacityMeshSolver = AutoroutingPipelineSolver2_PortPointPathing;
+
+interface NodePortSegment {
+    capacityMeshNodeId: string;
+    nodePortSegmentId?: string;
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    availableZ: number[];
+    connectionNames: string[];
+    rootConnectionNames?: string[];
+}
+
+/**
+ * Each Node is a square. The capacity paths indicate the nodes the trace will
+ * travel through. We want to find the "Port Segment" that each capacity path
+ * will take for each node.
+ */
+declare class CapacityEdgeToPortSegmentSolver extends BaseSolver {
+    nodes: CapacityMeshNode[];
+    edges: CapacityMeshEdge[];
+    capacityPaths: CapacityPath[];
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
+    unprocessedNodeIds: CapacityMeshNodeId[];
+    nodePortSegments: Map<CapacityMeshNodeId, NodePortSegment[]>;
+    colorMap: Record<string, string>;
+    constructor({ nodes, edges, capacityPaths, colorMap, }: {
+        nodes: CapacityMeshNode[];
+        edges: CapacityMeshEdge[];
+        capacityPaths: CapacityPath[];
+        colorMap?: Record<string, string>;
+    });
+    step(): void;
+    visualize(): GraphicsObject;
+}
+
+interface SegmentWithAssignedPoints extends NodePortSegment {
+    assignedPoints?: {
+        connectionName: string;
+        rootConnectionName?: string;
+        point: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }[];
+}
+/**
+ * CapacitySegmentToPointSolver:
+ *
+ * In each step, the solver iterates over all unsolved segments (segments
+ * without points assigned for each connection). For each segment:
+ *
+ * - If there is only one connection, it assigns the center as the point.
+ * - If there are two connections, it attempts to determine the ordering using
+ *   other segments within the node. If no ordering can be determined, it does nothing.
+ *
+ * If an iteration produces no new assignments, the solver picks the segment with
+ * the fewest connections and assigns points evenly spaced along the segment,
+ * ordering them alphabetically.
+ */
+declare class CapacitySegmentToPointSolver extends BaseSolver {
+    unsolvedSegments: SegmentWithAssignedPoints[];
+    solvedSegments: (NodePortSegment & {
+        assignedPoints: {
+            connectionName: string;
+            rootConnectionName?: string;
+            point: {
+                x: number;
+                y: number;
+                z: number;
+            };
+        }[];
+    })[];
+    nodeMap: Record<string, CapacityMeshNode>;
+    colorMap: Record<string, string>;
+    constructor({ segments, colorMap, nodes, }: {
+        segments: NodePortSegment[];
+        colorMap?: Record<string, string>;
+        /**
+         * This isn't used by the algorithm, but allows associating metadata
+         * for the result datatype (the center, width, height of the node)
+         */
+        nodes: CapacityMeshNode[];
+    });
+    /**
+     * Perform one iteration step.
+     */
+    _step(): void;
+    /**
+     * Return the assigned points for each segment.
+     */
+    getNodesWithPortPoints(): NodeWithPortPoints[];
+    /**
+     * Return a GraphicsObject that visualizes the segments with assigned points.
+     */
+    visualize(): GraphicsObject;
+}
+
+type NodePortSegmentId = string;
+interface ChangeLayerOperation {
+    op: "changeLayer";
+    segmentId: string;
+    pointIndex: number;
+    newLayer: number;
+    /** Operation is mutated and oldLayer is added to allow reversal */
+    oldLayer?: number;
+    cost?: number;
+}
+interface SwitchOperation {
+    op: "switch";
+    segmentId: string;
+    point1Index: number;
+    point2Index: number;
+    cost?: number;
+}
+interface CombinedOperation {
+    op: "combined";
+    subOperations: Array<SwitchOperation | ChangeLayerOperation>;
+    cost?: number;
+}
+type Operation = ChangeLayerOperation | SwitchOperation | CombinedOperation;
+/**
+ * Use simulated annealing to try to improve the placement of points (via
+ * swapping with points on the same segment) or changing the layer.
+ *
+ * We have the following pieces of information:
+ * - NodePortSegment with nodePortSegmentId
+ * - A "neighbor" NodePortSegmentWithAssignedPoints has one change
+ *    - A change can be flipping a point to the opposite layer
+ *    - A change can also be switching the position of two points
+ * - We represent the operations used to change from an original scene
+ *   with a list of operations [SEG1_CL(1, 1), SEG1_SW(1, 2), SEG2_CL(2, 0)]
+ *    - CN indicates the capacity node to edit
+ *    - The SW operation "switches" the x/y location of two points
+ *    - The CL operation changes the layer of the point
+ * - When choosing edits to make, we are biased to operate on nodes that have a
+ *   high cost and biased against operating on nodes we've operated on a lot
+ * - Each step, we generate an operation and use the standard simulated
+ *   annealing function to determine if we should perform the operation
+ */
+declare class CapacitySegmentPointOptimizer extends BaseSolver {
+    assignedSegments: SegmentWithAssignedPoints[];
+    colorMap: Record<string, string>;
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    nodeIdToSegmentIds: Map<string, string[]>;
+    segmentIdToNodeIds: Map<string, string[]>;
+    currentMutatedSegments: Map<NodePortSegmentId, SegmentWithAssignedPoints>;
+    allSegmentIds: string[];
+    lastAppliedOperation: Operation | null;
+    lastCreatedOperation: Operation | null;
+    currentNodeCosts: Map<CapacityMeshNodeId, number>;
+    lastAcceptedIteration: number;
+    currentCost: number;
+    randomSeed: number;
+    numNodes: number;
+    probabilityOfFailure: number;
+    nodesThatCantFitVias: Set<CapacityMeshNodeId>;
+    mutableSegments: Set<NodePortSegmentId>;
+    VIA_DIAMETER: number;
+    OBSTACLE_MARGIN: number;
+    MAX_OPERATIONS_PER_MUTATION: number;
+    MAX_NODE_CHAIN_PER_MUTATION: number;
+    NOOP_ITERATIONS_BEFORE_EARLY_STOP: number;
+    constructor({ assignedSegments, colorMap, nodes, viaDiameter, }: {
+        assignedSegments: NodePortSegment[];
+        colorMap?: Record<string, string>;
+        /**
+         * This isn't used by the algorithm, but allows associating metadata
+         * for the result datatype (the center, width, height of the node)
+         */
+        nodes: CapacityMeshNode[];
+        viaDiameter?: number;
+    });
+    random(): number;
+    /**
+     * The cost is the "probability of failure" of the node.
+     */
+    computeNodeCost(nodeId: CapacityMeshNodeId): number;
+    /**
+     * Number of traces that can go through this node if they are completely
+     * straight without crossings
+     */
+    getUsedTraceCapacity(nodeId: CapacityMeshNodeId): number;
+    /**
+     * Granular via capacity is a consideration of capacity that includes...
+     * - The number of traces
+     * - The number of trace crossings (0-2 vias per trace crossing)
+     *   - Empirically, each crossing typically results in 0.82 vias
+     *   - e.g. 17 traces would typically have 51 crossings & 42 vias
+     * - The number of layer changes (at least 1 via per layer change)
+     *   - We don't know how a entry/exit being on separated layers effects
+     *     the capacity/number of vias yet
+     *
+     * - Generally minimizing the number of crossings is pretty good, if there
+     *   is no trace crossing you basically don't have any used capacity
+     * - If the entry/exit layer is different, you're guaranteed to have at least
+     *   one via
+     *
+     * - Total capacity is computed by estimating the number of vias that could
+     *   be created using the formula (viaFitAcross / 2) ** 1.1
+     */
+    getUsedViaCapacity(nodeId: CapacityMeshNodeId): number;
+    getRandomWeightedNodeId(): CapacityMeshNodeId;
+    getRandomWeightedSegmentId(): string;
+    getMutableSegments(): Set<string>;
+    isSegmentMutable(segmentId: string): boolean;
+    getRandomOperationForSegment(randomSegmentId: string): SwitchOperation | ChangeLayerOperation | null;
+    getNodesNearNode(nodeId: CapacityMeshNodeId, hops?: number): CapacityMeshNodeId[];
+    getRandomCombinedOperationNearNode(nodeId: CapacityMeshNodeId): CombinedOperation;
+    /**
+     * A combined operation can perform multiple operations on a single node, this
+     * allows it to reach outcomes that may not be beneficial with since
+     * operations
+     */
+    getRandomCombinedOperationOnSingleNode(max?: number): CombinedOperation;
+    getRandomOperation(): Operation;
+    /**
+     * We compute "overall probability of failure" as our overall cost, then
+     * linearize it to make it easier to work with
+     */
+    computeCurrentCost(): {
+        cost: number;
+        nodeCosts: Map<CapacityMeshNodeId, number>;
+        probabilityOfFailure: number;
+        linearizedCost: number;
+    };
+    applyOperation(op: Operation): void;
+    reverseOperation(op: Operation): void;
+    isNewCostAcceptable(oldPf: number, newPf: number): boolean;
+    /**
+     * FOR OUTPUT: Return the assigned points for each segment.
+     */
+    getNodesWithPortPoints(): NodeWithPortPoints[];
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+type SegmentPointId = string;
+type SegmentId = string;
+interface BaseUnravelIssue {
+    probabilityOfFailure: number;
+}
+interface UnravelTransitionViaIssue extends BaseUnravelIssue {
+    type: "transition_via";
+    capacityMeshNodeId: CapacityMeshNodeId;
+    segmentPoints: SegmentPointId[];
+}
+interface UnravelSameLayerCrossingIssue extends BaseUnravelIssue {
+    type: "same_layer_crossing";
+    capacityMeshNodeId: CapacityMeshNodeId;
+    crossingLine1: [SegmentPointId, SegmentPointId];
     crossingLine2: [SegmentPointId, SegmentPointId];
 }
 interface UnravelSingleTransitionCrossingIssue extends BaseUnravelIssue {
@@ -1602,191 +2383,6 @@ declare class CapacityPathingMultiSectionSolver extends BaseSolver {
     visualize(): graphics_debug.GraphicsObject;
 }
 
-declare class StrawSolver extends BaseSolver {
-    multiLayerNodes: CapacityMeshNode[];
-    strawNodes: CapacityMeshNode[];
-    skippedNodes: CapacityMeshNode[];
-    unprocessedNodes: CapacityMeshNode[];
-    strawSize: number;
-    nodeIdCounter: number;
-    constructor(params: {
-        nodes: CapacityMeshNode[];
-        strawSize?: number;
-    });
-    getCapacityOfMultiLayerNodesWithinBounds(bounds: {
-        minX: number;
-        maxX: number;
-        minY: number;
-        maxY: number;
-    }): number;
-    getSurroundingCapacities(node: CapacityMeshNode): {
-        leftSurroundingCapacity: number;
-        rightSurroundingCapacity: number;
-        topSurroundingCapacity: number;
-        bottomSurroundingCapacity: number;
-    };
-    /**
-     * Creates straw nodes from a single-layer node based on surrounding capacities
-     */
-    createStrawsForNode(node: CapacityMeshNode): CapacityMeshNode[];
-    getResultNodes(): CapacityMeshNode[];
-    _step(): void;
-    visualize(): GraphicsObject;
-}
-
-/**
- * Merges same layer nodes into larger nodes. Pre-processing stage necessary
- * for "strawing".
- */
-declare class SingleLayerNodeMergerSolver extends BaseSolver {
-    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
-    currentBatchNodeIds: CapacityMeshNodeId[];
-    absorbedNodeIds: Set<CapacityMeshNodeId>;
-    nextBatchNodeIds: CapacityMeshNodeId[];
-    batchHadModifications: boolean;
-    hasComputedAdjacentNodeIds: boolean;
-    newNodes: CapacityMeshNode[];
-    constructor(nodes: CapacityMeshNode[]);
-    computeAdjacentNodeIdsForFirstBatch(nodes: CapacityMeshNode[]): void;
-    getAdjacentSameLayerUnprocessedNodes(rootNode: CapacityMeshNode): CapacityMeshNode[];
-    getAdjacentSameLayerUnprocessedNodes2(rootNode: CapacityMeshNode): CapacityMeshNode[];
-    _step(): void;
-    visualize(): GraphicsObject;
-}
-
-declare class CapacityMeshEdgeSolver2_NodeTreeOptimization extends CapacityMeshEdgeSolver {
-    nodes: CapacityMeshNode[];
-    private nodeTree;
-    private currentNodeIndex;
-    private edgeSet;
-    constructor(nodes: CapacityMeshNode[]);
-    _step(): void;
-}
-
-declare class DeadEndSolver extends BaseSolver {
-    removedNodeIds: Set<string>;
-    private targetNodeIds;
-    private leaves;
-    private leavesIndex;
-    private adjacencyList;
-    /** Only used for visualization, dynamically instantiated if necessary */
-    nodeMap?: Map<CapacityMeshNodeId, CapacityMeshNode>;
-    private nodes;
-    private edges;
-    constructor({ nodes, edges, }: {
-        nodes: CapacityMeshNode[];
-        edges: CapacityMeshEdge[];
-    });
-    _step(): void;
-    visualize(): GraphicsObject;
-}
-
-/**
- * A Disjoint Set Union (DSU) or Union-Find data structure.
- * It tracks a collection of disjoint sets and can efficiently merge them.
- */
-declare class DSU {
-    private parent;
-    /**
-     * Creates a new DSU instance.
-     * Each ID is initially in its own set.
-     */
-    constructor(ids: string[]);
-    /**
-     * Finds the representative of the set containing the given ID.
-     * Uses path compression.
-     */
-    find(id: string): string;
-    /**
-     * Merges the sets containing the two given IDs.
-     */
-    union(id1: string, id2: string): void;
-    /**
-     * Gets all IDs in the same set as the given ID.
-     */
-    getGroup(id: string): string[];
-}
-
-/**
- * Extends the base NetToPointPairsSolver with an optimization that utilizes
- * off-board connections to find shorter routing paths.
- *
- * This solver preprocesses all connections to identify points that are
- * electrically connected off-board (via the `isOffBoard` flag). It builds
- * "equivalence groups" of these points using a Disjoint Set Union (DSU)
- * data structure.
- *
- * When the solver processes an on-board connection or a segment from a
- * Minimum Spanning Tree (MST), it checks if either of the connection's
- * endpoints has an off-board equivalent. If so, it calculates the distance
- * to all possible substitutes and chooses the pair that results in the
- * shortest path, potentially rerouting the connection to a more optimal
- * equivalent point.
- */
-declare class NetToPointPairsSolver2_OffBoardConnection extends NetToPointPairsSolver {
-    ogSrj: SimpleRouteJson;
-    colorMap: Record<string, string>;
-    connectionPointDsu: DSU;
-    connectionPointMap: Map<string, ConnectionPoint>;
-    constructor(ogSrj: SimpleRouteJson, colorMap?: Record<string, string>);
-    _findBestConnectionPointsFromDisjointSets(sourcePoint: ConnectionPoint, targetPoint: ConnectionPoint): {
-        pointsToConnect: [ConnectionPoint, ConnectionPoint];
-    };
-    _step(): void;
-}
-
-type Phase = "via_removal" | "via_merging" | "path_simplification";
-/**
- * TraceSimplificationSolver consolidates trace optimization by iteratively applying
- * via removal, via merging, and path simplification phases. It reduces redundant vias
- * and simplifies routing paths through configurable iterations.
- *
- * The solver operates in three alternating phases per iteration:
- * 1. "via_removal" - Removes unnecessary vias from routes using UselessViaRemovalSolver
- * 2. "via_merging" - Merges redundant vias on the same net using SameNetViaMergerSolver
- * 3. "path_simplification" - Simplifies routing paths using MultiSimplifiedPathSolver
- *
- * Each iteration consists of all phases executed sequentially.
- */
-declare class TraceSimplificationSolver extends BaseSolver {
-    private simplificationConfig;
-    hdRoutes: HighDensityRoute$1[];
-    simplificationPipelineLoops: number;
-    MAX_SIMPLIFICATION_PIPELINE_LOOPS: number;
-    PHASE_ORDER: Phase[];
-    currentPhase: Phase;
-    /** Callback to extract results from the active sub-solver */
-    extractResult: ((solver: BaseSolver) => HighDensityRoute$1[]) | null;
-    /** Returns the simplified routes. This is the primary output of the solver. */
-    get simplifiedHdRoutes(): HighDensityRoute$1[];
-    /**
-     * Creates a new TraceSimplificationSolver
-     * @param simplificationConfig Configuration object containing:
-     *   - hdRoutes: Initial high-density routes to simplify
-     *   - obstacles: Board obstacles to avoid during simplification
-     *   - connMap: Connectivity map for routing validation
-     *   - colorMap: Mapping of net names to colors for visualization
-     *   - outline: Optional board outline boundary
-     *   - defaultViaDiameter: Default diameter for vias
-     *   - layerCount: Number of routing layers
-     *   - iterations: Number of complete simplification iterations (default: 2)
-     */
-    constructor(simplificationConfig: {
-        hdRoutes: HighDensityRoute$1[];
-        obstacles: Obstacle[];
-        connMap: ConnectivityMap;
-        colorMap: Record<string, string>;
-        outline?: Array<{
-            x: number;
-            y: number;
-        }>;
-        defaultViaDiameter: number;
-        layerCount: number;
-    });
-    _step(): void;
-    visualize(): GraphicsObject;
-}
-
 interface CapacityMeshSolverOptions$1 {
     capacityDepth?: number;
     targetMinCapacity?: number;
@@ -1795,10 +2391,10 @@ interface CapacityMeshSolverOptions$1 {
 type PipelineStep$1<T extends new (...args: any[]) => BaseSolver> = {
     solverName: string;
     solverClass: T;
-    getConstructorParams: (instance: AutoroutingPipelineSolver) => ConstructorParameters<T>;
-    onSolved?: (instance: AutoroutingPipelineSolver) => void;
+    getConstructorParams: (instance: AutoroutingPipeline1_OriginalUnravel) => ConstructorParameters<T>;
+    onSolved?: (instance: AutoroutingPipeline1_OriginalUnravel) => void;
 };
-declare class AutoroutingPipelineSolver extends BaseSolver {
+declare class AutoroutingPipeline1_OriginalUnravel extends BaseSolver {
     srj: SimpleRouteJson;
     opts: CapacityMeshSolverOptions$1;
     netToPointPairsSolver?: NetToPointPairsSolver;
@@ -1853,9 +2449,6 @@ declare class AutoroutingPipelineSolver extends BaseSolver {
     getOutputSimplifiedPcbTraces(): SimplifiedPcbTraces;
     getOutputSimpleRouteJson(): SimpleRouteJson;
 }
-/** @deprecated Use AutoroutingPipelineSolver instead */
-declare const CapacityMeshSolver: typeof AutoroutingPipelineSolver;
-type CapacityMeshSolver = AutoroutingPipelineSolver;
 
 /**
  * Calculate the capacity of a node based on its width
@@ -2685,4 +3278,4 @@ declare const convertSrjToGraphicsObject: (srj: SimpleRouteJson) => {
     points: Point$3[];
 };
 
-export { AssignableViaAutoroutingPipelineSolver, AutoroutingPipelineSolver, type AutoroutingPipelineSolverOptions, type CachableSolver, type CacheProvider, CapacityMeshSolver, InMemoryCache, LocalStorageCache, calculateOptimalCapacityDepth, convertSrjToGraphicsObject, getGlobalInMemoryCache, getGlobalLocalStorageCache, getTunedTotalCapacity1, setupGlobalCaches };
+export { AssignableViaAutoroutingPipelineSolver, AutoroutingPipeline1_OriginalUnravel, AutoroutingPipelineSolver2_PortPointPathing as AutoroutingPipelineSolver, type AutoroutingPipelineSolverOptions, type CachableSolver, type CacheProvider, CapacityMeshSolver, InMemoryCache, LocalStorageCache, calculateOptimalCapacityDepth, convertSrjToGraphicsObject, getGlobalInMemoryCache, getGlobalLocalStorageCache, getTunedTotalCapacity1, setupGlobalCaches };