@tscircuit/schematic-trace-solver 0.0.40 → 0.0.42

package/dist/index.d.ts

@@ -129,6 +129,7 @@ type ChipWithBounds = {
     maxX: number;
     maxY: number;
 };
+declare const getObstacleRects: (problem: InputProblem) => ChipWithBounds[];
 
 declare class SchematicTraceSingleLineSolver2 extends BaseSolver {
     pins: MspConnectionPair["pins"];
@@ -381,20 +382,128 @@ declare class NetLabelPlacementSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface TraceLabelOverlapAvoidanceSolverInput {
+interface LabelMergingSolverInput {
+    netLabelPlacements: NetLabelPlacement[];
     inputProblem: InputProblem;
     traces: SolvedTracePath[];
+}
+interface LabelMergingSolverOutput {
     netLabelPlacements: NetLabelPlacement[];
+    mergedLabelNetIdMap: Record<string, Set<string>>;
 }
-declare class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
-    private problem;
+/**
+ * Merges multiple net labels into a single, larger label if they are on the
+ * same side of the same chip, reducing schematic clutter.
+ */
+declare class MergedNetLabelObstacleSolver extends BaseSolver {
+    private input;
+    private output;
+    private inputProblem;
     private traces;
-    private netTempLabelPlacements;
-    private netLabelPlacements;
-    private updatedTraces;
-    private mergedLabelNetIdMap;
+    constructor(solverInput: LabelMergingSolverInput);
+    _step(): void;
+    getOutput(): LabelMergingSolverOutput;
+    visualize(): GraphicsObject;
+}
+
+interface TraceCleanupSolverInput {
+    inputProblem: InputProblem;
+    allTraces: SolvedTracePath[];
+    targetTraceIds: Set<string>;
+    allLabelPlacements: NetLabelPlacement[];
+    mergedLabelNetIdMap: Record<string, Set<string>>;
+    paddingBuffer: number;
+}
+/**
+ * Cleans up traces by minimizing turns and balancing L-shapes to improve
+ * the overall aesthetics and readability of the schematic.
+ */
+declare class TraceCleanupSolver extends BaseSolver {
+    private input;
+    private outputTraces;
+    private pipelineStepIndex;
+    private tracesToProcess;
+    private minimizedTraces;
+    private balancedTraces;
+    constructor(solverInput: TraceCleanupSolverInput);
+    _step(): void;
+    getOutput(): {
+        traces: SolvedTracePath[];
+    };
+    visualize(): GraphicsObject;
+}
+
+interface SingleOverlapSolverInput {
+    trace: SolvedTracePath;
+    label: NetLabelPlacement;
+    problem: InputProblem;
+    paddingBuffer: number;
+    detourCount: number;
+}
+/**
+ * This solver attempts to find a valid rerouting for a single trace that is
+ * overlapping with a net label. It tries various candidate paths until it
+ * finds one that does not introduce new collisions.
+ */
+declare class SingleOverlapSolver extends BaseSolver {
+    queuedCandidatePaths: Point[][];
+    solvedTracePath: Point[] | null;
+    initialTrace: SolvedTracePath;
+    problem: InputProblem;
+    obstacles: ReturnType<typeof getObstacleRects>;
+    label: NetLabelPlacement;
+    constructor(solverInput: SingleOverlapSolverInput);
+    _step(): void;
+    visualize(): GraphicsObject;
+}
+
+interface OverlapCollectionSolverInput {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+    mergedLabelNetIdMap: Record<string, Set<string>>;
+}
+/**
+ * This is an internal solver that manages the step-by-step process of avoiding
+ * multiple overlaps. It follows the pattern of SchematicTraceLinesSolver.
+ */
+declare class OverlapAvoidanceStepSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    netLabelPlacements: NetLabelPlacement[];
+    mergedLabelNetIdMap: Record<string, Set<string>>;
+    allTraces: SolvedTracePath[];
+    modifiedTraces: SolvedTracePath[];
     private detourCountByLabel;
     private readonly PADDING_BUFFER;
+    activeSubSolver: SingleOverlapSolver | null;
+    private overlapQueue;
+    private recentlyFailed;
+    constructor(solverInput: OverlapCollectionSolverInput);
+    _step(): void;
+    getOutput(): {
+        allTraces: SolvedTracePath[];
+        modifiedTraces: SolvedTracePath[];
+    };
+    visualize(): GraphicsObject;
+}
+
+interface TraceLabelOverlapAvoidanceSolverInput {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+}
+/**
+ * This solver is a pipeline that runs a series of sub-solvers to resolve
+ * trace-label overlaps and clean up the resulting traces.
+ */
+declare class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+    labelMergingSolver?: MergedNetLabelObstacleSolver;
+    overlapAvoidanceSolver?: OverlapAvoidanceStepSolver;
+    traceCleanupSolver?: TraceCleanupSolver;
+    pipelineStepIndex: number;
     constructor(solverInput: TraceLabelOverlapAvoidanceSolverInput);
     _step(): void;
     getOutput(): {
@@ -404,6 +513,35 @@ declare class TraceLabelOverlapAvoidanceSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+declare class LongDistancePairSolver extends BaseSolver {
+    private params;
+    solvedLongDistanceTraces: SolvedTracePath[];
+    private queuedCandidatePairs;
+    private currentCandidatePair;
+    private subSolver;
+    private chipMap;
+    private inputProblem;
+    private netConnMap;
+    private newlyConnectedPinIds;
+    private allSolvedTraces;
+    constructor(params: {
+        inputProblem: InputProblem;
+        alreadySolvedTraces: SolvedTracePath[];
+        primaryMspConnectionPairs: MspConnectionPair[];
+    });
+    getConstructorParams(): {
+        inputProblem: InputProblem;
+        alreadySolvedTraces: SolvedTracePath[];
+        primaryMspConnectionPairs: MspConnectionPair[];
+    };
+    _step(): void;
+    visualize(): graphics_debug.GraphicsObject;
+    getOutput(): {
+        newTraces: SolvedTracePath[];
+        allTracesMerged: SolvedTracePath[];
+    };
+}
+
 /**
  * Pipeline solver that runs a series of solvers to find the best schematic layout.
  * Coordinates the entire layout process from chip partitioning through final packing.
@@ -414,19 +552,27 @@ type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
     solverClass: T;
     getConstructorParams: (instance: SchematicTracePipelineSolver) => ConstructorParameters<T>;
     onSolved?: (instance: SchematicTracePipelineSolver) => void;
+    shouldSkip?: (instance: SchematicTracePipelineSolver) => boolean;
 };
+interface SchematicTracePipelineSolverParams {
+    inputProblem: InputProblem;
+    allowLongDistanceTraces?: boolean;
+}
 declare class SchematicTracePipelineSolver extends BaseSolver {
     mspConnectionPairSolver?: MspConnectionPairSolver;
     schematicTraceLinesSolver?: SchematicTraceLinesSolver;
+    longDistancePairSolver?: LongDistancePairSolver;
     traceOverlapShiftSolver?: TraceOverlapShiftSolver;
     netLabelPlacementSolver?: NetLabelPlacementSolver;
+    labelMergingSolver?: MergedNetLabelObstacleSolver;
     traceLabelOverlapAvoidanceSolver?: TraceLabelOverlapAvoidanceSolver;
+    traceCleanupSolver?: TraceCleanupSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
     inputProblem: InputProblem;
-    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver>)[];
+    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver>)[];
     constructor(inputProblem: InputProblem);
     getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>[0];
     currentPipelineStepIndex: number;
@@ -442,4 +588,4 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     preview(): GraphicsObject;
 }
 
-export { type ChipId, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type PinId, SchematicTracePipelineSolver, SchematicTraceSingleLineSolver2 };
+export { type ChipId, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type PinId, SchematicTracePipelineSolver, type SchematicTracePipelineSolverParams, SchematicTraceSingleLineSolver2 };