@tscircuit/hypergraph 0.0.33 → 0.0.35

package/dist/index.d.ts

@@ -241,6 +241,20 @@ declare class HyperGraphSolver<RegionType extends Region = Region, RegionPortTyp
      * a route would require ripping other routes due to problematic crossings.
      */
     getRipsRequiredForPortUsage(_region: RegionType, _port1: RegionPortType, _port2: RegionPortType): RegionPortAssignment[];
+    /**
+     * OPTIONALLY OVERRIDE THIS
+     *
+     * Return true if using the candidate transition should incur ripCost even
+     * when there is no direct port-assignment conflict.
+     */
+    isRipRequiredForPortUsage(_region: RegionType, _port1: RegionPortType, _port2: RegionPortType): boolean;
+    /**
+     * OPTIONALLY OVERRIDE THIS
+     *
+     * Return false to prevent transitioning through a region from `_port1` to
+     * `_port2`.
+     */
+    isTransitionAllowed(_region: RegionType, _port1: RegionPortType, _port2: RegionPortType): boolean;
     computeG(candidate: CandidateType): number;
     /**
      * Return a subset of the candidates for entering a region. These candidates
@@ -310,6 +324,11 @@ interface JRegion extends Region {
             x: number;
             y: number;
         }[];
+        polygonPerimeterCache?: {
+            edgeLengths: number[];
+            cumulative: number[];
+            perimeter: number;
+        };
         isPad: boolean;
         isThroughJumper?: boolean;
         isConnectionRegion?: boolean;
@@ -317,6 +336,8 @@ interface JRegion extends Region {
     };
 }
 interface JPort extends RegionPort {
+    region1T?: number;
+    region2T?: number;
     d: {
         x: number;
         y: number;
@@ -376,8 +397,10 @@ declare class JumperGraphSolver extends HyperGraphSolver<JRegion, JPort> {
     private populateDistanceToEndMaps;
     estimateCostToEnd(port: JPort): number;
     getPortUsagePenalty(port: JPort): number;
+    isTransitionAllowed(region: JRegion, port1: JPort, port2: JPort): boolean;
     computeIncreasedRegionCostIfPortsAreUsed(region: JRegion, port1: JPort, port2: JPort): number;
     getRipsRequiredForPortUsage(region: JRegion, port1: JPort, port2: JPort): RegionPortAssignment[];
+    isRipRequiredForPortUsage(region: JRegion, _port1: JPort, _port2: JPort): boolean;
     routeSolvedHook(solvedRoute: SolvedRoute): void;
     routeStartedHook(connection: Connection): void;
     visualize(): GraphicsObject;

package/dist/index.js

@@ -31,6 +31,28 @@ var convertHyperGraphToSerializedHyperGraph = (graph) => {
 // lib/HyperGraphSolver.ts
 import { BaseSolver } from "@tscircuit/solver-utils";
 
+// lib/convertSerializedConnectionsToConnections.ts
+var convertSerializedConnectionsToConnections = (inputConnections, graph) => {
+  const connections = [];
+  for (const inputConn of inputConnections) {
+    if ("startRegionId" in inputConn) {
+      connections.push({
+        connectionId: inputConn.connectionId,
+        mutuallyConnectedNetworkId: inputConn.connectionId,
+        startRegion: graph.regions.find(
+          (region) => region.regionId === inputConn.startRegionId
+        ),
+        endRegion: graph.regions.find(
+          (region) => region.regionId === inputConn.endRegionId
+        )
+      });
+    } else {
+      connections.push(inputConn);
+    }
+  }
+  return connections;
+};
+
 // lib/convertSerializedHyperGraphToHyperGraph.ts
 var convertSerializedHyperGraphToHyperGraph = (inputGraph) => {
   if (inputGraph.ports.length > 0 && "region1" in inputGraph.ports[0] && typeof inputGraph.ports[0].region1 === "object") {
@@ -65,28 +87,6 @@ var convertSerializedHyperGraphToHyperGraph = (inputGraph) => {
   };
 };
 
-// lib/convertSerializedConnectionsToConnections.ts
-var convertSerializedConnectionsToConnections = (inputConnections, graph) => {
-  const connections = [];
-  for (const inputConn of inputConnections) {
-    if ("startRegionId" in inputConn) {
-      connections.push({
-        connectionId: inputConn.connectionId,
-        mutuallyConnectedNetworkId: inputConn.connectionId,
-        startRegion: graph.regions.find(
-          (region) => region.regionId === inputConn.startRegionId
-        ),
-        endRegion: graph.regions.find(
-          (region) => region.regionId === inputConn.endRegionId
-        )
-      });
-    } else {
-      connections.push(inputConn);
-    }
-  }
-  return connections;
-};
-
 // lib/PriorityQueue.ts
 var PriorityQueue = class {
   // Store the heap as an array. Index 0 is the root (highest priority/smallest 'f').
@@ -328,6 +328,24 @@ var HyperGraphSolver = class extends BaseSolver {
   getRipsRequiredForPortUsage(_region, _port1, _port2) {
     return [];
   }
+  /**
+   * OPTIONALLY OVERRIDE THIS
+   *
+   * Return true if using the candidate transition should incur ripCost even
+   * when there is no direct port-assignment conflict.
+   */
+  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,
@@ -396,7 +414,18 @@ var HyperGraphSolver = class extends BaseSolver {
     const nextCandidatesByRegion = {};
     for (const port of currentRegion.ports) {
       if (port === currentCandidate.port) continue;
-      const ripRequired = port.assignment && port.assignment.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId;
+      if (!this.isTransitionAllowed(
+        currentRegion,
+        currentPort,
+        port
+      )) {
+        continue;
+      }
+      const ripRequired = port.assignment && port.assignment.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId || this.isRipRequiredForPortUsage(
+        currentRegion,
+        currentPort,
+        port
+      );
       const newCandidate = {
         port,
         hops: currentCandidate.hops + 1,
@@ -758,6 +787,277 @@ var rotateGraph90Degrees = (graph) => {
   return applyTransformToGraph(graph, matrix2);
 };
 
+// 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);
+  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 === 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 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)) {
+    return false;
+  }
+  return a < c && c < b && b < d || c < a && a < d && d < b;
+}
+
+// lib/JumperGraphSolver/computeCrossingAssignments.ts
+function computeCrossingAssignments(region, port1, port2) {
+  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 = getPortPerimeterTInRegion(
+      assignment.regionPort1,
+      region
+    );
+    const existingT2 = getPortPerimeterTInRegion(
+      assignment.regionPort2,
+      region
+    );
+    const existingChord = [existingT1, existingT2];
+    if (chordsCross(newChord, existingChord, perimeter)) {
+      crossingAssignments.push(assignment);
+    }
+  }
+  return crossingAssignments;
+}
+
+// lib/JumperGraphSolver/computeDifferentNetCrossings.ts
+function computeDifferentNetCrossings(region, port1, port2) {
+  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 = getPortPerimeterTInRegion(
+      assignment.regionPort1,
+      region
+    );
+    const existingT2 = getPortPerimeterTInRegion(
+      assignment.regionPort2,
+      region
+    );
+    const existingChord = [existingT1, existingT2];
+    if (chordsCross(newChord, existingChord, perimeter)) {
+      crossings++;
+    }
+  }
+  return crossings;
+}
+
+// lib/JumperGraphSolver/countInputConnectionCrossings.ts
+function countInputConnectionCrossings(graph, connections) {
+  if (connections.length < 2) {
+    return 0;
+  }
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+  for (const region of graph.regions) {
+    const jRegion = region;
+    if (jRegion.d?.bounds) {
+      minX = Math.min(minX, jRegion.d.bounds.minX);
+      maxX = Math.max(maxX, jRegion.d.bounds.maxX);
+      minY = Math.min(minY, jRegion.d.bounds.minY);
+      maxY = Math.max(maxY, jRegion.d.bounds.maxY);
+    } else if (jRegion.d?.center) {
+      minX = Math.min(minX, jRegion.d.center.x);
+      maxX = Math.max(maxX, jRegion.d.center.x);
+      minY = Math.min(minY, jRegion.d.center.y);
+      maxY = Math.max(maxY, jRegion.d.center.y);
+    }
+  }
+  const regionCenterMap = /* @__PURE__ */ new Map();
+  for (const region of graph.regions) {
+    const jRegion = region;
+    if (jRegion.d?.center) {
+      regionCenterMap.set(region.regionId, jRegion.d.center);
+    }
+  }
+  const chords = [];
+  const perimeter = 2 * (maxX - minX) + 2 * (maxY - minY);
+  for (const conn of connections) {
+    let startCenter;
+    let endCenter;
+    if ("startRegion" in conn && conn.startRegion) {
+      const startRegion = conn.startRegion;
+      const endRegion = conn.endRegion;
+      startCenter = startRegion.d?.center;
+      endCenter = endRegion.d?.center;
+    } else if ("startRegionId" in conn) {
+      startCenter = regionCenterMap.get(conn.startRegionId);
+      endCenter = regionCenterMap.get(conn.endRegionId);
+    }
+    if (!startCenter || !endCenter) {
+      continue;
+    }
+    const t1 = perimeterT(startCenter, minX, maxX, minY, maxY);
+    const t2 = perimeterT(endCenter, minX, maxX, minY, maxY);
+    chords.push([t1, t2]);
+  }
+  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], perimeter)) {
+        crossings++;
+      }
+    }
+  }
+  return crossings;
+}
+
 // lib/JumperGraphSolver/visualizeJumperGraph.ts
 var visualizeJumperGraph = (graph, options) => {
   const graphics = {
@@ -791,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({
@@ -884,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
@@ -971,174 +1275,6 @@ var visualizeJumperGraphSolver = (solver) => {
   return graphics;
 };
 
-// lib/JumperGraphSolver/perimeterChordUtils.ts
-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);
-  }
-  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 === 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 areCoincident(t1, t2, eps = 1e-6) {
-  return Math.abs(t1 - t2) < eps;
-}
-function chordsCross(chord1, chord2) {
-  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)) {
-    return false;
-  }
-  return a < c && c < b && b < d || c < a && a < d && d < b;
-}
-
-// 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 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 existingT2 = perimeterT(
-      assignment.regionPort2.d,
-      xmin,
-      xmax,
-      ymin,
-      ymax
-    );
-    const existingChord = [existingT1, existingT2];
-    if (chordsCross(newChord, existingChord)) {
-      crossings++;
-    }
-  }
-  return crossings;
-}
-
-// 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 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 existingT2 = perimeterT(
-      assignment.regionPort2.d,
-      xmin,
-      xmax,
-      ymin,
-      ymax
-    );
-    const existingChord = [existingT1, existingT2];
-    if (chordsCross(newChord, existingChord)) {
-      crossingAssignments.push(assignment);
-    }
-  }
-  return crossingAssignments;
-}
-
-// lib/JumperGraphSolver/countInputConnectionCrossings.ts
-function countInputConnectionCrossings(graph, connections) {
-  if (connections.length < 2) {
-    return 0;
-  }
-  let minX = Infinity;
-  let maxX = -Infinity;
-  let minY = Infinity;
-  let maxY = -Infinity;
-  for (const region of graph.regions) {
-    const jRegion = region;
-    if (jRegion.d?.bounds) {
-      minX = Math.min(minX, jRegion.d.bounds.minX);
-      maxX = Math.max(maxX, jRegion.d.bounds.maxX);
-      minY = Math.min(minY, jRegion.d.bounds.minY);
-      maxY = Math.max(maxY, jRegion.d.bounds.maxY);
-    } else if (jRegion.d?.center) {
-      minX = Math.min(minX, jRegion.d.center.x);
-      maxX = Math.max(maxX, jRegion.d.center.x);
-      minY = Math.min(minY, jRegion.d.center.y);
-      maxY = Math.max(maxY, jRegion.d.center.y);
-    }
-  }
-  const regionCenterMap = /* @__PURE__ */ new Map();
-  for (const region of graph.regions) {
-    const jRegion = region;
-    if (jRegion.d?.center) {
-      regionCenterMap.set(region.regionId, jRegion.d.center);
-    }
-  }
-  const chords = [];
-  for (const conn of connections) {
-    let startCenter;
-    let endCenter;
-    if ("startRegion" in conn && conn.startRegion) {
-      const startRegion = conn.startRegion;
-      const endRegion = conn.endRegion;
-      startCenter = startRegion.d?.center;
-      endCenter = endRegion.d?.center;
-    } else if ("startRegionId" in conn) {
-      startCenter = regionCenterMap.get(conn.startRegionId);
-      endCenter = regionCenterMap.get(conn.endRegionId);
-    }
-    if (!startCenter || !endCenter) {
-      continue;
-    }
-    const t1 = perimeterT(startCenter, minX, maxX, minY, maxY);
-    const t2 = perimeterT(endCenter, minX, maxX, minY, maxY);
-    chords.push([t1, t2]);
-  }
-  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])) {
-        crossings++;
-      }
-    }
-  }
-  return crossings;
-}
-
 // lib/JumperGraphSolver/JumperGraphSolver.ts
 var JUMPER_GRAPH_SOLVER_DEFAULTS = {
   portUsagePenalty: 0.034685181009478865,
@@ -1217,15 +1353,56 @@ 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);
-    return crossingAssignments.filter(
+    const conflictingAssignments = crossingAssignments.filter(
       (a) => a.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId
     );
+    if (!region.d.isThroughJumper) return conflictingAssignments;
+    for (const assignment of region.assignments ?? []) {
+      if (assignment.connection.mutuallyConnectedNetworkId === this.currentConnection.mutuallyConnectedNetworkId) {
+        continue;
+      }
+      conflictingAssignments.push(assignment);
+    }
+    return conflictingAssignments;
+  }
+  isRipRequiredForPortUsage(region, _port1, _port2) {
+    if (!region.d.isThroughJumper && !region.d.isPad) return false;
+    for (const assignment of region.assignments ?? []) {
+      if (assignment.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId) {
+        return true;
+      }
+    }
+    return false;
   }
   routeSolvedHook(solvedRoute) {
   }
@@ -1271,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 };
@@ -1296,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) {
@@ -4946,64 +5219,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++;
     }
   }
@@ -5014,22 +5251,23 @@ 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);
     }
   }
@@ -5076,6 +5314,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();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/hypergraph",
   "main": "dist/index.js",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "type": "module",
   "scripts": {
     "start": "cosmos",
@@ -17,7 +17,7 @@
   "devDependencies": {
     "@biomejs/biome": "^2.3.11",
     "@tscircuit/find-convex-regions": "^0.0.7",
-    "@tscircuit/jumper-topology-generator": "^0.0.1",
+    "@tscircuit/jumper-topology-generator": "^0.0.2",
     "@tscircuit/math-utils": "^0.0.29",
     "@types/bun": "latest",
     "bun-match-svg": "^0.0.15",