@tscircuit/schematic-trace-solver 0.0.93 → 0.0.95

package/dist/index.d.ts

@@ -788,7 +788,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
-interface VccNetLabelCornerPlacementSolverParams {
+interface RailNetLabelCornerPlacementSolverParams {
     inputProblem: InputProblem;
     traces: SolvedTracePath[];
     netLabelPlacements: NetLabelPlacement[];
@@ -797,6 +797,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 +813,7 @@ type EvaluatedCornerCandidate = TraceCornerCandidate & {
     selected: boolean;
 };
 
-declare class VccNetLabelCornerPlacementSolver extends BaseSolver {
+declare class RailNetLabelCornerPlacementSolver extends BaseSolver {
     inputProblem: InputProblem;
     traces: SolvedTracePath[];
     netLabelPlacements: NetLabelPlacement[];
@@ -819,8 +825,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[];
@@ -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,7 +1036,7 @@ 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>)[];
+    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);
     getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>[0];
     currentPipelineStepIndex: number;

package/dist/index.js

@@ -5653,6 +5653,30 @@ var getSegmentOverlapWithRectSpan = (start, end, rect) => {
 
 // lib/solvers/Example28Solver/reroute.ts
 var LABEL_CLEARANCE = 0.1;
+var MAX_CORRIDOR_SHIFTS = 16;
+var corridorHasOtherNetTrace = ({
+  x,
+  lowY,
+  highY,
+  outputTraces,
+  netId
+}) => {
+  for (const other of outputTraces) {
+    if (other.globalConnNetId === netId) continue;
+    const path = other.tracePath;
+    for (let i = 0; i + 1 < path.length; i++) {
+      const start = path[i];
+      const end = path[i + 1];
+      if (Math.abs(start.x - end.x) >= 1e-9) continue;
+      if (Math.abs(start.x - x) >= LABEL_CLEARANCE / 2) continue;
+      const segLowY = Math.min(start.y, end.y);
+      const segHighY = Math.max(start.y, end.y);
+      if (Math.min(highY, segHighY) - Math.max(lowY, segLowY) > 1e-6)
+        return true;
+    }
+  }
+  return false;
+};
 var findBestReroutePath = ({
   trace,
   obstacleLabel,
@@ -5691,8 +5715,11 @@ var generateRerouteCandidateResults = ({
   const seen = /* @__PURE__ */ new Set();
   const candidateResults = [];
   const horizontalSegmentPushCandidate = generateHorizontalSegmentPushCandidate(
-    trace,
-    label
+    {
+      trace,
+      label,
+      outputTraces
+    }
   );
   if (horizontalSegmentPushCandidate) {
     candidateResults.push(
@@ -5886,7 +5913,11 @@ var selectBestReroutePath = ({
   }
   return bestPath;
 };
-var generateHorizontalSegmentPushCandidate = (trace, label) => {
+var generateHorizontalSegmentPushCandidate = ({
+  trace,
+  label,
+  outputTraces
+}) => {
   const labelDirection = dir(label.orientation);
   if (labelDirection.x === 0) return null;
   const path = trace.tracePath;
@@ -5911,6 +5942,20 @@ var generateHorizontalSegmentPushCandidate = (trace, label) => {
   if (labelDirection.x > 0) {
     segmentPushX = bounds.maxX + LABEL_CLEARANCE;
   }
+  const corridorStep = labelDirection.x > 0 ? LABEL_CLEARANCE : -LABEL_CLEARANCE;
+  const verticalLowY = Math.min(verticalStart.y, verticalEnd.y);
+  const verticalHighY = Math.max(verticalStart.y, verticalEnd.y);
+  for (let shift = 0; shift < MAX_CORRIDOR_SHIFTS; shift++) {
+    const occupied = corridorHasOtherNetTrace({
+      x: segmentPushX,
+      lowY: verticalLowY,
+      highY: verticalHighY,
+      outputTraces,
+      netId: trace.globalConnNetId
+    });
+    if (!occupied) break;
+    segmentPushX += corridorStep;
+  }
   const segmentPushStartY = getClearedHorizontalY({
     start: previousAnchor,
     end: { x: segmentPushX, y: verticalStart.y },
@@ -7257,7 +7302,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;
@@ -7290,10 +7335,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);
@@ -7374,8 +7419,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;
@@ -7507,7 +7552,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(
@@ -7524,17 +7570,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
         });
       }
     }
@@ -7556,7 +7611,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,
@@ -8970,7 +9025,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   traceCleanupSolver;
   example28Solver;
   availableNetOrientationSolver;
-  vccNetLabelCornerPlacementSolver;
+  railNetLabelCornerPlacementSolver;
   traceAnchoredNetLabelOverlapSolver;
   netLabelTraceCollisionSolver;
   netLabelNetLabelCollisionSolver;
@@ -9132,8 +9187,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       ]
     ),
     definePipelineStep(
-      "vccNetLabelCornerPlacementSolver",
-      VccNetLabelCornerPlacementSolver,
+      "railNetLabelCornerPlacementSolver",
+      RailNetLabelCornerPlacementSolver,
       (instance) => {
         return [
           {
@@ -9151,7 +9206,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         {
           inputProblem: instance.inputProblem,
           traces: instance.availableNetOrientationSolver.traces,
-          netLabelPlacements: instance.vccNetLabelCornerPlacementSolver.outputNetLabelPlacements
+          netLabelPlacements: instance.railNetLabelCornerPlacementSolver.outputNetLabelPlacements
         }
       ]
     ),

package/lib/solvers/Example28Solver/reroute.ts

@@ -8,13 +8,13 @@ import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceS
 import { generateRerouteCandidates } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/rerouteCollidingTrace"
 import type { InputProblem } from "lib/types/InputProblem"
 import { dir } from "lib/utils/dir"
+import { getChipBoundaryOverlap } from "./doesPathRunAlongChipBoundary"
 import {
   countPathIntersections,
   getPathKey,
   getPathLength,
   isPathCollidingWithChipInterior,
 } from "./geometry"
-import { getChipBoundaryOverlap } from "./doesPathRunAlongChipBoundary"
 import type {
   ChipObstacle,
   RerouteCandidateResult,
@@ -22,6 +22,43 @@ import type {
 } from "./types"
 
 const LABEL_CLEARANCE = 0.1
+// How many LABEL_CLEARANCE-wide corridors to try before giving up on finding a
+// free one for a pushed segment.
+const MAX_CORRIDOR_SHIFTS = 16
+
+/**
+ * Whether a vertical trace segment of a different net already runs along the
+ * corridor at `x`, overlapping the [lowY, highY] span (within a corridor width).
+ */
+const corridorHasOtherNetTrace = ({
+  x,
+  lowY,
+  highY,
+  outputTraces,
+  netId,
+}: {
+  x: number
+  lowY: number
+  highY: number
+  outputTraces: SolvedTracePath[]
+  netId: string
+}): boolean => {
+  for (const other of outputTraces) {
+    if (other.globalConnNetId === netId) continue
+    const path = other.tracePath
+    for (let i = 0; i + 1 < path.length; i++) {
+      const start = path[i]!
+      const end = path[i + 1]!
+      if (Math.abs(start.x - end.x) >= 1e-9) continue
+      if (Math.abs(start.x - x) >= LABEL_CLEARANCE / 2) continue
+      const segLowY = Math.min(start.y, end.y)
+      const segHighY = Math.max(start.y, end.y)
+      if (Math.min(highY, segHighY) - Math.max(lowY, segLowY) > 1e-6)
+        return true
+    }
+  }
+  return false
+}
 
 export const findBestReroutePath = ({
   trace,
@@ -78,8 +115,11 @@ export const generateRerouteCandidateResults = ({
   const seen = new Set<string>()
   const candidateResults: RerouteCandidateResult[] = []
   const horizontalSegmentPushCandidate = generateHorizontalSegmentPushCandidate(
-    trace,
-    label,
+    {
+      trace,
+      label,
+      outputTraces,
+    },
   )
 
   if (horizontalSegmentPushCandidate) {
@@ -328,10 +368,15 @@ const selectBestReroutePath = ({
   return bestPath
 }
 
-const generateHorizontalSegmentPushCandidate = (
-  trace: SolvedTracePath,
-  label: NetLabelPlacement,
-): Point[] | null => {
+const generateHorizontalSegmentPushCandidate = ({
+  trace,
+  label,
+  outputTraces,
+}: {
+  trace: SolvedTracePath
+  label: NetLabelPlacement
+  outputTraces: SolvedTracePath[]
+}): Point[] | null => {
   const labelDirection = dir(label.orientation)
   if (labelDirection.x === 0) return null
 
@@ -367,6 +412,25 @@ const generateHorizontalSegmentPushCandidate = (
   if (labelDirection.x > 0) {
     segmentPushX = bounds.maxX + LABEL_CLEARANCE
   }
+
+  // Two traces escaping the same label block would otherwise be pushed to the
+  // identical corridor and stack on one line. Slide the corridor further out
+  // until it no longer coincides with a different-net trace already routed
+  // there, giving each escaping trace its own parallel corridor.
+  const corridorStep = labelDirection.x > 0 ? LABEL_CLEARANCE : -LABEL_CLEARANCE
+  const verticalLowY = Math.min(verticalStart.y, verticalEnd.y)
+  const verticalHighY = Math.max(verticalStart.y, verticalEnd.y)
+  for (let shift = 0; shift < MAX_CORRIDOR_SHIFTS; shift++) {
+    const occupied = corridorHasOtherNetTrace({
+      x: segmentPushX,
+      lowY: verticalLowY,
+      highY: verticalHighY,
+      outputTraces,
+      netId: trace.globalConnNetId,
+    })
+    if (!occupied) break
+    segmentPushX += corridorStep
+  }
   const segmentPushStartY = getClearedHorizontalY({
     start: previousAnchor,
     end: { x: segmentPushX, y: verticalStart.y },

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"
@@ -78,7 +78,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   traceCleanupSolver?: TraceCleanupSolver
   example28Solver?: Example28Solver
   availableNetOrientationSolver?: AvailableNetOrientationSolver
-  vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver
+  railNetLabelCornerPlacementSolver?: RailNetLabelCornerPlacementSolver
   traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver
   netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
   netLabelNetLabelCollisionSolver?: NetLabelNetLabelCollisionSolver
@@ -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,
         },
       ],
     ),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/schematic-trace-solver",
   "main": "dist/index.js",
-  "version": "0.0.93",
+  "version": "0.0.95",
   "type": "module",
   "scripts": {
     "start": "cosmos",