@tscircuit/capacity-autorouter 0.0.85 → 0.0.87

package/dist/index.d.ts

@@ -1581,6 +1581,8 @@ declare class CapacityPathingMultiSectionSolver extends BaseSolver {
             endingScore: number;
             endingHighestNodePf: number;
         }>;
+        cacheHits: number;
+        cacheMisses: number;
     };
     OPTIMIZATION_SCHEDULE: {
         MAX_ATTEMPTS_PER_NODE: number;
@@ -1732,6 +1734,22 @@ declare class CapacityMeshEdgeSolver2_NodeTreeOptimization extends CapacityMeshE
     _step(): void;
 }
 
+declare class DeadEndSolver extends BaseSolver {
+    removedNodeIds: Set<string>;
+    private targetNodeIds;
+    private leaves;
+    private leavesIndex;
+    private adjacencyList;
+    private nodes;
+    private edges;
+    constructor({ nodes, edges, }: {
+        nodes: CapacityMeshNode[];
+        edges: CapacityMeshEdge[];
+    });
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
 interface Point {
     x: number;
     y: number;
@@ -1871,6 +1889,7 @@ declare class AutoroutingPipelineSolver extends BaseSolver {
     highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
     singleLayerNodeMerger?: SingleLayerNodeMergerSolver;
     strawSolver?: StrawSolver;
+    deadEndSolver?: DeadEndSolver;
     uselessViaRemovalSolver1?: UselessViaRemovalSolver;
     uselessViaRemovalSolver2?: UselessViaRemovalSolver;
     multiSimplifiedPathSolver1?: MultiSimplifiedPathSolver;
@@ -1882,8 +1901,9 @@ declare class AutoroutingPipelineSolver extends BaseSolver {
     connMap: ConnectivityMap;
     srjWithPointPairs?: SimpleRouteJson;
     capacityNodes: CapacityMeshNode[] | null;
+    capacityEdges: CapacityMeshEdge[] | null;
     cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver2_NodeUnderObstacle> | PipelineStep<typeof SingleLayerNodeMergerSolver> | PipelineStep<typeof StrawSolver> | PipelineStep<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep<typeof CapacityPathingGreedySolver> | PipelineStep<typeof CapacityPathingMultiSectionSolver> | PipelineStep<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep<typeof CapacitySegmentToPointSolver> | PipelineStep<typeof UnravelMultiSectionSolver> | PipelineStep<typeof HighDensitySolver> | PipelineStep<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep<typeof UselessViaRemovalSolver> | PipelineStep<typeof MultiSimplifiedPathSolver>)[];
+    pipelineDef: (PipelineStep<typeof NetToPointPairsSolver> | PipelineStep<typeof CapacityMeshNodeSolver2_NodeUnderObstacle> | PipelineStep<typeof SingleLayerNodeMergerSolver> | PipelineStep<typeof StrawSolver> | PipelineStep<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep<typeof DeadEndSolver> | PipelineStep<typeof CapacityPathingGreedySolver> | PipelineStep<typeof CapacityPathingMultiSectionSolver> | PipelineStep<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep<typeof CapacitySegmentToPointSolver> | PipelineStep<typeof UnravelMultiSectionSolver> | PipelineStep<typeof HighDensitySolver> | PipelineStep<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep<typeof UselessViaRemovalSolver> | PipelineStep<typeof MultiSimplifiedPathSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions);
     currentPipelineStepIndex: number;
     _step(): void;

package/dist/index.js

@@ -13522,6 +13522,7 @@ var CachedHyperCapacityPathingSingleSectionSolver = class extends HyperCapacityP
     });
     const terminals = {};
     const cacheSpaceToRealConnectionId = /* @__PURE__ */ new Map();
+    const connectionPairMap = /* @__PURE__ */ new Map();
     for (const conn of this.constructorParams.sectionConnectionTerminals) {
       const cacheStartNodeId = realToCacheSpaceNodeIdMap.get(conn.startNodeId);
       const cacheEndNodeId = realToCacheSpaceNodeIdMap.get(conn.endNodeId);
@@ -13529,7 +13530,10 @@ var CachedHyperCapacityPathingSingleSectionSolver = class extends HyperCapacityP
         cacheStartNodeId,
         cacheEndNodeId
       ].sort();
-      const cacheSpaceConnectionId = `${sortedStartId}->${sortedEndId}`;
+      const pairKey = `${sortedStartId}->${sortedEndId}`;
+      const pairIndex = connectionPairMap.get(pairKey) ?? 0;
+      connectionPairMap.set(pairKey, pairIndex + 1);
+      const cacheSpaceConnectionId = `${sortedStartId}->${sortedEndId}::${pairIndex}`;
       terminals[cacheSpaceConnectionId] = {
         start: sortedStartId,
         end: sortedEndId
@@ -13796,9 +13800,11 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
           endingHighestNodePf: 0,
           sectionAttempts: 0
         })
-      )
+      ),
+      cacheHits: 0,
+      cacheMisses: 0
     };
-    this.MAX_ITERATIONS = 1e7;
+    this.MAX_ITERATIONS = params.MAX_ITERATIONS ?? 1e7;
     this.cacheProvider = params.cacheProvider;
     this.simpleRouteJson = params.simpleRouteJson;
     this.nodes = params.nodes;
@@ -13943,6 +13949,13 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
       );
     }
     this.sectionSolver.step();
+    if (this.sectionSolver.failed || this.sectionSolver.solved) {
+      if (this.sectionSolver.cacheHit) {
+        this.stats.cacheHits++;
+      } else {
+        this.stats.cacheMisses++;
+      }
+    }
     if (this.sectionSolver.failed) {
       console.warn(
         `Section solver failed for node ${this.currentSection.centerNodeId}. Error: ${this.sectionSolver.error}`
@@ -15801,6 +15814,93 @@ var CapacityMeshEdgeSolver2_NodeTreeOptimization = class extends CapacityMeshEdg
   }
 };
 
+// lib/solvers/DeadEndSolver/DeadEndSolver.ts
+var DeadEndSolver = class extends BaseSolver {
+  removedNodeIds;
+  targetNodeIds;
+  leaves;
+  leavesIndex;
+  adjacencyList;
+  // Store the nodes and edges just for visualization purposes
+  nodes;
+  edges;
+  constructor({
+    nodes,
+    edges
+  }) {
+    super();
+    this.MAX_ITERATIONS = nodes.length;
+    this.nodes = nodes;
+    this.edges = edges;
+    this.removedNodeIds = /* @__PURE__ */ new Set();
+    this.targetNodeIds = new Set(
+      nodes.filter((n) => n._containsTarget).map((n) => n.capacityMeshNodeId)
+    );
+    this.adjacencyList = new Map(
+      nodes.map(({ capacityMeshNodeId }) => [capacityMeshNodeId, /* @__PURE__ */ new Set()])
+    );
+    for (const {
+      nodeIds: [u, v]
+    } of edges) {
+      this.adjacencyList.get(u).add(v);
+      this.adjacencyList.get(v).add(u);
+    }
+    this.leavesIndex = 0;
+    this.leaves = [...this.adjacencyList.entries()].filter(([_, neighbours]) => neighbours.size === 1).filter(([nodeId, _]) => !this.targetNodeIds.has(nodeId)).map(([nodeId, _]) => nodeId);
+  }
+  _step() {
+    if (this.leavesIndex === this.leaves.length) {
+      this.solved = true;
+      return;
+    }
+    const leaf = this.leaves[this.leavesIndex];
+    const [neighbor] = this.adjacencyList.get(leaf);
+    const neighborsOfLeafNeighbor = this.adjacencyList.get(neighbor);
+    neighborsOfLeafNeighbor.delete(leaf);
+    this.removedNodeIds.add(leaf);
+    if (neighborsOfLeafNeighbor.size === 1 && !this.targetNodeIds.has(neighbor)) {
+      this.leaves.push(neighbor);
+    }
+    this.leavesIndex += 1;
+    if (this.leavesIndex === this.leaves.length) {
+      this.solved = true;
+    }
+  }
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+    for (const edge of this.edges) {
+      if (!edge.nodeIds.some((nodeId) => this.removedNodeIds.has(nodeId))) {
+        continue;
+      }
+      const [node1, node2] = edge.nodeIds.map((nodeId) => {
+        return this.nodes.find((node) => node.capacityMeshNodeId === nodeId);
+      });
+      if (node1?.center && node2?.center) {
+        const lowestZ1 = Math.min(...node1.availableZ);
+        const lowestZ2 = Math.min(...node2.availableZ);
+        const nodeCenter1Adj = {
+          x: node1.center.x + lowestZ1 * node1.width * 0.05,
+          y: node1.center.y - lowestZ1 * node1.width * 0.05
+        };
+        const nodeCenter2Adj = {
+          x: node2.center.x + lowestZ2 * node2.width * 0.05,
+          y: node2.center.y - lowestZ2 * node2.width * 0.05
+        };
+        graphics.lines.push({
+          strokeColor: "black",
+          points: [nodeCenter1Adj, nodeCenter2Adj]
+        });
+      }
+    }
+    return graphics;
+  }
+};
+
 // lib/data-structures/HighDensityRouteSpatialIndex.ts
 var getSegmentBounds2 = (segment) => {
   return {
@@ -16409,6 +16509,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
   highDensityStitchSolver;
   singleLayerNodeMerger;
   strawSolver;
+  deadEndSolver;
   uselessViaRemovalSolver1;
   uselessViaRemovalSolver2;
   multiSimplifiedPathSolver1;
@@ -16420,6 +16521,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
   connMap;
   srjWithPointPairs;
   capacityNodes = null;
+  capacityEdges = null;
   cacheProvider = null;
   pipelineDef = [
     definePipelineStep(
@@ -16484,7 +16586,28 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
     definePipelineStep(
       "edgeSolver",
       CapacityMeshEdgeSolver2_NodeTreeOptimization,
-      (cms) => [cms.capacityNodes]
+      (cms) => [cms.capacityNodes],
+      {
+        onSolved: (cms) => {
+          cms.capacityEdges = cms.edgeSolver?.edges;
+        }
+      }
+    ),
+    definePipelineStep(
+      "deadEndSolver",
+      DeadEndSolver,
+      (cms) => [{ nodes: cms.capacityNodes, edges: cms.capacityEdges }],
+      {
+        onSolved: (cms) => {
+          const removedNodeIds = cms.deadEndSolver?.removedNodeIds;
+          cms.capacityNodes = cms.capacityNodes.filter(
+            (n) => !removedNodeIds.has(n.capacityMeshNodeId)
+          );
+          cms.capacityEdges = cms.capacityEdges.filter(
+            (e) => e.nodeIds.every((nodeId) => !removedNodeIds.has(nodeId))
+          );
+        }
+      }
     ),
     definePipelineStep(
       "initialPathingSolver",
@@ -16493,7 +16616,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
         {
           simpleRouteJson: cms.srjWithPointPairs,
           nodes: cms.capacityNodes,
-          edges: cms.edgeSolver?.edges || [],
+          edges: cms.capacityEdges || [],
           colorMap: cms.colorMap,
           hyperParameters: {
             MAX_CAPACITY_FACTOR: 1
@@ -16511,7 +16634,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
           initialPathingSolver: cms.initialPathingSolver,
           simpleRouteJson: cms.srjWithPointPairs,
           nodes: cms.capacityNodes,
-          edges: cms.edgeSolver?.edges || [],
+          edges: cms.capacityEdges || [],
           colorMap: cms.colorMap,
           cacheProvider: cms.cacheProvider,
           hyperParameters: {
@@ -16526,7 +16649,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
       (cms) => [
         {
           nodes: cms.capacityNodes,
-          edges: cms.edgeSolver?.edges || [],
+          edges: cms.capacityEdges || [],
           capacityPaths: cms.pathingOptimizer?.getCapacityPaths() || [],
           colorMap: cms.colorMap
         }
@@ -16687,6 +16810,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
     const singleLayerNodeMergerViz = this.singleLayerNodeMerger?.visualize();
     const strawSolverViz = this.strawSolver?.visualize();
     const edgeViz = this.edgeSolver?.visualize();
+    const deadEndViz = this.deadEndSolver?.visualize();
     const initialPathingViz = this.initialPathingSolver?.visualize();
     const pathingOptimizerViz = this.pathingOptimizer?.visualize();
     const edgeToPortSegmentViz = this.edgeToPortSegmentSolver?.visualize();
@@ -16743,6 +16867,7 @@ var AutoroutingPipelineSolver = class extends BaseSolver {
       singleLayerNodeMergerViz,
       strawSolverViz,
       edgeViz,
+      deadEndViz,
       initialPathingViz,
       pathingOptimizerViz,
       edgeToPortSegmentViz,