@tscircuit/hypergraph 0.0.46 → 0.0.48

package/dist/index.d.ts

@@ -1017,6 +1017,7 @@ declare class ViaGraphSolver extends HyperGraphSolver<JRegion, JPort> {
     estimateCostToEnd(port: JPort): number;
     getPortUsagePenalty(port: JPort): number;
     computeIncreasedRegionCostIfPortsAreUsed(region: JRegion, port1: JPort, port2: JPort): number;
+    isRipRequiredForPortUsage(region: JRegion, _port1: JPort, _port2: JPort): boolean;
     getRipsRequiredForPortUsage(region: JRegion, port1: JPort, port2: JPort): RegionPortAssignment[];
     routeSolvedHook(solvedRoute: SolvedRoute): void;
     getSolvedRoutePoints(solvedRoute: SolvedRoute): Array<{

package/dist/index.js

@@ -5815,6 +5815,34 @@ function lineSegmentsIntersect(p1, p2, p3, p4, eps = 1e-9) {
   if (d1 * d2 < 0 && d3 * d4 < 0) {
     return true;
   }
+  const pointOnSegment = (point2, segStart, segEnd, crossProduct) => {
+    if (Math.abs(crossProduct) > eps) return false;
+    const minX = Math.min(segStart.x, segEnd.x) - eps;
+    const maxX = Math.max(segStart.x, segEnd.x) + eps;
+    const minY = Math.min(segStart.y, segEnd.y) - eps;
+    const maxY = Math.max(segStart.y, segEnd.y) + eps;
+    return point2.x >= minX && point2.x <= maxX && point2.y >= minY && point2.y <= maxY;
+  };
+  if (pointOnSegment(p1, p3, p4, d1)) {
+    if (!pointsCoincident(p1, p3) && !pointsCoincident(p1, p4)) {
+      return true;
+    }
+  }
+  if (pointOnSegment(p2, p3, p4, d2)) {
+    if (!pointsCoincident(p2, p3) && !pointsCoincident(p2, p4)) {
+      return true;
+    }
+  }
+  if (pointOnSegment(p3, p1, p2, d3)) {
+    if (!pointsCoincident(p3, p1) && !pointsCoincident(p3, p2)) {
+      return true;
+    }
+  }
+  if (pointOnSegment(p4, p1, p2, d4)) {
+    if (!pointsCoincident(p4, p1) && !pointsCoincident(p4, p2)) {
+      return true;
+    }
+  }
   return false;
 }
 function chordsIntersect(newChord, existingChord, perimeter, newPort1, newPort2, existingPort1, existingPort2) {
@@ -6300,6 +6328,15 @@ var ViaGraphSolver = class extends HyperGraphSolver {
     );
     return crossings * this.crossingPenalty + crossings * this.crossingPenaltySq;
   }
+  isRipRequiredForPortUsage(region, _port1, _port2) {
+    if (region.d.isViaRegion) {
+      const assignments = region.assignments ?? [];
+      return assignments.some(
+        (a) => a.connection.mutuallyConnectedNetworkId !== this.currentConnection.mutuallyConnectedNetworkId
+      );
+    }
+    return false;
+  }
   getRipsRequiredForPortUsage(region, port1, port2) {
     if (region.d.isViaRegion) {
       const assignments = region.assignments ?? [];
@@ -6356,13 +6393,16 @@ function closestPointOnPolygonEdge(point2, polygon2) {
   }
   return { ...bestPoint, dist: bestDist };
 }
-var findBoundaryRegionForPolygons = (x, y, regions) => {
+var findBoundaryRegionForPolygons = (params) => {
+  const { x, y, regions } = params;
+  const hasFillerRegions = regions.some((r) => r.regionId.startsWith("filler:"));
   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;
+    if (hasFillerRegions && !region.regionId.startsWith("filler:")) continue;
     const polygon2 = region.d.polygon;
     if (!polygon2 || polygon2.length < 3) continue;
     const result = closestPointOnPolygonEdge({ x, y }, polygon2);
@@ -6397,11 +6437,11 @@ var createViaGraphWithConnections = (baseGraph, xyConnections) => {
       end.y
     );
     regions.push(endRegion);
-    const startBoundary = findBoundaryRegionForPolygons(
-      start.x,
-      start.y,
-      baseGraph.regions
-    );
+    const startBoundary = findBoundaryRegionForPolygons({
+      x: start.x,
+      y: start.y,
+      regions: baseGraph.regions
+    });
     if (startBoundary) {
       const startPort = createConnectionPort(
         `conn:${connectionId}:start-port`,
@@ -6411,11 +6451,11 @@ var createViaGraphWithConnections = (baseGraph, xyConnections) => {
       );
       ports.push(startPort);
     }
-    const endBoundary = findBoundaryRegionForPolygons(
-      end.x,
-      end.y,
-      baseGraph.regions
-    );
+    const endBoundary = findBoundaryRegionForPolygons({
+      x: end.x,
+      y: end.y,
+      regions: baseGraph.regions
+    });
     if (endBoundary) {
       const endPort = createConnectionPort(
         `conn:${connectionId}:end-port`,
@@ -15916,6 +15956,34 @@ function rectPolygonFromBounds(b) {
     { x: b.minX, y: b.maxY }
   ];
 }
+function findViaRegionSidePorts(polygon2) {
+  if (polygon2.length < 3) {
+    return { top: null, bottom: null, left: null, right: null };
+  }
+  const bounds = boundsFromPolygon(polygon2);
+  const tolerance = 1e-3;
+  let topPort = null;
+  let bottomPort = null;
+  let leftPort = null;
+  let rightPort = null;
+  for (let i = 0; i < polygon2.length; i++) {
+    const p1 = polygon2[i];
+    const p2 = polygon2[(i + 1) % polygon2.length];
+    if (Math.abs(p1.y - bounds.maxY) < tolerance && Math.abs(p2.y - bounds.maxY) < tolerance) {
+      topPort = { x: (p1.x + p2.x) / 2, y: bounds.maxY };
+    }
+    if (Math.abs(p1.y - bounds.minY) < tolerance && Math.abs(p2.y - bounds.minY) < tolerance) {
+      bottomPort = { x: (p1.x + p2.x) / 2, y: bounds.minY };
+    }
+    if (Math.abs(p1.x - bounds.minX) < tolerance && Math.abs(p2.x - bounds.minX) < tolerance) {
+      leftPort = { x: bounds.minX, y: (p1.y + p2.y) / 2 };
+    }
+    if (Math.abs(p1.x - bounds.maxX) < tolerance && Math.abs(p2.x - bounds.maxX) < tolerance) {
+      rightPort = { x: bounds.maxX, y: (p1.y + p2.y) / 2 };
+    }
+  }
+  return { top: topPort, bottom: bottomPort, left: leftPort, right: rightPort };
+}
 function extendViaRegionToTileEdge(polygon2, tileBounds, threshold = 0.1) {
   if (polygon2.length === 0) return polygon2;
   const polyBounds = boundsFromPolygon(polygon2);
@@ -16391,24 +16459,120 @@ function generateConvexViaTopologyRegions(opts) {
       }
     }
   }
+  const fillerPortPositions = /* @__PURE__ */ new Map();
   for (const fillerRegion of fillerRegions) {
+    fillerPortPositions.set(fillerRegion.regionId, []);
+    const fillerBounds = fillerRegion.d.bounds;
+    const stripWidth = fillerBounds.maxX - fillerBounds.minX;
+    const stripHeight = fillerBounds.maxY - fillerBounds.minY;
+    const isHorizontalStrip = stripWidth > stripHeight;
+    const stripSize = isHorizontalStrip ? stripWidth : stripHeight;
+    const numPorts = Math.max(1, Math.floor(stripSize / portPitch));
+    const actualPitch = stripSize / numPorts;
+    const adjacencyTolerance = clearance * 2;
+    const isTopFiller = fillerRegion.regionId.startsWith("filler:top:");
+    const isBottomFiller = fillerRegion.regionId.startsWith("filler:bottom:");
+    const isLeftFiller = fillerRegion.regionId.startsWith("filler:left:");
+    const isRightFiller = fillerRegion.regionId.startsWith("filler:right:");
     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
+      const tileBounds = tileRegion.d.bounds;
+      const eps = 1e-3;
+      let isAdjacent = false;
+      let edgeX = null;
+      let edgeY = null;
+      if (isHorizontalStrip) {
+        const overlapMinX = Math.max(fillerBounds.minX, tileBounds.minX);
+        const overlapMaxX = Math.min(fillerBounds.maxX, tileBounds.maxX);
+        const hasXOverlap = overlapMaxX > overlapMinX + eps;
+        if (hasXOverlap) {
+          if (isTopFiller) {
+            isAdjacent = Math.abs(tileBounds.maxY - fillerBounds.minY) < adjacencyTolerance;
+            edgeY = fillerBounds.minY;
+          } else if (isBottomFiller) {
+            isAdjacent = Math.abs(tileBounds.minY - fillerBounds.maxY) < adjacencyTolerance;
+            edgeY = fillerBounds.maxY;
+          }
+        }
+      } else {
+        const overlapMinY = Math.max(fillerBounds.minY, tileBounds.minY);
+        const overlapMaxY = Math.min(fillerBounds.maxY, tileBounds.maxY);
+        const hasYOverlap = overlapMaxY > overlapMinY + eps;
+        if (hasYOverlap) {
+          if (isLeftFiller) {
+            isAdjacent = Math.abs(tileBounds.minX - fillerBounds.maxX) < adjacencyTolerance;
+            edgeX = fillerBounds.maxX;
+          } else if (isRightFiller) {
+            isAdjacent = Math.abs(tileBounds.maxX - fillerBounds.minX) < adjacencyTolerance;
+            edgeX = fillerBounds.minX;
+          }
+        }
+      }
+      if (!isAdjacent) continue;
+      let overlapMin;
+      let overlapMax;
+      if (isHorizontalStrip) {
+        overlapMin = Math.max(fillerBounds.minX, tileBounds.minX);
+        overlapMax = Math.min(fillerBounds.maxX, tileBounds.maxX);
+      } else {
+        overlapMin = Math.max(fillerBounds.minY, tileBounds.minY);
+        overlapMax = Math.min(fillerBounds.maxY, tileBounds.maxY);
+      }
+      const overlapSize = overlapMax - overlapMin;
+      if (overlapSize < eps) continue;
+      const overlapNumPorts = Math.max(1, Math.floor(overlapSize / portPitch));
+      const overlapActualPitch = overlapSize / overlapNumPorts;
+      for (let i = 0; i < overlapNumPorts; i++) {
+        let pos;
+        if (isHorizontalStrip) {
+          const x = overlapMin + (i + 0.5) * overlapActualPitch;
+          pos = { x, y: edgeY };
+        } else {
+          const y = overlapMin + (i + 0.5) * overlapActualPitch;
+          pos = { x: edgeX, y };
+        }
+        if (tileRegion.d.polygon) {
+          let testPoint;
+          if (isTopFiller) {
+            const gap = fillerBounds.minY - tileBounds.maxY;
+            const testOffset = gap + 0.01;
+            testPoint = { x: pos.x, y: pos.y - testOffset };
+          } else if (isBottomFiller) {
+            const gap = tileBounds.minY - fillerBounds.maxY;
+            const testOffset = gap + 0.01;
+            testPoint = { x: pos.x, y: pos.y + testOffset };
+          } else if (isLeftFiller) {
+            const gap = tileBounds.minX - fillerBounds.maxX;
+            const testOffset = gap + 0.01;
+            testPoint = { x: pos.x + testOffset, y: pos.y };
+          } else {
+            const gap = fillerBounds.minX - tileBounds.maxX;
+            const testOffset = gap + 0.01;
+            testPoint = { x: pos.x - testOffset, y: pos.y };
+          }
+          if (!pointInPolygon(testPoint, tileRegion.d.polygon)) {
+            continue;
+          }
+        }
+        const existingPositions = fillerPortPositions.get(
+          fillerRegion.regionId
+        );
+        const tooClose = existingPositions.some((existing) => {
+          const dist = Math.sqrt(
+            (pos.x - existing.x) ** 2 + (pos.y - existing.y) ** 2
           );
+          return dist < portPitch;
+        });
+        if (tooClose) {
+          continue;
         }
+        existingPositions.push(pos);
+        createPort(
+          `filler:${tileRegion.regionId}-${fillerRegion.regionId}:${portIdCounter++}`,
+          tileRegion,
+          fillerRegion,
+          pos
+        );
       }
     }
   }
@@ -16425,10 +16589,20 @@ function generateConvexViaTopologyRegions(opts) {
         const edgeLength = Math.sqrt(
           (edge.to.x - edge.from.x) ** 2 + (edge.to.y - edge.from.y) ** 2
         );
-        if (edgeLength < portPitch) {
+        if (edgeLength < 0.01) {
           continue;
         }
-        const portPositions = createPortsAlongEdge(edge, portPitch);
+        let portPositions;
+        if (edgeLength < portPitch) {
+          portPositions = [
+            {
+              x: (edge.from.x + edge.to.x) / 2,
+              y: (edge.from.y + edge.to.y) / 2
+            }
+          ];
+        } else {
+          portPositions = createPortsAlongEdge(edge, portPitch);
+        }
         for (const pos of portPositions) {
           createPort(
             `filler:${region1.regionId}-${region2.regionId}:${portIdCounter++}`,
@@ -16440,22 +16614,61 @@ function generateConvexViaTopologyRegions(opts) {
       }
     }
   }
+  const nonViaRegions = allRegions.filter((r) => !r.d.isViaRegion);
+  const createdViaSidePorts = /* @__PURE__ */ new Set();
   for (const viaRegion of viaRegions) {
-    for (const convexRegion of convexRegions) {
-      const sharedEdges = findSharedEdges(
-        viaRegion.d.polygon,
-        convexRegion.d.polygon,
-        clearance * 2
-      );
-      for (const edge of sharedEdges) {
-        const portPositions = createPortsAlongEdge(edge, portPitch);
-        for (const pos of portPositions) {
+    const sidePorts = findViaRegionSidePorts(viaRegion.d.polygon);
+    const viaBounds = viaRegion.d.bounds;
+    const sides = ["top", "bottom", "left", "right"];
+    for (const side of sides) {
+      const portPos = sidePorts[side];
+      if (!portPos) continue;
+      const sideKey = `${viaRegion.regionId}:${side}`;
+      if (createdViaSidePorts.has(sideKey)) continue;
+      const adjacencyTolerance = 0.2;
+      const testOffset = adjacencyTolerance;
+      let testPoint;
+      switch (side) {
+        case "top":
+          testPoint = { x: portPos.x, y: viaBounds.maxY + testOffset };
+          break;
+        case "bottom":
+          testPoint = { x: portPos.x, y: viaBounds.minY - testOffset };
+          break;
+        case "left":
+          testPoint = { x: viaBounds.minX - testOffset, y: portPos.y };
+          break;
+        case "right":
+          testPoint = { x: viaBounds.maxX + testOffset, y: portPos.y };
+          break;
+      }
+      for (const adjacentRegion of nonViaRegions) {
+        const adjBounds = adjacentRegion.d.bounds;
+        let boundsAdjacent = false;
+        switch (side) {
+          case "top":
+            boundsAdjacent = Math.abs(adjBounds.minY - viaBounds.maxY) < adjacencyTolerance && adjBounds.minX < portPos.x && adjBounds.maxX > portPos.x;
+            break;
+          case "bottom":
+            boundsAdjacent = Math.abs(adjBounds.maxY - viaBounds.minY) < adjacencyTolerance && adjBounds.minX < portPos.x && adjBounds.maxX > portPos.x;
+            break;
+          case "left":
+            boundsAdjacent = Math.abs(adjBounds.maxX - viaBounds.minX) < adjacencyTolerance && adjBounds.minY < portPos.y && adjBounds.maxY > portPos.y;
+            break;
+          case "right":
+            boundsAdjacent = Math.abs(adjBounds.minX - viaBounds.maxX) < adjacencyTolerance && adjBounds.minY < portPos.y && adjBounds.maxY > portPos.y;
+            break;
+        }
+        if (!boundsAdjacent) continue;
+        if (adjacentRegion.d.polygon && pointInPolygon(testPoint, adjacentRegion.d.polygon)) {
           createPort(
-            `via-convex:${viaRegion.regionId}-${convexRegion.regionId}:${portIdCounter++}`,
+            `via-side:${viaRegion.regionId}:${side}:${portIdCounter++}`,
             viaRegion,
-            convexRegion,
-            pos
+            adjacentRegion,
+            portPos
           );
+          createdViaSidePorts.add(sideKey);
+          break;
         }
       }
     }

package/package.json

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