@tscircuit/capacity-autorouter 0.0.39 → 0.0.41

package/dist/index.d.ts

@@ -259,6 +259,7 @@ declare class CapacityPathingSolver extends BaseSolver {
         connection: SimpleRouteConnection;
         nodes: CapacityMeshNode[];
         path?: CapacityMeshNode[];
+        straightLineDistance: number;
     }>;
     usedNodeCapacityMap: Map<CapacityMeshNodeId, number>;
     simpleRouteJson: SimpleRouteJson;
@@ -291,6 +292,7 @@ declare class CapacityPathingSolver extends BaseSolver {
             connection: SimpleRouteConnection;
             nodes: CapacityMeshNode[];
             pathFound: boolean;
+            straightLineDistance: number;
         }[];
         connectionNameToGoalNodeIds: Map<string, string[]>;
     };
@@ -1420,10 +1422,10 @@ interface CapacityMeshSolverOptions {
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
     solverName: string;
     solverClass: T;
-    getConstructorParams: (instance: CapacityMeshSolver) => ConstructorParameters<T>;
-    onSolved?: (instance: CapacityMeshSolver) => void;
+    getConstructorParams: (instance: AutoroutingPipelineSolver) => ConstructorParameters<T>;
+    onSolved?: (instance: AutoroutingPipelineSolver) => void;
 };
-declare class CapacityMeshSolver extends BaseSolver {
+declare class AutoroutingPipelineSolver extends BaseSolver {
     srj: SimpleRouteJson;
     opts: CapacityMeshSolverOptions;
     netToPointPairsSolver?: NetToPointPairsSolver;
@@ -1452,6 +1454,7 @@ declare class CapacityMeshSolver extends BaseSolver {
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions);
     currentPipelineStepIndex: number;
     _step(): void;
+    solveUntilPhase(phase: string): void;
     getCurrentPhase(): string;
     visualize(): GraphicsObject;
     /**
@@ -1477,6 +1480,9 @@ declare class CapacityMeshSolver extends BaseSolver {
     getOutputSimplifiedPcbTraces(): SimplifiedPcbTraces;
     getOutputSimpleRouteJson(): SimpleRouteJson;
 }
+/** @deprecated Use AutoroutingPipelineSolver instead */
+declare const CapacityMeshSolver: typeof AutoroutingPipelineSolver;
+type CapacityMeshSolver = AutoroutingPipelineSolver;
 
 /**
  * Calculate the capacity of a node based on its width

package/dist/index.js

@@ -5122,47 +5122,72 @@ var UnravelSectionSolver = class extends BaseSolver {
       const Bmutable = this.unravelSection.mutableSegmentIds.has(B.segmentId);
       const Cmutable = this.unravelSection.mutableSegmentIds.has(C.segmentId);
       const Dmutable = this.unravelSection.mutableSegmentIds.has(D.segmentId);
+      const aSegment = this.dedupedSegmentMap.get(A.segmentId);
+      const bSegment = this.dedupedSegmentMap.get(B.segmentId);
+      const cSegment = this.dedupedSegmentMap.get(C.segmentId);
+      const dSegment = this.dedupedSegmentMap.get(D.segmentId);
+      const isNewZAvailableForAll = (segmentObjects, newZ) => {
+        return segmentObjects.every((seg) => seg.availableZ.includes(newZ));
+      };
       if (Amutable && Bmutable) {
-        operations.push({
-          type: "change_layer",
-          newZ: A.z === 0 ? 1 : 0,
-          segmentPointIds: [APointId, BPointId]
-        });
+        const newZ = A.z === 0 ? 1 : 0;
+        if (isNewZAvailableForAll([aSegment, bSegment], newZ)) {
+          operations.push({
+            type: "change_layer",
+            newZ,
+            segmentPointIds: [APointId, BPointId]
+          });
+        }
       }
       if (Cmutable && Dmutable) {
-        operations.push({
-          type: "change_layer",
-          newZ: C.z === 0 ? 1 : 0,
-          segmentPointIds: [CPointId, DPointId]
-        });
+        const newZ = C.z === 0 ? 1 : 0;
+        if (isNewZAvailableForAll([cSegment, dSegment], newZ)) {
+          operations.push({
+            type: "change_layer",
+            newZ,
+            segmentPointIds: [CPointId, DPointId]
+          });
+        }
       }
       if (Amutable) {
-        operations.push({
-          type: "change_layer",
-          newZ: A.z === 0 ? 1 : 0,
-          segmentPointIds: [APointId]
-        });
+        const newZ = A.z === 0 ? 1 : 0;
+        if (aSegment.availableZ.includes(newZ)) {
+          operations.push({
+            type: "change_layer",
+            newZ,
+            segmentPointIds: [APointId]
+          });
+        }
       }
       if (Bmutable) {
-        operations.push({
-          type: "change_layer",
-          newZ: B.z === 0 ? 1 : 0,
-          segmentPointIds: [BPointId]
-        });
+        const newZ = B.z === 0 ? 1 : 0;
+        if (bSegment.availableZ.includes(newZ)) {
+          operations.push({
+            type: "change_layer",
+            newZ,
+            segmentPointIds: [BPointId]
+          });
+        }
       }
       if (Cmutable) {
-        operations.push({
-          type: "change_layer",
-          newZ: C.z === 0 ? 1 : 0,
-          segmentPointIds: [CPointId]
-        });
+        const newZ = C.z === 0 ? 1 : 0;
+        if (cSegment.availableZ.includes(newZ)) {
+          operations.push({
+            type: "change_layer",
+            newZ,
+            segmentPointIds: [CPointId]
+          });
+        }
       }
       if (Dmutable) {
-        operations.push({
-          type: "change_layer",
-          newZ: D.z === 0 ? 1 : 0,
-          segmentPointIds: [DPointId]
-        });
+        const newZ = D.z === 0 ? 1 : 0;
+        if (dSegment.availableZ.includes(newZ)) {
+          operations.push({
+            type: "change_layer",
+            newZ,
+            segmentPointIds: [DPointId]
+          });
+        }
       }
     }
     return operations;
@@ -5851,6 +5876,7 @@ var createRectFromCapacityNode = (node, opts = {}) => {
       "0": "rgba(0,200,200, 0.1)",
       "1": "rgba(0,0,200, 0.1)"
     }[node.availableZ.join(",")] ?? "rgba(0,200,200,0.1)",
+    layer: `z${node.availableZ.join(",")}`,
     label: [
       node.capacityMeshNodeId,
       `availableZ: ${node.availableZ.join(",")}`,
@@ -5942,9 +5968,16 @@ var CapacityPathingSolver = class extends BaseSolver {
       connectionsWithNodes.push({
         connection,
         nodes: nodesForConnection,
-        pathFound: false
+        pathFound: false,
+        straightLineDistance: distance(
+          nodesForConnection[0].center,
+          nodesForConnection[nodesForConnection.length - 1].center
+        )
       });
     }
+    connectionsWithNodes.sort(
+      (a, b) => a.straightLineDistance - b.straightLineDistance
+    );
     return { connectionsWithNodes, connectionNameToGoalNodeIds };
   }
   currentConnectionIndex = 0;
@@ -6040,6 +6073,7 @@ var CapacityPathingSolver = class extends BaseSolver {
       this.currentConnectionIndex++;
       this.candidates = null;
       this.visitedNodes = null;
+      this.failed = true;
       return;
     }
     if (this.isConnectedToEndGoal(currentCandidate.node, end)) {
@@ -6098,11 +6132,14 @@ var CapacityPathingSolver = class extends BaseSolver {
       for (let i = 0; i < this.connectionsWithNodes.length; i++) {
         const conn = this.connectionsWithNodes[i];
         if (conn.path && conn.path.length > 0) {
-          const pathPoints = conn.path.map(({ center: { x, y }, width }) => ({
-            // slight offset to allow viewing overlapping paths
-            x: x + (i % 10 + i % 19) * (5e-3 * width),
-            y: y + (i % 10 + i % 19) * (5e-3 * width)
-          }));
+          const pathPoints = conn.path.map(
+            ({ center: { x, y }, width, availableZ }) => ({
+              // slight offset to allow viewing overlapping paths
+              x: x + (i % 10 + i % 19) * (5e-3 * width),
+              y: y + (i % 10 + i % 19) * (5e-3 * width),
+              availableZ
+            })
+          );
           graphics.lines.push({
             points: pathPoints,
             strokeColor: this.colorMap[conn.connection.name]
@@ -6114,7 +6151,8 @@ var CapacityPathingSolver = class extends BaseSolver {
               y: point.y,
               label: [
                 `conn: ${conn.connection.name}`,
-                `node: ${conn.path[u].capacityMeshNodeId}`
+                `node: ${conn.path[u].capacityMeshNodeId}`,
+                `z: ${point.availableZ.join(",")}`
               ].join("\n")
             });
           }
@@ -6201,7 +6239,20 @@ var CapacityPathingSolver5 = class extends CapacityPathingSolver {
    * Penalty you pay for using this node
    */
   getNodeCapacityPenalty(node) {
-    return 0.05;
+    const MAX_PENALTY = node.width + node.height;
+    const MIN_PENALTY = 0.05;
+    const START_PENALIZING_CAPACITY_WHEN_IT_DROPS_BELOW = 2;
+    const totalCapacity = this.getTotalCapacity(node);
+    const usedCapacity = this.usedNodeCapacityMap.get(node.capacityMeshNodeId) ?? 0;
+    const remainingCapacity = totalCapacity - usedCapacity;
+    if (remainingCapacity > START_PENALIZING_CAPACITY_WHEN_IT_DROPS_BELOW) {
+      return MIN_PENALTY;
+    }
+    const penalty = (MAX_PENALTY - MIN_PENALTY) * Math.max(
+      1,
+      (START_PENALIZING_CAPACITY_WHEN_IT_DROPS_BELOW - remainingCapacity) / (MAX_PENALTY - MIN_PENALTY)
+    ) + MIN_PENALTY;
+    return penalty;
   }
   /**
    * We're rewarding travel into big nodes.
@@ -6217,7 +6268,7 @@ var CapacityPathingSolver5 = class extends CapacityPathingSolver {
     return prevCandidate.g + this.getDistanceBetweenNodes(prevCandidate.node, node) + this.getNodeCapacityPenalty(node);
   }
   computeH(prevCandidate, node, endGoal) {
-    return this.getDistanceBetweenNodes(node, endGoal);
+    return this.getDistanceBetweenNodes(node, endGoal) + this.getNodeCapacityPenalty(node);
   }
 };
 
@@ -6362,7 +6413,7 @@ var StrawSolver = class extends BaseSolver {
       this.solved = true;
       return;
     }
-    if (rootNode.width < this.strawSize * 5 && rootNode.height < this.strawSize * 5) {
+    if (rootNode.width < this.strawSize && rootNode.height < this.strawSize) {
       this.skippedNodes.push(rootNode);
       return;
     }
@@ -7796,7 +7847,7 @@ function definePipelineStep(solverName, solverClass, getConstructorParams, opts
     onSolved: opts.onSolved
   };
 }
-var CapacityMeshSolver = class extends BaseSolver {
+var AutoroutingPipelineSolver = class extends BaseSolver {
   constructor(srj, opts = {}) {
     super();
     this.srj = srj;
@@ -8028,6 +8079,11 @@ var CapacityMeshSolver = class extends BaseSolver {
     this.timeSpentOnPhase[pipelineStepDef.solverName] = 0;
     this.startTimeOfPhase[pipelineStepDef.solverName] = performance.now();
   }
+  solveUntilPhase(phase) {
+    while (this.getCurrentPhase() !== phase) {
+      this.step();
+    }
+  }
   getCurrentPhase() {
     return this.pipelineDef[this.currentPipelineStepIndex]?.solverName ?? "none";
   }
@@ -8198,6 +8254,7 @@ var CapacityMeshSolver = class extends BaseSolver {
     };
   }
 };
+var CapacityMeshSolver = AutoroutingPipelineSolver;
 export {
   CapacityMeshSolver,
   calculateOptimalCapacityDepth,