@tscircuit/hypergraph 0.0.43 → 0.0.45

package/dist/index.js

@@ -5504,7 +5504,9 @@ var via_tile_4_regions_default = {
         }
       ]
     }
-  ]
+  ],
+  tileWidth: 3.735441,
+  tileHeight: 4.029267
 };
 
 // lib/ViaGraphSolver/via-graph-generator/generateViaTopologyRegions.ts
@@ -5770,647 +5772,38 @@ var generateViaTopologyRegions = (viaTile, opts) => {
   return { regions, ports };
 };
 
-// lib/ViaGraphSolver/via-graph-generator/generateViaTopologyGrid.ts
-var DEFAULT_PORT_PITCH = 0.4;
-var DEFAULT_TILE_SIZE = 5;
-function translateGraph(graph, dx, dy, prefix) {
-  const regionMap = /* @__PURE__ */ new Map();
-  const regions = graph.regions.map((r) => {
-    const newRegion = {
-      regionId: `${prefix}:${r.regionId}`,
-      ports: [],
-      d: {
-        bounds: {
-          minX: r.d.bounds.minX + dx,
-          maxX: r.d.bounds.maxX + dx,
-          minY: r.d.bounds.minY + dy,
-          maxY: r.d.bounds.maxY + dy
-        },
-        center: {
-          x: r.d.center.x + dx,
-          y: r.d.center.y + dy
-        },
-        polygon: r.d.polygon?.map((p) => ({ x: p.x + dx, y: p.y + dy })),
-        isPad: r.d.isPad,
-        isThroughJumper: r.d.isThroughJumper,
-        isConnectionRegion: r.d.isConnectionRegion,
-        isViaRegion: r.d.isViaRegion
-      }
-    };
-    regionMap.set(r, newRegion);
-    return newRegion;
-  });
-  const ports = graph.ports.map((p) => {
-    const newPort = {
-      portId: `${prefix}:${p.portId}`,
-      region1: regionMap.get(p.region1),
-      region2: regionMap.get(p.region2),
-      d: { x: p.d.x + dx, y: p.d.y + dy }
-    };
-    newPort.region1.ports.push(newPort);
-    newPort.region2.ports.push(newPort);
-    return newPort;
-  });
-  return { regions, ports };
-}
-function translateRouteSegments(routeSegments, dx, dy, prefix) {
-  return routeSegments.map((segment2) => ({
-    routeId: `${prefix}:${segment2.routeId}`,
-    fromPort: `${prefix}:${segment2.fromPort}`,
-    toPort: `${prefix}:${segment2.toPort}`,
-    layer: segment2.layer,
-    segments: segment2.segments.map((point2) => ({
-      x: point2.x + dx,
-      y: point2.y + dy
-    }))
-  }));
-}
-function createBoundaryPorts(portIdPrefix, region1, region2, axis, fixedCoord, start, end, portPitch) {
-  const length = Math.abs(end - start);
-  if (length < 1e-3) return [];
-  const count = Math.max(1, Math.floor(length / portPitch));
-  const min = Math.min(start, end);
-  const ports = [];
-  for (let i = 0; i < count; i++) {
-    const t = (i + 0.5) / count;
-    const varying = min + t * length;
-    const x = axis === "horizontal" ? varying : fixedCoord;
-    const y = axis === "horizontal" ? fixedCoord : varying;
-    const portId = count === 1 ? portIdPrefix : `${portIdPrefix}_${i}`;
-    const port = {
-      portId,
-      region1,
-      region2,
-      d: { x, y }
-    };
-    region1.ports.push(port);
-    region2.ports.push(port);
-    ports.push(port);
-  }
-  return ports;
-}
-function createRectRegion(regionId, minX, maxX, minY, maxY) {
-  const polygon2 = [
-    { x: minX, y: minY },
-    { x: maxX, y: minY },
-    { x: maxX, y: maxY },
-    { x: minX, y: maxY }
-  ];
-  return {
-    regionId,
-    ports: [],
-    d: {
-      bounds: { minX, maxX, minY, maxY },
-      center: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 },
-      polygon: polygon2,
-      isPad: false
-    }
-  };
-}
-function findRegionBySuffix(graph, suffix) {
-  const region = graph.regions.find((r) => r.regionId.endsWith(`:${suffix}`));
-  if (!region) throw new Error(`Region with suffix ${suffix} not found`);
-  return region;
-}
-function getBoundarySegments(polygon2, edge, boundaryCoord) {
-  const eps = 1e-3;
-  const segments = [];
-  for (let i = 0; i < polygon2.length; i++) {
-    const a = polygon2[i];
-    const b = polygon2[(i + 1) % polygon2.length];
-    const isVerticalEdge = edge === "right" || edge === "left";
-    if (isVerticalEdge) {
-      if (Math.abs(a.x - boundaryCoord) < eps && Math.abs(b.x - boundaryCoord) < eps) {
-        segments.push({ from: Math.min(a.y, b.y), to: Math.max(a.y, b.y) });
-      }
-    } else {
-      if (Math.abs(a.y - boundaryCoord) < eps && Math.abs(b.y - boundaryCoord) < eps) {
-        segments.push({ from: Math.min(a.x, b.x), to: Math.max(a.x, b.x) });
-      }
-    }
-  }
-  return segments;
-}
-function rangeOverlap(a, b) {
-  const from = Math.max(a.from, b.from);
-  const to = Math.min(a.to, b.to);
-  if (to - from < 1e-3) return null;
-  return { from, to };
-}
-function generateViaTopologyGrid(opts) {
-  const tileSize = opts.tileSize ?? DEFAULT_TILE_SIZE;
-  const portPitch = opts.portPitch ?? DEFAULT_PORT_PITCH;
-  const { bounds, viaTile: inputViaTile } = opts;
-  const { viasByNet, routeSegments } = inputViaTile;
-  const width = bounds.maxX - bounds.minX;
-  const height = bounds.maxY - bounds.minY;
-  const cols = Math.floor(width / tileSize);
-  const rows = Math.floor(height / tileSize);
-  const allRegions = [];
-  const allPorts = [];
-  const viaTile = { viasByNet: {}, routeSegments: [] };
-  const gridWidth = cols * tileSize;
-  const gridHeight = rows * tileSize;
-  const gridMinX = bounds.minX + (width - gridWidth) / 2;
-  const gridMinY = bounds.minY + (height - gridHeight) / 2;
-  const gridMaxX = gridMinX + gridWidth;
-  const gridMaxY = gridMinY + gridHeight;
-  const tileGraphs = [];
-  if (rows > 0 && cols > 0) {
-    const baseGraph = generateViaTopologyRegions(inputViaTile, {
-      graphSize: tileSize,
-      idPrefix: "v"
-    });
-    const half = tileSize / 2;
-    const outerIds = ["T", "B", "L", "R"];
-    const baseBoundarySegs = {};
-    for (const id of outerIds) {
-      const r = baseGraph.regions.find((r2) => r2.regionId === `v:${id}`);
-      baseBoundarySegs[id] = {
-        right: getBoundarySegments(r.d.polygon, "right", half),
-        left: getBoundarySegments(r.d.polygon, "left", -half),
-        top: getBoundarySegments(r.d.polygon, "top", half),
-        bottom: getBoundarySegments(r.d.polygon, "bottom", -half)
-      };
-    }
-    for (let row = 0; row < rows; row++) {
-      tileGraphs[row] = [];
-      for (let col = 0; col < cols; col++) {
-        const tileCenterX = gridMinX + col * tileSize + half;
-        const tileCenterY = gridMinY + row * tileSize + half;
-        const prefix = `t${row}_${col}`;
-        const tile = translateGraph(baseGraph, tileCenterX, tileCenterY, prefix);
-        tileGraphs[row][col] = tile;
-        allRegions.push(...tile.regions);
-        allPorts.push(...tile.ports);
-        for (const [netName, vias] of Object.entries(viasByNet)) {
-          if (!viaTile.viasByNet[netName]) {
-            viaTile.viasByNet[netName] = [];
-          }
-          for (const via of vias) {
-            viaTile.viasByNet[netName].push({
-              viaId: `${prefix}:${via.viaId}`,
-              diameter: via.diameter,
-              position: {
-                x: via.position.x + tileCenterX,
-                y: via.position.y + tileCenterY
-              }
-            });
-          }
-        }
-        viaTile.routeSegments.push(
-          ...translateRouteSegments(
-            routeSegments,
-            tileCenterX,
-            tileCenterY,
-            prefix
-          )
-        );
-      }
-    }
-    const hPairs = [
-      {
-        leftRegionId: "T",
-        leftEdge: "right",
-        rightRegionId: "T",
-        rightEdge: "left"
-      },
-      {
-        leftRegionId: "R",
-        leftEdge: "right",
-        rightRegionId: "L",
-        rightEdge: "left"
-      },
-      {
-        leftRegionId: "B",
-        leftEdge: "right",
-        rightRegionId: "B",
-        rightEdge: "left"
-      }
-    ];
-    for (let row = 0; row < rows; row++) {
-      for (let col = 0; col < cols - 1; col++) {
-        const leftTile = tileGraphs[row][col];
-        const rightTile = tileGraphs[row][col + 1];
-        const boundaryX = gridMinX + (col + 1) * tileSize;
-        const yOffset = gridMinY + row * tileSize + half;
-        for (const pair of hPairs) {
-          const leftSegs = baseBoundarySegs[pair.leftRegionId][pair.leftEdge];
-          const rightSegs = baseBoundarySegs[pair.rightRegionId][pair.rightEdge];
-          for (const ls of leftSegs) {
-            for (const rs of rightSegs) {
-              const overlap = rangeOverlap(ls, rs);
-              if (!overlap) continue;
-              const r1 = findRegionBySuffix(leftTile, `v:${pair.leftRegionId}`);
-              const r2 = findRegionBySuffix(
-                rightTile,
-                `v:${pair.rightRegionId}`
-              );
-              const tag = `${pair.leftRegionId}${pair.rightRegionId}`;
-              const ports = createBoundaryPorts(
-                `cross:h:${row}_${col}:${tag}`,
-                r1,
-                r2,
-                "vertical",
-                boundaryX,
-                overlap.from + yOffset,
-                overlap.to + yOffset,
-                portPitch
-              );
-              allPorts.push(...ports);
-            }
-          }
-        }
-      }
-    }
-    const vPairs = [
-      {
-        bottomRegionId: "T",
-        bottomEdge: "top",
-        topRegionId: "B",
-        topEdge: "bottom"
-      },
-      {
-        bottomRegionId: "L",
-        bottomEdge: "top",
-        topRegionId: "L",
-        topEdge: "bottom"
-      },
-      {
-        bottomRegionId: "R",
-        bottomEdge: "top",
-        topRegionId: "R",
-        topEdge: "bottom"
-      }
-    ];
-    for (let row = 0; row < rows - 1; row++) {
-      for (let col = 0; col < cols; col++) {
-        const bottomTile = tileGraphs[row][col];
-        const topTile = tileGraphs[row + 1][col];
-        const boundaryY = gridMinY + (row + 1) * tileSize;
-        const xOffset = gridMinX + col * tileSize + half;
-        for (const pair of vPairs) {
-          const bottomSegs = baseBoundarySegs[pair.bottomRegionId][pair.bottomEdge];
-          const topSegs = baseBoundarySegs[pair.topRegionId][pair.topEdge];
-          for (const bs of bottomSegs) {
-            for (const ts of topSegs) {
-              const overlap = rangeOverlap(bs, ts);
-              if (!overlap) continue;
-              const r1 = findRegionBySuffix(
-                bottomTile,
-                `v:${pair.bottomRegionId}`
-              );
-              const r2 = findRegionBySuffix(topTile, `v:${pair.topRegionId}`);
-              const tag = `${pair.bottomRegionId}${pair.topRegionId}`;
-              const ports = createBoundaryPorts(
-                `cross:v:${row}_${col}:${tag}`,
-                r1,
-                r2,
-                "horizontal",
-                boundaryY,
-                overlap.from + xOffset,
-                overlap.to + xOffset,
-                portPitch
-              );
-              allPorts.push(...ports);
-            }
-          }
-        }
-      }
-    }
-  }
-  const hasTopGap = bounds.maxY > gridMaxY || rows === 0;
-  const hasBottomGap = bounds.minY < gridMinY || rows === 0;
-  const hasLeftGap = bounds.minX < gridMinX || cols === 0;
-  const hasRightGap = bounds.maxX > gridMaxX || cols === 0;
-  let outerTop = null;
-  let outerBottom = null;
-  let outerLeft = null;
-  let outerRight = null;
-  const frameMinX = cols > 0 ? gridMinX : bounds.minX;
-  const frameMaxX = cols > 0 ? gridMaxX : bounds.maxX;
-  const frameMinY = rows > 0 ? gridMinY : bounds.minY;
-  const frameMaxY = rows > 0 ? gridMaxY : bounds.maxY;
-  if (hasLeftGap && bounds.minX < frameMinX) {
-    outerLeft = createRectRegion(
-      "outer:L",
-      bounds.minX,
-      frameMinX,
-      bounds.minY,
-      bounds.maxY
-    );
-    allRegions.push(outerLeft);
-  }
-  if (hasRightGap && bounds.maxX > frameMaxX) {
-    outerRight = createRectRegion(
-      "outer:R",
-      frameMaxX,
-      bounds.maxX,
-      bounds.minY,
-      bounds.maxY
-    );
-    allRegions.push(outerRight);
-  }
-  if (hasTopGap && bounds.maxY > frameMaxY) {
-    outerTop = createRectRegion(
-      "outer:T",
-      frameMinX,
-      frameMaxX,
-      frameMaxY,
-      bounds.maxY
-    );
-    allRegions.push(outerTop);
-  }
-  if (hasBottomGap && bounds.minY < frameMinY) {
-    outerBottom = createRectRegion(
-      "outer:B",
-      frameMinX,
-      frameMaxX,
-      bounds.minY,
-      frameMinY
-    );
-    allRegions.push(outerBottom);
-  }
-  if (outerTop && outerLeft) {
-    allPorts.push(
-      ...createBoundaryPorts(
-        "outer:T-L",
-        outerTop,
-        outerLeft,
-        "vertical",
-        frameMinX,
-        frameMaxY,
-        bounds.maxY,
-        portPitch
-      )
-    );
-  }
-  if (outerTop && outerRight) {
-    allPorts.push(
-      ...createBoundaryPorts(
-        "outer:T-R",
-        outerTop,
-        outerRight,
-        "vertical",
-        frameMaxX,
-        frameMaxY,
-        bounds.maxY,
-        portPitch
-      )
-    );
-  }
-  if (outerBottom && outerLeft) {
-    allPorts.push(
-      ...createBoundaryPorts(
-        "outer:B-L",
-        outerBottom,
-        outerLeft,
-        "vertical",
-        frameMinX,
-        bounds.minY,
-        frameMinY,
-        portPitch
-      )
-    );
-  }
-  if (outerBottom && outerRight) {
-    allPorts.push(
-      ...createBoundaryPorts(
-        "outer:B-R",
-        outerBottom,
-        outerRight,
-        "vertical",
-        frameMaxX,
-        bounds.minY,
-        frameMinY,
-        portPitch
-      )
-    );
-  }
-  if (rows > 0 && cols > 0) {
-    const half = tileSize / 2;
-    if (outerTop) {
-      for (let col = 0; col < cols; col++) {
-        const tile = tileGraphs[rows - 1][col];
-        const tileT = findRegionBySuffix(tile, "v:T");
-        const baseT = generateViaTopologyRegions(inputViaTile, {
-          graphSize: tileSize,
-          idPrefix: "v"
-        }).regions.find((r) => r.regionId === "v:T");
-        const topSegs = getBoundarySegments(baseT.d.polygon, "top", half);
-        for (const seg of topSegs) {
-          const tileCenterX = gridMinX + col * tileSize + half;
-          allPorts.push(
-            ...createBoundaryPorts(
-              `outer:T-tile${col}`,
-              outerTop,
-              tileT,
-              "horizontal",
-              gridMaxY,
-              seg.from + tileCenterX,
-              seg.to + tileCenterX,
-              portPitch
-            )
-          );
-        }
-      }
-    }
-    if (outerBottom) {
-      for (let col = 0; col < cols; col++) {
-        const tile = tileGraphs[0][col];
-        const tileB = findRegionBySuffix(tile, "v:B");
-        const baseB = generateViaTopologyRegions(inputViaTile, {
-          graphSize: tileSize,
-          idPrefix: "v"
-        }).regions.find((r) => r.regionId === "v:B");
-        const bottomSegs = getBoundarySegments(
-          baseB.d.polygon,
-          "bottom",
-          -half
-        );
-        for (const seg of bottomSegs) {
-          const tileCenterX = gridMinX + col * tileSize + half;
-          allPorts.push(
-            ...createBoundaryPorts(
-              `outer:B-tile${col}`,
-              outerBottom,
-              tileB,
-              "horizontal",
-              gridMinY,
-              seg.from + tileCenterX,
-              seg.to + tileCenterX,
-              portPitch
-            )
-          );
-        }
-      }
-    }
-    if (outerLeft) {
-      for (let row = 0; row < rows; row++) {
-        const tile = tileGraphs[row][0];
-        const tileL = findRegionBySuffix(tile, "v:L");
-        const baseL = generateViaTopologyRegions(inputViaTile, {
-          graphSize: tileSize,
-          idPrefix: "v"
-        }).regions.find((r) => r.regionId === "v:L");
-        const leftSegs = getBoundarySegments(baseL.d.polygon, "left", -half);
-        for (const seg of leftSegs) {
-          const tileCenterY = gridMinY + row * tileSize + half;
-          allPorts.push(
-            ...createBoundaryPorts(
-              `outer:L-tile${row}`,
-              outerLeft,
-              tileL,
-              "vertical",
-              gridMinX,
-              seg.from + tileCenterY,
-              seg.to + tileCenterY,
-              portPitch
-            )
-          );
-        }
-      }
-    }
-    if (outerRight) {
-      for (let row = 0; row < rows; row++) {
-        const tile = tileGraphs[row][cols - 1];
-        const tileR = findRegionBySuffix(tile, "v:R");
-        const baseR = generateViaTopologyRegions(inputViaTile, {
-          graphSize: tileSize,
-          idPrefix: "v"
-        }).regions.find((r) => r.regionId === "v:R");
-        const rightSegs = getBoundarySegments(baseR.d.polygon, "right", half);
-        for (const seg of rightSegs) {
-          const tileCenterY = gridMinY + row * tileSize + half;
-          allPorts.push(
-            ...createBoundaryPorts(
-              `outer:R-tile${row}`,
-              outerRight,
-              tileR,
-              "vertical",
-              gridMaxX,
-              seg.from + tileCenterY,
-              seg.to + tileCenterY,
-              portPitch
-            )
-          );
-        }
-      }
-    }
-    if (outerLeft) {
-      const baseGraph = generateViaTopologyRegions(inputViaTile, {
-        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(inputViaTile, {
-        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,
-    viaTile,
-    tileCount: { rows, cols }
-  };
-}
-
 // lib/ViaGraphSolver/defaultTopology.ts
 function generateDefaultViaTopologyRegions(opts) {
   return generateViaTopologyRegions(via_tile_4_regions_default, opts);
 }
-function generateDefaultViaTopologyGrid(opts) {
-  return generateViaTopologyGrid({
-    ...opts,
-    viaTile: via_tile_4_regions_default
-  });
-}
 
 // lib/ViaGraphSolver/polygonPerimeterUtils.ts
+function lineSegmentsIntersect(p1, p2, p3, p4, eps = 1e-9) {
+  const pointsCoincident = (a, b) => Math.abs(a.x - b.x) < eps && Math.abs(a.y - b.y) < eps;
+  if (pointsCoincident(p1, p3) || pointsCoincident(p1, p4) || pointsCoincident(p2, p3) || pointsCoincident(p2, p4)) {
+    return false;
+  }
+  const cross2 = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+  const d1 = cross2(p3, p4, p1);
+  const d2 = cross2(p3, p4, p2);
+  const d3 = cross2(p1, p2, p3);
+  const d4 = cross2(p1, p2, p4);
+  if (d1 * d2 < 0 && d3 * d4 < 0) {
+    return true;
+  }
+  return false;
+}
+function chordsIntersect(newChord, existingChord, perimeter, newPort1, newPort2, existingPort1, existingPort2) {
+  if (chordsCross(newChord, existingChord, perimeter)) {
+    return true;
+  }
+  return lineSegmentsIntersect(
+    newPort1.d,
+    newPort2.d,
+    existingPort1.d,
+    existingPort2.d
+  );
+}
 function computeDifferentNetCrossingsForPolygon(region, port1, port2) {
   const polygon2 = region.d.polygon;
   if (!polygon2 || polygon2.length < 3) {
@@ -6423,16 +5816,20 @@ function computeDifferentNetCrossingsForPolygon(region, port1, port2) {
   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 existingPort1 = assignment.regionPort1;
+    const existingPort2 = assignment.regionPort2;
+    const existingT1 = getPortPerimeterTInRegion(existingPort1, region);
+    const existingT2 = getPortPerimeterTInRegion(existingPort2, region);
     const existingChord = [existingT1, existingT2];
-    if (chordsCross(newChord, existingChord, perimeter)) {
+    if (chordsIntersect(
+      newChord,
+      existingChord,
+      perimeter,
+      port1,
+      port2,
+      existingPort1,
+      existingPort2
+    )) {
       crossings++;
     }
   }
@@ -6450,16 +5847,20 @@ function computeCrossingAssignmentsForPolygon(region, port1, port2) {
   const crossingAssignments = [];
   const assignments = region.assignments ?? [];
   for (const assignment of assignments) {
-    const existingT1 = getPortPerimeterTInRegion(
-      assignment.regionPort1,
-      region
-    );
-    const existingT2 = getPortPerimeterTInRegion(
-      assignment.regionPort2,
-      region
-    );
+    const existingPort1 = assignment.regionPort1;
+    const existingPort2 = assignment.regionPort2;
+    const existingT1 = getPortPerimeterTInRegion(existingPort1, region);
+    const existingT2 = getPortPerimeterTInRegion(existingPort2, region);
     const existingChord = [existingT1, existingT2];
-    if (chordsCross(newChord, existingChord, perimeter)) {
+    if (chordsIntersect(
+      newChord,
+      existingChord,
+      perimeter,
+      port1,
+      port2,
+      existingPort1,
+      existingPort2
+    )) {
       crossingAssignments.push(assignment);
     }
   }
@@ -16296,7 +15697,7 @@ function projectOntoSegment(p, a, b) {
   const distance3 = Math.sqrt((p.x - closestX) ** 2 + (p.y - closestY) ** 2);
   return { t, distance: distance3 };
 }
-function rangeOverlap2(t1Start, t1End, t2Start, t2End) {
+function rangeOverlap(t1Start, t1End, t2Start, t2End) {
   const min1 = Math.min(t1Start, t1End);
   const max1 = Math.max(t1Start, t1End);
   const min2 = Math.min(t2Start, t2End);
@@ -16318,7 +15719,7 @@ function findSharedEdges(polygon1, polygon2, tolerance = 0.01) {
       const proj1 = projectOntoSegment(b1, a1, a2);
       const proj2 = projectOntoSegment(b2, a1, a2);
       if (proj1.distance > tolerance || proj2.distance > tolerance) continue;
-      const overlap = rangeOverlap2(0, 1, proj1.t, proj2.t);
+      const overlap = rangeOverlap(0, 1, proj1.t, proj2.t);
       if (!overlap) continue;
       const dx = a2.x - a1.x;
       const dy = a2.y - a1.y;
@@ -16330,10 +15731,7 @@ function findSharedEdges(polygon1, polygon2, tolerance = 0.01) {
         x: a1.x + overlap.to * dx,
         y: a1.y + overlap.to * dy
       };
-      const edgeLen = Math.sqrt((to.x - from.x) ** 2 + (to.y - from.y) ** 2);
-      if (edgeLen > tolerance) {
-        sharedEdges.push({ from, to });
-      }
+      sharedEdges.push({ from, to });
     }
   }
   return sharedEdges;
@@ -16356,9 +15754,7 @@ function createPortsAlongEdge(edge, portPitch = 0.4) {
 }
 
 // lib/ViaGraphSolver/via-graph-generator/generateConvexViaTopologyRegions.ts
-var DEFAULT_PORT_PITCH2 = 0.4;
-var DEFAULT_TILE_WIDTH = 3.727;
-var DEFAULT_TILE_HEIGHT = 4.03;
+var DEFAULT_PORT_PITCH = 0.4;
 var DEFAULT_CLEARANCE = 0.1;
 function deduplicateConsecutivePoints(points, tolerance = 1e-3) {
   if (points.length <= 1) return points;
@@ -16403,35 +15799,6 @@ function centroid(points) {
   }
   return { x: cx / points.length, y: cy / points.length };
 }
-function classifySideFromBounds(point2, bounds) {
-  const distances = {
-    left: Math.abs(point2.x - bounds.minX),
-    right: Math.abs(point2.x - bounds.maxX),
-    bottom: Math.abs(point2.y - bounds.minY),
-    top: Math.abs(point2.y - bounds.maxY)
-  };
-  let bestSide = "left";
-  let bestDistance = distances.left;
-  for (const side of ["right", "bottom", "top"]) {
-    if (distances[side] < bestDistance) {
-      bestSide = side;
-      bestDistance = distances[side];
-    }
-  }
-  return bestSide;
-}
-function toCandidateKey(regionId, point2) {
-  return `${regionId}:${point2.x.toFixed(6)},${point2.y.toFixed(6)}`;
-}
-function compareCandidateQuality(a, b) {
-  if (Math.abs(a.primaryDistance - b.primaryDistance) > 1e-6) {
-    return b.primaryDistance - a.primaryDistance;
-  }
-  if (Math.abs(a.orthDistance - b.orthDistance) > 1e-6) {
-    return a.orthDistance - b.orthDistance;
-  }
-  return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
-}
 function createRegionFromPolygon(regionId, polygon2, opts) {
   const bounds = boundsFromPolygon(polygon2);
   return {
@@ -16502,7 +15869,7 @@ function translateVias(vias, dx, dy, prefix) {
     }
   }));
 }
-function translateRouteSegments2(routeSegments, dx, dy, prefix) {
+function translateRouteSegments(routeSegments, dx, dy, prefix) {
   return routeSegments.map((segment2) => ({
     routeId: `${prefix}:${segment2.routeId}`,
     fromPort: `${prefix}:${segment2.fromPort}`,
@@ -16514,10 +15881,133 @@ function translateRouteSegments2(routeSegments, dx, dy, prefix) {
     }))
   }));
 }
+function translatePolygon(polygon2, dx, dy) {
+  return polygon2.map((p) => ({ x: p.x + dx, y: p.y + dy }));
+}
+function rectPolygonFromBounds(b) {
+  return [
+    { x: b.minX, y: b.minY },
+    { x: b.maxX, y: b.minY },
+    { x: b.maxX, y: b.maxY },
+    { x: b.minX, y: b.maxY }
+  ];
+}
+function extendViaRegionToTileEdge(polygon2, tileBounds, threshold = 0.1) {
+  if (polygon2.length === 0) return polygon2;
+  const polyBounds = boundsFromPolygon(polygon2);
+  const distToLeft = polyBounds.minX - tileBounds.minX;
+  const distToRight = tileBounds.maxX - polyBounds.maxX;
+  const distToBottom = polyBounds.minY - tileBounds.minY;
+  const distToTop = tileBounds.maxY - polyBounds.maxY;
+  const extendLeft = distToLeft > 0 && distToLeft < threshold;
+  const extendRight = distToRight > 0 && distToRight < threshold;
+  const extendBottom = distToBottom > 0 && distToBottom < threshold;
+  const extendTop = distToTop > 0 && distToTop < threshold;
+  if (!extendLeft && !extendRight && !extendBottom && !extendTop) {
+    return polygon2;
+  }
+  const result = polygon2.map((p) => {
+    let x = p.x;
+    let y = p.y;
+    if (extendLeft && Math.abs(p.x - polyBounds.minX) < 1e-3) {
+      x = tileBounds.minX;
+    }
+    if (extendRight && Math.abs(p.x - polyBounds.maxX) < 1e-3) {
+      x = tileBounds.maxX;
+    }
+    if (extendBottom && Math.abs(p.y - polyBounds.minY) < 1e-3) {
+      y = tileBounds.minY;
+    }
+    if (extendTop && Math.abs(p.y - polyBounds.maxY) < 1e-3) {
+      y = tileBounds.maxY;
+    }
+    return { x, y };
+  });
+  return deduplicateConsecutivePoints(result);
+}
+function pointInPolygon(point2, polygon2) {
+  let inside2 = false;
+  const n = polygon2.length;
+  for (let i = 0, j = n - 1; i < n; j = i++) {
+    const xi = polygon2[i].x;
+    const yi = polygon2[i].y;
+    const xj = polygon2[j].x;
+    const yj = polygon2[j].y;
+    const onEdge = Math.abs((point2.y - yi) * (xj - xi) - (point2.x - xi) * (yj - yi)) < 1e-3 && point2.x >= Math.min(xi, xj) - 1e-3 && point2.x <= Math.max(xi, xj) + 1e-3 && point2.y >= Math.min(yi, yj) - 1e-3 && point2.y <= Math.max(yi, yj) + 1e-3;
+    if (onEdge) return true;
+    if (yi > point2.y !== yj > point2.y) {
+      const intersectX = (xj - xi) * (point2.y - yi) / (yj - yi) + xi;
+      if (point2.x < intersectX) {
+        inside2 = !inside2;
+      }
+    }
+  }
+  return inside2;
+}
+function findRegionContainingPoint(point2, regions) {
+  for (const region of regions) {
+    if (region.d.polygon && pointInPolygon(point2, region.d.polygon)) {
+      return region;
+    }
+  }
+  return null;
+}
+function computeUnitTileTemplate(viaTile, tileWidth, tileHeight, clearance, concavityTolerance) {
+  const halfWidth = tileWidth / 2;
+  const halfHeight = tileHeight / 2;
+  const tileBounds = {
+    minX: -halfWidth,
+    maxX: halfWidth,
+    minY: -halfHeight,
+    maxY: halfHeight
+  };
+  const viaRegions = [];
+  for (const [netName, vias] of Object.entries(viaTile.viasByNet)) {
+    if (vias.length === 0) continue;
+    const polygon2 = generateViaRegionPolygon(vias);
+    if (polygon2.length === 0) continue;
+    viaRegions.push({
+      netName,
+      polygon: polygon2,
+      bounds: boundsFromPolygon(polygon2),
+      center: centroid(polygon2)
+    });
+  }
+  const obstaclePolygons = viaRegions.map((r) => ({
+    points: extendViaRegionToTileEdge(r.polygon, tileBounds)
+  }));
+  const solver = new ConvexRegionsSolver({
+    bounds: tileBounds,
+    polygons: obstaclePolygons,
+    clearance,
+    concavityTolerance
+  });
+  solver.solve();
+  const solverOutput = solver.getOutput();
+  if (!solverOutput) {
+    throw new Error("ConvexRegionsSolver failed to compute unit tile regions");
+  }
+  const convexRegions = solverOutput.regions.map((polygon2) => ({
+    polygon: polygon2,
+    bounds: boundsFromPolygon(polygon2),
+    center: centroid(polygon2)
+  }));
+  return {
+    viaRegions,
+    convexRegions,
+    tileWidth,
+    tileHeight
+  };
+}
 function generateConvexViaTopologyRegions(opts) {
-  const tileWidth = opts.tileWidth ?? opts.tileSize ?? DEFAULT_TILE_WIDTH;
-  const tileHeight = opts.tileHeight ?? opts.tileSize ?? DEFAULT_TILE_HEIGHT;
-  const portPitch = opts.portPitch ?? DEFAULT_PORT_PITCH2;
+  const tileWidth = opts.tileWidth ?? opts.tileSize ?? opts.viaTile.tileWidth;
+  const tileHeight = opts.tileHeight ?? opts.tileSize ?? opts.viaTile.tileHeight;
+  if (tileWidth === void 0 || tileHeight === void 0) {
+    throw new Error(
+      "tileWidth and tileHeight must be provided either in opts or in viaTile"
+    );
+  }
+  const portPitch = opts.portPitch ?? DEFAULT_PORT_PITCH;
   const clearance = opts.clearance ?? DEFAULT_CLEARANCE;
   const concavityTolerance = opts.concavityTolerance ?? 0;
   const { bounds, viaTile: inputViaTile } = opts;
@@ -16530,18 +16020,79 @@ function generateConvexViaTopologyRegions(opts) {
   const allPorts = [];
   const viaTile = { viasByNet: {}, routeSegments: [] };
   const viaRegions = [];
+  const convexRegions = [];
   const gridWidth = cols * tileWidth;
   const gridHeight = rows * tileHeight;
   const gridMinX = bounds.minX + (width - gridWidth) / 2;
   const gridMinY = bounds.minY + (height - gridHeight) / 2;
+  const gridMaxX = gridMinX + gridWidth;
+  const gridMaxY = gridMinY + gridHeight;
   const halfWidth = tileWidth / 2;
   const halfHeight = tileHeight / 2;
+  let portIdCounter = 0;
+  const usedPortPositions = /* @__PURE__ */ new Set();
+  const getPortPosKey = (x, y) => `${x.toFixed(4)},${y.toFixed(4)}`;
+  const createPort = (portId, region1, region2, pos) => {
+    const posKey = getPortPosKey(pos.x, pos.y);
+    if (usedPortPositions.has(posKey)) {
+      return null;
+    }
+    usedPortPositions.add(posKey);
+    const port = {
+      portId,
+      region1,
+      region2,
+      d: { x: pos.x, y: pos.y }
+    };
+    region1.ports.push(port);
+    region2.ports.push(port);
+    allPorts.push(port);
+    return port;
+  };
+  let unitTileTemplate = null;
   if (rows > 0 && cols > 0) {
+    unitTileTemplate = computeUnitTileTemplate(
+      inputViaTile,
+      tileWidth,
+      tileHeight,
+      clearance,
+      concavityTolerance
+    );
+  }
+  if (rows > 0 && cols > 0 && unitTileTemplate) {
     for (let row = 0; row < rows; row++) {
       for (let col = 0; col < cols; col++) {
         const tileCenterX = gridMinX + col * tileWidth + halfWidth;
         const tileCenterY = gridMinY + row * tileHeight + halfHeight;
         const prefix = `t${row}_${col}`;
+        for (const templateViaRegion of unitTileTemplate.viaRegions) {
+          const translatedPolygon = translatePolygon(
+            templateViaRegion.polygon,
+            tileCenterX,
+            tileCenterY
+          );
+          const viaRegion = createRegionFromPolygon(
+            `${prefix}:v:${templateViaRegion.netName}`,
+            translatedPolygon,
+            { isViaRegion: true }
+          );
+          viaRegions.push(viaRegion);
+          allRegions.push(viaRegion);
+        }
+        for (let i = 0; i < unitTileTemplate.convexRegions.length; i++) {
+          const templateConvexRegion = unitTileTemplate.convexRegions[i];
+          const translatedPolygon = translatePolygon(
+            templateConvexRegion.polygon,
+            tileCenterX,
+            tileCenterY
+          );
+          const convexRegion = createRegionFromPolygon(
+            `${prefix}:convex:${i}`,
+            translatedPolygon
+          );
+          convexRegions.push(convexRegion);
+          allRegions.push(convexRegion);
+        }
         for (const [netName, vias] of Object.entries(viasByNet)) {
           if (vias.length === 0) continue;
           const translatedVias = translateVias(
@@ -16554,18 +16105,9 @@ function generateConvexViaTopologyRegions(opts) {
             viaTile.viasByNet[netName] = [];
           }
           viaTile.viasByNet[netName].push(...translatedVias);
-          const polygon2 = generateViaRegionPolygon(translatedVias);
-          if (polygon2.length === 0) continue;
-          const viaRegion = createRegionFromPolygon(
-            `${prefix}:v:${netName}`,
-            polygon2,
-            { isViaRegion: true }
-          );
-          viaRegions.push(viaRegion);
-          allRegions.push(viaRegion);
         }
         viaTile.routeSegments.push(
-          ...translateRouteSegments2(
+          ...translateRouteSegments(
             routeSegments,
             tileCenterX,
             tileCenterY,
@@ -16575,55 +16117,306 @@ function generateConvexViaTopologyRegions(opts) {
       }
     }
   }
-  const obstaclePolygons = viaRegions.map((r) => ({
-    points: r.d.polygon
-  }));
-  const solverInput = {
-    bounds,
-    polygons: obstaclePolygons,
-    clearance,
-    concavityTolerance
-  };
-  const solver = new ConvexRegionsSolver(solverInput);
-  solver.solve();
-  const solverOutput = solver.getOutput();
-  if (!solverOutput) {
-    throw new Error("ConvexRegionsSolver failed to compute regions");
+  const fillerRegions = [];
+  const topMargin = bounds.maxY - gridMaxY;
+  const bottomMargin = gridMinY - bounds.minY;
+  const leftMargin = gridMinX - bounds.minX;
+  const rightMargin = bounds.maxX - gridMaxX;
+  const verticalMargin = Math.max(topMargin, bottomMargin);
+  const horizontalMargin = Math.max(leftMargin, rightMargin);
+  const topBottomGetCorners = verticalMargin >= horizontalMargin;
+  const topMinX = topBottomGetCorners ? bounds.minX : gridMinX;
+  const topMaxX = topBottomGetCorners ? bounds.maxX : gridMaxX;
+  const bottomMinX = topBottomGetCorners ? bounds.minX : gridMinX;
+  const bottomMaxX = topBottomGetCorners ? bounds.maxX : gridMaxX;
+  const leftMinY = topBottomGetCorners ? gridMinY : bounds.minY;
+  const leftMaxY = topBottomGetCorners ? gridMaxY : bounds.maxY;
+  const rightMinY = topBottomGetCorners ? gridMinY : bounds.minY;
+  const rightMaxY = topBottomGetCorners ? gridMaxY : bounds.maxY;
+  if (topMargin > 1e-3) {
+    const topWidth = topMaxX - topMinX;
+    const targetStripWidth = Math.max(topMargin, portPitch);
+    const numTopStrips = Math.max(1, Math.floor(topWidth / targetStripWidth));
+    const stripWidth = topWidth / numTopStrips;
+    for (let i = 0; i < numTopStrips; i++) {
+      const fillerBounds = {
+        minX: topMinX + i * stripWidth,
+        maxX: topMinX + (i + 1) * stripWidth,
+        minY: gridMaxY,
+        maxY: bounds.maxY
+      };
+      const regionId = `filler:top:${i}`;
+      const filler = createRegionFromPolygon(
+        regionId,
+        rectPolygonFromBounds(fillerBounds)
+      );
+      fillerRegions.push(filler);
+      allRegions.push(filler);
+    }
   }
-  const convexRegions = solverOutput.regions.map(
-    (polygon2, i) => createRegionFromPolygon(`convex:${i}`, polygon2)
-  );
-  allRegions.push(...convexRegions);
-  let portIdCounter = 0;
-  for (let i = 0; i < convexRegions.length; i++) {
-    for (let j = i + 1; j < convexRegions.length; j++) {
-      const region1 = convexRegions[i];
-      const region2 = convexRegions[j];
+  if (bottomMargin > 1e-3) {
+    const bottomWidth = bottomMaxX - bottomMinX;
+    const targetStripWidth = Math.max(bottomMargin, portPitch);
+    const numBottomStrips = Math.max(
+      1,
+      Math.floor(bottomWidth / targetStripWidth)
+    );
+    const stripWidth = bottomWidth / numBottomStrips;
+    for (let i = 0; i < numBottomStrips; i++) {
+      const fillerBounds = {
+        minX: bottomMinX + i * stripWidth,
+        maxX: bottomMinX + (i + 1) * stripWidth,
+        minY: bounds.minY,
+        maxY: gridMinY
+      };
+      const regionId = `filler:bottom:${i}`;
+      const filler = createRegionFromPolygon(
+        regionId,
+        rectPolygonFromBounds(fillerBounds)
+      );
+      fillerRegions.push(filler);
+      allRegions.push(filler);
+    }
+  }
+  if (leftMargin > 1e-3) {
+    const leftHeight = leftMaxY - leftMinY;
+    const targetStripHeight = Math.max(leftMargin, portPitch);
+    const numLeftStrips = Math.max(
+      1,
+      Math.floor(leftHeight / targetStripHeight)
+    );
+    const stripHeight = leftHeight / numLeftStrips;
+    for (let i = 0; i < numLeftStrips; i++) {
+      const fillerBounds = {
+        minX: bounds.minX,
+        maxX: gridMinX,
+        minY: leftMinY + i * stripHeight,
+        maxY: leftMinY + (i + 1) * stripHeight
+      };
+      const regionId = `filler:left:${i}`;
+      const filler = createRegionFromPolygon(
+        regionId,
+        rectPolygonFromBounds(fillerBounds)
+      );
+      fillerRegions.push(filler);
+      allRegions.push(filler);
+    }
+  }
+  if (rightMargin > 1e-3) {
+    const rightHeight = rightMaxY - rightMinY;
+    const targetStripHeight = Math.max(rightMargin, portPitch);
+    const numRightStrips = Math.max(
+      1,
+      Math.floor(rightHeight / targetStripHeight)
+    );
+    const stripHeight = rightHeight / numRightStrips;
+    for (let i = 0; i < numRightStrips; i++) {
+      const fillerBounds = {
+        minX: gridMaxX,
+        maxX: bounds.maxX,
+        minY: rightMinY + i * stripHeight,
+        maxY: rightMinY + (i + 1) * stripHeight
+      };
+      const regionId = `filler:right:${i}`;
+      const filler = createRegionFromPolygon(
+        regionId,
+        rectPolygonFromBounds(fillerBounds)
+      );
+      fillerRegions.push(filler);
+      allRegions.push(filler);
+    }
+  }
+  if (unitTileTemplate && rows > 0 && cols > 0) {
+    const regionsPerTile = unitTileTemplate.convexRegions.length;
+    for (let row = 0; row < rows; row++) {
+      for (let col = 0; col < cols; col++) {
+        const tileIndex = row * cols + col;
+        const tileStartIdx = tileIndex * regionsPerTile;
+        for (let i = 0; i < regionsPerTile; i++) {
+          for (let j = i + 1; j < regionsPerTile; j++) {
+            const region1 = convexRegions[tileStartIdx + i];
+            const region2 = convexRegions[tileStartIdx + j];
+            const sharedEdges = findSharedEdges(
+              region1.d.polygon,
+              region2.d.polygon,
+              clearance * 2
+            );
+            for (const edge of sharedEdges) {
+              const portPositions = createPortsAlongEdge(edge, portPitch);
+              for (const pos of portPositions) {
+                createPort(
+                  `t${row}_${col}:convex:${i}-${j}:${portIdCounter++}`,
+                  region1,
+                  region2,
+                  pos
+                );
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (unitTileTemplate && rows > 0 && cols > 0) {
+    const convexPerTile = unitTileTemplate.convexRegions.length;
+    const viasPerTile = unitTileTemplate.viaRegions.length;
+    const numVerticalPorts = Math.floor(tileHeight / portPitch);
+    const verticalPortYOffsets = [];
+    for (let i = 0; i < numVerticalPorts; i++) {
+      verticalPortYOffsets.push(-halfHeight + (i + 0.5) * portPitch);
+    }
+    const numHorizontalPorts = Math.floor(tileWidth / portPitch);
+    const horizontalPortXOffsets = [];
+    for (let i = 0; i < numHorizontalPorts; i++) {
+      horizontalPortXOffsets.push(-halfWidth + (i + 0.5) * portPitch);
+    }
+    for (let row = 0; row < rows; row++) {
+      for (let col = 0; col < cols; col++) {
+        const tileIndex = row * cols + col;
+        const convexStartIdx = tileIndex * convexPerTile;
+        const viaStartIdx = tileIndex * viasPerTile;
+        const tileCenterX = gridMinX + col * tileWidth + halfWidth;
+        const tileCenterY = gridMinY + row * tileHeight + halfHeight;
+        const tileConvexRegions = convexRegions.slice(
+          convexStartIdx,
+          convexStartIdx + convexPerTile
+        );
+        const tileViaRegions = viaRegions.slice(
+          viaStartIdx,
+          viaStartIdx + viasPerTile
+        );
+        const tileAllRegions = [...tileConvexRegions, ...tileViaRegions];
+        if (col + 1 < cols) {
+          const rightTileIndex = row * cols + (col + 1);
+          const rightConvexStartIdx = rightTileIndex * convexPerTile;
+          const rightViaStartIdx = rightTileIndex * viasPerTile;
+          const rightTileConvexRegions = convexRegions.slice(
+            rightConvexStartIdx,
+            rightConvexStartIdx + convexPerTile
+          );
+          const rightTileViaRegions = viaRegions.slice(
+            rightViaStartIdx,
+            rightViaStartIdx + viasPerTile
+          );
+          const rightTileAllRegions = [
+            ...rightTileConvexRegions,
+            ...rightTileViaRegions
+          ];
+          const boundaryX = tileCenterX + halfWidth;
+          for (const yOffset of verticalPortYOffsets) {
+            const portY = tileCenterY + yOffset;
+            const pointInCurrentTile = { x: boundaryX - 0.01, y: portY };
+            const pointInRightTile = { x: boundaryX + 0.01, y: portY };
+            const region1 = findRegionContainingPoint(
+              pointInCurrentTile,
+              tileAllRegions
+            );
+            const region2 = findRegionContainingPoint(
+              pointInRightTile,
+              rightTileAllRegions
+            );
+            if (region1 && region2) {
+              createPort(
+                `tile:${row}_${col}-${row}_${col + 1}:${portIdCounter++}`,
+                region1,
+                region2,
+                { x: boundaryX, y: portY }
+              );
+            }
+          }
+        }
+        if (row + 1 < rows) {
+          const topTileIndex = (row + 1) * cols + col;
+          const topConvexStartIdx = topTileIndex * convexPerTile;
+          const topViaStartIdx = topTileIndex * viasPerTile;
+          const topTileConvexRegions = convexRegions.slice(
+            topConvexStartIdx,
+            topConvexStartIdx + convexPerTile
+          );
+          const topTileViaRegions = viaRegions.slice(
+            topViaStartIdx,
+            topViaStartIdx + viasPerTile
+          );
+          const topTileAllRegions = [
+            ...topTileConvexRegions,
+            ...topTileViaRegions
+          ];
+          const boundaryY = tileCenterY + halfHeight;
+          for (const xOffset of horizontalPortXOffsets) {
+            const portX = tileCenterX + xOffset;
+            const pointInCurrentTile = { x: portX, y: boundaryY - 0.01 };
+            const pointInTopTile = { x: portX, y: boundaryY + 0.01 };
+            const region1 = findRegionContainingPoint(
+              pointInCurrentTile,
+              tileAllRegions
+            );
+            const region2 = findRegionContainingPoint(
+              pointInTopTile,
+              topTileAllRegions
+            );
+            if (region1 && region2) {
+              createPort(
+                `tile:${row}_${col}-${row + 1}_${col}:${portIdCounter++}`,
+                region1,
+                region2,
+                { x: portX, y: boundaryY }
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  for (const fillerRegion of fillerRegions) {
+    const tileRegions = [...convexRegions, ...viaRegions];
+    for (const tileRegion of tileRegions) {
+      const sharedEdges = findSharedEdges(
+        tileRegion.d.polygon,
+        fillerRegion.d.polygon,
+        clearance * 2
+      );
+      for (const edge of sharedEdges) {
+        const portPositions = createPortsAlongEdge(edge, portPitch);
+        for (const pos of portPositions) {
+          createPort(
+            `filler:${tileRegion.regionId}-${fillerRegion.regionId}:${portIdCounter++}`,
+            tileRegion,
+            fillerRegion,
+            pos
+          );
+        }
+      }
+    }
+  }
+  for (let i = 0; i < fillerRegions.length; i++) {
+    for (let j = i + 1; j < fillerRegions.length; j++) {
+      const region1 = fillerRegions[i];
+      const region2 = fillerRegions[j];
       const sharedEdges = findSharedEdges(
         region1.d.polygon,
         region2.d.polygon,
-        clearance * 2
-        // tolerance slightly larger than clearance
+        0.01
       );
       for (const edge of sharedEdges) {
+        const edgeLength = Math.sqrt(
+          (edge.to.x - edge.from.x) ** 2 + (edge.to.y - edge.from.y) ** 2
+        );
+        if (edgeLength < portPitch) {
+          continue;
+        }
         const portPositions = createPortsAlongEdge(edge, portPitch);
         for (const pos of portPositions) {
-          const port = {
-            portId: `convex:${i}-${j}:${portIdCounter++}`,
+          createPort(
+            `filler:${region1.regionId}-${region2.regionId}:${portIdCounter++}`,
             region1,
             region2,
-            d: { x: pos.x, y: pos.y }
-          };
-          region1.ports.push(port);
-          region2.ports.push(port);
-          allPorts.push(port);
+            pos
+          );
         }
       }
     }
   }
   for (const viaRegion of viaRegions) {
-    const viaCenter = viaRegion.d.center;
-    const candidates = [];
     for (const convexRegion of convexRegions) {
       const sharedEdges = findSharedEdges(
         viaRegion.d.polygon,
@@ -16633,55 +16426,15 @@ function generateConvexViaTopologyRegions(opts) {
       for (const edge of sharedEdges) {
         const portPositions = createPortsAlongEdge(edge, portPitch);
         for (const pos of portPositions) {
-          const dx = pos.x - viaCenter.x;
-          const dy = pos.y - viaCenter.y;
-          const side = classifySideFromBounds(pos, viaRegion.d.bounds);
-          const primaryDistance = side === "left" || side === "right" ? Math.abs(dx) : Math.abs(dy);
-          const orthDistance = side === "left" || side === "right" ? Math.abs(dy) : Math.abs(dx);
-          candidates.push({
+          createPort(
+            `via-convex:${viaRegion.regionId}-${convexRegion.regionId}:${portIdCounter++}`,
+            viaRegion,
             convexRegion,
-            position: pos,
-            side,
-            primaryDistance,
-            orthDistance,
-            key: toCandidateKey(convexRegion.regionId, pos)
-          });
+            pos
+          );
         }
       }
     }
-    if (candidates.length === 0) continue;
-    const selectedCandidates = [];
-    const selectedKeys = /* @__PURE__ */ new Set();
-    const addCandidate = (candidate) => {
-      if (!candidate) return;
-      if (selectedKeys.has(candidate.key)) return;
-      selectedCandidates.push(candidate);
-      selectedKeys.add(candidate.key);
-    };
-    for (const side of ["top", "bottom", "left", "right"]) {
-      const sideCandidate = [...candidates].filter((candidate) => candidate.side === side).sort(compareCandidateQuality)[0];
-      addCandidate(sideCandidate);
-    }
-    if (selectedCandidates.length < 4) {
-      for (const candidate of [...candidates].sort(compareCandidateQuality)) {
-        addCandidate(candidate);
-        if (selectedCandidates.length >= 4) break;
-      }
-    }
-    for (const selectedCandidate of selectedCandidates.slice(0, 4)) {
-      const port = {
-        portId: `via-convex:${viaRegion.regionId}-${selectedCandidate.convexRegion.regionId}:${portIdCounter++}`,
-        region1: viaRegion,
-        region2: selectedCandidate.convexRegion,
-        d: {
-          x: selectedCandidate.position.x,
-          y: selectedCandidate.position.y
-        }
-      };
-      viaRegion.ports.push(port);
-      selectedCandidate.convexRegion.ports.push(port);
-      allPorts.push(port);
-    }
   }
   return {
     regions: allRegions,
@@ -16718,8 +16471,8 @@ function createConvexViaGraphFromXYConnections(xyConnections, viaTile = via_tile
   } = generateConvexViaTopologyRegions({
     viaTile,
     bounds,
-    tileWidth: opts?.tileWidth,
-    tileHeight: opts?.tileHeight,
+    tileWidth: opts?.tileWidth ?? viaTile.tileWidth,
+    tileHeight: opts?.tileHeight ?? viaTile.tileHeight,
     tileSize: opts?.tileSize,
     portPitch: opts?.portPitch,
     clearance: opts?.clearance,
@@ -16736,48 +16489,6 @@ function createConvexViaGraphFromXYConnections(xyConnections, viaTile = via_tile
     tileCount
   };
 }
-
-// lib/ViaGraphSolver/via-graph-generator/createViaGraphFromXYConnections.ts
-function calculateBoundsFromConnections2(xyConnections) {
-  if (xyConnections.length === 0) {
-    throw new Error("Cannot calculate bounds from empty connections array");
-  }
-  let minX = Infinity;
-  let maxX = -Infinity;
-  let minY = Infinity;
-  let maxY = -Infinity;
-  for (const conn of xyConnections) {
-    minX = Math.min(minX, conn.start.x, conn.end.x);
-    maxX = Math.max(maxX, conn.start.x, conn.end.x);
-    minY = Math.min(minY, conn.start.y, conn.end.y);
-    maxY = Math.max(maxY, conn.start.y, conn.end.y);
-  }
-  return { minX, maxX, minY, maxY };
-}
-function createViaGraphFromXYConnections(xyConnections, viaTile, opts) {
-  const bounds = calculateBoundsFromConnections2(xyConnections);
-  const {
-    regions,
-    ports,
-    viaTile: generatedViaTile,
-    tileCount
-  } = generateViaTopologyGrid({
-    viaTile,
-    bounds,
-    tileSize: opts?.tileSize,
-    portPitch: opts?.portPitch
-  });
-  const baseGraph = { regions, ports };
-  const graphWithConnections = createViaGraphWithConnections(
-    baseGraph,
-    xyConnections
-  );
-  return {
-    ...graphWithConnections,
-    viaTile: generatedViaTile,
-    tileCount
-  };
-}
 export {
   ConnectBuilder,
   HyperGraphSolver,
@@ -16795,14 +16506,11 @@ export {
   convertHyperGraphToSerializedHyperGraph,
   createConvexViaGraphFromXYConnections,
   createGraphWithConnectionsFromBaseGraph,
-  createViaGraphFromXYConnections,
   createViaGraphWithConnections,
   generateConvexViaTopologyRegions,
-  generateDefaultViaTopologyGrid,
   generateDefaultViaTopologyRegions,
   generateJumperGrid,
   generateJumperX4Grid,
-  generateViaTopologyGrid,
   generateViaTopologyRegions,
   rotateGraph90Degrees,
   via_tile_4_regions_default as viaTile