@tscircuit/capacity-autorouter 0.0.54 → 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;
@@ -127,14 +128,24 @@ declare class CapacityMeshEdgeSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-type BucketCoordinate$1 = `${number}x${number}`;
+/**
+ * ObstacleTree wraps different spatial index implementations:
+ * - 'native': original spatial-hash grid
+ * - 'rbush': dynamic R-tree via rbush
+ * - 'flatbush': static index via flatbush
+ */
 declare class ObstacleSpatialHashIndex {
-    obstacles: Obstacle[];
-    buckets: Map<BucketCoordinate$1, [Obstacle, number][]>;
-    CELL_SIZE: number;
-    constructor(obstacles: Obstacle[]);
-    getBucketKey(x: number, y: number): BucketCoordinate$1;
-    getNodesInArea(centerX: number, centerY: number, width: number, height: number): Obstacle[];
+    private idx;
+    private storage;
+    constructor(implementation?: "native" | "rbush" | "flatbush", obstacles?: Obstacle[]);
+    insert(o: Obstacle): void;
+    search(bbox: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    }): Obstacle[];
+    searchArea(centerX: number, centerY: number, width: number, height: number): Obstacle[];
 }
 
 interface Target$1 {
@@ -606,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;
@@ -973,6 +985,16 @@ declare class SingleHighDensityRouteStitchSolver extends BaseSolver {
         };
         colorMap?: Record<string, string>;
     });
+    /**
+     * Scan `remainingHdRoutes` and find a route that has **one** end that is not
+     * within `5e-6` of the start or end of any other route on the same layer.
+     * That “lonely” end marks one extremity of the whole chain, which we use as
+     * our starting segment. If no such route exists (e.g., the data form a loop),
+     * we simply return the first route so the solver can proceed.
+     */
+    getDisjointedRoute(): {
+        firstRoute: HighDensityIntraNodeRoute$1;
+    };
     _step(): void;
     visualize(): GraphicsObject;
 }
@@ -1367,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[];
@@ -1383,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;
@@ -1408,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
@@ -1461,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;
@@ -1470,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;