@tscircuit/capacity-autorouter 0.0.239 → 0.0.241

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import * as graphics_debug from 'graphics-debug';
 import { GraphicsObject, Rect, Circle, Line, Point as Point$5 } from 'graphics-debug';
 import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
 import { RectDiffPipeline } from '@tscircuit/rectdiff';
-import { JumperGraphSolver } from '@tscircuit/hypergraph';
+import { JumperGraphSolver, JRegion } from '@tscircuit/hypergraph';
 import { ConnectivityMap as ConnectivityMap$1 } from 'connectivity-map';
 import { Polygon } from '@tscircuit/math-utils';
 
@@ -27,6 +27,17 @@ type MultiLayerConnectionPoint = {
     pcb_port_id?: string;
 };
 type ConnectionPoint = SingleLayerConnectionPoint | MultiLayerConnectionPoint;
+type Jumper$1 = {
+    jumper_footprint: "0603" | "1206x4";
+    center: {
+        x: number;
+        y: number;
+    };
+    orientation: "horizontal" | "vertical";
+    width: number;
+    height: number;
+    pads: Obstacle[];
+};
 interface SimpleRouteJson {
     layerCount: number;
     minTraceWidth: number;
@@ -46,6 +57,7 @@ interface SimpleRouteJson {
         y: number;
     }>;
     traces?: SimplifiedPcbTraces;
+    jumpers?: Jumper$1[];
     allowJumpers?: boolean;
 }
 interface Obstacle {
@@ -244,6 +256,7 @@ type HighDensityIntraNodeRoute$1 = {
         x: number;
         y: number;
         z: number;
+        insideJumperPad?: boolean;
     }>;
     vias: Array<{
         x: number;
@@ -1827,7 +1840,11 @@ interface CreatePortPointSectionInput {
     connectionResults?: ConnectionPathResult[];
 }
 
+type HyperParameterScheduleEntry = PortPointPathingHyperParameters & {
+    EXPANSION_DEGREES: number;
+};
 interface MultiSectionPortPointOptimizerParams {
+    JUMPER_PF_FN_ENABLED?: boolean;
     simpleRouteJson: SimpleRouteJson;
     inputNodes: InputNodeWithPortPoints[];
     capacityMeshNodes: CapacityMeshNode[];
@@ -1853,6 +1870,21 @@ interface MultiSectionPortPointOptimizerParams {
      * even if they would otherwise be kept due to FRACTION_TO_REPLACE.
      */
     ALWAYS_RIP_INTERSECTIONS?: boolean;
+    /**
+     * Maximum number of attempts to fix a single node before moving on.
+     * Default is 100.
+     */
+    MAX_ATTEMPTS_PER_NODE?: number;
+    /**
+     * Maximum total number of section optimization attempts.
+     * Default is 500.
+     */
+    MAX_SECTION_ATTEMPTS?: number;
+    /**
+     * Custom hyperparameter schedule for optimization.
+     * Each entry defines parameters for one optimization attempt.
+     */
+    HYPERPARAMETER_SCHEDULE?: HyperParameterScheduleEntry[];
 }
 /**
  * MultiSectionPortPointOptimizer runs local optimization on sections of the
@@ -1907,6 +1939,7 @@ declare class MultiSectionPortPointOptimizer extends BaseSolver {
      * Default 1 means rip all connections. Values less than 1 keep some traces.
      */
     FRACTION_TO_REPLACE: number;
+    JUMPER_PF_FN_ENABLED: boolean;
     /**
      * If true, always rip connections that have same-layer intersections,
      * even if they would otherwise be kept due to FRACTION_TO_REPLACE.
@@ -1917,6 +1950,8 @@ declare class MultiSectionPortPointOptimizer extends BaseSolver {
      */
     ALWAYS_RIP_INTERSECTIONS: boolean;
     effort: number;
+    /** Hyperparameter schedule for optimization attempts */
+    HYPERPARAMETER_SCHEDULE: HyperParameterScheduleEntry[];
     constructor(params: MultiSectionPortPointOptimizerParams);
     /**
      * Compute initial Pf map for all nodes
@@ -1926,6 +1961,11 @@ declare class MultiSectionPortPointOptimizer extends BaseSolver {
      * Compute the score for the ENTIRE board (all nodes with port points).
      */
     computeBoardScore(): number;
+    /**
+     * Compute score for a set of nodes, using the appropriate scoring function
+     * based on JUMPER_PF_FN_ENABLED.
+     */
+    computeScoreForNodes(nodesWithPortPoints: NodeWithPortPoints[]): number;
     /**
      * Recompute Pf for nodes in a section
      */
@@ -3036,7 +3076,16 @@ declare class JumperPrepatternSolver2_HyperGraph extends BaseSolver {
         minY: number;
         maxY: number;
     } | null;
+    jumperLocations: Array<{
+        center: {
+            x: number;
+            y: number;
+        };
+        orientation: "vertical" | "horizontal";
+        padRegions: JRegion[];
+    }>;
     solvedRoutes: HighDensityIntraNodeRouteWithJumpers[];
+    jumpers: Jumper$1[];
     constructor(params: JumperPrepatternSolver2Params);
     getConstructorParams(): JumperPrepatternSolver2Params;
     private _buildColorMap;
@@ -3044,7 +3093,26 @@ declare class JumperPrepatternSolver2_HyperGraph extends BaseSolver {
     private _initializeGraph;
     _step(): void;
     private _processResults;
+    /**
+     * Post-process routes to add offset midpoints for collinear overlapping segments.
+     *
+     * When two segments are collinear and overlap (arranged as A-C-D-B where AB
+     * is one segment and CD is another), the outer segment (AB) needs a midpoint
+     * pushed to the side to hint to the force-directed graph that it should route
+     * around the inner segment.
+     *
+     * This handles both:
+     * 1. Segments from different connections that overlap
+     * 2. Segments from the SAME connection that overlap (when a route doubles back)
+     */
+    private _addMidpointsForCollinearOverlaps;
     getOutput(): HighDensityIntraNodeRouteWithJumpers[];
+    /**
+     * Returns all jumpers from the baseGraph as SRJ Jumper objects.
+     * The pads have connectedTo set based on which routes use each jumper.
+     * Must be called after the solver is solved.
+     */
+    getOutputJumpers(): Jumper$1[];
     visualize(): GraphicsObject;
     private _drawJumperPads;
 }
@@ -3078,6 +3146,7 @@ declare class HyperJumperPrepatternSolver2 extends HyperParameterSupervisorSolve
     connMap?: ConnectivityMap;
     baseHyperParameters?: JumperPrepatternSolver2HyperParameters;
     solvedRoutes: HighDensityIntraNodeRouteWithJumpers[];
+    jumpers: Jumper$1[];
     constructor(params: HyperJumperPrepatternSolver2Params);
     getConstructorParams(): HyperJumperPrepatternSolver2Params;
     getHyperParameterDefs(): ({
@@ -3097,6 +3166,7 @@ declare class HyperJumperPrepatternSolver2 extends HyperParameterSupervisorSolve
     computeH(solver: JumperPrepatternSolver2_HyperGraph): number;
     onSolve(solver: SupervisedSolver<JumperPrepatternSolver2_HyperGraph>): void;
     getOutput(): HighDensityIntraNodeRouteWithJumpers[];
+    getOutputJumpers(): Jumper$1[];
     visualize(): GraphicsObject;
 }
 
@@ -3127,6 +3197,7 @@ declare class JumperHighDensitySolver extends BaseSolver {
     jumperSolvers: HyperJumperPrepatternSolver2[];
     currentJumperSolverIndex: number;
     phase: "analyzing" | "simple" | "jumpers" | "done";
+    jumpers: Jumper$1[];
     constructor({ nodePortPoints, colorMap, traceWidth, viaDiameter, connMap, hyperParameters, }: {
         nodePortPoints: NodeWithPortPoints[];
         colorMap?: Record<string, string>;
@@ -3152,6 +3223,13 @@ declare class JumperHighDensitySolver extends BaseSolver {
         connMap: ConnectivityMap | undefined;
         hyperParameters: Partial<HighDensityHyperParameters> | undefined;
     };
+    /**
+     * Returns ALL jumpers collected from the jumper solvers.
+     * These include all jumpers placed in the grid (from baseGraph.jumperLocations),
+     * not just the ones used by routes. The pads have connectedTo set based on
+     * which routes use each jumper.
+     */
+    getOutputJumpers(): Jumper$1[];
     visualize(): GraphicsObject;
 }
 
@@ -3193,6 +3271,7 @@ type HighDensityIntraNodeRoute = {
         x: number;
         y: number;
         z: number;
+        insideJumperPad?: boolean;
     }>;
     vias: Array<{
         x: number;
@@ -3247,10 +3326,13 @@ interface Point2D$1 {
 }
 interface Point3D$1 extends Point2D$1 {
     z: number;
+    insideJumperPad?: boolean;
 }
 interface TraceKeepoutSolverInput {
     hdRoutes: HighDensityRoute$1[];
     obstacles: Obstacle[];
+    /** SRJ Jumpers with pre-computed pad obstacles. These will be added to the obstacle index. */
+    jumpers?: Jumper$1[];
     connMap: ConnectivityMap;
     colorMap: Record<string, string>;
     keepoutRadiusSchedule?: number[];
@@ -3284,16 +3366,38 @@ declare class TraceKeepoutSolver extends BaseSolver {
     currentTraceSegmentT: number;
     recordedDrawPositions: Point3D$1[];
     lastCollidingSegments: Segment[];
+    /** Maps segment index to the jumper that occupies that segment */
+    currentTraceJumperSegments: Map<number, Jumper>;
     obstacleSHI: ObstacleSpatialHashIndex;
     hdRouteSHI: HighDensityRouteSpatialIndex;
     boardOutlineRoutes: HighDensityRoute$1[];
     constructor(input: TraceKeepoutSolverInput);
     getSmoothDistance(): number;
+    /**
+     * Extracts pad obstacles from the passed-in SRJ jumpers.
+     * The pads already have connectedTo set based on which routes use each jumper.
+     */
+    private getJumperPadObstacles;
+    /**
+     * Builds a map from segment index to the jumper that occupies that segment.
+     * A segment is considered a jumper segment if it connects points near the
+     * jumper's start and end positions.
+     *
+     * Uses a larger tolerance for matching because routes may be modified during
+     * collision avoidance passes, but we still need to find the segment that
+     * represents each jumper.
+     */
+    private buildJumperSegmentMap;
     _step(): void;
     getStepDistance(): number;
+    /**
+     * Check if we're about to enter a jumper segment.
+     * Returns the jumper if we're at the start of a jumper segment (T=0), null otherwise.
+     */
+    private getJumperAtCurrentSegmentStart;
     /**
      * Steps the cursor forward by CURSOR_STEP_DISTANCE along the trace
-     * Returns false if we've reached the end of the trace
+     * Returns: "stepped" if normal step, "end" if reached end, "jumper" if crossed a jumper
      */
     private stepCursorForward;
     /**
@@ -3305,12 +3409,22 @@ declare class TraceKeepoutSolver extends BaseSolver {
         y: number;
         z: number;
     }, margin?: number): boolean;
+    /**
+     * Checks if a new segment would intersect with any route from unprocessedRoutes,
+     * smoothedCursorRoutes, or processedRoutes (excluding routes with the same connection name).
+     */
+    private segmentIntersectsOtherRoutes;
     /**
      * Finalizes the current trace with the recorded draw positions
      */
     private finalizeCurrentTrace;
     /**
-     * Simplifies the route by removing collinear points
+     * Checks if a point is a jumper endpoint.
+     */
+    private isJumperEndpoint;
+    /**
+     * Simplifies the route by removing collinear points, but preserves
+     * jumper endpoints which must remain fixed.
      */
     private simplifyRoute;
     /**
@@ -3366,9 +3480,6 @@ declare class TraceWidthSolver extends BaseSolver {
     currentScheduleIndex: number;
     currentTargetWidth: number;
     hasInsufficientClearance: boolean;
-    currentWalkMinClearance: number;
-    bestMinClearance: number;
-    bestWidth: number;
     lastCollidingObstacles: Obstacle[];
     lastCollidingRoutes: HighDensityRoute$1[];
     lastClearance: number;
@@ -3386,8 +3497,14 @@ declare class TraceWidthSolver extends BaseSolver {
     /**
      * Steps the cursor forward by CURSOR_STEP_DISTANCE along the trace
      * Returns false if we've reached the end of the trace
+     * Skips segments where both endpoints are inside jumper pads
      */
     private stepCursorForward;
+    /**
+     * Checks if an obstacle is a jumper pad belonging to the current trace's jumpers.
+     * This is needed because jumper pads may not have connectedTo set properly.
+     */
+    private isObstacleOwnJumperPad;
     /**
      * Gets the minimum clearance at a given position from obstacles and other traces
      * Also updates lastCollidingObstacles and lastCollidingRoutes for visualization