@tscircuit/capacity-autorouter 0.0.38 → 0.0.40

package/dist/index.d.ts

@@ -503,6 +503,7 @@ type FutureConnection = {
     points: {
         x: number;
         y: number;
+        z: number;
     }[];
 };
 declare class SingleHighDensityRouteSolver extends BaseSolver {
@@ -619,9 +620,10 @@ declare class IntraNodeRouteSolver extends BaseSolver {
     failedSubSolvers: SingleHighDensityRouteSolver[];
     hyperParameters: Partial<HighDensityHyperParameters>;
     minDistBetweenEnteringPoints: number;
-    activeSolver: SingleHighDensityRouteSolver | null;
+    activeSubSolver: SingleHighDensityRouteSolver | null;
     connMap?: ConnectivityMap;
     get failedSolvers(): SingleHighDensityRouteSolver[];
+    get activeSolver(): SingleHighDensityRouteSolver | null;
     constructor(params: {
         nodeWithPortPoints: NodeWithPortPoints;
         colorMap?: Record<string, string>;

package/dist/index.js

@@ -2454,7 +2454,7 @@ var SingleHighDensityRouteSolver6_VertHorzLayer_FutureCost = class extends Singl
     let closestPoint = null;
     for (const futureConnection of this.futureConnections) {
       for (const point of futureConnection.points) {
-        const dist = distance(node, point);
+        const dist = distance(node, point) + (node.z !== point.z ? this.viaPenaltyDistance : 0);
         if (dist < minDist) {
           minDist = dist;
           closestPoint = point;
@@ -2568,6 +2568,9 @@ var getMinDistBetweenEnteringPoints = (node) => {
   const points = node.portPoints;
   for (let i = 0; i < points.length; i++) {
     for (let j = i + 1; j < points.length; j++) {
+      if (points[i].z !== points[j].z) {
+        continue;
+      }
       const p1 = points[i];
       const p2 = points[j];
       const dist = Math.sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2);
@@ -2587,12 +2590,16 @@ var IntraNodeRouteSolver = class extends BaseSolver {
   failedSubSolvers;
   hyperParameters;
   minDistBetweenEnteringPoints;
-  activeSolver = null;
+  activeSubSolver = null;
   connMap;
   // Legacy compat
   get failedSolvers() {
     return this.failedSubSolvers;
   }
+  // Legacy compat
+  get activeSolver() {
+    return this.activeSubSolver;
+  }
   constructor(params) {
     const { nodeWithPortPoints, colorMap } = params;
     super();
@@ -2651,18 +2658,18 @@ var IntraNodeRouteSolver = class extends BaseSolver {
   //   this.unsolvedConnections = []
   // }
   computeProgress() {
-    return (this.solvedRoutes.length + (this.activeSolver?.progress || 0)) / this.totalConnections;
+    return (this.solvedRoutes.length + (this.activeSubSolver?.progress || 0)) / this.totalConnections;
   }
   _step() {
-    if (this.activeSolver) {
-      this.activeSolver.step();
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
       this.progress = this.computeProgress();
-      if (this.activeSolver.solved) {
-        this.solvedRoutes.push(this.activeSolver.solvedPath);
-        this.activeSolver = null;
-      } else if (this.activeSolver.failed) {
-        this.failedSubSolvers.push(this.activeSolver);
-        this.activeSolver = null;
+      if (this.activeSubSolver.solved) {
+        this.solvedRoutes.push(this.activeSubSolver.solvedPath);
+        this.activeSubSolver = null;
+      } else if (this.activeSubSolver.failed) {
+        this.failedSubSolvers.push(this.activeSubSolver);
+        this.activeSubSolver = null;
         this.error = this.failedSubSolvers.map((s) => s.error).join("\n");
         this.failed = true;
       }
@@ -2684,7 +2691,7 @@ var IntraNodeRouteSolver = class extends BaseSolver {
       }
     }
     const { connectionName, points } = unsolvedConnection;
-    this.activeSolver = new SingleHighDensityRouteSolver6_VertHorzLayer_FutureCost({
+    this.activeSubSolver = new SingleHighDensityRouteSolver6_VertHorzLayer_FutureCost({
       connectionName,
       minDistBetweenEnteringPoints: this.minDistBetweenEnteringPoints,
       bounds: getBoundsFromNodeWithPortPoints(this.nodeWithPortPoints),
@@ -5115,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;
@@ -5844,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(",")}`,
@@ -6033,6 +6066,7 @@ var CapacityPathingSolver = class extends BaseSolver {
       this.currentConnectionIndex++;
       this.candidates = null;
       this.visitedNodes = null;
+      this.failed = true;
       return;
     }
     if (this.isConnectedToEndGoal(currentCandidate.node, end)) {
@@ -6091,11 +6125,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]
@@ -6107,7 +6144,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")
             });
           }
@@ -6194,7 +6232,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.
@@ -6210,7 +6261,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);
   }
 };
 
@@ -6355,7 +6406,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;
     }