@tscircuit/capacity-autorouter 0.0.9 → 0.0.11

package/dist/index.d.ts

@@ -28,6 +28,7 @@ interface Obstacle {
 }
 interface SimpleRouteConnection {
     name: string;
+    netConnectionName?: string;
     pointsToConnect: Array<{
         x: number;
         y: number;
@@ -35,7 +36,7 @@ interface SimpleRouteConnection {
         pcb_port_id?: string;
     }>;
 }
-type SimplifiedPcbTraces = Array<{
+interface SimplifiedPcbTrace {
     type: "pcb_trace";
     pcb_trace_id: TraceId;
     connection_name: string;
@@ -52,7 +53,8 @@ type SimplifiedPcbTraces = Array<{
         to_layer: string;
         from_layer: string;
     }>;
-}>;
+}
+type SimplifiedPcbTraces = Array<SimplifiedPcbTrace>;
 
 type CapacityMeshNodeId = string;
 interface CapacityMeshNode {
@@ -489,7 +491,7 @@ declare class SingleHighDensityRouteSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-declare class SingleIntraNodeRouteSolver extends BaseSolver {
+declare class IntraNodeRouteSolver extends BaseSolver {
     nodeWithPortPoints: NodeWithPortPoints;
     colorMap: Record<string, string>;
     unsolvedConnections: {
@@ -554,11 +556,11 @@ declare class HyperParameterSupervisorSolver<T extends BaseSolver> extends BaseS
     visualize(): GraphicsObject;
 }
 
-declare class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<SingleIntraNodeRouteSolver> {
-    constructorParams: ConstructorParameters<typeof SingleIntraNodeRouteSolver>[0];
+declare class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<IntraNodeRouteSolver> {
+    constructorParams: ConstructorParameters<typeof IntraNodeRouteSolver>[0];
     solvedRoutes: HighDensityIntraNodeRoute[];
     nodeWithPortPoints: NodeWithPortPoints;
-    constructor(opts: ConstructorParameters<typeof SingleIntraNodeRouteSolver>[0]);
+    constructor(opts: ConstructorParameters<typeof IntraNodeRouteSolver>[0]);
     getCombinationDefs(): string[][];
     getHyperParameterDefs(): ({
         name: string;
@@ -597,20 +599,20 @@ declare class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<
             VIA_PENALTY_FACTOR_2: number;
         }[];
     })[];
-    computeG(solver: SingleIntraNodeRouteSolver): number;
-    computeH(solver: SingleIntraNodeRouteSolver): number;
-    generateSolver(hyperParameters: any): SingleIntraNodeRouteSolver;
-    onSolve(solver: SupervisedSolver<SingleIntraNodeRouteSolver>): void;
+    computeG(solver: IntraNodeRouteSolver): number;
+    computeH(solver: IntraNodeRouteSolver): number;
+    generateSolver(hyperParameters: any): IntraNodeRouteSolver;
+    onSolve(solver: SupervisedSolver<IntraNodeRouteSolver>): void;
 }
 
-declare class HighDensityRouteSolver extends BaseSolver {
+declare class HighDensitySolver extends BaseSolver {
     unsolvedNodePortPoints: NodeWithPortPoints[];
     routes: HighDensityIntraNodeRoute[];
     colorMap: Record<string, string>;
     readonly defaultViaDiameter = 0.6;
     readonly defaultTraceThickness = 0.15;
-    failedSolvers: (SingleIntraNodeRouteSolver | HyperSingleIntraNodeSolver)[];
-    activeSubSolver: SingleIntraNodeRouteSolver | HyperSingleIntraNodeSolver | null;
+    failedSolvers: (IntraNodeRouteSolver | HyperSingleIntraNodeSolver)[];
+    activeSubSolver: IntraNodeRouteSolver | HyperSingleIntraNodeSolver | null;
     connMap?: ConnectivityMap;
     constructor({ nodePortPoints, colorMap, connMap, }: {
         nodePortPoints: NodeWithPortPoints[];
@@ -625,6 +627,29 @@ declare class HighDensityRouteSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+declare class CapacityPathingSolver4_FlexibleNegativeCapacity extends CapacityPathingSolver {
+    NEGATIVE_CAPACITY_PENALTY_FACTOR: number;
+    REDUCED_CAPACITY_PENALTY_FACTOR: number;
+    get maxCapacityFactor(): number;
+    /**
+     * In the FlexibleNegativeCapacity mode, we allow negative capacity
+     */
+    doesNodeHaveCapacityForTrace(node: CapacityMeshNode): boolean;
+    getTotalCapacity(node: CapacityMeshNode): number;
+    /**
+     * Penalty you pay for using this node
+     */
+    getNodeCapacityPenalty(node: CapacityMeshNode): number;
+    /**
+     * We're rewarding travel into big nodes.
+     *
+     * To minimize shortest path, you'd want to comment this out.
+     */
+    getDistanceBetweenNodes(A: CapacityMeshNode, B: CapacityMeshNode): number;
+    computeG(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+    computeH(prevCandidate: Candidate, node: CapacityMeshNode, endGoal: CapacityMeshNode): number;
+}
+
 declare class CapacityNodeTargetMerger extends BaseSolver {
     nodes: CapacityMeshNode[];
     connMap: ConnectivityMap;
@@ -798,10 +823,73 @@ declare class NetToPointPairsSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+declare class SingleHighDensityRouteStitchSolver extends BaseSolver {
+    mergedHdRoute: HighDensityIntraNodeRoute;
+    remainingHdRoutes: HighDensityIntraNodeRoute[];
+    start: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    end: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    constructor(opts: {
+        hdRoutes: HighDensityIntraNodeRoute[];
+        start: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        end: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    });
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+type UnsolvedRoute = {
+    connectionName: string;
+    hdRoutes: HighDensityIntraNodeRoute[];
+    start: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    end: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+declare class MultipleHighDensityRouteStitchSolver extends BaseSolver {
+    unsolvedRoutes: UnsolvedRoute[];
+    activeSolver: SingleHighDensityRouteStitchSolver | null;
+    mergedHdRoutes: HighDensityIntraNodeRoute[];
+    constructor(opts: {
+        connections: SimpleRouteConnection[];
+        hdRoutes: HighDensityIntraNodeRoute[];
+        layerCount: number;
+    });
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
 interface CapacityMeshSolverOptions {
     capacityDepth?: number;
     targetMinCapacity?: number;
 }
+type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
+    solverName: string;
+    solverClass: T;
+    getConstructorParams: (instance: CapacityMeshSolver) => ConstructorParameters<T>;
+    onSolved?: (instance: CapacityMeshSolver) => void;
+};
 declare class CapacityMeshSolver extends BaseSolver {
     srj: SimpleRouteJson;
     opts: CapacityMeshSolverOptions;
@@ -814,22 +902,20 @@ declare class CapacityMeshSolver extends BaseSolver {
     colorMap: Record<string, string>;
     segmentToPointSolver?: CapacitySegmentToPointSolver;
     segmentToPointOptimizer?: CapacitySegmentPointOptimizer;
-    highDensityRouteSolver?: HighDensityRouteSolver;
+    highDensityRouteSolver?: HighDensitySolver;
+    highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
+    startTimeOfPhase: Record<string, number>;
+    endTimeOfPhase: Record<string, number>;
+    timeSpentOnPhase: Record<string, number>;
     activeSolver?: BaseSolver | null;
     connMap: ConnectivityMap;
+    srjWithPointPairs?: SimpleRouteJson;
+    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver> | PipelineStep<typeof CapacityNodeTargetMerger> | PipelineStep<typeof CapacityMeshEdgeSolver> | PipelineStep<typeof CapacityPathingSolver4_FlexibleNegativeCapacity> | PipelineStep<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep<typeof CapacitySegmentToPointSolver> | PipelineStep<typeof CapacitySegmentPointOptimizer> | PipelineStep<typeof HighDensitySolver> | PipelineStep<typeof MultipleHighDensityRouteStitchSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions);
+    currentPipelineStepIndex: number;
     _step(): void;
+    getCurrentPhase(): string;
     visualize(): GraphicsObject;
-    /**
-     * Simplifies a route by merging consecutive points along the same line
-     */
-    private simplifyRoute;
-    /**
-     * Maps numeric layer to named layer
-     * @param layer Numeric layer (0, 1, etc)
-     * @returns Named layer ("top", "bottom", etc)
-     */
-    private mapLayer;
     /**
      * Get original connection name from connection name with MST suffix
      * @param mstConnectionName The MST-suffixed connection name (e.g. "connection1_mst0")
@@ -839,6 +925,7 @@ declare class CapacityMeshSolver extends BaseSolver {
     /**
      * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
      */
+    getOutputSimplifiedPcbTraces(): SimplifiedPcbTraces;
     getOutputSimpleRouteJson(): SimpleRouteJson;
 }