@tscircuit/capacity-autorouter 0.0.39 → 0.0.40

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(",")}`,
@@ -6040,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)) {
@@ -6098,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]
@@ -6114,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")
             });
           }
@@ -6201,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.
@@ -6217,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);
   }
 };
 
@@ -6362,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;
     }