@tscircuit/capacity-autorouter 0.0.61 → 0.0.63

package/dist/index.js

@@ -3721,8 +3721,54 @@ function seededRandom(seed) {
     return result - Math.floor(result);
   };
 }
+var PRESHUFFLED_CASES = {
+  1: [[0]],
+  2: [
+    [0, 1],
+    [1, 0]
+  ],
+  3: [
+    [0, 1, 2],
+    [2, 0, 1],
+    [1, 0, 2],
+    [0, 2, 1],
+    [1, 2, 0],
+    [2, 1, 0]
+  ],
+  4: [
+    [0, 1, 2, 3],
+    [2, 0, 1, 3],
+    [1, 3, 2, 0],
+    [3, 0, 1, 2],
+    [0, 2, 1, 3],
+    [2, 1, 3, 0],
+    [3, 0, 2, 1],
+    [1, 2, 0, 3],
+    [3, 1, 0, 2],
+    [0, 3, 2, 1],
+    [2, 3, 0, 1],
+    [2, 3, 1, 0],
+    [1, 2, 3, 0],
+    [3, 1, 2, 0],
+    [0, 1, 3, 2],
+    [0, 2, 3, 1],
+    [0, 3, 1, 2],
+    [1, 0, 2, 3],
+    [1, 0, 3, 2],
+    [1, 3, 0, 2],
+    [2, 0, 3, 1],
+    [2, 1, 0, 3],
+    [3, 2, 0, 1],
+    [3, 2, 1, 0]
+  ]
+};
 function cloneAndShuffleArray(arr, seed) {
   if (seed === 0) return arr;
+  if (arr.length <= 4) {
+    const preshuffledOptions = PRESHUFFLED_CASES[arr.length];
+    const preshuffledCase = preshuffledOptions[seed % preshuffledOptions.length];
+    return preshuffledCase.map((orderIndex) => arr[orderIndex]);
+  }
   const random = seededRandom(seed);
   const shuffled = arr.slice();
   for (let i = 0; i < shuffled.length; i++) {
@@ -3897,7 +3943,12 @@ var IntraNodeRouteSolver = class extends BaseSolver {
         y: points[points.length - 1].y,
         z: points[points.length - 1].z
       },
-      obstacleRoutes: this.solvedRoutes,
+      obstacleRoutes: this.connMap ? this.solvedRoutes.filter(
+        (sr) => !this.connMap.areIdsConnected(
+          sr.connectionName,
+          connectionName
+        )
+      ) : this.solvedRoutes,
       futureConnections: this.unsolvedConnections,
       layerCount: 2,
       hyperParameters: this.hyperParameters,
@@ -8837,9 +8888,11 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
   constructorParams;
   solvedRoutes = [];
   nodeWithPortPoints;
+  connMap;
   constructor(opts) {
     super();
     this.nodeWithPortPoints = opts.nodeWithPortPoints;
+    this.connMap = opts.connMap;
     this.constructorParams = opts;
     this.MAX_ITERATIONS = 25e4;
     this.GREEDY_MULTIPLIER = 5;
@@ -8983,6 +9036,7 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
     if (hyperParameters.MULTI_HEAD_POLYLINE_SOLVER) {
       return new MultiHeadPolyLineIntraNodeSolver3({
         nodeWithPortPoints: this.nodeWithPortPoints,
+        connMap: this.connMap,
         hyperParameters
       });
     }
@@ -9071,7 +9125,7 @@ var HighDensitySolver = class extends BaseSolver {
       if (this.failedSolvers.length > 0) {
         this.solved = false;
         this.failed = true;
-        this.error = `Failed to solve ${this.failedSolvers.length} nodes, ${this.failedSolvers.slice(0, 5).map((fs) => fs.nodeWithPortPoints.capacityMeshNodeId)}`;
+        this.error = `Failed to solve ${this.failedSolvers.length} nodes, ${this.failedSolvers.slice(0, 5).map((fs) => fs.nodeWithPortPoints.capacityMeshNodeId)}. err0: ${this.failedSolvers[0].error}.`;
         return;
       }
       this.solved = true;
@@ -10929,6 +10983,8 @@ import objectHash from "object-hash";
 
 // lib/cache/InMemoryCache.ts
 var InMemoryCache = class {
+  cacheHitsByPrefix = {};
+  cacheMissesByPrefix = {};
   isSyncCache = true;
   cacheHits = 0;
   cacheMisses = 0;
@@ -10994,6 +11050,8 @@ var LocalStorageCache = class {
   isSyncCache = true;
   cacheHits = 0;
   cacheMisses = 0;
+  cacheHitsByPrefix = {};
+  cacheMissesByPrefix = {};
   constructor() {
     if (typeof localStorage === "undefined") {
       console.warn(
@@ -11018,14 +11076,20 @@ var LocalStorageCache = class {
       if (cachedItem !== null) {
         const solution = JSON.parse(cachedItem);
         this.cacheHits++;
+        const prefix = cacheKey.split(":")[0];
+        this.cacheHitsByPrefix[prefix] = (this.cacheHitsByPrefix[prefix] || 0) + 1;
         return solution;
       } else {
         this.cacheMisses++;
+        const prefix = cacheKey.split(":")[0];
+        this.cacheMissesByPrefix[prefix] = (this.cacheMissesByPrefix[prefix] || 0) + 1;
         return void 0;
       }
     } catch (error) {
       console.error(`Error getting cached solution sync for ${key}:`, error);
       this.cacheMisses++;
+      const prefix = cacheKey.split(":")[0];
+      this.cacheMissesByPrefix[prefix] = (this.cacheMissesByPrefix[prefix] || 0) + 1;
       return void 0;
     }
   }
@@ -11090,6 +11154,8 @@ var LocalStorageCache = class {
     } finally {
       this.cacheHits = 0;
       this.cacheMisses = 0;
+      this.cacheHitsByPrefix = {};
+      this.cacheMissesByPrefix = {};
     }
   }
   getAllCacheKeys() {
@@ -11111,6 +11177,12 @@ function getGlobalLocalStorageCache() {
   }
   return globalThis.TSCIRCUIT_AUTOROUTER_LOCAL_STORAGE_CACHE;
 }
+function getGlobalInMemoryCache() {
+  if (!globalThis.TSCIRCUIT_AUTOROUTER_IN_MEMORY_CACHE) {
+    setupGlobalCaches();
+  }
+  return globalThis.TSCIRCUIT_AUTOROUTER_IN_MEMORY_CACHE;
+}
 function setupGlobalCaches() {
   globalThis.TSCIRCUIT_AUTOROUTER_LOCAL_STORAGE_CACHE ??= new LocalStorageCache();
   globalThis.TSCIRCUIT_AUTOROUTER_IN_MEMORY_CACHE ??= new InMemoryCache();
@@ -12513,6 +12585,21 @@ var calculateNodeProbabilityOfFailure2 = (usedCapacity, totalCapacity, layerCoun
   const adjustedRatio = ratioOverTotal - 1;
   return 1 - Math.exp(-k * adjustedRatio);
 };
+var calculateSingleNodeLogSuccessProbability = (usedCapacity, totalCapacity, node) => {
+  if (node._containsTarget) return 0;
+  if (usedCapacity <= totalCapacity) return 0;
+  const probabilityOfFailure = calculateNodeProbabilityOfFailure2(
+    usedCapacity,
+    totalCapacity,
+    node.availableZ.length
+  );
+  const probabilityOfSuccess = 1 - probabilityOfFailure;
+  if (probabilityOfSuccess <= 0) {
+    return -1e9;
+  } else {
+    return Math.log(probabilityOfSuccess);
+  }
+};
 var computeSectionScore = ({
   totalNodeCapacityMap,
   usedNodeCapacityMap,
@@ -12526,21 +12613,13 @@ var computeSectionScore = ({
     if (!totalNodeCapacityMap.has(nodeId)) continue;
     const node = nodeMap.get(nodeId);
     if (!node) continue;
-    if (node._containsTarget) continue;
     const totalCapacity = totalNodeCapacityMap.get(nodeId);
     const usedCapacity = usedNodeCapacityMap.get(nodeId) ?? 0;
-    if (usedCapacity <= totalCapacity) continue;
-    const probabilityOfFailure = calculateNodeProbabilityOfFailure2(
+    logProbabilityOfSuccessSum += calculateSingleNodeLogSuccessProbability(
       usedCapacity,
       totalCapacity,
-      node.availableZ.length
+      node
     );
-    const probabilityOfSuccess = 1 - probabilityOfFailure;
-    if (probabilityOfSuccess <= 0) {
-      logProbabilityOfSuccessSum += -1e9;
-    } else {
-      logProbabilityOfSuccessSum += Math.log(probabilityOfSuccess);
-    }
   }
   return logProbabilityOfSuccessSum;
 };
@@ -12721,9 +12800,9 @@ ${percent}% (Pf: ${(probabilityOfFailure * 100).toFixed(1)}%)`;
             x: x + offset.x,
             y: y + offset.y
           })),
-          strokeColor: safeTransparentize(pathColor, 0.2),
+          strokeColor: safeTransparentize(pathColor, 0.2)
           // Make solved paths semi-transparent
-          strokeWidth: 0.03
+          // strokeWidth: 0.03,
         });
       }
     });
@@ -12731,6 +12810,72 @@ ${percent}% (Pf: ${(probabilityOfFailure * 100).toFixed(1)}%)`;
   return graphics;
 }
 
+// lib/solvers/CapacityPathingSectionSolver/computeSectionNodesTerminalsAndEdges.ts
+var computeSectionNodesTerminalsAndEdges = (opts) => {
+  const {
+    centerNodeId,
+    connectionsWithNodes,
+    nodeMap,
+    edges,
+    nodeEdgeMap,
+    expansionDegrees
+  } = opts;
+  const sectionNodeIds = /* @__PURE__ */ new Set();
+  const queue = [
+    { nodeId: centerNodeId, depth: 0 }
+  ];
+  sectionNodeIds.add(centerNodeId);
+  let head = 0;
+  while (head < queue.length) {
+    const { nodeId, depth } = queue[head++];
+    if (depth >= expansionDegrees) continue;
+    const neighbors = nodeEdgeMap.get(nodeId)?.flatMap((edge) => edge.nodeIds.filter((id) => id !== nodeId)) ?? [];
+    for (const neighborId of neighbors) {
+      if (!sectionNodeIds.has(neighborId)) {
+        sectionNodeIds.add(neighborId);
+        queue.push({ nodeId: neighborId, depth: depth + 1 });
+      }
+    }
+  }
+  const sectionNodes = Array.from(sectionNodeIds).map((id) => nodeMap.get(id));
+  const sectionEdges = edges.filter((edge) => {
+    const [nodeIdA, nodeIdB] = edge.nodeIds;
+    return sectionNodeIds.has(nodeIdA) && sectionNodeIds.has(nodeIdB);
+  });
+  const sectionConnectionTerminals = [];
+  for (const conn of connectionsWithNodes) {
+    if (!conn.path) continue;
+    let startNodeId = null;
+    let endNodeId = null;
+    for (const node of conn.path) {
+      if (sectionNodeIds.has(node.capacityMeshNodeId)) {
+        startNodeId = node.capacityMeshNodeId;
+        break;
+      }
+    }
+    for (let i = conn.path.length - 1; i >= 0; i--) {
+      const node = conn.path[i];
+      if (sectionNodeIds.has(node.capacityMeshNodeId)) {
+        endNodeId = node.capacityMeshNodeId;
+        break;
+      }
+    }
+    if (startNodeId && endNodeId) {
+      sectionConnectionTerminals.push({
+        connectionName: conn.connection.name,
+        startNodeId,
+        endNodeId
+      });
+    }
+  }
+  return {
+    sectionConnectionTerminals,
+    sectionNodes,
+    sectionEdges,
+    centerNodeId
+  };
+};
+
 // lib/solvers/CapacityPathingSectionSolver/CapacityPathingSingleSectionSolver.ts
 var CapacityPathingSingleSectionSolver = class extends BaseSolver {
   GREEDY_MULTIPLIER = 1.5;
@@ -12744,7 +12889,10 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
   colorMap;
   usedNodeCapacityMap;
   // Tracks capacity usage *within this solver's run*
+  totalNodeCapacityMap;
+  // Added: Stores total capacity for each node
   centerNodeId;
+  currentSectionScore = 0;
   MAX_CANDIDATES_IN_MEMORY = 1e4;
   // A* state
   currentConnectionIndex = 0;
@@ -12765,14 +12913,28 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
     this.sectionConnectionTerminals = params.sectionConnectionTerminals.map(
       (t) => ({ ...t, path: void 0 })
     );
-    this.nodeMap = new Map(
-      this.sectionNodes.map((n) => [n.capacityMeshNodeId, n])
-    );
+    this.nodeMap = params.nodeMap ?? new Map(this.sectionNodes.map((n) => [n.capacityMeshNodeId, n]));
     this.nodeEdgeMap = params.nodeEdgeMap ?? getNodeEdgeMap(this.sectionEdges);
     this.colorMap = params.colorMap ?? {};
     this.usedNodeCapacityMap = new Map(
       this.sectionNodes.map((node) => [node.capacityMeshNodeId, 0])
     );
+    this.totalNodeCapacityMap = new Map(
+      this.sectionNodes.map((node) => [
+        node.capacityMeshNodeId,
+        this.getTotalCapacity(node)
+      ])
+    );
+    const initialSectionNodeIds = new Set(
+      this.sectionNodes.map((n) => n.capacityMeshNodeId)
+    );
+    this.currentSectionScore = computeSectionScore({
+      totalNodeCapacityMap: this.totalNodeCapacityMap,
+      usedNodeCapacityMap: this.usedNodeCapacityMap,
+      // Reflects initial capacities
+      nodeMap: this.nodeMap,
+      sectionNodeIds: initialSectionNodeIds
+    });
     if (params.hyperParameters?.SHUFFLE_SEED) {
       this.sectionConnectionTerminals = cloneAndShuffleArray(
         this.sectionConnectionTerminals,
@@ -12852,15 +13014,40 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
   }
   // Adapted from CapacityPathingSolver - uses section's capacity map
   reduceCapacityAlongPath(path) {
-    for (const node of path) {
-      if (this.usedNodeCapacityMap.has(node.capacityMeshNodeId)) {
-        this.usedNodeCapacityMap.set(
-          node.capacityMeshNodeId,
-          (this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0) + 1
+    for (const pathNode of path) {
+      if (this.usedNodeCapacityMap.has(pathNode.capacityMeshNodeId)) {
+        const nodeId = pathNode.capacityMeshNodeId;
+        const nodeInSection = this.nodeMap.get(nodeId);
+        if (!nodeInSection) {
+          console.warn(
+            `Node ${nodeId} from path not found in section's nodeMap during score update.`
+          );
+          continue;
+        }
+        const totalCapacity = this.totalNodeCapacityMap.get(nodeId);
+        const oldUsedCapacity = this.usedNodeCapacityMap.get(nodeId) ?? 0;
+        const oldNodeScoreContribution = calculateSingleNodeLogSuccessProbability(
+          oldUsedCapacity,
+          totalCapacity,
+          nodeInSection
+          // Use the node object from the section's map
         );
+        this.currentSectionScore -= oldNodeScoreContribution;
+        const newUsedCapacity = oldUsedCapacity + 1;
+        this.usedNodeCapacityMap.set(nodeId, newUsedCapacity);
+        const newNodeScoreContribution = calculateSingleNodeLogSuccessProbability(
+          newUsedCapacity,
+          totalCapacity,
+          nodeInSection
+          // Use the node object from the section's map
+        );
+        this.currentSectionScore += newNodeScoreContribution;
       }
     }
   }
+  getSolvedSectionScore() {
+    return this.currentSectionScore;
+  }
   _step() {
     const currentTerminal = this.sectionConnectionTerminals[this.currentConnectionIndex];
     if (!currentTerminal) {
@@ -13062,6 +13249,7 @@ var CapacityPathingSingleSectionSolver = class extends BaseSolver {
 var CapacityPathingSingleSectionPathingSolver = CapacityPathingSingleSectionSolver;
 
 // lib/solvers/CapacityPathingSectionSolver/HyperCapacityPathingSingleSectionSolver.ts
+var range = (n) => Array.from({ length: n }, (_, i) => i);
 var HyperCapacityPathingSingleSectionSolver = class extends HyperParameterSupervisorSolver {
   constructorParams;
   winningSolver;
@@ -13070,14 +13258,24 @@ var HyperCapacityPathingSingleSectionSolver = class extends HyperParameterSuperv
     this.MAX_ITERATIONS = 1e5;
     this.constructorParams = params;
   }
+  // TODO this needs to use the section score, ideally incorporating the current best candidate
+  // of the paths being explored inside the single section
   computeG(solver) {
-    return solver.iterations / 100;
+    return -solver.getSolvedSectionScore();
   }
   computeH(solver) {
-    return solver.computeProgress();
+    return 0;
   }
   getCombinationDefs() {
-    return [["orderings10"]];
+    const numConnections = this.constructorParams.sectionConnectionTerminals.length;
+    if (numConnections === 2) {
+      return [["orderings2_for2"]];
+    } else if (numConnections === 3) {
+      return [["orderings6_for3"]];
+    } else if (numConnections === 4) {
+      return [["orderings24_for4"]];
+    }
+    return [["orderings30"]];
   }
   getFailureMessage() {
     return `All CapacityPathingSingleSection solvers failed for "${this.centerNodeId}"`;
@@ -13085,39 +13283,28 @@ var HyperCapacityPathingSingleSectionSolver = class extends HyperParameterSuperv
   getHyperParameterDefs() {
     return [
       {
-        name: "orderings10",
-        possibleValues: [
-          {
-            SHUFFLE_SEED: 0
-          },
-          {
-            SHUFFLE_SEED: 1
-          },
-          {
-            SHUFFLE_SEED: 2
-          },
-          {
-            SHUFFLE_SEED: 3
-          },
-          {
-            SHUFFLE_SEED: 4
-          },
-          {
-            SHUFFLE_SEED: 5
-          },
-          {
-            SHUFFLE_SEED: 6
-          },
-          {
-            SHUFFLE_SEED: 7
-          },
-          {
-            SHUFFLE_SEED: 8
-          },
-          {
-            SHUFFLE_SEED: 9
-          }
-        ]
+        name: "orderings2_for2",
+        possibleValues: range(2).map((i) => ({
+          SHUFFLE_SEED: i
+        }))
+      },
+      {
+        name: "orderings6_for3",
+        possibleValues: range(6).map((i) => ({
+          SHUFFLE_SEED: i
+        }))
+      },
+      {
+        name: "orderings24_for4",
+        possibleValues: range(24).map((i) => ({
+          SHUFFLE_SEED: i
+        }))
+      },
+      {
+        name: "orderings30",
+        possibleValues: range(30).map((i) => ({
+          SHUFFLE_SEED: i
+        }))
       }
     ];
   }
@@ -13146,70 +13333,320 @@ var HyperCapacityPathingSingleSectionSolver = class extends HyperParameterSuperv
   }
 };
 
-// lib/solvers/CapacityPathingSectionSolver/computeSectionNodesTerminalsAndEdges.ts
-var computeSectionNodesTerminalsAndEdges = (opts) => {
-  const {
-    centerNodeId,
-    connectionsWithNodes,
-    nodeMap,
-    edges,
-    nodeEdgeMap,
-    expansionDegrees
-  } = opts;
-  const sectionNodeIds = /* @__PURE__ */ new Set();
-  const queue = [
-    { nodeId: centerNodeId, depth: 0 }
-  ];
-  sectionNodeIds.add(centerNodeId);
-  let head = 0;
-  while (head < queue.length) {
-    const { nodeId, depth } = queue[head++];
-    if (depth >= expansionDegrees) continue;
-    const neighbors = nodeEdgeMap.get(nodeId)?.flatMap((edge) => edge.nodeIds.filter((id) => id !== nodeId)) ?? [];
-    for (const neighborId of neighbors) {
-      if (!sectionNodeIds.has(neighborId)) {
-        sectionNodeIds.add(neighborId);
-        queue.push({ nodeId: neighborId, depth: depth + 1 });
-      }
+// lib/solvers/CapacityPathingSectionSolver/CachedHyperCapacityPathingSingleSectionSolver.ts
+import objectHash2 from "object-hash";
+var roundCapacity = (capacity) => Math.floor(capacity * 10) / 10;
+var CachedHyperCapacityPathingSingleSectionSolver = class extends HyperCapacityPathingSingleSectionSolver {
+  cacheHit = false;
+  cacheProvider;
+  hasAttemptedToUseCache = false;
+  sectionNodeIdSet;
+  cachedSectionConnectionTerminals = null;
+  sectionScore = 0;
+  constructor(params) {
+    params.nodeMap = params.nodeMap ?? new Map(params.sectionNodes.map((n) => [n.capacityMeshNodeId, n]));
+    super(params);
+    this.sectionNodeIdSet = new Set(
+      params.sectionNodes.map((sn) => sn.capacityMeshNodeId)
+    );
+    this.cacheProvider = params.cacheProvider === void 0 ? getGlobalInMemoryCache() : params.cacheProvider;
+  }
+  _step() {
+    if (!this.hasAttemptedToUseCache && this.cacheProvider) {
+      if (this.attemptToUseCacheSync()) return;
+    }
+    super._step();
+    if ((this.solved || this.failed) && this.cacheProvider) {
+      this.saveToCacheSync();
     }
   }
-  const sectionNodes = Array.from(sectionNodeIds).map((id) => nodeMap.get(id));
-  const sectionEdges = edges.filter((edge) => {
-    const [nodeIdA, nodeIdB] = edge.nodeIds;
-    return sectionNodeIds.has(nodeIdA) && sectionNodeIds.has(nodeIdB);
-  });
-  const sectionConnectionTerminals = [];
-  for (const conn of connectionsWithNodes) {
-    if (!conn.path) continue;
-    let startNodeId = null;
-    let endNodeId = null;
-    for (const node of conn.path) {
-      if (sectionNodeIds.has(node.capacityMeshNodeId)) {
-        startNodeId = node.capacityMeshNodeId;
-        break;
+  _computeBfsOrderingOfNodesInSection() {
+    const seenNodeIds = new Set(this.constructorParams.centerNodeId);
+    const ordering = [];
+    const candidates = [
+      {
+        ancestorCapacitySum: 0,
+        capacity: 0,
+        g: 0,
+        capacityMeshNodeId: this.constructorParams.centerNodeId
+      }
+    ];
+    while (candidates.length > 0) {
+      candidates.sort((a, b) => b.g - a.g);
+      const candidate = candidates.pop();
+      if (!candidate) break;
+      ordering.push(candidate.capacityMeshNodeId);
+      const neighborNodeIds = this.constructorParams.nodeEdgeMap.get(candidate.capacityMeshNodeId).flatMap((edge) => edge.nodeIds).filter((nodeId) => !seenNodeIds.has(nodeId)).filter((nodeId) => this.sectionNodeIdSet.has(nodeId));
+      for (const neighborNodeId of neighborNodeIds) {
+        seenNodeIds.add(neighborNodeId);
+        const neighbor = this.constructorParams.nodeMap.get(neighborNodeId);
+        const capacity = getTunedTotalCapacity1(neighbor);
+        candidates.push({
+          ancestorCapacitySum: candidate.g,
+          capacity,
+          g: candidate.g + capacity,
+          capacityMeshNodeId: neighborNodeId
+        });
       }
     }
-    for (let i = conn.path.length - 1; i >= 0; i--) {
-      const node = conn.path[i];
-      if (sectionNodeIds.has(node.capacityMeshNodeId)) {
-        endNodeId = node.capacityMeshNodeId;
-        break;
+    return ordering;
+  }
+  computeCacheKeyAndTransform() {
+    const nodeOrdering = this._computeBfsOrderingOfNodesInSection();
+    const realToCacheSpaceNodeIdMap = /* @__PURE__ */ new Map();
+    const cacheSpaceToRealNodeIdMap = /* @__PURE__ */ new Map();
+    nodeOrdering.forEach((realNodeId, i) => {
+      const cacheNodeId = `node${i}`;
+      realToCacheSpaceNodeIdMap.set(realNodeId, cacheNodeId);
+      cacheSpaceToRealNodeIdMap.set(cacheNodeId, realNodeId);
+    });
+    const node_capacity_map = {};
+    for (const realNodeId of nodeOrdering) {
+      const cacheNodeId = realToCacheSpaceNodeIdMap.get(realNodeId);
+      const node = this.constructorParams.nodeMap.get(realNodeId);
+      const capacity = getTunedTotalCapacity1(node);
+      node_capacity_map[cacheNodeId] = roundCapacity(capacity).toFixed(
+        1
+      );
+    }
+    const node_edge_map_set = /* @__PURE__ */ new Set();
+    const node_edge_map = [];
+    for (const realNodeId1 of nodeOrdering) {
+      const cacheNodeId1 = realToCacheSpaceNodeIdMap.get(realNodeId1);
+      const neighbors = this.constructorParams.nodeEdgeMap.get(realNodeId1) ?? [];
+      for (const edge of neighbors) {
+        const realNodeId2 = edge.nodeIds.find((id) => id !== realNodeId1);
+        if (this.sectionNodeIdSet.has(realNodeId2)) {
+          const cacheNodeId2 = realToCacheSpaceNodeIdMap.get(realNodeId2);
+          const pair = [cacheNodeId1, cacheNodeId2].sort();
+          const pairKey = `${pair[0]}-${pair[1]}`;
+          if (!node_edge_map_set.has(pairKey)) {
+            node_edge_map.push(pair);
+            node_edge_map_set.add(pairKey);
+          }
+        }
       }
     }
-    if (startNodeId && endNodeId) {
-      sectionConnectionTerminals.push({
-        connectionName: conn.connection.name,
-        startNodeId,
-        endNodeId
+    node_edge_map.sort((a, b) => {
+      if (a[0] !== b[0]) return a[0].localeCompare(b[0]);
+      return a[1].localeCompare(b[1]);
+    });
+    const terminals = {};
+    const cacheSpaceToRealConnectionId = /* @__PURE__ */ new Map();
+    for (const conn of this.constructorParams.sectionConnectionTerminals) {
+      const cacheStartNodeId = realToCacheSpaceNodeIdMap.get(conn.startNodeId);
+      const cacheEndNodeId = realToCacheSpaceNodeIdMap.get(conn.endNodeId);
+      const [sortedStartId, sortedEndId] = [
+        cacheStartNodeId,
+        cacheEndNodeId
+      ].sort();
+      const cacheSpaceConnectionId = `${sortedStartId}->${sortedEndId}`;
+      terminals[cacheSpaceConnectionId] = {
+        start: sortedStartId,
+        end: sortedEndId
+      };
+      cacheSpaceToRealConnectionId.set(
+        cacheSpaceConnectionId,
+        // Use the canonically sorted key
+        conn.connectionName
+      );
+    }
+    const cacheKeyContent = {
+      node_capacity_map,
+      node_edge_map,
+      terminals
+    };
+    const cacheKey = `capacitypathing:${objectHash2(cacheKeyContent)}`;
+    const cacheToSolveSpaceTransform = {
+      cacheSpaceToRealConnectionId,
+      cacheSpaceToRealNodeId: cacheSpaceToRealNodeIdMap
+    };
+    this.cacheKey = cacheKey;
+    this.cacheToSolveSpaceTransform = cacheToSolveSpaceTransform;
+    return { cacheKey, cacheToSolveSpaceTransform };
+  }
+  applyCachedSolution(cachedSolution) {
+    if (!this.cacheToSolveSpaceTransform) {
+      console.error(
+        "Cache transform not available, cannot apply cached solution."
+      );
+      this.failed = true;
+      return;
+    }
+    if (!cachedSolution.success) {
+      this.failed = true;
+      this.cacheHit = true;
+      return;
+    }
+    this.cachedSectionConnectionTerminals = [];
+    const { cacheSpaceToRealNodeId, cacheSpaceToRealConnectionId } = this.cacheToSolveSpaceTransform;
+    for (const [cacheConnId, cachePathNodeIds] of Object.entries(
+      cachedSolution.solutionPaths
+    )) {
+      const realConnectionName = cacheSpaceToRealConnectionId.get(
+        cacheConnId
+      );
+      if (!realConnectionName) {
+        console.warn(`Could not find real connection name for ${cacheConnId}`);
+        continue;
+      }
+      const originalTerminal = this.constructorParams.sectionConnectionTerminals.find(
+        (t) => t.connectionName === realConnectionName
+      );
+      if (!originalTerminal) {
+        console.warn(
+          `Could not find original terminal for connection name ${realConnectionName}`
+        );
+        continue;
+      }
+      const realPathNodes = cachePathNodeIds.map(
+        (cacheNodeId) => {
+          const realNodeId = cacheSpaceToRealNodeId.get(cacheNodeId);
+          if (!realNodeId) {
+            throw new Error(
+              `Could not map cache node ID ${cacheNodeId} to real node ID for connection ${realConnectionName}`
+            );
+          }
+          const node = this.constructorParams.nodeMap.get(realNodeId);
+          if (!node) {
+            throw new Error(
+              `Could not find node with ID ${realNodeId} in nodeMap for connection ${realConnectionName}`
+            );
+          }
+          return node;
+        }
+      );
+      this.cachedSectionConnectionTerminals.push({
+        ...originalTerminal,
+        path: realPathNodes
       });
     }
+    this.sectionScore = cachedSolution.sectionScore;
+    this.solved = true;
+    this.cacheHit = true;
+  }
+  attemptToUseCacheSync() {
+    this.hasAttemptedToUseCache = true;
+    if (!this.cacheProvider?.isSyncCache) {
+      console.log(
+        "Cache provider is not synchronous, skipping sync cache check."
+      );
+      return false;
+    }
+    if (!this.cacheKey) {
+      this.computeCacheKeyAndTransform();
+    }
+    if (!this.cacheKey) {
+      console.error("Failed to compute cache key.");
+      return false;
+    }
+    try {
+      const cachedSolution = this.cacheProvider.getCachedSolutionSync(
+        this.cacheKey
+      );
+      if (cachedSolution) {
+        this.applyCachedSolution(
+          cachedSolution
+        );
+        return true;
+      }
+    } catch (error) {
+      console.error("Error attempting to use cache:", error);
+    }
+    return false;
+  }
+  saveToCacheSync() {
+    if (!this.cacheKey) {
+      console.error("Cannot save to cache without cache key.");
+      return;
+    }
+    if (!this.cacheToSolveSpaceTransform) {
+      console.error(
+        "Cache transform not available, cannot save solution to cache."
+      );
+      return;
+    }
+    let cachedSolution;
+    if (this.failed) {
+      cachedSolution = { success: false };
+    } else if (this.solved) {
+      const solutionPathsInCacheSpace = {};
+      const { cacheSpaceToRealNodeId, cacheSpaceToRealConnectionId } = this.cacheToSolveSpaceTransform;
+      const realToCacheSpaceNodeId = /* @__PURE__ */ new Map();
+      for (const [cacheId, realId] of cacheSpaceToRealNodeId) {
+        realToCacheSpaceNodeId.set(realId, cacheId);
+      }
+      const realToCacheSpaceConnectionId = /* @__PURE__ */ new Map();
+      for (const [cacheConnId, realConnName] of cacheSpaceToRealConnectionId) {
+        realToCacheSpaceConnectionId.set(realConnName, cacheConnId);
+      }
+      const realSolutionPaths = [];
+      if (super.sectionConnectionTerminals) {
+        for (const terminal of super.sectionConnectionTerminals) {
+          if (terminal.path && terminal.path.length > 0) {
+            const realPathNodeIds = terminal.path.map(
+              (node) => node.capacityMeshNodeId
+            );
+            realSolutionPaths.push([terminal.connectionName, realPathNodeIds]);
+          }
+        }
+      }
+      for (const [realConnectionName, realPathNodeIds] of realSolutionPaths) {
+        const cacheConnectionId = realToCacheSpaceConnectionId.get(realConnectionName);
+        if (!cacheConnectionId) {
+          console.warn(
+            `Could not find cache space connection ID for ${realConnectionName} when saving to cache.`
+          );
+          continue;
+        }
+        const cachePathNodeIds = realPathNodeIds.map((realNodeId) => {
+          const cacheNodeId = realToCacheSpaceNodeId.get(realNodeId);
+          if (!cacheNodeId) {
+            throw new Error(
+              `Could not map real node ID ${realNodeId} to cache node ID for connection ${realConnectionName} when saving to cache.`
+            );
+          }
+          return cacheNodeId;
+        });
+        solutionPathsInCacheSpace[cacheConnectionId] = cachePathNodeIds;
+      }
+      cachedSolution = {
+        success: true,
+        sectionScore: this.sectionScore,
+        solutionPaths: solutionPathsInCacheSpace
+      };
+    } else {
+      return;
+    }
+    try {
+      this.cacheProvider?.setCachedSolutionSync(this.cacheKey, cachedSolution);
+    } catch (error) {
+      console.error("Error saving solution to cache:", error);
+    }
+  }
+  get sectionConnectionTerminals() {
+    if (this.cacheHit && this.solved && this.cachedSectionConnectionTerminals) {
+      console.log("returning the cached section connection terminals");
+      return this.cachedSectionConnectionTerminals;
+    }
+    return super.sectionConnectionTerminals;
+  }
+  visualize() {
+    if (!this.cacheHit) return super.visualize();
+    const graphics = visualizeSection({
+      sectionNodes: this.constructorParams.sectionNodes,
+      sectionEdges: this.constructorParams.sectionEdges,
+      sectionConnectionTerminals: this.cachedSectionConnectionTerminals,
+      completedPaths: this.cachedSectionConnectionTerminals.map((t) => ({
+        connectionName: t.connectionName,
+        path: t.path
+      })),
+      nodeMap: this.constructorParams.nodeMap,
+      colorMap: this.constructorParams.colorMap,
+      title: "CachedHyperCapacityPathingSingleSectionSolver"
+    });
+    return graphics;
   }
-  return {
-    sectionConnectionTerminals,
-    sectionNodes,
-    sectionEdges,
-    centerNodeId
-  };
 };
 
 // lib/solvers/CapacityPathingSectionSolver/CapacityPathingMultiSectionSolver.ts
@@ -13222,8 +13659,10 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   // Initialize here
   colorMap;
   initialSolver;
+  cacheProvider;
   stage = "initialization";
   nodeMap = /* @__PURE__ */ new Map();
+  allNodeIdsSet;
   usedNodeCapacityMap = /* @__PURE__ */ new Map();
   totalNodeCapacityMap = /* @__PURE__ */ new Map();
   // Added
@@ -13233,16 +13672,22 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   sectionSolver = null;
   currentScheduleIndex = 0;
   stats;
+  // Adjusting this schedule is a trade-off between optimization speed and quality.
   OPTIMIZATION_SCHEDULE = [
     {
       MAX_ATTEMPTS_PER_NODE: 1,
-      MAX_EXPANSION_DEGREES: 5,
-      MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: 0.1
+      MAX_EXPANSION_DEGREES: 3,
+      MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: 0.05
     },
     {
       MAX_ATTEMPTS_PER_NODE: 2,
-      MAX_EXPANSION_DEGREES: 3,
-      MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: 0.05
+      MAX_EXPANSION_DEGREES: 5,
+      MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: 0.2
+    },
+    {
+      MAX_ATTEMPTS_PER_NODE: 3,
+      MAX_EXPANSION_DEGREES: 7,
+      MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE: 0.9
     }
   ];
   get currentSchedule() {
@@ -13254,6 +13699,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
       successfulOptimizations: 0,
       failedOptimizations: 0,
       failedSectionSolvers: 0,
+      startingScore: 0,
       scheduleScores: this.OPTIMIZATION_SCHEDULE.map(
         ({ MAX_EXPANSION_DEGREES }) => ({
           maxExpansionDegrees: MAX_EXPANSION_DEGREES,
@@ -13264,6 +13710,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
       )
     };
     this.MAX_ITERATIONS = 1e7;
+    this.cacheProvider = params.cacheProvider;
     this.simpleRouteJson = params.simpleRouteJson;
     this.nodes = params.nodes;
     this.edges = params.edges;
@@ -13284,6 +13731,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
       const totalCapacity = this.initialSolver.getTotalCapacity(node);
       this.totalNodeCapacityMap.set(node.capacityMeshNodeId, totalCapacity);
     }
+    this.allNodeIdsSet = new Set(this.nodes.map((n) => n.capacityMeshNodeId));
   }
   _stepInitialization() {
     this.initialSolver?.step();
@@ -13302,6 +13750,12 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
         this.nodeOptimizationAttemptCountMap.set(node.capacityMeshNodeId, 0);
       }
       this.connectionsWithNodes = this.initialSolver.connectionsWithNodes;
+      this.stats.startingScore = computeSectionScore({
+        totalNodeCapacityMap: this.totalNodeCapacityMap,
+        usedNodeCapacityMap: this.usedNodeCapacityMap,
+        nodeMap: this.nodeMap,
+        sectionNodeIds: this.allNodeIdsSet
+      });
       this.stage = "section-optimization";
     }
   }
@@ -13353,9 +13807,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
         totalNodeCapacityMap: this.totalNodeCapacityMap,
         usedNodeCapacityMap: this.usedNodeCapacityMap,
         nodeMap: this.nodeMap,
-        sectionNodeIds: new Set(
-          this.nodes.map((node) => node.capacityMeshNodeId)
-        )
+        sectionNodeIds: this.allNodeIdsSet
       })
     };
   }
@@ -13383,13 +13835,17 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
       });
       this.stats.scheduleScores[this.currentScheduleIndex].sectionAttempts++;
       this.currentSection = section;
-      this.sectionSolver = new HyperCapacityPathingSingleSectionSolver({
+      this.sectionSolver = new CachedHyperCapacityPathingSingleSectionSolver({
         sectionNodes: this.currentSection.sectionNodes,
         sectionEdges: this.currentSection.sectionEdges,
         sectionConnectionTerminals: this.currentSection.sectionConnectionTerminals,
         colorMap: this.colorMap,
         centerNodeId: this.currentSection.centerNodeId,
-        nodeEdgeMap: this.nodeEdgeMap
+        nodeEdgeMap: this.nodeEdgeMap,
+        hyperParameters: {
+          EXPANSION_DEGREES: this.currentSchedule.MAX_EXPANSION_DEGREES
+        },
+        cacheProvider: this.cacheProvider
       });
       this.activeSubSolver = this.sectionSolver;
       this.nodeOptimizationAttemptCountMap.set(
@@ -13409,18 +13865,19 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
       return;
     }
     if (this.sectionSolver.solved) {
-      const solvedSectionSolver = this.sectionSolver;
-      const pathingSolver = solvedSectionSolver?.activeSubSolver || solvedSectionSolver;
+      const sectionConnectionTerminals = this.sectionSolver.sectionConnectionTerminals;
+      const sectionNodes = this.sectionSolver.sectionNodes;
+      const centerNodeId = this.sectionSolver.centerNodeId;
       this.sectionSolver = null;
       this.activeSubSolver = null;
-      if (!pathingSolver || !pathingSolver.solved) {
+      if (!sectionConnectionTerminals) {
         console.warn(
           `Pathing sub-solver for section ${this.currentSection.centerNodeId} did not complete successfully. Discarding results.`
         );
         return;
       }
       const sectionNodeIds = new Set(
-        solvedSectionSolver.sectionNodes.map((n) => n.capacityMeshNodeId)
+        sectionNodes.map((n) => n.capacityMeshNodeId)
       );
       const beforeScore = computeSectionScore({
         totalNodeCapacityMap: this.totalNodeCapacityMap,
@@ -13429,7 +13886,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
         sectionNodeIds
       });
       const afterUsedCapacityMap = new Map(this.usedNodeCapacityMap);
-      const newSectionPaths = pathingSolver.sectionConnectionTerminals;
+      const newSectionPaths = sectionConnectionTerminals;
       for (const terminal of newSectionPaths) {
         const originalConnection = this.connectionsWithNodes.find(
           (conn) => conn.connection.name === terminal.connectionName
@@ -13466,7 +13923,10 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
       });
       if (afterScore > beforeScore) {
         this.stats.successfulOptimizations++;
-        this._mergeSolvedSectionPaths(solvedSectionSolver);
+        this._mergeSolvedSectionPaths({
+          centerNodeId,
+          sectionConnectionTerminals
+        });
         this._recalculateNodeCapacityUsage();
       } else {
         this.stats.failedOptimizations++;
@@ -13477,16 +13937,11 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
    * Merges the paths found by a successful section solver back into the main
    * connectionsWithNodes list.
    */
-  _mergeSolvedSectionPaths(solvedSectionSolver) {
-    const centerNodeId = solvedSectionSolver.centerNodeId;
-    if (!solvedSectionSolver || !solvedSectionSolver.solved) {
-      console.warn(
-        `Pathing sub-solver for section ${centerNodeId} did not complete successfully. Skipping merge.`
-      );
-      return;
-    }
-    const solvedTerminals = solvedSectionSolver.sectionConnectionTerminals;
-    for (const solvedTerminal of solvedTerminals) {
+  _mergeSolvedSectionPaths({
+    centerNodeId,
+    sectionConnectionTerminals
+  }) {
+    for (const solvedTerminal of sectionConnectionTerminals) {
       if (!solvedTerminal.path) {
         console.warn(
           `No path found for connection ${solvedTerminal.connectionName} in section ${centerNodeId}`
@@ -13498,7 +13953,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
       );
       if (!originalConnection || !originalConnection.path) {
         console.warn(
-          `Original connection or path not found for ${solvedTerminal.connectionName} while merging section ${solvedSectionSolver.centerNodeId}`
+          `Original connection or path not found for ${solvedTerminal.connectionName} while merging section ${centerNodeId}`
         );
         continue;
       }
@@ -15845,7 +16300,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
     }
     this.connMap = getConnectivityMapFromSimpleRouteJson(srj);
     this.colorMap = getColorMap(srj, this.connMap);
-    this.cacheProvider = opts.cacheProvider ?? null;
+    this.cacheProvider = opts.cacheProvider === void 0 ? getGlobalInMemoryCache() : opts.cacheProvider === null ? null : opts.cacheProvider;
     this.startTimeOfPhase = {};
     this.endTimeOfPhase = {};
     this.timeSpentOnPhase = {};
@@ -15969,6 +16424,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
           nodes: cms.capacityNodes,
           edges: cms.edgeSolver?.edges || [],
           colorMap: cms.colorMap,
+          cacheProvider: cms.cacheProvider,
           hyperParameters: {
             MAX_CAPACITY_FACTOR: 1
           }
@@ -16311,7 +16767,12 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
 var CapacityMeshSolver = AutoroutingPipelineSolver;
 export {
   CapacityMeshSolver,
+  InMemoryCache,
+  LocalStorageCache,
   calculateOptimalCapacityDepth,
-  getTunedTotalCapacity1
+  getGlobalInMemoryCache,
+  getGlobalLocalStorageCache,
+  getTunedTotalCapacity1,
+  setupGlobalCaches
 };
 //# sourceMappingURL=index.js.map