@tscircuit/capacity-autorouter 0.0.208 → 0.0.210

package/dist/index.d.ts

@@ -1209,6 +1209,29 @@ declare class AvailableSegmentPointSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+/**
+ * Precomputed parameters that can be shared across multiple PortPointPathingSolver instances.
+ * These are computed once and passed to each solver to avoid redundant computation.
+ */
+interface PrecomputedInitialParams {
+    /** Map from nodeId to InputNodeWithPortPoints */
+    nodeMap: Map<CapacityMeshNodeId, InputNodeWithPortPoints>;
+    /** Average node pitch for heuristic calculations */
+    avgNodePitch: number;
+    /** Nodes with off-board connections */
+    offBoardNodes: InputNodeWithPortPoints[];
+    /** Map from portPointId to InputPortPoint */
+    portPointMap: Map<string, InputPortPoint>;
+    /** Map from nodeId to list of port points accessible from that node */
+    nodePortPointsMap: Map<CapacityMeshNodeId, InputPortPoint[]>;
+    /** Map from nodeId to assigned port points (empty initially, will be cloned per solver) */
+    nodeAssignedPortPoints: Map<CapacityMeshNodeId, PortPoint[]>;
+    /** Connections with results (NOT shuffled) - shuffling is done per solver */
+    unshuffledConnectionsWithResults: ConnectionPathResult[];
+    /** Map from connection name to goal node IDs */
+    connectionNameToGoalNodeIds: Map<string, CapacityMeshNodeId[]>;
+}
+
 interface PortPointPathingHyperParameters {
     SHUFFLE_SEED?: number;
     CENTER_OFFSET_DIST_PENALTY_FACTOR?: number;
@@ -1360,6 +1383,8 @@ declare class PortPointPathingSolver extends BaseSolver {
     get GREEDY_MULTIPLIER(): number;
     MAX_CANDIDATES_IN_MEMORY: number;
     get MAX_ITERATIONS_PER_PATH(): number;
+    ITERATIONS_PER_MM_FOR_PATH: number;
+    BASE_ITERATIONS_PER_PATH: number;
     get MIN_ALLOWED_BOARD_SCORE(): number;
     nodeMemoryPfMap: Map<CapacityMeshNodeId, number>;
     currentConnectionIndex: number;
@@ -1373,17 +1398,19 @@ declare class PortPointPathingSolver extends BaseSolver {
     avgNodePitch: number;
     /** Whether the current connection should be forced to route off-board */
     currentConnectionShouldRouteOffBoard: boolean;
+    activeCandidateStraightLineDistance?: number;
     /** Cached list of off-board nodes for computing distance to nearest off-board node */
     offBoardNodes: InputNodeWithPortPoints[];
     /** Cache of base node cost (cost of node in current committed state) */
     private baseNodeCostCache;
-    constructor({ simpleRouteJson, inputNodes, capacityMeshNodes, colorMap, nodeMemoryPfMap, hyperParameters, }: {
+    constructor({ simpleRouteJson, inputNodes, capacityMeshNodes, colorMap, nodeMemoryPfMap, hyperParameters, precomputedInitialParams, }: {
         simpleRouteJson: SimpleRouteJson;
         capacityMeshNodes: CapacityMeshNode[];
         inputNodes: InputNodeWithPortPoints[];
         colorMap?: Record<string, string>;
         nodeMemoryPfMap?: Map<CapacityMeshNodeId, number>;
         hyperParameters?: Partial<PortPointPathingHyperParameters>;
+        precomputedInitialParams?: PrecomputedInitialParams;
     });
     private clearCostCaches;
     private clampPf;
@@ -1392,6 +1419,7 @@ declare class PortPointPathingSolver extends BaseSolver {
     /** Base node cost with the currently-committed port points (no candidate additions) */
     private getBaseNodeFailureCost;
     computeBoardScore(): number;
+    getMaxIterationsForCurrentPath(): number;
     /**
      * Exact delta cost of routing this connection through `nodeId`
      * for the segment defined by entry->exit.
@@ -1507,6 +1535,7 @@ interface HyperPortPointPathingSolverParams {
 }
 declare class HyperPortPointPathingSolver extends HyperParameterSupervisorSolver<PortPointPathingSolver> {
     private params;
+    private precomputedInitialParams;
     constructor(params: HyperPortPointPathingSolverParams);
     getHyperParameterDefs(): Array<HyperParameterDef>;
     getCombinationDefs(): Array<string[]>;