@tscircuit/capacity-autorouter 0.0.193 → 0.0.194

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import * as graphics_debug from 'graphics-debug';
 import { GraphicsObject, Rect, Circle, Line, Point as Point$3 } from 'graphics-debug';
 import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
 import { RectDiffPipeline } from '@tscircuit/rectdiff';
+import { ConnectivityMap as ConnectivityMap$1 } from 'connectivity-map';
 import { Polygon } from '@tscircuit/math-utils';
 
 type TraceId = string;
@@ -949,7 +950,7 @@ declare class NetToPointPairsSolver2_OffBoardConnection extends NetToPointPairsS
     _step(): void;
 }
 
-type Phase = "via_removal" | "via_merging" | "path_simplification";
+type Phase$1 = "via_removal" | "via_merging" | "path_simplification";
 /**
  * TraceSimplificationSolver consolidates trace optimization by iteratively applying
  * via removal, via merging, and path simplification phases. It reduces redundant vias
@@ -967,8 +968,8 @@ declare class TraceSimplificationSolver extends BaseSolver {
     hdRoutes: HighDensityRoute$1[];
     simplificationPipelineLoops: number;
     MAX_SIMPLIFICATION_PIPELINE_LOOPS: number;
-    PHASE_ORDER: Phase[];
-    currentPhase: Phase;
+    PHASE_ORDER: Phase$1[];
+    currentPhase: Phase$1;
     /** Callback to extract results from the active sub-solver */
     extractResult: ((solver: BaseSolver) => HighDensityRoute$1[]) | null;
     /** Returns the simplified routes. This is the primary output of the solver. */
@@ -1631,12 +1632,12 @@ declare class MultiSectionPortPointOptimizer extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface CapacityMeshSolverOptions$2 {
+interface CapacityMeshSolverOptions$3 {
     capacityDepth?: number;
     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: AutoroutingPipelineSolver2_PortPointPathing) => ConstructorParameters<T>;
@@ -1644,7 +1645,7 @@ type PipelineStep$2<T extends new (...args: any[]) => BaseSolver> = {
 };
 declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
     srj: SimpleRouteJson;
-    opts: CapacityMeshSolverOptions$2;
+    opts: CapacityMeshSolverOptions$3;
     netToPointPairsSolver?: NetToPointPairsSolver;
     nodeSolver?: RectDiffPipeline;
     nodeTargetMerger?: CapacityNodeTargetMerger;
@@ -1670,8 +1671,8 @@ declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
     capacityNodes: CapacityMeshNode[] | null;
     capacityEdges: CapacityMeshEdge[] | null;
     cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep$2<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$2<typeof RectDiffPipeline> | PipelineStep$2<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$2<typeof AvailableSegmentPointSolver> | PipelineStep$2<typeof HyperPortPointPathingSolver> | PipelineStep$2<typeof MultiSectionPortPointOptimizer> | PipelineStep$2<typeof HighDensitySolver> | PipelineStep$2<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$2<typeof TraceSimplificationSolver>)[];
-    constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$2);
+    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>)[];
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$3);
     currentPipelineStepIndex: number;
     _step(): void;
     solveUntilPhase(phase: string): void;
@@ -2487,12 +2488,12 @@ declare class CapacityPathingMultiSectionSolver extends BaseSolver {
     visualize(): graphics_debug.GraphicsObject;
 }
 
-interface CapacityMeshSolverOptions$1 {
+interface CapacityMeshSolverOptions$2 {
     capacityDepth?: number;
     targetMinCapacity?: number;
     cacheProvider?: CacheProvider | null;
 }
-type PipelineStep$1<T extends new (...args: any[]) => BaseSolver> = {
+type PipelineStep$2<T extends new (...args: any[]) => BaseSolver> = {
     solverName: string;
     solverClass: T;
     getConstructorParams: (instance: AutoroutingPipeline1_OriginalUnravel) => ConstructorParameters<T>;
@@ -2500,7 +2501,7 @@ type PipelineStep$1<T extends new (...args: any[]) => BaseSolver> = {
 };
 declare class AutoroutingPipeline1_OriginalUnravel extends BaseSolver {
     srj: SimpleRouteJson;
-    opts: CapacityMeshSolverOptions$1;
+    opts: CapacityMeshSolverOptions$2;
     netToPointPairsSolver?: NetToPointPairsSolver;
     nodeSolver?: RectDiffPipeline;
     nodeTargetMerger?: CapacityNodeTargetMerger;
@@ -2529,7 +2530,440 @@ declare class AutoroutingPipeline1_OriginalUnravel extends BaseSolver {
     capacityNodes: CapacityMeshNode[] | null;
     capacityEdges: CapacityMeshEdge[] | null;
     cacheProvider: CacheProvider | null;
-    pipelineDef: (PipelineStep$1<typeof NetToPointPairsSolver2_OffBoardConnection> | PipelineStep$1<typeof RectDiffPipeline> | PipelineStep$1<typeof StrawSolver> | PipelineStep$1<typeof CapacityMeshEdgeSolver2_NodeTreeOptimization> | PipelineStep$1<typeof DeadEndSolver> | PipelineStep$1<typeof CapacityPathingGreedySolver> | PipelineStep$1<typeof CapacityPathingMultiSectionSolver> | PipelineStep$1<typeof CapacityEdgeToPortSegmentSolver> | PipelineStep$1<typeof CapacitySegmentToPointSolver> | PipelineStep$1<typeof UnravelMultiSectionSolver> | PipelineStep$1<typeof HighDensitySolver> | PipelineStep$1<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$1<typeof TraceSimplificationSolver>)[];
+    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>)[];
+    constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$2);
+    currentPipelineStepIndex: number;
+    _step(): void;
+    solveUntilPhase(phase: string): void;
+    getCurrentPhase(): string;
+    visualize(): GraphicsObject;
+    /**
+     * A lightweight version of the visualize method that can be used to stream
+     * progress
+     *
+     * We return the most relevant graphic for the stage:
+     * 1. netToPointPairs output
+     * 2. Capacity Planning Output
+     * 3. High Density Route Solver Output, max 200 lines
+     */
+    preview(): GraphicsObject;
+    _getOutputHdRoutes(): HighDensityRoute$1[];
+    /**
+     * Returns the SimpleRouteJson with routes converted to SimplifiedPcbTraces
+     */
+    getOutputSimplifiedPcbTraces(): SimplifiedPcbTraces;
+    getOutputSimpleRouteJson(): SimpleRouteJson;
+}
+
+interface MovablePoint {
+    x: number;
+    y: number;
+    z: number;
+    rootConnectionName?: string;
+    connectionName: string;
+    forceX?: number;
+    forceY?: number;
+}
+interface RouteInProgress {
+    connectionName: string;
+    rootConnectionName?: string;
+    startPoint: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    endPoint: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    movablePoints: MovablePoint[];
+}
+/**
+ * A simplified high density solver that directly connects port points
+ * within each node without considering intersections or vias.
+ *
+ * This solver creates 3-segment lines (4 points) for each connection and uses
+ * a force-directed approach to push movable points away from borders and
+ * other movable points with different rootConnectionName.
+ *
+ * Only solves intra-node routing - connecting port points within a single node.
+ */
+declare class SimpleHighDensitySolver extends BaseSolver {
+    unsolvedNodes: NodeWithPortPoints[];
+    allNodes: NodeWithPortPoints[];
+    routes: HighDensityIntraNodeRoute$1[];
+    colorMap: Record<string, string>;
+    traceWidth: number;
+    viaDiameter: number;
+    numMovablePoints: number;
+    currentNode: NodeWithPortPoints | null;
+    currentNodeStep: number;
+    routesInProgress: RouteInProgress[];
+    pushMargin: number;
+    currentNodeBounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    } | null;
+    constructor({ nodePortPoints, colorMap, traceWidth, viaDiameter, pushMargin, numMovablePoints, }: {
+        nodePortPoints: NodeWithPortPoints[];
+        colorMap?: Record<string, string>;
+        traceWidth?: number;
+        viaDiameter?: number;
+        numMovablePoints?: number;
+        pushMargin?: number;
+    });
+    _step(): void;
+    _initializeRoutesForCurrentNode(): void;
+    _runForceDirectedStep(): void;
+    _finalizeRoutesForCurrentNode(): void;
+    _getNodeBounds(node: NodeWithPortPoints): {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+    visualize(): GraphicsObject;
+}
+
+/**
+ * ObstacleTree wraps different spatial index implementations:
+ * - 'native': original spatial-hash grid
+ * - 'rbush': dynamic R-tree via rbush
+ * - 'flatbush': static index via flatbush
+ */
+declare class ObstacleSpatialHashIndex {
+    private idx;
+    private storage;
+    constructor(implementation?: "native" | "rbush" | "flatbush", obstacles?: Obstacle[]);
+    insert(o: Obstacle): void;
+    search(bbox: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    }): Obstacle[];
+    searchArea(centerX: number, centerY: number, width: number, height: number): Obstacle[];
+}
+
+interface Point$1 {
+    x: number;
+    y: number;
+    z: number;
+}
+type Point2D$2 = {
+    x: number;
+    y: number;
+};
+type HighDensityIntraNodeRoute = {
+    connectionName: string;
+    rootConnectionName?: string;
+    traceThickness: number;
+    viaDiameter: number;
+    route: Array<{
+        x: number;
+        y: number;
+        z: number;
+    }>;
+    vias: Array<{
+        x: number;
+        y: number;
+    }>;
+};
+type HighDensityRoute = HighDensityIntraNodeRoute;
+declare class HighDensityRouteSpatialIndex {
+    private segmentBuckets;
+    private viaBuckets;
+    private routes;
+    private CELL_SIZE;
+    constructor(routes: HighDensityRoute[], cellSize?: number);
+    /**
+     * Finds routes that potentially conflict with a given line segment within a margin.
+     * Checks both segments and vias.
+     * @param segmentStart Start point of the query segment.
+     * @param segmentEnd End point of the query segment.
+     * @param margin The minimum required clearance distance from the query segment's centerline.
+     * @returns An array of conflicting routes and their minimum distance to the segment.
+     */
+    getConflictingRoutesForSegment(segmentStart: Point$1, // Keep Point for original Z data if needed elsewhere
+    segmentEnd: Point$1, margin: number): Array<{
+        conflictingRoute: HighDensityRoute;
+        distance: number;
+    }>;
+    /**
+     * Finds routes that pass near a given point within a margin.
+     * Checks both segments and vias.
+     * @param point The query point {x, y}. Z is ignored.
+     * @param margin The minimum required clearance distance from the query point.
+     * @returns An array of conflicting routes and their minimum distance to the point.
+     */
+    getConflictingRoutesNearPoint(point: Point2D$2, margin: number): Array<{
+        conflictingRoute: HighDensityRoute;
+        distance: number;
+    }>;
+}
+
+interface Point2D$1 {
+    x: number;
+    y: number;
+}
+interface Segment {
+    start: Point2D$1;
+    end: Point2D$1;
+}
+
+interface Point2D {
+    x: number;
+    y: number;
+}
+interface Point3D extends Point2D {
+    z: number;
+}
+interface TraceKeepoutSolverInput {
+    hdRoutes: HighDensityRoute$1[];
+    obstacles: Obstacle[];
+    connMap: ConnectivityMap;
+    colorMap: Record<string, string>;
+    keepoutRadiusSchedule?: number[];
+    smoothDistance?: number;
+}
+/**
+ * TraceKeepoutSolver adjusts traces to maintain keepout distance from obstacles
+ * and non-connected traces. It works by walking along each trace with a cursor,
+ * detecting obstacles within a keepout radius, and pushing the draw position
+ * orthogonally to avoid them.
+ *
+ * The solver processes traces through multiple passes with decreasing keepout
+ * radii as defined by KEEPOUT_RADIUS_SCHEDULE.
+ */
+declare class TraceKeepoutSolver extends BaseSolver {
+    private input;
+    originalHdRoutes: HighDensityRoute$1[];
+    hdRoutes: HighDensityRoute$1[];
+    redrawnHdRoutes: HighDensityRoute$1[];
+    smoothDistance: number;
+    KEEPOUT_RADIUS_SCHEDULE: number[];
+    currentScheduleIndex: number;
+    currentKeepoutRadius: number;
+    unprocessedRoutes: HighDensityRoute$1[];
+    smoothedCursorRoutes: HighDensityRoute$1[];
+    processedRoutes: HighDensityRoute$1[];
+    currentTrace: HighDensityRoute$1 | null;
+    cursorPosition: Point3D | null;
+    lastCursorPosition: Point3D | null;
+    drawPosition: Point2D | null;
+    currentTraceSegmentIndex: number;
+    currentTraceSegmentT: number;
+    recordedDrawPositions: Point3D[];
+    lastCollidingSegments: Segment[];
+    obstacleSHI: ObstacleSpatialHashIndex;
+    hdRouteSHI: HighDensityRouteSpatialIndex;
+    constructor(input: TraceKeepoutSolverInput);
+    _step(): void;
+    /**
+     * Steps the cursor forward by CURSOR_STEP_DISTANCE along the trace
+     * Returns false if we've reached the end of the trace
+     */
+    private stepCursorForward;
+    /**
+     * Gets all colliding segments (obstacle edges and trace outlines) within the keepout radius
+     */
+    private getCollidingSegments;
+    positionHasCollision(position: {
+        x: number;
+        y: number;
+        z: number;
+    }, margin?: number): boolean;
+    /**
+     * Finalizes the current trace with the recorded draw positions
+     */
+    private finalizeCurrentTrace;
+    /**
+     * Simplifies the route by removing collinear points
+     */
+    private simplifyRoute;
+    visualize(): GraphicsObject;
+    /** Returns the redrawn routes. This is the primary output of the solver. */
+    getRedrawnHdRoutes(): HighDensityRoute$1[];
+}
+
+interface OffboardPortPoint {
+    portPointId: string;
+    x: number;
+    y: number;
+    /** The obstacle this port point is at the center of */
+    obstacleIndex: number;
+    /** The offBoardConnectsTo ids this port point is associated with */
+    offBoardConnectionIds: OffBoardConnectionId[];
+    /** Available Z layers for this port point based on obstacle layers */
+    availableZ: number[];
+}
+interface OffboardPathFragment {
+    pathFragmentId: string;
+    /** The shared offBoardConnectsTo id that connects these port points */
+    offBoardConnectionId: OffBoardConnectionId;
+    /** The two port points connected by this path fragment */
+    portPointIds: [string, string];
+    /** Endpoints of this edge */
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+}
+type Phase = "finding_obstacles" | "creating_fragments" | "done";
+interface PendingFragment {
+    offBoardId: OffBoardConnectionId;
+    pp1: OffboardPortPoint;
+    pp2: OffboardPortPoint;
+}
+/**
+ * PortPointOffboardPathFragmentSolver finds obstacles with offBoardConnectsTo
+ * defined and creates port points at their centers. It then creates path
+ * fragments (edges) connecting port points that share the same offBoardConnectsTo
+ * ids.
+ *
+ * This enables routing through off-board connections like flex cables or
+ * external connectors.
+ *
+ * The solver iterates step-by-step:
+ * 1. Phase "finding_obstacles": Process one obstacle per step, creating port points
+ * 2. Phase "creating_fragments": Create one path fragment per step
+ * 3. Phase "done": Solver complete
+ */
+declare class PortPointOffboardPathFragmentSolver extends BaseSolver {
+    srj: SimpleRouteJson;
+    colorMap: Record<string, string>;
+    /** Current phase of the solver */
+    phase: Phase;
+    /** Index of the current obstacle being processed */
+    currentObstacleIndex: number;
+    /** Obstacles that have offBoardConnectsTo defined */
+    offboardObstacles: Array<{
+        obstacle: Obstacle;
+        index: number;
+    }>;
+    /** Port points created at obstacle centers */
+    portPoints: OffboardPortPoint[];
+    /** Map from portPointId to OffboardPortPoint */
+    portPointMap: Map<string, OffboardPortPoint>;
+    /** Path fragments connecting port points with shared offBoardConnectsTo */
+    pathFragments: OffboardPathFragment[];
+    /** Map from offBoardConnectionId to port points that share it */
+    offBoardConnectionToPortPoints: Map<OffBoardConnectionId, OffboardPortPoint[]>;
+    /** Pending path fragments to create (computed after obstacle phase) */
+    pendingFragments: PendingFragment[];
+    /** Index of current fragment being created */
+    currentFragmentIndex: number;
+    /** Last processed obstacle (for visualization) */
+    lastProcessedObstacle: {
+        obstacle: Obstacle;
+        index: number;
+    } | null;
+    /** Last created port point (for visualization) */
+    lastCreatedPortPoint: OffboardPortPoint | null;
+    /** Last created path fragment (for visualization) */
+    lastCreatedFragment: OffboardPathFragment | null;
+    /** Color map for offBoardConnectionIds */
+    offBoardColorMap: Record<string, string>;
+    constructor({ srj, colorMap, }: {
+        srj: SimpleRouteJson;
+        colorMap?: Record<string, string>;
+    });
+    _step(): void;
+    private stepFindingObstacles;
+    private computePendingFragments;
+    private stepCreatingFragments;
+    private layerToZ;
+    computeProgress(): number;
+    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;
+    cacheProvider?: CacheProvider | null;
+}
+type PipelineStep$1<T extends new (...args: any[]) => BaseSolver> = {
+    solverName: string;
+    solverClass: T;
+    getConstructorParams: (instance: AssignableAutoroutingPipeline2) => ConstructorParameters<T>;
+    onSolved?: (instance: AssignableAutoroutingPipeline2) => void;
+};
+declare class AssignableAutoroutingPipeline2 extends BaseSolver {
+    srj: SimpleRouteJson;
+    opts: CapacityMeshSolverOptions$1;
+    netToPointPairsSolver?: NetToPointPairsSolver;
+    nodeSolver?: RectDiffPipeline;
+    nodeTargetMerger?: CapacityNodeTargetMerger;
+    edgeSolver?: CapacityMeshEdgeSolver;
+    relateNodesToOffBoardConnections?: RelateNodesToOffBoardConnectionsSolver;
+    colorMap: Record<string, string>;
+    highDensityRouteSolver?: HighDensitySolver;
+    simpleHighDensityRouteSolver?: SimpleHighDensitySolver;
+    highDensityStitchSolver?: MultipleHighDensityRouteStitchSolver;
+    singleLayerNodeMerger?: SingleLayerNodeMergerSolver;
+    offboardPathFragmentSolver?: PortPointOffboardPathFragmentSolver;
+    strawSolver?: StrawSolver;
+    deadEndSolver?: DeadEndSolver;
+    traceSimplificationSolver?: TraceSimplificationSolver;
+    traceKeepoutSolver?: TraceKeepoutSolver;
+    availableSegmentPointSolver?: AvailableSegmentPointSolver;
+    portPointPathingSolver?: PortPointPathingSolver;
+    multiSectionPortPointOptimizer?: MultiSectionPortPointOptimizer;
+    viaDiameter: number;
+    minTraceWidth: number;
+    startTimeOfPhase: Record<string, number>;
+    endTimeOfPhase: Record<string, number>;
+    timeSpentOnPhase: Record<string, number>;
+    activeSubSolver?: BaseSolver | null;
+    connMap: ConnectivityMap;
+    srjWithPointPairs?: SimpleRouteJson;
+    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 SimpleHighDensitySolver> | PipelineStep$1<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$1<typeof TraceSimplificationSolver> | PipelineStep$1<typeof TraceKeepoutSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$1);
     currentPipelineStepIndex: number;
     _step(): void;
@@ -2681,26 +3115,6 @@ declare function getGlobalLocalStorageCache(): LocalStorageCache;
 declare function getGlobalInMemoryCache(): InMemoryCache;
 declare function setupGlobalCaches(): void;
 
-/**
- * ObstacleTree wraps different spatial index implementations:
- * - 'native': original spatial-hash grid
- * - 'rbush': dynamic R-tree via rbush
- * - 'flatbush': static index via flatbush
- */
-declare class ObstacleSpatialHashIndex {
-    private idx;
-    private storage;
-    constructor(implementation?: "native" | "rbush" | "flatbush", obstacles?: Obstacle[]);
-    insert(o: Obstacle): void;
-    search(bbox: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    }): Obstacle[];
-    searchArea(centerX: number, centerY: number, width: number, height: number): Obstacle[];
-}
-
 interface Target$1 {
     x: number;
     y: number;
@@ -2919,7 +3333,7 @@ declare class AssignableViaNodeMergerSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface Point$1 {
+interface Point {
     x: number;
     y: number;
     z: number;
@@ -2961,7 +3375,7 @@ declare class SingleSimplifiedPathSolver extends BaseSolver {
         }[] | undefined;
     };
     get simplifiedRoute(): HighDensityIntraNodeRoute$1;
-    isValidPath(pointsInRoute: Point$1[]): boolean;
+    isValidPath(pointsInRoute: Point[]): boolean;
     _step(): void;
     getVisualsForNewRouteAndObstacles(): GraphicsObject & Pick<Required<GraphicsObject>, "points" | "lines" | "rects" | "circles">;
 }
@@ -2994,63 +3408,6 @@ declare class MultiSimplifiedPathSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface Point {
-    x: number;
-    y: number;
-    z: number;
-}
-type Point2D = {
-    x: number;
-    y: number;
-};
-type HighDensityIntraNodeRoute = {
-    connectionName: string;
-    rootConnectionName?: string;
-    traceThickness: number;
-    viaDiameter: number;
-    route: Array<{
-        x: number;
-        y: number;
-        z: number;
-    }>;
-    vias: Array<{
-        x: number;
-        y: number;
-    }>;
-};
-type HighDensityRoute = HighDensityIntraNodeRoute;
-declare class HighDensityRouteSpatialIndex {
-    private segmentBuckets;
-    private viaBuckets;
-    private routes;
-    private CELL_SIZE;
-    constructor(routes: HighDensityRoute[], cellSize?: number);
-    /**
-     * Finds routes that potentially conflict with a given line segment within a margin.
-     * Checks both segments and vias.
-     * @param segmentStart Start point of the query segment.
-     * @param segmentEnd End point of the query segment.
-     * @param margin The minimum required clearance distance from the query segment's centerline.
-     * @returns An array of conflicting routes and their minimum distance to the segment.
-     */
-    getConflictingRoutesForSegment(segmentStart: Point, // Keep Point for original Z data if needed elsewhere
-    segmentEnd: Point, margin: number): Array<{
-        conflictingRoute: HighDensityRoute;
-        distance: number;
-    }>;
-    /**
-     * Finds routes that pass near a given point within a margin.
-     * Checks both segments and vias.
-     * @param point The query point {x, y}. Z is ignored.
-     * @param margin The minimum required clearance distance from the query point.
-     * @returns An array of conflicting routes and their minimum distance to the point.
-     */
-    getConflictingRoutesNearPoint(point: Point2D, margin: number): Array<{
-        conflictingRoute: HighDensityRoute;
-        distance: number;
-    }>;
-}
-
 interface RouteSection {
     startIndex: number;
     endIndex: number;
@@ -3383,4 +3740,4 @@ declare const convertSrjToGraphicsObject: (srj: SimpleRouteJson) => {
     points: Point$3[];
 };
 
-export { AssignableAutoroutingPipeline1Solver, AutoroutingPipeline1_OriginalUnravel, AutoroutingPipelineSolver2_PortPointPathing as AutoroutingPipelineSolver, type AutoroutingPipelineSolverOptions, type CachableSolver, type CacheProvider, CapacityMeshSolver, InMemoryCache, LocalStorageCache, calculateOptimalCapacityDepth, convertSrjToGraphicsObject, getGlobalInMemoryCache, getGlobalLocalStorageCache, getTunedTotalCapacity1, setupGlobalCaches };
+export { AssignableAutoroutingPipeline1Solver, AssignableAutoroutingPipeline2, AutoroutingPipeline1_OriginalUnravel, AutoroutingPipelineSolver2_PortPointPathing as AutoroutingPipelineSolver, type AutoroutingPipelineSolverOptions, type CachableSolver, type CacheProvider, CapacityMeshSolver, InMemoryCache, LocalStorageCache, calculateOptimalCapacityDepth, convertSrjToGraphicsObject, getGlobalInMemoryCache, getGlobalLocalStorageCache, getTunedTotalCapacity1, setupGlobalCaches };