@tscircuit/capacity-autorouter 0.0.310 → 0.0.311

package/dist/index.d.ts

@@ -3,10 +3,11 @@ import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
 import * as graphics_debug from 'graphics-debug';
 import { GraphicsObject, Rect, Circle, Line, Point as Point$5 } from 'graphics-debug';
 import { BaseSolver as BaseSolver$1 } from '@tscircuit/solver-utils';
-import { ViaTile, ViaGraphSolver, ViaByNet, JumperGraphSolver, JRegion, JPort, Region, RegionPort, HyperGraphSolver, HyperGraph, Connection, Candidate as Candidate$3, RegionPortAssignment, SolvedRoute } from '@tscircuit/hypergraph';
+import { ViaTile, ViaGraphSolver, ViaByNet, JumperGraphSolver, JRegion, JPort, Region, RegionPortAssignment, RegionPort, Connection, SolvedRoute, Candidate as Candidate$3, HyperGraph, HyperGraphSolver } from '@tscircuit/hypergraph';
 import { Point3, Polygon } from '@tscircuit/math-utils';
 import { CurvyTraceSolver } from '@tscircuit/curvy-trace-solver';
 import { ConnectivityMap as ConnectivityMap$1 } from 'connectivity-map';
+import { NodeWithPortPoints as NodeWithPortPoints$1 } from '@tscircuit/high-density-a01';
 
 interface CacheProvider {
     isSyncCache: boolean;
@@ -4397,104 +4398,6 @@ declare class AssignableAutoroutingPipeline3 extends BaseSolver {
     getOutputSimpleRouteJson(): SimpleRouteJson;
 }
 
-type HgRegion = Region & {
-    d: InputNodeWithPortPoints;
-};
-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>;
-    regionMemoryPfMap: RegionMemoryPfMap;
-    rippingEnabled: boolean;
-    forceCenterFirst: boolean;
-    weights: {
-        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;
-    };
-    layerCount: number;
-}
-declare class HgPortPointPathingSolver extends HyperGraphSolver<HgRegion, HgPort> {
-    inputNodes: InputNodeWithPortPoints[];
-    regionNodeMap: Map<RegionId, InputNodeWithPortPoints>;
-    regionById: Map<RegionId, HgRegion>;
-    portPointMap: Map<string, InputPortPoint>;
-    connectionsWithResults: ConnectionPathResult[];
-    assignedPortPoints: Map<string, {
-        connectionName: string;
-        rootConnectionName?: string;
-    }>;
-    nodeAssignedPortPoints: Map<CapacityMeshNodeId, PortPoint[]>;
-    assignmentsBuilt: boolean;
-    portUsagePenalty: number;
-    regionTransitionPenalty: number;
-    ripRegionPfThresholdStart: number;
-    maxRegionRips: number;
-    memoryPfFactor: number;
-    centerOffsetDistPenaltyFactor: number;
-    forceCenterFirst: boolean;
-    straightLineDeviationPenaltyFactor: number;
-    connectionResultByName: Map<string, ConnectionPathResult>;
-    regionRipCountMap: RegionRipCountMap;
-    regionMemoryPfMap: RegionMemoryPfMap;
-    totalRipCount: number;
-    randomRipFraction: number;
-    maxRips: number;
-    MIN_ALLOWED_BOARD_SCORE: number;
-    layerCount: number;
-    constructor({ inputGraph, inputConnections, connectionsWithResults, inputNodes, portPointMap, regionMemoryPfMap, rippingEnabled, weights, forceCenterFirst, layerCount, }: HgPortPointPathingSolverParams);
-    private clampPf;
-    private pfToFailureCost;
-    private recordRegionMemoryPf;
-    estimateCostToEnd(port: HgPort): number;
-    computeH(candidate: Candidate$3<HgRegion, HgPort>): number;
-    private getStraightLineDeviationPenalty;
-    computeIncreasedRegionCostIfPortsAreUsed(region: HgRegion, port1: HgPort, port2: HgPort): number;
-    getPortUsagePenalty(port: HgPort): number;
-    getRipsRequiredForPortUsage(region: HgRegion, port1: HgPort, port2: HgPort): RegionPortAssignment[];
-    private isPortAvailableForCurrentNet;
-    private getCenterFirstEnteringRegionCandidates;
-    selectCandidatesForEnteringRegion(candidates: Candidate$3<HgRegion, HgPort>[]): Candidate$3<HgRegion, HgPort>[];
-    routeSolvedHook(solvedRoute: SolvedRoute): void;
-    _step(): void;
-    private enforceBoardScoreGuardrail;
-    private buildAssignmentsIfSolved;
-    private getRegionRippingPfThreshold;
-    private getPortPointsFromRegionAssignments;
-    private getPortPointsFromNewlySolvedRouteInRegion;
-    private computeRegionPf;
-    private computeRegionPfFromAssignments;
-    private getDerivedCapacityMeshNode;
-    private getCrossingRoutesByRegionForRoute;
-    private getRoutesInRegionForRipping;
-    private getTraversedRegionIds;
-    private processRandomRips;
-    private processRippingForRoute;
-    computeRoutesToRip(newlySolvedRoute: SolvedRoute): Set<SolvedRoute>;
-    getNodesWithPortPoints(): NodeWithPortPoints[];
-    computeBoardScore(): number;
-    computeNodePf(node: InputNodeWithPortPoints): number;
-    visualize(): GraphicsObject;
-}
-
 type ExploredPortPoint = {
     port: SegmentPortPoint;
     depth: number;
@@ -4554,6 +4457,146 @@ declare class MultiTargetNecessaryCrampedPortPointSolver extends BaseSolver$1 {
     visualize(): GraphicsObject;
 }
 
+type RawPort = {
+    portId: string;
+    x: number;
+    y: number;
+    z: number;
+    distToCentermostPortOnZ: number;
+    regions: RegionHg[];
+};
+type RegionPortHg = Omit<RegionPort, "d" | "port"> & {
+    d: RawPort;
+};
+type RegionHg = Omit<Region, "d" | "assignments" | "ports"> & {
+    d: CapacityMeshNode;
+    assignments?: RegionPortAssignmentHg[];
+    ports: RegionPortHg[];
+};
+type HyperGraphHg = Omit<HyperGraph, "ports" | "regions"> & {
+    ports: RegionPortHg[];
+    regions: RegionHg[];
+};
+type ConnectionHg = Omit<Connection, "startRegion" | "endRegion"> & {
+    startRegion: RegionHg;
+    endRegion: RegionHg;
+    simpleRouteConnection?: SimpleRouteConnection;
+};
+type CandidateHg = Omit<Candidate$3, "port" | "parent" | "lastPort" | "lastRegion" | "nextRegion"> & {
+    port: RegionPortHg;
+    parent?: CandidateHg;
+    lastPort?: RegionPortHg;
+    lastRegion?: RegionHg;
+    nextRegion?: RegionHg;
+    ripRequired: boolean;
+};
+type SolvedRoutesHg = Omit<SolvedRoute, "path" | "connection"> & {
+    path: CandidateHg[];
+    connection: ConnectionHg;
+};
+type RegionPortAssignmentHg = Omit<RegionPortAssignment, "regionPort1" | "regionPort2" | "region" | "connection" | "solvedRoute"> & {
+    regionPort1: RegionPortHg;
+    regionPort2: RegionPortHg;
+    region: RegionHg;
+    connection: ConnectionHg;
+    solvedRoute: SolvedRoutesHg;
+};
+type RegionId = CapacityMeshNodeId;
+type RegionMemoryPfMap = Map<RegionId, number>;
+interface HgPortPointPathingSolverParams {
+    graph: HyperGraphHg;
+    connections: ConnectionHg[];
+    colorMap?: Record<string, string>;
+    layerCount: number;
+    effort: number;
+    flags: {
+        FORCE_CENTER_FIRST: boolean;
+        RIPPING_ENABLED: boolean;
+    };
+    weights: {
+        /** Seed used for deterministic shuffling in rip-selection ordering. */
+        SHUFFLE_SEED: number;
+        /** Multiplier for center-offset penalty in heuristic h (larger = prefer centermost ports). */
+        CENTER_OFFSET_DIST_PENALTY_FACTOR: number;
+        /** Center-offset amount ignored before penalty starts in heuristic h. */
+        CENTER_OFFSET_FOCUS_SHIFT: number;
+        /** A* greediness factor: f = g + GREEDY_MULTIPLIER * h. */
+        GREEDY_MULTIPLIER: number;
+        /** Scales exact Pf-delta step cost in g (higher = stronger congestion avoidance). */
+        NODE_PF_FACTOR: number;
+        /** Flat added cost when transition changes layer (z differs). */
+        LAYER_CHANGE_COST: number;
+        /** Cost associated with ripping a region due to Pf threshold. */
+        RIPPING_PF_COST: number;
+        /** Maximum cap applied to Pf-derived costs to avoid explosive scores. */
+        NODE_PF_MAX_PENALTY: number;
+        /** Scales memory-Pf contribution in heuristic h (bias away from historically bad regions). */
+        MEMORY_PF_FACTOR: number;
+        /** Base geometric transition multiplier used by auxiliary step penalties. */
+        BASE_CANDIDATE_COST: number;
+        /** Soft board-score guard for candidate filtering; more negative allows riskier paths. */
+        MIN_ALLOWED_BOARD_SCORE: number;
+        /** Per-connection candidate queue cap (0 means use default queue size). */
+        MAX_ITERATIONS_PER_PATH: number;
+        /** Distance threshold where heuristic is suppressed to encourage initial exploration. */
+        RANDOM_WALK_DISTANCE: number;
+        /** Fallback ripping threshold if START/END thresholds are not used. */
+        RIPPING_PF_THRESHOLD: number;
+        /** Initial region Pf threshold for ripping decisions. */
+        START_RIPPING_PF_THRESHOLD: number;
+        /** Final region Pf threshold as region rip-count approaches its cap. */
+        END_RIPPING_PF_THRESHOLD: number;
+        /** Global limit for total rip operations in one solve run. */
+        MAX_RIPS: number;
+        /** Fraction of extra random rips added when ripping is triggered. */
+        RANDOM_RIP_FRACTION: number;
+        /** Multiplier for straight-line deviation penalty in heuristic h. */
+        STRAIGHT_LINE_DEVIATION_PENALTY_FACTOR: number;
+    };
+    opts?: {
+        regionMemoryPfMap?: RegionMemoryPfMap;
+    };
+}
+
+/** Solves port-point routing over an HG hypergraph using heuristics and optional ripping. */
+declare class HgPortPointPathingSolver extends HyperGraphSolver<RegionHg, RegionPortHg> {
+    private params;
+    private regionMemoryPfMap;
+    private baseRegionFailureCostMap;
+    private regionRipCountMap;
+    private totalRipCount;
+    constructor(params: HgPortPointPathingSolverParams);
+    estimateCostToEnd(port: RegionPortHg): number;
+    computeH(candidate: CandidateHg): number;
+    computeIncreasedRegionCostIfPortsAreUsed(region: RegionHg, port1: RegionPortHg, port2: RegionPortHg): number;
+    computeG(candidate: CandidateHg): number;
+    getPortUsagePenalty(port: RegionPortHg): number;
+    getRipsRequiredForPortUsage(region: RegionHg, port1: RegionPortHg, port2: RegionPortHg): RegionPortAssignment[];
+    selectCandidatesForEnteringRegion(candidates: CandidateHg[]): CandidateHg[];
+    routeSolvedHook(solvedRoute: SolvedRoutesHg): void;
+    computeRoutesToRip(newlySolvedRoute: SolvedRoutesHg): Set<SolvedRoutesHg>;
+    private computeDeviation;
+    private computeDistanceTraveled;
+    private computeMemoryPfPenalty;
+    private computeEndRegionCloseCost;
+    private getCenterFirstEnteringRegionCandidates;
+    private isPortAvailableForCurrentNet;
+    private computeRegionPfFromAssignments;
+    private clampPf;
+    private get NODE_MAX_PF();
+    private pfToFailureCost;
+    private getBaseRegionFailureCost;
+    private getRegionAssignedPortPoints;
+    private computeRegionPfWithAdditionalSegment;
+    private getRegionRippingPfThreshold;
+    private computeRegionPf;
+    getOutput(): {
+        nodesWithPortPoints: NodeWithPortPoints$1[];
+        inputNodeWithPortPoints: InputNodeWithPortPoints[];
+    };
+    visualize(): GraphicsObject;
+}
+
 interface CapacityMeshSolverOptions$1 {
     capacityDepth?: number;
     targetMinCapacity?: number;
@@ -4597,7 +4640,6 @@ declare class AutoroutingPipelineSolver3_HgPortPointPathing extends BaseSolver {
     srjWithPointPairs?: SimpleRouteJson;
     capacityNodes: CapacityMeshNode[] | null;
     capacityEdges: CapacityMeshEdge[] | null;
-    inputNodeWithPortPoints: InputNodeWithPortPoints[];
     cacheProvider: CacheProvider | null;
     pipelineDef: (PipelineStep$1<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$1<typeof RectDiffPipeline> | PipelineStep$1<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$1<typeof AvailableSegmentPointSolver> | PipelineStep$1<typeof MultiTargetNecessaryCrampedPortPointSolver> | PipelineStep$1<typeof HgPortPointPathingSolver> | PipelineStep$1<typeof UniformPortDistributionSolver> | PipelineStep$1<typeof HighDensitySolver> | PipelineStep$1<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$1<typeof TraceSimplificationSolver> | PipelineStep$1<typeof TraceWidthSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$1);