@tscircuit/capacity-autorouter 0.0.280 → 0.0.281

package/dist/index.d.ts

@@ -4317,33 +4317,37 @@ type HgPort = RegionPort & {
     d: InputPortPoint;
 };
 
+type RegionId = CapacityMeshNodeId;
+type RegionMemoryPfMap = Map<RegionId, number>;
+type RegionRipCountMap = Map<RegionId, number>;
 interface HgPortPointPathingSolverParams {
     inputGraph: HyperGraph;
     inputConnections: Connection[];
     connectionsWithResults: ConnectionPathResult[];
     inputNodes: InputNodeWithPortPoints[];
     portPointMap: Map<string, InputPortPoint>;
-    nodeMemoryPfMap: Map<CapacityMeshNodeId, number>;
+    regionMemoryPfMap: RegionMemoryPfMap;
     rippingEnabled: boolean;
     forceCenterFirst: boolean;
     weights: {
-        greedyMultiplier: number;
-        ripCost: number;
-        portUsagePenalty: number;
-        regionTransitionPenalty: number;
-        memoryPfFactor: number;
-        straightLineDeviationPenaltyFactor: number;
-        ripNodePfThresholdStart: number;
-        maxNodeRips: number;
-        randomRipFraction: number;
-        maxRips: number;
+        GREEDY_MULTIPLIER: number;
+        RIP_COST: number;
+        PORT_USAGE_PENALTY: number;
+        REGION_TRANSITION_PENALTY: number;
+        MEMORY_PF_FACTOR: number;
+        CENTER_OFFSET_DIST_PENALTY_FACTOR: number;
+        STRAIGHT_LINE_DEVIATION_PENALTY_FACTOR: number;
+        RIP_REGION_PF_THRESHOLD_START: number;
+        MAX_REGION_RIPS: number;
+        RANDOM_RIP_FRACTION: number;
+        MAX_RIPS: number;
+        MIN_ALLOWED_BOARD_SCORE: number;
     };
-    MIN_ALLOWED_BOARD_SCORE: number;
 }
 declare class HgPortPointPathingSolver extends HyperGraphSolver<HgRegion, HgPort> {
     inputNodes: InputNodeWithPortPoints[];
-    nodeMap: Map<CapacityMeshNodeId, InputNodeWithPortPoints>;
-    regionMap: Map<CapacityMeshNodeId, HgRegion>;
+    regionNodeMap: Map<RegionId, InputNodeWithPortPoints>;
+    regionById: Map<RegionId, HgRegion>;
     portPointMap: Map<string, InputPortPoint>;
     connectionsWithResults: ConnectionPathResult[];
     assignedPortPoints: Map<string, {
@@ -4354,22 +4358,23 @@ declare class HgPortPointPathingSolver extends HyperGraphSolver<HgRegion, HgPort
     assignmentsBuilt: boolean;
     portUsagePenalty: number;
     regionTransitionPenalty: number;
-    ripNodePfThresholdStart: number;
-    maxNodeRips: number;
+    ripRegionPfThresholdStart: number;
+    maxRegionRips: number;
     memoryPfFactor: number;
+    centerOffsetDistPenaltyFactor: number;
     forceCenterFirst: boolean;
     straightLineDeviationPenaltyFactor: number;
-    connectionResultByConnectionId: Map<string, ConnectionPathResult>;
-    nodeRipCountMap: Map<CapacityMeshNodeId, number>;
-    nodeMemoryPfMap: Map<CapacityMeshNodeId, number>;
+    connectionResultByName: Map<string, ConnectionPathResult>;
+    regionRipCountMap: RegionRipCountMap;
+    regionMemoryPfMap: RegionMemoryPfMap;
     totalRipCount: number;
     randomRipFraction: number;
     maxRips: number;
     MIN_ALLOWED_BOARD_SCORE: number;
-    constructor({ inputGraph, inputConnections, connectionsWithResults, inputNodes, portPointMap, nodeMemoryPfMap, rippingEnabled, weights, forceCenterFirst, MIN_ALLOWED_BOARD_SCORE, }: HgPortPointPathingSolverParams);
+    constructor({ inputGraph, inputConnections, connectionsWithResults, inputNodes, portPointMap, regionMemoryPfMap, rippingEnabled, weights, forceCenterFirst, }: HgPortPointPathingSolverParams);
     private clampPf;
     private pfToFailureCost;
-    private recordNodeMemoryPf;
+    private recordRegionMemoryPf;
     estimateCostToEnd(port: HgPort): number;
     computeH(candidate: Candidate$3<HgRegion, HgPort>): number;
     private getStraightLineDeviationPenalty;
@@ -4377,22 +4382,23 @@ declare class HgPortPointPathingSolver extends HyperGraphSolver<HgRegion, HgPort
     getPortUsagePenalty(port: HgPort): number;
     getRipsRequiredForPortUsage(region: HgRegion, port1: HgPort, port2: HgPort): RegionPortAssignment[];
     private isPortAvailableForCurrentNet;
-    private getCenterFirstCandidatesForRegion;
+    private getCenterFirstEnteringRegionCandidates;
     selectCandidatesForEnteringRegion(candidates: Candidate$3<HgRegion, HgPort>[]): Candidate$3<HgRegion, HgPort>[];
     routeSolvedHook(solvedRoute: SolvedRoute): void;
     _step(): void;
     private enforceBoardScoreGuardrail;
     private buildAssignmentsIfSolved;
-    private getNodeRippingPfThreshold;
+    private getRegionRippingPfThreshold;
     private getPortPointsFromRegionAssignments;
     private getPortPointsFromNewlySolvedRouteInRegion;
-    private computeNodePfForRegion;
-    private computeNodePfFromAssignments;
+    private computeRegionPf;
+    private computeRegionPfFromAssignments;
     private getDerivedCapacityMeshNode;
-    private getCrossingRoutesByNodeForPath;
-    private getCandidateRoutesForNodeRipping;
-    private getNodeIdsTraversedByRoute;
-    private maybeAddRandomRips;
+    private getCrossingRoutesByRegionForRoute;
+    private getRoutesInRegionForRipping;
+    private getTraversedRegionIds;
+    private processRandomRips;
+    private processRippingForRoute;
     computeRoutesToRip(newlySolvedRoute: SolvedRoute): Set<SolvedRoute>;
     getNodesWithPortPoints(): NodeWithPortPoints[];
     computeBoardScore(): number;