@tscircuit/hypergraph 0.0.43 → 0.0.44

package/dist/index.d.ts

@@ -306,7 +306,7 @@ declare class HyperGraphSolver<RegionType extends Region = Region, RegionPortTyp
     _step(): void;
 }
 
-type Bounds$2 = {
+type Bounds$1 = {
     minX: number;
     minY: number;
     maxX: number;
@@ -315,7 +315,7 @@ type Bounds$2 = {
 
 interface JRegion extends Region {
     d: {
-        bounds: Bounds$2;
+        bounds: Bounds$1;
         center: {
             x: number;
             y: number;
@@ -406,7 +406,7 @@ declare class JumperGraphSolver extends HyperGraphSolver<JRegion, JPort> {
     visualize(): GraphicsObject;
 }
 
-declare const calculateGraphBounds: (regions: JRegion[]) => Bounds$2;
+declare const calculateGraphBounds: (regions: JRegion[]) => Bounds$1;
 
 type XYConnection = {
     start: {
@@ -502,7 +502,7 @@ type SharedBoundary = {
 };
 type RegionData = {
     id: string;
-    bounds: Bounds$2 | null;
+    bounds: Bounds$1 | null;
     polygon: {
         x: number;
         y: number;
@@ -543,7 +543,7 @@ declare class RegionBuilder implements RegionRef {
     private data;
     constructor(id: string);
     get id(): string;
-    rect(b: Bounds$2): this;
+    rect(b: Bounds$1): this;
     polygon(points: {
         x: number;
         y: number;
@@ -572,7 +572,7 @@ declare class ConnectBuilder {
     private portIds;
     private boundary;
     private prefixWasExplicitlySet;
-    constructor(region1Id: string, region2Id: string, bounds1: Bounds$2, bounds2: Bounds$2, addPortFn: AddPortFn$1, prefixIdFn: PrefixIdFn, opts?: {
+    constructor(region1Id: string, region2Id: string, bounds1: Bounds$1, bounds2: Bounds$1, addPortFn: AddPortFn$1, prefixIdFn: PrefixIdFn, opts?: {
         idPrefix?: string;
         tolerance?: number;
     });
@@ -592,7 +592,7 @@ declare class ConnectBuilder {
 
 type ResolveRegionFn = (ref: RegionRef | string) => {
     id: string;
-    bounds: Bounds$2;
+    bounds: Bounds$1;
 };
 type AddPortFn = (port: PortData) => void;
 declare class PortBuilder {
@@ -920,9 +920,13 @@ var routeSegments = [
 		]
 	}
 ];
+var tileWidth = 3.735441;
+var tileHeight = 4.029267;
 var viaTile4Regions = {
 	viasByNet: viasByNet,
-	routeSegments: routeSegments
+	routeSegments: routeSegments,
+	tileWidth: tileWidth,
+	tileHeight: tileHeight
 };
 
 type ResolvedRouteLineSegment = {
@@ -960,6 +964,8 @@ type ViaByNet = Record<string, ViaData[]>;
 type ViaTile = {
     viasByNet: ViaByNet;
     routeSegments: RouteSegment[];
+    tileWidth?: number;
+    tileHeight?: number;
 };
 declare class ViaGraphSolver extends HyperGraphSolver<JRegion, JPort> {
     getSolverName(): string;
@@ -998,36 +1004,6 @@ declare class ViaGraphSolver extends HyperGraphSolver<JRegion, JPort> {
     visualize(): GraphicsObject;
 }
 
-type Bounds$1 = {
-    minX: number;
-    maxX: number;
-    minY: number;
-    maxY: number;
-};
-/**
- * Generates a tiled grid of via topologies with outer frame regions.
- *
- * The via tiles are centered within the given bounds. If the bounds are smaller
- * than one tile, no via tiles are created - only outer frame regions.
- *
- * The outer frame consists of rectangular regions (T, B, L, R) that fill the
- * space between the tiled area and the problem bounds.
- */
-declare function generateViaTopologyGrid(opts: {
-    viaTile: ViaTile;
-    bounds: Bounds$1;
-    tileSize?: number;
-    portPitch?: number;
-}): {
-    regions: JRegion[];
-    ports: JPort[];
-    viaTile: ViaTile;
-    tileCount: {
-        rows: number;
-        cols: number;
-    };
-};
-
 /**
  * Generates four outer topology regions (top, bottom, left, right) that wrap
  * around all vias, forming a closed frame that extends to the graph boundary.
@@ -1048,15 +1024,6 @@ declare function generateDefaultViaTopologyRegions(opts: Parameters<typeof gener
     regions: JRegion[];
     ports: JPort[];
 };
-declare function generateDefaultViaTopologyGrid(opts: Omit<Parameters<typeof generateViaTopologyGrid>[0], "viaTile">): {
-    regions: JRegion[];
-    ports: JPort[];
-    viaTile: ViaTile;
-    tileCount: {
-        rows: number;
-        cols: number;
-    };
-};
 
 type ConvexViaGraphFromXYConnectionsResult = JumperGraph & {
     connections: Connection[];
@@ -1092,33 +1059,6 @@ declare function createConvexViaGraphFromXYConnections(xyConnections: XYConnecti
     concavityTolerance?: number;
 }): ConvexViaGraphFromXYConnectionsResult;
 
-type ViaGraphFromXYConnectionsResult = JumperGraph & {
-    connections: Connection[];
-    viaTile: ViaTile;
-    tileCount: {
-        rows: number;
-        cols: number;
-    };
-};
-/**
- * Creates a complete via topology graph from XY connections.
- *
- * This is the main entry point for integrating ViaGraphSolver with dataset02.
- * It:
- * 1. Calculates bounds from connection XY coordinates (no margin)
- * 2. Generates a tiled grid of via topologies that fits within bounds
- * 3. Creates outer frame regions to fill remaining space
- * 4. Attaches connection regions to the graph
- *
- * @param xyConnections - Array of connections with start/end XY coordinates
- * @param viaTile - Via tile data (vias grouped by net plus route segments)
- * @param opts - Optional configuration (tileSize defaults to 5mm, portPitch to 0.4mm)
- */
-declare function createViaGraphFromXYConnections(xyConnections: XYConnection[], viaTile: ViaTile, opts?: {
-    tileSize?: number;
-    portPitch?: number;
-}): ViaGraphFromXYConnectionsResult;
-
 type ViaGraphWithConnections = JumperGraph & {
     connections: Connection[];
 };
@@ -1165,4 +1105,4 @@ declare function generateConvexViaTopologyRegions(opts: {
     };
 };
 
-export { type Bounds$2 as Bounds, type BuildOpts, type Candidate, ConnectBuilder, type ConnectOpts, type Connection, type ConnectionId, type ConvexViaGraphFromXYConnectionsResult, type GScore, type GraphEdgeId, type HyperGraph, HyperGraphSolver, type JPort, type JRegion, JUMPER_GRAPH_SOLVER_DEFAULTS, type JumperGraph, JumperGraphSolver, type JumperGraphWithConnections, type NetworkId, type PortAssignment, PortBuilder, type PortData, type PortId, type PortSpread, type Region, RegionBuilder, type RegionData, type RegionId, type RegionPort, type RegionPortAssignment, type RegionRef, type RouteSegment, type SerializedConnection, type SerializedGraphPort, type SerializedGraphRegion, type SerializedHyperGraph, type SerializedRegionPortAssignment, type SharedBoundary, type SolvedRoute, Topology, TopologyError, VIA_GRAPH_SOLVER_DEFAULTS, type ValidateOpts, type ViaByNet, type ViaData, type ViaGraphFromXYConnectionsResult, ViaGraphSolver, type ViaGraphWithConnections, type ViaTile, type XYConnection, applyTransformToGraph, calculateGraphBounds, convertConnectionsToSerializedConnections, convertHyperGraphToSerializedHyperGraph, createConvexViaGraphFromXYConnections, createGraphWithConnectionsFromBaseGraph, createViaGraphFromXYConnections, createViaGraphWithConnections, generateConvexViaTopologyRegions, generateDefaultViaTopologyGrid, generateDefaultViaTopologyRegions, generateJumperGrid, generateJumperX4Grid, generateViaTopologyGrid, generateViaTopologyRegions, rotateGraph90Degrees, viaTile4Regions as viaTile };
+export { type Bounds$1 as Bounds, type BuildOpts, type Candidate, ConnectBuilder, type ConnectOpts, type Connection, type ConnectionId, type ConvexViaGraphFromXYConnectionsResult, type GScore, type GraphEdgeId, type HyperGraph, HyperGraphSolver, type JPort, type JRegion, JUMPER_GRAPH_SOLVER_DEFAULTS, type JumperGraph, JumperGraphSolver, type JumperGraphWithConnections, type NetworkId, type PortAssignment, PortBuilder, type PortData, type PortId, type PortSpread, type Region, RegionBuilder, type RegionData, type RegionId, type RegionPort, type RegionPortAssignment, type RegionRef, type RouteSegment, type SerializedConnection, type SerializedGraphPort, type SerializedGraphRegion, type SerializedHyperGraph, type SerializedRegionPortAssignment, type SharedBoundary, type SolvedRoute, Topology, TopologyError, VIA_GRAPH_SOLVER_DEFAULTS, type ValidateOpts, type ViaByNet, type ViaData, ViaGraphSolver, type ViaGraphWithConnections, type ViaTile, type XYConnection, applyTransformToGraph, calculateGraphBounds, convertConnectionsToSerializedConnections, convertHyperGraphToSerializedHyperGraph, createConvexViaGraphFromXYConnections, createGraphWithConnectionsFromBaseGraph, createViaGraphWithConnections, generateConvexViaTopologyRegions, generateDefaultViaTopologyRegions, generateJumperGrid, generateJumperX4Grid, generateViaTopologyRegions, rotateGraph90Degrees, viaTile4Regions as viaTile };

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,645 +5772,10 @@ 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 computeDifferentNetCrossingsForPolygon(region, port1, port2) {
@@ -16296,7 +15663,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 +15685,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;
@@ -16356,9 +15723,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;
@@ -16502,7 +15867,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}`,
@@ -16515,9 +15880,14 @@ function translateRouteSegments2(routeSegments, dx, dy, prefix) {
   }));
 }
 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;
@@ -16565,7 +15935,7 @@ function generateConvexViaTopologyRegions(opts) {
           allRegions.push(viaRegion);
         }
         viaTile.routeSegments.push(
-          ...translateRouteSegments2(
+          ...translateRouteSegments(
             routeSegments,
             tileCenterX,
             tileCenterY,
@@ -16718,8 +16088,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 +16106,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 +16123,11 @@ export {
   convertHyperGraphToSerializedHyperGraph,
   createConvexViaGraphFromXYConnections,
   createGraphWithConnectionsFromBaseGraph,
-  createViaGraphFromXYConnections,
   createViaGraphWithConnections,
   generateConvexViaTopologyRegions,
-  generateDefaultViaTopologyGrid,
   generateDefaultViaTopologyRegions,
   generateJumperGrid,
   generateJumperX4Grid,
-  generateViaTopologyGrid,
   generateViaTopologyRegions,
   rotateGraph90Degrees,
   via_tile_4_regions_default as viaTile

package/package.json

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