@tscircuit/capacity-autorouter 0.0.466 → 0.0.468

package/dist/index.d.ts

@@ -3,9 +3,8 @@ import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
 import * as graphics_debug from 'graphics-debug';
 import { GraphicsObject, Rect, Circle, Line, Point as Point$7 } from 'graphics-debug';
 import { BaseSolver as BaseSolver$1 } from '@tscircuit/solver-utils';
-import Flatbush from 'flatbush';
 import { HighDensitySolverA03, NodeWithPortPoints as NodeWithPortPoints$1 } from '@tscircuit/high-density-a01';
-import { FixedViaHypergraphSolver } from '@tscircuit/fixed-via-hypergraph-solver/lib/index';
+import Flatbush from 'flatbush';
 import { Point3, Polygon } from '@tscircuit/math-utils';
 import { CurvyTraceSolver } from '@tscircuit/curvy-trace-solver';
 import { JumperGraphSolver, JRegion, JPort, HyperGraph, RegionPort, Region, RegionPortAssignment, Connection, SolvedRoute, Candidate as Candidate$3, HyperGraphSolver, HyperGraphSectionOptimizer } from '@tscircuit/hypergraph';
@@ -1034,7 +1033,6 @@ interface HighDensityHyperParameters {
     FUTURE_CONNECTION_LINE_PROXIMITY?: number;
     FUTURE_CONNECTION_LINE_PENALTY?: number;
     MIN_TRAVEL_BEFORE_JUMPER?: number;
-    FIXED_TOPOLOGY_HIGH_DENSITY_INTRA_NODE_SOLVER?: boolean;
 }
 
 type Node = {
@@ -1299,42 +1297,21 @@ declare class CachedIntraNodeRouteSolver extends IntraNodeRouteSolver implements
     saveToCacheSync(): void;
 }
 
-type SupervisedSolver<T extends BaseSolver> = {
-    hyperParameters: any;
-    solver: T;
-    h: number;
-    g: number;
-    f: number;
-};
-type HyperParameterDef = {
-    name: string;
-    possibleValues: Array<any>;
-};
-/**
- * The HyperParameterSupervisorSolver is a solver that solves a problem by
- * running competing solvers with different hyperparameters.
- *
- * As solvers make progress, the supervisor will allow the best solvers to run
- * for more iterations, prioritizing the solvers that are working the best.
- */
-declare class HyperParameterSupervisorSolver<T extends BaseSolver> extends BaseSolver {
+declare class SingleLayerNoDifferentRootIntersectionsIntraNodeSolver extends BaseSolver {
     getSolverName(): string;
-    GREEDY_MULTIPLIER: number;
-    MIN_SUBSTEPS: number;
-    supervisedSolvers?: Array<SupervisedSolver<T>>;
-    winningSolver?: T;
-    getHyperParameterDefs(): Array<HyperParameterDef>;
-    getCombinationDefs(): Array<Array<string>> | null;
-    getHyperParameterCombinations(hyperParameterDefs?: Array<HyperParameterDef>): Array<Record<string, any>>;
-    initializeSolvers(): void;
-    generateSolver(hyperParameters: any): T;
-    computeG(solver: T): number;
-    computeH(solver: T): number;
-    computeF(g: number, h: number): number;
-    getSupervisedSolverWithBestFitness(): SupervisedSolver<T> | null;
-    getFailureMessage(): string;
+    nodeWithPortPoints: NodeWithPortPoints;
+    traceWidth: number;
+    viaDiameter: number;
+    solvedRoutes: HighDensityIntraNodeRoute$1[];
+    constructor(params: {
+        nodeWithPortPoints: NodeWithPortPoints;
+        traceWidth?: number;
+        viaDiameter?: number;
+    });
+    static isApplicable(node: NodeWithPortPoints): boolean;
+    private buildTaskGroups;
+    private trySolveNode;
     _step(): void;
-    onSolve(solver: SupervisedSolver<T>): void;
     visualize(): GraphicsObject;
 }
 
@@ -1344,23 +1321,17 @@ type Point$6 = {
     z?: number;
 };
 type Route$3 = {
-    startPort: Point$6;
-    endPort: Point$6;
+    A: Point$6;
+    B: Point$6;
     connectionName: string;
 };
-declare class TwoCrossingRoutesHighDensitySolver extends BaseSolver {
+declare class SingleTransitionIntraNodeSolver extends BaseSolver {
     getSolverName(): string;
     nodeWithPortPoints: NodeWithPortPoints;
     routes: Route$3[];
     viaDiameter: number;
     traceThickness: number;
     obstacleMargin: number;
-    layerCount: number;
-    debugViaPositions: {
-        via1: Point$6;
-        via2: Point$6;
-    }[];
-    escapeLayer: number;
     solvedRoutes: HighDensityIntraNodeRoute$1[];
     bounds: {
         minX: number;
@@ -1373,52 +1344,67 @@ declare class TwoCrossingRoutesHighDensitySolver extends BaseSolver {
         viaDiameter?: number;
         traceThickness?: number;
         obstacleMargin?: number;
-        layerCount?: number;
     });
-    /**
-     * Extract routes that need to be connected from the node data
-     */
     private extractRoutesFromNode;
-    /**
-     * Calculate the bounding box of the node
-     */
     private calculateBounds;
-    /**
-     * Check if two routes are crossing
-     */
-    private doRoutesCross;
-    private calculateViaPositions;
-    /**
-     * Try to solve with routeA going over and routeB staying on layer 0
-     */
-    private trySolveAOverB;
-    private pushViasFromEndpoints;
-    private getMinDistanceBetweenViaCenters;
-    private moveViasAsCloseAsPossible;
-    handleRoutesDontCross(): void;
-    /**
-     * Main step method that attempts to solve the two crossing routes
-     */
+    private createTransitionRoute;
     _step(): void;
-    /**
-     * Visualization for debugging
-     */
     visualize(): GraphicsObject;
-    /**
-     * Get the solved routes
-     */
-    getSolvedRoutes(): HighDensityIntraNodeRoute$1[];
 }
 
 type Point$5 = {
     x: number;
     y: number;
     z?: number;
+    rootConnectionName?: string;
 };
 type Route$2 = {
     A: Point$5;
     B: Point$5;
     connectionName: string;
+    rootConnectionName?: string;
+};
+type LayeredObstacle = Obstacle & {
+    zLayers: number[];
+};
+declare class SingleTransitionThroughObstacleIntraNodeSolver extends BaseSolver {
+    getSolverName(): string;
+    nodeWithPortPoints: NodeWithPortPoints;
+    routes: Route$2[];
+    obstacles: LayeredObstacle[];
+    viaDiameter: number;
+    traceThickness: number;
+    connMap?: ConnectivityMap;
+    solvedRoutes: HighDensityIntraNodeRoute$1[];
+    constructor(params: {
+        nodeWithPortPoints: NodeWithPortPoints;
+        obstacles?: Obstacle[];
+        connMap?: ConnectivityMap;
+        layerCount?: number;
+        viaDiameter?: number;
+        traceThickness?: number;
+    });
+    static isApplicable(params: {
+        nodeWithPortPoints: NodeWithPortPoints;
+        obstacles?: Obstacle[];
+        connMap?: ConnectivityMap;
+        layerCount?: number;
+    }): boolean;
+    private extractRoutesFromNode;
+    private getContainingThroughObstacle;
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+type Point$4 = {
+    x: number;
+    y: number;
+    z?: number;
+};
+type Route$1 = {
+    A: Point$4;
+    B: Point$4;
+    connectionName: string;
 };
 /**
  * Solver for exactly two crossing routes where exactly one route transitions
@@ -1431,13 +1417,13 @@ type Route$2 = {
 declare class SingleTransitionCrossingRouteSolver extends BaseSolver {
     getSolverName(): string;
     nodeWithPortPoints: NodeWithPortPoints;
-    routes: Route$2[];
+    routes: Route$1[];
     viaDiameter: number;
     traceThickness: number;
     obstacleMargin: number;
     layerCount: number;
     debugViaPositions: {
-        via: Point$5;
+        via: Point$4;
     }[];
     solvedRoutes: HighDensityIntraNodeRoute$1[];
     bounds: {
@@ -1497,23 +1483,29 @@ declare class SingleTransitionCrossingRouteSolver extends BaseSolver {
     getSolvedRoutes(): HighDensityIntraNodeRoute$1[];
 }
 
-type Point$4 = {
+type Point$3 = {
     x: number;
     y: number;
     z?: number;
 };
-type Route$1 = {
-    A: Point$4;
-    B: Point$4;
+type Route = {
+    startPort: Point$3;
+    endPort: Point$3;
     connectionName: string;
 };
-declare class SingleTransitionIntraNodeSolver extends BaseSolver {
+declare class TwoCrossingRoutesHighDensitySolver extends BaseSolver {
     getSolverName(): string;
     nodeWithPortPoints: NodeWithPortPoints;
-    routes: Route$1[];
+    routes: Route[];
     viaDiameter: number;
     traceThickness: number;
     obstacleMargin: number;
+    layerCount: number;
+    debugViaPositions: {
+        via1: Point$3;
+        via2: Point$3;
+    }[];
+    escapeLayer: number;
     solvedRoutes: HighDensityIntraNodeRoute$1[];
     bounds: {
         minX: number;
@@ -1526,132 +1518,83 @@ declare class SingleTransitionIntraNodeSolver extends BaseSolver {
         viaDiameter?: number;
         traceThickness?: number;
         obstacleMargin?: number;
-    });
-    private extractRoutesFromNode;
-    private calculateBounds;
-    private createTransitionRoute;
-    _step(): void;
-    visualize(): GraphicsObject;
-}
-
-type Point$3 = {
-    x: number;
-    y: number;
-    z?: number;
-    rootConnectionName?: string;
-};
-type Route = {
-    A: Point$3;
-    B: Point$3;
-    connectionName: string;
-    rootConnectionName?: string;
-};
-type LayeredObstacle = Obstacle & {
-    zLayers: number[];
-};
-declare class SingleTransitionThroughObstacleIntraNodeSolver extends BaseSolver {
-    getSolverName(): string;
-    nodeWithPortPoints: NodeWithPortPoints;
-    routes: Route[];
-    obstacles: LayeredObstacle[];
-    viaDiameter: number;
-    traceThickness: number;
-    connMap?: ConnectivityMap;
-    solvedRoutes: HighDensityIntraNodeRoute$1[];
-    constructor(params: {
-        nodeWithPortPoints: NodeWithPortPoints;
-        obstacles?: Obstacle[];
-        connMap?: ConnectivityMap;
         layerCount?: number;
-        viaDiameter?: number;
-        traceThickness?: number;
     });
-    static isApplicable(params: {
-        nodeWithPortPoints: NodeWithPortPoints;
-        obstacles?: Obstacle[];
-        connMap?: ConnectivityMap;
-        layerCount?: number;
-    }): boolean;
+    /**
+     * Extract routes that need to be connected from the node data
+     */
     private extractRoutesFromNode;
-    private getContainingThroughObstacle;
+    /**
+     * Calculate the bounding box of the node
+     */
+    private calculateBounds;
+    /**
+     * Check if two routes are crossing
+     */
+    private doRoutesCross;
+    private calculateViaPositions;
+    /**
+     * Try to solve with routeA going over and routeB staying on layer 0
+     */
+    private trySolveAOverB;
+    private pushViasFromEndpoints;
+    private getMinDistanceBetweenViaCenters;
+    private moveViasAsCloseAsPossible;
+    handleRoutesDontCross(): void;
+    /**
+     * Main step method that attempts to solve the two crossing routes
+     */
     _step(): void;
+    /**
+     * Visualization for debugging
+     */
     visualize(): GraphicsObject;
+    /**
+     * Get the solved routes
+     */
+    getSolvedRoutes(): HighDensityIntraNodeRoute$1[];
 }
 
-type ViaRegion = {
-    viaRegionId: string;
-    center: {
-        x: number;
-        y: number;
-    };
-    diameter: number;
-    connectedTo: string[];
+type SupervisedSolver<T extends BaseSolver> = {
+    hyperParameters: any;
+    solver: T;
+    h: number;
+    g: number;
+    f: number;
 };
-type HighDensityIntraNodeRouteWithVias = HighDensityIntraNodeRoute$1 & {
-    viaRegions: ViaRegion[];
+type HyperParameterDef = {
+    name: string;
+    possibleValues: Array<any>;
 };
-interface FixedTopologyHighDensityIntraNodeSolverParams {
-    nodeWithPortPoints: NodeWithPortPoints;
-    colorMap?: Record<string, string>;
-    traceWidth?: number;
-    connMap?: ConnectivityMap;
-    effort?: number;
-}
 /**
- * Routes intra-node traces using a fixed via-topology grid and the hypergraph
- * via solver.
+ * The HyperParameterSupervisorSolver is a solver that solves a problem by
+ * running competing solvers with different hyperparameters.
+ *
+ * As solvers make progress, the supervisor will allow the best solvers to run
+ * for more iterations, prioritizing the solvers that are working the best.
  */
-declare class FixedTopologyHighDensityIntraNodeSolver extends BaseSolver {
-    getSolverName(): string;
-    constructorParams: FixedTopologyHighDensityIntraNodeSolverParams;
-    nodeWithPortPoints: NodeWithPortPoints;
-    colorMap: Record<string, string>;
-    traceWidth: number;
-    connMap?: ConnectivityMap;
-    rootConnectionNameByConnectionId: Map<string, string | undefined>;
-    lastActiveSubSolver: FixedViaHypergraphSolver | null;
-    solvedRoutes: HighDensityIntraNodeRouteWithVias[];
-    vias: ViaRegion[];
-    constructor(params: FixedTopologyHighDensityIntraNodeSolverParams);
-    getConstructorParams(): FixedTopologyHighDensityIntraNodeSolverParams;
-    private _getBottomLayerZ;
-    private _getViaTileDiameter;
-    private _initializeGraph;
-    _step(): void;
-    private _upsertGlobalVia;
-    private _upsertRouteViaRegion;
-    private _appendRoutePoint;
-    private _parseViaRegionNetName;
-    private _parseViaRegionTilePrefix;
-    private _selectViasForTraversedRegion;
-    private _findNearestVia;
-    private _getBottomRoutePointsBetweenVias;
-    private _appendViaUsage;
-    private _processResults;
-    getOutput(): HighDensityIntraNodeRouteWithVias[];
-    getOutputVias(): ViaRegion[];
-    visualize(): GraphicsObject;
-}
-
-declare class SingleLayerNoDifferentRootIntersectionsIntraNodeSolver extends BaseSolver {
+declare class HyperParameterSupervisorSolver<T extends BaseSolver> extends BaseSolver {
     getSolverName(): string;
-    nodeWithPortPoints: NodeWithPortPoints;
-    traceWidth: number;
-    viaDiameter: number;
-    solvedRoutes: HighDensityIntraNodeRoute$1[];
-    constructor(params: {
-        nodeWithPortPoints: NodeWithPortPoints;
-        traceWidth?: number;
-        viaDiameter?: number;
-    });
-    static isApplicable(node: NodeWithPortPoints): boolean;
-    private buildTaskGroups;
-    private trySolveNode;
+    GREEDY_MULTIPLIER: number;
+    MIN_SUBSTEPS: number;
+    supervisedSolvers?: Array<SupervisedSolver<T>>;
+    winningSolver?: T;
+    getHyperParameterDefs(): Array<HyperParameterDef>;
+    getCombinationDefs(): Array<Array<string>> | null;
+    getHyperParameterCombinations(hyperParameterDefs?: Array<HyperParameterDef>): Array<Record<string, any>>;
+    initializeSolvers(): void;
+    generateSolver(hyperParameters: any): T;
+    computeG(solver: T): number;
+    computeH(solver: T): number;
+    computeF(g: number, h: number): number;
+    getSupervisedSolverWithBestFitness(): SupervisedSolver<T> | null;
+    getFailureMessage(): string;
     _step(): void;
+    onSolve(solver: SupervisedSolver<T>): void;
     visualize(): GraphicsObject;
 }
 
-declare class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<IntraNodeRouteSolver | TwoCrossingRoutesHighDensitySolver | SingleTransitionCrossingRouteSolver | SingleTransitionIntraNodeSolver | SingleTransitionThroughObstacleIntraNodeSolver | FixedTopologyHighDensityIntraNodeSolver | SingleLayerNoDifferentRootIntersectionsIntraNodeSolver | HighDensitySolverA03> {
+declare class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<IntraNodeRouteSolver | TwoCrossingRoutesHighDensitySolver | SingleTransitionCrossingRouteSolver | SingleTransitionIntraNodeSolver | SingleTransitionThroughObstacleIntraNodeSolver | SingleLayerNoDifferentRootIntersectionsIntraNodeSolver | HighDensitySolverA03> {
     getSolverName(): string;
     constructorParams: ConstructorParameters<typeof CachedIntraNodeRouteSolver>[0];
     solvedRoutes: HighDensityIntraNodeRoute$1[];
@@ -1733,11 +1676,6 @@ declare class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<
         possibleValues: {
             HIGH_DENSITY_A01: boolean;
         }[];
-    } | {
-        name: string;
-        possibleValues: {
-            FIXED_TOPOLOGY_HIGH_DENSITY_INTRA_NODE_SOLVER: boolean;
-        }[];
     } | {
         name: string;
         possibleValues: {