@tscircuit/hypergraph 0.0.32 → 0.0.34

package/dist/index.d.ts

@@ -241,6 +241,13 @@ 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;
     computeG(candidate: CandidateType): number;
     /**
      * Return a subset of the candidates for entering a region. These candidates
@@ -378,6 +385,7 @@ declare class JumperGraphSolver extends HyperGraphSolver<JRegion, JPort> {
     getPortUsagePenalty(port: JPort): number;
     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,15 @@ 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;
+  }
   computeG(candidate) {
     return candidate.parent.g + this.computeIncreasedRegionCostIfPortsAreUsed(
       candidate.lastRegion,
@@ -396,7 +405,11 @@ 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;
+      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 +771,174 @@ var rotateGraph90Degrees = (graph) => {
   return applyTransformToGraph(graph, matrix2);
 };
 
+// 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/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/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/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/visualizeJumperGraph.ts
 var visualizeJumperGraph = (graph, options) => {
   const graphics = {
@@ -971,174 +1152,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,
@@ -1223,9 +1236,26 @@ var JumperGraphSolver = class extends HyperGraphSolver {
   }
   getRipsRequiredForPortUsage(region, port1, port2) {
     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) return false;
+    for (const assignment of region.assignments ?? []) {
+      if (assignment.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId) {
+        return true;
+      }
+    }
+    return false;
   }
   routeSolvedHook(solvedRoute) {
   }
@@ -14760,12 +14790,13 @@ function generateConvexViaTopologyRegions(opts) {
   const obstaclePolygons = viaRegions.map((r) => ({
     points: r.d.polygon
   }));
-  const solver = new ConvexRegionsSolver({
+  const solverInput = {
     bounds,
     polygons: obstaclePolygons,
     clearance,
     concavityTolerance
-  });
+  };
+  const solver = new ConvexRegionsSolver(solverInput);
   solver.solve();
   const solverOutput = solver.getOutput();
   if (!solverOutput) {

package/package.json

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