@tscircuit/capacity-autorouter 0.0.47 → 0.0.49

package/dist/index.js

@@ -8358,26 +8358,59 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       return;
     }
     if (layerChangeBtwHeadAndTail && layerChangeAtDistance > 0) {
-      const pointBeforeChange = this.getPointAtDistance(layerChangeAtDistance);
+      const indexAfterLayerChange = this.getNearestIndexForDistance(layerChangeAtDistance) + 1;
+      const pointAfterChange = this.inputRoute.route[indexAfterLayerChange];
+      const viaLocation = { x: pointAfterChange.x, y: pointAfterChange.y };
       if (this.lastValidPath) {
         this.addPathToResult(this.lastValidPath);
         this.lastValidPath = null;
       }
-      const indexAfterLayerChange = this.getNearestIndexForDistance(layerChangeAtDistance) + 1;
-      const pointAfterChange = this.inputRoute.route[indexAfterLayerChange];
-      this.newVias.push({
-        x: pointAfterChange.x,
-        y: pointAfterChange.y
+      const lastPointInNewRoute = this.newRoute[this.newRoute.length - 1];
+      if (lastPointInNewRoute.x !== viaLocation.x || lastPointInNewRoute.y !== viaLocation.y) {
+        this.newRoute.push({
+          x: viaLocation.x,
+          y: viaLocation.y,
+          z: lastPointInNewRoute.z
+          // Use the Z of the layer we are leaving
+        });
+      }
+      this.newVias.push(viaLocation);
+      this.newRoute.push({
+        x: viaLocation.x,
+        y: viaLocation.y,
+        z: pointAfterChange.z
+        // Use the Z of the layer we are entering
       });
-      this.newRoute.push(pointAfterChange);
       this.currentStepSize = this.maxStepSize;
-      if (this.pathSegments[indexAfterLayerChange]) {
-        this.tailDistanceAlongPath = this.pathSegments[indexAfterLayerChange].startDistance;
+      const segmentIndexAfterChange = this.pathSegments.findIndex(
+        (seg) => seg.start === pointAfterChange
+      );
+      if (segmentIndexAfterChange !== -1) {
+        this.tailDistanceAlongPath = this.pathSegments[segmentIndexAfterChange].startDistance;
         this.headDistanceAlongPath = this.tailDistanceAlongPath;
+        this.lastValidPath = null;
+        this.lastValidPathHeadDistance = this.tailDistanceAlongPath;
+      } else if (indexAfterLayerChange < this.inputRoute.route.length) {
+        console.warn(
+          "Fallback used for tailDistanceAlongPath after layer change"
+        );
+        const segment = this.pathSegments.find(
+          (seg) => seg.start === this.inputRoute.route[indexAfterLayerChange]
+        );
+        if (segment) {
+          this.tailDistanceAlongPath = segment.startDistance;
+          this.headDistanceAlongPath = this.tailDistanceAlongPath;
+          this.lastValidPath = null;
+          this.lastValidPathHeadDistance = this.tailDistanceAlongPath;
+        } else {
+          console.error(
+            "Could not find segment start after layer change, path might be incomplete."
+          );
+          this.solved = true;
+        }
       } else {
-        console.error("Creating via at end, this is probably not right");
+        console.warn("Layer change occurred at the end of the path.");
         this.solved = true;
-        return;
       }
       return;
     }
@@ -8387,8 +8420,17 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       return;
     }
     if (!path45 && !this.lastValidPath) {
+      const oldTailPoint = this.getPointAtDistance(this.tailDistanceAlongPath);
       this.tailDistanceAlongPath += this.minStepSize;
       this.moveHead(this.minStepSize);
+      const newTailIndex = this.getNearestIndexForDistance(
+        this.tailDistanceAlongPath
+      );
+      const newTailPoint = this.inputRoute.route[newTailIndex];
+      const lastRoutePoint = this.inputRoute.route[this.inputRoute.route.length - 1];
+      if (!this.arePointsEqual(oldTailPoint, newTailPoint) && !this.arePointsEqual(newTailPoint, lastRoutePoint)) {
+        this.newRoute.push(newTailPoint);
+      }
       return;
     }
     if (path45) {