@tscircuit/capacity-autorouter 0.0.280 → 0.0.282

package/dist/index.d.ts

@@ -1208,7 +1208,7 @@ type Phase$1 = "via_removal" | "via_merging" | "path_simplification";
  * Each iteration consists of all phases executed sequentially.
  */
 declare class TraceSimplificationSolver extends BaseSolver {
-    private simplificationConfig;
+    private readonly simplificationConfig;
     getSolverName(): string;
     hdRoutes: HighDensityRoute$1[];
     simplificationPipelineLoops: number;
@@ -1232,16 +1232,16 @@ declare class TraceSimplificationSolver extends BaseSolver {
      *   - iterations: Number of complete simplification iterations (default: 2)
      */
     constructor(simplificationConfig: {
-        hdRoutes: HighDensityRoute$1[];
-        obstacles: Obstacle[];
-        connMap: ConnectivityMap;
-        colorMap: Record<string, string>;
-        outline?: Array<{
+        readonly hdRoutes: ReadonlyArray<HighDensityRoute$1>;
+        readonly obstacles: ReadonlyArray<Obstacle>;
+        readonly connMap: ConnectivityMap;
+        readonly colorMap: Readonly<Record<string, string>>;
+        readonly outline?: ReadonlyArray<{
             x: number;
             y: number;
         }>;
-        defaultViaDiameter: number;
-        layerCount: number;
+        readonly defaultViaDiameter: number;
+        readonly layerCount: number;
     });
     _step(): void;
     visualize(): GraphicsObject;
@@ -2243,6 +2243,7 @@ interface TraceWidthSolverInput {
     colorMap?: Record<string, string>;
     minTraceWidth: number;
     obstacleMargin?: number;
+    layerCount: number;
 }
 /**
  * TraceWidthSolver determines the optimal trace width for each route.
@@ -2328,8 +2329,8 @@ type PipelineStep$5<T extends new (...args: any[]) => BaseSolver> = {
     onSolved?: (instance: AutoroutingPipelineSolver2_PortPointPathing) => void;
 };
 declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
-    srj: SimpleRouteJson;
-    opts: CapacityMeshSolverOptions$5;
+    readonly srj: SimpleRouteJson;
+    readonly opts: CapacityMeshSolverOptions$5;
     getSolverName(): string;
     netToPointPairsSolver?: NetToPointPairsSolver;
     nodeSolver?: RectDiffPipeline;
@@ -2439,6 +2440,7 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
     targets: Target[];
     targetTree: TargetTree;
     obstacleTree: ObstacleSpatialHashIndex;
+    readonly obstacleZLayersByObstacle: WeakMap<Obstacle, number[]>;
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshNodeSolverOptions$2);
     computeTargets(): Target[];
     protected getNodeBounds(node: CapacityMeshNode): {
@@ -2484,6 +2486,7 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
      * - Points for each connection’s pointsToConnect are drawn in a unique color.
      */
     visualize(): GraphicsObject;
+    private getObstacleZLayers;
 }
 
 interface CapacityMeshNodeSolverOptions$1 {
@@ -3361,8 +3364,8 @@ type PipelineStep$4<T extends new (...args: any[]) => BaseSolver> = {
     onSolved?: (instance: AutoroutingPipeline1_OriginalUnravel) => void;
 };
 declare class AutoroutingPipeline1_OriginalUnravel extends BaseSolver {
-    srj: SimpleRouteJson;
-    opts: CapacityMeshSolverOptions$4;
+    readonly srj: SimpleRouteJson;
+    readonly opts: CapacityMeshSolverOptions$4;
     getSolverName(): string;
     netToPointPairsSolver?: NetToPointPairsSolver;
     nodeSolver?: CapacityMeshNodeSolver;
@@ -4096,8 +4099,8 @@ type PipelineStep$3<T extends new (...args: any[]) => BaseSolver> = {
     onSolved?: (instance: AssignableAutoroutingPipeline2) => void;
 };
 declare class AssignableAutoroutingPipeline2 extends BaseSolver {
-    srj: SimpleRouteJson;
-    opts: CapacityMeshSolverOptions$3;
+    readonly srj: SimpleRouteJson;
+    readonly opts: CapacityMeshSolverOptions$3;
     getSolverName(): string;
     netToPointPairsSolver?: NetToPointPairsSolver;
     nodeSolver?: RectDiffPipeline;
@@ -4240,8 +4243,8 @@ type PipelineStep$2<T extends new (...args: any[]) => BaseSolver> = {
     onSolved?: (instance: AssignableAutoroutingPipeline3) => void;
 };
 declare class AssignableAutoroutingPipeline3 extends BaseSolver {
-    srj: SimpleRouteJson;
-    opts: CapacityMeshSolverOptions$2;
+    readonly srj: SimpleRouteJson;
+    readonly opts: CapacityMeshSolverOptions$2;
     getSolverName(): string;
     netToPointPairsSolver?: NetToPointPairsSolver;
     traceKeepoutSolver?: TraceKeepoutSolver;
@@ -4317,33 +4320,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 +4361,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 +4385,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;
@@ -4413,8 +4422,8 @@ type PipelineStep$1<T extends new (...args: any[]) => BaseSolver> = {
     onSolved?: (instance: AutoroutingPipelineSolver3_HgPortPointPathing) => void;
 };
 declare class AutoroutingPipelineSolver3_HgPortPointPathing extends BaseSolver {
-    srj: SimpleRouteJson;
-    opts: CapacityMeshSolverOptions$1;
+    readonly srj: SimpleRouteJson;
+    readonly opts: CapacityMeshSolverOptions$1;
     netToPointPairsSolver?: NetToPointPairsSolver;
     nodeSolver?: RectDiffPipeline;
     nodeTargetMerger?: CapacityNodeTargetMerger;
@@ -5023,8 +5032,8 @@ type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
     onSolved?: (instance: AssignableAutoroutingPipeline1Solver) => void;
 };
 declare class AssignableAutoroutingPipeline1Solver extends BaseSolver {
-    srj: SimpleRouteJson;
-    opts: CapacityMeshSolverOptions;
+    readonly srj: SimpleRouteJson;
+    readonly opts: CapacityMeshSolverOptions;
     getSolverName(): string;
     netToPointPairsSolver?: NetToPointPairsSolver;
     nodeSolver?: CapacityMeshNodeSolver;