@tscircuit/capacity-autorouter 0.0.87 → 0.0.89

package/dist/index.d.ts

@@ -35,8 +35,10 @@ interface SimpleRouteConnection {
         x: number;
         y: number;
         layer: string;
+        pointId?: string;
         pcb_port_id?: string;
     }>;
+    externallyConnectedPointIds?: string[][];
 }
 interface SimplifiedPcbTrace {
     type: "pcb_trace";
@@ -114,6 +116,12 @@ declare class BaseSolver {
     getConstructorParams(): void;
     solve(): void;
     visualize(): GraphicsObject;
+    /**
+     * Called when the solver is about to fail, but we want to see if we have an
+     * "acceptable" or "passable" solution. Mostly used for optimizers that
+     * have an aggressive early stopping criterion.
+     */
+    tryFinalAcceptance(): void;
     /**
      * A lightweight version of the visualize method that can be used to stream
      * progress
@@ -422,6 +430,7 @@ interface HighDensityHyperParameters {
     SEGMENTS_PER_POLYLINE: number;
     BOUNDARY_PADDING: number;
     ITERATION_PENALTY: number;
+    MINIMUM_FINAL_ACCEPTANCE_GAP?: number;
 }
 
 type Node = {
@@ -762,11 +771,13 @@ declare class HyperSingleIntraNodeSolver extends HyperParameterSupervisorSolver<
             SEGMENTS_PER_POLYLINE: number;
             BOUNDARY_PADDING: number;
             ITERATION_PENALTY?: undefined;
+            MINIMUM_FINAL_ACCEPTANCE_GAP?: undefined;
         } | {
             MULTI_HEAD_POLYLINE_SOLVER: boolean;
             SEGMENTS_PER_POLYLINE: number;
             BOUNDARY_PADDING: number;
             ITERATION_PENALTY: number;
+            MINIMUM_FINAL_ACCEPTANCE_GAP: number;
         })[];
     })[];
     computeG(solver: IntraNodeRouteSolver): number;

package/dist/index.js

@@ -67,6 +67,9 @@ var BaseSolver = class {
       this.failed = true;
       throw e;
     }
+    if (!this.solved && this.iterations > this.MAX_ITERATIONS) {
+      this.tryFinalAcceptance();
+    }
     if (!this.solved && this.iterations > this.MAX_ITERATIONS) {
       this.error = `${this.constructor.name} ran out of iterations`;
       console.error(this.error);
@@ -97,6 +100,13 @@ var BaseSolver = class {
       circles: []
     };
   }
+  /**
+   * Called when the solver is about to fail, but we want to see if we have an
+   * "acceptable" or "passable" solution. Mostly used for optimizers that
+   * have an aggressive early stopping criterion.
+   */
+  tryFinalAcceptance() {
+  }
   /**
    * A lightweight version of the visualize method that can be used to stream
    * progress
@@ -8172,6 +8182,21 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
     });
     return minGapsToOtherConnectionsValid && allPointsWithinBounds;
   }
+  // ------------------------------------------------------------------
+  //  Try accepting the best candidate even if normal solving failed.
+  // ------------------------------------------------------------------
+  tryFinalAcceptance() {
+    const minGapTarget = this.hyperParameters?.MINIMUM_FINAL_ACCEPTANCE_GAP ?? void 0;
+    if (minGapTarget === void 0 || this.lastCandidate === null || this.lastCandidate.minGaps.length === 0)
+      return;
+    const minGapAchieved = Math.min(...this.lastCandidate.minGaps);
+    if (minGapAchieved >= minGapTarget) {
+      this.solved = true;
+      this._setSolvedRoutes();
+      return;
+    }
+    return;
+  }
   _step() {
     if (this.phase === "setup") {
       this.setupInitialPolyLines();
@@ -8180,6 +8205,8 @@ var MultiHeadPolyLineIntraNodeSolver = class extends BaseSolver {
     }
     const currentCandidate = this.candidates.shift();
     if (!currentCandidate) {
+      this.tryFinalAcceptance();
+      if (this.solved) return;
       this.failed = true;
       this.error = "No candidates left";
       return;
@@ -8413,6 +8440,8 @@ var MultiHeadPolyLineIntraNodeSolver2 = class extends MultiHeadPolyLineIntraNode
     }
     const currentCandidate = this.candidates.shift();
     if (!currentCandidate) {
+      this.tryFinalAcceptance();
+      if (this.solved) return;
       this.failed = true;
       return;
     }
@@ -9063,7 +9092,8 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
             SEGMENTS_PER_POLYLINE: 6,
             BOUNDARY_PADDING: -0.05,
             // Allow vias/traces outside the boundary
-            ITERATION_PENALTY: 1e4
+            ITERATION_PENALTY: 1e4,
+            MINIMUM_FINAL_ACCEPTANCE_GAP: 1e-3
           }
         ]
       }
@@ -9585,16 +9615,34 @@ var NetToPointPairsSolver = class extends BaseSolver {
       return;
     }
     const connection = this.unprocessedConnections.pop();
+    const externalGroups = connection.externallyConnectedPointIds ?? [];
+    const pointIdToGroup = /* @__PURE__ */ new Map();
+    externalGroups.forEach(
+      (group, idx) => group.forEach((pid) => pointIdToGroup.set(pid, idx))
+    );
+    const areExternallyConnected = (a, b) => {
+      if (!a.pointId || !b.pointId) return false;
+      const g1 = pointIdToGroup.get(a.pointId);
+      const g2 = pointIdToGroup.get(b.pointId);
+      return g1 !== void 0 && g1 === g2;
+    };
     if (connection.pointsToConnect.length === 2) {
+      if (areExternallyConnected(
+        connection.pointsToConnect[0],
+        connection.pointsToConnect[1]
+      )) {
+        return;
+      }
       this.newConnections.push(connection);
       return;
     }
     const edges = buildMinimumSpanningTree(connection.pointsToConnect);
-    for (let i = 0; i < edges.length; i++) {
-      const edge = edges[i];
+    let mstIdx = 0;
+    for (const edge of edges) {
+      if (areExternallyConnected(edge.from, edge.to)) continue;
       this.newConnections.push({
         pointsToConnect: [edge.from, edge.to],
-        name: `${connection.name}_mst${i}`
+        name: `${connection.name}_mst${mstIdx++}`
       });
     }
   }