@tscircuit/capacity-autorouter 0.0.50 → 0.0.52

package/dist/index.d.ts

@@ -559,6 +559,10 @@ declare class SingleHighDensityRouteSolver extends BaseSolver {
     debug_nodesTooCloseToObstacle: Set<string>;
     debug_nodePathToParentIntersectsObstacle: Set<string>;
     debugEnabled: boolean;
+    initialNodeGridOffset: {
+        x: number;
+        y: number;
+    };
     constructor(opts: {
         connectionName: string;
         obstacleRoutes: HighDensityIntraNodeRoute$1[];
@@ -1225,6 +1229,7 @@ declare class UnravelSectionSolver extends BaseSolver {
     colorMap: Record<string, string>;
     tunedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
     MAX_CANDIDATES: number;
+    iterationsSinceImprovement: number;
     selectedCandidateIndex: number | "best" | "original" | null;
     queuedOrExploredCandidatePointModificationHashes: Set<string>;
     constructor(params: {

package/dist/index.js

@@ -2205,6 +2205,7 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
   debug_nodesTooCloseToObstacle;
   debug_nodePathToParentIntersectsObstacle;
   debugEnabled = true;
+  initialNodeGridOffset;
   constructor(opts) {
     super();
     this.bounds = opts.bounds;
@@ -2250,11 +2251,18 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
     if (this.futureConnections && this.futureConnections.length === 0 && this.obstacleRoutes.length === 0) {
       this.handleSimpleCases();
     }
+    const initialNodePosition = {
+      x: Math.round(opts.A.x / (this.cellStep / 2)) * (this.cellStep / 2),
+      y: Math.round(opts.A.y / (this.cellStep / 2)) * (this.cellStep / 2)
+    };
+    this.initialNodeGridOffset = {
+      x: initialNodePosition.x - Math.round(opts.A.x / this.cellStep) * this.cellStep,
+      y: initialNodePosition.y - Math.round(opts.A.y / this.cellStep) * this.cellStep
+    };
     this.candidates = new SingleRouteCandidatePriorityQueue([
       {
         ...opts.A,
-        x: Math.floor(opts.A.x / this.cellStep) * this.cellStep,
-        y: Math.floor(opts.A.y / this.cellStep) * this.cellStep,
+        ...initialNodePosition,
         z: opts.A.z ?? 0,
         g: 0,
         h: 0,
@@ -2317,7 +2325,7 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
         }
       }
       for (const via of route.vias) {
-        if (distance(node, via) < this.viaDiameter / 2 + margin) {
+        if (distance(node, via) < this.viaDiameter / 2 + this.traceThickness / 2 + margin) {
           return true;
         }
       }
@@ -2484,7 +2492,13 @@ var SingleHighDensityRouteSolver = class extends BaseSolver {
       goalDist,
       currentNode.z === this.B.z
     );
-    if (goalDist <= this.cellStep * Math.SQRT2 && currentNode.z === this.B.z) {
+    if (goalDist <= this.cellStep * Math.SQRT2 && currentNode.z === this.B.z && // Make sure the last segment doesn't intersect an obstacle
+    !this.doesPathToParentIntersectObstacle({
+      ...currentNode,
+      parent: currentNode,
+      x: this.B.x,
+      y: this.B.y
+    })) {
       this.solved = true;
       this.setSolvedPath(currentNode);
     }
@@ -2539,8 +2553,8 @@ z: ${this.B.z}`,
       if (this.debug_nodePathToParentIntersectsObstacle.has(nodeKey)) continue;
       graphics.rects.push({
         center: {
-          x: x + z * this.cellStep / 20,
-          y: y + z * this.cellStep / 20
+          x: x + this.initialNodeGridOffset.x + z * this.cellStep / 20,
+          y: y + this.initialNodeGridOffset.y + z * this.cellStep / 20
         },
         fill: z === 0 ? `rgba(255,0,255,${0.3 - i / this.debug_exploredNodesOrdered.length * 0.2})` : `rgba(0,0,255,${0.3 - i / this.debug_exploredNodesOrdered.length * 0.2})`,
         width: this.cellStep * 0.9,
@@ -4016,20 +4030,17 @@ function distance2(p1, p2) {
 
 // lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/calculateSideTraversal.ts
 var EPSILON2 = 1e-9;
-function calculateSegmentTraversal(startPoint, endPoint, bounds) {
+function calculateSegmentTraversal(startPoint, endPoint, bounds, turnDirection = "cw") {
   const startAngle = pointToAngle(startPoint, bounds);
-  let endAngle = pointToAngle(endPoint, bounds);
-  if (endAngle < startAngle) {
-    endAngle += 2 * Math.PI;
-  }
+  const endAngle = pointToAngle(endPoint, bounds);
   if (Math.abs(endAngle - startAngle) < EPSILON2) {
     return { left: 0, top: 0, right: 0, bottom: 0 };
   }
-  return calculateSidePercentages(startAngle, endAngle, bounds);
+  return calculateSidePercentages(startAngle, endAngle, bounds, turnDirection);
 }
-function calculateTraversalPercentages(A, B, C, bounds) {
-  const percentagesAB = calculateSegmentTraversal(A, B, bounds);
-  const percentagesBC = calculateSegmentTraversal(B, C, bounds);
+function calculateTraversalPercentages(A, B, C, bounds, turnDirection) {
+  const percentagesAB = calculateSegmentTraversal(A, B, bounds, turnDirection);
+  const percentagesBC = calculateSegmentTraversal(B, C, bounds, turnDirection);
   const totalPercentages = {
     left: Math.min(1, percentagesAB.left + percentagesBC.left),
     top: Math.min(1, percentagesAB.top + percentagesBC.top),
@@ -4066,7 +4077,7 @@ function pointToAngle(point, bounds) {
   distance6 = Math.max(0, Math.min(perimeter, distance6));
   return perimeter > EPSILON2 ? distance6 / perimeter * (2 * Math.PI) : 0;
 }
-function calculateSidePercentages(startAngle, endAngle, bounds) {
+function calculateSidePercentages(startAngle, endAngle, bounds, turnDirection) {
   const width = bounds.maxX - bounds.minX;
   const height = bounds.maxY - bounds.minY;
   if (width < EPSILON2 && height < EPSILON2)
@@ -4090,17 +4101,54 @@ function calculateSidePercentages(startAngle, endAngle, bounds) {
     // Ends at 2PI
   ];
   const result = { left: 0, top: 0, right: 0, bottom: 0 };
-  const totalAngleTraversal = endAngle - startAngle;
-  if (totalAngleTraversal < EPSILON2) return result;
+  const calculateTraversalOverlap = (sStart, sEnd, tStart, tEnd, wrapsAround) => {
+    const effectiveSEnd = sEnd > 2 * Math.PI - EPSILON2 ? 2 * Math.PI : sEnd;
+    if (effectiveSEnd <= sStart + EPSILON2) return 0;
+    if (!wrapsAround) {
+      const overlapStart = Math.max(sStart, tStart);
+      const overlapEnd = Math.min(effectiveSEnd, tEnd);
+      return Math.max(0, overlapEnd - overlapStart);
+    } else {
+      const overlap1Start = Math.max(sStart, tStart);
+      const overlap1End = Math.min(effectiveSEnd, 2 * Math.PI);
+      const overlap1 = Math.max(0, overlap1End - overlap1Start);
+      const overlap2Start = Math.max(sStart, 0);
+      const overlap2End = Math.min(effectiveSEnd, tEnd);
+      const overlap2 = Math.max(0, overlap2End - overlap2Start);
+      return overlap1 + overlap2;
+    }
+  };
   for (const side of sides) {
     const sideAngleRange = side.end - side.start;
     if (sideAngleRange < EPSILON2 || side.length < EPSILON2) continue;
-    const overlapStart = Math.max(startAngle, side.start);
-    const overlapEnd = Math.min(endAngle, side.end);
-    if (overlapStart < overlapEnd - EPSILON2) {
-      const traversedAngleOnSide = overlapEnd - overlapStart;
+    let traversedAngleOnSide = 0;
+    if (turnDirection === "cw") {
+      const wraps = startAngle > endAngle + EPSILON2;
+      traversedAngleOnSide = calculateTraversalOverlap(
+        side.start,
+        side.end,
+        startAngle,
+        endAngle,
+        wraps
+      );
+    } else {
+      const wraps = endAngle > startAngle + EPSILON2;
+      traversedAngleOnSide = calculateTraversalOverlap(
+        side.start,
+        side.end,
+        endAngle,
+        // Start of equivalent CW traversal
+        startAngle,
+        // End of equivalent CW traversal
+        wraps
+      );
+    }
+    if (traversedAngleOnSide > EPSILON2) {
       const percentage = traversedAngleOnSide / sideAngleRange;
-      result[side.name] += Math.max(0, percentage);
+      result[side.name] += Math.max(
+        0,
+        Number.isFinite(percentage) ? percentage : 0
+      );
     }
   }
   for (const key in result) {
@@ -4112,6 +4160,28 @@ function calculateSidePercentages(startAngle, endAngle, bounds) {
   return result;
 }
 
+// lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/computeTurnDirection.ts
+function triangleDirection({
+  angleA,
+  angleB,
+  angleC
+}) {
+  const Ax = Math.cos(angleA);
+  const Ay = Math.sin(angleA);
+  const Bx = Math.cos(angleB);
+  const By = Math.sin(angleB);
+  const Cx = Math.cos(angleC);
+  const Cy = Math.sin(angleC);
+  const signedArea = (Bx - Ax) * (Cy - Ay) - (By - Ay) * (Cx - Ax);
+  return signedArea < 0 ? "ccw" : "cw";
+}
+function computeTurnDirection(A, B, C, bounds) {
+  const angleA = pointToAngle(A, bounds);
+  const angleB = pointToAngle(B, bounds);
+  const angleC = pointToAngle(C, bounds);
+  return triangleDirection({ angleA, angleB, angleC });
+}
+
 // lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/SingleTransitionCrossingRouteSolver.ts
 var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
   // Input parameters
@@ -4199,7 +4269,14 @@ var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
     const A = flatRoute.A;
     const B = ntrP1;
     const C = flatRoute.B;
-    const sideTraversal = calculateTraversalPercentages(A, B, C, this.bounds);
+    const turnDirection = computeTurnDirection(A, B, C, this.bounds);
+    const sideTraversal = calculateTraversalPercentages(
+      A,
+      B,
+      C,
+      this.bounds,
+      turnDirection
+    );
     const viaBounds = {
       minX: this.bounds.minX + (sideTraversal.left > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
       minY: this.bounds.minY + (sideTraversal.bottom > 0.5 ? marginFromBorderWithTrace : marginFromBorderWithoutTrace),
@@ -4277,23 +4354,29 @@ var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
       otherRouteStart.z !== flatStart.z ? otherRouteStart : otherRouteEnd,
       this.traceThickness
     );
-    const p1 = findPointToGetAroundCircle(flatStart, p2, {
+    const viaCircle = {
       center: { x: via.x, y: via.y },
       radius: minDistFromViaToTrace
-    }).E;
-    const p3 = findPointToGetAroundCircle(p2, flatEnd, {
-      center: { x: via.x, y: via.y },
-      radius: minDistFromViaToTrace
-    }).E;
-    const p1IsNeeded = pointToSegmentDistance(via, flatStart, p2) < minDistFromViaToTrace;
-    const p3IsNeeded = pointToSegmentDistance(via, p2, flatEnd) < minDistFromViaToTrace;
+    };
+    const p1 = findPointToGetAroundCircle(flatStart, p2, viaCircle).E;
+    const p3 = findPointToGetAroundCircle(p2, flatEnd, viaCircle).E;
+    const p0_5 = findPointToGetAroundCircle(flatStart, p1, viaCircle).E;
+    const p1_5 = findPointToGetAroundCircle(p1, p2, viaCircle).E;
+    const p2_5 = findPointToGetAroundCircle(p2, p3, viaCircle).E;
+    const p3_5 = findPointToGetAroundCircle(p3, flatEnd, viaCircle).E;
+    const p2_better = findPointToGetAroundCircle(p1_5, p2_5, viaCircle).E;
     return {
       connectionName: flatRouteConnectionName,
       route: [
         { x: flatStart.x, y: flatStart.y, z: flatStart.z ?? 0 },
-        ...p1IsNeeded ? [{ x: p1.x, y: p1.y, z: flatStart.z ?? 0 }] : [],
-        { x: p2.x, y: p2.y, z: flatStart.z ?? 0 },
-        ...p3IsNeeded ? [{ x: p3.x, y: p3.y, z: flatStart.z ?? 0 }] : [],
+        { x: p0_5.x, y: p0_5.y, z: flatStart.z ?? 0 },
+        { x: p1.x, y: p1.y, z: flatStart.z ?? 0 },
+        { x: p1_5.x, y: p1_5.y, z: flatStart.z ?? 0 },
+        // { x: p2.x, y: p2.y, z: flatStart.z ?? 0 },
+        { x: p2_better.x, y: p2_better.y, z: flatStart.z ?? 0 },
+        { x: p2_5.x, y: p2_5.y, z: flatStart.z ?? 0 },
+        { x: p3.x, y: p3.y, z: flatStart.z ?? 0 },
+        { x: p3_5.x, y: p3_5.y, z: flatStart.z ?? 0 },
         { x: flatEnd.x, y: flatEnd.y, z: flatEnd.z ?? 0 }
       ],
       traceThickness: this.traceThickness,
@@ -5784,11 +5867,13 @@ var UnravelSectionSolver = class extends BaseSolver {
   colorMap;
   tunedNodeCapacityMap;
   MAX_CANDIDATES = 500;
+  iterationsSinceImprovement = 0;
   selectedCandidateIndex = null;
   queuedOrExploredCandidatePointModificationHashes = /* @__PURE__ */ new Set();
   constructor(params) {
     super();
     this.MUTABLE_HOPS = params.MUTABLE_HOPS ?? this.MUTABLE_HOPS;
+    this.MAX_ITERATIONS = 5e4;
     this.nodeMap = params.nodeMap;
     this.dedupedSegments = params.dedupedSegments;
     if (params.dedupedSegmentMap) {
@@ -6183,6 +6268,7 @@ var UnravelSectionSolver = class extends BaseSolver {
   }
   _step() {
     const candidate = this.candidates.shift();
+    this.iterationsSinceImprovement++;
     if (!candidate) {
       this.solved = true;
       return;
@@ -6190,6 +6276,7 @@ var UnravelSectionSolver = class extends BaseSolver {
     this.lastProcessedCandidate = candidate;
     if (candidate.f < (this.bestCandidate?.f ?? Infinity)) {
       this.bestCandidate = candidate;
+      this.iterationsSinceImprovement = 0;
     }
     this.getNeighbors(candidate).forEach((neighbor) => {
       const isPartialHashExplored = this.queuedOrExploredCandidatePointModificationHashes.has(
@@ -6591,8 +6678,7 @@ var UnravelMultiSectionSolver = class extends BaseSolver {
     }
     this.activeSolver.step();
     const { bestCandidate, originalCandidate, lastProcessedCandidate } = this.activeSolver;
-    const giveUpFactor = 1 + 4 * (1 - Math.min(1, this.activeSolver.iterations / 40));
-    const shouldEarlyStop = lastProcessedCandidate && lastProcessedCandidate.g > bestCandidate.g * giveUpFactor;
+    const shouldEarlyStop = this.activeSolver.iterationsSinceImprovement > 200;
     if (this.activeSolver.solved || shouldEarlyStop) {
       const foundBetterSolution = bestCandidate && bestCandidate.g < originalCandidate.g;
       if (foundBetterSolution) {
@@ -7909,13 +7995,13 @@ function minimumDistanceBetweenSegments(A1, A2, B1, B2) {
   if (segmentsIntersect(A1, A2, B1, B2)) {
     return 0;
   }
-  const distA1 = pointToSegmentDistance4(A1, B1, B2);
-  const distA2 = pointToSegmentDistance4(A2, B1, B2);
-  const distB1 = pointToSegmentDistance4(B1, A1, A2);
-  const distB2 = pointToSegmentDistance4(B2, A1, A2);
+  const distA1 = pointToSegmentDistance5(A1, B1, B2);
+  const distA2 = pointToSegmentDistance5(A2, B1, B2);
+  const distB1 = pointToSegmentDistance5(B1, A1, A2);
+  const distB2 = pointToSegmentDistance5(B2, A1, A2);
   return Math.min(distA1, distA2, distB1, distB2);
 }
-function pointToSegmentDistance4(P, Q1, Q2) {
+function pointToSegmentDistance5(P, Q1, Q2) {
   const v = { x: Q2.x - Q1.x, y: Q2.y - Q1.y };
   const w = { x: P.x - Q1.x, y: P.y - Q1.y };
   const c1 = dotProduct(w, v);