@tscircuit/hypergraph 0.0.44 → 0.0.45

package/dist/index.d.ts

@@ -1081,10 +1081,13 @@ type Bounds = {
 /**
  * Generates a via topology using convex regions computed by ConvexRegionsSolver.
  *
- * 1. Via tiles are placed on a grid (5mm tiles by default)
- * 2. Per-net via region polygons are created within each tile
- * 3. Convex regions are computed globally with via region polygons as obstacles
- * 4. Ports are created between adjacent convex regions and between convex/via regions
+ * New tiled approach:
+ * 1. Compute convex regions for a single unit tile (centered at origin)
+ * 2. Replicate the tile's regions across the grid by translation
+ * 3. Create rectangular filler regions for outer areas:
+ *    - Top/bottom regions extend horizontally across full bounds width
+ *    - Left/right regions extend vertically between top/bottom regions
+ * 4. Create ports between adjacent tiles and between tiles and filler regions
  */
 declare function generateConvexViaTopologyRegions(opts: {
     viaTile: ViaTile;

package/dist/index.js

@@ -5778,6 +5778,32 @@ function generateDefaultViaTopologyRegions(opts) {
 }
 
 // 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) {
@@ -5790,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++;
     }
   }
@@ -5817,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);
     }
   }
@@ -15697,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;
@@ -15768,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 {
@@ -15879,6 +15881,124 @@ function translateRouteSegments(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 ?? opts.viaTile.tileWidth;
   const tileHeight = opts.tileHeight ?? opts.tileSize ?? opts.viaTile.tileHeight;
@@ -15900,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(
@@ -15924,15 +16105,6 @@ 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(
           ...translateRouteSegments(
@@ -15945,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,
@@ -16003,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,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/hypergraph",
   "main": "dist/index.js",
-  "version": "0.0.44",
+  "version": "0.0.45",
   "type": "module",
   "scripts": {
     "start": "cosmos",