@tscircuit/schematic-trace-solver 0.0.94 → 0.0.96

package/dist/index.d.ts

@@ -103,6 +103,7 @@ interface InputProblem {
     availableNetLabelOrientations: Record<NetId, FacingDirection[]>;
     maxMspPairDistance?: number;
     _chipObstacleSpatialIndex?: ChipObstacleSpatialIndex;
+    _hideRatsNet?: boolean;
 }
 
 type MspConnectionPairId = string;
@@ -788,7 +789,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface VccNetLabelCornerPlacementSolverParams {
+interface RailNetLabelCornerPlacementSolverParams {
     inputProblem: InputProblem;
     traces: SolvedTracePath[];
     netLabelPlacements: NetLabelPlacement[];
@@ -797,6 +798,12 @@ type TraceCornerCandidate = {
     anchorPoint: Point;
     traceId: string;
     distance: number;
+    /**
+     * True when the corner lines up with one of the trace's pins along the
+     * label's stub axis (same x for a vertical rail label), so the label reads as
+     * a clean stub off that pin rather than floating over a mid-trace bend.
+     */
+    pinAligned: boolean;
 };
 type CornerCandidateStatus = "valid" | "chip-collision" | "text-collision" | "trace-collision" | "netlabel-collision";
 type EvaluatedCornerCandidate = TraceCornerCandidate & {
@@ -807,7 +814,7 @@ type EvaluatedCornerCandidate = TraceCornerCandidate & {
     selected: boolean;
 };
 
-declare class VccNetLabelCornerPlacementSolver extends BaseSolver {
+declare class RailNetLabelCornerPlacementSolver extends BaseSolver {
     inputProblem: InputProblem;
     traces: SolvedTracePath[];
     netLabelPlacements: NetLabelPlacement[];
@@ -819,8 +826,8 @@ declare class VccNetLabelCornerPlacementSolver extends BaseSolver {
     private queuedCornerCandidates;
     private shouldAdvanceToNextLabel;
     private traceMap;
-    constructor(params: VccNetLabelCornerPlacementSolverParams);
-    getConstructorParams(): ConstructorParameters<typeof VccNetLabelCornerPlacementSolver>[0];
+    constructor(params: RailNetLabelCornerPlacementSolverParams);
+    getConstructorParams(): ConstructorParameters<typeof RailNetLabelCornerPlacementSolver>[0];
     _step(): void;
     getOutput(): {
         netLabelPlacements: NetLabelPlacement[];
@@ -1006,9 +1013,8 @@ type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
     onSolved?: (instance: SchematicTracePipelineSolver) => void;
     shouldSkip?: (instance: SchematicTracePipelineSolver) => boolean;
 };
-interface SchematicTracePipelineSolverParams {
-    inputProblem: InputProblem;
-    allowLongDistanceTraces?: boolean;
+interface Options {
+    hideRatsNet?: boolean;
 }
 declare class SchematicTracePipelineSolver extends BaseSolver {
     mspConnectionPairSolver?: MspConnectionPairSolver;
@@ -1021,7 +1027,7 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     traceCleanupSolver?: TraceCleanupSolver;
     example28Solver?: Example28Solver;
     availableNetOrientationSolver?: AvailableNetOrientationSolver;
-    vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver;
+    railNetLabelCornerPlacementSolver?: RailNetLabelCornerPlacementSolver;
     traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver;
     netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver;
     netLabelNetLabelCollisionSolver?: NetLabelNetLabelCollisionSolver;
@@ -1030,9 +1036,10 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
     inputProblem: InputProblem;
-    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof VccNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver> | PipelineStep<typeof NetLabelNetLabelCollisionSolver>)[];
-    constructor(inputProblem: InputProblem);
-    getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>[0];
+    hideRatsNet: boolean;
+    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof RailNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver> | PipelineStep<typeof NetLabelNetLabelCollisionSolver>)[];
+    constructor(inputProblem: InputProblem, opts?: Options);
+    getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>;
     currentPipelineStepIndex: number;
     private cloneAndCorrectInputProblem;
     _step(): void;
@@ -1046,4 +1053,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, type SchematicTracePipelineSolverParams, SchematicTraceSingleLineSolver2, type SectionId, type TextBoxes };
+export { type ChipId, type InputChip, type InputDirectConnection, type InputNetConnection, type InputPin, type InputProblem, type NetId, type PinId, SchematicTracePipelineSolver, SchematicTraceSingleLineSolver2, type SectionId, type TextBoxes };

package/dist/index.js

@@ -327,7 +327,11 @@ var arePinsInDifferentSchematicSections = (inputProblem, p1, p2) => {
 
 // lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts
 var visualizeInputProblem = (inputProblem, opts = {}) => {
-  const { connectionAlpha = 0.8, chipAlpha = 0.8 } = opts;
+  const {
+    connectionAlpha = 0.8,
+    chipAlpha = 0.8,
+    hideRatsNet = inputProblem._hideRatsNet ?? false
+  } = opts;
   const graphics = {
     lines: [],
     points: [],
@@ -367,47 +371,49 @@ ${pin._facingDirection ?? getPinDirection(pin, chip)}`,
       strokeColor: "rgba(160, 0, 220, 0.9)"
     });
   }
-  for (const directConn of inputProblem.directConnections) {
-    const [pinId1, pinId2] = directConn.pinIds;
-    const pin1 = pinIdMap.get(pinId1);
-    const pin2 = pinIdMap.get(pinId2);
-    if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
-      continue;
+  if (!hideRatsNet) {
+    for (const directConn of inputProblem.directConnections) {
+      const [pinId1, pinId2] = directConn.pinIds;
+      const pin1 = pinIdMap.get(pinId1);
+      const pin2 = pinIdMap.get(pinId2);
+      if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+        continue;
+      }
+      graphics.lines.push({
+        points: [
+          {
+            x: pin1.x,
+            y: pin1.y
+          },
+          {
+            x: pin2.x,
+            y: pin2.y
+          }
+        ],
+        strokeColor: getColorFromString(
+          directConn.netId ?? `${pinId1}-${pinId2}`,
+          connectionAlpha
+        )
+      });
     }
-    graphics.lines.push({
-      points: [
-        {
-          x: pin1.x,
-          y: pin1.y
-        },
-        {
-          x: pin2.x,
-          y: pin2.y
-        }
-      ],
-      strokeColor: getColorFromString(
-        directConn.netId ?? `${pinId1}-${pinId2}`,
-        connectionAlpha
-      )
-    });
-  }
-  for (const netConn of inputProblem.netConnections) {
-    const pins = netConn.pinIds.map((pinId) => pinIdMap.get(pinId));
-    for (let i = 0; i < pins.length - 1; i++) {
-      for (let j = i + 1; j < pins.length; j++) {
-        const pin1 = pins[i];
-        const pin2 = pins[j];
-        if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
-          continue;
+    for (const netConn of inputProblem.netConnections) {
+      const pins = netConn.pinIds.map((pinId) => pinIdMap.get(pinId));
+      for (let i = 0; i < pins.length - 1; i++) {
+        for (let j = i + 1; j < pins.length; j++) {
+          const pin1 = pins[i];
+          const pin2 = pins[j];
+          if (arePinsInDifferentSchematicSections(inputProblem, pin1, pin2)) {
+            continue;
+          }
+          graphics.lines.push({
+            points: [
+              { x: pin1.x, y: pin1.y },
+              { x: pin2.x, y: pin2.y }
+            ],
+            strokeColor: getColorFromString(netConn.netId, connectionAlpha),
+            strokeDash: "4 2"
+          });
         }
-        graphics.lines.push({
-          points: [
-            { x: pin1.x, y: pin1.y },
-            { x: pin2.x, y: pin2.y }
-          ],
-          strokeColor: getColorFromString(netConn.netId, connectionAlpha),
-          strokeDash: "4 2"
-        });
       }
     }
   }
@@ -7302,7 +7308,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
 };
 
-// lib/solvers/VccNetLabelCornerPlacementSolver/geometry.ts
+// lib/solvers/RailNetLabelCornerPlacementSolver/geometry.ts
 var EPS9 = 1e-6;
 var isTraceLine = (trace) => getUniquePinCount(trace.pinIds) >= 2;
 var rectsOverlap2 = (a, b) => Math.min(a.maxX, b.maxX) - Math.max(a.minX, b.minX) > EPS9 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS9;
@@ -7335,10 +7341,10 @@ var isPointOnSegment = (point, start, end) => {
 };
 var getSegmentOrientation2 = (a, b) => Math.abs(a.y - b.y) <= EPS9 ? "horizontal" : "vertical";
 
-// lib/solvers/VccNetLabelCornerPlacementSolver/visualize.ts
+// lib/solvers/RailNetLabelCornerPlacementSolver/visualize.ts
 var CANDIDATE_SELECTED_COLOR3 = "blue";
 var CANDIDATE_REJECTED_COLOR3 = "red";
-var visualizeVccNetLabelCornerPlacementSolver = (state) => {
+var visualizeRailNetLabelCornerPlacementSolver = (state) => {
   const graphics = visualizeInputProblem(state.inputProblem);
   ensureGraphicsArrays2(graphics);
   drawTraces3(graphics, state.traces);
@@ -7419,8 +7425,8 @@ var ensureGraphicsArrays2 = (graphics) => {
   if (!graphics.texts) graphics.texts = [];
 };
 
-// lib/solvers/VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver.ts
-var VccNetLabelCornerPlacementSolver = class extends BaseSolver {
+// lib/solvers/RailNetLabelCornerPlacementSolver/RailNetLabelCornerPlacementSolver.ts
+var RailNetLabelCornerPlacementSolver = class extends BaseSolver {
   inputProblem;
   traces;
   netLabelPlacements;
@@ -7552,7 +7558,8 @@ var VccNetLabelCornerPlacementSolver = class extends BaseSolver {
     };
   }
   shouldProcessLabel(label) {
-    return label.netId === "VCC" && this.getCornerCandidatesForLabel(label).length > 0;
+    const isVerticalRailLabel = label.orientation === "y+" || label.orientation === "y-";
+    return isVerticalRailLabel && this.getCornerCandidatesForLabel(label).length > 0;
   }
   intersectsAnyChip(bounds) {
     return this.inputProblem.chips.some(
@@ -7569,17 +7576,26 @@ var VccNetLabelCornerPlacementSolver = class extends BaseSolver {
     });
   }
   getCornerCandidatesForLabel(label) {
+    const isVertical4 = label.orientation === "y+" || label.orientation === "y-";
     const candidates = [];
     const seenCornerKeys = /* @__PURE__ */ new Set();
     for (const trace of this.getTraceLinesForLabel(label)) {
-      for (const anchorPoint of getTraceCorners(trace.tracePath)) {
+      const path = trace.tracePath;
+      const pins = [path[0], path[path.length - 1]];
+      for (const anchorPoint of getTraceCorners(path)) {
         const key = `${anchorPoint.x}:${anchorPoint.y}`;
         if (seenCornerKeys.has(key)) continue;
         seenCornerKeys.add(key);
+        const pinAligned = pins.some((pin) => {
+          if (isVertical4) return Math.abs(pin.x - anchorPoint.x) < EPS9;
+          return Math.abs(pin.y - anchorPoint.y) < EPS9;
+        });
+        if (!pinAligned) continue;
         candidates.push({
           anchorPoint,
           traceId: trace.mspPairId,
-          distance: getDistance2(anchorPoint, label.anchorPoint)
+          distance: getDistance2(anchorPoint, label.anchorPoint),
+          pinAligned
         });
       }
     }
@@ -7601,7 +7617,7 @@ var VccNetLabelCornerPlacementSolver = class extends BaseSolver {
     return trace.globalConnNetId === label.globalConnNetId;
   }
   visualize() {
-    return visualizeVccNetLabelCornerPlacementSolver({
+    return visualizeRailNetLabelCornerPlacementSolver({
       inputProblem: this.inputProblem,
       traces: this.traces,
       outputNetLabelPlacements: this.outputNetLabelPlacements,
@@ -9015,7 +9031,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   traceCleanupSolver;
   example28Solver;
   availableNetOrientationSolver;
-  vccNetLabelCornerPlacementSolver;
+  railNetLabelCornerPlacementSolver;
   traceAnchoredNetLabelOverlapSolver;
   netLabelTraceCollisionSolver;
   netLabelNetLabelCollisionSolver;
@@ -9024,6 +9040,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   timeSpentOnPhase;
   firstIterationOfPhase;
   inputProblem;
+  hideRatsNet;
   pipelineDef = [
     definePipelineStep(
       "mspConnectionPairSolver",
@@ -9177,8 +9194,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       ]
     ),
     definePipelineStep(
-      "vccNetLabelCornerPlacementSolver",
-      VccNetLabelCornerPlacementSolver,
+      "railNetLabelCornerPlacementSolver",
+      RailNetLabelCornerPlacementSolver,
       (instance) => {
         return [
           {
@@ -9196,7 +9213,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         {
           inputProblem: instance.inputProblem,
           traces: instance.availableNetOrientationSolver.traces,
-          netLabelPlacements: instance.vccNetLabelCornerPlacementSolver.outputNetLabelPlacements
+          netLabelPlacements: instance.railNetLabelCornerPlacementSolver.outputNetLabelPlacements
         }
       ]
     ),
@@ -9223,8 +9240,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       ]
     )
   ];
-  constructor(inputProblem) {
+  constructor(inputProblem, opts) {
     super();
+    this.hideRatsNet = opts?.hideRatsNet ?? false;
     this.inputProblem = this.cloneAndCorrectInputProblem(inputProblem);
     this.MAX_ITERATIONS = 1e6;
     this.startTimeOfPhase = {};
@@ -9233,13 +9251,14 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
     this.firstIterationOfPhase = {};
   }
   getConstructorParams() {
-    return this.inputProblem;
+    return [this.inputProblem, { hideRatsNet: this.hideRatsNet }];
   }
   currentPipelineStepIndex = 0;
   cloneAndCorrectInputProblem(original) {
     const cloned = structuredClone({
       ...original,
-      _chipObstacleSpatialIndex: void 0
+      _chipObstacleSpatialIndex: void 0,
+      _hideRatsNet: this.hideRatsNet
     });
     expandChipsToFitPins(cloned);
     correctPinsInsideChips(cloned);
@@ -9285,7 +9304,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
     if (!this.solved && this.activeSubSolver)
       return this.activeSubSolver.visualize();
     const visualizations = [
-      visualizeInputProblem(this.inputProblem),
+      visualizeInputProblem(this.inputProblem, {
+        hideRatsNet: this.hideRatsNet
+      }),
       ...this.pipelineDef.map((p) => this[p.solverName]?.visualize()).filter(Boolean).map((viz, stepIndex) => {
         for (const rect of viz.rects ?? []) {
           rect.step = stepIndex;

package/lib/solvers/{VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver.ts → RailNetLabelCornerPlacementSolver/RailNetLabelCornerPlacementSolver.ts}

@@ -9,6 +9,7 @@ import {
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { InputProblem } from "lib/types/InputProblem"
 import {
+  EPS,
   getDistance,
   getTraceCorners,
   isTraceLine,
@@ -20,12 +21,12 @@ import type {
   CornerCandidateStatus,
   EvaluatedCornerCandidate,
   TraceCornerCandidate,
-  VccNetLabelCornerPlacementSolverParams,
+  RailNetLabelCornerPlacementSolverParams,
 } from "./types"
-import { visualizeVccNetLabelCornerPlacementSolver } from "./visualize"
+import { visualizeRailNetLabelCornerPlacementSolver } from "./visualize"
 import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 
-export class VccNetLabelCornerPlacementSolver extends BaseSolver {
+export class RailNetLabelCornerPlacementSolver extends BaseSolver {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
@@ -40,7 +41,7 @@ export class VccNetLabelCornerPlacementSolver extends BaseSolver {
   private shouldAdvanceToNextLabel = false
   private traceMap: Record<string, SolvedTracePath>
 
-  constructor(params: VccNetLabelCornerPlacementSolverParams) {
+  constructor(params: RailNetLabelCornerPlacementSolverParams) {
     super()
     this.inputProblem = params.inputProblem
     this.traces = params.traces
@@ -54,7 +55,7 @@ export class VccNetLabelCornerPlacementSolver extends BaseSolver {
   }
 
   override getConstructorParams(): ConstructorParameters<
-    typeof VccNetLabelCornerPlacementSolver
+    typeof RailNetLabelCornerPlacementSolver
   >[0] {
     return {
       inputProblem: this.inputProblem,
@@ -197,9 +198,13 @@ export class VccNetLabelCornerPlacementSolver extends BaseSolver {
   }
 
   private shouldProcessLabel(label: NetLabelPlacement) {
+    // Power/ground rail labels (VCC, GND, V3_3, ...) have a fixed vertical
+    // orientation and read best snapped to a trace corner rather than floating
+    // mid-segment. Signal labels (x+/x-) are left where they are.
+    const isVerticalRailLabel =
+      label.orientation === "y+" || label.orientation === "y-"
     return (
-      label.netId === "VCC" &&
-      this.getCornerCandidatesForLabel(label).length > 0
+      isVerticalRailLabel && this.getCornerCandidatesForLabel(label).length > 0
     )
   }
 
@@ -220,18 +225,31 @@ export class VccNetLabelCornerPlacementSolver extends BaseSolver {
   }
 
   private getCornerCandidatesForLabel(label: NetLabelPlacement) {
+    const isVertical = label.orientation === "y+" || label.orientation === "y-"
     const candidates: TraceCornerCandidate[] = []
     const seenCornerKeys = new Set<string>()
 
     for (const trace of this.getTraceLinesForLabel(label)) {
-      for (const anchorPoint of getTraceCorners(trace.tracePath)) {
+      const path = trace.tracePath
+      const pins = [path[0]!, path[path.length - 1]!]
+      for (const anchorPoint of getTraceCorners(path)) {
         const key = `${anchorPoint.x}:${anchorPoint.y}`
         if (seenCornerKeys.has(key)) continue
         seenCornerKeys.add(key)
+        const pinAligned = pins.some((pin) => {
+          if (isVertical) return Math.abs(pin.x - anchorPoint.x) < EPS
+          return Math.abs(pin.y - anchorPoint.y) < EPS
+        })
+        // Only pin-aligned corners are worth snapping a rail label to (a clean
+        // stub off a pin). Non-aligned corners are no better than where the
+        // label already is, so they aren't offered as candidates — this keeps
+        // already-well-placed labels untouched.
+        if (!pinAligned) continue
         candidates.push({
           anchorPoint,
           traceId: trace.mspPairId,
           distance: getDistance(anchorPoint, label.anchorPoint),
+          pinAligned,
         })
       }
     }
@@ -259,7 +277,7 @@ export class VccNetLabelCornerPlacementSolver extends BaseSolver {
   }
 
   override visualize(): GraphicsObject {
-    return visualizeVccNetLabelCornerPlacementSolver({
+    return visualizeRailNetLabelCornerPlacementSolver({
       inputProblem: this.inputProblem,
       traces: this.traces,
       outputNetLabelPlacements: this.outputNetLabelPlacements,

package/lib/solvers/{VccNetLabelCornerPlacementSolver → RailNetLabelCornerPlacementSolver}/types.ts

@@ -3,7 +3,7 @@ import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetL
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { InputProblem } from "lib/types/InputProblem"
 
-export interface VccNetLabelCornerPlacementSolverParams {
+export interface RailNetLabelCornerPlacementSolverParams {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
@@ -20,6 +20,12 @@ export type TraceCornerCandidate = {
   anchorPoint: Point
   traceId: string
   distance: number
+  /**
+   * True when the corner lines up with one of the trace's pins along the
+   * label's stub axis (same x for a vertical rail label), so the label reads as
+   * a clean stub off that pin rather than floating over a mid-trace bend.
+   */
+  pinAligned: boolean
 }
 
 export type CornerCandidateStatus =

package/lib/solvers/{VccNetLabelCornerPlacementSolver → RailNetLabelCornerPlacementSolver}/visualize.ts

@@ -9,7 +9,7 @@ import type { EvaluatedCornerCandidate } from "./types"
 const CANDIDATE_SELECTED_COLOR = "blue"
 const CANDIDATE_REJECTED_COLOR = "red"
 
-export const visualizeVccNetLabelCornerPlacementSolver = (state: {
+export const visualizeRailNetLabelCornerPlacementSolver = (state: {
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   outputNetLabelPlacements: NetLabelPlacement[]

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -23,7 +23,7 @@ import { MergedNetLabelObstacleSolver } from "../TraceLabelOverlapAvoidanceSolve
 import { TraceCleanupSolver } from "../TraceCleanupSolver/TraceCleanupSolver"
 import { Example28Solver } from "../Example28Solver/Example28Solver"
 import { AvailableNetOrientationSolver } from "../AvailableNetOrientationSolver/AvailableNetOrientationSolver"
-import { VccNetLabelCornerPlacementSolver } from "../VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver"
+import { RailNetLabelCornerPlacementSolver } from "../RailNetLabelCornerPlacementSolver/RailNetLabelCornerPlacementSolver"
 import { TraceAnchoredNetLabelOverlapSolver } from "../TraceAnchoredNetLabelOverlapSolver/TraceAnchoredNetLabelOverlapSolver"
 import { NetLabelTraceCollisionSolver } from "../NetLabelTraceCollisionSolver/NetLabelTraceCollisionSolver"
 import { NetLabelNetLabelCollisionSolver } from "../NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver"
@@ -61,9 +61,8 @@ function definePipelineStep<
   }
 }
 
-export interface SchematicTracePipelineSolverParams {
-  inputProblem: InputProblem
-  allowLongDistanceTraces?: boolean
+interface Options {
+  hideRatsNet?: boolean
 }
 
 export class SchematicTracePipelineSolver extends BaseSolver {
@@ -78,7 +77,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   traceCleanupSolver?: TraceCleanupSolver
   example28Solver?: Example28Solver
   availableNetOrientationSolver?: AvailableNetOrientationSolver
-  vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver
+  railNetLabelCornerPlacementSolver?: RailNetLabelCornerPlacementSolver
   traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver
   netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
   netLabelNetLabelCollisionSolver?: NetLabelNetLabelCollisionSolver
@@ -89,6 +88,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   firstIterationOfPhase: Record<string, number>
 
   inputProblem: InputProblem
+  hideRatsNet: boolean
 
   pipelineDef = [
     definePipelineStep(
@@ -264,8 +264,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       ],
     ),
     definePipelineStep(
-      "vccNetLabelCornerPlacementSolver",
-      VccNetLabelCornerPlacementSolver,
+      "railNetLabelCornerPlacementSolver",
+      RailNetLabelCornerPlacementSolver,
       (instance) => {
         return [
           {
@@ -285,7 +285,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
           inputProblem: instance.inputProblem,
           traces: instance.availableNetOrientationSolver!.traces,
           netLabelPlacements:
-            instance.vccNetLabelCornerPlacementSolver!.outputNetLabelPlacements,
+            instance.railNetLabelCornerPlacementSolver!
+              .outputNetLabelPlacements,
         },
       ],
     ),
@@ -317,8 +318,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
     ),
   ]
 
-  constructor(inputProblem: InputProblem) {
+  constructor(inputProblem: InputProblem, opts?: Options) {
     super()
+    this.hideRatsNet = opts?.hideRatsNet ?? false
     this.inputProblem = this.cloneAndCorrectInputProblem(inputProblem)
     this.MAX_ITERATIONS = 1e6
     this.startTimeOfPhase = {}
@@ -329,8 +331,8 @@ export class SchematicTracePipelineSolver extends BaseSolver {
 
   override getConstructorParams(): ConstructorParameters<
     typeof SchematicTracePipelineSolver
-  >[0] {
-    return this.inputProblem
+  > {
+    return [this.inputProblem, { hideRatsNet: this.hideRatsNet }]
   }
 
   currentPipelineStepIndex = 0
@@ -339,6 +341,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
     const cloned: InputProblem = structuredClone({
       ...original,
       _chipObstacleSpatialIndex: undefined,
+      _hideRatsNet: this.hideRatsNet,
     })
 
     // First, expand chips so existing pin coordinates sit on or within their edges without shrinking.
@@ -398,7 +401,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       return this.activeSubSolver.visualize()
 
     const visualizations = [
-      visualizeInputProblem(this.inputProblem),
+      visualizeInputProblem(this.inputProblem, {
+        hideRatsNet: this.hideRatsNet,
+      }),
       ...(this.pipelineDef
         .map((p) => (this as any)[p.solverName]?.visualize())
         .filter(Boolean)