@tscircuit/capacity-autorouter 0.0.262 → 0.0.264

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import { GraphicsObject, Rect, Circle, Line, Point as Point$5 } from 'graphics-d
 import { ConnectivityMap } from 'circuit-json-to-connectivity-map';
 import { RectDiffPipeline } from '@tscircuit/rectdiff';
 import { BaseSolver as BaseSolver$1 } from '@tscircuit/solver-utils';
-import { Polygon } from '@tscircuit/math-utils';
+import { Point3, Polygon } from '@tscircuit/math-utils';
 import { JumperGraphSolver, JRegion, JPort } from '@tscircuit/hypergraph';
 import { CurvyTraceSolver } from '@tscircuit/curvy-trace-solver';
 import { ConnectivityMap as ConnectivityMap$1 } from 'connectivity-map';
@@ -2089,6 +2089,176 @@ declare class UniformPortDistributionSolver extends BaseSolver$1 {
     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 HighDensityIntraNodeRoute = {
+    connectionName: string;
+    rootConnectionName?: string;
+    traceThickness: number;
+    viaDiameter: number;
+    route: Array<{
+        x: number;
+        y: number;
+        z: number;
+        insideJumperPad?: boolean;
+    }>;
+    vias: Array<{
+        x: number;
+        y: number;
+    }>;
+    jumpers?: Jumper[];
+};
+type HighDensityRoute = HighDensityIntraNodeRoute;
+declare class HighDensityRouteSpatialIndex {
+    private segmentBuckets;
+    private viaBuckets;
+    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;
+    }>;
+    /**
+     * Removes a route from the spatial index by connection name.
+     * @param connectionName The connection name of the route to remove.
+     */
+    removeRoute(connectionName: string): void;
+    /**
+     * Adds a single route to the spatial index.
+     * @param route The route to add.
+     */
+    addRoute(route: HighDensityRoute): void;
+    /**
+     * Finds routes that pass near a given point within a margin.
+     * Checks both segments and vias.
+     * @param point The query point {x, y, z}.
+     * @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: Point3, margin: number): Array<{
+        conflictingRoute: HighDensityRoute;
+        distance: number;
+    }>;
+}
+
+interface Point2D$2 {
+    x: number;
+    y: number;
+}
+interface Point3D$1 extends Point2D$2 {
+    z: number;
+}
+interface TraceWidthSolverInput {
+    hdRoutes: HighDensityRoute$1[];
+    connection: SimpleRouteConnection[];
+    obstacles?: Obstacle[];
+    connMap?: ConnectivityMap;
+    colorMap?: Record<string, string>;
+    minTraceWidth: number;
+    obstacleMargin?: number;
+}
+/**
+ * TraceWidthSolver determines the optimal trace width for each route.
+ * It uses a TRACE_WIDTH_SCHEDULE to try progressively narrower widths:
+ * [nominalTraceWidth, (nominalTraceWidth + minTraceWidth)/2, minTraceWidth]
+ *
+ * For each trace, it walks along with a cursor checking clearance.
+ * If clearance is insufficient for the current width, it tries the next
+ * narrower width in the schedule.
+ *
+ * It only runs width adjustments for routes whose connection provides a
+ * nominalTraceWidth; routes without one are passed through unchanged.
+ * The schedule is built per-route from that connection's nominalTraceWidth.
+ */
+declare class TraceWidthSolver extends BaseSolver {
+    hdRoutes: HighDensityRoute$1[];
+    hdRoutesWithWidths: HighDensityRoute$1[];
+    nominalTraceWidth: number;
+    minTraceWidth: number;
+    obstacleMargin: number;
+    TRACE_WIDTH_SCHEDULE: number[];
+    connectionNominalTraceWidthMap: Map<string, number>;
+    unprocessedRoutes: HighDensityRoute$1[];
+    processedRoutes: HighDensityRoute$1[];
+    currentTrace: HighDensityRoute$1 | null;
+    cursorPosition: Point3D$1 | null;
+    currentTraceSegmentIndex: number;
+    currentTraceSegmentT: number;
+    currentScheduleIndex: number;
+    currentTargetWidth: number;
+    hasInsufficientClearance: boolean;
+    lastCollidingObstacles: Obstacle[];
+    lastCollidingRoutes: HighDensityRoute$1[];
+    lastClearance: number;
+    obstacles: Obstacle[];
+    obstacleSHI?: ObstacleSpatialHashIndex;
+    hdRouteSHI: HighDensityRouteSpatialIndex;
+    connMap?: ConnectivityMap;
+    colorMap?: Record<string, string>;
+    constructor(input: TraceWidthSolverInput);
+    private getNominalTraceWidthForRoute;
+    _step(): void;
+    /**
+     * Initializes/resets the cursor for processing a trace
+     */
+    private initializeCursor;
+    /**
+     * 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
+     */
+    private getClearanceAtPosition;
+    /**
+     * Finalizes the current trace with the given width
+     */
+    private finalizeCurrentTrace;
+    visualize(): GraphicsObject;
+    /** Returns the routes with determined widths. This is the primary output of the solver. */
+    getHdRoutesWithWidths(): HighDensityRoute$1[];
+}
+
 interface CapacityMeshSolverOptions$4 {
     capacityDepth?: number;
     targetMinCapacity?: number;
@@ -2119,6 +2289,7 @@ declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
     portPointPathingSolver?: HyperPortPointPathingSolver;
     multiSectionPortPointOptimizer?: MultiSectionPortPointOptimizer;
     uniformPortDistributionSolver?: UniformPortDistributionSolver;
+    traceWidthSolver?: TraceWidthSolver;
     viaDiameter: number;
     minTraceWidth: number;
     effort: number;
@@ -2132,7 +2303,7 @@ declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
     capacityEdges: CapacityMeshEdge[] | null;
     inputNodeWithPortPoints: InputNodeWithPortPoints[];
     cacheProvider: CacheProvider | null;
-    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 UniformPortDistributionSolver> | PipelineStep$4<typeof HighDensitySolver> | PipelineStep$4<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$4<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 UniformPortDistributionSolver> | PipelineStep$4<typeof HighDensitySolver> | PipelineStep$4<typeof MultipleHighDensityRouteStitchSolver> | PipelineStep$4<typeof TraceSimplificationSolver> | PipelineStep$4<typeof TraceWidthSolver>)[];
     constructor(srj: SimpleRouteJson, opts?: CapacityMeshSolverOptions$4);
     getConstructorParams(): readonly [SimpleRouteJson, CapacityMeshSolverOptions$4];
     currentPipelineStepIndex: number;
@@ -2161,26 +2332,6 @@ declare class AutoroutingPipelineSolver2_PortPointPathing extends BaseSolver {
 declare const CapacityMeshSolver: typeof AutoroutingPipelineSolver2_PortPointPathing;
 type CapacityMeshSolver = AutoroutingPipelineSolver2_PortPointPathing;
 
-/**
- * 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;
@@ -3579,88 +3730,20 @@ declare class JumperHighDensitySolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface Point$1 {
-    x: number;
-    y: number;
-    z: number;
-}
-type Point2D$3 = {
-    x: number;
-    y: number;
-};
-type HighDensityIntraNodeRoute = {
-    connectionName: string;
-    rootConnectionName?: string;
-    traceThickness: number;
-    viaDiameter: number;
-    route: Array<{
-        x: number;
-        y: number;
-        z: number;
-        insideJumperPad?: boolean;
-    }>;
-    vias: Array<{
-        x: number;
-        y: number;
-    }>;
-    jumpers?: Jumper[];
-};
-type HighDensityRoute = HighDensityIntraNodeRoute;
-declare class HighDensityRouteSpatialIndex {
-    private segmentBuckets;
-    private viaBuckets;
-    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;
-    }>;
-    /**
-     * Removes a route from the spatial index by connection name.
-     * @param connectionName The connection name of the route to remove.
-     */
-    removeRoute(connectionName: string): void;
-    /**
-     * Adds a single route to the spatial index.
-     * @param route The route to add.
-     */
-    addRoute(route: HighDensityRoute): void;
-    /**
-     * 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$3, margin: number): Array<{
-        conflictingRoute: HighDensityRoute;
-        distance: number;
-    }>;
-}
-
-interface Point2D$2 {
+interface Point2D$1 {
     x: number;
     y: number;
 }
 interface Segment {
-    start: Point2D$2;
-    end: Point2D$2;
+    start: Point2D$1;
+    end: Point2D$1;
 }
 
-interface Point2D$1 {
+interface Point2D {
     x: number;
     y: number;
 }
-interface Point3D$1 extends Point2D$1 {
+interface Point3D extends Point2D {
     z: number;
     insideJumperPad?: boolean;
 }
@@ -3695,12 +3778,12 @@ declare class TraceKeepoutSolver extends BaseSolver {
     smoothedCursorRoutes: HighDensityRoute$1[];
     processedRoutes: HighDensityRoute$1[];
     currentTrace: HighDensityRoute$1 | null;
-    cursorPosition: Point3D$1 | null;
-    lastCursorPosition: Point3D$1 | null;
-    drawPosition: Point2D$1 | null;
+    cursorPosition: Point3D | null;
+    lastCursorPosition: Point3D | null;
+    drawPosition: Point2D | null;
     currentTraceSegmentIndex: number;
     currentTraceSegmentT: number;
-    recordedDrawPositions: Point3D$1[];
+    recordedDrawPositions: Point3D[];
     lastCollidingSegments: Segment[];
     /** Maps segment index to the jumper that occupies that segment */
     currentTraceJumperSegments: Map<number, Jumper>;
@@ -3773,88 +3856,6 @@ declare class TraceKeepoutSolver extends BaseSolver {
     getRedrawnHdRoutes(): HighDensityRoute$1[];
 }
 
-interface Point2D {
-    x: number;
-    y: number;
-}
-interface Point3D extends Point2D {
-    z: number;
-}
-interface TraceWidthSolverInput {
-    hdRoutes: HighDensityRoute$1[];
-    obstacles?: Obstacle[];
-    connMap?: ConnectivityMap;
-    colorMap?: Record<string, string>;
-    nominalTraceWidth?: number;
-    minTraceWidth: number;
-    obstacleMargin?: number;
-}
-/**
- * TraceWidthSolver determines the optimal trace width for each route.
- * It uses a TRACE_WIDTH_SCHEDULE to try progressively narrower widths:
- * [nominalTraceWidth, (nominalTraceWidth + minTraceWidth)/2, minTraceWidth]
- *
- * For each trace, it walks along with a cursor checking clearance.
- * If clearance is insufficient for the current width, it tries the next
- * narrower width in the schedule.
- *
- * nominalTraceWidth defaults to minTraceWidth * 2 if not specified.
- */
-declare class TraceWidthSolver extends BaseSolver {
-    hdRoutes: HighDensityRoute$1[];
-    hdRoutesWithWidths: HighDensityRoute$1[];
-    nominalTraceWidth: number;
-    minTraceWidth: number;
-    obstacleMargin: number;
-    TRACE_WIDTH_SCHEDULE: number[];
-    unprocessedRoutes: HighDensityRoute$1[];
-    processedRoutes: HighDensityRoute$1[];
-    currentTrace: HighDensityRoute$1 | null;
-    cursorPosition: Point3D | null;
-    currentTraceSegmentIndex: number;
-    currentTraceSegmentT: number;
-    currentScheduleIndex: number;
-    currentTargetWidth: number;
-    hasInsufficientClearance: boolean;
-    lastCollidingObstacles: Obstacle[];
-    lastCollidingRoutes: HighDensityRoute$1[];
-    lastClearance: number;
-    obstacles: Obstacle[];
-    obstacleSHI?: ObstacleSpatialHashIndex;
-    hdRouteSHI: HighDensityRouteSpatialIndex;
-    connMap?: ConnectivityMap;
-    colorMap?: Record<string, string>;
-    constructor(input: TraceWidthSolverInput);
-    _step(): void;
-    /**
-     * Initializes/resets the cursor for processing a trace
-     */
-    private initializeCursor;
-    /**
-     * 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
-     */
-    private getClearanceAtPosition;
-    /**
-     * Finalizes the current trace with the given width
-     */
-    private finalizeCurrentTrace;
-    visualize(): GraphicsObject;
-    /** Returns the routes with determined widths. This is the primary output of the solver. */
-    getHdRoutesWithWidths(): HighDensityRoute$1[];
-}
-
 interface OffboardPortPoint {
     portPointId: string;
     x: number;