@tscircuit/capacity-autorouter 0.0.55 → 0.0.56

package/dist/index.d.ts

@@ -101,6 +101,7 @@ declare class BaseSolver {
     activeSubSolver?: BaseSolver | null;
     failedSubSolvers?: BaseSolver[];
     timeToSolve?: number;
+    stats: Record<string, number>;
     /** DO NOT OVERRIDE! Override _step() instead */
     step(): void;
     _step(): void;
@@ -616,6 +617,7 @@ declare class HyperParameterSupervisorSolver<T extends BaseSolver> extends BaseS
     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;
@@ -1387,9 +1389,10 @@ interface CapacityPathingSingleSectionPathingSolverParams {
         endNodeId: CapacityMeshNodeId;
     }>;
     colorMap?: Record<string, string>;
+    centerNodeId: string;
     hyperParameters?: CpssPathingSolverHyperParameters;
 }
-declare class CapacityPathingSingleSectionPathingSolver extends BaseSolver {
+declare class CapacityPathingSingleSectionSolver extends BaseSolver {
     GREEDY_MULTIPLIER: number;
     sectionNodes: CapacityMeshNode[];
     sectionEdges: CapacityMeshEdge[];
@@ -1403,6 +1406,7 @@ declare class CapacityPathingSingleSectionPathingSolver extends BaseSolver {
     nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
     colorMap: Record<string, string>;
     usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
+    centerNodeId: string;
     MAX_CANDIDATES_IN_MEMORY: number;
     currentConnectionIndex: number;
     candidates?: Array<Candidate> | null;
@@ -1428,50 +1432,50 @@ declare class CapacityPathingSingleSectionPathingSolver extends BaseSolver {
     doesNodeHaveCapacityForTrace(node: CapacityMeshNode, prevNode: CapacityMeshNode | null): boolean;
     reduceCapacityAlongPath(path: CapacityMeshNode[]): void;
     _step(): void;
+    computeProgress(): number;
     private _setupAStar;
     private _handleCandidatesExhausted;
     private _handleGoalReached;
     visualize(): GraphicsObject;
 }
+declare const CapacityPathingSingleSectionPathingSolver: typeof CapacityPathingSingleSectionSolver;
+type CapacityPathingSingleSectionPathingSolver = InstanceType<typeof CapacityPathingSingleSectionSolver>;
 
-interface CapacityPathingSingleSectionSolverInput {
-    centerNodeId: CapacityMeshNodeId;
-    connectionsWithNodes: Array<ConnectionPathWithNodes>;
-    nodes: CapacityMeshNode[];
-    edges: CapacityMeshEdge[];
-    colorMap: Record<string, string>;
-    hyperParameters?: CpssPathingSolverHyperParameters;
-}
-declare class CapacityPathingSingleSectionSolver extends BaseSolver {
-    centerNodeId: CapacityMeshNodeId;
-    connectionsWithNodes: Array<ConnectionPathWithNodes>;
-    nodes: CapacityMeshNode[];
-    nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
-    edges: CapacityMeshEdge[];
-    nodeEdgeMap: Map<CapacityMeshNodeId, CapacityMeshEdge[]>;
-    expansionDegrees: number;
-    colorMap: Record<string, string>;
-    sectionNodes: CapacityMeshNode[];
-    sectionEdges: CapacityMeshEdge[];
-    sectionConnectionTerminals: Array<{
+declare class HyperCapacityPathingSingleSectionSolver extends HyperParameterSupervisorSolver<CapacityPathingSingleSectionPathingSolver> {
+    constructorParams: CapacityPathingSingleSectionPathingSolverParams;
+    winningSolver?: CapacityPathingSingleSectionPathingSolver;
+    constructor(params: ConstructorParameters<typeof CapacityPathingSingleSectionPathingSolver>[0]);
+    computeG(solver: CapacityPathingSingleSectionPathingSolver): number;
+    computeH(solver: CapacityPathingSingleSectionPathingSolver): number;
+    getCombinationDefs(): Array<Array<string>> | null;
+    getFailureMessage(): string;
+    getHyperParameterDefs(): Array<HyperParameterDef>;
+    generateSolver(hyperParameters: any): CapacityPathingSingleSectionPathingSolver;
+    onSolve({ solver, }: SupervisedSolver<CapacityPathingSingleSectionPathingSolver>): void;
+    get centerNodeId(): string;
+    get sectionNodes(): CapacityMeshNode[];
+    get sectionConnectionTerminals(): {
         connectionName: string;
         startNodeId: CapacityMeshNodeId;
         endNodeId: CapacityMeshNodeId;
-    }>;
-    activeSubSolver?: CapacityPathingSingleSectionPathingSolver | null | undefined;
-    constructor(params: CapacityPathingSingleSectionSolverInput);
-    private computeSectionNodesTerminalsAndEdges;
-    _step(): void;
-    getConstructorParams(): readonly [{
-        readonly centerNodeId: string;
-        readonly connectionsWithNodes: ConnectionPathWithNodes[];
-        readonly nodes: CapacityMeshNode[];
-        readonly edges: CapacityMeshEdge[];
-        readonly expansionDegrees: number;
-    }];
-    visualize(): GraphicsObject;
+        path?: CapacityMeshNode[];
+    }[] | undefined;
+}
+
+interface SectionConnectionTerminal {
+    connectionName: string;
+    startNodeId: CapacityMeshNodeId;
+    endNodeId: CapacityMeshNodeId;
+    path?: CapacityMeshNode[];
+}
+interface CapacityPathingSection {
+    centerNodeId: string;
+    sectionConnectionTerminals: SectionConnectionTerminal[];
+    sectionNodes: CapacityMeshNode[];
+    sectionEdges: CapacityMeshEdge[];
 }
 
+type CapacityMeshEdgeId = string;
 /**
  * This solver solves for capacity paths by first solving with negative
  * capacities allowed, then re-solving problematic sections with a section
@@ -1481,6 +1485,7 @@ declare class CapacityPathingMultiSectionSolver extends BaseSolver {
     simpleRouteJson: SimpleRouteJson;
     nodes: CapacityMeshNode[];
     edges: CapacityMeshEdge[];
+    nodeEdgeMap: Map<CapacityMeshEdgeId, CapacityMeshEdge[]>;
     connectionsWithNodes: Array<ConnectionPathWithNodes>;
     colorMap: Record<string, string>;
     initialSolver: CapacityPathingGreedySolver;
@@ -1490,7 +1495,8 @@ declare class CapacityPathingMultiSectionSolver extends BaseSolver {
     totalNodeCapacityMap: Map<CapacityMeshNodeId, number>;
     nodeCapacityPercentMap: Map<CapacityMeshNodeId, number>;
     nodeOptimizationAttemptCountMap: Map<CapacityMeshNodeId, number>;
-    sectionSolver?: CapacityPathingSingleSectionSolver | null;
+    currentSection: CapacityPathingSection | null;
+    sectionSolver?: CapacityPathingSingleSectionSolver | HyperCapacityPathingSingleSectionSolver | null;
     MAX_ATTEMPTS_PER_NODE: number;
     MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: number;
     MAX_EXPANSION_DEGREES: number;