@tscircuit/capacity-autorouter 0.0.129 → 0.0.130

package/dist/index.d.ts

@@ -642,6 +642,78 @@ declare class IntraNodeRouteSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+interface CacheProvider {
+    isSyncCache: boolean;
+    cacheHits: number;
+    cacheMisses: number;
+    cacheHitsByPrefix: Record<string, number>;
+    cacheMissesByPrefix: Record<string, number>;
+    getCachedSolutionSync(cacheKey: string): any;
+    getCachedSolution(cacheKey: string): Promise<any>;
+    setCachedSolutionSync(cacheKey: string, cachedSolution: any): void;
+    setCachedSolution(cacheKey: string, cachedSolution: any): Promise<void>;
+    getAllCacheKeys(): string[];
+    clearCache(): void;
+}
+interface CachableSolver<CacheToSolveSpaceTransform = any, CachedSolution = any> {
+    cacheHit: boolean;
+    hasAttemptedToUseCache: boolean;
+    cacheProvider: CacheProvider | null;
+    cacheKey?: string;
+    cacheToSolveSpaceTransform?: CacheToSolveSpaceTransform;
+    /**
+     * Processes solver inputs and constructs a cacheKey and a cacheToSolveSpaceTransform
+     * which gives the necessary information to convert a cached solution into a valid
+     * solution for this solver. For example, the cacheKey may be translation-invariant, so
+     * any cachedSolution would not be translated properly for this solver. The cacheToSolveSpaceTransform
+     * tells you how to convert from the cache space (translation-invarant) to the correct
+     * space for this solver. It can also contain information about how cache ids map to
+     * ids for the solver
+     **/
+    computeCacheKeyAndTransform(): {
+        cacheKey: string;
+        cacheToSolveSpaceTransform: CacheToSolveSpaceTransform;
+    };
+    applyCachedSolution(cachedSolution: CachedSolution): void;
+    attemptToUseCacheSync(): boolean;
+    saveToCacheSync(): void;
+}
+
+type CachedSolvedIntraNodeRouteSolver = {
+    success: true;
+    solvedRoutes: HighDensityIntraNodeRoute$1[];
+} | {
+    success: false;
+    error?: string;
+};
+type CacheToIntraNodeSolverTransform = Record<string, never>;
+declare class CachedIntraNodeRouteSolver extends IntraNodeRouteSolver implements CachableSolver<CacheToIntraNodeSolverTransform, CachedSolvedIntraNodeRouteSolver> {
+    cacheProvider: CacheProvider | null;
+    cacheHit: boolean;
+    hasAttemptedToUseCache: boolean;
+    cacheKey?: string | undefined;
+    cacheToSolveSpaceTransform?: CacheToIntraNodeSolverTransform | undefined;
+    initialUnsolvedConnections: {
+        connectionName: string;
+        points: {
+            x: number;
+            y: number;
+            z: number;
+        }[];
+    }[];
+    constructor(params: ConstructorParameters<typeof IntraNodeRouteSolver>[0] & {
+        cacheProvider?: CacheProvider | null;
+    });
+    _step(): void;
+    computeCacheKeyAndTransform(): {
+        cacheKey: string;
+        cacheToSolveSpaceTransform: CacheToIntraNodeSolverTransform;
+    };
+    applyCachedSolution(cachedSolution: CachedSolvedIntraNodeRouteSolver): void;
+    attemptToUseCacheSync(): boolean;
+    saveToCacheSync(): void;
+}
+
 type SupervisedSolver<T extends BaseSolver> = {
     hyperParameters: any;
     solver: T;
@@ -752,11 +824,11 @@ declare class TwoCrossingRoutesHighDensitySolver extends BaseSolver {
 }
 
 declare class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<IntraNodeRouteSolver | TwoCrossingRoutesHighDensitySolver> {
-    constructorParams: ConstructorParameters<typeof IntraNodeRouteSolver>[0];
+    constructorParams: ConstructorParameters<typeof CachedIntraNodeRouteSolver>[0];
     solvedRoutes: HighDensityIntraNodeRoute$1[];
     nodeWithPortPoints: NodeWithPortPoints;
     connMap?: ConnectivityMap;
-    constructor(opts: ConstructorParameters<typeof IntraNodeRouteSolver>[0]);
+    constructor(opts: ConstructorParameters<typeof CachedIntraNodeRouteSolver>[0]);
     getCombinationDefs(): string[][];
     getHyperParameterDefs(): ({
         name: string;
@@ -844,6 +916,7 @@ declare class HighDensitySolver extends BaseSolver {
      * of it.
      */
     _step(): void;
+    private updateCacheStats;
     visualize(): GraphicsObject;
 }
 
@@ -1307,43 +1380,6 @@ declare class UnravelSectionSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface CacheProvider {
-    isSyncCache: boolean;
-    cacheHits: number;
-    cacheMisses: number;
-    cacheHitsByPrefix: Record<string, number>;
-    cacheMissesByPrefix: Record<string, number>;
-    getCachedSolutionSync(cacheKey: string): any;
-    getCachedSolution(cacheKey: string): Promise<any>;
-    setCachedSolutionSync(cacheKey: string, cachedSolution: any): void;
-    setCachedSolution(cacheKey: string, cachedSolution: any): Promise<void>;
-    getAllCacheKeys(): string[];
-    clearCache(): void;
-}
-interface CachableSolver<CacheToSolveSpaceTransform = any, CachedSolution = any> {
-    cacheHit: boolean;
-    hasAttemptedToUseCache: boolean;
-    cacheProvider: CacheProvider | null;
-    cacheKey?: string;
-    cacheToSolveSpaceTransform?: CacheToSolveSpaceTransform;
-    /**
-     * Processes solver inputs and constructs a cacheKey and a cacheToSolveSpaceTransform
-     * which gives the necessary information to convert a cached solution into a valid
-     * solution for this solver. For example, the cacheKey may be translation-invariant, so
-     * any cachedSolution would not be translated properly for this solver. The cacheToSolveSpaceTransform
-     * tells you how to convert from the cache space (translation-invarant) to the correct
-     * space for this solver. It can also contain information about how cache ids map to
-     * ids for the solver
-     **/
-    computeCacheKeyAndTransform(): {
-        cacheKey: string;
-        cacheToSolveSpaceTransform: CacheToSolveSpaceTransform;
-    };
-    applyCachedSolution(cachedSolution: CachedSolution): void;
-    attemptToUseCacheSync(): boolean;
-    saveToCacheSync(): void;
-}
-
 declare class UnravelMultiSectionSolver extends BaseSolver {
     nodeMap: Map<CapacityMeshNodeId, CapacityMeshNode>;
     dedupedSegmentMap: Map<SegmentId, SegmentWithAssignedPoints>;