@tscircuit/capacity-autorouter 0.0.59 → 0.0.61

package/dist/index.d.ts

@@ -101,7 +101,7 @@ declare class BaseSolver {
     activeSubSolver?: BaseSolver | null;
     failedSubSolvers?: BaseSolver[];
     timeToSolve?: number;
-    stats: Record<string, number>;
+    stats: Record<string, any>;
     /**
      * For cached solvers
      **/
@@ -1250,6 +1250,7 @@ interface CacheProvider {
     getCachedSolution(cacheKey: string): Promise<any>;
     setCachedSolutionSync(cacheKey: string, cachedSolution: any): void;
     setCachedSolution(cacheKey: string, cachedSolution: any): Promise<void>;
+    getAllCacheKeys(): string[];
     clearCache(): void;
 }
 
@@ -1522,18 +1523,37 @@ declare class CapacityPathingMultiSectionSolver extends BaseSolver {
     nodeOptimizationAttemptCountMap: Map<CapacityMeshNodeId, number>;
     currentSection: CapacityPathingSection | null;
     sectionSolver?: CapacityPathingSingleSectionSolver | HyperCapacityPathingSingleSectionSolver | null;
-    MAX_ATTEMPTS_PER_NODE: number;
-    MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: number;
-    MAX_EXPANSION_DEGREES: number;
+    currentScheduleIndex: number;
     stats: {
         successfulOptimizations: number;
         failedOptimizations: number;
+        failedSectionSolvers: number;
+        scheduleScores: Array<{
+            maxExpansionDegrees: number;
+            sectionAttempts: number;
+            endingScore: number;
+            endingHighestNodePf: number;
+        }>;
+    };
+    OPTIMIZATION_SCHEDULE: {
+        MAX_ATTEMPTS_PER_NODE: number;
+        MAX_EXPANSION_DEGREES: number;
+        MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: number;
+    }[];
+    get currentSchedule(): {
+        MAX_ATTEMPTS_PER_NODE: number;
+        MAX_EXPANSION_DEGREES: number;
+        MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: number;
     };
     constructor(params: ConstructorParameters<typeof CapacityPathingSolver>[0] & {
         initialPathingSolver?: CapacityPathingGreedySolver;
     });
     _stepInitialization(): void;
     _getNextNodeToOptimize(): CapacityMeshNodeId | null;
+    getOverallScore(): {
+        highestNodePf: number;
+        score: number;
+    };
     _stepSectionOptimization(): void;
     /**
      * Merges the paths found by a successful section solver back into the main

package/dist/index.js

@@ -68,7 +68,7 @@ var BaseSolver = class {
       throw e;
     }
     if (!this.solved && this.iterations > this.MAX_ITERATIONS) {
-      this.error = `${this.constructor.name} did not converge`;
+      this.error = `${this.constructor.name} ran out of iterations`;
       console.error(this.error);
       this.failed = true;
     }
@@ -10983,6 +10983,9 @@ var InMemoryCache = class {
     this.cacheHits = 0;
     this.cacheMisses = 0;
   }
+  getAllCacheKeys() {
+    return Array.from(this.cache.keys());
+  }
 };
 
 // lib/cache/LocalStorageCache.ts
@@ -11089,6 +11092,16 @@ var LocalStorageCache = class {
       this.cacheMisses = 0;
     }
   }
+  getAllCacheKeys() {
+    const cacheKeys = [];
+    for (let i = 0; i < 1e4; i++) {
+      const keyName = localStorage.key(i);
+      if (!keyName) break;
+      if (!keyName.includes(CACHE_PREFIX)) continue;
+      cacheKeys.push(keyName);
+    }
+    return cacheKeys;
+  }
 };
 
 // lib/cache/setupGlobalCaches.ts
@@ -12718,7 +12731,7 @@ ${percent}% (Pf: ${(probabilityOfFailure * 100).toFixed(1)}%)`;
   return graphics;
 }
 
-// lib/solvers/CapacityPathingSectionSolver/CapacityPathingSingleSectionPathingSolver.ts
+// lib/solvers/CapacityPathingSectionSolver/CapacityPathingSingleSectionSolver.ts
 var CapacityPathingSingleSectionSolver = class extends BaseSolver {
   GREEDY_MULTIPLIER = 1.5;
   sectionNodes;
@@ -12745,6 +12758,7 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
   // Default, similar to CapacityPathingSolver5
   constructor(params) {
     super();
+    this.MAX_ITERATIONS = 1e4;
     this.centerNodeId = params.centerNodeId;
     this.sectionNodes = params.sectionNodes;
     this.sectionEdges = params.sectionEdges;
@@ -13053,7 +13067,7 @@ var HyperCapacityPathingSingleSectionSolver = class extends HyperParameterSuperv
   winningSolver;
   constructor(params) {
     super();
-    this.MAX_ITERATIONS = 1e4;
+    this.MAX_ITERATIONS = 1e5;
     this.constructorParams = params;
   }
   computeG(solver) {
@@ -13217,15 +13231,37 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   nodeOptimizationAttemptCountMap = /* @__PURE__ */ new Map();
   currentSection = null;
   sectionSolver = null;
-  MAX_ATTEMPTS_PER_NODE = 1;
-  MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE = 0.05;
-  MAX_EXPANSION_DEGREES = 5;
+  currentScheduleIndex = 0;
   stats;
+  OPTIMIZATION_SCHEDULE = [
+    {
+      MAX_ATTEMPTS_PER_NODE: 1,
+      MAX_EXPANSION_DEGREES: 5,
+      MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: 0.1
+    },
+    {
+      MAX_ATTEMPTS_PER_NODE: 2,
+      MAX_EXPANSION_DEGREES: 3,
+      MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: 0.05
+    }
+  ];
+  get currentSchedule() {
+    return this.OPTIMIZATION_SCHEDULE[this.currentScheduleIndex] ?? null;
+  }
   constructor(params) {
     super();
     this.stats = {
       successfulOptimizations: 0,
-      failedOptimizations: 0
+      failedOptimizations: 0,
+      failedSectionSolvers: 0,
+      scheduleScores: this.OPTIMIZATION_SCHEDULE.map(
+        ({ MAX_EXPANSION_DEGREES }) => ({
+          maxExpansionDegrees: MAX_EXPANSION_DEGREES,
+          endingScore: 0,
+          endingHighestNodePf: 0,
+          sectionAttempts: 0
+        })
+      )
     };
     this.MAX_ITERATIONS = 1e7;
     this.simpleRouteJson = params.simpleRouteJson;
@@ -13287,7 +13323,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
         node.availableZ.length
       );
       const nodePfDivAttempts = nodePf / (attemptCount + 1);
-      if (attemptCount < this.MAX_ATTEMPTS_PER_NODE && nodePfDivAttempts > highestNodePfDivAttempts && nodePf > this.MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE) {
+      if (attemptCount < this.currentSchedule.MAX_ATTEMPTS_PER_NODE && nodePfDivAttempts > highestNodePfDivAttempts && nodePf > this.currentSchedule.MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE) {
         highestNodePfDivAttempts = nodePfDivAttempts;
         highestNodePf = nodePf;
         nodeWithHighestPercentCapacityUsed = node.capacityMeshNodeId;
@@ -13295,11 +13331,45 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
     }
     return nodeWithHighestPercentCapacityUsed;
   }
+  getOverallScore() {
+    let highestNodePf = 0;
+    for (const node of this.nodes) {
+      if (node._containsTarget) continue;
+      const totalCapacity = this.totalNodeCapacityMap.get(
+        node.capacityMeshNodeId
+      );
+      const nodePf = calculateNodeProbabilityOfFailure2(
+        this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0,
+        totalCapacity,
+        node.availableZ.length
+      );
+      if (nodePf > highestNodePf) {
+        highestNodePf = nodePf;
+      }
+    }
+    return {
+      highestNodePf,
+      score: computeSectionScore({
+        totalNodeCapacityMap: this.totalNodeCapacityMap,
+        usedNodeCapacityMap: this.usedNodeCapacityMap,
+        nodeMap: this.nodeMap,
+        sectionNodeIds: new Set(
+          this.nodes.map((node) => node.capacityMeshNodeId)
+        )
+      })
+    };
+  }
   _stepSectionOptimization() {
     if (!this.sectionSolver) {
       const centerNodeId = this._getNextNodeToOptimize();
       if (!centerNodeId) {
-        this.solved = true;
+        const { highestNodePf, score } = this.getOverallScore();
+        this.stats.scheduleScores[this.currentScheduleIndex].endingHighestNodePf = highestNodePf;
+        this.stats.scheduleScores[this.currentScheduleIndex].endingScore = score;
+        this.currentScheduleIndex++;
+        if (!this.currentSchedule) {
+          this.solved = true;
+        }
         return;
       }
       const section = computeSectionNodesTerminalsAndEdges({
@@ -13307,16 +13377,18 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
         connectionsWithNodes: this.connectionsWithNodes,
         nodeMap: this.nodeMap,
         edges: this.edges,
-        expansionDegrees: this.MAX_EXPANSION_DEGREES,
+        expansionDegrees: this.currentSchedule.MAX_EXPANSION_DEGREES,
+        // Corrected
         nodeEdgeMap: this.nodeEdgeMap
       });
+      this.stats.scheduleScores[this.currentScheduleIndex].sectionAttempts++;
       this.currentSection = section;
       this.sectionSolver = new HyperCapacityPathingSingleSectionSolver({
-        sectionConnectionTerminals: section.sectionConnectionTerminals,
-        sectionEdges: section.sectionEdges,
-        sectionNodes: section.sectionNodes,
+        sectionNodes: this.currentSection.sectionNodes,
+        sectionEdges: this.currentSection.sectionEdges,
+        sectionConnectionTerminals: this.currentSection.sectionConnectionTerminals,
         colorMap: this.colorMap,
-        centerNodeId: section.centerNodeId,
+        centerNodeId: this.currentSection.centerNodeId,
         nodeEdgeMap: this.nodeEdgeMap
       });
       this.activeSubSolver = this.sectionSolver;
@@ -13330,6 +13402,8 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
       console.warn(
         `Section solver failed for node ${this.currentSection.centerNodeId}. Error: ${this.sectionSolver.error}`
       );
+      this.stats.failedSectionSolvers++;
+      this.stats.failedOptimizations++;
       this.sectionSolver = null;
       this.activeSubSolver = null;
       return;
@@ -15758,7 +15832,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
     super();
     this.srj = srj;
     this.opts = opts;
-    this.MAX_ITERATIONS = 1e7;
+    this.MAX_ITERATIONS = 1e8;
     if (opts.capacityDepth === void 0) {
       const boundsWidth = srj.bounds.maxX - srj.bounds.minX;
       const boundsHeight = srj.bounds.maxY - srj.bounds.minY;