@tscircuit/capacity-autorouter 0.0.52 → 0.0.53

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import * as graphics_debug from 'graphics-debug';
 import { GraphicsObject } from 'graphics-debug';
 import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
 
@@ -242,80 +243,6 @@ declare class CapacityMeshNodeSolver2_NodeUnderObstacle extends CapacityMeshNode
     _step(): void;
 }
 
-interface CapacityHyperParameters {
-    VIA_DIAMETER: number;
-    TRACE_WIDTH: number;
-    MAX_CAPACITY_FACTOR: number;
-}
-
-type Candidate = {
-    prevCandidate: Candidate | null;
-    node: CapacityMeshNode;
-    f: number;
-    g: number;
-    h: number;
-};
-declare class CapacityPathingSolver extends BaseSolver {
-    connectionsWithNodes: Array<{
-        connection: SimpleRouteConnection;
-        nodes: CapacityMeshNode[];
-        path?: CapacityMeshNode[];
-        straightLineDistance: number;
-    }>;
-    usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
-    simpleRouteJson: SimpleRouteJson;
-    nodes: CapacityMeshNode[];
-    edges: CapacityMeshEdge[];
-    GREEDY_MULTIPLIER: number;
-    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
-    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
-    connectionNameToGoalNodeIds: Map<string, CapacityMeshNodeId[]>;
-    colorMap: Record<string, string>;
-    maxDepthOfNodes: number;
-    activeCandidateStraightLineDistance?: number;
-    debug_lastNodeCostMap: Map<CapacityMeshNodeId, {
-        g: number;
-        h: number;
-        f: number;
-    }>;
-    hyperParameters: Partial<CapacityHyperParameters>;
-    constructor({ simpleRouteJson, nodes, edges, colorMap, MAX_ITERATIONS, hyperParameters, }: {
-        simpleRouteJson: SimpleRouteJson;
-        nodes: CapacityMeshNode[];
-        edges: CapacityMeshEdge[];
-        colorMap?: Record<string, string>;
-        MAX_ITERATIONS?: number;
-        hyperParameters?: Partial<CapacityHyperParameters>;
-    });
-    getTotalCapacity(node: CapacityMeshNode): number;
-    getConnectionsWithNodes(): {
-        connectionsWithNodes: {
-            connection: SimpleRouteConnection;
-            nodes: CapacityMeshNode[];
-            pathFound: boolean;
-            straightLineDistance: number;
-        }[];
-        connectionNameToGoalNodeIds: Map<string, string[]>;
-    };
-    currentConnectionIndex: number;
-    candidates?: Array<Candidate> | null;
-    visitedNodes?: Set<CapacityMeshNodeId> | null;
-    computeG(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    computeH(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    getBacktrackedPath(candidate: Candidate): CapacityMeshNode[];
-    getNeighboringNodes(node: CapacityMeshNode): CapacityMeshNode[];
-    getCapacityPaths(): CapacityPath[];
-    doesNodeHaveCapacityForTrace(node: CapacityMeshNode, prevNode: CapacityMeshNode): boolean;
-    canTravelThroughObstacle(node: CapacityMeshNode, connectionName: string): boolean;
-    getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
-    reduceCapacityAlongPath(nextConnection: {
-        path?: CapacityMeshNode[];
-    }): void;
-    isConnectedToEndGoal(node: CapacityMeshNode, endGoal: CapacityMeshNode): boolean;
-    _step(): void;
-    visualize(): GraphicsObject;
-}
-
 interface NodePortSegment {
     capacityMeshNodeId: string;
     nodePortSegmentId?: string;
@@ -700,6 +627,7 @@ declare class TwoCrossingRoutesHighDensitySolver extends BaseSolver {
         via1: Point$2;
         via2: Point$2;
     }[];
+    escapeLayer: number;
     solvedRoutes: HighDensityIntraNodeRoute$1[];
     bounds: {
         minX: number;
@@ -727,20 +655,14 @@ declare class TwoCrossingRoutesHighDensitySolver extends BaseSolver {
      */
     private doRoutesCross;
     private calculateViaPositions;
-    /**
-     * Create a route with properly placed vias
-     */
-    private createRoute;
     /**
      * Try to solve with routeA going over and routeB staying on layer 0
      */
     private trySolveAOverB;
-    private optimizeViaPositions;
-    /**
-     * Calculate the orthogonal route points for the second route
-     */
-    private calculateConservativeOrthogonalRoutePoints;
-    private calculateShortestOrthogonalRoutePoints;
+    private pushViasFromEndpoints;
+    private getMinDistanceBetweenViaCenters;
+    private moveViasAsCloseAsPossible;
+    handleRoutesDontCross(): void;
     /**
      * Main step method that attempts to solve the two crossing routes
      */
@@ -1024,6 +946,7 @@ declare class SingleHighDensityRouteStitchSolver extends BaseSolver {
         y: number;
         z: number;
     };
+    colorMap: Record<string, string>;
     constructor(opts: {
         connectionName?: string;
         hdRoutes: HighDensityIntraNodeRoute$1[];
@@ -1037,6 +960,7 @@ declare class SingleHighDensityRouteStitchSolver extends BaseSolver {
             y: number;
             z: number;
         };
+        colorMap?: Record<string, string>;
     });
     _step(): void;
     visualize(): GraphicsObject;
@@ -1060,9 +984,11 @@ declare class MultipleHighDensityRouteStitchSolver extends BaseSolver {
     unsolvedRoutes: UnsolvedRoute[];
     activeSolver: SingleHighDensityRouteStitchSolver | null;
     mergedHdRoutes: HighDensityIntraNodeRoute$1[];
+    colorMap: Record<string, string>;
     constructor(opts: {
         connections: SimpleRouteConnection[];
         hdRoutes: HighDensityIntraNodeRoute$1[];
+        colorMap?: Record<string, string>;
         layerCount: number;
     });
     _step(): void;
@@ -1304,6 +1230,81 @@ declare class UnravelMultiSectionSolver extends BaseSolver {
     getNodesWithPortPoints(): NodeWithPortPoints[];
 }
 
+interface CapacityHyperParameters {
+    VIA_DIAMETER: number;
+    TRACE_WIDTH: number;
+    MAX_CAPACITY_FACTOR: number;
+}
+
+type Candidate$1 = {
+    prevCandidate: Candidate$1 | null;
+    node: CapacityMeshNode;
+    f: number;
+    g: number;
+    h: number;
+};
+type ConnectionPathWithNodes = {
+    connection: SimpleRouteConnection;
+    nodes: CapacityMeshNode[];
+    path?: CapacityMeshNode[];
+    straightLineDistance: number;
+};
+declare class CapacityPathingSolver extends BaseSolver {
+    connectionsWithNodes: Array<ConnectionPathWithNodes>;
+    usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    simpleRouteJson: SimpleRouteJson;
+    nodes: CapacityMeshNode[];
+    edges: CapacityMeshEdge[];
+    GREEDY_MULTIPLIER: number;
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
+    connectionNameToGoalNodeIds: Map<string, CapacityMeshNodeId[]>;
+    colorMap: Record<string, string>;
+    maxDepthOfNodes: number;
+    activeCandidateStraightLineDistance?: number;
+    debug_lastNodeCostMap: Map<CapacityMeshNodeId, {
+        g: number;
+        h: number;
+        f: number;
+    }>;
+    hyperParameters: Partial<CapacityHyperParameters>;
+    constructor({ simpleRouteJson, nodes, edges, colorMap, MAX_ITERATIONS, hyperParameters, }: {
+        simpleRouteJson: SimpleRouteJson;
+        nodes: CapacityMeshNode[];
+        edges: CapacityMeshEdge[];
+        colorMap?: Record<string, string>;
+        MAX_ITERATIONS?: number;
+        hyperParameters?: Partial<CapacityHyperParameters>;
+    });
+    getTotalCapacity(node: CapacityMeshNode): number;
+    getConnectionsWithNodes(): {
+        connectionsWithNodes: {
+            connection: SimpleRouteConnection;
+            nodes: CapacityMeshNode[];
+            pathFound: boolean;
+            straightLineDistance: number;
+        }[];
+        connectionNameToGoalNodeIds: Map<string, string[]>;
+    };
+    currentConnectionIndex: number;
+    candidates?: Array<Candidate$1> | null;
+    visitedNodes?: Set<CapacityMeshNodeId> | null;
+    computeG(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    getBacktrackedPath(candidate: Candidate$1): CapacityMeshNode[];
+    getNeighboringNodes(node: CapacityMeshNode): CapacityMeshNode[];
+    getCapacityPaths(): CapacityPath[];
+    doesNodeHaveCapacityForTrace(node: CapacityMeshNode, prevNode: CapacityMeshNode): boolean;
+    canTravelThroughObstacle(node: CapacityMeshNode, connectionName: string): boolean;
+    getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
+    reduceCapacityAlongPath(nextConnection: {
+        path?: CapacityMeshNode[];
+    }): void;
+    isConnectedToEndGoal(node: CapacityMeshNode, endGoal: CapacityMeshNode): boolean;
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
 declare class CapacityPathingSolver5 extends CapacityPathingSolver {
     NEGATIVE_CAPACITY_PENALTY_FACTOR: number;
     REDUCED_CAPACITY_PENALTY_FACTOR: number;
@@ -1320,8 +1321,158 @@ declare class CapacityPathingSolver5 extends CapacityPathingSolver {
      * To minimize shortest path, you'd want to comment this out.
      */
     getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
+    computeG(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate$1, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+}
+
+declare class CapacityPathingGreedySolver extends CapacityPathingSolver5 {
+    doesNodeHaveCapacityForTrace(node: CapacityMeshNode, prevNode: CapacityMeshNode): boolean;
+    getNodeCapacityPenalty(node: CapacityMeshNode): number;
+}
+
+type Candidate = {
+    prevCandidate: Candidate | null;
+    node: CapacityMeshNode;
+    f: number;
+    g: number;
+    h: number;
+};
+interface CpssPathingSolverHyperParameters {
+    SHUFFLE_SEED?: number;
+    EXPANSION_DEGREES?: number;
+}
+interface CapacityPathingSingleSectionPathingSolverParams {
+    sectionNodes: CapacityMeshNode[];
+    sectionEdges: CapacityMeshEdge[];
+    sectionConnectionTerminals: Array<{
+        connectionName: string;
+        startNodeId: CapacityMeshNodeId;
+        endNodeId: CapacityMeshNodeId;
+    }>;
+    colorMap?: Record<string, string>;
+    hyperParameters?: CpssPathingSolverHyperParameters;
+}
+declare class CapacityPathingSingleSectionPathingSolver extends BaseSolver {
+    GREEDY_MULTIPLIER: number;
+    NEGATIVE_CAPACITY_PENALTY_FACTOR: number;
+    REDUCED_CAPACITY_PENALTY_FACTOR: number;
+    sectionNodes: CapacityMeshNode[];
+    sectionEdges: CapacityMeshEdge[];
+    sectionConnectionTerminals: Array<{
+        connectionName: string;
+        startNodeId: CapacityMeshNodeId;
+        endNodeId: CapacityMeshNodeId;
+        path?: CapacityMeshNode[];
+    }>;
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
+    colorMap: Record<string, string>;
+    usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    currentConnectionIndex: number;
+    candidates?: Array<Candidate> | null;
+    visitedNodes?: Set<CapacityMeshNodeId> | null;
+    queuedNodes?: Set<CapacityMeshNodeId> | null;
+    activeCandidateStraightLineDistance?: number;
+    debug_lastNodeCostMap: Map<CapacityMeshNodeId, {
+        g: number;
+        h: number;
+        f: number;
+    }>;
+    maxCapacityFactor: number;
+    constructor(params: CapacityPathingSingleSectionPathingSolverParams);
+    getTotalCapacity(node: CapacityMeshNode): number;
+    getNodeCapacityPenalty(node: CapacityMeshNode): number;
+    getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
     computeG(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
-    computeH(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate, // prevCandidate not strictly needed here
+    node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    getBacktrackedPath(candidate: Candidate): CapacityMeshNode[];
+    getNeighboringNodes(node: CapacityMeshNode): CapacityMeshNode[];
+    isConnectedToEndGoal(node: CapacityMeshNode, endGoal: CapacityMeshNode): boolean;
+    doesNodeHaveCapacityForTrace(node: CapacityMeshNode, prevNode: CapacityMeshNode | null): boolean;
+    reduceCapacityAlongPath(path: CapacityMeshNode[]): void;
+    _step(): void;
+    private _setupAStar;
+    private _handleCandidatesExhausted;
+    private _handleGoalReached;
+    visualize(): GraphicsObject;
+}
+
+interface CapacityPathingSingleSectionSolverInput {
+    centerNodeId: CapacityMeshNodeId;
+    connectionsWithNodes: Array<ConnectionPathWithNodes>;
+    nodes: CapacityMeshNode[];
+    edges: CapacityMeshEdge[];
+    colorMap: Record<string, string>;
+    hyperParameters?: CpssPathingSolverHyperParameters;
+}
+declare class CapacityPathingSingleSectionSolver extends BaseSolver {
+    centerNodeId: CapacityMeshNodeId;
+    connectionsWithNodes: Array<ConnectionPathWithNodes>;
+    nodes: CapacityMeshNode[];
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    edges: CapacityMeshEdge[];
+    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
+    expansionDegrees: number;
+    colorMap: Record<string, string>;
+    sectionNodes: CapacityMeshNode[];
+    sectionEdges: CapacityMeshEdge[];
+    sectionConnectionTerminals: Array<{
+        connectionName: string;
+        startNodeId: CapacityMeshNodeId;
+        endNodeId: CapacityMeshNodeId;
+    }>;
+    activeSubSolver?: CapacityPathingSingleSectionPathingSolver | null | undefined;
+    constructor(params: CapacityPathingSingleSectionSolverInput);
+    private computeSectionNodesTerminalsAndEdges;
+    _step(): void;
+    getConstructorParams(): readonly [{
+        readonly centerNodeId: string;
+        readonly connectionsWithNodes: ConnectionPathWithNodes[];
+        readonly nodes: CapacityMeshNode[];
+        readonly edges: CapacityMeshEdge[];
+        readonly expansionDegrees: number;
+    }];
+    visualize(): GraphicsObject;
+}
+
+/**
+ * This solver solves for capacity paths by first solving with negative
+ * capacities allowed, then re-solving problematic sections with a section
+ * solver.
+ */
+declare class CapacityPathingMultiSectionSolver extends BaseSolver {
+    simpleRouteJson: SimpleRouteJson;
+    nodes: CapacityMeshNode[];
+    edges: CapacityMeshEdge[];
+    connectionsWithNodes: Array<ConnectionPathWithNodes>;
+    colorMap: Record<string, string>;
+    initialSolver: CapacityPathingGreedySolver;
+    stage: "initialization" | "section-optimization";
+    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
+    usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    totalNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    nodeCapacityPercentMap: Map<CapacityMeshNodeId, number>;
+    nodeOptimizationAttemptCountMap: Map<CapacityMeshNodeId, number>;
+    sectionSolver?: CapacityPathingSingleSectionSolver | null;
+    MAX_ATTEMPTS_PER_NODE: number;
+    constructor(params: ConstructorParameters<typeof CapacityPathingSolver>[0]);
+    _stepInitialization(): void;
+    _getNextNodeToOptimize(): CapacityMeshNodeId | null;
+    _stepSectionOptimization(): void;
+    /**
+     * Merges the paths found by a successful section solver back into the main
+     * connectionsWithNodes list.
+     */
+    private _mergeSolvedSectionPaths;
+    /**
+     * Recalculates node capacity usage based on the current connectionsWithNodes
+     * and updates the nodeCapacityPercentMap.
+     */
+    private _recalculateNodeCapacityUsage;
+    getCapacityPaths(): CapacityPath[];
+    _step(): void;
+    visualize(): graphics_debug.GraphicsObject;
 }
 
 declare class StrawSolver extends BaseSolver {
@@ -1514,6 +1665,11 @@ declare class SingleRouteUselessViaRemovalSolver extends BaseSolver {
         currentSection: RouteSection;
         targetZ: number;
     }): boolean;
+    getConstructorParams(): {
+        obstacleSHI: ObstacleSpatialHashIndex;
+        hdRouteSHI: HighDensityRouteSpatialIndex;
+        unsimplifiedRoute: HighDensityIntraNodeRoute;
+    };
     getOptimizedHdRoute(): HighDensityRoute;
     visualize(): GraphicsObject;
 }
@@ -1555,7 +1711,7 @@ declare class AutoroutingPipelineSolver extends BaseSolver {
     nodeSolver?: CapacityMeshNodeSolver;
     nodeTargetMerger?: CapacityNodeTargetMerger;
     edgeSolver?: CapacityMeshEdgeSolver;
-    pathingSolver?: CapacityPathingSolver;
+    pathingSolver?: CapacityPathingMultiSectionSolver;
     edgeToPortSegmentSolver?: CapacityEdgeToPortSegmentSolver;
     colorMap: Record<string, string>;
     segmentToPointSolver?: CapacitySegmentToPointSolver;
@@ -1565,8 +1721,10 @@ declare class AutoroutingPipelineSolver extends BaseSolver {
     highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
     singleLayerNodeMerger?: SingleLayerNodeMergerSolver;
     strawSolver?: StrawSolver;
-    uselessViaRemovalSolver?: UselessViaRemovalSolver;
-    multiSimplifiedPathSolver?: MultiSimplifiedPathSolver;
+    uselessViaRemovalSolver1?: UselessViaRemovalSolver;
+    uselessViaRemovalSolver2?: UselessViaRemovalSolver;
+    multiSimplifiedPathSolver1?: MultiSimplifiedPathSolver;
+    multiSimplifiedPathSolver2?: MultiSimplifiedPathSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
@@ -1620,6 +1778,7 @@ type CapacityMeshSolver = AutoroutingPipelineSolver;
  */
 declare const getTunedTotalCapacity1: (nodeOrWidth: CapacityMeshNode | {
     width: number;
+    availableZ?: number[];
 }, maxCapacityFactor?: number) => number;
 /**
  * Calculate the optimal subdivision depth to reach a target minimum capacity