@tscircuit/capacity-autorouter 0.0.55 → 0.0.56

package/dist/index.js

@@ -47,6 +47,7 @@ var BaseSolver = class {
   activeSubSolver;
   failedSubSolvers;
   timeToSolve;
+  stats = {};
   /** DO NOT OVERRIDE! Override _step() instead */
   step() {
     if (this.solved) return;
@@ -65,6 +66,9 @@ var BaseSolver = class {
       console.error(this.error);
       this.failed = true;
     }
+    if ("computeProgress" in this) {
+      this.progress = this.computeProgress();
+    }
   }
   _step() {
   }
@@ -2902,7 +2906,7 @@ var CapacitySegmentToPointSolver = class extends BaseSolver {
   }
 };
 
-// node_modules/@tscircuit/math-utils/dist/chunk-CHQOCSFB.js
+// node_modules/@tscircuit/math-utils/dist/chunk-3453HRP7.js
 function doSegmentsIntersect(p1, q1, p2, q2) {
   const o1 = orientation(p1, q1, p2);
   const o2 = orientation(p1, q1, q2);
@@ -2974,7 +2978,7 @@ function clamp(value, min, max) {
   return Math.max(min, Math.min(max, value));
 }
 
-// node_modules/@tscircuit/math-utils/dist/chunk-RNQKFERU.js
+// node_modules/@tscircuit/math-utils/dist/chunk-FWQGMQBW.js
 function segmentToSegmentMinDistance(a, b, u, v) {
   if (a.x === b.x && a.y === b.y) {
     return pointToSegmentDistance(a, u, v);
@@ -4008,12 +4012,15 @@ var HyperParameterSupervisorSolver = class extends BaseSolver {
     }
     return bestSolver;
   }
+  getFailureMessage() {
+    return "All solvers failed in hyper solver.";
+  }
   _step() {
     if (!this.supervisedSolvers) this.initializeSolvers();
     const supervisedSolver = this.getSupervisedSolverWithBestFitness();
     if (!supervisedSolver) {
       this.failed = true;
-      this.error = "All solvers failed";
+      this.error = this.getFailureMessage();
       return;
     }
     for (let i = 0; i < this.MIN_SUBSTEPS; i++) {
@@ -6262,10 +6269,13 @@ var Vertex = class {
   y;
   out;
   // Outgoing half-edge indices
+  connectionNames;
+  // Names of connections passing through this vertex
   constructor(x, y) {
     this.x = x;
     this.y = y;
     this.out = [];
+    this.connectionNames = /* @__PURE__ */ new Set();
   }
 };
 var HalfEdge = class {
@@ -6349,9 +6359,17 @@ function getCentroidsFromInnerBoxIntersections(rectangle, userSegments) {
       return t1 - t2;
     });
     for (let k = 0; k < list.length - 1; ++k) {
-      const v1 = getVertexId(list[k]);
-      const v2 = getVertexId(list[k + 1]);
-      if (v1 !== v2) undirectedEdges.push([v1, v2]);
+      const p1 = list[k];
+      const p2 = list[k + 1];
+      const v1 = getVertexId(p1);
+      const v2 = getVertexId(p2);
+      if (v1 !== v2) {
+        undirectedEdges.push([v1, v2]);
+        if (s.connectionName) {
+          vertices[v1].connectionNames.add(s.connectionName);
+          vertices[v2].connectionNames.add(s.connectionName);
+        }
+      }
     }
   }
   const halfEdges = [];
@@ -6408,8 +6426,11 @@ function getCentroidsFromInnerBoxIntersections(rectangle, userSegments) {
       if (c) {
         centroids.push(c);
         faces.push({
-          vertices: poly.map((p) => ({ x: p.x, y: p.y })),
-          // Convert Vertex back to simple Point
+          vertices: poly.map((v) => ({
+            x: v.x,
+            y: v.y,
+            connectionNames: v.connectionNames.size > 0 ? v.connectionNames : void 0
+          })),
           centroid: c
         });
       }
@@ -6995,6 +7016,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
   obstacleMargin = 0.1;
   traceWidth = 0.15;
   availableZ = [];
+  uniqueConnections = 0;
   lastCandidate = null;
   maxViaCount;
   minViaCount;
@@ -7022,6 +7044,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
     const uniqueConnections = new Set(
       this.nodeWithPortPoints.portPoints.map((pp) => pp.connectionName)
     ).size;
+    this.uniqueConnections = uniqueConnections;
     const { numSameLayerCrossings, numTransitions } = getIntraNodeCrossings(
       this.nodeWithPortPoints
     );
@@ -7030,11 +7053,6 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
       Math.floor(areaInsideNode / areaPerVia),
       Math.ceil(uniqueConnections * 1.5)
     );
-    if (uniqueConnections > 5) {
-      this.failed = true;
-      this.error = `Limit is currently set to 6 unique connections, ${uniqueConnections} found`;
-      return;
-    }
     if (this.minViaCount > this.SEGMENTS_PER_POLYLINE * (uniqueConnections / 2)) {
       this.failed = true;
       this.error = `Not possible to solve problem with given SEGMENTS_PER_POLYLINE (${this.SEGMENTS_PER_POLYLINE}), atleast ${this.minViaCount} vias are required`;
@@ -7773,7 +7791,7 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
             strokeColor: segmentColor,
             strokeWidth: this.traceWidth,
             // TODO: Use actual trace thickness from HighDensityRoute?
-            strokeDash: !isLayer0 ? "5,5" : void 0,
+            strokeDash: !isLayer0 ? [0.15, 0.15] : void 0,
             // Dashed for layers > 0
             label: `${polyLine.connectionName} segment (z=${segmentLayer})`
           });
@@ -8502,7 +8520,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.error = `Failed to solve ${this.failedSolvers.length} nodes, ${this.failedSolvers.slice(0, 5).map((fs) => fs.nodeWithPortPoints.capacityMeshNodeId)}`;
         return;
       }
       this.solved = true;
@@ -8574,7 +8592,8 @@ var HighDensitySolver = class extends BaseSolver {
           graphics.lines.push({
             points: [start, end],
             strokeColor: "red",
-            strokeDash: "10, 5"
+            strokeDash: "10, 5",
+            layer: "did_not_connect"
           });
         }
       }
@@ -11476,7 +11495,7 @@ ${percent}% (Pf: ${(probabilityOfFailure * 100).toFixed(1)}%)`;
 }
 
 // lib/solvers/CapacityPathingSectionSolver/CapacityPathingSingleSectionPathingSolver.ts
-var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
+var CapacityPathingSingleSectionSolver = class extends BaseSolver {
   GREEDY_MULTIPLIER = 1.5;
   sectionNodes;
   sectionEdges;
@@ -11488,6 +11507,7 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
   colorMap;
   usedNodeCapacityMap;
   // Tracks capacity usage *within this solver's run*
+  centerNodeId;
   MAX_CANDIDATES_IN_MEMORY = 1e4;
   // A* state
   currentConnectionIndex = 0;
@@ -11501,6 +11521,7 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
   // Default, similar to CapacityPathingSolver5
   constructor(params) {
     super();
+    this.centerNodeId = params.centerNodeId;
     this.sectionNodes = params.sectionNodes;
     this.sectionEdges = params.sectionEdges;
     this.sectionConnectionTerminals = params.sectionConnectionTerminals.map(
@@ -11674,6 +11695,28 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
       candidates.push(newCandidate);
     }
   }
+  computeProgress() {
+    const totalConnections = this.sectionConnectionTerminals.length;
+    if (totalConnections === 0) return 1;
+    const completedConnections = this.currentConnectionIndex;
+    let progress = completedConnections / totalConnections;
+    if (this.currentConnectionIndex < totalConnections && this.candidates && this.candidates.length > 0 && this.activeCandidateStraightLineDistance && this.activeCandidateStraightLineDistance > 0) {
+      const bestCandidate = this.candidates.reduce(
+        (best, current) => current.f < best.f ? current : best
+      );
+      const currentConnectionProgress = Math.max(
+        0,
+        Math.min(
+          1,
+          1 - bestCandidate.h / this.activeCandidateStraightLineDistance
+        )
+      );
+      progress += currentConnectionProgress / totalConnections;
+    } else if (this.solved) {
+      progress = 1;
+    }
+    return Math.min(1, progress);
+  }
   _setupAStar(startNode, endNode) {
     this.candidates = [
       { prevCandidate: null, node: startNode, f: 0, g: 0, h: 0 }
@@ -11778,133 +11821,157 @@ var CapacityPathingSingleSectionPathingSolver = class extends BaseSolver {
     return baseGraphics;
   }
 };
+var CapacityPathingSingleSectionPathingSolver = CapacityPathingSingleSectionSolver;
 
-// lib/solvers/CapacityPathingSectionSolver/CapacityPathingSingleSectionSolver.ts
-var CapacityPathingSingleSectionSolver = class extends BaseSolver {
-  centerNodeId;
-  connectionsWithNodes;
-  nodes;
-  nodeMap;
-  edges;
-  nodeEdgeMap;
-  expansionDegrees;
-  colorMap;
-  sectionNodes;
-  sectionEdges;
-  // Added sectionEdges property
-  sectionConnectionTerminals;
-  activeSubSolver = null;
+// lib/solvers/CapacityPathingSectionSolver/HyperCapacityPathingSingleSectionSolver.ts
+var HyperCapacityPathingSingleSectionSolver = class extends HyperParameterSupervisorSolver {
+  constructorParams;
+  winningSolver;
   constructor(params) {
     super();
-    this.MAX_ITERATIONS = 1e5;
-    this.colorMap = params.colorMap;
-    this.centerNodeId = params.centerNodeId;
-    this.connectionsWithNodes = params.connectionsWithNodes;
-    this.nodes = params.nodes;
-    this.nodeMap = new Map(this.nodes.map((n) => [n.capacityMeshNodeId, n]));
-    this.edges = params.edges;
-    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
-    this.expansionDegrees = params.hyperParameters?.EXPANSION_DEGREES ?? 3;
-    this.sectionNodes = [];
-    this.sectionEdges = [];
-    this.sectionConnectionTerminals = [];
-    this.computeSectionNodesTerminalsAndEdges();
-    this.activeSubSolver = new CapacityPathingSingleSectionPathingSolver({
-      sectionConnectionTerminals: this.sectionConnectionTerminals,
-      sectionNodes: this.sectionNodes,
-      sectionEdges: this.sectionEdges,
-      colorMap: this.colorMap,
-      hyperParameters: params.hyperParameters
-    });
+    this.MAX_ITERATIONS = 1e4;
+    this.constructorParams = params;
   }
-  computeSectionNodesTerminalsAndEdges() {
-    const sectionNodeIds = /* @__PURE__ */ new Set();
-    const queue = [
-      { nodeId: this.centerNodeId, depth: 0 }
-    ];
-    sectionNodeIds.add(this.centerNodeId);
-    let head = 0;
-    while (head < queue.length) {
-      const { nodeId, depth } = queue[head++];
-      if (depth >= this.expansionDegrees) continue;
-      const neighbors = this.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 });
-        }
-      }
-    }
-    this.sectionNodes = Array.from(sectionNodeIds).map(
-      (id) => this.nodeMap.get(id)
-    );
-    this.sectionEdges = this.edges.filter((edge) => {
-      const [nodeIdA, nodeIdB] = edge.nodeIds;
-      return sectionNodeIds.has(nodeIdA) && sectionNodeIds.has(nodeIdB);
-    });
-    this.sectionConnectionTerminals = [];
-    for (const conn of this.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) {
-        this.sectionConnectionTerminals.push({
-          connectionName: conn.connection.name,
-          startNodeId,
-          endNodeId
-        });
-      }
-    }
+  computeG(solver) {
+    return solver.iterations / 100;
   }
-  _step() {
-    this.activeSubSolver?.step();
-    if (this.activeSubSolver?.solved) {
-      this.solved = true;
-      return;
-    }
-    if (this.activeSubSolver?.failed) {
-      this.failed = true;
-      this.error = this.activeSubSolver.error;
-      return;
-    }
+  computeH(solver) {
+    return solver.computeProgress();
   }
-  getConstructorParams() {
+  getCombinationDefs() {
+    return [["orderings10"]];
+  }
+  getFailureMessage() {
+    return `All CapacityPathingSingleSection solvers failed for "${this.centerNodeId}"`;
+  }
+  getHyperParameterDefs() {
     return [
       {
-        centerNodeId: this.centerNodeId,
-        connectionsWithNodes: this.connectionsWithNodes,
-        nodes: this.nodes,
-        edges: this.edges,
-        expansionDegrees: this.expansionDegrees
+        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
+          }
+        ]
       }
     ];
   }
-  visualize() {
-    return visualizeSection({
-      sectionNodes: this.sectionNodes,
-      sectionEdges: this.sectionEdges,
-      // Use the computed class property
-      sectionConnectionTerminals: this.sectionConnectionTerminals,
-      nodeMap: this.nodeMap,
-      colorMap: this.colorMap,
-      centerNodeId: this.centerNodeId,
-      nodeOpacity: 1e-3,
-      title: `Section Solver (Center: ${this.centerNodeId}, Hops: ${this.expansionDegrees})`
+  generateSolver(hyperParameters) {
+    return new CapacityPathingSingleSectionPathingSolver({
+      ...this.constructorParams,
+      hyperParameters: {
+        ...this.constructorParams.hyperParameters,
+        ...hyperParameters
+      }
     });
   }
+  onSolve({
+    solver
+  }) {
+    this.winningSolver = solver;
+  }
+  get centerNodeId() {
+    return this.constructorParams.centerNodeId;
+  }
+  get sectionNodes() {
+    return this.constructorParams.sectionNodes;
+  }
+  get sectionConnectionTerminals() {
+    return this.winningSolver?.sectionConnectionTerminals;
+  }
+};
+
+// 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/CapacityPathingMultiSectionSolver.ts
@@ -11912,6 +11979,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   simpleRouteJson;
   nodes;
   edges;
+  nodeEdgeMap;
   connectionsWithNodes = [];
   // Initialize here
   colorMap;
@@ -11923,6 +11991,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
   // Added
   nodeCapacityPercentMap = /* @__PURE__ */ new Map();
   nodeOptimizationAttemptCountMap = /* @__PURE__ */ new Map();
+  currentSection = null;
   sectionSolver = null;
   MAX_ATTEMPTS_PER_NODE = 10;
   MINIMUM_PROBABILITY_OF_FAILURE_TO_OPTIMIZE = 0.05;
@@ -11937,6 +12006,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
     this.nodeMap = new Map(
       this.nodes.map((node) => [node.capacityMeshNodeId, node])
     );
+    this.nodeEdgeMap = getNodeEdgeMap(this.edges);
     this.initialSolver = new CapacityPathingGreedySolver({
       simpleRouteJson: this.simpleRouteJson,
       nodes: this.nodes,
@@ -12002,16 +12072,21 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
         this.solved = true;
         return;
       }
-      this.sectionSolver = new CapacityPathingSingleSectionSolver({
+      const section = computeSectionNodesTerminalsAndEdges({
         centerNodeId,
         connectionsWithNodes: this.connectionsWithNodes,
-        nodes: this.nodes,
+        nodeMap: this.nodeMap,
         edges: this.edges,
+        expansionDegrees: this.MAX_EXPANSION_DEGREES,
+        nodeEdgeMap: this.nodeEdgeMap
+      });
+      this.currentSection = section;
+      this.sectionSolver = new HyperCapacityPathingSingleSectionSolver({
+        sectionConnectionTerminals: section.sectionConnectionTerminals,
+        sectionEdges: section.sectionEdges,
+        sectionNodes: section.sectionNodes,
         colorMap: this.colorMap,
-        hyperParameters: {
-          EXPANSION_DEGREES: this.MAX_EXPANSION_DEGREES,
-          SHUFFLE_SEED: this.iterations
-        }
+        centerNodeId: section.centerNodeId
       });
       this.activeSubSolver = this.sectionSolver;
       this.nodeOptimizationAttemptCountMap.set(
@@ -12022,7 +12097,7 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
     this.sectionSolver.step();
     if (this.sectionSolver.failed) {
       console.warn(
-        `Section solver failed for node ${this.sectionSolver.centerNodeId}. Error: ${this.sectionSolver.error}`
+        `Section solver failed for node ${this.currentSection.centerNodeId}. Error: ${this.sectionSolver.error}`
       );
       this.sectionSolver = null;
       this.activeSubSolver = null;
@@ -12030,12 +12105,12 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
     }
     if (this.sectionSolver.solved) {
       const solvedSectionSolver = this.sectionSolver;
-      const pathingSolver = solvedSectionSolver.activeSubSolver;
+      const pathingSolver = solvedSectionSolver?.activeSubSolver || solvedSectionSolver;
       this.sectionSolver = null;
       this.activeSubSolver = null;
       if (!pathingSolver || !pathingSolver.solved) {
         console.warn(
-          `Pathing sub-solver for section ${solvedSectionSolver.centerNodeId} did not complete successfully. Discarding results.`
+          `Pathing sub-solver for section ${this.currentSection.centerNodeId} did not complete successfully. Discarding results.`
         );
         return;
       }
@@ -12096,18 +12171,18 @@ var CapacityPathingMultiSectionSolver = class extends BaseSolver {
    * connectionsWithNodes list.
    */
   _mergeSolvedSectionPaths(solvedSectionSolver) {
-    const pathingSolver = solvedSectionSolver.activeSubSolver;
-    if (!pathingSolver || !pathingSolver.solved) {
+    const centerNodeId = solvedSectionSolver.centerNodeId;
+    if (!solvedSectionSolver || !solvedSectionSolver.solved) {
       console.warn(
-        `Pathing sub-solver for section ${solvedSectionSolver.centerNodeId} did not complete successfully. Skipping merge.`
+        `Pathing sub-solver for section ${centerNodeId} did not complete successfully. Skipping merge.`
       );
       return;
     }
-    const solvedTerminals = pathingSolver.sectionConnectionTerminals;
+    const solvedTerminals = solvedSectionSolver.sectionConnectionTerminals;
     for (const solvedTerminal of solvedTerminals) {
       if (!solvedTerminal.path) {
         console.warn(
-          `No path found for connection ${solvedTerminal.connectionName} in section ${solvedSectionSolver.centerNodeId}`
+          `No path found for connection ${solvedTerminal.connectionName} in section ${centerNodeId}`
         );
         continue;
       }