@tscircuit/capacity-autorouter 0.0.41 → 0.0.42

package/dist/index.js

@@ -3567,6 +3567,540 @@ var TwoCrossingRoutesHighDensitySolver = class extends BaseSolver {
   }
 };
 
+// lib/utils/findClosestPointToABCWithinBounds.ts
+function findClosestPointToABCWithinBounds(A, B, C, radius, bounds) {
+  const avgPoint = {
+    x: (A.x + B.x + C.x) / 3,
+    y: (A.y + B.y + C.y) / 3
+  };
+  const distance5 = (p1, p2) => {
+    return Math.sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2);
+  };
+  const isValidPoint = (point) => {
+    const distToA = distance5(point, A);
+    const distToB = distance5(point, B);
+    const distToC = distance5(point, C);
+    const withinBounds = point.x >= bounds.minX && point.x <= bounds.maxX && point.y >= bounds.minY && point.y <= bounds.maxY;
+    return distToA >= radius && distToB >= radius && distToC >= radius && withinBounds;
+  };
+  const isOnBoundary = (point) => {
+    const epsilon = 1e-6;
+    return Math.abs(point.x - bounds.minX) < epsilon || Math.abs(point.x - bounds.maxX) < epsilon || Math.abs(point.y - bounds.minY) < epsilon || Math.abs(point.y - bounds.maxY) < epsilon;
+  };
+  if (isValidPoint(avgPoint)) {
+    return avgPoint;
+  }
+  const pointOnCircle = (center, constraint, r) => {
+    const vx = center.x - constraint.x;
+    const vy = center.y - constraint.y;
+    const dist = Math.sqrt(vx * vx + vy * vy);
+    if (dist < 1e-10) {
+      return { x: constraint.x + r, y: constraint.y };
+    }
+    return {
+      x: constraint.x + vx / dist * r,
+      y: constraint.y + vy / dist * r
+    };
+  };
+  const findCircleIntersections = (c1, c2, r) => {
+    const dx = c2.x - c1.x;
+    const dy = c2.y - c1.y;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    if (dist > 2 * r - 1e-10 || dist < 1e-10) {
+      return [];
+    }
+    const a = dist * dist / (2 * dist);
+    const h = Math.sqrt(Math.max(0, r * r - a * a));
+    const midX = c1.x + dx * a / dist;
+    const midY = c1.y + dy * a / dist;
+    const intersection1 = {
+      x: midX + h * dy / dist,
+      y: midY - h * dx / dist
+    };
+    const intersection2 = {
+      x: midX - h * dy / dist,
+      y: midY + h * dx / dist
+    };
+    const result = [];
+    const epsilon = 1e-6;
+    if (Math.abs(distance5(intersection1, c1) - r) < epsilon && Math.abs(distance5(intersection1, c2) - r) < epsilon) {
+      result.push(intersection1);
+    }
+    if (Math.abs(distance5(intersection2, c1) - r) < epsilon && Math.abs(distance5(intersection2, c2) - r) < epsilon) {
+      result.push(intersection2);
+    }
+    return result;
+  };
+  const candidateA = pointOnCircle(avgPoint, A, radius);
+  const candidateB = pointOnCircle(avgPoint, B, radius);
+  const candidateC = pointOnCircle(avgPoint, C, radius);
+  const intersectionsAB = findCircleIntersections(A, B, radius);
+  const intersectionsBC = findCircleIntersections(B, C, radius);
+  const intersectionsCA = findCircleIntersections(C, A, radius);
+  const allCandidates = [
+    candidateA,
+    candidateB,
+    candidateC,
+    ...intersectionsAB,
+    ...intersectionsBC,
+    ...intersectionsCA
+  ];
+  const validCandidates = allCandidates.filter(isValidPoint);
+  if (validCandidates.length > 0) {
+    const interiorCandidates = validCandidates.filter((p) => !isOnBoundary(p));
+    if (interiorCandidates.length > 0) {
+      interiorCandidates.sort(
+        (a, b) => distance5(a, avgPoint) - distance5(b, avgPoint)
+      );
+      return interiorCandidates[0];
+    }
+  }
+  const gridStep = 5;
+  let bestPoint = null;
+  let bestDistance = Infinity;
+  for (let x = bounds.minX + 1; x < bounds.maxX; x += gridStep) {
+    for (let y = bounds.minY + 1; y < bounds.maxY; y += gridStep) {
+      const point = { x, y };
+      if (isValidPoint(point)) {
+        const dist = distance5(point, avgPoint);
+        if (dist < bestDistance) {
+          bestDistance = dist;
+          bestPoint = point;
+        }
+      }
+    }
+  }
+  if (bestPoint !== null) {
+    return bestPoint;
+  }
+  const numSamples = 100;
+  const boundaryPoints = [];
+  for (let i = 0; i <= numSamples; i++) {
+    const t = i / numSamples;
+    boundaryPoints.push({
+      x: bounds.minX + t * (bounds.maxX - bounds.minX),
+      y: bounds.minY
+    });
+    boundaryPoints.push({
+      x: bounds.maxX,
+      y: bounds.minY + t * (bounds.maxY - bounds.minY)
+    });
+    boundaryPoints.push({
+      x: bounds.maxX - t * (bounds.maxX - bounds.minX),
+      y: bounds.maxY
+    });
+    boundaryPoints.push({
+      x: bounds.minX,
+      y: bounds.maxY - t * (bounds.maxY - bounds.minY)
+    });
+  }
+  const validBoundaryPoints = boundaryPoints.filter(isValidPoint);
+  if (validBoundaryPoints.length > 0) {
+    validBoundaryPoints.sort(
+      (a, b) => distance5(a, avgPoint) - distance5(b, avgPoint)
+    );
+    return validBoundaryPoints[0];
+  }
+  let minViolation = Infinity;
+  let leastBadPoint = { x: bounds.minX, y: bounds.minY };
+  for (const point of [...allCandidates, ...boundaryPoints]) {
+    if (point.x >= bounds.minX && point.x <= bounds.maxX && point.y >= bounds.minY && point.y <= bounds.maxY) {
+      const violationA = Math.max(0, radius - distance5(point, A));
+      const violationB = Math.max(0, radius - distance5(point, B));
+      const violationC = Math.max(0, radius - distance5(point, C));
+      const totalViolation = violationA + violationB + violationC;
+      if (totalViolation < minViolation) {
+        minViolation = totalViolation;
+        leastBadPoint = point;
+      }
+    }
+  }
+  return leastBadPoint;
+}
+
+// lib/utils/findPointToGetAroundCircle.ts
+function findPointToGetAroundCircle(A, C, Q) {
+  const B = computeTangentPoint(C, A, Q.center, Q.radius);
+  const D = computeTangentPoint(A, C, Q.center, Q.radius);
+  const E = computeIntersection(
+    { x: C.x, y: C.y },
+    { x: B.x, y: B.y },
+    { x: A.x, y: A.y },
+    { x: D.x, y: D.y }
+  );
+  return { B, D, E };
+}
+function computeTangentPoint(observationPoint, referencePoint, circleCenter, radius) {
+  const CQ = [
+    circleCenter.x - observationPoint.x,
+    circleCenter.y - observationPoint.y
+  ];
+  const CQLength = Math.sqrt(CQ[0] * CQ[0] + CQ[1] * CQ[1]);
+  if (CQLength < radius) {
+    return observationPoint;
+  }
+  const CR = [
+    referencePoint.x - observationPoint.x,
+    referencePoint.y - observationPoint.y
+  ];
+  const d = Math.sqrt(CQLength * CQLength - radius * radius);
+  const CQUnit = [CQ[0] / CQLength, CQ[1] / CQLength];
+  const perp1 = [-CQUnit[1], CQUnit[0]];
+  const perp2 = [CQUnit[1], -CQUnit[0]];
+  const dot1 = CR[0] * perp1[0] + CR[1] * perp1[1];
+  const dot2 = CR[0] * perp2[0] + CR[1] * perp2[1];
+  const perp = dot1 > dot2 ? perp1 : perp2;
+  const sinTheta = radius / CQLength;
+  const cosTheta = d / CQLength;
+  const unitToTangent = [
+    CQUnit[0] * cosTheta + perp[0] * sinTheta,
+    CQUnit[1] * cosTheta + perp[1] * sinTheta
+  ];
+  return {
+    x: observationPoint.x + d * unitToTangent[0],
+    y: observationPoint.y + d * unitToTangent[1]
+  };
+}
+function computeIntersection(p1, p2, p3, p4) {
+  const a1 = p2.y - p1.y;
+  const b1 = p1.x - p2.x;
+  const c1 = a1 * p1.x + b1 * p1.y;
+  const a2 = p4.y - p3.y;
+  const b2 = p3.x - p4.x;
+  const c2 = a2 * p3.x + b2 * p3.y;
+  const det = a1 * b2 - a2 * b1;
+  if (Math.abs(det) < 1e-8) {
+    return {
+      x: (p1.x + p3.x) / 2,
+      y: (p1.y + p3.y) / 2
+    };
+  }
+  const x = (b2 * c1 - b1 * c2) / det;
+  const y = (a1 * c2 - a2 * c1) / det;
+  return { x, y };
+}
+
+// lib/solvers/HighDensitySolver/TwoRouteHighDensitySolver/SingleTransitionCrossingRouteSolver.ts
+var SingleTransitionCrossingRouteSolver = class extends BaseSolver {
+  // Input parameters
+  nodeWithPortPoints;
+  routes;
+  // Configuration parameters
+  viaDiameter;
+  traceThickness;
+  obstacleMargin;
+  layerCount = 2;
+  debugViaPositions;
+  // Solution state
+  solvedRoutes = [];
+  // Bounds
+  bounds;
+  constructor(params) {
+    super();
+    this.nodeWithPortPoints = params.nodeWithPortPoints;
+    this.viaDiameter = params?.viaDiameter ?? 0.6;
+    this.traceThickness = params?.traceThickness ?? 0.15;
+    this.obstacleMargin = params?.obstacleMargin ?? 0.1;
+    this.layerCount = params?.layerCount ?? 2;
+    this.debugViaPositions = [];
+    this.routes = this.extractRoutesFromNode();
+    this.bounds = this.calculateBounds();
+    if (this.routes.length !== 2) {
+      this.failed = true;
+      return;
+    }
+    const [routeA, routeB] = this.routes;
+    const routeAHasTransition = routeA.A.z !== routeA.B.z;
+    const routeBHasTransition = routeB.A.z !== routeB.B.z;
+    if (routeAHasTransition && routeBHasTransition || !routeAHasTransition && !routeBHasTransition) {
+      this.failed = true;
+      return;
+    }
+  }
+  /**
+   * Extract routes that need to be connected from the node data
+   */
+  extractRoutesFromNode() {
+    const routes = [];
+    const connectedPorts = this.nodeWithPortPoints.portPoints;
+    const connectionGroups = /* @__PURE__ */ new Map();
+    for (const connectedPort of connectedPorts) {
+      const { connectionName } = connectedPort;
+      if (!connectionGroups.has(connectionName)) {
+        connectionGroups.set(connectionName, []);
+      }
+      connectionGroups.get(connectionName)?.push(connectedPort);
+    }
+    for (const [connectionName, points] of connectionGroups.entries()) {
+      if (points.length === 2) {
+        routes.push({
+          A: { ...points[0], z: points[0].z ?? 0 },
+          B: { ...points[1], z: points[1].z ?? 0 },
+          connectionName
+        });
+      }
+    }
+    return routes;
+  }
+  /**
+   * Calculate the bounding box of the node
+   */
+  calculateBounds() {
+    return {
+      minX: this.nodeWithPortPoints.center.x - this.nodeWithPortPoints.width / 2,
+      maxX: this.nodeWithPortPoints.center.x + this.nodeWithPortPoints.width / 2,
+      minY: this.nodeWithPortPoints.center.y - this.nodeWithPortPoints.height / 2,
+      maxY: this.nodeWithPortPoints.center.y + this.nodeWithPortPoints.height / 2
+    };
+  }
+  /**
+   * Check if two routes are crossing
+   */
+  doRoutesCross(routeA, routeB) {
+    return doSegmentsIntersect(routeA.A, routeA.B, routeB.A, routeB.B);
+  }
+  calculateViaPosition(transitionRoute, flatRoute) {
+    const flatRouteZ = flatRoute.A.z;
+    const ntrP1 = transitionRoute.A.z !== flatRouteZ ? transitionRoute.A : transitionRoute.B;
+    const marginFromBorderWithTrace = this.obstacleMargin * 2 + this.viaDiameter / 2 + this.traceThickness;
+    const marginFromBorderWithoutTrace = this.obstacleMargin + this.viaDiameter / 2;
+    return findClosestPointToABCWithinBounds(
+      flatRoute.A,
+      flatRoute.B,
+      ntrP1,
+      marginFromBorderWithTrace,
+      {
+        minX: this.bounds.minX + marginFromBorderWithoutTrace,
+        minY: this.bounds.minY + marginFromBorderWithoutTrace,
+        maxX: this.bounds.maxX - marginFromBorderWithTrace,
+        maxY: this.bounds.maxY - marginFromBorderWithTrace
+      }
+    );
+  }
+  /**
+   * Create a single transition route with properly placed via
+   */
+  createTransitionRoute(start, end, via, connectionName) {
+    const route = [
+      { x: start.x, y: start.y, z: start.z ?? 0 },
+      { x: via.x, y: via.y, z: start.z ?? 0 },
+      { x: via.x, y: via.y, z: end.z ?? 0 },
+      { x: end.x, y: end.y, z: end.z ?? 0 }
+    ];
+    return {
+      connectionName,
+      route,
+      traceThickness: this.traceThickness,
+      viaDiameter: this.viaDiameter,
+      vias: [via]
+    };
+  }
+  /**
+   * Create the non-transition route
+   */
+  createFlatRoute(flatStart, flatEnd, via, otherRouteStart, otherRouteEnd, flatRouteConnectionName) {
+    const ntrP1 = otherRouteStart.z !== flatStart.z ? otherRouteStart : otherRouteEnd;
+    const middle = (a, b) => {
+      return {
+        x: (a.x + b.x) / 2,
+        y: (a.y + b.y) / 2
+      };
+    };
+    const middleWithMargin = (a, aMargin, b, bMargin) => {
+      const dx = b.x - a.x;
+      const dy = b.y - a.y;
+      const effectiveA = {
+        x: a.x + dx * aMargin,
+        y: a.y + dy * aMargin
+      };
+      const effectiveB = {
+        x: b.x - dx * bMargin,
+        y: b.y - dy * bMargin
+      };
+      return middle(effectiveA, effectiveB);
+    };
+    const traceBounds = {
+      maxX: this.bounds.maxX - this.obstacleMargin - this.traceThickness / 2,
+      maxY: this.bounds.maxY - this.obstacleMargin - this.traceThickness / 2,
+      minX: this.bounds.minX + this.obstacleMargin + this.traceThickness / 2,
+      minY: this.bounds.minY + this.obstacleMargin + this.traceThickness / 2
+    };
+    const minDistFromViaToTrace = this.viaDiameter / 2 + this.traceThickness / 2 + this.obstacleMargin;
+    const p2 = middleWithMargin(
+      via,
+      this.viaDiameter,
+      otherRouteStart.z !== flatStart.z ? otherRouteStart : otherRouteEnd,
+      this.traceThickness
+    );
+    const p1 = findPointToGetAroundCircle(flatStart, p2, {
+      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;
+    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: flatEnd.x, y: flatEnd.y, z: flatEnd.z ?? 0 }
+      ],
+      traceThickness: this.traceThickness,
+      viaDiameter: this.viaDiameter,
+      vias: []
+    };
+  }
+  /**
+   * Try to solve with one route having a transition and the other staying flat
+   */
+  trySolve() {
+    const [routeA, routeB] = this.routes;
+    const routeAHasTransition = routeA.A.z !== routeA.B.z;
+    const transitionRoute = routeAHasTransition ? routeA : routeB;
+    const flatRoute = routeAHasTransition ? routeB : routeA;
+    const viaPosition = this.calculateViaPosition(transitionRoute, flatRoute);
+    if (viaPosition) {
+      this.debugViaPositions.push({ via: viaPosition });
+    } else {
+      return false;
+    }
+    const transitionRouteSolution = this.createTransitionRoute(
+      transitionRoute.A,
+      transitionRoute.B,
+      viaPosition,
+      transitionRoute.connectionName
+    );
+    const flatRouteSolution = this.createFlatRoute(
+      flatRoute.A,
+      flatRoute.B,
+      viaPosition,
+      transitionRoute.A,
+      transitionRoute.B,
+      flatRoute.connectionName
+    );
+    this.solvedRoutes.push(transitionRouteSolution, flatRouteSolution);
+    return true;
+  }
+  /**
+   * Main step method that attempts to solve the routes
+   */
+  _step() {
+    if (!this.doRoutesCross(this.routes[0], this.routes[1])) {
+      this.failed = true;
+      this.error = "Can only solve routes that have a single transition crossing";
+      return;
+    }
+    if (this.trySolve()) {
+      this.solved = true;
+      return;
+    }
+    this.failed = true;
+  }
+  /**
+   * Visualization for debugging
+   */
+  visualize() {
+    const graphics = {
+      lines: [],
+      points: [],
+      rects: [],
+      circles: []
+    };
+    graphics.rects.push({
+      center: {
+        x: (this.bounds.minX + this.bounds.maxX) / 2,
+        y: (this.bounds.minY + this.bounds.maxY) / 2
+      },
+      width: this.bounds.maxX - this.bounds.minX,
+      height: this.bounds.maxY - this.bounds.minY,
+      stroke: "rgba(0, 0, 0, 0.5)",
+      fill: "rgba(240, 240, 240, 0.1)",
+      label: "PCB Bounds"
+    });
+    for (const route of this.routes) {
+      graphics.points.push({
+        x: route.A.x,
+        y: route.A.y,
+        label: `${route.connectionName} start (z=${route.A.z})`,
+        color: "orange"
+      });
+      graphics.points.push({
+        x: route.B.x,
+        y: route.B.y,
+        label: `${route.connectionName} end (z=${route.B.z})`,
+        color: "orange"
+      });
+      graphics.lines.push({
+        points: [route.A, route.B],
+        strokeColor: "rgba(255, 0, 0, 0.5)",
+        label: `${route.connectionName} direct`
+      });
+    }
+    for (let i = 0; i < this.debugViaPositions.length; i++) {
+      const { via } = this.debugViaPositions[i];
+      graphics.circles.push({
+        center: via,
+        radius: this.viaDiameter / 2,
+        fill: "rgba(255, 165, 0, 0.7)",
+        stroke: "rgba(0, 0, 0, 0.5)",
+        label: `Computed Via (attempt ${i + 1})`
+      });
+      const safetyMargin = this.viaDiameter / 2 + this.obstacleMargin;
+      graphics.circles.push({
+        center: via,
+        radius: safetyMargin,
+        stroke: "rgba(255, 165, 0, 0.7)",
+        fill: "rgba(0, 0, 0, 0)",
+        label: "Safety Margin"
+      });
+    }
+    for (let si = 0; si < this.solvedRoutes.length; si++) {
+      const route = this.solvedRoutes[si];
+      const routeColor = si % 2 === 0 ? "rgba(0, 255, 0, 0.75)" : "rgba(255, 0, 255, 0.75)";
+      for (let i = 0; i < route.route.length - 1; i++) {
+        const pointA = route.route[i];
+        const pointB = route.route[i + 1];
+        graphics.lines.push({
+          points: [pointA, pointB],
+          strokeColor: routeColor,
+          strokeDash: pointA.z !== route.route[0].z ? [0.2, 0.2] : void 0,
+          strokeWidth: route.traceThickness,
+          label: `${route.connectionName} z=${pointA.z}`
+        });
+      }
+      for (const via of route.vias) {
+        graphics.circles.push({
+          center: via,
+          radius: this.viaDiameter / 2,
+          fill: "rgba(0, 0, 255, 0.8)",
+          stroke: "black",
+          label: "Solved Via"
+        });
+        graphics.circles.push({
+          center: via,
+          radius: this.viaDiameter / 2 + this.obstacleMargin,
+          fill: "rgba(0, 0, 255, 0.3)",
+          stroke: "black",
+          label: "Via Margin"
+        });
+      }
+    }
+    return graphics;
+  }
+  /**
+   * Get the solved routes
+   */
+  getSolvedRoutes() {
+    return this.solvedRoutes;
+  }
+};
+
 // lib/solvers/HyperHighDensitySolver/HyperSingleIntraNodeSolver.ts
 var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
   constructorParams;
@@ -3582,7 +4116,7 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
   }
   getCombinationDefs() {
     return [
-      ["closedFormTwoTraceSameLayer"],
+      ["closedFormTwoTrace"],
       ["majorCombinations", "orderings6", "cellSizeFactor"],
       ["noVias"],
       ["orderings50"],
@@ -3673,10 +4207,13 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
         }))
       },
       {
-        name: "closedFormTwoTraceSameLayer",
+        name: "closedFormTwoTrace",
         possibleValues: [
           {
             CLOSED_FORM_TWO_TRACE_SAME_LAYER: true
+          },
+          {
+            CLOSED_FORM_TWO_TRACE_TRANSITION_CROSSING: true
           }
         ]
       }
@@ -3694,6 +4231,11 @@ var HyperSingleIntraNodeSolver = class extends HyperParameterSupervisorSolver {
         nodeWithPortPoints: this.nodeWithPortPoints
       });
     }
+    if (hyperParameters.CLOSED_FORM_TWO_TRACE_TRANSITION_CROSSING) {
+      return new SingleTransitionCrossingRouteSolver({
+        nodeWithPortPoints: this.nodeWithPortPoints
+      });
+    }
     return new IntraNodeRouteSolver({
       ...this.constructorParams,
       hyperParameters
@@ -4120,13 +4662,13 @@ function buildMinimumSpanningTree(points) {
       if (point.x === neighbor.x && point.y === neighbor.y) {
         continue;
       }
-      const distance4 = Math.sqrt(
+      const distance5 = Math.sqrt(
         (point.x - neighbor.x) ** 2 + (point.y - neighbor.y) ** 2
       );
       edges.push({
         from: point,
         to: neighbor,
-        weight: distance4
+        weight: distance5
       });
     }
   }
@@ -5387,6 +5929,7 @@ ${isMutable ? "MUTABLE" : "IMMUTABLE"}`,
       for (const connectedPointId of segmentPoint.directlyConnectedSegmentPointIds) {
         if (segmentPointId < connectedPointId) {
           const connectedPoint = modifiedSegmentPoints.get(connectedPointId);
+          if (!connectedPoint) continue;
           const sameLayer = segmentPoint.z === connectedPoint.z;
           const commonLayer = segmentPoint.z;
           let strokeDash;
@@ -5946,11 +6489,11 @@ var CapacityPathingSolver = class extends BaseSolver {
         let closestNode = this.nodes[0];
         let minDistance = Number.MAX_VALUE;
         for (const node of nodesWithTargets) {
-          const distance4 = Math.sqrt(
+          const distance5 = Math.sqrt(
             (node.center.x - point.x) ** 2 + (node.center.y - point.y) ** 2
           );
-          if (distance4 < minDistance) {
-            minDistance = distance4;
+          if (distance5 < minDistance) {
+            minDistance = distance5;
             closestNode = node;
           }
         }
@@ -6998,23 +7541,23 @@ function pointToSegmentDistance4(P, Q1, Q2) {
   const w = { x: P.x - Q1.x, y: P.y - Q1.y };
   const c1 = dotProduct(w, v);
   if (c1 <= 0) {
-    return distance3(P, Q1);
+    return distance4(P, Q1);
   }
   const c2 = dotProduct(v, v);
   if (c2 <= c1) {
-    return distance3(P, Q2);
+    return distance4(P, Q2);
   }
   const b = c1 / c2;
   const Pb = {
     x: Q1.x + b * v.x,
     y: Q1.y + b * v.y
   };
-  return distance3(P, Pb);
+  return distance4(P, Pb);
 }
 function dotProduct(v1, v2) {
   return v1.x * v2.x + v1.y * v2.y;
 }
-function distance3(p1, p2) {
+function distance4(p1, p2) {
   const dx = p2.x - p1.x;
   const dy = p2.y - p1.y;
   return Math.sqrt(dx * dx + dy * dy);
@@ -7232,15 +7775,15 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     return p1.x === p2.x && p1.y === p2.y && p1.z === p2.z;
   }
   // Get point at a specific distance along the path
-  getPointAtDistance(distance4) {
-    distance4 = Math.max(0, Math.min(distance4, this.totalPathLength));
+  getPointAtDistance(distance5) {
+    distance5 = Math.max(0, Math.min(distance5, this.totalPathLength));
     const segment = this.pathSegments.find(
-      (seg) => distance4 >= seg.startDistance && distance4 <= seg.endDistance
+      (seg) => distance5 >= seg.startDistance && distance5 <= seg.endDistance
     );
     if (!segment) {
       return this.inputRoute.route[this.inputRoute.route.length - 1];
     }
-    const factor = (distance4 - segment.startDistance) / segment.length;
+    const factor = (distance5 - segment.startDistance) / segment.length;
     return {
       x: segment.start.x + factor * (segment.end.x - segment.start.x),
       y: segment.start.y + factor * (segment.end.y - segment.start.y),
@@ -7249,17 +7792,17 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     };
   }
   // Find nearest index in the original route for a given distance
-  getNearestIndexForDistance(distance4) {
-    if (distance4 <= 0) return 0;
-    if (distance4 >= this.totalPathLength)
+  getNearestIndexForDistance(distance5) {
+    if (distance5 <= 0) return 0;
+    if (distance5 >= this.totalPathLength)
       return this.inputRoute.route.length - 1;
     const segmentIndex = this.pathSegments.findIndex(
-      (seg) => distance4 >= seg.startDistance && distance4 <= seg.endDistance
+      (seg) => distance5 >= seg.startDistance && distance5 <= seg.endDistance
     );
     if (segmentIndex === -1) return 0;
     const segment = this.pathSegments[segmentIndex];
     const midDistance = (segment.startDistance + segment.endDistance) / 2;
-    return distance4 > midDistance ? segmentIndex + 1 : segmentIndex;
+    return distance5 > midDistance ? segmentIndex + 1 : segmentIndex;
   }
   // Check if a path segment is valid
   isValidPathSegment(start, end) {
@@ -7361,10 +7904,10 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
     }
     this.currentStepSize = this.maxStepSize;
   }
-  moveHead(distance4) {
-    this.lastHeadMoveDistance = distance4;
+  moveHead(distance5) {
+    this.lastHeadMoveDistance = distance5;
     this.headDistanceAlongPath = Math.min(
-      this.headDistanceAlongPath + distance4,
+      this.headDistanceAlongPath + distance5,
       this.totalPathLength
     );
   }
@@ -7502,9 +8045,9 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
       color: "red",
       label: ["Tentative Head", `z: ${tentativeHead.z}`].join("\n")
     });
-    let distance4 = 0;
-    while (distance4 < this.totalPathLength) {
-      const point = this.getPointAtDistance(distance4);
+    let distance5 = 0;
+    while (distance5 < this.totalPathLength) {
+      const point = this.getPointAtDistance(distance5);
       graphics.circles.push({
         center: {
           x: point.x,
@@ -7513,7 +8056,7 @@ var SingleSimplifiedPathSolver5 = class extends SingleSimplifiedPathSolver {
         radius: 0.05,
         fill: "rgba(100, 100, 100, 0.5)"
       });
-      distance4 += this.totalPathLength / 20;
+      distance5 += this.totalPathLength / 20;
     }
     if (this.lastValidPath && this.lastValidPath.length > 1) {
       for (let i = 0; i < this.lastValidPath.length - 1; i++) {