@tscircuit/capacity-autorouter 0.0.249 → 0.0.251

package/dist/index.d.ts

@@ -2,7 +2,8 @@ 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, JRegion } from '@tscircuit/hypergraph';
+import { JumperGraphSolver, JRegion, JPort } from '@tscircuit/hypergraph';
+import { CurvyTraceSolver } from '@tscircuit/curvy-trace-solver';
 import { ConnectivityMap as ConnectivityMap$1 } from 'connectivity-map';
 import { Polygon } from '@tscircuit/math-utils';
 
@@ -3039,10 +3040,11 @@ declare class SimpleHighDensitySolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-type HyperGraphPatternType = "single_1206x4" | "1x2_1206x4" | "2x2_1206x4" | "3x1_1206x4" | "3x2_1206x4" | "3x3_1206x4" | "4x4_1206x4" | "6x4_1206x4" | "8x4_1206x4";
 interface JumperPrepatternSolver2HyperParameters {
-    /** Pattern type for jumper placement - "single_1206x4" (~8x8mm) or "2x2_1206x4" (~14x14mm) */
-    PATTERN_TYPE?: HyperGraphPatternType;
+    /** Number of columns in the jumper grid */
+    COLS?: number;
+    /** Number of rows in the jumper grid */
+    ROWS?: number;
     /** Orientation of jumpers - "horizontal" or "vertical" */
     ORIENTATION?: "horizontal" | "vertical";
 }
@@ -3088,26 +3090,60 @@ declare class JumperPrepatternSolver2_HyperGraph extends BaseSolver {
     }>;
     solvedRoutes: HighDensityIntraNodeRouteWithJumpers[];
     jumpers: Jumper$1[];
+    phase: "jumperGraph" | "curvyTrace" | "done";
+    curvySolvers: Array<{
+        solver: CurvyTraceSolver;
+        regionId: string;
+        traversals: Array<{
+            routeIndex: number;
+            connectionName: string;
+            rootConnectionName?: string;
+        }>;
+    }>;
+    currentCurvySolverIndex: number;
+    routeInfos: Array<{
+        connectionId: string;
+        rootConnectionName?: string;
+        jumpers: Jumper[];
+        traversals: Array<{
+            regionId: string;
+            region: JRegion;
+            entryPort: JPort;
+            exitPort: JPort | null;
+        }>;
+    }>;
+    regionCurvedPaths: Map<string, Map<string, Array<{
+        path: Array<{
+            x: number;
+            y: number;
+        }>;
+        start: {
+            x: number;
+            y: number;
+        };
+        end: {
+            x: number;
+            y: number;
+        };
+    }>>>;
     constructor(params: JumperPrepatternSolver2Params);
     getConstructorParams(): JumperPrepatternSolver2Params;
     private _buildColorMap;
     private _getPatternConfig;
     private _initializeGraph;
     _step(): void;
-    private _processResults;
+    private _stepJumperGraph;
+    private _stepCurvyTrace;
     /**
-     * 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)
+     * Initialize CurvyTraceSolvers for each routing region.
+     * Called after JumperGraphSolver completes to set up the curvy trace phase.
+     */
+    private _initializeCurvyTraceSolvers;
+    /**
+     * Finalize results after all CurvyTraceSolvers have completed.
+     * Assembles final routes using curved paths where available.
      */
-    private _addMidpointsForCollinearOverlaps;
+    private _finalizeCurvyTraceResults;
     getOutput(): HighDensityIntraNodeRouteWithJumpers[];
     /**
      * Returns all jumpers from the baseGraph as SRJ Jumper objects.
@@ -3127,7 +3163,8 @@ interface HyperJumperPrepatternSolver2Params {
     hyperParameters?: JumperPrepatternSolver2HyperParameters;
 }
 type VariantHyperParameters = {
-    PATTERN_TYPE: HyperGraphPatternType;
+    COLS: number;
+    ROWS: number;
     ORIENTATION: "horizontal" | "vertical";
 };
 /**
@@ -3154,7 +3191,12 @@ declare class HyperJumperPrepatternSolver2 extends HyperParameterSupervisorSolve
     getHyperParameterDefs(): ({
         name: string;
         possibleValues: {
-            PATTERN_TYPE: HyperGraphPatternType;
+            COLS: number;
+        }[];
+    } | {
+        name: string;
+        possibleValues: {
+            ROWS: number;
         }[];
     } | {
         name: string;
@@ -3172,6 +3214,44 @@ declare class HyperJumperPrepatternSolver2 extends HyperParameterSupervisorSolve
     visualize(): GraphicsObject;
 }
 
+interface AdjacentObstacle {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    networkId?: string;
+}
+interface CurvyIntraNodeSolverParams {
+    nodeWithPortPoints: NodeWithPortPoints;
+    colorMap?: Record<string, string>;
+    traceWidth?: number;
+    viaDiameter?: number;
+    /** Obstacles from adjacent/solved nodes that might affect routing */
+    adjacentObstacles?: AdjacentObstacle[];
+}
+/**
+ * A solver that uses CurvyTraceSolver to create curved traces within a node.
+ * It converts port points to waypoint pairs and generates smooth curved traces
+ * that maximize distance between traces and obstacles.
+ */
+declare class CurvyIntraNodeSolver extends BaseSolver {
+    nodeWithPortPoints: NodeWithPortPoints;
+    colorMap: Record<string, string>;
+    traceWidth: number;
+    viaDiameter: number;
+    adjacentObstacles: AdjacentObstacle[];
+    routes: HighDensityIntraNodeRoute$1[];
+    curvyTraceSolver?: CurvyTraceSolver;
+    phase: "initializing" | "solving" | "done";
+    constructor(params: CurvyIntraNodeSolverParams);
+    _step(): void;
+    _initializeCurvySolver(): void;
+    _stepCurvySolver(): void;
+    _convertOutputTraces(): void;
+    getConstructorParams(): CurvyIntraNodeSolverParams;
+    visualize(): GraphicsObject;
+}
+
 interface NodeAnalysis {
     node: NodeWithPortPoints;
     hasCrossings: boolean;
@@ -3179,10 +3259,11 @@ interface NodeAnalysis {
 }
 /**
  * HighDensitySolver intelligently selects the appropriate solver for each node:
- * - SimpleHighDensitySolver for nodes without crossings (faster, force-directed)
+ * - CurvyIntraNodeSolver for nodes without crossings (uses curvy trace solver)
  * - IntraNodeSolverWithJumpers for single-layer nodes with crossings (uses 0603 jumpers)
  *
- * This solver processes nodes in batches based on their characteristics.
+ * This solver processes nodes one at a time, passing adjacent obstacles from
+ * already-solved routes to maximize trace spacing.
  */
 declare class JumperHighDensitySolver extends BaseSolver {
     allNodes: NodeWithPortPoints[];
@@ -3193,27 +3274,59 @@ declare class JumperHighDensitySolver extends BaseSolver {
     viaDiameter: number;
     connMap?: ConnectivityMap;
     hyperParameters?: Partial<HighDensityHyperParameters>;
+    capacityMeshNodes: CapacityMeshNode[];
+    capacityMeshEdges: CapacityMeshEdge[];
+    capacityMeshNodeMap: Map<string, CapacityMeshNode>;
+    nodeAdjacencyMap: Map<string, Set<string>>;
     nodesWithoutCrossings: NodeWithPortPoints[];
     nodesWithCrossings: NodeWithPortPoints[];
-    simpleHighDensitySolver?: SimpleHighDensitySolver;
+    curvyIntraNodeSolvers: CurvyIntraNodeSolver[];
+    currentCurvySolverIndex: number;
     jumperSolvers: HyperJumperPrepatternSolver2[];
     currentJumperSolverIndex: number;
-    phase: "analyzing" | "simple" | "jumpers" | "done";
+    phase: "analyzing" | "curvy" | "jumpers" | "done";
     jumpers: Jumper$1[];
-    constructor({ nodePortPoints, colorMap, traceWidth, viaDiameter, connMap, hyperParameters, }: {
+    constructor({ nodePortPoints, colorMap, traceWidth, viaDiameter, connMap, hyperParameters, capacityMeshNodes, capacityMeshEdges, }: {
         nodePortPoints: NodeWithPortPoints[];
         colorMap?: Record<string, string>;
         traceWidth?: number;
         viaDiameter?: number;
         connMap?: ConnectivityMap;
         hyperParameters?: Partial<HighDensityHyperParameters>;
+        capacityMeshNodes?: CapacityMeshNode[];
+        capacityMeshEdges?: CapacityMeshEdge[];
     });
+    /**
+     * Build adjacency map from edges for quick lookup of adjacent nodes
+     */
+    _buildNodeAdjacencyMap(): Map<string, Set<string>>;
     /**
      * Analyze all nodes to determine which solver to use for each
      */
     _analyzeNodes(): void;
     _step(): void;
-    _stepSimpleSolver(): void;
+    /**
+     * Compute obstacles from adjacent nodes.
+     * Uses the edge solver's adjacency information and only considers nodes
+     * that contain obstacles or targets.
+     *
+     * Rules:
+     * - Only adjacent nodes (from edges) are considered
+     * - Only nodes with _containsObstacle or _containsTarget are obstacles
+     * - If node contains obstacle but no target: no networkId
+     * - If node contains target: networkId = _targetConnectionName (or from port points)
+     */
+    _getAdjacentObstacles(node: NodeWithPortPoints): AdjacentObstacle[];
+    /**
+     * Initialize CurvyIntraNodeSolver for each node without crossings.
+     * Each solver is created with adjacent obstacles from already-solved routes.
+     */
+    _initializeCurvySolvers(): void;
+    /**
+     * Step through curvy solvers one at a time.
+     * After each solver completes, its routes become obstacles for subsequent nodes.
+     */
+    _stepCurvySolvers(): void;
     _initializeJumperSolvers(): void;
     _stepJumperSolvers(): void;
     computeProgress(): number;
@@ -3224,6 +3337,8 @@ declare class JumperHighDensitySolver extends BaseSolver {
         viaDiameter: number;
         connMap: ConnectivityMap | undefined;
         hyperParameters: Partial<HighDensityHyperParameters> | undefined;
+        capacityMeshNodes: CapacityMeshNode[];
+        capacityMeshEdges: CapacityMeshEdge[];
     };
     /**
      * Returns ALL jumpers collected from the jumper solvers.
@@ -3790,6 +3905,11 @@ declare class MultipleHighDensityRouteStitchSolver2 extends BaseSolver {
      * Order routes based on the node traversal path.
      * Each node in nodeOrder may have one or more routes.
      * Returns routes in the order they should be stitched.
+     *
+     * Uses a two-phase approach:
+     * 1. Find the route closest to start, build chain forward
+     * 2. From the connection point of first route, build chain backward
+     *    to catch any routes that come before
      */
     private orderRoutesByNodePath;
     /**
@@ -3815,6 +3935,7 @@ declare class AssignableAutoroutingPipeline3 extends BaseSolver {
     srj: SimpleRouteJson;
     opts: CapacityMeshSolverOptions$1;
     netToPointPairsSolver?: NetToPointPairsSolver;
+    traceKeepoutSolver?: TraceKeepoutSolver;
     nodeSolver?: RectDiffPipeline;
     nodeTargetMerger?: CapacityNodeTargetMerger;
     edgeSolver?: CapacityMeshEdgeSolver;
@@ -3830,7 +3951,6 @@ declare class AssignableAutoroutingPipeline3 extends BaseSolver {
     strawSolver?: StrawSolver;
     deadEndSolver?: DeadEndSolver;
     traceSimplificationSolver?: TraceSimplificationSolver;
-    traceKeepoutSolver?: TraceKeepoutSolver;
     traceWidthSolver?: TraceWidthSolver;
     availableSegmentPointSolver?: AvailableSegmentPointSolver;
     portPointPathingSolver?: PortPointPathingSolver;
@@ -3847,7 +3967,7 @@ declare class AssignableAutoroutingPipeline3 extends BaseSolver {
     capacityNodes: CapacityMeshNode[] | null;
     capacityEdges: CapacityMeshEdge[] | null;
     cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep$1<typeof NetToPointPairsSolver> | PipelineStep$1<typeof RectDiffPipeline> | PipelineStep$1<typeof RelateNodesToOffBoardConnectionsSolver> | PipelineStep$1<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$1<typeof AvailableSegmentPointSolver> | PipelineStep$1<typeof HyperPortPointPathingSolver> | PipelineStep$1<typeof MultiSectionPortPointOptimizer> | PipelineStep$1<typeof JumperHighDensitySolver> | PipelineStep$1<typeof MultipleHighDensityRouteStitchSolver2> | PipelineStep$1<typeof TraceKeepoutSolver> | PipelineStep$1<typeof TraceWidthSolver>)[];
+    pipelineDef: (PipelineStep$1<typeof NetToPointPairsSolver> | PipelineStep$1<typeof RectDiffPipeline> | PipelineStep$1<typeof RelateNodesToOffBoardConnectionsSolver> | PipelineStep$1<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$1<typeof AvailableSegmentPointSolver> | PipelineStep$1<typeof HyperPortPointPathingSolver> | PipelineStep$1<typeof JumperHighDensitySolver> | PipelineStep$1<typeof MultipleHighDensityRouteStitchSolver2>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$1);
     getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions$1];
     currentPipelineStepIndex: number;
@@ -5050,4 +5170,4 @@ declare class IntraNodeSolverWithJumpers extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-export { AssignableAutoroutingPipeline1Solver, AssignableAutoroutingPipeline2, AssignableAutoroutingPipeline3, AutoroutingPipeline1_OriginalUnravel, AutoroutingPipelineSolver2_PortPointPathing as AutoroutingPipelineSolver, type AutoroutingPipelineSolverOptions, type CachableSolver, type CacheProvider, CapacityMeshSolver, type HighDensityIntraNodeRouteWithJumpers, JumperHighDensitySolver as HighDensitySolver, InMemoryCache, IntraNodeSolverWithJumpers, type Jumper, LocalStorageCache, SingleHighDensityRouteWithJumpersSolver, calculateOptimalCapacityDepth, convertSrjToGraphicsObject, getGlobalInMemoryCache, getGlobalLocalStorageCache, getTunedTotalCapacity1, setupGlobalCaches };
+export { AssignableAutoroutingPipeline1Solver, AssignableAutoroutingPipeline2, AssignableAutoroutingPipeline3, AutoroutingPipeline1_OriginalUnravel, AutoroutingPipelineSolver2_PortPointPathing as AutoroutingPipelineSolver, type AutoroutingPipelineSolverOptions, type CachableSolver, type CacheProvider, CapacityMeshSolver, CurvyIntraNodeSolver, type HighDensityIntraNodeRouteWithJumpers, JumperHighDensitySolver as HighDensitySolver, InMemoryCache, IntraNodeSolverWithJumpers, type Jumper, LocalStorageCache, SingleHighDensityRouteWithJumpersSolver, calculateOptimalCapacityDepth, convertSrjToGraphicsObject, getGlobalInMemoryCache, getGlobalLocalStorageCache, getTunedTotalCapacity1, setupGlobalCaches };