@tscircuit/hypergraph 0.0.34 → 0.0.36

package/dist/index.js

@@ -337,6 +337,15 @@ var HyperGraphSolver = class extends BaseSolver {
   isRipRequiredForPortUsage(_region, _port1, _port2) {
     return false;
   }
+  /**
+   * OPTIONALLY OVERRIDE THIS
+   *
+   * Return false to prevent transitioning through a region from `_port1` to
+   * `_port2`.
+   */
+  isTransitionAllowed(_region, _port1, _port2) {
+    return true;
+  }
   computeG(candidate) {
     return candidate.parent.g + this.computeIncreasedRegionCostIfPortsAreUsed(
       candidate.lastRegion,
@@ -405,6 +414,13 @@ var HyperGraphSolver = class extends BaseSolver {
     const nextCandidatesByRegion = {};
     for (const port of currentRegion.ports) {
       if (port === currentCandidate.port) continue;
+      if (!this.isTransitionAllowed(
+        currentRegion,
+        currentPort,
+        port
+      )) {
+        continue;
+      }
       const ripRequired = port.assignment && port.assignment.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId || this.isRipRequiredForPortUsage(
         currentRegion,
         currentPort,
@@ -772,42 +788,156 @@ var rotateGraph90Degrees = (graph) => {
 };
 
 // lib/JumperGraphSolver/perimeterChordUtils.ts
+function clamp2(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function dist2(a, b) {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return dx * dx + dy * dy;
+}
+function getRectanglePerimeter(xmin, xmax, ymin, ymax) {
+  return 2 * (xmax - xmin) + 2 * (ymax - ymin);
+}
 function perimeterT(p, xmin, xmax, ymin, ymax) {
   const W = xmax - xmin;
   const H = ymax - ymin;
   const eps = 1e-6;
-  if (Math.abs(p.y - ymax) < eps) {
-    return p.x - xmin;
-  }
-  if (Math.abs(p.x - xmax) < eps) {
-    return W + (ymax - p.y);
-  }
-  if (Math.abs(p.y - ymin) < eps) {
-    return W + H + (xmax - p.x);
-  }
-  if (Math.abs(p.x - xmin) < eps) {
-    return 2 * W + H + (p.y - ymin);
-  }
+  if (Math.abs(p.y - ymax) < eps) return p.x - xmin;
+  if (Math.abs(p.x - xmax) < eps) return W + (ymax - p.y);
+  if (Math.abs(p.y - ymin) < eps) return W + H + (xmax - p.x);
+  if (Math.abs(p.x - xmin) < eps) return 2 * W + H + (p.y - ymin);
   const distTop = Math.abs(p.y - ymax);
   const distRight = Math.abs(p.x - xmax);
   const distBottom = Math.abs(p.y - ymin);
   const distLeft = Math.abs(p.x - xmin);
   const minDist = Math.min(distTop, distRight, distBottom, distLeft);
-  if (minDist === distTop) {
-    return Math.max(0, Math.min(W, p.x - xmin));
-  }
-  if (minDist === distRight) {
-    return W + Math.max(0, Math.min(H, ymax - p.y));
-  }
+  if (minDist === distTop) return Math.max(0, Math.min(W, p.x - xmin));
+  if (minDist === distRight) return W + Math.max(0, Math.min(H, ymax - p.y));
   if (minDist === distBottom) {
     return W + H + Math.max(0, Math.min(W, xmax - p.x));
   }
   return 2 * W + H + Math.max(0, Math.min(H, p.y - ymin));
 }
+function projectToSegment(p, a, b) {
+  const abx = b.x - a.x;
+  const aby = b.y - a.y;
+  const apx = p.x - a.x;
+  const apy = p.y - a.y;
+  const ab2 = abx * abx + aby * aby;
+  const u = ab2 > 0 ? clamp2((apx * abx + apy * aby) / ab2, 0, 1) : 0;
+  const q = { x: a.x + u * abx, y: a.y + u * aby };
+  return { u, d2: dist2(p, q) };
+}
+function createPolygonPerimeterCache(polygon2) {
+  const n = polygon2.length;
+  const edgeLengths = new Array(n);
+  const cumulative = new Array(n + 1);
+  cumulative[0] = 0;
+  for (let i = 0; i < n; i++) {
+    const a = polygon2[i];
+    const b = polygon2[(i + 1) % n];
+    const edgeLength = Math.hypot(b.x - a.x, b.y - a.y);
+    edgeLengths[i] = edgeLength;
+    cumulative[i + 1] = cumulative[i] + edgeLength;
+  }
+  return { edgeLengths, cumulative, perimeter: cumulative[n] };
+}
+function perimeterTPolygonWithCache(p, polygon2, cache, eps = 1e-6) {
+  let bestEdgeIndex = 0;
+  let bestU = 0;
+  let bestD2 = Number.POSITIVE_INFINITY;
+  const eps2 = eps * eps;
+  for (let i = 0; i < polygon2.length; i++) {
+    const a = polygon2[i];
+    const b = polygon2[(i + 1) % polygon2.length];
+    const projected = projectToSegment(p, a, b);
+    if (projected.d2 <= eps2) {
+      bestEdgeIndex = i;
+      bestU = projected.u;
+      bestD2 = projected.d2;
+      break;
+    }
+    if (projected.d2 < bestD2) {
+      bestEdgeIndex = i;
+      bestU = projected.u;
+      bestD2 = projected.d2;
+    }
+  }
+  return cache.cumulative[bestEdgeIndex] + bestU * cache.edgeLengths[bestEdgeIndex];
+}
+function getRegionPolygonCache(region) {
+  const polygon2 = region.d.polygon;
+  if (!polygon2 || polygon2.length < 3) return null;
+  const existing = region.d.polygonPerimeterCache;
+  if (existing) return existing;
+  const cache = createPolygonPerimeterCache(polygon2);
+  region.d.polygonPerimeterCache = cache;
+  return cache;
+}
+function getRegionPerimeter(region) {
+  const polygonCache = getRegionPolygonCache(region);
+  if (polygonCache) return polygonCache.perimeter;
+  const { minX, maxX, minY, maxY } = region.d.bounds;
+  return getRectanglePerimeter(minX, maxX, minY, maxY);
+}
+function getPortPerimeterTInRegion(port, region) {
+  if (port.region1 === region) {
+    if (typeof port.region1T === "number") return port.region1T;
+    const t = getPointPerimeterTInRegion(port.d, region);
+    port.region1T = t;
+    return t;
+  }
+  if (port.region2 === region) {
+    if (typeof port.region2T === "number") return port.region2T;
+    const t = getPointPerimeterTInRegion(port.d, region);
+    port.region2T = t;
+    return t;
+  }
+  return getPointPerimeterTInRegion(port.d, region);
+}
+function getPointPerimeterTInRegion(p, region) {
+  const polygon2 = region.d.polygon;
+  if (polygon2 && polygon2.length >= 3) {
+    const cache = getRegionPolygonCache(region);
+    if (cache) return perimeterTPolygonWithCache(p, polygon2, cache);
+  }
+  const { minX, maxX, minY, maxY } = region.d.bounds;
+  return perimeterT(p, minX, maxX, minY, maxY);
+}
 function areCoincident(t1, t2, eps = 1e-6) {
   return Math.abs(t1 - t2) < eps;
 }
-function chordsCross(chord1, chord2) {
+function normalizeMod(value, modulus) {
+  return (value % modulus + modulus) % modulus;
+}
+function areCoincidentOnCircle(t1, t2, perimeter, eps) {
+  const delta = Math.abs(normalizeMod(t1 - t2, perimeter));
+  return delta < eps || perimeter - delta < eps;
+}
+function betweenMod(x, start, end, perimeter, eps) {
+  const nx = normalizeMod(x, perimeter);
+  const ns = normalizeMod(start, perimeter);
+  const ne = normalizeMod(end, perimeter);
+  if (Math.abs(ns - ne) < eps) return false;
+  if (ns < ne) return ns < nx && nx < ne;
+  return nx > ns || nx < ne;
+}
+function chordsCross(chord1, chord2, perimeter) {
+  if (typeof perimeter === "number" && perimeter > 0) {
+    let [a2, b2] = chord1;
+    let [c2, d2] = chord2;
+    a2 = normalizeMod(a2, perimeter);
+    b2 = normalizeMod(b2, perimeter);
+    c2 = normalizeMod(c2, perimeter);
+    d2 = normalizeMod(d2, perimeter);
+    if (areCoincidentOnCircle(a2, c2, perimeter, 1e-6) || areCoincidentOnCircle(a2, d2, perimeter, 1e-6) || areCoincidentOnCircle(b2, c2, perimeter, 1e-6) || areCoincidentOnCircle(b2, d2, perimeter, 1e-6)) {
+      return false;
+    }
+    const cInside = betweenMod(c2, a2, b2, perimeter, 1e-12);
+    const dInside = betweenMod(d2, a2, b2, perimeter, 1e-12);
+    return cInside !== dInside;
+  }
   const [a, b] = chord1[0] < chord1[1] ? chord1 : [chord1[1], chord1[0]];
   const [c, d] = chord2[0] < chord2[1] ? chord2 : [chord2[1], chord2[0]];
   if (areCoincident(a, c) || areCoincident(a, d) || areCoincident(b, c) || areCoincident(b, d)) {
@@ -818,29 +948,23 @@ function chordsCross(chord1, chord2) {
 
 // lib/JumperGraphSolver/computeCrossingAssignments.ts
 function computeCrossingAssignments(region, port1, port2) {
-  const { minX: xmin, maxX: xmax, minY: ymin, maxY: ymax } = region.d.bounds;
-  const t1 = perimeterT(port1.d, xmin, xmax, ymin, ymax);
-  const t2 = perimeterT(port2.d, xmin, xmax, ymin, ymax);
+  const perimeter = getRegionPerimeter(region);
+  const t1 = getPortPerimeterTInRegion(port1, region);
+  const t2 = getPortPerimeterTInRegion(port2, region);
   const newChord = [t1, t2];
   const crossingAssignments = [];
   const assignments = region.assignments ?? [];
   for (const assignment of assignments) {
-    const existingT1 = perimeterT(
-      assignment.regionPort1.d,
-      xmin,
-      xmax,
-      ymin,
-      ymax
+    const existingT1 = getPortPerimeterTInRegion(
+      assignment.regionPort1,
+      region
     );
-    const existingT2 = perimeterT(
-      assignment.regionPort2.d,
-      xmin,
-      xmax,
-      ymin,
-      ymax
+    const existingT2 = getPortPerimeterTInRegion(
+      assignment.regionPort2,
+      region
     );
     const existingChord = [existingT1, existingT2];
-    if (chordsCross(newChord, existingChord)) {
+    if (chordsCross(newChord, existingChord, perimeter)) {
       crossingAssignments.push(assignment);
     }
   }
@@ -849,29 +973,23 @@ function computeCrossingAssignments(region, port1, port2) {
 
 // lib/JumperGraphSolver/computeDifferentNetCrossings.ts
 function computeDifferentNetCrossings(region, port1, port2) {
-  const { minX: xmin, maxX: xmax, minY: ymin, maxY: ymax } = region.d.bounds;
-  const t1 = perimeterT(port1.d, xmin, xmax, ymin, ymax);
-  const t2 = perimeterT(port2.d, xmin, xmax, ymin, ymax);
+  const perimeter = getRegionPerimeter(region);
+  const t1 = getPortPerimeterTInRegion(port1, region);
+  const t2 = getPortPerimeterTInRegion(port2, region);
   const newChord = [t1, t2];
   let crossings = 0;
   const assignments = region.assignments ?? [];
   for (const assignment of assignments) {
-    const existingT1 = perimeterT(
-      assignment.regionPort1.d,
-      xmin,
-      xmax,
-      ymin,
-      ymax
+    const existingT1 = getPortPerimeterTInRegion(
+      assignment.regionPort1,
+      region
     );
-    const existingT2 = perimeterT(
-      assignment.regionPort2.d,
-      xmin,
-      xmax,
-      ymin,
-      ymax
+    const existingT2 = getPortPerimeterTInRegion(
+      assignment.regionPort2,
+      region
     );
     const existingChord = [existingT1, existingT2];
-    if (chordsCross(newChord, existingChord)) {
+    if (chordsCross(newChord, existingChord, perimeter)) {
       crossings++;
     }
   }
@@ -909,6 +1027,7 @@ function countInputConnectionCrossings(graph, connections) {
     }
   }
   const chords = [];
+  const perimeter = 2 * (maxX - minX) + 2 * (maxY - minY);
   for (const conn of connections) {
     let startCenter;
     let endCenter;
@@ -931,7 +1050,7 @@ function countInputConnectionCrossings(graph, connections) {
   let crossings = 0;
   for (let i = 0; i < chords.length; i++) {
     for (let j = i + 1; j < chords.length; j++) {
-      if (chordsCross(chords[i], chords[j])) {
+      if (chordsCross(chords[i], chords[j], perimeter)) {
         crossings++;
       }
     }
@@ -972,9 +1091,7 @@ var visualizeJumperGraph = (graph, options) => {
       const points = polygon2;
       graphics.polygons.push({
         points,
-        fill,
-        stroke: "rgba(128, 128, 128, 0.5)",
-        strokeWidth: 0.03
+        fill
       });
     } else {
       graphics.rects.push({
@@ -1065,6 +1182,12 @@ var visualizeJumperGraphSolver = (solver) => {
       hidePortPoints: true
     } : {}
   });
+  if (solver.iterations === 0) {
+    for (const polygon2 of graphics.polygons) {
+      polygon2.stroke = "rgba(128, 128, 128, 0.5)";
+      polygon2.strokeWidth = 0.03;
+    }
+  }
   if (solver.currentConnection && !solver.solved) {
     const connectionColor = getConnectionColor(
       solver.currentConnection.connectionId
@@ -1230,11 +1353,35 @@ var JumperGraphSolver = class extends HyperGraphSolver {
     const ripCount = port.ripCount ?? 0;
     return ripCount * this.portUsagePenalty + ripCount * this.portUsagePenaltySq;
   }
+  isTransitionAllowed(region, port1, port2) {
+    if (!region.d.isPad) return true;
+    const usesThroughJumper = (port) => {
+      const otherRegion = port.region1 === region ? port.region2 : port.region1;
+      return Boolean(otherRegion.d.isThroughJumper);
+    };
+    return usesThroughJumper(port1) || usesThroughJumper(port2);
+  }
   computeIncreasedRegionCostIfPortsAreUsed(region, port1, port2) {
+    if (region.d.isPad) {
+      const assignments = region.assignments ?? [];
+      const differentNetCount = assignments.filter(
+        (a) => a.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId
+      ).length;
+      if (differentNetCount > 0) {
+        return differentNetCount * this.crossingPenalty + differentNetCount * this.crossingPenaltySq;
+      }
+      return 0;
+    }
     const crossings = computeDifferentNetCrossings(region, port1, port2);
     return crossings * this.crossingPenalty + crossings * this.crossingPenaltySq;
   }
   getRipsRequiredForPortUsage(region, port1, port2) {
+    if (region.d.isPad) {
+      const assignments = region.assignments ?? [];
+      return assignments.filter(
+        (a) => a.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId
+      );
+    }
     const crossingAssignments = computeCrossingAssignments(region, port1, port2);
     const conflictingAssignments = crossingAssignments.filter(
       (a) => a.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId
@@ -1249,7 +1396,7 @@ var JumperGraphSolver = class extends HyperGraphSolver {
     return conflictingAssignments;
   }
   isRipRequiredForPortUsage(region, _port1, _port2) {
-    if (!region.d.isThroughJumper) return false;
+    if (!region.d.isThroughJumper && !region.d.isPad) return false;
     for (const assignment of region.assignments ?? []) {
       if (assignment.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId) {
         return true;
@@ -1301,23 +1448,123 @@ var createConnectionRegion = (regionId, x, y) => {
 };
 
 // lib/JumperGraphSolver/jumper-graph-generator/findBoundaryRegion.ts
-var findBoundaryRegion = (x, y, regions, graphBounds) => {
-  for (const region of regions) {
-    if (region.d.isPad || region.d.isThroughJumper) continue;
-    const bounds = region.d.bounds;
-    if (Math.abs(x - bounds.minX) < 0.01 && y >= bounds.minY && y <= bounds.maxY) {
-      return { region, portPosition: { x: bounds.minX, y } };
-    }
-    if (Math.abs(x - bounds.maxX) < 0.01 && y >= bounds.minY && y <= bounds.maxY) {
-      return { region, portPosition: { x: bounds.maxX, y } };
+var EPS = 0.01;
+var clamp3 = (value, min, max) => {
+  return Math.max(min, Math.min(max, value));
+};
+var getBoundarySidesForPoint = (x, y, graphBounds) => {
+  const sides = [];
+  if (Math.abs(x - graphBounds.minX) < EPS) sides.push("left");
+  if (Math.abs(x - graphBounds.maxX) < EPS) sides.push("right");
+  if (Math.abs(y - graphBounds.maxY) < EPS) sides.push("top");
+  if (Math.abs(y - graphBounds.minY) < EPS) sides.push("bottom");
+  return sides;
+};
+var isPointOnSide = (p, side, b) => {
+  if (side === "left") return Math.abs(p.x - b.minX) < EPS;
+  if (side === "right") return Math.abs(p.x - b.maxX) < EPS;
+  if (side === "top") return Math.abs(p.y - b.maxY) < EPS;
+  return Math.abs(p.y - b.minY) < EPS;
+};
+var projectToSegment2 = (x, y, a, b) => {
+  const abx = b.x - a.x;
+  const aby = b.y - a.y;
+  const apx = x - a.x;
+  const apy = y - a.y;
+  const ab2 = abx * abx + aby * aby;
+  const t = ab2 > 0 ? clamp3((apx * abx + apy * aby) / ab2, 0, 1) : 0;
+  const px = a.x + t * abx;
+  const py = a.y + t * aby;
+  const dx = x - px;
+  const dy = y - py;
+  return {
+    x: px,
+    y: py,
+    d2: dx * dx + dy * dy
+  };
+};
+var getRegionBoundaryProjection = (x, y, region, graphBounds, preferredSides) => {
+  const polygon2 = region.d.polygon;
+  if (polygon2 && polygon2.length >= 3) {
+    const sideSet = new Set(preferredSides);
+    let best2 = null;
+    for (let i = 0; i < polygon2.length; i++) {
+      const a = polygon2[i];
+      const b = polygon2[(i + 1) % polygon2.length];
+      if (preferredSides.length > 0) {
+        const edgeOnPreferredSide = preferredSides.some(
+          (side) => isPointOnSide(a, side, graphBounds) && isPointOnSide(b, side, graphBounds) && sideSet.has(side)
+        );
+        if (!edgeOnPreferredSide) continue;
+      }
+      const p = projectToSegment2(x, y, a, b);
+      if (!best2 || p.d2 < best2.d2) {
+        best2 = p;
+      }
     }
-    if (Math.abs(y - bounds.minY) < 0.01 && x >= bounds.minX && x <= bounds.maxX) {
-      return { region, portPosition: { x, y: bounds.minY } };
+    if (best2) return best2;
+  }
+  const bounds = region.d.bounds;
+  const sideCandidates = [];
+  if (preferredSides.length > 0) {
+    for (const side of preferredSides) {
+      if (side === "left") {
+        sideCandidates.push({
+          side,
+          x: bounds.minX,
+          y: clamp3(y, bounds.minY, bounds.maxY)
+        });
+      } else if (side === "right") {
+        sideCandidates.push({
+          side,
+          x: bounds.maxX,
+          y: clamp3(y, bounds.minY, bounds.maxY)
+        });
+      } else if (side === "top") {
+        sideCandidates.push({
+          side,
+          x: clamp3(x, bounds.minX, bounds.maxX),
+          y: bounds.maxY
+        });
+      } else {
+        sideCandidates.push({
+          side,
+          x: clamp3(x, bounds.minX, bounds.maxX),
+          y: bounds.minY
+        });
+      }
     }
-    if (Math.abs(y - bounds.maxY) < 0.01 && x >= bounds.minX && x <= bounds.maxX) {
-      return { region, portPosition: { x, y: bounds.maxY } };
+  }
+  if (sideCandidates.length === 0) {
+    sideCandidates.push(
+      { side: "left", x: bounds.minX, y: clamp3(y, bounds.minY, bounds.maxY) },
+      {
+        side: "right",
+        x: bounds.maxX,
+        y: clamp3(y, bounds.minY, bounds.maxY)
+      },
+      { side: "top", x: clamp3(x, bounds.minX, bounds.maxX), y: bounds.maxY },
+      {
+        side: "bottom",
+        x: clamp3(x, bounds.minX, bounds.maxX),
+        y: bounds.minY
+      }
+    );
+  }
+  let best = null;
+  for (const c of sideCandidates) {
+    if (preferredSides.length > 0 && !preferredSides.includes(c.side)) continue;
+    const dx = x - c.x;
+    const dy = y - c.y;
+    const d2 = dx * dx + dy * dy;
+    if (!best || d2 < best.d2) {
+      best = { x: c.x, y: c.y, d2 };
     }
   }
+  return best;
+};
+var findBoundaryRegion = (x, y, regions, graphBounds) => {
+  const preferredSides = getBoundarySidesForPoint(x, y, graphBounds);
   let closestRegion = null;
   let closestDistance = Number.POSITIVE_INFINITY;
   let closestPortPosition = { x, y };
@@ -1326,23 +1573,19 @@ var findBoundaryRegion = (x, y, regions, graphBounds) => {
     const bounds = region.d.bounds;
     const isOuterRegion = Math.abs(bounds.minX - graphBounds.minX) < 0.01 || Math.abs(bounds.maxX - graphBounds.maxX) < 0.01 || Math.abs(bounds.minY - graphBounds.minY) < 0.01 || Math.abs(bounds.maxY - graphBounds.maxY) < 0.01;
     if (!isOuterRegion) continue;
-    const clampedX = Math.max(bounds.minX, Math.min(bounds.maxX, x));
-    const clampedY = Math.max(bounds.minY, Math.min(bounds.maxY, y));
-    const dist = Math.sqrt((x - clampedX) ** 2 + (y - clampedY) ** 2);
+    const projection = getRegionBoundaryProjection(
+      x,
+      y,
+      region,
+      graphBounds,
+      preferredSides
+    );
+    if (!projection) continue;
+    const dist = Math.sqrt(projection.d2);
     if (dist < closestDistance) {
       closestDistance = dist;
       closestRegion = region;
-      if (x < bounds.minX) {
-        closestPortPosition = { x: bounds.minX, y: clampedY };
-      } else if (x > bounds.maxX) {
-        closestPortPosition = { x: bounds.maxX, y: clampedY };
-      } else if (y < bounds.minY) {
-        closestPortPosition = { x: clampedX, y: bounds.minY };
-      } else if (y > bounds.maxY) {
-        closestPortPosition = { x: clampedX, y: bounds.maxY };
-      } else {
-        closestPortPosition = { x: clampedX, y: clampedY };
-      }
+      closestPortPosition = { x: projection.x, y: projection.y };
     }
   }
   if (closestRegion) {
@@ -3640,48 +3883,24 @@ var via_tile_default = {
           y: 0.582296
         },
         {
-          x: 1.31705,
-          y: 0.74908
-        },
-        {
-          x: 1.425309,
-          y: 0.74908
-        },
-        {
-          x: 1.762721,
-          y: 1.086492
-        },
-        {
-          x: 1.762721,
-          y: 1.563668
-        },
-        {
-          x: 1.425309,
-          y: 1.90108
+          x: 1.712721,
+          y: 0.811183
         },
         {
-          x: 1.266397,
-          y: 1.90108
+          x: 1.712721,
+          y: 1.542957
         },
         {
-          x: 0.781911,
-          y: 2.385567
+          x: 0.920111,
+          y: 2.335567
         },
         {
-          x: 0.013957,
-          y: 2.385567
-        },
-        {
-          x: -0.753066,
-          y: 1.618543
-        },
-        {
-          x: -0.753066,
-          y: 1.360375
+          x: 0.034666,
+          y: 2.335566
         },
         {
           x: -0.703066,
-          y: 1.310375
+          y: 1.597834
         },
         {
           x: -0.703066,
@@ -3704,32 +3923,20 @@ var via_tile_default = {
           y: -1.893395
         },
         {
-          x: -2.2,
-          y: -1.4
-        },
-        {
-          x: -2.2,
-          y: 0.903041
-        },
-        {
-          x: -1.603041,
-          y: 1.5
+          x: -2.10103,
+          y: -1.49897
         },
         {
-          x: -1.516757,
-          y: 1.5
+          x: -2.10103,
+          y: 1.002011
         },
         {
-          x: -1.430473,
-          y: 1.586284
+          x: -1.708294,
+          y: 1.394747
         },
         {
-          x: -0.978975,
-          y: 1.586284
-        },
-        {
-          x: -0.703066,
-          y: 1.310375
+          x: -0.897813,
+          y: 1.394747
         },
         {
           x: -0.703066,
@@ -3739,81 +3946,37 @@ var via_tile_default = {
     },
     {
       routeId: "Net5:route_0",
-      fromPort: "a3797f13-73f9-48c3-a448-bea3980cdd65",
-      toPort: "b0c56bb1-ea80-4154-9bb7-cb0fd760de8f",
+      fromPort: "4e57cee8-0910-4c83-9ec1-1ed2c9d16dcc",
+      toPort: "a3797f13-73f9-48c3-a448-bea3980cdd65",
       layer: "bottom",
       segments: [
         {
-          x: -1.115754,
-          y: -0.799377
-        },
-        {
-          x: -0.764375,
-          y: -0.447998
-        },
-        {
-          x: -0.636191,
-          y: -0.447998
-        },
-        {
-          x: -0.368136,
-          y: -0.179943
-        },
-        {
-          x: -0.368136,
-          y: -0.178529
-        },
-        {
-          x: 0.556834,
-          y: 0.746441
+          x: 1.268717,
+          y: -1.698536
         },
         {
-          x: 0.397934,
-          y: 0.905341
+          x: 0.369558,
+          y: -0.799377
         },
         {
-          x: 0.397934,
-          y: 1.458567
+          x: -1.115754,
+          y: -0.799377
         }
       ]
     },
     {
       routeId: "Net5:route_1",
-      fromPort: "4e57cee8-0910-4c83-9ec1-1ed2c9d16dcc",
+      fromPort: "a3797f13-73f9-48c3-a448-bea3980cdd65",
       toPort: "b0c56bb1-ea80-4154-9bb7-cb0fd760de8f",
       layer: "bottom",
       segments: [
         {
-          x: 1.268717,
-          y: -1.698536
-        },
-        {
-          x: 1.405649,
-          y: -1.561604
-        },
-        {
-          x: 1.393076,
-          y: -1.561604
-        },
-        {
-          x: 1.055664,
-          y: -1.224192
-        },
-        {
-          x: 1.055664,
-          y: -0.905992
-        },
-        {
-          x: 0.556834,
-          y: -0.407162
-        },
-        {
-          x: 0.556834,
-          y: 0.746441
+          x: -1.115754,
+          y: -0.799377
         },
         {
           x: 0.397934,
-          y: 0.905341
+          y: 0.714311
         },
         {
           x: 0.397934,
@@ -3871,28 +4034,16 @@ var via_tile_default = {
           x: 0.159346,
           y: 2.034567
         },
-        {
-          x: 0.06239,
-          y: 1.93761
-        },
         {
           x: -0.178066,
           y: 1.697155
         },
         {
           x: -0.178066,
-          y: 0.824715
+          y: 0.981123
         },
         {
-          x: -1.042874,
-          y: -0.040093
-        },
-        {
-          x: -1.169705,
-          y: -0.040093
-        },
-        {
-          x: -1.209798,
+          x: -1.159189,
           y: 0
         },
         {
@@ -3912,69 +4063,25 @@ var via_tile_default = {
           y: -0.164505
         },
         {
-          x: 1.562188,
-          y: -0.173664
-        },
-        {
-          x: 1.634312,
-          y: -0.173664
-        },
-        {
-          x: 2.207664,
-          y: -0.747016
-        },
-        {
-          x: 2.207664,
-          y: -1.224192
-        },
-        {
-          x: 1.870252,
-          y: -1.561604
+          x: 1.565592,
+          y: -0.164505
         },
         {
-          x: 1.844717,
-          y: -1.561604
+          x: 2.181408,
+          y: -0.780321
         },
         {
-          x: 1.844717,
-          y: -1.937124
+          x: 2.181408,
+          y: -1.600433
         },
         {
           x: 1.507305,
           y: -2.274536
         },
         {
-          x: 1.030129,
+          x: 0.630282,
           y: -2.274536
         },
-        {
-          x: 0.692717,
-          y: -1.937124
-        },
-        {
-          x: 0.692717,
-          y: -1.739534
-        },
-        {
-          x: 0.475553,
-          y: -1.739534
-        },
-        {
-          x: 0.470734,
-          y: -1.744353
-        },
-        {
-          x: 0.455647,
-          y: -1.744353
-        },
-        {
-          x: 0.30246,
-          y: -1.89754
-        },
-        {
-          x: 0.253286,
-          y: -1.89754
-        },
         {
           x: 0.222457,
           y: -1.866711
@@ -3992,23 +4099,15 @@ var via_tile_default = {
           y: -1.866711
         },
         {
-          x: 0.208345,
+          x: 0.137528,
           y: -1.866711
         },
         {
-          x: 0.2,
-          y: -1.858366
-        },
-        {
-          x: 0.2,
-          y: -1.2
-        },
-        {
-          x: -0.701789,
-          y: -1.2
+          x: -0.329183,
+          y: -1.4
         },
         {
-          x: -0.869184,
+          x: -0.361788,
           y: -1.367395
         },
         {
@@ -4016,28 +4115,16 @@ var via_tile_default = {
           y: -1.367395
         },
         {
-          x: -1.025859,
-          y: -1.375377
+          x: -1.237643,
+          y: -1.587161
         },
         {
-          x: -1.354342,
-          y: -1.375377
-        },
-        {
-          x: -1.529719,
-          y: -1.2
-        },
-        {
-          x: -1.636994,
-          y: -1.2
-        },
-        {
-          x: -1.718497,
-          y: -1.118497
+          x: -1.587161,
+          y: -1.587161
         },
         {
           x: -1.8,
-          y: -1.2
+          y: -1.374322
         },
         {
           x: -1.8,
@@ -4049,19 +4136,11 @@ var via_tile_default = {
         },
         {
           x: -1.80003,
-          y: -0.559789
+          y: -0.6
         },
         {
-          x: -1.8,
-          y: -0.559759
-        },
-        {
-          x: -1.8,
-          y: 0.877363
-        },
-        {
-          x: -1.614161,
-          y: 1.063202
+          x: -1.80003,
+          y: 0.488423
         },
         {
           x: -1.419706,
@@ -4976,64 +5055,28 @@ function generateDefaultViaTopologyGrid(opts) {
 }
 
 // lib/ViaGraphSolver/polygonPerimeterUtils.ts
-function polygonPerimeterT(p, polygon2) {
-  const n = polygon2.length;
-  let bestDist = Infinity;
-  let bestEdgeIndex = 0;
-  let bestT = 0;
-  for (let i = 0; i < n; i++) {
-    const a2 = polygon2[i];
-    const b2 = polygon2[(i + 1) % n];
-    const dx = b2.x - a2.x;
-    const dy = b2.y - a2.y;
-    const lenSq = dx * dx + dy * dy;
-    if (lenSq < 1e-10) continue;
-    const t = Math.max(
-      0,
-      Math.min(1, ((p.x - a2.x) * dx + (p.y - a2.y) * dy) / lenSq)
-    );
-    const projX = a2.x + t * dx;
-    const projY = a2.y + t * dy;
-    const dist = Math.sqrt((p.x - projX) ** 2 + (p.y - projY) ** 2);
-    if (dist < bestDist) {
-      bestDist = dist;
-      bestEdgeIndex = i;
-      bestT = t;
-    }
-  }
-  let cumulative = 0;
-  for (let i = 0; i < bestEdgeIndex; i++) {
-    const a2 = polygon2[i];
-    const b2 = polygon2[(i + 1) % n];
-    cumulative += Math.sqrt((b2.x - a2.x) ** 2 + (b2.y - a2.y) ** 2);
-  }
-  const a = polygon2[bestEdgeIndex];
-  const b = polygon2[(bestEdgeIndex + 1) % n];
-  const edgeLen = Math.sqrt((b.x - a.x) ** 2 + (b.y - a.y) ** 2);
-  cumulative += bestT * edgeLen;
-  return cumulative;
-}
 function computeDifferentNetCrossingsForPolygon(region, port1, port2) {
   const polygon2 = region.d.polygon;
   if (!polygon2 || polygon2.length < 3) {
     return 0;
   }
-  const t1 = polygonPerimeterT(port1.d, polygon2);
-  const t2 = polygonPerimeterT(port2.d, polygon2);
+  const perimeter = getRegionPerimeter(region);
+  const t1 = getPortPerimeterTInRegion(port1, region);
+  const t2 = getPortPerimeterTInRegion(port2, region);
   const newChord = [t1, t2];
   let crossings = 0;
   const assignments = region.assignments ?? [];
   for (const assignment of assignments) {
-    const existingT1 = polygonPerimeterT(
-      assignment.regionPort1.d,
-      polygon2
+    const existingT1 = getPortPerimeterTInRegion(
+      assignment.regionPort1,
+      region
     );
-    const existingT2 = polygonPerimeterT(
-      assignment.regionPort2.d,
-      polygon2
+    const existingT2 = getPortPerimeterTInRegion(
+      assignment.regionPort2,
+      region
     );
     const existingChord = [existingT1, existingT2];
-    if (chordsCross(newChord, existingChord)) {
+    if (chordsCross(newChord, existingChord, perimeter)) {
       crossings++;
     }
   }
@@ -5044,28 +5087,170 @@ function computeCrossingAssignmentsForPolygon(region, port1, port2) {
   if (!polygon2 || polygon2.length < 3) {
     return [];
   }
-  const t1 = polygonPerimeterT(port1.d, polygon2);
-  const t2 = polygonPerimeterT(port2.d, polygon2);
+  const perimeter = getRegionPerimeter(region);
+  const t1 = getPortPerimeterTInRegion(port1, region);
+  const t2 = getPortPerimeterTInRegion(port2, region);
   const newChord = [t1, t2];
   const crossingAssignments = [];
   const assignments = region.assignments ?? [];
   for (const assignment of assignments) {
-    const existingT1 = polygonPerimeterT(
-      assignment.regionPort1.d,
-      polygon2
+    const existingT1 = getPortPerimeterTInRegion(
+      assignment.regionPort1,
+      region
     );
-    const existingT2 = polygonPerimeterT(
-      assignment.regionPort2.d,
-      polygon2
+    const existingT2 = getPortPerimeterTInRegion(
+      assignment.regionPort2,
+      region
     );
     const existingChord = [existingT1, existingT2];
-    if (chordsCross(newChord, existingChord)) {
+    if (chordsCross(newChord, existingChord, perimeter)) {
       crossingAssignments.push(assignment);
     }
   }
   return crossingAssignments;
 }
 
+// lib/ViaGraphSolver/resolveSolvedRoutePoints.ts
+var POINT_EPSILON = 1e-6;
+function arePointsEqual(a, b) {
+  return Math.abs(a.x - b.x) <= POINT_EPSILON && Math.abs(a.y - b.y) <= POINT_EPSILON;
+}
+function appendPoint(points, point2) {
+  const lastPoint = points[points.length - 1];
+  if (lastPoint && arePointsEqual(lastPoint, point2)) return;
+  points.push(point2);
+}
+function findNearestVia(vias, point2) {
+  let bestVia = null;
+  let bestDistance = Infinity;
+  for (const via of vias) {
+    const dx = via.position.x - point2.x;
+    const dy = via.position.y - point2.y;
+    const distance3 = Math.hypot(dx, dy);
+    if (distance3 < bestDistance) {
+      bestDistance = distance3;
+      bestVia = via;
+    }
+  }
+  return bestVia;
+}
+function parseViaRegionNetName(regionId) {
+  const marker = ":v:";
+  const markerIndex = regionId.lastIndexOf(marker);
+  if (markerIndex !== -1) {
+    return regionId.slice(markerIndex + marker.length);
+  }
+  const lastColonIndex = regionId.lastIndexOf(":");
+  if (lastColonIndex === -1) return regionId;
+  return regionId.slice(lastColonIndex + 1);
+}
+function parseViaRegionTilePrefix(regionId) {
+  const marker = ":v:";
+  const markerIndex = regionId.lastIndexOf(marker);
+  if (markerIndex <= 0) return null;
+  return regionId.slice(0, markerIndex);
+}
+function getBottomRouteSegmentsForVias(viaTile, vias) {
+  const viaIdSet = new Set(vias.map((via) => via.viaId));
+  return viaTile.routeSegments.filter(
+    (routeSegment) => routeSegment.layer === "bottom" && viaIdSet.has(routeSegment.fromPort) && viaIdSet.has(routeSegment.toPort) && routeSegment.segments.length >= 2
+  );
+}
+function selectViasForTraversedRegion(viaTile, viaRegion) {
+  const netName = parseViaRegionNetName(viaRegion.regionId);
+  if (!netName) return [];
+  const viasForNet = viaTile.viasByNet[netName];
+  if (!viasForNet || viasForNet.length === 0) return [];
+  const tilePrefix = parseViaRegionTilePrefix(viaRegion.regionId);
+  if (!tilePrefix) return viasForNet;
+  const tileScopedVias = viasForNet.filter(
+    (via) => via.viaId.startsWith(`${tilePrefix}:`)
+  );
+  return tileScopedVias.length > 0 ? tileScopedVias : viasForNet;
+}
+function normalizeSegmentPoints(points) {
+  const normalized = [];
+  for (const point2 of points) appendPoint(normalized, point2);
+  return normalized;
+}
+function appendLineSegment(lineSegments, points, layer) {
+  const normalized = normalizeSegmentPoints(points);
+  if (normalized.length < 2) return;
+  const lastLine = lineSegments[lineSegments.length - 1];
+  if (!lastLine || lastLine.layer !== layer) {
+    lineSegments.push({ points: normalized, layer });
+    return;
+  }
+  const lastPoint = lastLine.points[lastLine.points.length - 1];
+  const firstPoint = normalized[0];
+  if (!lastPoint || !firstPoint || !arePointsEqual(lastPoint, firstPoint)) {
+    lineSegments.push({ points: normalized, layer });
+    return;
+  }
+  const continuation = normalized.slice(1);
+  for (const point2 of continuation) {
+    appendPoint(lastLine.points, point2);
+  }
+}
+function flattenLineSegments(lineSegments) {
+  const points = [];
+  for (const lineSegment of lineSegments) {
+    for (const point2 of lineSegment.points) {
+      appendPoint(points, point2);
+    }
+  }
+  return points;
+}
+function resolveSolvedRouteLineSegments(solvedRoute, viaTile) {
+  if (solvedRoute.path.length === 0) return [];
+  const path = solvedRoute.path;
+  const lineSegments = [];
+  const drawnViaRegionIds = /* @__PURE__ */ new Set();
+  for (let index = 1; index < path.length; index++) {
+    const previousCandidate = path[index - 1];
+    const currentCandidate = path[index];
+    const previousPoint = {
+      x: previousCandidate.port.d.x,
+      y: previousCandidate.port.d.y
+    };
+    const currentPoint = {
+      x: currentCandidate.port.d.x,
+      y: currentCandidate.port.d.y
+    };
+    const traversedRegion = currentCandidate.lastRegion;
+    const isViaRegionTraversal = !!viaTile && !!traversedRegion?.d?.isViaRegion;
+    if (!isViaRegionTraversal) {
+      appendLineSegment(lineSegments, [previousPoint, currentPoint], "top");
+      continue;
+    }
+    const viasForRegion = selectViasForTraversedRegion(viaTile, traversedRegion);
+    if (viasForRegion.length === 0) continue;
+    const entryVia = findNearestVia(viasForRegion, previousPoint);
+    const exitVia = findNearestVia(viasForRegion, currentPoint);
+    if (entryVia) {
+      appendLineSegment(lineSegments, [previousPoint, entryVia.position], "top");
+    }
+    const bottomRouteSegments = getBottomRouteSegmentsForVias(
+      viaTile,
+      viasForRegion
+    );
+    if (bottomRouteSegments.length > 0 && !drawnViaRegionIds.has(traversedRegion.regionId)) {
+      drawnViaRegionIds.add(traversedRegion.regionId);
+      for (const routeSegment of bottomRouteSegments) {
+        appendLineSegment(lineSegments, routeSegment.segments, "bottom");
+      }
+    }
+    if (exitVia) {
+      appendLineSegment(lineSegments, [exitVia.position, currentPoint], "top");
+    }
+  }
+  return lineSegments;
+}
+function resolveSolvedRoutePoints(solvedRoute, viaTile) {
+  const lineSegments = resolveSolvedRouteLineSegments(solvedRoute, viaTile);
+  return flattenLineSegments(lineSegments);
+}
+
 // lib/ViaGraphSolver/visualizeViaGraphSolver.ts
 var getConnectionColor2 = (connectionId, alpha = 0.8) => {
   let hash = 0;
@@ -5093,6 +5278,8 @@ var NET_COLOR_PALETTE = [
   "rgba(230, 126, 34, 0.35)"
   // dark orange
 ];
+var BOTTOM_LAYER_TRACE_COLOR = "rgba(52, 152, 219, 0.95)";
+var BOTTOM_LAYER_TRACE_DASH = "3 2";
 var visualizeViaGraphSolver = (solver) => {
   const graph = {
     regions: solver.graph.regions,
@@ -5106,6 +5293,12 @@ var visualizeViaGraphSolver = (solver) => {
       hidePortPoints: true
     } : {}
   });
+  if (solver.iterations === 0) {
+    for (const polygon2 of graphics.polygons) {
+      polygon2.stroke = "rgba(128, 128, 128, 0.5)";
+      polygon2.strokeWidth = 0.03;
+    }
+  }
   const outerIds = /* @__PURE__ */ new Set(["T", "B", "L", "R"]);
   let netColorIndex = 0;
   const netColorMap = /* @__PURE__ */ new Map();
@@ -5166,15 +5359,13 @@ var visualizeViaGraphSolver = (solver) => {
     const connectionColor = getConnectionColor2(
       solvedRoute.connection.connectionId
     );
-    const pathPoints = [];
-    for (const candidate of solvedRoute.path) {
-      const port = candidate.port;
-      pathPoints.push({ x: port.d.x, y: port.d.y });
-    }
-    if (pathPoints.length > 0) {
+    const lineSegments = solver.getSolvedRouteLineSegments(solvedRoute);
+    for (const lineSegment of lineSegments) {
+      const isBottomLayer = lineSegment.layer === "bottom";
       graphics.lines.push({
-        points: pathPoints,
-        strokeColor: connectionColor
+        points: lineSegment.points,
+        strokeColor: isBottomLayer ? BOTTOM_LAYER_TRACE_COLOR : connectionColor,
+        ...isBottomLayer ? { strokeDash: BOTTOM_LAYER_TRACE_DASH } : {}
       });
     }
   }
@@ -5346,6 +5537,12 @@ var ViaGraphSolver = class extends HyperGraphSolver {
   }
   routeSolvedHook(solvedRoute) {
   }
+  getSolvedRoutePoints(solvedRoute) {
+    return resolveSolvedRoutePoints(solvedRoute, this.viaTile);
+  }
+  getSolvedRouteLineSegments(solvedRoute) {
+    return resolveSolvedRouteLineSegments(solvedRoute, this.viaTile);
+  }
   routeStartedHook(connection) {
   }
   visualize() {
@@ -14646,6 +14843,35 @@ function centroid(points) {
   }
   return { x: cx / points.length, y: cy / points.length };
 }
+function classifySideFromBounds(point2, bounds) {
+  const distances = {
+    left: Math.abs(point2.x - bounds.minX),
+    right: Math.abs(point2.x - bounds.maxX),
+    bottom: Math.abs(point2.y - bounds.minY),
+    top: Math.abs(point2.y - bounds.maxY)
+  };
+  let bestSide = "left";
+  let bestDistance = distances.left;
+  for (const side of ["right", "bottom", "top"]) {
+    if (distances[side] < bestDistance) {
+      bestSide = side;
+      bestDistance = distances[side];
+    }
+  }
+  return bestSide;
+}
+function toCandidateKey(regionId, point2) {
+  return `${regionId}:${point2.x.toFixed(6)},${point2.y.toFixed(6)}`;
+}
+function compareCandidateQuality(a, b) {
+  if (Math.abs(a.primaryDistance - b.primaryDistance) > 1e-6) {
+    return b.primaryDistance - a.primaryDistance;
+  }
+  if (Math.abs(a.orthDistance - b.orthDistance) > 1e-6) {
+    return a.orthDistance - b.orthDistance;
+  }
+  return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+}
 function createRegionFromPolygon(regionId, polygon2, opts) {
   const bounds = boundsFromPolygon(polygon2);
   return {
@@ -14834,6 +15060,8 @@ function generateConvexViaTopologyRegions(opts) {
     }
   }
   for (const viaRegion of viaRegions) {
+    const viaCenter = viaRegion.d.center;
+    const candidates = [];
     for (const convexRegion of convexRegions) {
       const sharedEdges = findSharedEdges(
         viaRegion.d.polygon,
@@ -14843,18 +15071,55 @@ function generateConvexViaTopologyRegions(opts) {
       for (const edge of sharedEdges) {
         const portPositions = createPortsAlongEdge(edge, portPitch);
         for (const pos of portPositions) {
-          const port = {
-            portId: `via-convex:${viaRegion.regionId}-${convexRegion.regionId}:${portIdCounter++}`,
-            region1: viaRegion,
-            region2: convexRegion,
-            d: { x: pos.x, y: pos.y }
-          };
-          viaRegion.ports.push(port);
-          convexRegion.ports.push(port);
-          allPorts.push(port);
+          const dx = pos.x - viaCenter.x;
+          const dy = pos.y - viaCenter.y;
+          const side = classifySideFromBounds(pos, viaRegion.d.bounds);
+          const primaryDistance = side === "left" || side === "right" ? Math.abs(dx) : Math.abs(dy);
+          const orthDistance = side === "left" || side === "right" ? Math.abs(dy) : Math.abs(dx);
+          candidates.push({
+            convexRegion,
+            position: pos,
+            side,
+            primaryDistance,
+            orthDistance,
+            key: toCandidateKey(convexRegion.regionId, pos)
+          });
         }
       }
     }
+    if (candidates.length === 0) continue;
+    const selectedCandidates = [];
+    const selectedKeys = /* @__PURE__ */ new Set();
+    const addCandidate = (candidate) => {
+      if (!candidate) return;
+      if (selectedKeys.has(candidate.key)) return;
+      selectedCandidates.push(candidate);
+      selectedKeys.add(candidate.key);
+    };
+    for (const side of ["top", "bottom", "left", "right"]) {
+      const sideCandidate = [...candidates].filter((candidate) => candidate.side === side).sort(compareCandidateQuality)[0];
+      addCandidate(sideCandidate);
+    }
+    if (selectedCandidates.length < 4) {
+      for (const candidate of [...candidates].sort(compareCandidateQuality)) {
+        addCandidate(candidate);
+        if (selectedCandidates.length >= 4) break;
+      }
+    }
+    for (const selectedCandidate of selectedCandidates.slice(0, 4)) {
+      const port = {
+        portId: `via-convex:${viaRegion.regionId}-${selectedCandidate.convexRegion.regionId}:${portIdCounter++}`,
+        region1: viaRegion,
+        region2: selectedCandidate.convexRegion,
+        d: {
+          x: selectedCandidate.position.x,
+          y: selectedCandidate.position.y
+        }
+      };
+      viaRegion.ports.push(port);
+      selectedCandidate.convexRegion.ports.push(port);
+      allPorts.push(port);
+    }
   }
   return {
     regions: allRegions,