@tscircuit/capacity-autorouter 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,818 @@
+import { GraphicsObject } from 'graphics-debug';
+import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
+
+type TraceId = string;
+interface SimpleRouteJson {
+    layerCount: number;
+    minTraceWidth: number;
+    obstacles: Obstacle[];
+    connections: Array<SimpleRouteConnection>;
+    bounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+    traces?: SimplifiedPcbTraces;
+}
+interface Obstacle {
+    type: "rect";
+    layers: string[];
+    center: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    connectedTo: TraceId[];
+}
+interface SimpleRouteConnection {
+    name: string;
+    pointsToConnect: Array<{
+        x: number;
+        y: number;
+        layer: string;
+    }>;
+}
+type SimplifiedPcbTraces = Array<{
+    type: "pcb_trace";
+    pcb_trace_id: TraceId;
+    route: Array<{
+        route_type: "wire";
+        x: number;
+        y: number;
+        width: number;
+        layer: string;
+    } | {
+        route_type: "via";
+        x: number;
+        y: number;
+        to_layer: string;
+        from_layer: string;
+    }>;
+}>;
+
+type CapacityMeshNodeId = string;
+interface CapacityMeshNode {
+    capacityMeshNodeId: string;
+    center: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    layer: string;
+    _depth?: number;
+    _completelyInsideObstacle?: boolean;
+    _containsObstacle?: boolean;
+    _containsTarget?: boolean;
+    _targetConnectionName?: string;
+    _parent?: CapacityMeshNode;
+}
+interface CapacityMeshEdge {
+    capacityMeshEdgeId: string;
+    nodeIds: [CapacityMeshNodeId, CapacityMeshNodeId];
+}
+
+type CapacityPathId = string;
+interface CapacityPath {
+    capacityPathId: CapacityPathId;
+    connectionName: string;
+    nodeIds: CapacityMeshNodeId[];
+}
+
+declare class BaseSolver {
+    MAX_ITERATIONS: number;
+    solved: boolean;
+    failed: boolean;
+    iterations: number;
+    progress: number;
+    error: string | null;
+    /** DO NOT OVERRIDE! Override _step() instead */
+    step(): void;
+    _step(): void;
+    solve(): void;
+    visualize(): GraphicsObject;
+}
+
+declare class CapacityMeshEdgeSolver extends BaseSolver {
+    nodes: CapacityMeshNode[];
+    edges: Array<CapacityMeshEdge>;
+    constructor(nodes: CapacityMeshNode[]);
+    getNextCapacityMeshEdgeId(): string;
+    step(): void;
+    private areNodesBordering;
+    visualize(): GraphicsObject;
+}
+
+interface CapacityMeshNodeSolverOptions {
+    capacityDepth?: number;
+}
+declare class CapacityMeshNodeSolver extends BaseSolver {
+    srj: SimpleRouteJson;
+    opts: CapacityMeshNodeSolverOptions;
+    unfinishedNodes: CapacityMeshNode[];
+    finishedNodes: CapacityMeshNode[];
+    nodeToOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle[]>;
+    MAX_DEPTH: number;
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions);
+    _nextNodeCounter: number;
+    getNextNodeId(): string;
+    getCapacityFromDepth(depth: number): number;
+    getTargetNameIfNodeContainsTarget(node: CapacityMeshNode): string | null;
+    getOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
+    /**
+     * 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[];
+    shouldNodeBeSubdivided(node: CapacityMeshNode): boolean;
+    _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.
+     */
+    visualize(): GraphicsObject;
+}
+
+interface CapacityHyperParameters {
+    VIA_DIAMETER: number;
+    TRACE_WIDTH: number;
+    MAX_CAPACITY_FACTOR: number;
+}
+
+type Candidate = {
+    prevCandidate: Candidate | null;
+    node: CapacityMeshNode;
+    f: number;
+    g: number;
+    h: number;
+};
+declare class CapacityPathingSolver extends BaseSolver {
+    connectionsWithNodes: Array<{
+        connection: SimpleRouteConnection;
+        nodes: CapacityMeshNode[];
+        path?: CapacityMeshNode[];
+    }>;
+    usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    simpleRouteJson: SimpleRouteJson;
+    nodes: CapacityMeshNode[];
+    edges: CapacityMeshEdge[];
+    GREEDY_MULTIPLIER: number;
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
+    connectionNameToGoalNodeIds: Map<string, CapacityMeshNodeId[]>;
+    colorMap: Record<string, string>;
+    maxDepthOfNodes: number;
+    activeCandidateStraightLineDistance?: number;
+    hyperParameters: Partial<CapacityHyperParameters>;
+    constructor({ simpleRouteJson, nodes, edges, colorMap, MAX_ITERATIONS, hyperParameters, }: {
+        simpleRouteJson: SimpleRouteJson;
+        nodes: CapacityMeshNode[];
+        edges: CapacityMeshEdge[];
+        colorMap?: Record<string, string>;
+        MAX_ITERATIONS?: number;
+        hyperParameters?: Partial<CapacityHyperParameters>;
+    });
+    getTotalCapacity(node: CapacityMeshNode): number;
+    getConnectionsWithNodes(): {
+        connectionsWithNodes: {
+            connection: SimpleRouteConnection;
+            nodes: CapacityMeshNode[];
+            pathFound: boolean;
+        }[];
+        connectionNameToGoalNodeIds: Map<string, string[]>;
+    };
+    currentConnectionIndex: number;
+    candidates?: Array<Candidate> | null;
+    visitedNodes?: Set<CapacityMeshNodeId> | null;
+    computeG(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    getBacktrackedPath(candidate: Candidate): CapacityMeshNode[];
+    getNeighboringNodes(node: CapacityMeshNode): CapacityMeshNode[];
+    getCapacityPaths(): CapacityPath[];
+    doesNodeHaveCapacityForTrace(node: CapacityMeshNode): boolean;
+    canTravelThroughObstacle(node: CapacityMeshNode, connectionName: string): boolean;
+    getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
+    reduceCapacityAlongPath(nextConnection: {
+        path?: CapacityMeshNode[];
+    }): void;
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+interface NodePortSegment {
+    capacityMeshNodeId: string;
+    nodePortSegmentId?: string;
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    connectionNames: 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;
+    x: number;
+    y: number;
+    z: number;
+};
+type NodeWithPortPoints = {
+    capacityMeshNodeId: string;
+    center: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    portPoints: PortPoint[];
+};
+/**
+ * A path for a wire in high-density intra-node routing.
+ *
+ * Wires travel along a route, and are placed to avoid other
+ * wires at the same z-level. Any time a z level is changed,
+ * you must place a via.
+ *
+ * z is an integer corresponding to the layer index
+ *
+ * z=0: top layer for 2 layer boards
+ * z=1: bottom layer for 2 layer boards
+ *
+ * z must be an integer
+ */
+type HighDensityIntraNodeRoute = {
+    connectionName: string;
+    traceThickness: number;
+    viaDiameter: number;
+    route: Array<{
+        x: number;
+        y: number;
+        z: number;
+    }>;
+    vias: Array<{
+        x: number;
+        y: number;
+    }>;
+};
+
+interface SegmentWithAssignedPoints extends NodePortSegment {
+    assignedPoints?: {
+        connectionName: 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;
+            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;
+    FUTURE_CONNECTION_PROXIMITY_VD: number;
+    MISALIGNED_DIST_PENALTY_FACTOR: number;
+    VIA_PENALTY_FACTOR_2: number;
+    SHUFFLE_SEED: number;
+    CELL_SIZE_FACTOR: number;
+    FLIP_TRACE_ALIGNMENT_DIRECTION: boolean;
+}
+
+type FutureConnection = {
+    connectionName: string;
+    points: {
+        x: number;
+        y: number;
+    }[];
+};
+type Node = {
+    x: number;
+    y: number;
+    z: number;
+    g: number;
+    h: number;
+    f: number;
+    parent: Node | null;
+};
+declare class SingleHighDensityRouteSolver extends BaseSolver {
+    obstacleRoutes: HighDensityIntraNodeRoute[];
+    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;
+    };
+    straightLineDistance: number;
+    viaDiameter: number;
+    traceThickness: number;
+    obstacleMargin: number;
+    layerCount: number;
+    minCellSize: number;
+    cellStep: number;
+    GREEDY_MULTIPLER: number;
+    numRoutes: number;
+    VIA_PENALTY_FACTOR: number;
+    CELL_SIZE_FACTOR: number;
+    exploredNodes: Set<string>;
+    candidates: Node[];
+    connectionName: string;
+    solvedPath: HighDensityIntraNodeRoute | null;
+    futureConnections: FutureConnection[];
+    hyperParameters: Partial<HighDensityHyperParameters>;
+    connMap?: ConnectivityMap;
+    /** For debugging/animating the exploration */
+    debug_exploredNodesOrdered: string[];
+    debug_nodesTooCloseToObstacle: Set<string>;
+    debug_nodePathToParentIntersectsObstacle: Set<string>;
+    debugEnabled: boolean;
+    constructor(opts: {
+        connectionName: string;
+        obstacleRoutes: HighDensityIntraNodeRoute[];
+        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;
+        };
+        viaDiameter?: number;
+        traceThickness?: number;
+        obstacleMargin?: number;
+        layerCount?: number;
+        futureConnections?: FutureConnection[];
+        hyperParameters?: Partial<HighDensityHyperParameters>;
+        connMap?: ConnectivityMap;
+    });
+    handleSimpleCases(): void;
+    get viaPenaltyDistance(): number;
+    isNodeTooCloseToObstacle(node: Node, margin?: number, isVia?: boolean): boolean;
+    isNodeTooCloseToEdge(node: Node): boolean;
+    doesPathToParentIntersectObstacle(node: Node): boolean;
+    computeH(node: Node): number;
+    computeG(node: Node): number;
+    computeF(g: number, h: number): number;
+    getNodeKey(node: Node): string;
+    getNeighbors(node: Node): Node[];
+    getNodePath(node: Node): Node[];
+    getViasInNodePath(node: Node): {
+        x: number;
+        y: number;
+    }[];
+    setSolvedPath(node: Node): void;
+    computeProgress(currentNode: Node, goalDist: number, isOnLayer: boolean): number;
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+declare class SingleIntraNodeRouteSolver extends BaseSolver {
+    nodeWithPortPoints: NodeWithPortPoints;
+    colorMap: Record<string, string>;
+    unsolvedConnections: {
+        connectionName: string;
+        points: {
+            x: number;
+            y: number;
+            z: number;
+        }[];
+    }[];
+    totalConnections: number;
+    solvedRoutes: HighDensityIntraNodeRoute[];
+    failedSolvers: SingleHighDensityRouteSolver[];
+    hyperParameters: Partial<HighDensityHyperParameters>;
+    minDistBetweenEnteringPoints: number;
+    activeSolver: SingleHighDensityRouteSolver | null;
+    connMap?: ConnectivityMap;
+    constructor(params: {
+        nodeWithPortPoints: NodeWithPortPoints;
+        colorMap?: Record<string, string>;
+        hyperParameters?: Partial<HighDensityHyperParameters>;
+        connMap?: ConnectivityMap;
+    });
+    computeProgress(): number;
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+type SupervisedSolver<T extends BaseSolver> = {
+    hyperParameters: any;
+    solver: T;
+    h: number;
+    g: number;
+    f: number;
+};
+type HyperParameterDef = {
+    name: string;
+    possibleValues: Array<any>;
+};
+/**
+ * The HyperParameterSupervisorSolver is a solver that solves a problem by
+ * running competing solvers with different hyperparameters.
+ *
+ * As solvers make progress, the supervisor will allow the best solvers to run
+ * for more iterations, prioritizing the solvers that are working the best.
+ */
+declare class HyperParameterSupervisorSolver<T extends BaseSolver> extends BaseSolver {
+    GREEDY_MULTIPLIER: number;
+    MIN_SUBSTEPS: number;
+    supervisedSolvers?: Array<SupervisedSolver<T>>;
+    getHyperParameterDefs(): Array<HyperParameterDef>;
+    getCombinationDefs(): Array<Array<string>> | null;
+    getHyperParameterCombinations(hyperParameterDefs?: Array<HyperParameterDef>): Array<Record<string, any>>;
+    initializeSolvers(): void;
+    generateSolver(hyperParameters: any): T;
+    computeG(solver: T): number;
+    computeH(solver: T): number;
+    computeF(g: number, h: number): number;
+    getSupervisedSolverWithBestFitness(): SupervisedSolver<T> | null;
+    _step(): void;
+    onSolve(solver: SupervisedSolver<T>): void;
+    visualize(): GraphicsObject;
+}
+
+declare class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<SingleIntraNodeRouteSolver> {
+    constructorParams: ConstructorParameters<typeof SingleIntraNodeRouteSolver>[0];
+    solvedRoutes: HighDensityIntraNodeRoute[];
+    nodeWithPortPoints: NodeWithPortPoints;
+    constructor(opts: ConstructorParameters<typeof SingleIntraNodeRouteSolver>[0]);
+    getCombinationDefs(): string[][];
+    getHyperParameterDefs(): ({
+        name: string;
+        possibleValues: ({
+            FUTURE_CONNECTION_PROX_TRACE_PENALTY_FACTOR: number;
+            FUTURE_CONNECTION_PROX_VIA_PENALTY_FACTOR: number;
+            FUTURE_CONNECTION_PROXIMITY_VD: number;
+            MISALIGNED_DIST_PENALTY_FACTOR: number;
+            VIA_PENALTY_FACTOR_2?: undefined;
+        } | {
+            FUTURE_CONNECTION_PROX_TRACE_PENALTY_FACTOR: number;
+            FUTURE_CONNECTION_PROX_VIA_PENALTY_FACTOR: number;
+            FUTURE_CONNECTION_PROXIMITY_VD: number;
+            MISALIGNED_DIST_PENALTY_FACTOR: number;
+            VIA_PENALTY_FACTOR_2: number;
+        })[];
+    } | {
+        name: string;
+        possibleValues: {
+            SHUFFLE_SEED: number;
+        }[];
+    } | {
+        name: string;
+        possibleValues: {
+            CELL_SIZE_FACTOR: number;
+        }[];
+    } | {
+        name: string;
+        possibleValues: {
+            FLIP_TRACE_ALIGNMENT_DIRECTION: boolean;
+        }[];
+    } | {
+        name: string;
+        possibleValues: {
+            CELL_SIZE_FACTOR: number;
+            VIA_PENALTY_FACTOR_2: number;
+        }[];
+    })[];
+    computeG(solver: SingleIntraNodeRouteSolver): number;
+    computeH(solver: SingleIntraNodeRouteSolver): number;
+    generateSolver(hyperParameters: any): SingleIntraNodeRouteSolver;
+    onSolve(solver: SupervisedSolver<SingleIntraNodeRouteSolver>): void;
+}
+
+declare class HighDensityRouteSolver extends BaseSolver {
+    unsolvedNodePortPoints: NodeWithPortPoints[];
+    routes: HighDensityIntraNodeRoute[];
+    colorMap: Record<string, string>;
+    readonly defaultViaDiameter = 0.6;
+    readonly defaultTraceThickness = 0.15;
+    failedSolvers: (SingleIntraNodeRouteSolver | HyperSingleIntraNodeSolver)[];
+    activeSubSolver: SingleIntraNodeRouteSolver | HyperSingleIntraNodeSolver | null;
+    connMap?: ConnectivityMap;
+    constructor({ nodePortPoints, colorMap, connMap, }: {
+        nodePortPoints: NodeWithPortPoints[];
+        colorMap?: Record<string, string>;
+        connMap?: ConnectivityMap;
+    });
+    /**
+     * Each iteration, pop an unsolved node and attempt to find the routes inside
+     * of it.
+     */
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+declare class CapacityNodeTargetMerger extends BaseSolver {
+    nodes: CapacityMeshNode[];
+    connMap: ConnectivityMap;
+    unprocessedObstacles: Obstacle[];
+    newNodes: CapacityMeshNode[];
+    removedNodeIds: Set<string>;
+    constructor(nodes: CapacityMeshNode[], obstacles: Obstacle[], connMap: ConnectivityMap);
+    _step(): void;
+    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, }: {
+        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[];
+    });
+    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;
+}
+
+interface CapacityMeshSolverOptions {
+    capacityDepth?: number;
+    targetMinCapacity?: number;
+}
+declare class CapacityMeshSolver extends BaseSolver {
+    srj: SimpleRouteJson;
+    opts: CapacityMeshSolverOptions;
+    nodeSolver: CapacityMeshNodeSolver;
+    nodeTargetMerger?: CapacityNodeTargetMerger;
+    edgeSolver?: CapacityMeshEdgeSolver;
+    pathingSolver?: CapacityPathingSolver;
+    edgeToPortSegmentSolver?: CapacityEdgeToPortSegmentSolver;
+    colorMap: Record<string, string>;
+    segmentToPointSolver?: CapacitySegmentToPointSolver;
+    segmentToPointOptimizer?: CapacitySegmentPointOptimizer;
+    highDensityRouteSolver?: HighDensityRouteSolver;
+    activeSolver?: BaseSolver | null;
+    connMap: ConnectivityMap;
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions);
+    _step(): void;
+    visualize(): GraphicsObject;
+    /**
+     * Simplifies a route by merging consecutive points along the same line
+     */
+    private simplifyRoute;
+    /**
+     * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
+     */
+    getOutputSimpleRouteJson(): SimpleRouteJson;
+}
+
+/**
+ * Calculate the capacity of a node based on its width
+ * @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;
+}, maxCapacityFactor?: 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;
+
+export { CapacityMeshSolver, calculateOptimalCapacityDepth, getTunedTotalCapacity1 };