@tscircuit/hypergraph 0.0.28 → 0.0.29

package/dist/index.js

@@ -3490,700 +3490,321 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`
   }
 };
 
-// lib/ViaGraphSolver/polygonPerimeterUtils.ts
-function polygonPerimeterT(p, polygon) {
-  const n = polygon.length;
-  let bestDist = Infinity;
-  let bestEdgeIndex = 0;
-  let bestT = 0;
-  for (let i = 0; i < n; i++) {
-    const a2 = polygon[i];
-    const b2 = polygon[(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;
+// assets/ViaGraphSolver/vias-by-net.json
+var vias_by_net_default = {
+  Net6: [
+    {
+      viaId: "4ef04070-bacf-4a8a-8ac9-ea222cf4bf2c",
+      diameter: 0.6,
+      position: {
+        x: 1.483834,
+        y: 0.582296
+      }
+    },
+    {
+      viaId: "79364d38-c966-4eff-aa4a-e3ff6cca6339",
+      diameter: 0.6,
+      position: {
+        x: -0.8,
+        y: -1.893395
+      }
+    },
+    {
+      viaId: "f1d52fd5-ddd2-4440-8772-da3d096b033f",
+      diameter: 0.6,
+      position: {
+        x: -0.703066,
+        y: 1.2
+      }
     }
-  }
-  let cumulative = 0;
-  for (let i = 0; i < bestEdgeIndex; i++) {
-    const a2 = polygon[i];
-    const b2 = polygon[(i + 1) % n];
-    cumulative += Math.sqrt((b2.x - a2.x) ** 2 + (b2.y - a2.y) ** 2);
-  }
-  const a = polygon[bestEdgeIndex];
-  const b = polygon[(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 polygon = region.d.polygon;
-  if (!polygon || polygon.length < 3) {
-    return 0;
-  }
-  const t1 = polygonPerimeterT(port1.d, polygon);
-  const t2 = polygonPerimeterT(port2.d, polygon);
-  const newChord = [t1, t2];
-  let crossings = 0;
-  const assignments = region.assignments ?? [];
-  for (const assignment of assignments) {
-    const existingT1 = polygonPerimeterT(
-      assignment.regionPort1.d,
-      polygon
-    );
-    const existingT2 = polygonPerimeterT(
-      assignment.regionPort2.d,
-      polygon
-    );
-    const existingChord = [existingT1, existingT2];
-    if (chordsCross(newChord, existingChord)) {
-      crossings++;
+  ],
+  Net5: [
+    {
+      viaId: "4e57cee8-0910-4c83-9ec1-1ed2c9d16dcc",
+      diameter: 0.6,
+      position: {
+        x: 1.268717,
+        y: -1.698536
+      }
+    },
+    {
+      viaId: "a3797f13-73f9-48c3-a448-bea3980cdd65",
+      diameter: 0.6,
+      position: {
+        x: -1.115754,
+        y: -0.799377
+      }
+    },
+    {
+      viaId: "b0c56bb1-ea80-4154-9bb7-cb0fd760de8f",
+      diameter: 0.6,
+      position: {
+        x: 0.397934,
+        y: 1.458567
+      }
     }
-  }
-  return crossings;
-}
-function computeCrossingAssignmentsForPolygon(region, port1, port2) {
-  const polygon = region.d.polygon;
-  if (!polygon || polygon.length < 3) {
-    return [];
-  }
-  const t1 = polygonPerimeterT(port1.d, polygon);
-  const t2 = polygonPerimeterT(port2.d, polygon);
-  const newChord = [t1, t2];
-  const crossingAssignments = [];
-  const assignments = region.assignments ?? [];
-  for (const assignment of assignments) {
-    const existingT1 = polygonPerimeterT(
-      assignment.regionPort1.d,
-      polygon
-    );
-    const existingT2 = polygonPerimeterT(
-      assignment.regionPort2.d,
-      polygon
-    );
-    const existingChord = [existingT1, existingT2];
-    if (chordsCross(newChord, existingChord)) {
-      crossingAssignments.push(assignment);
+  ],
+  Net7: [
+    {
+      viaId: "3719876b-17c8-4ee3-9cce-5b5c073d6614",
+      diameter: 0.6,
+      position: {
+        x: 1.186721,
+        y: 1.32508
+      }
+    },
+    {
+      viaId: "4e46d759-a04a-4f7e-99cd-9e05adf5fa23",
+      diameter: 0.6,
+      position: {
+        x: -1.275,
+        y: 0
+      }
+    },
+    {
+      viaId: "63afce65-b94e-47da-ae14-51ff0ee8eb39",
+      diameter: 0.6,
+      position: {
+        x: 1.655408,
+        y: -0.998198
+      }
     }
-  }
-  return crossingAssignments;
-}
-
-// lib/ViaGraphSolver/visualizeViaGraphSolver.ts
-var getConnectionColor2 = (connectionId, alpha = 0.8) => {
-  let hash = 0;
-  for (let i = 0; i < connectionId.length; i++) {
-    hash = connectionId.charCodeAt(i) * 17777 + ((hash << 5) - hash);
-  }
-  const hue = Math.abs(hash) % 360;
-  return `hsla(${hue}, 70%, 50%, ${alpha})`;
-};
-var NET_COLOR_PALETTE = [
-  "rgba(231, 76, 60, 0.35)",
-  // red
-  "rgba(46, 204, 113, 0.35)",
-  // green
-  "rgba(52, 152, 219, 0.35)",
-  // blue
-  "rgba(243, 156, 18, 0.35)",
-  // orange
-  "rgba(155, 89, 182, 0.35)",
-  // purple
-  "rgba(26, 188, 156, 0.35)",
-  // teal
-  "rgba(241, 196, 15, 0.35)",
-  // yellow
-  "rgba(230, 126, 34, 0.35)"
-  // dark orange
-];
-var visualizeViaGraphSolver = (solver) => {
-  const graph = {
-    regions: solver.graph.regions,
-    ports: solver.graph.ports
-  };
-  const graphics = visualizeJumperGraph(graph, {
-    connections: solver.connections,
-    ...solver.iterations > 0 ? {
-      hideRegionPortLines: true,
-      hideConnectionLines: true,
-      hidePortPoints: true
-    } : {}
-  });
-  const outerIds = /* @__PURE__ */ new Set(["T", "B", "L", "R"]);
-  let netColorIndex = 0;
-  const netColorMap = /* @__PURE__ */ new Map();
-  let polyIndex = 0;
-  for (const region of graph.regions) {
-    const jRegion = region;
-    const hasPolygon = jRegion.d.polygon && jRegion.d.polygon.length >= 3;
-    if (!hasPolygon) continue;
-    const suffix = jRegion.regionId.split(":").pop() ?? "";
-    const isOuter = outerIds.has(suffix);
-    if (!isOuter && !jRegion.d.isConnectionRegion) {
-      if (!netColorMap.has(suffix)) {
-        netColorMap.set(
-          suffix,
-          NET_COLOR_PALETTE[netColorIndex % NET_COLOR_PALETTE.length]
-        );
-        netColorIndex++;
+  ],
+  Net8: [
+    {
+      viaId: "26d3bef1-a78f-4947-b551-c48f04289a98",
+      diameter: 0.6,
+      position: {
+        x: 1.553029,
+        y: -0.164505
       }
-      if (graphics.polygons[polyIndex]) {
-        graphics.polygons[polyIndex].fill = netColorMap.get(suffix);
+    },
+    {
+      viaId: "548acbca-8b68-4186-a589-681ec44fba42",
+      diameter: 0.6,
+      position: {
+        x: 0.222457,
+        y: -1.866711
+      }
+    },
+    {
+      viaId: "d6bf60bf-4b90-4967-a295-fc930b1f2549",
+      diameter: 0.6,
+      position: {
+        x: -1.419706,
+        y: 0.868747
       }
     }
-    polyIndex++;
-  }
-  if (solver.currentConnection && !solver.solved) {
-    const connectionColor = getConnectionColor2(
-      solver.currentConnection.connectionId
+  ]
+};
+
+// lib/ViaGraphSolver/via-graph-generator/generateViaTopologyRegions.ts
+var TRACE_PITCH = 0.4;
+var generateViaTopologyRegions = (viasByNet, opts) => {
+  const graphSize = opts?.graphSize ?? 5;
+  const idPrefix = opts?.idPrefix ?? "via";
+  const half = graphSize / 2;
+  const topSegments = [];
+  const bottomSegments = [];
+  const leftSegments = [];
+  const rightSegments = [];
+  for (const vias of Object.values(viasByNet)) {
+    if (vias.length === 0) continue;
+    const topVia = vias.reduce(
+      (best, v) => v.position.y > best.position.y ? v : best
     );
-    const startRegion = solver.currentConnection.startRegion;
-    const endRegion = solver.currentConnection.endRegion;
-    const startCenter = {
-      x: (startRegion.d.bounds.minX + startRegion.d.bounds.maxX) / 2,
-      y: (startRegion.d.bounds.minY + startRegion.d.bounds.maxY) / 2
-    };
-    const endCenter = {
-      x: (endRegion.d.bounds.minX + endRegion.d.bounds.maxX) / 2,
-      y: (endRegion.d.bounds.minY + endRegion.d.bounds.maxY) / 2
-    };
-    graphics.lines.push({
-      points: [startCenter, endCenter],
-      strokeColor: connectionColor,
-      strokeDash: "10 5"
+    const topY = topVia.position.y + topVia.diameter / 2;
+    topSegments.push({
+      xStart: topVia.position.x - topVia.diameter / 2,
+      xEnd: topVia.position.x + topVia.diameter / 2,
+      y: topY
     });
-    graphics.points.push({
-      x: startCenter.x - 0.1,
-      y: startCenter.y + 0.1,
-      color: connectionColor,
-      label: [solver.currentConnection.connectionId, "start"].join("\n")
+    const bottomVia = vias.reduce(
+      (best, v) => v.position.y < best.position.y ? v : best
+    );
+    const botY = bottomVia.position.y - bottomVia.diameter / 2;
+    bottomSegments.push({
+      xStart: bottomVia.position.x - bottomVia.diameter / 2,
+      xEnd: bottomVia.position.x + bottomVia.diameter / 2,
+      y: botY
     });
-    graphics.points.push({
-      x: endCenter.x - 0.1,
-      y: endCenter.y + 0.1,
-      color: connectionColor,
-      label: [solver.currentConnection.connectionId, "end"].join("\n")
+    const leftVia = vias.reduce(
+      (best, v) => v.position.x < best.position.x ? v : best
+    );
+    const leftX = leftVia.position.x - leftVia.diameter / 2;
+    leftSegments.push({
+      x: leftX,
+      yStart: leftVia.position.y - leftVia.diameter / 2,
+      yEnd: leftVia.position.y + leftVia.diameter / 2
     });
-  }
-  for (const solvedRoute of solver.solvedRoutes) {
-    const connectionColor = getConnectionColor2(
-      solvedRoute.connection.connectionId
+    const rightVia = vias.reduce(
+      (best, v) => v.position.x > best.position.x ? v : best
     );
-    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) {
-      graphics.lines.push({
-        points: pathPoints,
-        strokeColor: connectionColor
-      });
-    }
-  }
-  const candidates = solver.candidateQueue.peekMany(10);
-  for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
-    const candidate = candidates[candidateIndex];
-    const port = candidate.port;
-    const isNext = candidateIndex === 0;
-    graphics.points.push({
-      x: port.d.x,
-      y: port.d.y,
-      color: isNext ? "green" : "rgba(128, 128, 128, 0.25)",
-      label: [
-        candidate.port.portId,
-        `g: ${candidate.g.toFixed(2)}`,
-        `h: ${candidate.h.toFixed(2)}`,
-        `f: ${candidate.f.toFixed(2)}`
-      ].join("\n")
+    const rightX = rightVia.position.x + rightVia.diameter / 2;
+    rightSegments.push({
+      x: rightX,
+      yStart: rightVia.position.y - rightVia.diameter / 2,
+      yEnd: rightVia.position.y + rightVia.diameter / 2
     });
   }
-  const nextCandidate = candidates[0];
-  if (!solver.solved && nextCandidate && solver.currentConnection) {
-    const connectionColor = getConnectionColor2(
-      solver.currentConnection.connectionId
-    );
-    const activePath = [];
-    let cursor = nextCandidate;
-    while (cursor) {
-      const port = cursor.port;
-      activePath.unshift({ x: port.d.x, y: port.d.y });
-      cursor = cursor.parent;
-    }
-    if (activePath.length > 1) {
-      graphics.lines.push({
-        points: activePath,
-        strokeColor: connectionColor
-      });
+  topSegments.sort((a, b) => a.xStart - b.xStart);
+  bottomSegments.sort((a, b) => a.xStart - b.xStart);
+  leftSegments.sort((a, b) => a.yStart - b.yStart);
+  rightSegments.sort((a, b) => a.yStart - b.yStart);
+  const lTop = leftSegments[leftSegments.length - 1];
+  const lBot = leftSegments[0];
+  const rTop = rightSegments[rightSegments.length - 1];
+  const rBot = rightSegments[0];
+  const boundsFromPolygon = (points) => {
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+    for (const p of points) {
+      if (p.x < minX) minX = p.x;
+      if (p.x > maxX) maxX = p.x;
+      if (p.y < minY) minY = p.y;
+      if (p.y > maxY) maxY = p.y;
     }
-  }
-  if (solver.viasByNet) {
-    if (!graphics.circles) graphics.circles = [];
-    for (const [netName, vias] of Object.entries(solver.viasByNet)) {
-      const netColor = netColorMap.get(netName);
-      const viaFill = netColor ? netColor.replace("0.35", "0.5") : "rgba(255, 0, 0, 0.3)";
-      for (const via of vias) {
-        graphics.circles.push({
-          center: via.position,
-          radius: via.diameter / 2,
-          fill: viaFill,
-          label: netName
-        });
+    return { minX, maxX, minY, maxY };
+  };
+  const createRegion = (id, polygon, opts2) => {
+    const bounds = boundsFromPolygon(polygon);
+    return {
+      regionId: `${idPrefix}:${id}`,
+      ports: [],
+      d: {
+        bounds,
+        center: {
+          x: (bounds.minX + bounds.maxX) / 2,
+          y: (bounds.minY + bounds.maxY) / 2
+        },
+        polygon,
+        isPad: false,
+        isViaRegion: opts2?.isViaRegion
       }
-    }
-  }
-  return graphics;
-};
-
-// lib/ViaGraphSolver/ViaGraphSolver.ts
-var VIA_GRAPH_SOLVER_DEFAULTS = {
-  portUsagePenalty: 0.034685181009478865,
-  portUsagePenaltySq: 0,
-  crossingPenalty: 4.072520483177124,
-  crossingPenaltySq: 0,
-  ripCost: 35.38577539020022,
-  greedyMultiplier: 0.5518001238069296
-};
-var ViaGraphSolver = class extends HyperGraphSolver {
-  getSolverName() {
-    return "ViaGraphSolver";
+    };
+  };
+  const topPolygon = [];
+  topPolygon.push({ x: -half, y: half });
+  topPolygon.push({ x: half, y: half });
+  topPolygon.push({ x: half, y: rTop.yEnd });
+  topPolygon.push({ x: rTop.x, y: rTop.yEnd });
+  const nTop = topSegments.length;
+  for (let i = nTop - 1; i >= 0; i--) {
+    topPolygon.push({ x: topSegments[i].xEnd, y: topSegments[i].y });
+    topPolygon.push({ x: topSegments[i].xStart, y: topSegments[i].y });
   }
-  UNIT_OF_COST = "hops";
-  viasByNet;
-  portUsagePenalty = VIA_GRAPH_SOLVER_DEFAULTS.portUsagePenalty;
-  portUsagePenaltySq = VIA_GRAPH_SOLVER_DEFAULTS.portUsagePenaltySq;
-  crossingPenalty = VIA_GRAPH_SOLVER_DEFAULTS.crossingPenalty;
-  crossingPenaltySq = VIA_GRAPH_SOLVER_DEFAULTS.crossingPenaltySq;
-  ripCost = VIA_GRAPH_SOLVER_DEFAULTS.ripCost;
-  baseMaxIterations = 9e5;
-  additionalMaxIterationsPerConnection = 2e3;
-  additionalMaxIterationsPerCrossing = 2e3;
-  constructor(input) {
-    super({
-      greedyMultiplier: VIA_GRAPH_SOLVER_DEFAULTS.greedyMultiplier,
-      rippingEnabled: true,
-      ...input
+  topPolygon.push({ x: lTop.x, y: lTop.yEnd });
+  topPolygon.push({ x: -half, y: lTop.yEnd });
+  const topRegion = createRegion("T", topPolygon);
+  const bottomPolygon = [];
+  bottomPolygon.push({ x: -half, y: -half });
+  bottomPolygon.push({ x: half, y: -half });
+  bottomPolygon.push({ x: half, y: rBot.yStart });
+  bottomPolygon.push({ x: rBot.x, y: rBot.yStart });
+  const nBot = bottomSegments.length;
+  for (let i = nBot - 1; i >= 0; i--) {
+    bottomPolygon.push({ x: bottomSegments[i].xEnd, y: bottomSegments[i].y });
+    bottomPolygon.push({
+      x: bottomSegments[i].xStart,
+      y: bottomSegments[i].y
     });
-    this.viasByNet = input.viasByNet;
-    this.ripCost = input.ripCost ?? this.ripCost;
-    this.portUsagePenalty = input.portUsagePenalty ?? this.portUsagePenalty;
-    this.crossingPenalty = input.crossingPenalty ?? this.crossingPenalty;
-    this.baseMaxIterations = input.baseMaxIterations ?? this.baseMaxIterations;
-    this.additionalMaxIterationsPerConnection = input.additionalMaxIterationsPerConnection ?? this.additionalMaxIterationsPerConnection;
-    const crossings = countInputConnectionCrossings(
-      this.graph,
-      input.inputConnections
-    );
-    this.MAX_ITERATIONS = this.baseMaxIterations + input.inputConnections.length * this.additionalMaxIterationsPerConnection + crossings * this.additionalMaxIterationsPerCrossing;
-    this.populateDistanceToEndMaps();
-  }
-  populateDistanceToEndMaps() {
-    const endRegions = new Set(this.connections.map((c) => c.endRegion));
-    for (const endRegion of endRegions) {
-      const regionDistanceMap = /* @__PURE__ */ new Map();
-      const queue = [];
-      regionDistanceMap.set(endRegion.regionId, 0);
-      queue.push({ region: endRegion, distance: 0 });
-      while (queue.length > 0) {
-        const { region, distance: dist } = queue.shift();
-        for (const port of region.ports) {
-          const otherRegion = port.region1 === region ? port.region2 : port.region1;
-          if (!regionDistanceMap.has(otherRegion.regionId)) {
-            regionDistanceMap.set(otherRegion.regionId, dist + 1);
-            queue.push({ region: otherRegion, distance: dist + 1 });
-          }
-        }
-      }
-      for (const port of this.graph.ports) {
-        if (!port.distanceToEndMap) {
-          port.distanceToEndMap = {};
-        }
-        const d1 = regionDistanceMap.get(port.region1.regionId) ?? Infinity;
-        const d2 = regionDistanceMap.get(port.region2.regionId) ?? Infinity;
-        port.distanceToEndMap[endRegion.regionId] = Math.min(d1, d2);
-      }
-    }
-  }
-  estimateCostToEnd(port) {
-    const endRegionId = this.currentEndRegion.regionId;
-    const hopDistance = port.distanceToEndMap[endRegionId];
-    return hopDistance;
   }
-  getPortUsagePenalty(port) {
-    const ripCount = port.ripCount ?? 0;
-    return ripCount * this.portUsagePenalty + ripCount * this.portUsagePenaltySq;
+  bottomPolygon.push({ x: lBot.x, y: lBot.yStart });
+  bottomPolygon.push({ x: -half, y: lBot.yStart });
+  const bottomRegion = createRegion("B", bottomPolygon);
+  const rightPolygon = [];
+  rightPolygon.push({ x: half, y: rBot.yStart });
+  rightPolygon.push({ x: rBot.x, y: rBot.yStart });
+  for (let i = 0; i < rightSegments.length; i++) {
+    rightPolygon.push({ x: rightSegments[i].x, y: rightSegments[i].yStart });
+    rightPolygon.push({ x: rightSegments[i].x, y: rightSegments[i].yEnd });
   }
-  computeIncreasedRegionCostIfPortsAreUsed(region, port1, port2) {
-    if (region.d.isViaRegion) {
-      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 = computeDifferentNetCrossingsForPolygon(
-      region,
-      port1,
-      port2
-    );
-    return crossings * this.crossingPenalty + crossings * this.crossingPenaltySq;
+  rightPolygon.push({ x: half, y: rTop.yEnd });
+  const rightRegion = createRegion("R", rightPolygon);
+  const leftPolygon = [];
+  leftPolygon.push({ x: -half, y: lBot.yStart });
+  leftPolygon.push({ x: lBot.x, y: lBot.yStart });
+  for (let i = 0; i < leftSegments.length; i++) {
+    leftPolygon.push({ x: leftSegments[i].x, y: leftSegments[i].yStart });
+    leftPolygon.push({ x: leftSegments[i].x, y: leftSegments[i].yEnd });
   }
-  getRipsRequiredForPortUsage(region, port1, port2) {
-    if (region.d.isViaRegion) {
-      const assignments = region.assignments ?? [];
-      return assignments.filter(
-        (a) => a.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId
-      );
+  leftPolygon.push({ x: -half, y: lTop.yEnd });
+  const leftRegion = createRegion("L", leftPolygon);
+  const regions = [topRegion, bottomRegion, leftRegion, rightRegion];
+  const ports = [];
+  const createPort = (id, region1, region2, x, y) => {
+    const port = {
+      portId: `${idPrefix}:${id}`,
+      region1,
+      region2,
+      d: { x, y }
+    };
+    region1.ports.push(port);
+    region2.ports.push(port);
+    return port;
+  };
+  const createHorizontalPorts = (groupId, region1, region2, xStart, xEnd, y) => {
+    const length = Math.abs(xEnd - xStart);
+    const count = Math.max(1, Math.floor(length / TRACE_PITCH));
+    const minX = Math.min(xStart, xEnd);
+    for (let i = 0; i < count; i++) {
+      const t = (i + 0.5) / count;
+      const x = minX + t * length;
+      const portId = count === 1 ? groupId : `${groupId}_${i}`;
+      ports.push(createPort(portId, region1, region2, x, y));
     }
-    const crossingAssignments = computeCrossingAssignmentsForPolygon(
-      region,
-      port1,
-      port2
-    );
-    return crossingAssignments.filter(
-      (a) => a.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId
-    );
-  }
-  routeSolvedHook(solvedRoute) {
-  }
-  routeStartedHook(connection) {
-  }
-  visualize() {
-    return visualizeViaGraphSolver(this);
-  }
-};
-
-// lib/ViaGraphSolver/via-graph-generator/findBoundaryRegionForPolygons.ts
-function closestPointOnPolygonEdge(point, polygon) {
-  let bestDist = Infinity;
-  let bestPoint = { x: point.x, y: point.y };
-  for (let i = 0; i < polygon.length; i++) {
-    const a = polygon[i];
-    const b = polygon[(i + 1) % polygon.length];
-    const dx = b.x - a.x;
-    const dy = b.y - a.y;
-    const lenSq = dx * dx + dy * dy;
-    if (lenSq < 1e-10) continue;
-    const t = Math.max(
-      0,
-      Math.min(1, ((point.x - a.x) * dx + (point.y - a.y) * dy) / lenSq)
-    );
-    const projX = a.x + t * dx;
-    const projY = a.y + t * dy;
-    const dist = Math.sqrt((point.x - projX) ** 2 + (point.y - projY) ** 2);
-    if (dist < bestDist) {
-      bestDist = dist;
-      bestPoint = { x: projX, y: projY };
-    }
-  }
-  return { ...bestPoint, dist: bestDist };
-}
-var findBoundaryRegionForPolygons = (x, y, regions) => {
-  let closestRegion = null;
-  let closestDistance = Infinity;
-  let closestPortPosition = { x, y };
-  for (const region of regions) {
-    if (region.d.isPad || region.d.isThroughJumper || region.d.isConnectionRegion)
-      continue;
-    const polygon = region.d.polygon;
-    if (!polygon || polygon.length < 3) continue;
-    const result = closestPointOnPolygonEdge({ x, y }, polygon);
-    if (result.dist < closestDistance) {
-      closestDistance = result.dist;
-      closestRegion = region;
-      closestPortPosition = { x: result.x, y: result.y };
-    }
-  }
-  if (closestRegion) {
-    return { region: closestRegion, portPosition: closestPortPosition };
-  }
-  return null;
-};
-
-// lib/ViaGraphSolver/via-graph-generator/createViaGraphWithConnections.ts
-var createViaGraphWithConnections = (baseGraph, xyConnections) => {
-  const regions = [...baseGraph.regions];
-  const ports = [...baseGraph.ports];
-  const connections = [];
-  for (const xyConn of xyConnections) {
-    const { start, end, connectionId } = xyConn;
-    const startRegion = createConnectionRegion(
-      `conn:${connectionId}:start`,
-      start.x,
-      start.y
-    );
-    regions.push(startRegion);
-    const endRegion = createConnectionRegion(
-      `conn:${connectionId}:end`,
-      end.x,
-      end.y
-    );
-    regions.push(endRegion);
-    const startBoundary = findBoundaryRegionForPolygons(
-      start.x,
-      start.y,
-      baseGraph.regions
-    );
-    if (startBoundary) {
-      const startPort = createConnectionPort(
-        `conn:${connectionId}:start-port`,
-        startRegion,
-        startBoundary.region,
-        startBoundary.portPosition
-      );
-      ports.push(startPort);
-    }
-    const endBoundary = findBoundaryRegionForPolygons(
-      end.x,
-      end.y,
-      baseGraph.regions
-    );
-    if (endBoundary) {
-      const endPort = createConnectionPort(
-        `conn:${connectionId}:end-port`,
-        endRegion,
-        endBoundary.region,
-        endBoundary.portPosition
-      );
-      ports.push(endPort);
-    }
-    const connection = {
-      connectionId,
-      mutuallyConnectedNetworkId: connectionId,
-      startRegion,
-      endRegion
-    };
-    connections.push(connection);
-  }
-  return {
-    regions,
-    ports,
-    connections
   };
-};
-
-// lib/ViaGraphSolver/via-graph-generator/generateViaTopologyRegions.ts
-var TRACE_PITCH = 0.4;
-var generateViaTopologyRegions = (viasByNet, opts) => {
-  const graphSize = opts?.graphSize ?? 5;
-  const idPrefix = opts?.idPrefix ?? "via";
-  const half = graphSize / 2;
-  const topSegments = [];
-  const bottomSegments = [];
-  const leftSegments = [];
-  const rightSegments = [];
-  for (const vias of Object.values(viasByNet)) {
+  createHorizontalPorts("T-R", topRegion, rightRegion, rTop.x, half, rTop.yEnd);
+  createHorizontalPorts("T-L", topRegion, leftRegion, -half, lTop.x, lTop.yEnd);
+  createHorizontalPorts(
+    "B-R",
+    bottomRegion,
+    rightRegion,
+    rBot.x,
+    half,
+    rBot.yStart
+  );
+  createHorizontalPorts(
+    "B-L",
+    bottomRegion,
+    leftRegion,
+    -half,
+    lBot.x,
+    lBot.yStart
+  );
+  for (const [netName, vias] of Object.entries(viasByNet)) {
     if (vias.length === 0) continue;
     const topVia = vias.reduce(
       (best, v) => v.position.y > best.position.y ? v : best
     );
-    const topY = topVia.position.y + topVia.diameter / 2;
-    topSegments.push({
-      xStart: topVia.position.x - topVia.diameter / 2,
-      xEnd: topVia.position.x + topVia.diameter / 2,
-      y: topY
-    });
     const bottomVia = vias.reduce(
       (best, v) => v.position.y < best.position.y ? v : best
     );
-    const botY = bottomVia.position.y - bottomVia.diameter / 2;
-    bottomSegments.push({
-      xStart: bottomVia.position.x - bottomVia.diameter / 2,
-      xEnd: bottomVia.position.x + bottomVia.diameter / 2,
-      y: botY
-    });
     const leftVia = vias.reduce(
       (best, v) => v.position.x < best.position.x ? v : best
     );
-    const leftX = leftVia.position.x - leftVia.diameter / 2;
-    leftSegments.push({
-      x: leftX,
-      yStart: leftVia.position.y - leftVia.diameter / 2,
-      yEnd: leftVia.position.y + leftVia.diameter / 2
-    });
     const rightVia = vias.reduce(
       (best, v) => v.position.x > best.position.x ? v : best
     );
-    const rightX = rightVia.position.x + rightVia.diameter / 2;
-    rightSegments.push({
-      x: rightX,
-      yStart: rightVia.position.y - rightVia.diameter / 2,
-      yEnd: rightVia.position.y + rightVia.diameter / 2
-    });
-  }
-  topSegments.sort((a, b) => a.xStart - b.xStart);
-  bottomSegments.sort((a, b) => a.xStart - b.xStart);
-  leftSegments.sort((a, b) => a.yStart - b.yStart);
-  rightSegments.sort((a, b) => a.yStart - b.yStart);
-  const lTop = leftSegments[leftSegments.length - 1];
-  const lBot = leftSegments[0];
-  const rTop = rightSegments[rightSegments.length - 1];
-  const rBot = rightSegments[0];
-  const boundsFromPolygon = (points) => {
-    let minX = Infinity;
-    let maxX = -Infinity;
-    let minY = Infinity;
-    let maxY = -Infinity;
-    for (const p of points) {
-      if (p.x < minX) minX = p.x;
-      if (p.x > maxX) maxX = p.x;
-      if (p.y < minY) minY = p.y;
-      if (p.y > maxY) maxY = p.y;
-    }
-    return { minX, maxX, minY, maxY };
-  };
-  const createRegion = (id, polygon, opts2) => {
-    const bounds = boundsFromPolygon(polygon);
-    return {
-      regionId: `${idPrefix}:${id}`,
-      ports: [],
-      d: {
-        bounds,
-        center: {
-          x: (bounds.minX + bounds.maxX) / 2,
-          y: (bounds.minY + bounds.maxY) / 2
-        },
-        polygon,
-        isPad: false,
-        isViaRegion: opts2?.isViaRegion
-      }
-    };
-  };
-  const topPolygon = [];
-  topPolygon.push({ x: -half, y: half });
-  topPolygon.push({ x: half, y: half });
-  topPolygon.push({ x: half, y: rTop.yEnd });
-  topPolygon.push({ x: rTop.x, y: rTop.yEnd });
-  const nTop = topSegments.length;
-  for (let i = nTop - 1; i >= 0; i--) {
-    topPolygon.push({ x: topSegments[i].xEnd, y: topSegments[i].y });
-    topPolygon.push({ x: topSegments[i].xStart, y: topSegments[i].y });
-  }
-  topPolygon.push({ x: lTop.x, y: lTop.yEnd });
-  topPolygon.push({ x: -half, y: lTop.yEnd });
-  const topRegion = createRegion("T", topPolygon);
-  const bottomPolygon = [];
-  bottomPolygon.push({ x: -half, y: -half });
-  bottomPolygon.push({ x: half, y: -half });
-  bottomPolygon.push({ x: half, y: rBot.yStart });
-  bottomPolygon.push({ x: rBot.x, y: rBot.yStart });
-  const nBot = bottomSegments.length;
-  for (let i = nBot - 1; i >= 0; i--) {
-    bottomPolygon.push({ x: bottomSegments[i].xEnd, y: bottomSegments[i].y });
-    bottomPolygon.push({
-      x: bottomSegments[i].xStart,
-      y: bottomSegments[i].y
-    });
-  }
-  bottomPolygon.push({ x: lBot.x, y: lBot.yStart });
-  bottomPolygon.push({ x: -half, y: lBot.yStart });
-  const bottomRegion = createRegion("B", bottomPolygon);
-  const rightPolygon = [];
-  rightPolygon.push({ x: half, y: rBot.yStart });
-  rightPolygon.push({ x: rBot.x, y: rBot.yStart });
-  for (let i = 0; i < rightSegments.length; i++) {
-    rightPolygon.push({ x: rightSegments[i].x, y: rightSegments[i].yStart });
-    rightPolygon.push({ x: rightSegments[i].x, y: rightSegments[i].yEnd });
-  }
-  rightPolygon.push({ x: half, y: rTop.yEnd });
-  const rightRegion = createRegion("R", rightPolygon);
-  const leftPolygon = [];
-  leftPolygon.push({ x: -half, y: lBot.yStart });
-  leftPolygon.push({ x: lBot.x, y: lBot.yStart });
-  for (let i = 0; i < leftSegments.length; i++) {
-    leftPolygon.push({ x: leftSegments[i].x, y: leftSegments[i].yStart });
-    leftPolygon.push({ x: leftSegments[i].x, y: leftSegments[i].yEnd });
-  }
-  leftPolygon.push({ x: -half, y: lTop.yEnd });
-  const leftRegion = createRegion("L", leftPolygon);
-  const regions = [topRegion, bottomRegion, leftRegion, rightRegion];
-  const ports = [];
-  const createPort = (id, region1, region2, x, y) => {
-    const port = {
-      portId: `${idPrefix}:${id}`,
-      region1,
-      region2,
-      d: { x, y }
-    };
-    region1.ports.push(port);
-    region2.ports.push(port);
-    return port;
-  };
-  const createHorizontalPorts = (groupId, region1, region2, xStart, xEnd, y) => {
-    const length = Math.abs(xEnd - xStart);
-    const count = Math.max(1, Math.floor(length / TRACE_PITCH));
-    const minX = Math.min(xStart, xEnd);
-    for (let i = 0; i < count; i++) {
-      const t = (i + 0.5) / count;
-      const x = minX + t * length;
-      const portId = count === 1 ? groupId : `${groupId}_${i}`;
-      ports.push(createPort(portId, region1, region2, x, y));
-    }
-  };
-  createHorizontalPorts("T-R", topRegion, rightRegion, rTop.x, half, rTop.yEnd);
-  createHorizontalPorts("T-L", topRegion, leftRegion, -half, lTop.x, lTop.yEnd);
-  createHorizontalPorts(
-    "B-R",
-    bottomRegion,
-    rightRegion,
-    rBot.x,
-    half,
-    rBot.yStart
-  );
-  createHorizontalPorts(
-    "B-L",
-    bottomRegion,
-    leftRegion,
-    -half,
-    lBot.x,
-    lBot.yStart
-  );
-  for (const [netName, vias] of Object.entries(viasByNet)) {
-    if (vias.length === 0) continue;
-    const topVia = vias.reduce(
-      (best, v) => v.position.y > best.position.y ? v : best
-    );
-    const bottomVia = vias.reduce(
-      (best, v) => v.position.y < best.position.y ? v : best
-    );
-    const leftVia = vias.reduce(
-      (best, v) => v.position.x < best.position.x ? v : best
-    );
-    const rightVia = vias.reduce(
-      (best, v) => v.position.x > best.position.x ? v : best
-    );
-    const netTopSeg = {
-      xStart: topVia.position.x - topVia.diameter / 2,
-      xEnd: topVia.position.x + topVia.diameter / 2,
-      y: topVia.position.y + topVia.diameter / 2
-    };
-    const netBotSeg = {
-      xStart: bottomVia.position.x - bottomVia.diameter / 2,
-      xEnd: bottomVia.position.x + bottomVia.diameter / 2,
-      y: bottomVia.position.y - bottomVia.diameter / 2
-    };
-    const netLeftSeg = {
-      x: leftVia.position.x - leftVia.diameter / 2,
-      yStart: leftVia.position.y - leftVia.diameter / 2,
-      yEnd: leftVia.position.y + leftVia.diameter / 2
-    };
-    const netRightSeg = {
-      x: rightVia.position.x + rightVia.diameter / 2,
+    const netTopSeg = {
+      xStart: topVia.position.x - topVia.diameter / 2,
+      xEnd: topVia.position.x + topVia.diameter / 2,
+      y: topVia.position.y + topVia.diameter / 2
+    };
+    const netBotSeg = {
+      xStart: bottomVia.position.x - bottomVia.diameter / 2,
+      xEnd: bottomVia.position.x + bottomVia.diameter / 2,
+      y: bottomVia.position.y - bottomVia.diameter / 2
+    };
+    const netLeftSeg = {
+      x: leftVia.position.x - leftVia.diameter / 2,
+      yStart: leftVia.position.y - leftVia.diameter / 2,
+      yEnd: leftVia.position.y + leftVia.diameter / 2
+    };
+    const netRightSeg = {
+      x: rightVia.position.x + rightVia.diameter / 2,
       yStart: rightVia.position.y - rightVia.diameter / 2,
       yEnd: rightVia.position.y + rightVia.diameter / 2
     };
@@ -4742,108 +4363,606 @@ function generateViaTopologyGrid(opts) {
           );
         }
       }
-    }
-    if (outerLeft) {
-      const baseGraph = generateViaTopologyRegions(viasByNet, {
-        graphSize: tileSize,
-        idPrefix: "v"
-      });
-      const baseT = baseGraph.regions.find((r) => r.regionId === "v:T");
-      const baseB = baseGraph.regions.find((r) => r.regionId === "v:B");
-      const tLeftSegs = getBoundarySegments(baseT.d.polygon, "left", -half);
-      const bLeftSegs = getBoundarySegments(baseB.d.polygon, "left", -half);
-      for (let row = 0; row < rows; row++) {
-        const tile = tileGraphs[row][0];
-        const tileT = findRegionBySuffix(tile, "v:T");
-        const tileB = findRegionBySuffix(tile, "v:B");
-        const tileCenterY = gridMinY + row * tileSize + half;
-        for (const seg of tLeftSegs) {
-          allPorts.push(
-            ...createBoundaryPorts(
-              `outer:L-tileT${row}`,
-              outerLeft,
-              tileT,
-              "vertical",
-              gridMinX,
-              seg.from + tileCenterY,
-              seg.to + tileCenterY,
-              portPitch
-            )
-          );
-        }
-        for (const seg of bLeftSegs) {
-          allPorts.push(
-            ...createBoundaryPorts(
-              `outer:L-tileB${row}`,
-              outerLeft,
-              tileB,
-              "vertical",
-              gridMinX,
-              seg.from + tileCenterY,
-              seg.to + tileCenterY,
-              portPitch
-            )
-          );
+    }
+    if (outerLeft) {
+      const baseGraph = generateViaTopologyRegions(viasByNet, {
+        graphSize: tileSize,
+        idPrefix: "v"
+      });
+      const baseT = baseGraph.regions.find((r) => r.regionId === "v:T");
+      const baseB = baseGraph.regions.find((r) => r.regionId === "v:B");
+      const tLeftSegs = getBoundarySegments(baseT.d.polygon, "left", -half);
+      const bLeftSegs = getBoundarySegments(baseB.d.polygon, "left", -half);
+      for (let row = 0; row < rows; row++) {
+        const tile = tileGraphs[row][0];
+        const tileT = findRegionBySuffix(tile, "v:T");
+        const tileB = findRegionBySuffix(tile, "v:B");
+        const tileCenterY = gridMinY + row * tileSize + half;
+        for (const seg of tLeftSegs) {
+          allPorts.push(
+            ...createBoundaryPorts(
+              `outer:L-tileT${row}`,
+              outerLeft,
+              tileT,
+              "vertical",
+              gridMinX,
+              seg.from + tileCenterY,
+              seg.to + tileCenterY,
+              portPitch
+            )
+          );
+        }
+        for (const seg of bLeftSegs) {
+          allPorts.push(
+            ...createBoundaryPorts(
+              `outer:L-tileB${row}`,
+              outerLeft,
+              tileB,
+              "vertical",
+              gridMinX,
+              seg.from + tileCenterY,
+              seg.to + tileCenterY,
+              portPitch
+            )
+          );
+        }
+      }
+    }
+    if (outerRight) {
+      const baseGraph = generateViaTopologyRegions(viasByNet, {
+        graphSize: tileSize,
+        idPrefix: "v"
+      });
+      const baseT = baseGraph.regions.find((r) => r.regionId === "v:T");
+      const baseB = baseGraph.regions.find((r) => r.regionId === "v:B");
+      const tRightSegs = getBoundarySegments(baseT.d.polygon, "right", half);
+      const bRightSegs = getBoundarySegments(baseB.d.polygon, "right", half);
+      for (let row = 0; row < rows; row++) {
+        const tile = tileGraphs[row][cols - 1];
+        const tileT = findRegionBySuffix(tile, "v:T");
+        const tileB = findRegionBySuffix(tile, "v:B");
+        const tileCenterY = gridMinY + row * tileSize + half;
+        for (const seg of tRightSegs) {
+          allPorts.push(
+            ...createBoundaryPorts(
+              `outer:R-tileT${row}`,
+              outerRight,
+              tileT,
+              "vertical",
+              gridMaxX,
+              seg.from + tileCenterY,
+              seg.to + tileCenterY,
+              portPitch
+            )
+          );
+        }
+        for (const seg of bRightSegs) {
+          allPorts.push(
+            ...createBoundaryPorts(
+              `outer:R-tileB${row}`,
+              outerRight,
+              tileB,
+              "vertical",
+              gridMaxX,
+              seg.from + tileCenterY,
+              seg.to + tileCenterY,
+              portPitch
+            )
+          );
+        }
+      }
+    }
+  } else {
+    if (outerTop && outerBottom) {
+    }
+    if (outerLeft && outerRight) {
+    }
+  }
+  return {
+    regions: allRegions,
+    ports: allPorts,
+    tiledViasByNet,
+    tileCount: { rows, cols }
+  };
+}
+
+// lib/ViaGraphSolver/defaultTopology.ts
+function generateDefaultViaTopologyRegions(opts) {
+  return generateViaTopologyRegions(vias_by_net_default, opts);
+}
+function generateDefaultViaTopologyGrid(opts) {
+  return generateViaTopologyGrid({
+    ...opts,
+    viasByNet: vias_by_net_default
+  });
+}
+
+// lib/ViaGraphSolver/polygonPerimeterUtils.ts
+function polygonPerimeterT(p, polygon) {
+  const n = polygon.length;
+  let bestDist = Infinity;
+  let bestEdgeIndex = 0;
+  let bestT = 0;
+  for (let i = 0; i < n; i++) {
+    const a2 = polygon[i];
+    const b2 = polygon[(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 = polygon[i];
+    const b2 = polygon[(i + 1) % n];
+    cumulative += Math.sqrt((b2.x - a2.x) ** 2 + (b2.y - a2.y) ** 2);
+  }
+  const a = polygon[bestEdgeIndex];
+  const b = polygon[(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 polygon = region.d.polygon;
+  if (!polygon || polygon.length < 3) {
+    return 0;
+  }
+  const t1 = polygonPerimeterT(port1.d, polygon);
+  const t2 = polygonPerimeterT(port2.d, polygon);
+  const newChord = [t1, t2];
+  let crossings = 0;
+  const assignments = region.assignments ?? [];
+  for (const assignment of assignments) {
+    const existingT1 = polygonPerimeterT(
+      assignment.regionPort1.d,
+      polygon
+    );
+    const existingT2 = polygonPerimeterT(
+      assignment.regionPort2.d,
+      polygon
+    );
+    const existingChord = [existingT1, existingT2];
+    if (chordsCross(newChord, existingChord)) {
+      crossings++;
+    }
+  }
+  return crossings;
+}
+function computeCrossingAssignmentsForPolygon(region, port1, port2) {
+  const polygon = region.d.polygon;
+  if (!polygon || polygon.length < 3) {
+    return [];
+  }
+  const t1 = polygonPerimeterT(port1.d, polygon);
+  const t2 = polygonPerimeterT(port2.d, polygon);
+  const newChord = [t1, t2];
+  const crossingAssignments = [];
+  const assignments = region.assignments ?? [];
+  for (const assignment of assignments) {
+    const existingT1 = polygonPerimeterT(
+      assignment.regionPort1.d,
+      polygon
+    );
+    const existingT2 = polygonPerimeterT(
+      assignment.regionPort2.d,
+      polygon
+    );
+    const existingChord = [existingT1, existingT2];
+    if (chordsCross(newChord, existingChord)) {
+      crossingAssignments.push(assignment);
+    }
+  }
+  return crossingAssignments;
+}
+
+// lib/ViaGraphSolver/visualizeViaGraphSolver.ts
+var getConnectionColor2 = (connectionId, alpha = 0.8) => {
+  let hash = 0;
+  for (let i = 0; i < connectionId.length; i++) {
+    hash = connectionId.charCodeAt(i) * 17777 + ((hash << 5) - hash);
+  }
+  const hue = Math.abs(hash) % 360;
+  return `hsla(${hue}, 70%, 50%, ${alpha})`;
+};
+var NET_COLOR_PALETTE = [
+  "rgba(231, 76, 60, 0.35)",
+  // red
+  "rgba(46, 204, 113, 0.35)",
+  // green
+  "rgba(52, 152, 219, 0.35)",
+  // blue
+  "rgba(243, 156, 18, 0.35)",
+  // orange
+  "rgba(155, 89, 182, 0.35)",
+  // purple
+  "rgba(26, 188, 156, 0.35)",
+  // teal
+  "rgba(241, 196, 15, 0.35)",
+  // yellow
+  "rgba(230, 126, 34, 0.35)"
+  // dark orange
+];
+var visualizeViaGraphSolver = (solver) => {
+  const graph = {
+    regions: solver.graph.regions,
+    ports: solver.graph.ports
+  };
+  const graphics = visualizeJumperGraph(graph, {
+    connections: solver.connections,
+    ...solver.iterations > 0 ? {
+      hideRegionPortLines: true,
+      hideConnectionLines: true,
+      hidePortPoints: true
+    } : {}
+  });
+  const outerIds = /* @__PURE__ */ new Set(["T", "B", "L", "R"]);
+  let netColorIndex = 0;
+  const netColorMap = /* @__PURE__ */ new Map();
+  let polyIndex = 0;
+  for (const region of graph.regions) {
+    const jRegion = region;
+    const hasPolygon = jRegion.d.polygon && jRegion.d.polygon.length >= 3;
+    if (!hasPolygon) continue;
+    const suffix = jRegion.regionId.split(":").pop() ?? "";
+    const isOuter = outerIds.has(suffix);
+    if (!isOuter && !jRegion.d.isConnectionRegion) {
+      if (!netColorMap.has(suffix)) {
+        netColorMap.set(
+          suffix,
+          NET_COLOR_PALETTE[netColorIndex % NET_COLOR_PALETTE.length]
+        );
+        netColorIndex++;
+      }
+      if (graphics.polygons[polyIndex]) {
+        graphics.polygons[polyIndex].fill = netColorMap.get(suffix);
+      }
+    }
+    polyIndex++;
+  }
+  if (solver.currentConnection && !solver.solved) {
+    const connectionColor = getConnectionColor2(
+      solver.currentConnection.connectionId
+    );
+    const startRegion = solver.currentConnection.startRegion;
+    const endRegion = solver.currentConnection.endRegion;
+    const startCenter = {
+      x: (startRegion.d.bounds.minX + startRegion.d.bounds.maxX) / 2,
+      y: (startRegion.d.bounds.minY + startRegion.d.bounds.maxY) / 2
+    };
+    const endCenter = {
+      x: (endRegion.d.bounds.minX + endRegion.d.bounds.maxX) / 2,
+      y: (endRegion.d.bounds.minY + endRegion.d.bounds.maxY) / 2
+    };
+    graphics.lines.push({
+      points: [startCenter, endCenter],
+      strokeColor: connectionColor,
+      strokeDash: "10 5"
+    });
+    graphics.points.push({
+      x: startCenter.x - 0.1,
+      y: startCenter.y + 0.1,
+      color: connectionColor,
+      label: [solver.currentConnection.connectionId, "start"].join("\n")
+    });
+    graphics.points.push({
+      x: endCenter.x - 0.1,
+      y: endCenter.y + 0.1,
+      color: connectionColor,
+      label: [solver.currentConnection.connectionId, "end"].join("\n")
+    });
+  }
+  for (const solvedRoute of solver.solvedRoutes) {
+    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) {
+      graphics.lines.push({
+        points: pathPoints,
+        strokeColor: connectionColor
+      });
+    }
+  }
+  const candidates = solver.candidateQueue.peekMany(10);
+  for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
+    const candidate = candidates[candidateIndex];
+    const port = candidate.port;
+    const isNext = candidateIndex === 0;
+    graphics.points.push({
+      x: port.d.x,
+      y: port.d.y,
+      color: isNext ? "green" : "rgba(128, 128, 128, 0.25)",
+      label: [
+        candidate.port.portId,
+        `g: ${candidate.g.toFixed(2)}`,
+        `h: ${candidate.h.toFixed(2)}`,
+        `f: ${candidate.f.toFixed(2)}`
+      ].join("\n")
+    });
+  }
+  const nextCandidate = candidates[0];
+  if (!solver.solved && nextCandidate && solver.currentConnection) {
+    const connectionColor = getConnectionColor2(
+      solver.currentConnection.connectionId
+    );
+    const activePath = [];
+    let cursor = nextCandidate;
+    while (cursor) {
+      const port = cursor.port;
+      activePath.unshift({ x: port.d.x, y: port.d.y });
+      cursor = cursor.parent;
+    }
+    if (activePath.length > 1) {
+      graphics.lines.push({
+        points: activePath,
+        strokeColor: connectionColor
+      });
+    }
+  }
+  if (solver.viasByNet) {
+    if (!graphics.circles) graphics.circles = [];
+    for (const [netName, vias] of Object.entries(solver.viasByNet)) {
+      const netColor = netColorMap.get(netName);
+      const viaFill = netColor ? netColor.replace("0.35", "0.5") : "rgba(255, 0, 0, 0.3)";
+      for (const via of vias) {
+        graphics.circles.push({
+          center: via.position,
+          radius: via.diameter / 2,
+          fill: viaFill,
+          label: netName
+        });
+      }
+    }
+  }
+  return graphics;
+};
+
+// lib/ViaGraphSolver/ViaGraphSolver.ts
+var VIA_GRAPH_SOLVER_DEFAULTS = {
+  portUsagePenalty: 0.034685181009478865,
+  portUsagePenaltySq: 0,
+  crossingPenalty: 4.072520483177124,
+  crossingPenaltySq: 0,
+  ripCost: 35.38577539020022,
+  greedyMultiplier: 0.5518001238069296
+};
+var ViaGraphSolver = class extends HyperGraphSolver {
+  getSolverName() {
+    return "ViaGraphSolver";
+  }
+  UNIT_OF_COST = "hops";
+  viasByNet;
+  portUsagePenalty = VIA_GRAPH_SOLVER_DEFAULTS.portUsagePenalty;
+  portUsagePenaltySq = VIA_GRAPH_SOLVER_DEFAULTS.portUsagePenaltySq;
+  crossingPenalty = VIA_GRAPH_SOLVER_DEFAULTS.crossingPenalty;
+  crossingPenaltySq = VIA_GRAPH_SOLVER_DEFAULTS.crossingPenaltySq;
+  ripCost = VIA_GRAPH_SOLVER_DEFAULTS.ripCost;
+  baseMaxIterations = 9e5;
+  additionalMaxIterationsPerConnection = 2e3;
+  additionalMaxIterationsPerCrossing = 2e3;
+  constructor(input) {
+    super({
+      greedyMultiplier: VIA_GRAPH_SOLVER_DEFAULTS.greedyMultiplier,
+      rippingEnabled: true,
+      ...input
+    });
+    this.viasByNet = input.viasByNet;
+    this.ripCost = input.ripCost ?? this.ripCost;
+    this.portUsagePenalty = input.portUsagePenalty ?? this.portUsagePenalty;
+    this.crossingPenalty = input.crossingPenalty ?? this.crossingPenalty;
+    this.baseMaxIterations = input.baseMaxIterations ?? this.baseMaxIterations;
+    this.additionalMaxIterationsPerConnection = input.additionalMaxIterationsPerConnection ?? this.additionalMaxIterationsPerConnection;
+    const crossings = countInputConnectionCrossings(
+      this.graph,
+      input.inputConnections
+    );
+    this.MAX_ITERATIONS = this.baseMaxIterations + input.inputConnections.length * this.additionalMaxIterationsPerConnection + crossings * this.additionalMaxIterationsPerCrossing;
+    this.populateDistanceToEndMaps();
+  }
+  populateDistanceToEndMaps() {
+    const endRegions = new Set(this.connections.map((c) => c.endRegion));
+    for (const endRegion of endRegions) {
+      const regionDistanceMap = /* @__PURE__ */ new Map();
+      const queue = [];
+      regionDistanceMap.set(endRegion.regionId, 0);
+      queue.push({ region: endRegion, distance: 0 });
+      while (queue.length > 0) {
+        const { region, distance: dist } = queue.shift();
+        for (const port of region.ports) {
+          const otherRegion = port.region1 === region ? port.region2 : port.region1;
+          if (!regionDistanceMap.has(otherRegion.regionId)) {
+            regionDistanceMap.set(otherRegion.regionId, dist + 1);
+            queue.push({ region: otherRegion, distance: dist + 1 });
+          }
+        }
+      }
+      for (const port of this.graph.ports) {
+        if (!port.distanceToEndMap) {
+          port.distanceToEndMap = {};
         }
+        const d1 = regionDistanceMap.get(port.region1.regionId) ?? Infinity;
+        const d2 = regionDistanceMap.get(port.region2.regionId) ?? Infinity;
+        port.distanceToEndMap[endRegion.regionId] = Math.min(d1, d2);
       }
     }
-    if (outerRight) {
-      const baseGraph = generateViaTopologyRegions(viasByNet, {
-        graphSize: tileSize,
-        idPrefix: "v"
-      });
-      const baseT = baseGraph.regions.find((r) => r.regionId === "v:T");
-      const baseB = baseGraph.regions.find((r) => r.regionId === "v:B");
-      const tRightSegs = getBoundarySegments(baseT.d.polygon, "right", half);
-      const bRightSegs = getBoundarySegments(baseB.d.polygon, "right", half);
-      for (let row = 0; row < rows; row++) {
-        const tile = tileGraphs[row][cols - 1];
-        const tileT = findRegionBySuffix(tile, "v:T");
-        const tileB = findRegionBySuffix(tile, "v:B");
-        const tileCenterY = gridMinY + row * tileSize + half;
-        for (const seg of tRightSegs) {
-          allPorts.push(
-            ...createBoundaryPorts(
-              `outer:R-tileT${row}`,
-              outerRight,
-              tileT,
-              "vertical",
-              gridMaxX,
-              seg.from + tileCenterY,
-              seg.to + tileCenterY,
-              portPitch
-            )
-          );
-        }
-        for (const seg of bRightSegs) {
-          allPorts.push(
-            ...createBoundaryPorts(
-              `outer:R-tileB${row}`,
-              outerRight,
-              tileB,
-              "vertical",
-              gridMaxX,
-              seg.from + tileCenterY,
-              seg.to + tileCenterY,
-              portPitch
-            )
-          );
-        }
+  }
+  estimateCostToEnd(port) {
+    const endRegionId = this.currentEndRegion.regionId;
+    const hopDistance = port.distanceToEndMap[endRegionId];
+    return hopDistance;
+  }
+  getPortUsagePenalty(port) {
+    const ripCount = port.ripCount ?? 0;
+    return ripCount * this.portUsagePenalty + ripCount * this.portUsagePenaltySq;
+  }
+  computeIncreasedRegionCostIfPortsAreUsed(region, port1, port2) {
+    if (region.d.isViaRegion) {
+      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;
     }
-  } else {
-    if (outerTop && outerBottom) {
+    const crossings = computeDifferentNetCrossingsForPolygon(
+      region,
+      port1,
+      port2
+    );
+    return crossings * this.crossingPenalty + crossings * this.crossingPenaltySq;
+  }
+  getRipsRequiredForPortUsage(region, port1, port2) {
+    if (region.d.isViaRegion) {
+      const assignments = region.assignments ?? [];
+      return assignments.filter(
+        (a) => a.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId
+      );
     }
-    if (outerLeft && outerRight) {
+    const crossingAssignments = computeCrossingAssignmentsForPolygon(
+      region,
+      port1,
+      port2
+    );
+    return crossingAssignments.filter(
+      (a) => a.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId
+    );
+  }
+  routeSolvedHook(solvedRoute) {
+  }
+  routeStartedHook(connection) {
+  }
+  visualize() {
+    return visualizeViaGraphSolver(this);
+  }
+};
+
+// lib/ViaGraphSolver/via-graph-generator/findBoundaryRegionForPolygons.ts
+function closestPointOnPolygonEdge(point, polygon) {
+  let bestDist = Infinity;
+  let bestPoint = { x: point.x, y: point.y };
+  for (let i = 0; i < polygon.length; i++) {
+    const a = polygon[i];
+    const b = polygon[(i + 1) % polygon.length];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const lenSq = dx * dx + dy * dy;
+    if (lenSq < 1e-10) continue;
+    const t = Math.max(
+      0,
+      Math.min(1, ((point.x - a.x) * dx + (point.y - a.y) * dy) / lenSq)
+    );
+    const projX = a.x + t * dx;
+    const projY = a.y + t * dy;
+    const dist = Math.sqrt((point.x - projX) ** 2 + (point.y - projY) ** 2);
+    if (dist < bestDist) {
+      bestDist = dist;
+      bestPoint = { x: projX, y: projY };
+    }
+  }
+  return { ...bestPoint, dist: bestDist };
+}
+var findBoundaryRegionForPolygons = (x, y, regions) => {
+  let closestRegion = null;
+  let closestDistance = Infinity;
+  let closestPortPosition = { x, y };
+  for (const region of regions) {
+    if (region.d.isPad || region.d.isThroughJumper || region.d.isConnectionRegion)
+      continue;
+    const polygon = region.d.polygon;
+    if (!polygon || polygon.length < 3) continue;
+    const result = closestPointOnPolygonEdge({ x, y }, polygon);
+    if (result.dist < closestDistance) {
+      closestDistance = result.dist;
+      closestRegion = region;
+      closestPortPosition = { x: result.x, y: result.y };
+    }
+  }
+  if (closestRegion) {
+    return { region: closestRegion, portPosition: closestPortPosition };
+  }
+  return null;
+};
+
+// lib/ViaGraphSolver/via-graph-generator/createViaGraphWithConnections.ts
+var createViaGraphWithConnections = (baseGraph, xyConnections) => {
+  const regions = [...baseGraph.regions];
+  const ports = [...baseGraph.ports];
+  const connections = [];
+  for (const xyConn of xyConnections) {
+    const { start, end, connectionId } = xyConn;
+    const startRegion = createConnectionRegion(
+      `conn:${connectionId}:start`,
+      start.x,
+      start.y
+    );
+    regions.push(startRegion);
+    const endRegion = createConnectionRegion(
+      `conn:${connectionId}:end`,
+      end.x,
+      end.y
+    );
+    regions.push(endRegion);
+    const startBoundary = findBoundaryRegionForPolygons(
+      start.x,
+      start.y,
+      baseGraph.regions
+    );
+    if (startBoundary) {
+      const startPort = createConnectionPort(
+        `conn:${connectionId}:start-port`,
+        startRegion,
+        startBoundary.region,
+        startBoundary.portPosition
+      );
+      ports.push(startPort);
+    }
+    const endBoundary = findBoundaryRegionForPolygons(
+      end.x,
+      end.y,
+      baseGraph.regions
+    );
+    if (endBoundary) {
+      const endPort = createConnectionPort(
+        `conn:${connectionId}:end-port`,
+        endRegion,
+        endBoundary.region,
+        endBoundary.portPosition
+      );
+      ports.push(endPort);
     }
+    const connection = {
+      connectionId,
+      mutuallyConnectedNetworkId: connectionId,
+      startRegion,
+      endRegion
+    };
+    connections.push(connection);
   }
   return {
-    regions: allRegions,
-    ports: allPorts,
-    tiledViasByNet,
-    tileCount: { rows, cols }
+    regions,
+    ports,
+    connections
   };
-}
+};
 
 // lib/ViaGraphSolver/via-graph-generator/createViaGraphFromXYConnections.ts
 function calculateBoundsFromConnections(xyConnections) {
@@ -4901,9 +5020,12 @@ export {
   createGraphWithConnectionsFromBaseGraph,
   createViaGraphFromXYConnections,
   createViaGraphWithConnections,
+  generateDefaultViaTopologyGrid,
+  generateDefaultViaTopologyRegions,
   generateJumperGrid,
   generateJumperX4Grid,
   generateViaTopologyGrid,
   generateViaTopologyRegions,
-  rotateGraph90Degrees
+  rotateGraph90Degrees,
+  vias_by_net_default as viasByNet
 };