@tscircuit/hypergraph 0.0.20 → 0.0.22

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { GraphicsObject } from 'graphics-debug';
 import { BaseSolver } from '@tscircuit/solver-utils';
 import { Matrix } from 'transformation-matrix';
+import { GraphicsObject } from 'graphics-debug';
 
 type PortId = string;
 type GraphEdgeId = string;
@@ -96,109 +96,9 @@ type SerializedConnection = {
     endRegionId: RegionId;
 };
 
-type Bounds = {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-};
-
-interface JRegion extends Region {
-    d: {
-        bounds: Bounds;
-        center: {
-            x: number;
-            y: number;
-        };
-        polygon?: {
-            x: number;
-            y: number;
-        }[];
-        isPad: boolean;
-        isThroughJumper?: boolean;
-        isConnectionRegion?: boolean;
-    };
-}
-interface JPort extends RegionPort {
-    d: {
-        x: number;
-        y: number;
-    };
-}
-type JumperGraph = {
-    regions: JRegion[];
-    ports: JPort[];
-    jumperLocations?: Array<{
-        center: {
-            x: number;
-            y: number;
-        };
-        orientation: "vertical" | "horizontal";
-        padRegions: JRegion[];
-    }>;
-};
-
-declare const generateJumperX4Grid: ({ cols, rows, marginX, marginY, innerColChannelPointCount, innerRowChannelPointCount, regionsBetweenPads, outerPaddingX: outerPaddingXParam, outerPaddingY: outerPaddingYParam, outerChannelXPointCount, outerChannelYPointCount, orientation, center, bounds, parallelTracesUnderJumperCount, }: {
-    cols: number;
-    rows: number;
-    marginX: number;
-    marginY: number;
-    innerColChannelPointCount?: number;
-    innerRowChannelPointCount?: number;
-    regionsBetweenPads?: boolean;
-    outerPaddingX?: number;
-    outerPaddingY?: number;
-    outerChannelXPointCount?: number;
-    outerChannelYPointCount?: number;
-    orientation?: "vertical" | "horizontal";
-    center?: {
-        x: number;
-        y: number;
-    };
-    bounds?: {
-        minX: number;
-        maxX: number;
-        minY: number;
-        maxY: number;
-    };
-    /** Number of trace points that can pass through the jumper body from top to bottom without using jumpers */
-    parallelTracesUnderJumperCount?: number;
-}) => JumperGraph;
-
-declare const generateJumperGrid: ({ cols, rows, marginX, marginY, innerColChannelPointCount, innerRowChannelPointCount, outerPaddingX, outerPaddingY, outerChannelXPoints, outerChannelYPoints, orientation, }: {
-    cols: number;
-    rows: number;
-    marginX: number;
-    marginY: number;
-    innerColChannelPointCount?: number;
-    innerRowChannelPointCount?: number;
-    outerPaddingX?: number;
-    outerPaddingY?: number;
-    outerChannelXPoints?: number;
-    outerChannelYPoints?: number;
-    orientation?: "vertical" | "horizontal";
-}) => JumperGraph;
+declare const convertConnectionsToSerializedConnections: (connections: Connection[]) => SerializedConnection[];
 
-type XYConnection = {
-    start: {
-        x: number;
-        y: number;
-    };
-    end: {
-        x: number;
-        y: number;
-    };
-    connectionId: string;
-};
-type JumperGraphWithConnections = JumperGraph & {
-    connections: Connection[];
-};
-/**
- * Creates a new graph from a base graph with additional connection regions at
- * specified positions on the boundary. Connection regions are 0.4x0.4 pseudo-regions
- * that contain one port point connecting them to the grid boundary.
- */
-declare const createGraphWithConnectionsFromBaseGraph: (baseGraph: JumperGraph, xyConnections: XYConnection[]) => JumperGraphWithConnections;
+declare const convertHyperGraphToSerializedHyperGraph: (graph: HyperGraph) => SerializedHyperGraph;
 
 type Node = {
     f: number;
@@ -349,6 +249,23 @@ declare class HyperGraphSolver<RegionType extends Region = Region, RegionPortTyp
      * redundant.
      */
     selectCandidatesForEnteringRegion(candidates: Candidate[]): Candidate[];
+    /**
+     * OPTIONALLY OVERRIDE THIS
+     *
+     * Compute the full set of solved routes that must be ripped to accept
+     * `newlySolvedRoute`. By default this returns all conflicting routes
+     * (always-rip behavior)
+     *
+     * Override this to implement partial ripping, where only a subset of
+     * conflicting routes are removed.
+     */
+    computeRoutesToRip(newlySolvedRoute: SolvedRoute): Set<SolvedRoute>;
+    /**
+     * Returns solved routes that overlap ports with the newly solved route.
+     * Use this in computeRoutesToRip overrides to include port reuse rips.
+     */
+    computePortOverlapRoutes(newlySolvedRoute: SolvedRoute): Set<SolvedRoute>;
+    computeCrossingRoutes(newlySolvedRoute: SolvedRoute): Set<SolvedRoute>;
     getNextCandidates(currentCandidate: CandidateType): CandidateType[];
     processSolvedRoute(finalCandidate: CandidateType): void;
     /**
@@ -375,6 +292,59 @@ declare class HyperGraphSolver<RegionType extends Region = Region, RegionPortTyp
     _step(): void;
 }
 
+type Bounds$1 = {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+
+interface JRegion extends Region {
+    d: {
+        bounds: Bounds$1;
+        center: {
+            x: number;
+            y: number;
+        };
+        polygon?: {
+            x: number;
+            y: number;
+        }[];
+        isPad: boolean;
+        isThroughJumper?: boolean;
+        isConnectionRegion?: boolean;
+        isViaRegion?: boolean;
+    };
+}
+interface JPort extends RegionPort {
+    d: {
+        x: number;
+        y: number;
+    };
+}
+type JumperGraph = {
+    regions: JRegion[];
+    ports: JPort[];
+    jumperLocations?: Array<{
+        center: {
+            x: number;
+            y: number;
+        };
+        orientation: "vertical" | "horizontal";
+        padRegions: JRegion[];
+    }>;
+};
+
+/**
+ * Applies a transformation matrix to all points in a graph.
+ * Transforms region bounds, region centers, and port positions.
+ */
+declare const applyTransformToGraph: (graph: JumperGraph, matrix: Matrix) => JumperGraph;
+/**
+ * Rotates a graph 90 degrees clockwise around its center.
+ */
+declare const rotateGraph90Degrees: (graph: JumperGraph) => JumperGraph;
+
 declare const JUMPER_GRAPH_SOLVER_DEFAULTS: {
     portUsagePenalty: number;
     portUsagePenaltySq: number;
@@ -413,21 +383,69 @@ declare class JumperGraphSolver extends HyperGraphSolver<JRegion, JPort> {
     visualize(): GraphicsObject;
 }
 
-declare const convertHyperGraphToSerializedHyperGraph: (graph: HyperGraph) => SerializedHyperGraph;
-
-declare const convertConnectionsToSerializedConnections: (connections: Connection[]) => SerializedConnection[];
+declare const calculateGraphBounds: (regions: JRegion[]) => Bounds$1;
 
+type XYConnection = {
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    connectionId: string;
+};
+type JumperGraphWithConnections = JumperGraph & {
+    connections: Connection[];
+};
 /**
- * Applies a transformation matrix to all points in a graph.
- * Transforms region bounds, region centers, and port positions.
- */
-declare const applyTransformToGraph: (graph: JumperGraph, matrix: Matrix) => JumperGraph;
-/**
- * Rotates a graph 90 degrees clockwise around its center.
+ * Creates a new graph from a base graph with additional connection regions at
+ * specified positions on the boundary. Connection regions are 0.4x0.4 pseudo-regions
+ * that contain one port point connecting them to the grid boundary.
  */
-declare const rotateGraph90Degrees: (graph: JumperGraph) => JumperGraph;
+declare const createGraphWithConnectionsFromBaseGraph: (baseGraph: JumperGraph, xyConnections: XYConnection[]) => JumperGraphWithConnections;
 
-declare const calculateGraphBounds: (regions: JRegion[]) => Bounds;
+declare const generateJumperGrid: ({ cols, rows, marginX, marginY, innerColChannelPointCount, innerRowChannelPointCount, outerPaddingX, outerPaddingY, outerChannelXPoints, outerChannelYPoints, orientation, }: {
+    cols: number;
+    rows: number;
+    marginX: number;
+    marginY: number;
+    innerColChannelPointCount?: number;
+    innerRowChannelPointCount?: number;
+    outerPaddingX?: number;
+    outerPaddingY?: number;
+    outerChannelXPoints?: number;
+    outerChannelYPoints?: number;
+    orientation?: "vertical" | "horizontal";
+}) => JumperGraph;
+
+declare const generateJumperX4Grid: ({ cols, rows, marginX, marginY, innerColChannelPointCount, innerRowChannelPointCount, regionsBetweenPads, outerPaddingX: outerPaddingXParam, outerPaddingY: outerPaddingYParam, outerChannelXPointCount, outerChannelYPointCount, orientation, center, bounds, parallelTracesUnderJumperCount, }: {
+    cols: number;
+    rows: number;
+    marginX: number;
+    marginY: number;
+    innerColChannelPointCount?: number;
+    innerRowChannelPointCount?: number;
+    regionsBetweenPads?: boolean;
+    outerPaddingX?: number;
+    outerPaddingY?: number;
+    outerChannelXPointCount?: number;
+    outerChannelYPointCount?: number;
+    orientation?: "vertical" | "horizontal";
+    center?: {
+        x: number;
+        y: number;
+    };
+    bounds?: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+    /** Number of trace points that can pass through the jumper body from top to bottom without using jumpers */
+    parallelTracesUnderJumperCount?: number;
+}) => JumperGraph;
 
 type RegionRef = {
     id: string;
@@ -461,7 +479,7 @@ type SharedBoundary = {
 };
 type RegionData = {
     id: string;
-    bounds: Bounds | null;
+    bounds: Bounds$1 | null;
     polygon: {
         x: number;
         y: number;
@@ -502,7 +520,7 @@ declare class RegionBuilder implements RegionRef {
     private data;
     constructor(id: string);
     get id(): string;
-    rect(b: Bounds): this;
+    rect(b: Bounds$1): this;
     polygon(points: {
         x: number;
         y: number;
@@ -531,7 +549,7 @@ declare class ConnectBuilder {
     private portIds;
     private boundary;
     private prefixWasExplicitlySet;
-    constructor(region1Id: string, region2Id: string, bounds1: Bounds, bounds2: Bounds, 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;
     });
@@ -551,7 +569,7 @@ declare class ConnectBuilder {
 
 type ResolveRegionFn = (ref: RegionRef | string) => {
     id: string;
-    bounds: Bounds;
+    bounds: Bounds$1;
 };
 type AddPortFn = (port: PortData) => void;
 declare class PortBuilder {
@@ -607,4 +625,148 @@ declare class Topology {
     getPortIds(): string[];
 }
 
-export { type Bounds, type BuildOpts, type Candidate, ConnectBuilder, type ConnectOpts, type Connection, type ConnectionId, 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 SerializedConnection, type SerializedGraphPort, type SerializedGraphRegion, type SerializedHyperGraph, type SerializedRegionPortAssignment, type SharedBoundary, type SolvedRoute, Topology, TopologyError, type ValidateOpts, type XYConnection, applyTransformToGraph, calculateGraphBounds, convertConnectionsToSerializedConnections, convertHyperGraphToSerializedHyperGraph, createGraphWithConnectionsFromBaseGraph, generateJumperGrid, generateJumperX4Grid, rotateGraph90Degrees };
+declare const VIA_GRAPH_SOLVER_DEFAULTS: {
+    portUsagePenalty: number;
+    portUsagePenaltySq: number;
+    crossingPenalty: number;
+    crossingPenaltySq: number;
+    ripCost: number;
+    greedyMultiplier: number;
+};
+type ViaData$1 = {
+    viaId: string;
+    diameter: number;
+    position: {
+        x: number;
+        y: number;
+    };
+};
+type ViasByNet$1 = Record<string, ViaData$1[]>;
+declare class ViaGraphSolver extends HyperGraphSolver<JRegion, JPort> {
+    getSolverName(): string;
+    UNIT_OF_COST: string;
+    viasByNet?: ViasByNet$1;
+    portUsagePenalty: number;
+    portUsagePenaltySq: number;
+    crossingPenalty: number;
+    crossingPenaltySq: number;
+    ripCost: number;
+    baseMaxIterations: number;
+    additionalMaxIterationsPerConnection: number;
+    additionalMaxIterationsPerCrossing: number;
+    constructor(input: {
+        inputGraph: HyperGraph | SerializedHyperGraph;
+        inputConnections: (Connection | SerializedConnection)[];
+        viasByNet?: ViasByNet$1;
+        ripCost?: number;
+        portUsagePenalty?: number;
+        crossingPenalty?: number;
+        baseMaxIterations?: number;
+        additionalMaxIterationsPerConnection?: number;
+    });
+    private populateDistanceToEndMaps;
+    estimateCostToEnd(port: JPort): number;
+    getPortUsagePenalty(port: JPort): number;
+    computeIncreasedRegionCostIfPortsAreUsed(region: JRegion, port1: JPort, port2: JPort): number;
+    getRipsRequiredForPortUsage(region: JRegion, port1: JPort, port2: JPort): RegionPortAssignment[];
+    routeSolvedHook(solvedRoute: SolvedRoute): void;
+    routeStartedHook(connection: Connection): void;
+    visualize(): GraphicsObject;
+}
+
+type ViaGraphFromXYConnectionsResult = JumperGraph & {
+    connections: Connection[];
+    tiledViasByNet: ViasByNet$1;
+    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 viasByNet - Via positions grouped by net name
+ * @param opts - Optional configuration (tileSize defaults to 5mm, portPitch to 0.4mm)
+ */
+declare function createViaGraphFromXYConnections(xyConnections: XYConnection[], viasByNet: ViasByNet$1, opts?: {
+    tileSize?: number;
+    portPitch?: number;
+}): ViaGraphFromXYConnectionsResult;
+
+type ViaGraphWithConnections = JumperGraph & {
+    connections: Connection[];
+};
+/**
+ * Creates a new graph from a via topology base graph with additional connection
+ * regions at specified positions on the boundary.
+ *
+ * Uses polygon-edge proximity (not bounding-box proximity) to find the correct
+ * boundary region for each connection endpoint. This is necessary because the
+ * via topology's polygon regions have overlapping bounding boxes.
+ */
+declare const createViaGraphWithConnections: (baseGraph: JumperGraph, xyConnections: XYConnection[]) => ViaGraphWithConnections;
+
+type Bounds = {
+    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: {
+    viasByNet: ViasByNet$1;
+    bounds: Bounds;
+    tileSize?: number;
+    portPitch?: number;
+}): {
+    regions: JRegion[];
+    ports: JPort[];
+    tiledViasByNet: ViasByNet$1;
+    tileCount: {
+        rows: number;
+        cols: number;
+    };
+};
+
+type ViaData = {
+    viaId: string;
+    diameter: number;
+    position: {
+        x: number;
+        y: number;
+    };
+};
+type ViasByNet = Record<string, ViaData[]>;
+/**
+ * Generates four outer topology regions (top, bottom, left, right) that wrap
+ * around all vias, forming a closed frame that extends to the graph boundary.
+ *
+ * Each region is a polygon whose inner edge follows the extreme via edges
+ * (connected by straight diagonal lines between segments), and whose outer
+ * edge is the graph boundary.
+ */
+declare const generateViaTopologyRegions: (viasByNet: ViasByNet, opts?: {
+    graphSize?: number;
+    idPrefix?: string;
+}) => {
+    regions: JRegion[];
+    ports: JPort[];
+};
+
+export { type Bounds$1 as Bounds, type BuildOpts, type Candidate, ConnectBuilder, type ConnectOpts, type Connection, type ConnectionId, 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 SerializedConnection, type SerializedGraphPort, type SerializedGraphRegion, type SerializedHyperGraph, type SerializedRegionPortAssignment, type SharedBoundary, type SolvedRoute, Topology, TopologyError, VIA_GRAPH_SOLVER_DEFAULTS, type ValidateOpts, type ViaData$1 as ViaData, type ViaGraphFromXYConnectionsResult, ViaGraphSolver, type ViaGraphWithConnections, type ViasByNet$1 as ViasByNet, type XYConnection, applyTransformToGraph, calculateGraphBounds, convertConnectionsToSerializedConnections, convertHyperGraphToSerializedHyperGraph, createGraphWithConnectionsFromBaseGraph, createViaGraphFromXYConnections, createViaGraphWithConnections, generateJumperGrid, generateJumperX4Grid, generateViaTopologyGrid, generateViaTopologyRegions, rotateGraph90Degrees };