@tscircuit/capacity-autorouter 0.0.58 → 0.0.60

package/dist/index.js

@@ -48,6 +48,12 @@ var BaseSolver = class {
   failedSubSolvers;
   timeToSolve;
   stats = {};
+  /**
+   * For cached solvers
+   **/
+  cacheHit;
+  cacheKey;
+  cacheToSolveSpaceTransform;
   /** DO NOT OVERRIDE! Override _step() instead */
   step() {
     if (this.solved) return;
@@ -8053,13 +8059,17 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
     return [newNeighbor];
   }
   checkIfSolved(candidate) {
-    return candidate.minGaps.every((minGap) => minGap >= this.obstacleMargin) && candidate.polyLines.every((polyLine) => {
+    const minGapsToOtherConnectionsValid = candidate.minGaps.every(
+      (minGap) => minGap >= this.obstacleMargin
+    );
+    const allPointsWithinBounds = candidate.polyLines.every((polyLine) => {
       return polyLine.mPoints.every((mPoint) => {
-        const padding = (mPoint.z1 !== mPoint.z2 ? this.viaDiameter / 2 : this.traceWidth / 2) * // Forgiveness outside bounds
+        const padding = (mPoint.z1 !== mPoint.z2 ? this.viaDiameter / 2 : 0) * // Forgiveness outside bounds
         0.9;
         return withinBounds(mPoint, this.bounds, padding);
       });
     });
+    return minGapsToOtherConnectionsValid && allPointsWithinBounds;
   }
   _step() {
     if (this.phase === "setup") {
@@ -10259,6 +10269,7 @@ var UnravelSectionSolver = class extends BaseSolver {
   tunedNodeCapacityMap;
   MAX_CANDIDATES = 500;
   iterationsSinceImprovement = 0;
+  hyperParameters;
   selectedCandidateIndex = null;
   queuedOrExploredCandidatePointModificationHashes = /* @__PURE__ */ new Set();
   constructorParams;
@@ -10267,6 +10278,10 @@ var UnravelSectionSolver = class extends BaseSolver {
     this.constructorParams = params;
     this.MUTABLE_HOPS = params.MUTABLE_HOPS ?? this.MUTABLE_HOPS;
     this.MAX_ITERATIONS = 5e4;
+    this.hyperParameters = {
+      ...params.hyperParameters,
+      MAX_ITERATIONS_WITHOUT_IMPROVEMENT: 200
+    };
     this.nodeMap = params.nodeMap;
     this.dedupedSegments = params.dedupedSegments;
     if (params.dedupedSegmentMap) {
@@ -10429,16 +10444,21 @@ var UnravelSectionSolver = class extends BaseSolver {
     });
     return {
       pointModifications,
-      issues,
       g,
       h: 0,
       f: g,
       operationsPerformed: 0,
-      candidateHash: createPointModificationsHash(pointModifications)
+      candidateHash: createPointModificationsHash(pointModifications),
       // candidateFullHash: createFullPointModificationsHash(
       //   this.unravelSection.segmentPointMap,
       //   pointModifications,
       // ),
+      // Ensure original candidate has issues calculated
+      issues: getIssuesInSection(
+        this.unravelSection,
+        this.nodeMap,
+        pointModifications
+      )
     };
   }
   get nextCandidate() {
@@ -10690,6 +10710,10 @@ var UnravelSectionSolver = class extends BaseSolver {
   _step() {
     const candidate = this.candidates.shift();
     this.iterationsSinceImprovement++;
+    if (this.iterationsSinceImprovement > this.hyperParameters.MAX_ITERATIONS_WITHOUT_IMPROVEMENT) {
+      this.solved = true;
+      return;
+    }
     if (!candidate) {
       this.solved = true;
       return;
@@ -10733,6 +10757,8 @@ var UnravelSectionSolver = class extends BaseSolver {
       } else {
         candidate = this.candidates[this.selectedCandidateIndex];
       }
+    } else if (this.solved) {
+      candidate = this.bestCandidate;
     } else {
       candidate = this.lastProcessedCandidate || this.candidates[0];
     }
@@ -10898,6 +10924,653 @@ New: (${modifiedPoint.x.toFixed(2)}, ${modifiedPoint.y.toFixed(2)}, ${modifiedPo
   }
 };
 
+// lib/solvers/UnravelSolver/CachedUnravelSectionSolver.ts
+import objectHash from "object-hash";
+
+// lib/cache/InMemoryCache.ts
+var InMemoryCache = class {
+  isSyncCache = true;
+  cacheHits = 0;
+  cacheMisses = 0;
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Retrieves a cached solution synchronously based on the cache key.
+   * Increments cache hit/miss counters.
+   * @param cacheKey The key to look up in the cache.
+   * @returns The cached solution if found, otherwise undefined.
+   */
+  getCachedSolutionSync(cacheKey) {
+    const cachedSolution = this.cache.get(cacheKey);
+    if (cachedSolution !== void 0) {
+      this.cacheHits++;
+      return structuredClone(cachedSolution);
+    } else {
+      this.cacheMisses++;
+      return void 0;
+    }
+  }
+  /**
+   * Retrieves a cached solution asynchronously. Wraps the synchronous method.
+   * @param cacheKey The key to look up in the cache.
+   * @returns A promise that resolves with the cached solution or undefined.
+   */
+  async getCachedSolution(cacheKey) {
+    return this.getCachedSolutionSync(cacheKey);
+  }
+  /**
+   * Stores a solution in the cache synchronously.
+   * Uses structured cloning to store a copy, preventing external modifications.
+   * @param cacheKey The key under which to store the solution.
+   * @param cachedSolution The solution data to cache.
+   */
+  setCachedSolutionSync(cacheKey, cachedSolution) {
+    this.cache.set(cacheKey, structuredClone(cachedSolution));
+  }
+  /**
+   * Stores a solution in the cache asynchronously. Wraps the synchronous method.
+   * @param cacheKey The key under which to store the solution.
+   * @param cachedSolution The solution data to cache.
+   * @returns A promise that resolves when the solution is cached.
+   */
+  async setCachedSolution(cacheKey, cachedSolution) {
+    this.setCachedSolutionSync(cacheKey, cachedSolution);
+  }
+  /**
+   * Clears the entire cache and resets hit/miss counters.
+   */
+  clearCache() {
+    this.cache.clear();
+    this.cacheHits = 0;
+    this.cacheMisses = 0;
+  }
+  getAllCacheKeys() {
+    return Array.from(this.cache.keys());
+  }
+};
+
+// lib/cache/LocalStorageCache.ts
+var CACHE_PREFIX = "tscircuit_autorouter_cache_";
+var LocalStorageCache = class {
+  isSyncCache = true;
+  cacheHits = 0;
+  cacheMisses = 0;
+  constructor() {
+    if (typeof localStorage === "undefined") {
+      console.warn(
+        "LocalStorage is not available. LocalStorageCache will not function."
+      );
+    }
+  }
+  getKey(cacheKey) {
+    return `${CACHE_PREFIX}${cacheKey}`;
+  }
+  /**
+   * Retrieves a cached solution synchronously from localStorage.
+   * Increments cache hit/miss counters.
+   * @param cacheKey The key to look up in the cache.
+   * @returns The cached solution if found and parsed correctly, otherwise undefined.
+   */
+  getCachedSolutionSync(cacheKey) {
+    if (typeof localStorage === "undefined") return void 0;
+    const key = this.getKey(cacheKey);
+    try {
+      const cachedItem = localStorage.getItem(key);
+      if (cachedItem !== null) {
+        const solution = JSON.parse(cachedItem);
+        this.cacheHits++;
+        return solution;
+      } else {
+        this.cacheMisses++;
+        return void 0;
+      }
+    } catch (error) {
+      console.error(`Error getting cached solution sync for ${key}:`, error);
+      this.cacheMisses++;
+      return void 0;
+    }
+  }
+  /**
+   * Retrieves a cached solution asynchronously. Wraps the synchronous method.
+   * @param cacheKey The key to look up in the cache.
+   * @returns A promise that resolves with the cached solution or undefined.
+   */
+  async getCachedSolution(cacheKey) {
+    return this.getCachedSolutionSync(cacheKey);
+  }
+  /**
+   * Stores a solution in localStorage synchronously.
+   * The solution is JSON stringified before storing.
+   * @param cacheKey The key under which to store the solution.
+   * @param cachedSolution The solution data to cache.
+   */
+  setCachedSolutionSync(cacheKey, cachedSolution) {
+    if (typeof localStorage === "undefined") return;
+    const key = this.getKey(cacheKey);
+    try {
+      const stringifiedSolution = JSON.stringify(cachedSolution);
+      localStorage.setItem(key, stringifiedSolution);
+    } catch (error) {
+      console.error(`Error setting cached solution sync for ${key}:`, error);
+      if (error instanceof DOMException && (error.name === "QuotaExceededError" || error.name === "NS_ERROR_DOM_QUOTA_REACHED")) {
+        console.warn(
+          `LocalStorage quota exceeded. Failed to cache solution for ${key}. Consider clearing the cache.`
+        );
+      }
+    }
+  }
+  /**
+   * Stores a solution in the cache asynchronously. Wraps the synchronous method.
+   * @param cacheKey The key under which to store the solution.
+   * @param cachedSolution The solution data to cache.
+   * @returns A promise that resolves when the solution is cached.
+   */
+  async setCachedSolution(cacheKey, cachedSolution) {
+    this.setCachedSolutionSync(cacheKey, cachedSolution);
+  }
+  /**
+   * Clears all cache entries created by this instance from localStorage
+   * and resets hit/miss counters.
+   */
+  clearCache() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const keysToRemove = [];
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith(CACHE_PREFIX)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach((key) => localStorage.removeItem(key));
+      console.log(
+        `Cleared ${keysToRemove.length} items from LocalStorage cache.`
+      );
+    } catch (error) {
+      console.error("Error clearing LocalStorage cache:", error);
+    } finally {
+      this.cacheHits = 0;
+      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
+function getGlobalLocalStorageCache() {
+  if (!globalThis.TSCIRCUIT_AUTOROUTER_LOCAL_STORAGE_CACHE) {
+    setupGlobalCaches();
+  }
+  return globalThis.TSCIRCUIT_AUTOROUTER_LOCAL_STORAGE_CACHE;
+}
+function setupGlobalCaches() {
+  globalThis.TSCIRCUIT_AUTOROUTER_LOCAL_STORAGE_CACHE ??= new LocalStorageCache();
+  globalThis.TSCIRCUIT_AUTOROUTER_IN_MEMORY_CACHE ??= new InMemoryCache();
+}
+
+// node_modules/transformation-matrix/src/applyToPoint.js
+function applyToPoint(matrix, point) {
+  return Array.isArray(point) ? [
+    matrix.a * point[0] + matrix.c * point[1] + matrix.e,
+    matrix.b * point[0] + matrix.d * point[1] + matrix.f
+  ] : {
+    x: matrix.a * point.x + matrix.c * point.y + matrix.e,
+    y: matrix.b * point.x + matrix.d * point.y + matrix.f
+  };
+}
+
+// node_modules/transformation-matrix/src/translate.js
+function translate(tx, ty = 0) {
+  return {
+    a: 1,
+    c: 0,
+    e: tx,
+    b: 0,
+    d: 1,
+    f: ty
+  };
+}
+
+// node_modules/transformation-matrix/src/rotate.js
+var { cos, sin, PI } = Math;
+
+// node_modules/transformation-matrix/src/skew.js
+var { tan } = Math;
+
+// node_modules/transformation-matrix/src/fromTransformAttribute.autogenerated.js
+function peg$subclass(child, parent) {
+  function C() {
+    this.constructor = child;
+  }
+  C.prototype = parent.prototype;
+  child.prototype = new C();
+}
+function peg$SyntaxError(message, expected, found, location) {
+  var self = Error.call(this, message);
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(self, peg$SyntaxError.prototype);
+  }
+  self.expected = expected;
+  self.found = found;
+  self.location = location;
+  self.name = "SyntaxError";
+  return self;
+}
+peg$subclass(peg$SyntaxError, Error);
+function peg$padEnd(str, targetLength, padString) {
+  padString = padString || " ";
+  if (str.length > targetLength) {
+    return str;
+  }
+  targetLength -= str.length;
+  padString += padString.repeat(targetLength);
+  return str + padString.slice(0, targetLength);
+}
+peg$SyntaxError.prototype.format = function(sources) {
+  var str = "Error: " + this.message;
+  if (this.location) {
+    var src = null;
+    var k;
+    for (k = 0; k < sources.length; k++) {
+      if (sources[k].source === this.location.source) {
+        src = sources[k].text.split(/\r\n|\n|\r/g);
+        break;
+      }
+    }
+    var s = this.location.start;
+    var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s;
+    var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column;
+    if (src) {
+      var e = this.location.end;
+      var filler = peg$padEnd("", offset_s.line.toString().length, " ");
+      var line = src[s.line - 1];
+      var last = s.line === e.line ? e.column : line.length + 1;
+      var hatLen = last - s.column || 1;
+      str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, " ") + peg$padEnd("", hatLen, "^");
+    } else {
+      str += "\n at " + loc;
+    }
+  }
+  return str;
+};
+peg$SyntaxError.buildMessage = function(expected, found) {
+  var DESCRIBE_EXPECTATION_FNS = {
+    literal: function(expectation) {
+      return '"' + literalEscape(expectation.text) + '"';
+    },
+    class: function(expectation) {
+      var escapedParts = expectation.parts.map(function(part) {
+        return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part);
+      });
+      return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]";
+    },
+    any: function() {
+      return "any character";
+    },
+    end: function() {
+      return "end of input";
+    },
+    other: function(expectation) {
+      return expectation.description;
+    }
+  };
+  function hex(ch) {
+    return ch.charCodeAt(0).toString(16).toUpperCase();
+  }
+  function literalEscape(s) {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) {
+      return "\\x0" + hex(ch);
+    }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) {
+      return "\\x" + hex(ch);
+    });
+  }
+  function classEscape(s) {
+    return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function(ch) {
+      return "\\x0" + hex(ch);
+    }).replace(/[\x10-\x1F\x7F-\x9F]/g, function(ch) {
+      return "\\x" + hex(ch);
+    });
+  }
+  function describeExpectation(expectation) {
+    return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+  }
+  function describeExpected(expected2) {
+    var descriptions = expected2.map(describeExpectation);
+    var i, j;
+    descriptions.sort();
+    if (descriptions.length > 0) {
+      for (i = 1, j = 1; i < descriptions.length; i++) {
+        if (descriptions[i - 1] !== descriptions[i]) {
+          descriptions[j] = descriptions[i];
+          j++;
+        }
+      }
+      descriptions.length = j;
+    }
+    switch (descriptions.length) {
+      case 1:
+        return descriptions[0];
+      case 2:
+        return descriptions[0] + " or " + descriptions[1];
+      default:
+        return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1];
+    }
+  }
+  function describeFound(found2) {
+    return found2 ? '"' + literalEscape(found2) + '"' : "end of input";
+  }
+  return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+};
+
+// lib/solvers/UnravelSolver/CachedUnravelSectionSolver.ts
+var approximateCoordinate = (coord) => {
+  return (Math.round(coord * 20) / 20).toFixed(2);
+};
+setupGlobalCaches();
+var CachedUnravelSectionSolver = class extends UnravelSectionSolver {
+  cacheHit = false;
+  cacheProvider;
+  hasAttemptedToUseCache = false;
+  constructor(params) {
+    super(params);
+    this.cacheProvider = params.cacheProvider === void 0 ? getGlobalLocalStorageCache() : params.cacheProvider;
+  }
+  _step() {
+    if (!this.hasAttemptedToUseCache && this.cacheProvider) {
+      if (this.attemptToUseCacheSync()) return;
+    }
+    super._step();
+    if ((this.solved || this.failed) && this.cacheProvider) {
+      this.saveToCacheSync();
+    }
+  }
+  computeCacheKeyAndTransform() {
+    const rootNode = this.nodeMap.get(this.rootNodeId);
+    const realToCacheTransform = translate(
+      -rootNode.center.x,
+      -rootNode.center.y
+    );
+    const nodeIdMap = /* @__PURE__ */ new Map();
+    const reverseNodeIdMap = /* @__PURE__ */ new Map();
+    const segmentIdMap = /* @__PURE__ */ new Map();
+    const reverseSegmentIdMap = /* @__PURE__ */ new Map();
+    const segmentPointIdMap = /* @__PURE__ */ new Map();
+    const reverseSegmentPointIdMap = /* @__PURE__ */ new Map();
+    let nodeCounter = 0;
+    let segmentCounter = 0;
+    let spCounter = 0;
+    const sortedNodeIds = [...this.unravelSection.allNodeIds].sort(
+      (aNId, bNId) => {
+        const n1 = this.nodeMap.get(aNId);
+        const n2 = this.nodeMap.get(bNId);
+        if (n1.center.x !== n2.center.x) {
+          return n1.center.x - n2.center.x;
+        }
+        return n1.center.y - n2.center.y;
+      }
+    );
+    for (const nodeId of sortedNodeIds) {
+      const normId = `node_${nodeCounter++}`;
+      nodeIdMap.set(nodeId, normId);
+      reverseNodeIdMap.set(normId, nodeId);
+    }
+    const sortedSegmentPointIds = [
+      ...Array.from(this.unravelSection.segmentPointMap.entries()).sort(([, a], [, b]) => {
+        if (a.x !== b.x) {
+          return a.x - b.x;
+        }
+        return a.y - b.y;
+      }).map(([id]) => id)
+    ].sort();
+    for (const spId of sortedSegmentPointIds) {
+      const normSpId = `sp_${spCounter++}`;
+      segmentPointIdMap.set(spId, normSpId);
+      reverseSegmentPointIdMap.set(normSpId, spId);
+      const segmentId = this.unravelSection.segmentPointMap.get(spId).segmentId;
+      if (!segmentIdMap.has(segmentId)) {
+        const normSegId = `seg_${segmentCounter++}`;
+        segmentIdMap.set(segmentId, normSegId);
+        reverseSegmentIdMap.set(normSegId, segmentId);
+      }
+    }
+    const normalizedNodes = {};
+    for (const [nodeId, normNodeId] of nodeIdMap.entries()) {
+      const node = this.nodeMap.get(nodeId);
+      const transformedCenter = applyToPoint(realToCacheTransform, node.center);
+      normalizedNodes[normNodeId] = {
+        // ...node,
+        width: node.width,
+        // TODO: Scale width/height if transform includes scaling
+        height: node.height,
+        availableZ: node.availableZ,
+        center: {
+          x: approximateCoordinate(transformedCenter.x),
+          y: approximateCoordinate(transformedCenter.y)
+        }
+      };
+    }
+    const normalizedSegmentPoints = {};
+    for (const [spId, normSpId] of segmentPointIdMap.entries()) {
+      const sp = this.unravelSection.segmentPointMap.get(spId);
+      const transformedPoint = applyToPoint(realToCacheTransform, {
+        x: sp.x,
+        y: sp.y
+      });
+      normalizedSegmentPoints[normSpId] = {
+        x: approximateCoordinate(transformedPoint.x),
+        y: approximateCoordinate(transformedPoint.y),
+        z: sp.z
+        // Z is not transformed by 2D matrix
+        // segmentId: segmentIdMap.get(sp.segmentId)!,
+        // connectionName: sp.connectionName,
+      };
+    }
+    const keyData = {
+      hyperParameters: this.hyperParameters,
+      normalizedNodes,
+      normalizedSegmentPoints,
+      mutableHops: this.MUTABLE_HOPS
+    };
+    const cacheKey = `unravelsec:${objectHash(keyData)}`;
+    const cacheToSolveSpaceTransform = {
+      realToCacheTransform,
+      nodeIdMap,
+      segmentIdMap,
+      segmentPointIdMap,
+      reverseNodeIdMap,
+      reverseSegmentIdMap,
+      reverseSegmentPointIdMap
+    };
+    this.cacheKey = cacheKey;
+    this.cacheToSolveSpaceTransform = cacheToSolveSpaceTransform;
+    return { cacheKey, cacheToSolveSpaceTransform };
+  }
+  applyCachedSolution(cachedSolution) {
+    if (cachedSolution.success === false) {
+      this.failed = true;
+      return;
+    }
+    if (!this.cacheToSolveSpaceTransform) {
+      console.error("Cache transform not available to apply cached solution.");
+      return;
+    }
+    const {
+      // realToCacheTransform, // Not needed to apply deltas
+      reverseSegmentPointIdMap,
+      reverseNodeIdMap
+      // Needed if issues depend on node IDs
+    } = this.cacheToSolveSpaceTransform;
+    const pointModifications = /* @__PURE__ */ new Map();
+    for (const [
+      normSpId,
+      normDelta
+      // normDelta.dx and normDelta.dy are strings here
+    ] of cachedSolution.bestCandidatePointModificationsDelta) {
+      const originalSpId = reverseSegmentPointIdMap.get(normSpId);
+      if (!originalSpId) {
+        console.warn(
+          `Could not find original ID for normalized SP ID: ${normSpId} when applying cache.`
+        );
+        continue;
+      }
+      const originalSegmentPoint = this.unravelSection.segmentPointMap.get(originalSpId);
+      if (!originalSegmentPoint) {
+        console.warn(
+          `Could not find original segment point for ID: ${originalSpId} when applying cache.`
+        );
+        continue;
+      }
+      const modifiedPoint = {};
+      if (normDelta.dx !== void 0) {
+        const dxNum = parseFloat(normDelta.dx);
+        if (!Number.isNaN(dxNum)) {
+          modifiedPoint.x = originalSegmentPoint.x + dxNum;
+        } else {
+          console.warn(`Failed to parse cached dx coordinate: ${normDelta.dx}`);
+        }
+      }
+      if (normDelta.dy !== void 0) {
+        const dyNum = parseFloat(normDelta.dy);
+        if (!Number.isNaN(dyNum)) {
+          modifiedPoint.y = originalSegmentPoint.y + dyNum;
+        } else {
+          console.warn(`Failed to parse cached dy coordinate: ${normDelta.dy}`);
+        }
+      }
+      if (normDelta.dz !== void 0) {
+        modifiedPoint.z = originalSegmentPoint.z + normDelta.dz;
+      }
+      if (Object.keys(modifiedPoint).length > 0) {
+        pointModifications.set(originalSpId, modifiedPoint);
+      }
+    }
+    const issues = getIssuesInSection(
+      this.unravelSection,
+      this.nodeMap,
+      pointModifications
+    );
+    this.bestCandidate = {
+      pointModifications,
+      issues,
+      f: cachedSolution.bestCandidateF,
+      g: cachedSolution.bestCandidateF,
+      // Assume g is the main component off for cached solution
+      h: 0,
+      // Heuristic is 0 when solution is loaded
+      operationsPerformed: -1,
+      // Indicate it's from cache, operation count unknown
+      candidateHash: createPointModificationsHash(pointModifications)
+    };
+    this.cacheHit = true;
+    this.solved = 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;
+      } else {
+      }
+    } catch (error) {
+      console.error("Error attempting to use cache:", error);
+    }
+    return false;
+  }
+  saveToCacheSync() {
+    if (this.failed) {
+      this.cacheProvider?.setCachedSolutionSync(this.cacheKey, {
+        success: false
+      });
+      return;
+    }
+    if (!this.bestCandidate) return;
+    const {
+      // realToCacheTransform, // Not needed to calculate deltas
+      segmentPointIdMap
+    } = this.cacheToSolveSpaceTransform;
+    const normalizedDeltas = [];
+    for (const [
+      originalSpId,
+      modifiedPoint
+      // This contains the absolute modified coordinates {x?, y?, z?}
+    ] of this.bestCandidate.pointModifications.entries()) {
+      const normSpId = segmentPointIdMap.get(originalSpId);
+      if (!normSpId) {
+        console.warn(
+          `Could not find normalized ID for original SP ID: ${originalSpId} when saving to cache.`
+        );
+        continue;
+      }
+      const originalSegmentPoint = this.unravelSection.segmentPointMap.get(originalSpId);
+      if (!originalSegmentPoint) {
+        console.warn(
+          `Could not find original segment point for ID: ${originalSpId} when saving cache.`
+        );
+        continue;
+      }
+      const normDelta = {};
+      let hasDelta = false;
+      if (modifiedPoint.x !== void 0) {
+        const dx = modifiedPoint.x - originalSegmentPoint.x;
+        const approxDx = approximateCoordinate(dx);
+        if (parseFloat(approxDx) !== 0) {
+          normDelta.dx = approxDx;
+          hasDelta = true;
+        }
+      }
+      if (modifiedPoint.y !== void 0) {
+        const dy = modifiedPoint.y - originalSegmentPoint.y;
+        const approxDy = approximateCoordinate(dy);
+        if (parseFloat(approxDy) !== 0) {
+          normDelta.dy = approxDy;
+          hasDelta = true;
+        }
+      }
+      if (modifiedPoint.z !== void 0) {
+        const dz = modifiedPoint.z - originalSegmentPoint.z;
+        if (dz !== 0) {
+          normDelta.dz = dz;
+          hasDelta = true;
+        }
+      }
+      if (hasDelta) {
+        normalizedDeltas.push([normSpId, normDelta]);
+      }
+    }
+    const cachedSolution = {
+      success: true,
+      bestCandidatePointModificationsDelta: normalizedDeltas,
+      bestCandidateF: this.bestCandidate.f
+    };
+    this.cacheProvider?.setCachedSolutionSync(this.cacheKey, cachedSolution);
+  }
+};
+
 // lib/solvers/UnravelSolver/getDedupedSegments.ts
 var getDedupedSegments = (assignedSegments) => {
   const dedupedSegments = [];
@@ -11024,12 +11697,19 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
   attemptsToFixNode;
   activeSubSolver = null;
   segmentPointMap;
+  cacheProvider = null;
   constructor({
     assignedSegments,
     colorMap,
-    nodes
+    nodes,
+    cacheProvider
   }) {
     super();
+    this.stats.successfulOptimizations = 0;
+    this.stats.failedOptimizations = 0;
+    this.stats.cacheHits = 0;
+    this.stats.cacheMisses = 0;
+    this.cacheProvider = cacheProvider ?? null;
     this.MAX_ITERATIONS = 1e6;
     this.dedupedSegments = getDedupedSegments(assignedSegments);
     this.dedupedSegmentMap = /* @__PURE__ */ new Map();
@@ -11112,7 +11792,7 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
         highestPfNodeId,
         (this.attemptsToFixNode.get(highestPfNodeId) ?? 0) + 1
       );
-      this.activeSubSolver = new UnravelSectionSolver({
+      this.activeSubSolver = new CachedUnravelSectionSolver({
         dedupedSegments: this.dedupedSegments,
         dedupedSegmentMap: this.dedupedSegmentMap,
         nodeMap: this.nodeMap,
@@ -11123,15 +11803,26 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
         MUTABLE_HOPS: this.MUTABLE_HOPS,
         segmentPointMap: this.segmentPointMap,
         nodeToSegmentPointMap: this.nodeToSegmentPointMap,
-        segmentToSegmentPointMap: this.segmentToSegmentPointMap
+        segmentToSegmentPointMap: this.segmentToSegmentPointMap,
+        cacheProvider: this.cacheProvider
       });
     }
     this.activeSubSolver.step();
     const { bestCandidate, originalCandidate, lastProcessedCandidate } = this.activeSubSolver;
-    const shouldEarlyStop = this.activeSubSolver.iterationsSinceImprovement > this.MAX_ITERATIONS_WITHOUT_IMPROVEMENT;
-    if (this.activeSubSolver.solved || shouldEarlyStop) {
+    if (this.activeSubSolver.failed) {
+      this.stats.failedOptimizations += 1;
+      this.activeSubSolver = null;
+      return;
+    }
+    if (this.activeSubSolver.solved) {
+      if (this.activeSubSolver.cacheHit) {
+        this.stats.cacheHits += 1;
+      } else {
+        this.stats.cacheMisses += 1;
+      }
       const foundBetterSolution = bestCandidate && bestCandidate.g < originalCandidate.g;
       if (foundBetterSolution) {
+        this.stats.successfulOptimizations += 1;
         for (const [
           segmentPointId,
           pointModification
@@ -11147,6 +11838,8 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
             this.computeNodePf(this.nodeMap.get(nodeId))
           );
         }
+      } else {
+        this.stats.failedOptimizations += 1;
       }
       this.activeSubSolver = null;
     }
@@ -15091,6 +15784,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
     }
     this.connMap = getConnectivityMapFromSimpleRouteJson(srj);
     this.colorMap = getColorMap(srj, this.connMap);
+    this.cacheProvider = opts.cacheProvider ?? null;
     this.startTimeOfPhase = {};
     this.endTimeOfPhase = {};
     this.timeSpentOnPhase = {};
@@ -15121,6 +15815,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
   connMap;
   srjWithPointPairs;
   capacityNodes = null;
+  cacheProvider = null;
   pipelineDef = [
     definePipelineStep(
       "netToPointPairsSolver",
@@ -15268,7 +15963,8 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
         {
           assignedSegments: cms.segmentToPointSolver?.solvedSegments || [],
           colorMap: cms.colorMap,
-          nodes: cms.capacityNodes
+          nodes: cms.capacityNodes,
+          cacheProvider: this.cacheProvider
         }
       ]
     ),