@tscircuit/capacity-autorouter 0.0.279 → 0.0.281

package/dist/index.d.ts

@@ -2085,19 +2085,33 @@ declare class MultiSectionPortPointOptimizer extends BaseSolver {
 }
 
 type Side = "left" | "right" | "top" | "bottom";
+type OwnerPair = [string, string];
+type OwnerPairKey = string;
+type EdgeOrientation = "vertical" | "horizontal";
 type Bounds = {
     minX: number;
     maxX: number;
     minY: number;
     maxY: number;
 };
-interface NodeAndSide {
-    nodeId: string;
-    side: Side;
-}
-type PortPointWithSide = PortPoint & {
-    side: Side;
-    ownerNodeId: string;
+type PortPointWithOwnerPair = PortPoint & {
+    ownerNodeIds: OwnerPair;
+    ownerPairKey: OwnerPairKey;
+};
+type SharedEdge = {
+    ownerNodeIds: OwnerPair;
+    ownerPairKey: OwnerPairKey;
+    orientation: EdgeOrientation;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    center: {
+        x: number;
+        y: number;
+    };
+    length: number;
+    nodeSideByOwnerId: Record<string, Side>;
 };
 
 interface UniformPortDistributionSolverInput {
@@ -2110,20 +2124,19 @@ interface UniformPortDistributionSolverInput {
  * routing density and prevent congestion.
  *
  * This solver:
- * 1. Classifies which side of a node each port point belongs to.
- * 2. Determines the "owner" node for port points shared between nodes.
- * 3. Evenly spaces port points along their assigned side.
+ * 1. Determines an owner pair of capacity nodes for each port point.
+ * 2. Precomputes the shared edge for each owner pair.
+ * 3. Evenly spaces "family" port points along their shared edge.
  */
 declare class UniformPortDistributionSolver extends BaseSolver$1 {
     private input;
     getSolverName(): string;
-    mapOfNodeIdToLengthOfEachSide: Map<string, Record<Side, number>>;
-    sidesToProcess: NodeAndSide[];
     mapOfNodeIdToBounds: Map<string, Bounds>;
-    mapOfNodeAndSideToPortPoints: Map<string, PortPointWithSide[]>;
-    currentSideBeingProcessed: NodeAndSide | null;
+    mapOfOwnerPairToPortPoints: Map<string, PortPointWithOwnerPair[]>;
+    mapOfOwnerPairToSharedEdge: Map<string, SharedEdge>;
+    ownerPairsToProcess: OwnerPairKey[];
+    currentOwnerPairBeingProcessed: OwnerPairKey | null;
     redistributedNodes: NodeWithPortPoints[];
-    private getNodeAndSideKey;
     constructor(input: UniformPortDistributionSolverInput);
     step(): void;
     rebuildNodes(): void;
@@ -4304,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, {
@@ -4341,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;
@@ -4364,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;