@tscircuit/schematic-trace-solver 0.0.50 → 0.0.51

package/dist/index.d.ts

@@ -706,6 +706,60 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     visualize(): GraphicsObject;
 }
 
+interface VccNetLabelCornerPlacementSolverParams {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+}
+type TraceCornerCandidate = {
+    anchorPoint: Point;
+    traceId: string;
+    distance: number;
+};
+type CornerCandidateStatus = "valid" | "chip-collision" | "trace-collision" | "netlabel-collision";
+type EvaluatedCornerCandidate = TraceCornerCandidate & {
+    center: Point;
+    width: number;
+    height: number;
+    status: CornerCandidateStatus;
+    selected: boolean;
+};
+
+declare class VccNetLabelCornerPlacementSolver extends BaseSolver {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+    outputNetLabelPlacements: NetLabelPlacement[];
+    queuedLabelIndices: number[];
+    currentLabelIndex: number | null;
+    currentLabel: NetLabelPlacement | null;
+    currentCandidateResults: EvaluatedCornerCandidate[];
+    private queuedCornerCandidates;
+    private shouldAdvanceToNextLabel;
+    private traceMap;
+    constructor(params: VccNetLabelCornerPlacementSolverParams);
+    getConstructorParams(): ConstructorParameters<typeof VccNetLabelCornerPlacementSolver>[0];
+    _step(): void;
+    getOutput(): {
+        netLabelPlacements: NetLabelPlacement[];
+    };
+    private getProcessableLabelIndices;
+    private prepareNextLabel;
+    private advanceToNextLabel;
+    private clearCurrentLabel;
+    private finish;
+    private evaluateCornerCandidate;
+    private getCandidateStatus;
+    private applyCandidate;
+    private shouldProcessLabel;
+    private intersectsAnyChip;
+    private intersectsAnyOtherNetLabel;
+    private getCornerCandidatesForLabel;
+    private getTraceLinesForLabel;
+    private isTraceForLabel;
+    visualize(): GraphicsObject;
+}
+
 /**
  * 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.
@@ -733,12 +787,13 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     traceCleanupSolver?: TraceCleanupSolver;
     example28Solver?: Example28Solver;
     availableNetOrientationSolver?: AvailableNetOrientationSolver;
+    vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver;
     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 LongDistancePairSolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver>)[];
+    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>)[];
     constructor(inputProblem: InputProblem);
     getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>[0];
     currentPipelineStepIndex: number;

package/dist/index.js

@@ -271,19 +271,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS7 = 1e-9;
+  const EPS8 = 1e-9;
   const crossesSegment = (a, b) => {
     for (const [, rcl] of restrictedCenterLines) {
       if (rcl.axes.has("x") && typeof rcl.x === "number") {
-        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS7) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS8) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS7) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS8) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS7 || Math.abs(p1.y - p2.y) < EPS7) {
+  if (Math.abs(p1.x - p2.x) < EPS8 || Math.abs(p1.y - p2.y) < EPS8) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -810,8 +810,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS7 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS7 && Math.abs(p.y - q.y) < EPS7;
+      const EPS8 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS8 && Math.abs(p.y - q.y) < EPS8;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
         this.solvedTracePath = path;
         this.solved = true;
@@ -1010,13 +1010,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS7 = 1e-6
+  EPS: EPS8 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical3 = Math.abs(start.x - end.x) < EPS7;
-  const isHorizontal2 = Math.abs(start.y - end.y) < EPS7;
+  const isVertical3 = Math.abs(start.x - end.x) < EPS8;
+  const isHorizontal2 = Math.abs(start.y - end.y) < EPS8;
   if (!isVertical3 && !isHorizontal2) return;
   const segDir = isVertical3 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (si === 0) {
@@ -1083,13 +1083,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
     }
   }
   _step() {
-    const EPS7 = 1e-6;
+    const EPS8 = 1e-6;
     const offsets = this.overlappingTraceSegments.map((_, idx) => {
       const n = Math.floor(idx / 2) + 1;
       const signed = idx % 2 === 0 ? -n : n;
       return signed * this.SHIFT_DISTANCE;
     });
-    const eq = (a, b) => Math.abs(a - b) < EPS7;
+    const eq = (a, b) => Math.abs(a - b) < EPS8;
     const samePoint = (p, q) => !!p && !!q && eq(p.x, q.x) && eq(p.y, q.y);
     this.overlappingTraceSegments.forEach((group, gidx) => {
       const offset = offsets[gidx];
@@ -1115,13 +1115,13 @@ var TraceOverlapIssueSolver = class extends BaseSolver {
               segmentIndex: si,
               offset,
               JOG_SIZE,
-              EPS: EPS7
+              EPS: EPS8
             });
           } else {
             const start = pts[si];
             const end = pts[si + 1];
-            const isVertical3 = Math.abs(start.x - end.x) < EPS7;
-            const isHorizontal2 = Math.abs(start.y - end.y) < EPS7;
+            const isVertical3 = Math.abs(start.x - end.x) < EPS8;
+            const isHorizontal2 = Math.abs(start.y - end.y) < EPS8;
             if (!isVertical3 && !isHorizontal2) continue;
             if (isVertical3) {
               start.x += offset;
@@ -1218,7 +1218,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS7 = 2e-3;
+    const EPS8 = 2e-3;
     const netIds = Object.keys(this.traceNetIslands);
     for (let i = 0; i < netIds.length; i++) {
       for (let j = i + 1; j < netIds.length; j++) {
@@ -1236,7 +1236,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           const minB = Math.min(b1, b2);
           const maxB = Math.max(b1, b2);
           const overlap = Math.min(maxA, maxB) - Math.max(minA, minB);
-          return overlap > EPS7;
+          return overlap > EPS8;
         };
         for (let pa = 0; pa < pathsA.length; pa++) {
           const pathA = pathsA[pa];
@@ -1244,8 +1244,8 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           for (let sa = 0; sa < ptsA.length - 1; sa++) {
             const a1 = ptsA[sa];
             const a2 = ptsA[sa + 1];
-            const aVert = Math.abs(a1.x - a2.x) < EPS7;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS7;
+            const aVert = Math.abs(a1.x - a2.x) < EPS8;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS8;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -1253,11 +1253,11 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
               for (let sb = 0; sb < ptsB.length - 1; sb++) {
                 const b1 = ptsB[sb];
                 const b2 = ptsB[sb + 1];
-                const bVert = Math.abs(b1.x - b2.x) < EPS7;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS7;
+                const bVert = Math.abs(b1.x - b2.x) < EPS8;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS8;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS7) {
+                  if (Math.abs(a1.x - b1.x) < EPS8) {
                     if (overlaps1D(a1.y, a2.y, b1.y, b2.y)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1278,7 +1278,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     }
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS7) {
+                  if (Math.abs(a1.y - b1.y) < EPS8) {
                     if (overlaps1D(a1.x, a2.x, b1.x, b2.x)) {
                       const keyA = `${pa}:${sa}`;
                       const keyB = `${pb}:${sb}`;
@@ -1316,14 +1316,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS7 = 2e-3;
+    const EPS8 = 2e-3;
     for (const mspPairId in this.correctedTraceMap) {
       const tracePath = this.correctedTraceMap[mspPairId].tracePath;
       for (let i = 0; i < tracePath.length - 1; i++) {
         const p1 = tracePath[i];
         const p2 = tracePath[i + 1];
-        const isHorizontal2 = Math.abs(p1.y - p2.y) < EPS7;
-        const isVertical3 = Math.abs(p1.x - p2.x) < EPS7;
+        const isHorizontal2 = Math.abs(p1.y - p2.y) < EPS8;
+        const isVertical3 = Math.abs(p1.x - p2.x) < EPS8;
         if (!isHorizontal2 && !isVertical3) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -1337,13 +1337,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS7 = 2e-3;
+    const EPS8 = 2e-3;
     const p0 = i > 0 ? tracePath[i - 1] : null;
     const p3 = i + 2 < tracePath.length ? tracePath[i + 2] : null;
-    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS7 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS7 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS7 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS7 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS8 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS8 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS8 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS8 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -1507,24 +1507,24 @@ function getRectBounds(center, w, h) {
 }
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS7 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS7;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS7;
+function segmentIntersectsRect2(p1, p2, rect, EPS8 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS8;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS8;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS7 || x > rect.maxX + EPS7) return false;
+    if (x < rect.minX - EPS8 || x > rect.maxX + EPS8) return false;
     const segMinY = Math.min(p1.y, p2.y);
     const segMaxY = Math.max(p1.y, p2.y);
     const overlap = Math.min(segMaxY, rect.maxY) - Math.max(segMinY, rect.minY);
-    return overlap > EPS7;
+    return overlap > EPS8;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS7 || y > rect.maxY + EPS7) return false;
+    if (y < rect.minY - EPS8 || y > rect.maxY + EPS8) return false;
     const segMinX = Math.min(p1.x, p2.x);
     const segMaxX = Math.max(p1.x, p2.x);
     const overlap = Math.min(segMaxX, rect.maxX) - Math.max(segMinX, rect.minX);
-    return overlap > EPS7;
+    return overlap > EPS8;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -1902,14 +1902,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS7 = 1e-6;
+    const EPS8 = 1e-6;
     for (const curr of tracesToScan) {
       const pts = curr.tracePath.slice();
       for (let si = 0; si < pts.length - 1; si++) {
         const a = pts[si];
         const b = pts[si + 1];
-        const isH = Math.abs(a.y - b.y) < EPS7;
-        const isV = Math.abs(a.x - b.x) < EPS7;
+        const isH = Math.abs(a.y - b.y) < EPS8;
+        const isV = Math.abs(a.x - b.x) < EPS8;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -6054,6 +6054,314 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/VccNetLabelCornerPlacementSolver/geometry.ts
+var EPS7 = 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) > EPS7 && Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY) > EPS7;
+var getTraceCorners = (path) => {
+  const corners = [];
+  for (let i = 1; i < path.length - 1; i++) {
+    const previousPoint = path[i - 1];
+    const cornerPoint = path[i];
+    const nextPoint = path[i + 1];
+    if (isTraceCorner(previousPoint, cornerPoint, nextPoint)) {
+      corners.push(cornerPoint);
+    }
+  }
+  return corners;
+};
+var tracePathContainsPoint = (path, point) => {
+  for (let i = 0; i < path.length - 1; i++) {
+    if (isPointOnSegment(point, path[i], path[i + 1])) return true;
+  }
+  return false;
+};
+var getDistance2 = (a, b) => Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+var getUniquePinCount = (pinIds) => new Set(pinIds).size;
+var isTraceCorner = (a, b, c) => getSegmentOrientation2(a, b) !== getSegmentOrientation2(b, c);
+var isPointOnSegment = (point, start, end) => {
+  if (getSegmentOrientation2(start, end) === "horizontal") {
+    return Math.abs(point.y - start.y) <= EPS7 && point.x >= Math.min(start.x, end.x) - EPS7 && point.x <= Math.max(start.x, end.x) + EPS7;
+  }
+  return Math.abs(point.x - start.x) <= EPS7 && point.y >= Math.min(start.y, end.y) - EPS7 && point.y <= Math.max(start.y, end.y) + EPS7;
+};
+var getSegmentOrientation2 = (a, b) => Math.abs(a.y - b.y) <= EPS7 ? "horizontal" : "vertical";
+
+// lib/solvers/VccNetLabelCornerPlacementSolver/visualize.ts
+var CANDIDATE_SELECTED_COLOR3 = "blue";
+var CANDIDATE_REJECTED_COLOR3 = "red";
+var visualizeVccNetLabelCornerPlacementSolver = (state) => {
+  const graphics = visualizeInputProblem(state.inputProblem);
+  ensureGraphicsArrays2(graphics);
+  drawTraces3(graphics, state.traces);
+  drawNetLabels3(graphics, state.outputNetLabelPlacements);
+  if (!state.solved) {
+    drawCurrentLabel2(graphics, state.currentLabel);
+    drawCurrentCandidates3(graphics, state.currentCandidateResults);
+  }
+  return graphics;
+};
+var drawTraces3 = (graphics, traces) => {
+  for (const trace of traces) {
+    graphics.lines.push({
+      points: trace.tracePath,
+      strokeColor: "purple"
+    });
+  }
+};
+var drawNetLabels3 = (graphics, labels) => {
+  for (const label of labels) {
+    graphics.rects.push({
+      center: label.center,
+      width: label.width,
+      height: label.height,
+      fill: getColorFromString(label.globalConnNetId, 0.35),
+      strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+      label: `netId: ${label.netId}
+globalConnNetId: ${label.globalConnNetId}`
+    });
+    graphics.points.push({
+      x: label.anchorPoint.x,
+      y: label.anchorPoint.y,
+      color: getColorFromString(label.globalConnNetId, 0.9),
+      label: `anchorPoint
+orientation: ${label.orientation}`
+    });
+  }
+};
+var drawCurrentLabel2 = (graphics, currentLabel) => {
+  if (!currentLabel) return;
+  graphics.rects.push({
+    center: currentLabel.center,
+    width: currentLabel.width,
+    height: currentLabel.height,
+    fill: "rgba(255, 0, 0, 0.2)",
+    strokeColor: CANDIDATE_REJECTED_COLOR3,
+    label: `trace-line VCC target
+${currentLabel.netId ?? currentLabel.globalConnNetId}`
+  });
+};
+var drawCurrentCandidates3 = (graphics, candidates) => {
+  for (const candidate of candidates) {
+    const color = candidate.selected ? CANDIDATE_SELECTED_COLOR3 : CANDIDATE_REJECTED_COLOR3;
+    graphics.rects.push({
+      center: candidate.center,
+      width: candidate.width,
+      height: candidate.height,
+      fill: candidate.selected ? "rgba(0, 0, 255, 0.2)" : "rgba(255, 0, 0, 0.15)",
+      strokeColor: color,
+      strokeDash: candidate.selected ? void 0 : "4 2",
+      label: `${candidate.selected ? "selected" : candidate.status} trace corner
+trace: ${candidate.traceId}
+distance: ${candidate.distance.toFixed(3)}`
+    });
+    graphics.points.push({
+      ...candidate.anchorPoint,
+      color,
+      label: `candidate anchor
+${candidate.status}`
+    });
+  }
+};
+var ensureGraphicsArrays2 = (graphics) => {
+  if (!graphics.lines) graphics.lines = [];
+  if (!graphics.points) graphics.points = [];
+  if (!graphics.rects) graphics.rects = [];
+  if (!graphics.circles) graphics.circles = [];
+  if (!graphics.texts) graphics.texts = [];
+};
+
+// lib/solvers/VccNetLabelCornerPlacementSolver/VccNetLabelCornerPlacementSolver.ts
+var VccNetLabelCornerPlacementSolver = class extends BaseSolver {
+  inputProblem;
+  traces;
+  netLabelPlacements;
+  outputNetLabelPlacements;
+  queuedLabelIndices = [];
+  currentLabelIndex = null;
+  currentLabel = null;
+  currentCandidateResults = [];
+  queuedCornerCandidates = [];
+  shouldAdvanceToNextLabel = false;
+  traceMap;
+  constructor(params) {
+    super();
+    this.inputProblem = params.inputProblem;
+    this.traces = params.traces;
+    this.netLabelPlacements = params.netLabelPlacements;
+    this.outputNetLabelPlacements = [...params.netLabelPlacements];
+    this.traceMap = Object.fromEntries(
+      params.traces.map((trace) => [trace.mspPairId, trace])
+    );
+    this.queuedLabelIndices = this.getProcessableLabelIndices();
+    this.prepareNextLabel();
+  }
+  getConstructorParams() {
+    return {
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      netLabelPlacements: this.netLabelPlacements
+    };
+  }
+  _step() {
+    if (this.shouldAdvanceToNextLabel) {
+      this.advanceToNextLabel();
+      return;
+    }
+    const label = this.currentLabel;
+    const labelIndex = this.currentLabelIndex;
+    if (label === null || labelIndex === null) {
+      this.finish();
+      return;
+    }
+    const candidate = this.queuedCornerCandidates.shift();
+    if (!candidate) {
+      this.shouldAdvanceToNextLabel = true;
+      return;
+    }
+    const result = this.evaluateCornerCandidate(label, labelIndex, candidate);
+    this.currentCandidateResults.push(result);
+    if (result.status !== "valid") return;
+    result.selected = true;
+    this.applyCandidate(labelIndex, label, result);
+    this.shouldAdvanceToNextLabel = true;
+  }
+  getOutput() {
+    return {
+      netLabelPlacements: this.outputNetLabelPlacements
+    };
+  }
+  getProcessableLabelIndices() {
+    const labelIndices = [];
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+      const label = this.outputNetLabelPlacements[i];
+      if (!this.shouldProcessLabel(label)) continue;
+      labelIndices.push(i);
+    }
+    return labelIndices;
+  }
+  prepareNextLabel() {
+    const labelIndex = this.queuedLabelIndices.shift();
+    if (labelIndex === void 0) {
+      this.clearCurrentLabel();
+      return false;
+    }
+    const label = this.outputNetLabelPlacements[labelIndex];
+    this.currentLabelIndex = labelIndex;
+    this.currentLabel = label;
+    this.currentCandidateResults = [];
+    this.queuedCornerCandidates = this.getCornerCandidatesForLabel(label);
+    return true;
+  }
+  advanceToNextLabel() {
+    this.shouldAdvanceToNextLabel = false;
+    if (!this.prepareNextLabel()) this.finish();
+  }
+  clearCurrentLabel() {
+    this.currentLabelIndex = null;
+    this.currentLabel = null;
+    this.currentCandidateResults = [];
+    this.queuedCornerCandidates = [];
+  }
+  finish() {
+    this.clearCurrentLabel();
+    this.solved = true;
+  }
+  evaluateCornerCandidate(label, labelIndex, candidate) {
+    const center = getCenterFromAnchor(
+      candidate.anchorPoint,
+      label.orientation,
+      label.width,
+      label.height
+    );
+    const bounds = getRectBounds(center, label.width, label.height);
+    return {
+      ...candidate,
+      center,
+      width: label.width,
+      height: label.height,
+      status: this.getCandidateStatus(bounds, labelIndex),
+      selected: false
+    };
+  }
+  getCandidateStatus(bounds, labelIndex) {
+    if (this.intersectsAnyChip(bounds)) return "chip-collision";
+    if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
+      return "trace-collision";
+    }
+    if (this.intersectsAnyOtherNetLabel(bounds, labelIndex)) {
+      return "netlabel-collision";
+    }
+    return "valid";
+  }
+  applyCandidate(labelIndex, label, candidate) {
+    this.outputNetLabelPlacements[labelIndex] = {
+      ...label,
+      anchorPoint: candidate.anchorPoint,
+      center: candidate.center
+    };
+  }
+  shouldProcessLabel(label) {
+    return label.netId === "VCC" && this.getCornerCandidatesForLabel(label).length > 0;
+  }
+  intersectsAnyChip(bounds) {
+    return this.inputProblem.chips.some(
+      (chip) => rectsOverlap2(bounds, getRectBounds(chip.center, chip.width, chip.height))
+    );
+  }
+  intersectsAnyOtherNetLabel(bounds, labelIndex) {
+    return this.outputNetLabelPlacements.some((label, index) => {
+      if (index === labelIndex) return false;
+      return rectsOverlap2(
+        bounds,
+        getRectBounds(label.center, label.width, label.height)
+      );
+    });
+  }
+  getCornerCandidatesForLabel(label) {
+    const candidates = [];
+    const seenCornerKeys = /* @__PURE__ */ new Set();
+    for (const trace of this.getTraceLinesForLabel(label)) {
+      for (const anchorPoint of getTraceCorners(trace.tracePath)) {
+        const key = `${anchorPoint.x}:${anchorPoint.y}`;
+        if (seenCornerKeys.has(key)) continue;
+        seenCornerKeys.add(key);
+        candidates.push({
+          anchorPoint,
+          traceId: trace.mspPairId,
+          distance: getDistance2(anchorPoint, label.anchorPoint)
+        });
+      }
+    }
+    return candidates.sort((a, b) => a.distance - b.distance);
+  }
+  getTraceLinesForLabel(label) {
+    return this.traces.filter(
+      (trace) => isTraceLine(trace) && this.isTraceForLabel(trace, label)
+    );
+  }
+  isTraceForLabel(trace, label) {
+    if (!tracePathContainsPoint(trace.tracePath, label.anchorPoint)) {
+      return false;
+    }
+    const traceIds = new Set(label.mspConnectionPairIds);
+    if (traceIds.size > 0) {
+      return traceIds.has(trace.mspPairId);
+    }
+    return trace.globalConnNetId === label.globalConnNetId;
+  }
+  visualize() {
+    return visualizeVccNetLabelCornerPlacementSolver({
+      inputProblem: this.inputProblem,
+      traces: this.traces,
+      outputNetLabelPlacements: this.outputNetLabelPlacements,
+      currentLabel: this.currentLabel,
+      currentCandidateResults: this.currentCandidateResults,
+      solved: this.solved
+    });
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -6076,6 +6384,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   traceCleanupSolver;
   example28Solver;
   availableNetOrientationSolver;
+  vccNetLabelCornerPlacementSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -6232,6 +6541,19 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           netLabelPlacements: instance.example28Solver.outputNetLabelPlacements
         }
       ]
+    ),
+    definePipelineStep(
+      "vccNetLabelCornerPlacementSolver",
+      VccNetLabelCornerPlacementSolver,
+      (instance) => {
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: instance.availableNetOrientationSolver.traces,
+            netLabelPlacements: instance.availableNetOrientationSolver.outputNetLabelPlacements
+          }
+        ];
+      }
     )
   ];
   constructor(inputProblem) {

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -22,6 +22,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"
 
 type PipelineStep<T extends new (...args: any[]) => BaseSolver> = {
   solverName: string
@@ -73,6 +74,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   traceCleanupSolver?: TraceCleanupSolver
   example28Solver?: Example28Solver
   availableNetOrientationSolver?: AvailableNetOrientationSolver
+  vccNetLabelCornerPlacementSolver?: VccNetLabelCornerPlacementSolver
 
   startTimeOfPhase: Record<string, number>
   endTimeOfPhase: Record<string, number>
@@ -254,6 +256,20 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ],
     ),
+    definePipelineStep(
+      "vccNetLabelCornerPlacementSolver",
+      VccNetLabelCornerPlacementSolver,
+      (instance) => {
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: instance.availableNetOrientationSolver!.traces,
+            netLabelPlacements:
+              instance.availableNetOrientationSolver!.outputNetLabelPlacements,
+          },
+        ]
+      },
+    ),
   ]
 
   constructor(inputProblem: InputProblem) {