@tscircuit/capacity-autorouter 0.0.228 → 0.0.229

package/dist/index.d.ts

@@ -32,7 +32,7 @@ interface SimpleRouteJson {
     nominalTraceWidth?: number;
     minViaDiameter?: number;
     defaultObstacleMargin?: number;
-    obstacles: Obstacle[];
+    obstacles: Obstacle$1[];
     connections: Array<SimpleRouteConnection>;
     bounds: {
         minX: number;
@@ -45,8 +45,9 @@ interface SimpleRouteJson {
         y: number;
     }>;
     traces?: SimplifiedPcbTraces;
+    allowJumpers?: boolean;
 }
-interface Obstacle {
+interface Obstacle$1 {
     obstacleId?: string;
     type: "rect";
     layers: string[];
@@ -247,6 +248,7 @@ type HighDensityIntraNodeRoute$1 = {
         x: number;
         y: number;
     }>;
+    jumpers?: Jumper[];
 };
 type HighDensityRoute$1 = HighDensityIntraNodeRoute$1;
 /**
@@ -896,10 +898,10 @@ declare class HighDensitySolver extends BaseSolver {
 declare class CapacityNodeTargetMerger extends BaseSolver {
     nodes: CapacityMeshNode[];
     connMap: ConnectivityMap;
-    unprocessedObstacles: Obstacle[];
+    unprocessedObstacles: Obstacle$1[];
     newNodes: CapacityMeshNode[];
     removedNodeIds: Set<string>;
-    constructor(nodes: CapacityMeshNode[], obstacles: Obstacle[], connMap: ConnectivityMap);
+    constructor(nodes: CapacityMeshNode[], obstacles: Obstacle$1[], connMap: ConnectivityMap);
     _step(): void;
     visualize(): GraphicsObject;
 }
@@ -1176,7 +1178,7 @@ declare class TraceSimplificationSolver extends BaseSolver {
      */
     constructor(simplificationConfig: {
         hdRoutes: HighDensityRoute$1[];
-        obstacles: Obstacle[];
+        obstacles: Obstacle$1[];
         connMap: ConnectivityMap;
         colorMap: Record<string, string>;
         outline?: Array<{
@@ -1328,6 +1330,8 @@ interface PortPointPathingHyperParameters {
     RIPPING_PF_THRESHOLD?: number;
     MAX_RIPS?: number;
     RANDOM_RIP_FRACTION?: number;
+    /** When enabled, use jumper-based pf calculation for same-layer crossings on single layer nodes */
+    JUMPER_PF_FN_ENABLED?: boolean;
 }
 /**
  * An input port point without connectionName assigned yet.
@@ -1419,6 +1423,17 @@ interface ConnectionPathResult {
  *  - prevents node cycles in a candidate chain (keeps Pf math correct without needing per-node multi-visit tracking)
  */
 declare class PortPointPathingSolver extends BaseSolver {
+    input: {
+        simpleRouteJson: SimpleRouteJson;
+        capacityMeshNodes: CapacityMeshNode[];
+        inputNodes: InputNodeWithPortPoints[];
+        colorMap?: Record<string, string>;
+        nodeMemoryPfMap?: Map<CapacityMeshNodeId, number>;
+        hyperParameters?: Partial<PortPointPathingHyperParameters>;
+        precomputedInitialParams?: PrecomputedInitialParams;
+        /** Pre-routed connections that should not be re-routed but should appear in results */
+        fixedRoutes?: ConnectionPathResult[];
+    };
     hyperParameters: Partial<PortPointPathingHyperParameters>;
     simpleRouteJson: SimpleRouteJson;
     inputNodes: InputNodeWithPortPoints[];
@@ -1470,6 +1485,9 @@ declare class PortPointPathingSolver extends BaseSolver {
     get RIPPING_PF_THRESHOLD(): number;
     get MAX_RIPS(): number;
     get RANDOM_RIP_FRACTION(): number;
+    get JUMPER_PF_FN_ENABLED(): boolean;
+    /** Number of jumpers that can fit per mm² of node area */
+    jumpersPerMmSquared: number;
     /** Tracks which connections have been test-ripped for each node to avoid retesting */
     testedRipConnections: Map<CapacityMeshNodeId, Set<string>>;
     /** Tracks total number of connections that have been ripped/requeued */
@@ -1499,7 +1517,7 @@ declare class PortPointPathingSolver extends BaseSolver {
     offBoardNodes: InputNodeWithPortPoints[];
     /** Cache of base node cost (cost of node in current committed state) */
     private baseNodeCostCache;
-    constructor({ simpleRouteJson, inputNodes, capacityMeshNodes, colorMap, nodeMemoryPfMap, hyperParameters, precomputedInitialParams, fixedRoutes, }: {
+    constructor(input: {
         simpleRouteJson: SimpleRouteJson;
         capacityMeshNodes: CapacityMeshNode[];
         inputNodes: InputNodeWithPortPoints[];
@@ -1510,6 +1528,17 @@ declare class PortPointPathingSolver extends BaseSolver {
         /** Pre-routed connections that should not be re-routed but should appear in results */
         fixedRoutes?: ConnectionPathResult[];
     });
+    getConstructorParams(): {
+        simpleRouteJson: SimpleRouteJson;
+        capacityMeshNodes: CapacityMeshNode[];
+        inputNodes: InputNodeWithPortPoints[];
+        colorMap?: Record<string, string>;
+        nodeMemoryPfMap?: Map<CapacityMeshNodeId, number>;
+        hyperParameters?: Partial<PortPointPathingHyperParameters>;
+        precomputedInitialParams?: PrecomputedInitialParams;
+        /** Pre-routed connections that should not be re-routed but should appear in results */
+        fixedRoutes?: ConnectionPathResult[];
+    };
     private clearCostCaches;
     private clampPf;
     /** Convert Pf into an additive "failure cost" */
@@ -1967,7 +1996,7 @@ interface CapacityMeshSolverOptions$3 {
     cacheProvider?: CacheProvider | null;
     effort?: number;
 }
-type PipelineStep$3<T extends new (...args: any[]) => BaseSolver> = {
+type PipelineStep$4<T extends new (...args: any[]) => BaseSolver> = {
     solverName: string;
     solverClass: T;
     getConstructorParams: (instance: AutoroutingPipelineSolver2_PortPointPathing) => ConstructorParameters<T>;
@@ -2002,7 +2031,7 @@ declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
     capacityNodes: CapacityMeshNode[] | null;
     capacityEdges: CapacityMeshEdge[] | null;
     cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep$3<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$3<typeof RectDiffPipeline> | PipelineStep$3<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$3<typeof AvailableSegmentPointSolver> | PipelineStep$3<typeof HyperPortPointPathingSolver> | PipelineStep$3<typeof MultiSectionPortPointOptimizer> | PipelineStep$3<typeof HighDensitySolver> | PipelineStep$3<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$3<typeof TraceSimplificationSolver>)[];
+    pipelineDef: (PipelineStep$4<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$4<typeof RectDiffPipeline> | PipelineStep$4<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$4<typeof AvailableSegmentPointSolver> | PipelineStep$4<typeof HyperPortPointPathingSolver> | PipelineStep$4<typeof MultiSectionPortPointOptimizer> | PipelineStep$4<typeof HighDensitySolver> | PipelineStep$4<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$4<typeof TraceSimplificationSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$3);
     getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions$3];
     currentPipelineStepIndex: number;
@@ -2825,7 +2854,7 @@ interface CapacityMeshSolverOptions$2 {
     targetMinCapacity?: number;
     cacheProvider?: CacheProvider | null;
 }
-type PipelineStep$2<T extends new (...args: any[]) => BaseSolver> = {
+type PipelineStep$3<T extends new (...args: any[]) => BaseSolver> = {
     solverName: string;
     solverClass: T;
     getConstructorParams: (instance: AutoroutingPipeline1_OriginalUnravel) => ConstructorParameters<T>;
@@ -2862,7 +2891,7 @@ declare class AutoroutingPipeline1_OriginalUnravel extends BaseSolver {
     capacityNodes: CapacityMeshNode[] | null;
     capacityEdges: CapacityMeshEdge[] | null;
     cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep$2<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$2<typeof RectDiffPipeline> | PipelineStep$2<typeof StrawSolver> | PipelineStep$2<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$2<typeof DeadEndSolver> | PipelineStep$2<typeof CapacityPathingGreedySolver> | PipelineStep$2<typeof CapacityPathingMultiSectionSolver> | PipelineStep$2<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep$2<typeof CapacitySegmentToPointSolver> | PipelineStep$2<typeof UnravelMultiSectionSolver> | PipelineStep$2<typeof HighDensitySolver> | PipelineStep$2<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$2<typeof TraceSimplificationSolver>)[];
+    pipelineDef: (PipelineStep$3<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$3<typeof RectDiffPipeline> | PipelineStep$3<typeof StrawSolver> | PipelineStep$3<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$3<typeof DeadEndSolver> | PipelineStep$3<typeof CapacityPathingGreedySolver> | PipelineStep$3<typeof CapacityPathingMultiSectionSolver> | PipelineStep$3<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep$3<typeof CapacitySegmentToPointSolver> | PipelineStep$3<typeof UnravelMultiSectionSolver> | PipelineStep$3<typeof HighDensitySolver> | PipelineStep$3<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$3<typeof TraceSimplificationSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$2);
     getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions$2];
     currentPipelineStepIndex: number;
@@ -3378,11 +3407,243 @@ declare class IntraNodeSolverWithJumpers extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+type BucketCoordinate$1 = `${number}x${number}`;
+declare class CapacityNodeTree {
+    nodes: CapacityMeshNode[];
+    buckets: Map<BucketCoordinate$1, CapacityMeshNode[]>;
+    CELL_SIZE: number;
+    constructor(nodes: CapacityMeshNode[]);
+    getBucketKey(x: number, y: number): BucketCoordinate$1;
+    getNodesInArea(centerX: number, centerY: number, width: number, height: number): CapacityMeshNode[];
+}
+
+/**
+ * This solver looks at every obstacle with off board connections (one per step),
+ * then sets _offBoardConnectedCapacityMeshNodeIds on each capacity node that is
+ * mutually connected via off board connections
+ */
+declare class RelateNodesToOffBoardConnectionsSolver extends BaseSolver {
+    input: {
+        capacityMeshNodes: CapacityMeshNode[];
+        srj: SimpleRouteJson;
+    };
+    unprocessedObstacles: Obstacle$1[];
+    nodeTree: CapacityNodeTree;
+    offBoardConnMap: ConnectivityMap$1;
+    nodesInNet: Map<OffBoardConnectionId, CapacityMeshNode[]>;
+    lastProcessedObstacle?: Obstacle$1;
+    constructor(input: {
+        capacityMeshNodes: CapacityMeshNode[];
+        srj: SimpleRouteJson;
+    });
+    _step(): void;
+    getOutput(): {
+        capacityNodes: CapacityMeshNode[];
+    };
+    visualize(): GraphicsObject;
+}
+
+type JumperFootprint = "0603" | "1206";
+
+interface Obstacle {
+    type: "rect";
+    obstacleId: string;
+    layers: string[];
+    center: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    connectedTo: string[];
+    offBoardConnectsTo?: string[];
+}
+interface PrepatternJumper {
+    jumperId: string;
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    footprint: JumperFootprint;
+    offBoardConnectionId: string;
+}
+interface PatternResult {
+    jumperPadObstacles: Obstacle[];
+    prepatternJumpers: PrepatternJumper[];
+}
+
+interface RemoveUnnecessaryJumpersSolverParams {
+    /**
+     * Input nodes from the PortPointPathingSolver
+     */
+    inputNodes: InputNodeWithPortPoints[];
+    /**
+     * Set of jumper off-board connection IDs that were actually used by routes
+     */
+    usedJumperOffBoardObstacleIds: Set<string>;
+    /**
+     * Connectivity map for off-board obstacles (used to check if a jumper net was used)
+     */
+    offBoardConnMap?: ConnectivityMap | null;
+}
+/**
+ * RemoveUnnecessaryJumpersSolver removes jumpers that aren't needed because
+ * there are no traces between the pads. It converts unused jumper nodes back
+ * to regular nodes so the high density solver can route through them normally.
+ *
+ * This solver runs after PortPointPathingSolver and before HighDensitySolver.
+ */
+declare class RemoveUnnecessaryJumpersSolver extends BaseSolver {
+    inputNodes: InputNodeWithPortPoints[];
+    usedJumperOffBoardObstacleIds: Set<string>;
+    offBoardConnMap: ConnectivityMap | null;
+    /**
+     * Output nodes with unused jumper nodes converted to regular nodes
+     */
+    outputNodes: InputNodeWithPortPoints[];
+    /**
+     * Set of off-board connection IDs that were removed
+     */
+    removedOffBoardConnectionIds: Set<string>;
+    constructor(params: RemoveUnnecessaryJumpersSolverParams);
+    /**
+     * Check if a jumper off-board connection ID was used
+     */
+    private isJumperUsed;
+    _step(): void;
+    getOutput(): InputNodeWithPortPoints[];
+    visualize(): GraphicsObject;
+}
+
+type PatternType = "alternating_grid" | "staggered_grid";
+interface JumperPrepatternSolverHyperParameters {
+    /** Orientation of jumpers - "horizontal" or "vertical" */
+    FIRST_ORIENTATION?: "horizontal" | "vertical";
+    /** Jumper footprint size - defaults to "0603" */
+    JUMPER_FOOTPRINT?: JumperFootprint;
+    /** Pattern type for jumper placement - defaults to "alternating_grid" */
+    PATTERN_TYPE?: PatternType;
+}
+interface JumperPrepatternSolverParams {
+    nodeWithPortPoints: NodeWithPortPoints;
+    colorMap?: Record<string, string>;
+    traceWidth?: number;
+    jumperFootprint?: JumperFootprint;
+    hyperParameters?: JumperPrepatternSolverHyperParameters;
+    connMap?: ConnectivityMap;
+}
+type PipelineStep$2<T extends new (...args: any[]) => BaseSolver> = {
+    solverName: string;
+    solverClass: T;
+    getConstructorParams: (instance: JumperPrepatternSolver) => ConstructorParameters<T>;
+    onSolved?: (instance: JumperPrepatternSolver) => void;
+};
+declare class JumperPrepatternSolver extends BaseSolver {
+    nodeWithPortPoints: NodeWithPortPoints;
+    colorMap: Record<string, string>;
+    traceWidth: number;
+    jumperFootprint: JumperFootprint;
+    hyperParameters: JumperPrepatternSolverHyperParameters;
+    connMap: ConnectivityMap;
+    prepatternJumpers: PrepatternJumper[];
+    patternResult: PatternResult | null;
+    capacityNodes: CapacityMeshNode[];
+    capacityEdges: CapacityMeshEdge[];
+    inputNodes: InputNodeWithPortPoints[];
+    connections: SimpleRouteConnection[];
+    srjWithPointPairs: SimpleRouteJson;
+    nodeSolver?: RectDiffPipeline;
+    relateNodesToOffBoardConnections?: RelateNodesToOffBoardConnectionsSolver;
+    edgeSolver?: CapacityMeshEdgeSolver2_NodeTreeOptimization;
+    availableSegmentPointSolver?: AvailableSegmentPointSolver;
+    portPointPathingSolver?: HyperPortPointPathingSolver;
+    multiSectionPortPointOptimizer?: MultiSectionPortPointOptimizer;
+    removeUnnecessaryJumpersSolver?: RemoveUnnecessaryJumpersSolver;
+    highDensitySolver?: SimpleHighDensitySolver;
+    highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
+    activeSubSolver?: BaseSolver | null;
+    currentPipelineStepIndex: number;
+    startTimeOfPhase: Record<string, number>;
+    endTimeOfPhase: Record<string, number>;
+    timeSpentOnPhase: Record<string, number>;
+    solvedRoutes: HighDensityIntraNodeRouteWithJumpers[];
+    usedJumperOffBoardObstacleIds: Set<string>;
+    allUsedJumperOffBoardIds: Set<string>;
+    offBoardConnMap: ConnectivityMap | null;
+    pipelineDef: (PipelineStep$2<typeof RectDiffPipeline> | PipelineStep$2<typeof RelateNodesToOffBoardConnectionsSolver> | PipelineStep$2<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$2<typeof AvailableSegmentPointSolver> | PipelineStep$2<typeof HyperPortPointPathingSolver> | PipelineStep$2<typeof RemoveUnnecessaryJumpersSolver> | PipelineStep$2<typeof SimpleHighDensitySolver> | PipelineStep$2<typeof MultipleHighDensityRouteStitchSolver>)[];
+    constructor(params: JumperPrepatternSolverParams);
+    getCurrentStageName(): string;
+    _step(): void;
+    getCurrentPhase(): string;
+    _createSimpleRouteJson(): SimpleRouteJson;
+    _createJumperPadObstacles(): SimpleRouteJson["obstacles"];
+    _addPortPointObstacles(obstacles: SimpleRouteJson["obstacles"]): void;
+    _combineResults(): void;
+    /**
+     * Get all used jumpers converted to the Jumper type format
+     */
+    _getUsedJumpers(): Jumper[];
+    getOutput(): HighDensityIntraNodeRouteWithJumpers[];
+    /**
+     * Draw the two pads of a jumper
+     */
+    private _drawJumperPads;
+    visualize(): GraphicsObject;
+}
+
+type JumperSolver = IntraNodeSolverWithJumpers | JumperPrepatternSolver;
+declare class HyperIntraNodeSolverWithJumpers extends HyperParameterSupervisorSolver<JumperSolver> {
+    constructorParams: ConstructorParameters<typeof IntraNodeSolverWithJumpers>[0];
+    solvedRoutes: HighDensityIntraNodeRouteWithJumpers[];
+    nodeWithPortPoints: NodeWithPortPoints;
+    connMap?: ConnectivityMap;
+    constructor(opts: ConstructorParameters<typeof IntraNodeSolverWithJumpers>[0]);
+    getConstructorParams(): {
+        nodeWithPortPoints: NodeWithPortPoints;
+        colorMap?: Record<string, string>;
+        hyperParameters?: Partial<HighDensityHyperParameters>;
+        connMap?: ConnectivityMap;
+        traceWidth?: number;
+    };
+    getHyperParameterDefs(): ({
+        name: string;
+        possibleValues: {
+            SHUFFLE_SEED: number;
+        }[];
+    } | {
+        name: string;
+        possibleValues: Array<{
+            USE_JUMPER_PREPATTERN: true;
+        } & JumperPrepatternSolverHyperParameters>;
+    } | {
+        name: string;
+        possibleValues: {
+            USE_JUMPER_PREPATTERN: boolean;
+            FIRST_ORIENTATION: string;
+            PATTERN_TYPE: string;
+        }[];
+    })[];
+    getCombinationDefs(): string[][];
+    _step(): void;
+    computeG(solver: JumperSolver): number;
+    computeH(solver: JumperSolver): number;
+    generateSolver(hyperParameters: Partial<HighDensityHyperParameters> & {
+        USE_JUMPER_PREPATTERN?: boolean;
+        FIRST_ORIENTATION?: "horizontal" | "vertical";
+        PATTERN_TYPE?: "alternating_grid" | "staggered_grid";
+    }): JumperSolver;
+    onSolve(solver: SupervisedSolver<JumperSolver>): void;
+    visualize(): GraphicsObject;
+}
+
 interface NodeAnalysis {
     node: NodeWithPortPoints;
     hasCrossings: boolean;
     numSameLayerCrossings: number;
-    isSingleLayer: boolean;
 }
 /**
  * HighDensitySolver intelligently selects the appropriate solver for each node:
@@ -3394,9 +3655,7 @@ interface NodeAnalysis {
 declare class JumperHighDensitySolver extends BaseSolver {
     allNodes: NodeWithPortPoints[];
     nodeAnalyses: NodeAnalysis[];
-    routes: (HighDensityIntraNodeRoute$1 & {
-        jumpers?: HighDensityIntraNodeRouteWithJumpers["jumpers"];
-    })[];
+    routes: HighDensityIntraNodeRoute$1[];
     colorMap: Record<string, string>;
     traceWidth: number;
     viaDiameter: number;
@@ -3405,7 +3664,7 @@ declare class JumperHighDensitySolver extends BaseSolver {
     nodesWithoutCrossings: NodeWithPortPoints[];
     nodesWithCrossings: NodeWithPortPoints[];
     simpleHighDensitySolver?: SimpleHighDensitySolver;
-    jumperSolvers: IntraNodeSolverWithJumpers[];
+    jumperSolvers: HyperIntraNodeSolverWithJumpers[];
     currentJumperSolverIndex: number;
     phase: "analyzing" | "simple" | "jumpers" | "done";
     constructor({ nodePortPoints, colorMap, traceWidth, viaDiameter, connMap, hyperParameters, }: {
@@ -3445,15 +3704,15 @@ declare class JumperHighDensitySolver extends BaseSolver {
 declare class ObstacleSpatialHashIndex {
     private idx;
     private storage;
-    constructor(implementation?: "native" | "rbush" | "flatbush", obstacles?: Obstacle[]);
-    insert(o: Obstacle): void;
+    constructor(implementation?: "native" | "rbush" | "flatbush", obstacles?: Obstacle$1[]);
+    insert(o: Obstacle$1): void;
     search(bbox: {
         minX: number;
         minY: number;
         maxX: number;
         maxY: number;
-    }): Obstacle[];
-    searchArea(centerX: number, centerY: number, width: number, height: number): Obstacle[];
+    }): Obstacle$1[];
+    searchArea(centerX: number, centerY: number, width: number, height: number): Obstacle$1[];
 }
 
 interface Point$1 {
@@ -3479,6 +3738,7 @@ type HighDensityIntraNodeRoute = {
         x: number;
         y: number;
     }>;
+    jumpers?: Jumper[];
 };
 type HighDensityRoute = HighDensityIntraNodeRoute;
 declare class HighDensityRouteSpatialIndex {
@@ -3530,7 +3790,7 @@ interface Point3D$1 extends Point2D$1 {
 }
 interface TraceKeepoutSolverInput {
     hdRoutes: HighDensityRoute$1[];
-    obstacles: Obstacle[];
+    obstacles: Obstacle$1[];
     connMap: ConnectivityMap;
     colorMap: Record<string, string>;
     keepoutRadiusSchedule?: number[];
@@ -3612,7 +3872,7 @@ interface Point3D extends Point2D {
 }
 interface TraceWidthSolverInput {
     hdRoutes: HighDensityRoute$1[];
-    obstacles?: Obstacle[];
+    obstacles?: Obstacle$1[];
     connMap?: ConnectivityMap;
     colorMap?: Record<string, string>;
     nominalTraceWidth?: number;
@@ -3649,10 +3909,10 @@ declare class TraceWidthSolver extends BaseSolver {
     currentWalkMinClearance: number;
     bestMinClearance: number;
     bestWidth: number;
-    lastCollidingObstacles: Obstacle[];
+    lastCollidingObstacles: Obstacle$1[];
     lastCollidingRoutes: HighDensityRoute$1[];
     lastClearance: number;
-    obstacles: Obstacle[];
+    obstacles: Obstacle$1[];
     obstacleSHI?: ObstacleSpatialHashIndex;
     hdRouteSHI: HighDensityRouteSpatialIndex;
     connMap?: ConnectivityMap;
@@ -3738,7 +3998,7 @@ declare class PortPointOffboardPathFragmentSolver extends BaseSolver {
     currentObstacleIndex: number;
     /** Obstacles that have offBoardConnectsTo defined */
     offboardObstacles: Array<{
-        obstacle: Obstacle;
+        obstacle: Obstacle$1;
         index: number;
     }>;
     /** Port points created at obstacle centers */
@@ -3755,7 +4015,7 @@ declare class PortPointOffboardPathFragmentSolver extends BaseSolver {
     currentFragmentIndex: number;
     /** Last processed obstacle (for visualization) */
     lastProcessedObstacle: {
-        obstacle: Obstacle;
+        obstacle: Obstacle$1;
         index: number;
     } | null;
     /** Last created port point (for visualization) */
@@ -3777,42 +4037,6 @@ declare class PortPointOffboardPathFragmentSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-type BucketCoordinate$1 = `${number}x${number}`;
-declare class CapacityNodeTree {
-    nodes: CapacityMeshNode[];
-    buckets: Map<BucketCoordinate$1, CapacityMeshNode[]>;
-    CELL_SIZE: number;
-    constructor(nodes: CapacityMeshNode[]);
-    getBucketKey(x: number, y: number): BucketCoordinate$1;
-    getNodesInArea(centerX: number, centerY: number, width: number, height: number): CapacityMeshNode[];
-}
-
-/**
- * This solver looks at every obstacle with off board connections (one per step),
- * then sets _offBoardConnectedCapacityMeshNodeIds on each capacity node that is
- * mutually connected via off board connections
- */
-declare class RelateNodesToOffBoardConnectionsSolver extends BaseSolver {
-    input: {
-        capacityMeshNodes: CapacityMeshNode[];
-        srj: SimpleRouteJson;
-    };
-    unprocessedObstacles: Obstacle[];
-    nodeTree: CapacityNodeTree;
-    offBoardConnMap: ConnectivityMap$1;
-    nodesInNet: Map<OffBoardConnectionId, CapacityMeshNode[]>;
-    lastProcessedObstacle?: Obstacle;
-    constructor(input: {
-        capacityMeshNodes: CapacityMeshNode[];
-        srj: SimpleRouteJson;
-    });
-    _step(): void;
-    getOutput(): {
-        capacityNodes: CapacityMeshNode[];
-    };
-    visualize(): GraphicsObject;
-}
-
 interface CapacityMeshSolverOptions$1 {
     capacityDepth?: number;
     targetMinCapacity?: number;
@@ -4057,7 +4281,7 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
     opts: CapacityMeshNodeSolverOptions$2;
     unfinishedNodes: CapacityMeshNode[];
     finishedNodes: CapacityMeshNode[];
-    nodeToXYOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle[]>;
+    nodeToXYOverlappingObstaclesMap: Map<CapacityMeshNodeId, Obstacle$1[]>;
     layerCount: number;
     protected outlinePolygon?: Polygon;
     MAX_DEPTH: number;
@@ -4084,8 +4308,8 @@ declare class CapacityMeshNodeSolver extends BaseSolver {
     getNextNodeId(): string;
     getCapacityFromDepth(depth: number): number;
     getTargetIfNodeContainsTarget(node: CapacityMeshNode): Target | null;
-    getXYOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
-    getXYZOverlappingObstacles(node: CapacityMeshNode): Obstacle[];
+    getXYOverlappingObstacles(node: CapacityMeshNode): Obstacle$1[];
+    getXYZOverlappingObstacles(node: CapacityMeshNode): Obstacle$1[];
     /**
      * Checks if the given mesh node overlaps with any obstacle.
      * We treat both obstacles and nodes as axis‐aligned rectangles.
@@ -4225,8 +4449,8 @@ declare class SingleLayerNodeMergerSolver_OnlyMergeTargets extends BaseSolver {
  */
 declare class AssignableViaNodeMergerSolver extends BaseSolver {
     newNodes: CapacityMeshNode[];
-    obstacleToNodesMap: Map<Obstacle, CapacityMeshNode[]>;
-    obstaclesToProcess: Obstacle[];
+    obstacleToNodesMap: Map<Obstacle$1, CapacityMeshNode[]>;
+    obstaclesToProcess: Obstacle$1[];
     mergedNodeIds: Set<CapacityMeshNodeId>;
     constructor(nodes: CapacityMeshNode[]);
     _step(): void;
@@ -4245,7 +4469,7 @@ declare class SingleSimplifiedPathSolver extends BaseSolver {
     tailIndex: number;
     inputRoute: HighDensityIntraNodeRoute$1;
     otherHdRoutes: HighDensityIntraNodeRoute$1[];
-    obstacles: Obstacle[];
+    obstacles: Obstacle$1[];
     connMap: ConnectivityMap;
     colorMap: Record<string, string>;
     outline?: Array<{
@@ -4255,7 +4479,7 @@ declare class SingleSimplifiedPathSolver extends BaseSolver {
     constructor(params: {
         inputRoute: HighDensityIntraNodeRoute$1;
         otherHdRoutes: HighDensityIntraNodeRoute$1[];
-        obstacles: Obstacle[];
+        obstacles: Obstacle$1[];
         connMap: ConnectivityMap;
         colorMap: Record<string, string>;
         outline?: Array<{
@@ -4266,7 +4490,7 @@ declare class SingleSimplifiedPathSolver extends BaseSolver {
     getConstructorParams(): {
         inputRoute: HighDensityIntraNodeRoute$1;
         otherHdRoutes: HighDensityIntraNodeRoute$1[];
-        obstacles: Obstacle[];
+        obstacles: Obstacle$1[];
         connMap: Record<string, string[]>;
         colorMap: Record<string, string>;
         outline: {
@@ -4285,7 +4509,7 @@ declare class MultiSimplifiedPathSolver extends BaseSolver {
     currentUnsimplifiedHdRouteIndex: number;
     activeSubSolver: SingleSimplifiedPathSolver | null;
     unsimplifiedHdRoutes: HighDensityIntraNodeRoute$1[];
-    obstacles: Obstacle[];
+    obstacles: Obstacle$1[];
     connMap: ConnectivityMap;
     colorMap: Record<string, string>;
     outline?: Array<{
@@ -4295,7 +4519,7 @@ declare class MultiSimplifiedPathSolver extends BaseSolver {
     defaultViaDiameter: number;
     constructor(params: {
         unsimplifiedHdRoutes: HighDensityIntraNodeRoute$1[];
-        obstacles: Obstacle[];
+        obstacles: Obstacle$1[];
         connMap?: ConnectivityMap;
         colorMap?: Record<string, string>;
         outline?: Array<{
@@ -4350,7 +4574,7 @@ declare class SingleRouteUselessViaRemovalSolver extends BaseSolver {
 
 interface UselessViaRemovalSolverInput {
     unsimplifiedHdRoutes: HighDensityRoute$1[];
-    obstacles: Obstacle[];
+    obstacles: Obstacle$1[];
     colorMap: Record<string, string>;
     layerCount: number;
 }