@tscircuit/schematic-trace-solver 0.0.187 → 0.0.189

package/dist/index.js

@@ -342,19 +342,19 @@ var doesPairCrossRestrictedCenterLines = (params) => {
     chipMap
   });
   if (restrictedCenterLines.size === 0) return false;
-  const EPS17 = 1e-9;
+  const EPS18 = 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) < -EPS17) return true;
+        if ((a.x - rcl.x) * (b.x - rcl.x) < -EPS18) return true;
       }
       if (rcl.axes.has("y") && typeof rcl.y === "number") {
-        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS17) return true;
+        if ((a.y - rcl.y) * (b.y - rcl.y) < -EPS18) return true;
       }
     }
     return false;
   };
-  if (Math.abs(p1.x - p2.x) < EPS17 || Math.abs(p1.y - p2.y) < EPS17) {
+  if (Math.abs(p1.x - p2.x) < EPS18 || Math.abs(p1.y - p2.y) < EPS18) {
     return crossesSegment({ x: p1.x, y: p1.y }, { x: p2.x, y: p2.y });
   }
   const elbowHV = { x: p2.x, y: p1.y };
@@ -1657,8 +1657,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     if (!collision) {
       const first = path[0];
       const last = path[path.length - 1];
-      const EPS17 = 1e-9;
-      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS17 && Math.abs(p.y - q.y) < EPS17;
+      const EPS18 = 1e-9;
+      const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS18 && Math.abs(p.y - q.y) < EPS18;
       if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y }) && (!this.hasAmbiguousPinDirections || pathMatchesPinDirections({
         path,
         pin1: { ...PA, _facingDirection: directions[0] },
@@ -2013,13 +2013,13 @@ var applyJogToTerminalSegment = ({
   segmentIndex: si,
   offset,
   JOG_SIZE,
-  EPS: EPS17 = 1e-6
+  EPS: EPS18 = 1e-6
 }) => {
   if (si !== 0 && si !== pts.length - 2) return;
   const start = pts[si];
   const end = pts[si + 1];
-  const isVertical6 = Math.abs(start.x - end.x) < EPS17;
-  const isHorizontal5 = Math.abs(start.y - end.y) < EPS17;
+  const isVertical6 = Math.abs(start.x - end.x) < EPS18;
+  const isHorizontal5 = Math.abs(start.y - end.y) < EPS18;
   if (!isVertical6 && !isHorizontal5) return;
   const segDir = isVertical6 ? end.y > start.y ? 1 : -1 : end.x > start.x ? 1 : -1;
   if (pts.length === 2) {
@@ -2453,7 +2453,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return islands;
   }
   findNextOverlapIssue() {
-    const EPS17 = 2e-3;
+    const EPS18 = 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++) {
@@ -2480,7 +2480,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
           segmentBIndex,
           rangeOverlap
         }) => {
-          if (rangeOverlap > EPS17) {
+          if (rangeOverlap > EPS18) {
             const keyA = `${pathAIndex}:${segmentAIndex}`;
             const keyB = `${pathBIndex}:${segmentBIndex}`;
             if (!seenA.has(keyA)) {
@@ -2499,7 +2499,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
             }
             return;
           }
-          if (rangeOverlap < -EPS17) return;
+          if (rangeOverlap < -EPS18) return;
           const pathA = pathsA[pathAIndex].tracePath;
           const pathB = pathsB[pathBIndex].tracePath;
           const segmentAStart = pathA[segmentAIndex];
@@ -2522,8 +2522,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) < EPS17;
-            const aHorz = Math.abs(a1.y - a2.y) < EPS17;
+            const aVert = Math.abs(a1.x - a2.x) < EPS18;
+            const aHorz = Math.abs(a1.y - a2.y) < EPS18;
             if (!aVert && !aHorz) continue;
             for (let pb = 0; pb < pathsB.length; pb++) {
               const pathB = pathsB[pb];
@@ -2534,11 +2534,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) < EPS17;
-                const bHorz = Math.abs(b1.y - b2.y) < EPS17;
+                const bVert = Math.abs(b1.x - b2.x) < EPS18;
+                const bHorz = Math.abs(b1.y - b2.y) < EPS18;
                 if (!bVert && !bHorz) continue;
                 if (aVert && bVert) {
-                  if (Math.abs(a1.x - b1.x) < EPS17) {
+                  if (Math.abs(a1.x - b1.x) < EPS18) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2548,7 +2548,7 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
                     });
                   }
                 } else if (aHorz && bHorz) {
-                  if (Math.abs(a1.y - b1.y) < EPS17) {
+                  if (Math.abs(a1.y - b1.y) < EPS18) {
                     recordCollinearInteraction({
                       pathAIndex: pa,
                       segmentAIndex: sa,
@@ -2604,14 +2604,14 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
     return null;
   }
   findNextDiagonalSegment() {
-    const EPS17 = 2e-3;
+    const EPS18 = 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 isHorizontal5 = Math.abs(p1.y - p2.y) < EPS17;
-        const isVertical6 = Math.abs(p1.x - p2.x) < EPS17;
+        const isHorizontal5 = Math.abs(p1.y - p2.y) < EPS18;
+        const isVertical6 = Math.abs(p1.x - p2.x) < EPS18;
         if (!isHorizontal5 && !isVertical6) {
           return { mspPairId, tracePath, i, p1, p2 };
         }
@@ -2625,13 +2625,13 @@ var TraceOverlapShiftSolver = class extends BaseSolver {
       return false;
     }
     const { mspPairId, tracePath, i, p1, p2 } = diagonalInfo;
-    const EPS17 = 2e-3;
+    const EPS18 = 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) < EPS17 : false;
-    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS17 : false;
-    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS17 : false;
-    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS17 : false;
+    const prevIsVertical = p0 ? Math.abs(p0.x - p1.x) < EPS18 : false;
+    const prevIsHorizontal = p0 ? Math.abs(p0.y - p1.y) < EPS18 : false;
+    const nextIsVertical = p3 ? Math.abs(p2.x - p3.x) < EPS18 : false;
+    const nextIsHorizontal = p3 ? Math.abs(p2.y - p3.y) < EPS18 : false;
     const elbow1 = { x: p1.x, y: p2.y };
     const elbow2 = { x: p2.x, y: p1.y };
     let score1 = 0;
@@ -2793,24 +2793,24 @@ var ChipObstacleSpatialIndex = class {
 };
 
 // lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions.ts
-function segmentIntersectsRect2(p1, p2, rect, EPS17 = 1e-9) {
-  const isVert = Math.abs(p1.x - p2.x) < EPS17;
-  const isHorz = Math.abs(p1.y - p2.y) < EPS17;
+function segmentIntersectsRect2(p1, p2, rect, EPS18 = 1e-9) {
+  const isVert = Math.abs(p1.x - p2.x) < EPS18;
+  const isHorz = Math.abs(p1.y - p2.y) < EPS18;
   if (!isVert && !isHorz) return false;
   if (isVert) {
     const x = p1.x;
-    if (x < rect.minX - EPS17 || x > rect.maxX + EPS17) return false;
+    if (x < rect.minX - EPS18 || x > rect.maxX + EPS18) 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 > EPS17;
+    return overlap > EPS18;
   } else {
     const y = p1.y;
-    if (y < rect.minY - EPS17 || y > rect.maxY + EPS17) return false;
+    if (y < rect.minY - EPS18 || y > rect.maxY + EPS18) 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 > EPS17;
+    return overlap > EPS18;
   }
 }
 function rectIntersectsAnyTrace(bounds, inputTraceMap, hostPathId, hostSegIndex) {
@@ -3209,14 +3209,14 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
     };
     let bestCandidate = null;
     let bestScore = -Infinity;
-    const EPS17 = 1e-6;
+    const EPS18 = 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) < EPS17;
-        const isV = Math.abs(a.x - b.x) < EPS17;
+        const isH = Math.abs(a.y - b.y) < EPS18;
+        const isV = Math.abs(a.x - b.x) < EPS18;
         if (!isH && !isV) continue;
         const segmentAllowed = isH ? ["y+", "y-"] : ["x+", "x-"];
         const candidateOrients = orientations.filter(
@@ -5049,7 +5049,7 @@ var clipPathAtFirstIntersection = (tracePath, existingTraces) => {
   for (let pathIndex = 0; pathIndex < tracePath.length - 1; pathIndex++) {
     const pathStart = tracePath[pathIndex];
     const pathEnd = tracePath[pathIndex + 1];
-    const intersections = existingTraces.flatMap(
+    const intersections2 = existingTraces.flatMap(
       (trace) => trace.tracePath.slice(0, -1).flatMap((traceStart, traceIndex) => {
         const intersection2 = getAxisAlignedIntersection(
           pathStart,
@@ -5060,10 +5060,10 @@ var clipPathAtFirstIntersection = (tracePath, existingTraces) => {
         return intersection2 ? [intersection2] : [];
       })
     );
-    intersections.sort(
+    intersections2.sort(
       (first, second) => distance3(pathStart, first) - distance3(pathStart, second)
     );
-    const intersection = intersections[0];
+    const intersection = intersections2[0];
     if (!intersection) continue;
     const clippedPath = tracePath.slice(0, pathIndex + 1);
     if (distance3(clippedPath.at(-1), intersection) > EPS6) {
@@ -6800,7 +6800,7 @@ var getTraceObstacles = (allTraces, excludeTraceId) => {
 import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections";
 var EPS9 = 1e-6;
 var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
-  const intersections = [];
+  const intersections2 = [];
   for (const obstacle of obstacles) {
     const obstaclePath = obstacle.points;
     for (let i = 0; i < obstaclePath.length - 1; i++) {
@@ -6811,11 +6811,11 @@ var findIntersectionsWithObstacles = (p1, p2, obstacles) => {
       }
       const intersection = getSegmentIntersection(p1, p2, o1, o2);
       if (intersection) {
-        intersections.push(intersection);
+        intersections2.push(intersection);
       }
     }
   }
-  return intersections;
+  return intersections2;
 };
 var isSamePoint = (first, second) => Math.abs(first.x - second.x) < EPS9 && Math.abs(first.y - second.y) < EPS9;
 var findPerpendicularPathCrossings = (path, otherPath, options = {}) => {
@@ -7005,13 +7005,15 @@ var generatePerpendicularTraceDetours = ({
         bounds2[highBound] + clearance
       ])
     ].filter((coordinate) => coordinate !== void 0);
+    const remainingPath = path.slice(index + 2);
+    if (remainingPath.length === 0) remainingPath.push(end);
     return [...new Set(detourCoordinates)].map(
       (detour) => simplifyPath([
         ...path.slice(0, index + 1),
         { ...start, [movingAxis]: gate },
         { ...start, [movingAxis]: gate, [detourAxis]: detour },
         { ...end, [detourAxis]: detour },
-        ...path.slice(index + 2)
+        ...remainingPath
       ])
     );
   };
@@ -12400,6 +12402,33 @@ globalConnNetId: ${label.globalConnNetId}`
   }
 };
 
+// lib/solvers/InlineNetLabelSolver/getAnchoredNetLabelRenderedBounds.ts
+var getAnchoredNetLabelRenderedBounds = (placement) => {
+  if (placement.orientation !== "x-" && placement.orientation !== "x+") {
+    if (placement.netLabelText && placement.width > placement.height) {
+      const width2 = placement.height;
+      const height2 = placement.width;
+      const center2 = getCenterFromAnchor(
+        placement.anchorPoint,
+        placement.orientation,
+        width2,
+        height2
+      );
+      return getRectBounds(center2, width2, height2);
+    }
+    return getRectBounds(placement.center, placement.width, placement.height);
+  }
+  const width = Math.max(placement.width, placement.height);
+  const height = NET_LABEL_HORIZONTAL_HEIGHT;
+  const center = getCenterFromAnchor(
+    placement.anchorPoint,
+    placement.orientation,
+    width,
+    height
+  );
+  return getRectBounds(center, width, height);
+};
+
 // lib/solvers/NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver.ts
 var ANCHOR_TRACE_CLEARANCE = 1e-4;
 var SEGMENT_PARALLEL_EPS = 1e-6;
@@ -12440,6 +12469,19 @@ function sampleAnchorsAlongSegment(a, b) {
   return anchors;
 }
 var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
+  constructor(params) {
+    super();
+    this.params = params;
+    this.inputProblem = params.inputProblem;
+    this.traces = params.traces;
+    this.netLabelPlacements = params.netLabelPlacements;
+    this.outputNetLabelPlacements = [...params.netLabelPlacements];
+    this.chipIndex = params.inputProblem._chipObstacleSpatialIndex ?? (params.inputProblem.chips.length > 0 ? new ChipObstacleSpatialIndex(params.inputProblem.chips) : void 0);
+    this.traceMap = Object.fromEntries(
+      params.traces.map((t) => [t.mspPairId, t])
+    );
+  }
+  params;
   inputProblem;
   traces;
   netLabelPlacements;
@@ -12453,40 +12495,37 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
   labelsToTry = [];
   candidateQueue = [];
   candidateIndex = 0;
-  constructor(params) {
-    super();
-    this.inputProblem = params.inputProblem;
-    this.traces = params.traces;
-    this.netLabelPlacements = params.netLabelPlacements;
-    this.outputNetLabelPlacements = [...params.netLabelPlacements];
-    this.chipIndex = params.inputProblem._chipObstacleSpatialIndex ?? new ChipObstacleSpatialIndex(params.inputProblem.chips);
-    this.traceMap = Object.fromEntries(
-      params.traces.map((t) => [t.mspPairId, t])
-    );
-  }
   getConstructorParams() {
     return {
       inputProblem: this.inputProblem,
       traces: this.traces,
-      netLabelPlacements: this.netLabelPlacements
+      netLabelPlacements: this.netLabelPlacements,
+      fixedNetLabelPlacements: this.params.fixedNetLabelPlacements,
+      useRenderedLabelBounds: this.params.useRenderedLabelBounds
     };
   }
   getOutput() {
     return { netLabelPlacements: this.outputNetLabelPlacements };
   }
   labelBounds(label) {
-    return getRectBounds(label.center, label.width, label.height);
+    if (!this.params.useRenderedLabelBounds || this.params.fixedNetLabelPlacements?.includes(label))
+      return getRectBounds(label.center, label.width, label.height);
+    return getAnchoredNetLabelRenderedBounds(label);
   }
   collisionKey(a, b) {
     return [a.globalConnNetId, b.globalConnNetId].sort().join("::");
   }
   findNextCollidingPair() {
-    const labels = this.outputNetLabelPlacements;
-    for (let i = 0; i < labels.length; i++) {
+    const labels = [
+      ...this.outputNetLabelPlacements,
+      ...this.params.fixedNetLabelPlacements ?? []
+    ];
+    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
       for (let j = i + 1; j < labels.length; j++) {
         const a = labels[i];
         const b = labels[j];
-        if (a.globalConnNetId === b.globalConnNetId) continue;
+        if (a.globalConnNetId === b.globalConnNetId && !this.params.fixedNetLabelPlacements?.includes(b))
+          continue;
         if (this.skippedCollisionKeys.has(this.collisionKey(a, b))) continue;
         if (boundsOverlap2(this.labelBounds(a), this.labelBounds(b)))
           return [a, b];
@@ -12526,14 +12565,23 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
         center,
         width,
         height,
-        bounds: getRectBounds(center, width, height),
+        bounds: this.params.useRenderedLabelBounds ? getAnchoredNetLabelRenderedBounds({
+          ...label,
+          orientation,
+          anchorPoint: anchor,
+          center,
+          width,
+          height
+        }) : getRectBounds(center, width, height),
         hostPairId,
         hostSegIndex,
         status: null
       };
     };
-    const isPortOnly = label.mspConnectionPairIds.length === 0;
-    if (isPortOnly) {
+    const isAnchoredOnConnector = this.traces.some(
+      (trace) => this.params.netLabelConnectorTraceIds?.has(trace.mspPairId) && trace.globalConnNetId === label.globalConnNetId && tracePathContainsPoint(trace.tracePath, label.anchorPoint)
+    );
+    if (label.mspConnectionPairIds.length === 0 || isAnchoredOnConnector) {
       const allOrientations = ["x+", "x-", "y+", "y-"];
       const orderedOrientations = [
         label.orientation,
@@ -12578,7 +12626,7 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
   }
   checkCandidate(candidate, movingLabelNetId, obstacleLabels) {
     const { bounds, hostPairId, hostSegIndex } = candidate;
-    if (this.chipIndex.getChipsInBounds(bounds).length > 0)
+    if ((this.chipIndex?.getChipsInBounds(bounds).length ?? 0) > 0)
       return "chip-collision";
     if (rectIntersectsAnyTextBox(bounds, this.inputProblem))
       return "text-collision";
@@ -12586,7 +12634,8 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
       return "trace-collision";
     }
     for (const obstacle of obstacleLabels) {
-      if (obstacle.globalConnNetId === movingLabelNetId) continue;
+      if (obstacle.globalConnNetId === movingLabelNetId && !this.params.fixedNetLabelPlacements?.includes(obstacle))
+        continue;
       if (boundsOverlap2(bounds, this.labelBounds(obstacle)))
         return "label-collision";
     }
@@ -12598,6 +12647,27 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
     this.candidateIndex = 0;
     this.candidateResults = [];
   }
+  /** Reuse the normal anchor search for a local trace-clearance proposal. */
+  getNearbyValidPlacements(label, maxDistance) {
+    const distance7 = (candidate) => Math.hypot(
+      candidate.anchor.x - label.anchorPoint.x,
+      candidate.anchor.y - label.anchorPoint.y
+    );
+    const obstacles = [
+      ...this.outputNetLabelPlacements.filter((other) => other !== label),
+      ...this.params.fixedNetLabelPlacements ?? []
+    ];
+    return this.buildCandidatesForLabel(label).filter(
+      (candidate) => distance7(candidate) <= maxDistance && this.checkCandidate(candidate, label.globalConnNetId, obstacles) === "ok"
+    ).sort((a, b) => distance7(a) - distance7(b)).map((candidate) => ({
+      ...label,
+      orientation: candidate.orientation,
+      anchorPoint: candidate.anchor,
+      center: candidate.center,
+      width: candidate.width,
+      height: candidate.height
+    }));
+  }
   clearActiveSearch() {
     this.currentCollision = null;
     this.currentLabelToMove = null;
@@ -12614,7 +12684,9 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
         return;
       }
       this.currentCollision = pair;
-      this.labelsToTry = [pair[1], pair[0]];
+      this.labelsToTry = [pair[1], pair[0]].filter(
+        (label) => !(this.params.fixedNetLabelPlacements ?? []).includes(label)
+      );
       this.beginSearchForLabel(this.labelsToTry.shift());
       return;
     }
@@ -12638,9 +12710,10 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
       fixedLabel = labelB;
     }
     const obstacleLabels = [
-      ...this.outputNetLabelPlacements.filter(
-        (l) => l !== labelA && l !== labelB
-      ),
+      ...[
+        ...this.outputNetLabelPlacements,
+        ...this.params.fixedNetLabelPlacements ?? []
+      ].filter((l) => l !== labelA && l !== labelB),
       fixedLabel
     ];
     const status = this.checkCandidate(
@@ -13601,8 +13674,10 @@ var getHorizontalPinApproachPoint = ({
   return approachesFromFacingSide ? approachPoint : null;
 };
 var getAttachedLabelIndexes = (trace, netLabelPlacements) => netLabelPlacements.flatMap((label, index) => {
-  const labelOwnsTrace = label.mspConnectionPairIds.includes(trace.mspPairId) || label.mspConnectionPairIds.length === 0 && label.globalConnNetId === trace.globalConnNetId;
-  return labelOwnsTrace && tracePathContainsPoint(trace.tracePath, label.anchorPoint) ? [index] : [];
+  if (isLabelAttachedToTrace(label, trace) && tracePathContainsPoint(trace.tracePath, label.anchorPoint)) {
+    return [index];
+  }
+  return [];
 });
 var moveAttachedLabels = ({
   trace,
@@ -14084,7 +14159,7 @@ var candidateIsClear = ({
   }
   for (const otherTrace of otherNetTraces) {
     const countIntersections = (path) => {
-      const intersections = /* @__PURE__ */ new Set();
+      const intersections2 = /* @__PURE__ */ new Set();
       for (let i = 1; i < path.length; i++) {
         for (let j = 1; j < otherTrace.tracePath.length; j++) {
           const point = getSegmentIntersection3(
@@ -14094,10 +14169,10 @@ var candidateIsClear = ({
             otherTrace.tracePath[j]
           );
           if (point)
-            intersections.add(`${point.x.toFixed(6)},${point.y.toFixed(6)}`);
+            intersections2.add(`${point.x.toFixed(6)},${point.y.toFixed(6)}`);
         }
       }
-      return intersections.size;
+      return intersections2.size;
     };
     if (countIntersections(candidateTrace.tracePath) > countIntersections(originalTrace.tracePath)) {
       return false;
@@ -15027,6 +15102,422 @@ var TraceElbowTransitionSimplificationSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/InlineNetLabelSolver/getLocalTraceLabelShifts.ts
+import { getSegmentIntersection as getSegmentIntersection5 } from "@tscircuit/math-utils/line-intersections";
+
+// lib/solvers/InlineNetLabelSolver/getInlineLabelObstacles.ts
+var getInlineTerminalBounds = (label) => {
+  if (!label.stubTracePath) return null;
+  const epsilon = 1e-6;
+  return {
+    minX: Math.min(...label.stubTracePath.map((p) => p.x)) - epsilon,
+    maxX: Math.max(...label.stubTracePath.map((p) => p.x)) + epsilon,
+    minY: Math.min(...label.stubTracePath.map((p) => p.y)) - epsilon,
+    maxY: Math.max(...label.stubTracePath.map((p) => p.y)) + epsilon
+  };
+};
+var getInlineLabelObstacles = (inputProblem, placements) => {
+  const fixedLabels = placements.map((label) => ({
+    globalConnNetId: label.globalConnNetId,
+    netId: label.netId,
+    pinIds: label.pinIds,
+    mspConnectionPairIds: [],
+    anchorPoint: label.anchorPoint,
+    orientation: "y+",
+    center: label.center,
+    width: label.axis === "x" ? label.width : label.height,
+    height: label.axis === "x" ? label.height : label.width
+  }));
+  const terminalTraces = placements.flatMap((label) => {
+    if (!label.stubTracePath) return [];
+    const chip = inputProblem.chips.find(
+      (chip2) => chip2.pins.some((pin2) => label.pinIds.includes(pin2.pinId))
+    );
+    const pin = chip?.pins.find((pin2) => label.pinIds.includes(pin2.pinId));
+    if (!chip || !pin) return [];
+    const id = JSON.stringify([
+      "inline-terminal",
+      label.globalConnNetId,
+      [...label.pinIds].sort()
+    ]);
+    return [
+      {
+        mspPairId: id,
+        mspConnectionPairIds: [id],
+        globalConnNetId: label.globalConnNetId,
+        dcConnNetId: label.globalConnNetId,
+        pinIds: label.pinIds,
+        pins: [
+          { ...pin, chipId: chip.chipId },
+          { ...pin, ...label.stubTracePath[1], chipId: chip.chipId }
+        ],
+        tracePath: label.stubTracePath
+      }
+    ];
+  });
+  return { fixedLabels, terminalTraces };
+};
+
+// lib/solvers/InlineNetLabelSolver/getLocalTraceLabelShifts.ts
+var EPS15 = 1e-6;
+var CLEARANCE = 0.05;
+var hits = (path, bounds) => path.slice(1).some((p, i) => segmentIntersectsRect(path[i], p, bounds));
+var same = (a, b) => Math.hypot(a.x - b.x, a.y - b.y) < EPS15;
+var translate = (p, axis, distance7) => ({
+  ...p,
+  [axis]: p[axis] + distance7
+});
+var intersections = (a, b) => a.slice(1).flatMap(
+  (p, i) => b.slice(1).flatMap((q, j) => {
+    const point = getSegmentIntersection5(a[i], p, b[j], q);
+    return point ? [point] : [];
+  })
+);
+function* getLocalTraceLabelShifts(inputProblem, output, pendingInlinePlacements = []) {
+  const placements = [
+    ...output.inlineNetLabelPlacements,
+    ...pendingInlinePlacements
+  ];
+  const { fixedLabels, terminalTraces } = getInlineLabelObstacles(
+    inputProblem,
+    placements
+  );
+  const terminalBounds = placements.flatMap((label) => {
+    const bounds = getInlineTerminalBounds(label);
+    return bounds ? [{ label, bounds }] : [];
+  });
+  const obstacles = [
+    ...inputProblem.chips.map((chip) => ({
+      minX: chip.center.x - chip.width / 2,
+      maxX: chip.center.x + chip.width / 2,
+      minY: chip.center.y - chip.height / 2,
+      maxY: chip.center.y + chip.height / 2
+    })),
+    ...(inputProblem.textBoxes ?? []).map((box) => getTextBoxBounds(box))
+  ];
+  const inlineBounds = fixedLabels.map((label) => ({
+    minX: label.center.x - label.width / 2,
+    maxX: label.center.x + label.width / 2,
+    minY: label.center.y - label.height / 2,
+    maxY: label.center.y + label.height / 2
+  }));
+  const pinPositions = [
+    ...inputProblem.chips.flatMap((chip) => chip.pins),
+    ...output.traces.flatMap((trace) => trace.pins)
+  ];
+  for (const trace of output.traces) {
+    const path = simplifyPath(trace.tracePath);
+    for (let i = 0; i < path.length - 1; i++) {
+      const a = path[i], b = path[i + 1];
+      const axis = Math.abs(a.x - b.x) < EPS15 ? "x" : "y";
+      const along = axis === "x" ? "y" : "x";
+      if (Math.abs(a[axis] - b[axis]) > EPS15 || same(a, b)) continue;
+      const blocking = [
+        ...output.netLabelPlacements.filter((label) => label.globalConnNetId !== trace.globalConnNetId).map(getAnchoredNetLabelRenderedBounds),
+        ...inlineBounds,
+        ...terminalBounds.filter(
+          ({ label }) => !trace.pinIds.some((pinId) => label.pinIds.includes(pinId))
+        ).map(({ bounds }) => bounds)
+      ].filter((bounds) => segmentIntersectsRect(a, b, bounds));
+      if (!blocking.length) continue;
+      let low = Math.min(a[along], b[along]);
+      let high = Math.max(a[along], b[along]);
+      let expanded = true;
+      while (expanded) {
+        expanded = false;
+        for (const other of output.traces) {
+          if (other.globalConnNetId !== trace.globalConnNetId) continue;
+          for (let j = 1; j < other.tracePath.length; j++) {
+            const p = other.tracePath[j - 1], q = other.tracePath[j];
+            if (Math.abs(p[axis] - a[axis]) > EPS15 || Math.abs(q[axis] - a[axis]) > EPS15)
+              continue;
+            const min = Math.min(p[along], q[along]), max = Math.max(p[along], q[along]);
+            if (max < low - EPS15 || min > high + EPS15) continue;
+            if (min < low || max > high) expanded = true;
+            low = Math.min(low, min);
+            high = Math.max(high, max);
+          }
+        }
+      }
+      const onRail = (p) => Math.abs(p[axis] - a[axis]) < EPS15 && p[along] >= low - EPS15 && p[along] <= high + EPS15;
+      if (pinPositions.some(onRail)) continue;
+      const minKey = axis === "x" ? "minX" : "minY";
+      const maxKey = axis === "x" ? "maxX" : "maxY";
+      const localWidth = Math.max(
+        ...blocking.map((bounds) => bounds[maxKey] - bounds[minKey])
+      );
+      const railLabelBounds = output.netLabelPlacements.filter(
+        (label) => label.globalConnNetId === trace.globalConnNetId && onRail(label.anchorPoint)
+      ).map(getAnchoredNetLabelRenderedBounds);
+      const coordinates = [
+        ...new Set(
+          blocking.flatMap((bounds) => [
+            bounds[minKey] - CLEARANCE,
+            bounds[maxKey] + CLEARANCE,
+            ...railLabelBounds.filter((own) => boundsOverlap(own, bounds)).flatMap((own) => [
+              a[axis] + bounds[minKey] - CLEARANCE - own[maxKey],
+              a[axis] + bounds[maxKey] + CLEARANCE - own[minKey]
+            ])
+          ])
+        )
+      ].sort((x, y) => Math.abs(x - a[axis]) - Math.abs(y - a[axis]));
+      for (const coordinate of coordinates) {
+        const distance7 = coordinate - a[axis];
+        if (Math.abs(distance7) > localWidth + 2 * CLEARANCE) continue;
+        const traces = output.traces.map((other) => {
+          if (other.globalConnNetId !== trace.globalConnNetId || !other.tracePath.some(onRail))
+            return other;
+          return {
+            ...other,
+            tracePath: other.tracePath.map(
+              (p) => onRail(p) ? translate(p, axis, distance7) : p
+            )
+          };
+        });
+        const shiftedPaths = traces.filter((other, index) => other !== output.traces[index]).map((other) => other.tracePath);
+        let labels = output.netLabelPlacements.map((label) => {
+          if (label.globalConnNetId !== trace.globalConnNetId || !onRail(label.anchorPoint))
+            return label;
+          return {
+            ...label,
+            anchorPoint: translate(label.anchorPoint, axis, distance7),
+            center: translate(label.center, axis, distance7)
+          };
+        });
+        let blocked = false;
+        const movedOwnLabelBounds = labels.flatMap(
+          (label, index) => label !== output.netLabelPlacements[index] ? [getAnchoredNetLabelRenderedBounds(label)] : []
+        );
+        for (const [labelIndex, label] of labels.entries()) {
+          if (label.globalConnNetId === trace.globalConnNetId) continue;
+          const bounds = getAnchoredNetLabelRenderedBounds(label);
+          const clearanceEdges = movedOwnLabelBounds.filter((own) => boundsOverlap(own, bounds)).map((own) => own[distance7 > 0 ? maxKey : minKey]);
+          if (shiftedPaths.some((p) => hits(p, bounds)) && !output.traces.some(
+            (other) => other.globalConnNetId === trace.globalConnNetId && hits(other.tracePath, bounds)
+          ))
+            clearanceEdges.push(coordinate);
+          if (!clearanceEdges.length) continue;
+          const connectorIndex = traces.findIndex(
+            (candidate) => candidate.globalConnNetId === label.globalConnNetId && candidate.pinIds.length === 1 && candidate.tracePath.length === 3 && same(candidate.tracePath.at(-1), label.anchorPoint)
+          );
+          const connector = traces[connectorIndex];
+          if (!connector) {
+            const placementSolver = new NetLabelNetLabelCollisionSolver({
+              inputProblem,
+              traces: [...traces, ...terminalTraces],
+              netLabelPlacements: labels,
+              fixedNetLabelPlacements: fixedLabels,
+              useRenderedLabelBounds: true
+            });
+            const nearby = placementSolver.getNearbyValidPlacements(
+              label,
+              localWidth + Math.max(label.width, label.height)
+            )[0];
+            if (!nearby) {
+              blocked = true;
+              break;
+            }
+            labels[labelIndex] = nearby;
+            continue;
+          }
+          const [start, bend, end] = connector.tracePath;
+          if (Math.abs(bend[axis] - end[axis]) > EPS15 || Math.abs(start[along] - bend[along]) > EPS15) {
+            blocked = true;
+            break;
+          }
+          const delta = distance7 > 0 ? Math.max(...clearanceEdges) + CLEARANCE - bounds[minKey] : Math.min(...clearanceEdges) - CLEARANCE - bounds[maxKey];
+          if (Math.abs(delta) > localWidth + bounds[maxKey] - bounds[minKey] + 2 * CLEARANCE) {
+            blocked = true;
+            break;
+          }
+          const moved = {
+            ...label,
+            anchorPoint: translate(label.anchorPoint, axis, delta),
+            center: translate(label.center, axis, delta)
+          };
+          labels[labelIndex] = moved;
+          traces[connectorIndex] = {
+            ...connector,
+            tracePath: [start, translate(bend, axis, delta), moved.anchorPoint]
+          };
+        }
+        if (blocked) continue;
+        for (const [index, proposed] of traces.entries()) {
+          const original = output.traces[index];
+          if (proposed === original) continue;
+          const candidate = proposed.tracePath;
+          const previous = original.tracePath;
+          if (candidate.slice(1).some(
+            (p, index2) => Math.abs(p.x - candidate[index2].x) > EPS15 && Math.abs(p.y - candidate[index2].y) > EPS15
+          )) {
+            blocked = true;
+            break;
+          }
+          const dot = (a2, b2, c, d) => (b2.x - a2.x) * (d.x - c.x) + (b2.y - a2.y) * (d.y - c.y);
+          if (dot(previous[0], previous[1], candidate[0], candidate[1]) <= EPS15 || dot(
+            previous.at(-1),
+            previous.at(-2),
+            candidate.at(-1),
+            candidate.at(-2)
+          ) <= EPS15) {
+            blocked = true;
+            break;
+          }
+          const junctions = output.traces.filter(
+            (other) => other !== original && other.globalConnNetId === original.globalConnNetId
+          ).flatMap((other) => [
+            ...other.tracePath,
+            ...intersections(previous, other.tracePath)
+          ]).filter((p) => tracePathContainsPoint(previous, p)).map(
+            (p) => original.globalConnNetId === trace.globalConnNetId && onRail(p) ? translate(p, axis, distance7) : p
+          );
+          const protectedPoints = [
+            ...pinPositions.filter((p) => tracePathContainsPoint(previous, p)),
+            ...junctions
+          ];
+          if (protectedPoints.some(
+            (p) => !tracePathContainsPoint(candidate, p)
+          ) || pinPositions.some((p) => {
+            const clearance = {
+              minX: p.x - CLEARANCE,
+              maxX: p.x + CLEARANCE,
+              minY: p.y - CLEARANCE,
+              maxY: p.y + CLEARANCE
+            };
+            return hits(candidate, clearance) && !hits(previous, clearance);
+          }) || obstacles.some(
+            (bounds) => hits(candidate, bounds) && !hits(previous, bounds)
+          )) {
+            blocked = true;
+            break;
+          }
+          for (const other of [...traces, ...terminalTraces]) {
+            if (other.mspPairId === proposed.mspPairId || other.globalConnNetId === proposed.globalConnNetId)
+              continue;
+            const originalOther = output.traces.find((t) => t.mspPairId === other.mspPairId) ?? other;
+            if (doesPathCoincideWithTraces(candidate, [other]) || intersections(candidate, other.tracePath).length > intersections(previous, originalOther.tracePath).length) {
+              blocked = true;
+              break;
+            }
+          }
+          if (blocked) break;
+        }
+        if (blocked) continue;
+        for (const [index, label] of labels.entries()) {
+          if (label === output.netLabelPlacements[index]) continue;
+          const bounds = getAnchoredNetLabelRenderedBounds(label);
+          if (obstacles.some((obstacle) => boundsOverlap(bounds, obstacle)) || inlineBounds.some((other) => boundsOverlap(bounds, other))) {
+            blocked = true;
+            break;
+          }
+          if (labels.some(
+            (other, j) => index !== j && boundsOverlap(bounds, getAnchoredNetLabelRenderedBounds(other))
+          )) {
+            blocked = true;
+            break;
+          }
+          if ([...traces, ...terminalTraces].some(
+            (other) => other.globalConnNetId !== label.globalConnNetId && hits(other.tracePath, bounds)
+          )) {
+            blocked = true;
+            break;
+          }
+        }
+        if (!blocked) yield { ...output, traces, netLabelPlacements: labels };
+      }
+    }
+  }
+}
+
+// lib/solvers/InlineNetLabelSolver/getOutputLabelCollisions.ts
+var sameLabel = (a, b) => {
+  const first = [...a.pinIds].sort();
+  const second = [...b.pinIds].sort();
+  return a.globalConnNetId === b.globalConnNetId && first.length === second.length && first.every((pinId, index) => pinId === second[index]);
+};
+var sameOutputLabelCollision = (a, b) => {
+  if (a.kind === "label-label" && b.kind === "label-label")
+    return sameLabel(a.labels[0], b.labels[0]) && sameLabel(a.labels[1], b.labels[1]) || sameLabel(a.labels[0], b.labels[1]) && sameLabel(a.labels[1], b.labels[0]);
+  if (a.kind !== "trace-label" || b.kind !== "trace-label") return false;
+  const sameTrace = a.trace.kind === "routed" && b.trace.kind === "routed" ? a.trace.id === b.trace.id : a.trace.kind === "terminal" && b.trace.kind === "terminal" && sameLabel(a.trace.label, b.trace.label);
+  return sameTrace && a.target === b.target && sameLabel(a.label, b.label);
+};
+var getOutputLabelCollisions = (output) => {
+  const labels = [
+    ...output.netLabelPlacements,
+    ...output.inlineNetLabelPlacements
+  ].map((label) => ({
+    label,
+    bounds: "axis" in label ? {
+      minX: label.center.x - (label.axis === "x" ? label.width : label.height) / 2,
+      maxX: label.center.x + (label.axis === "x" ? label.width : label.height) / 2,
+      minY: label.center.y - (label.axis === "x" ? label.height : label.width) / 2,
+      maxY: label.center.y + (label.axis === "x" ? label.height : label.width) / 2
+    } : getAnchoredNetLabelRenderedBounds(label)
+  }));
+  const collisions = [];
+  const add = (collision) => {
+    if (!collisions.some((other) => sameOutputLabelCollision(collision, other)))
+      collisions.push(collision);
+  };
+  for (let i = 0; i < labels.length; i++)
+    for (const other of labels.slice(i + 1)) {
+      if (boundsOverlap(labels[i].bounds, other.bounds))
+        add({ kind: "label-label", labels: [labels[i].label, other.label] });
+    }
+  const traces = [
+    ...output.traces.map((trace) => ({
+      ...trace,
+      identity: { kind: "routed", id: trace.mspPairId }
+    })),
+    ...output.inlineNetLabelPlacements.flatMap(
+      (label) => label.stubTracePath ? [
+        {
+          identity: { kind: "terminal", label },
+          globalConnNetId: label.globalConnNetId,
+          tracePath: label.stubTracePath
+        }
+      ] : []
+    )
+  ];
+  for (const trace of traces)
+    for (const { label, bounds } of labels) {
+      if (("axis" in label || label.globalConnNetId !== trace.globalConnNetId) && trace.tracePath.slice(1).some(
+        (end, index) => segmentIntersectsRect(trace.tracePath[index], end, bounds)
+      ))
+        add({
+          kind: "trace-label",
+          trace: trace.identity,
+          label,
+          target: "text"
+        });
+    }
+  for (const label of output.inlineNetLabelPlacements) {
+    const bounds = getInlineTerminalBounds(label);
+    if (!bounds) continue;
+    for (const trace of output.traces) {
+      if (trace.pinIds.some((pinId) => label.pinIds.includes(pinId))) continue;
+      if (trace.tracePath.slice(1).some(
+        (end, index) => segmentIntersectsRect(trace.tracePath[index], end, bounds)
+      ))
+        add({
+          kind: "trace-label",
+          trace: { kind: "routed", id: trace.mspPairId },
+          label,
+          target: "terminal"
+        });
+    }
+  }
+  return collisions;
+};
+
+// lib/solvers/InlineNetLabelSolver/isLabelRepresentedInline.ts
+var isLabelRepresentedInline = (label, inlinePlacements) => label.pinIds.length > 0 && label.pinIds.every(
+  (pinId) => inlinePlacements.some(
+    (inline) => inline.globalConnNetId === label.globalConnNetId && inline.pinIds.includes(pinId)
+  )
+);
+
 // lib/solvers/InlineNetLabelSolver/alignPortOnlyInlineNetLabelStubs.ts
 var getStubDirection = (path) => {
   const [start, end] = path;
@@ -15102,12 +15593,7 @@ var alignPortOnlyInlineNetLabelStubs = ({
     groups.set(groupKey, group);
   }
   const alignedPlacements = [...placements];
-  const supersededGlobalNetIds = new Set(
-    placements.map((placement) => placement.globalConnNetId)
-  );
-  const retainedAnchoredLabelBounds = netLabelPlacements.filter(
-    (placement) => !supersededGlobalNetIds.has(placement.globalConnNetId)
-  ).map(getLabelBounds2);
+  const retainedAnchoredLabelBounds = netLabelPlacements.filter((placement) => !isLabelRepresentedInline(placement, placements)).map(getLabelBounds2);
   for (const group of groups.values()) {
     if (group.length < 2) continue;
     const targetLength = Math.max(
@@ -15216,22 +15702,6 @@ var getAxisAlignedSegments2 = (path, epsilon = 1e-6) => {
   return segments.sort((a, b) => b.length - a.length);
 };
 
-// lib/solvers/InlineNetLabelSolver/getAnchoredNetLabelRenderedBounds.ts
-var getAnchoredNetLabelRenderedBounds = (placement) => {
-  if (placement.orientation !== "x-" && placement.orientation !== "x+") {
-    return getRectBounds(placement.center, placement.width, placement.height);
-  }
-  const width = Math.max(placement.width, placement.height);
-  const height = NET_LABEL_HORIZONTAL_HEIGHT;
-  const center = getCenterFromAnchor(
-    placement.anchorPoint,
-    placement.orientation,
-    width,
-    height
-  );
-  return getRectBounds(center, width, height);
-};
-
 // lib/solvers/InlineNetLabelSolver/pushAnchoredNetLabelsAwayFromInlineLabels.ts
 var LABEL_CLEARANCE2 = 0.05;
 var POINT_EPSILON = 1e-6;
@@ -15279,29 +15749,37 @@ var isPointOnPath2 = (point, path) => {
   return false;
 };
 var getRequiredOutwardDistance = (label, inlineBounds) => {
-  const labelBounds = getAnchoredNetLabelRenderedBounds(label);
-  if (label.orientation === "x-" || label.orientation === "x+") {
-    const nearby2 = inlineBounds.filter(
-      (bounds) => labelBounds.minY < bounds.maxY && labelBounds.maxY > bounds.minY
+  let distance7 = 0;
+  for (let iteration = 0; iteration < inlineBounds.length; iteration++) {
+    const labelBounds = getAnchoredNetLabelRenderedBounds(
+      moveLabel(label, label.orientation, distance7)
     );
-    if (nearby2.length === 0) return 0;
-    if (label.orientation === "x-") {
-      const targetMaxX = Math.min(...nearby2.map((bounds) => bounds.minX));
-      return Math.max(0, labelBounds.maxX - targetMaxX + LABEL_CLEARANCE2);
+    const horizontal = label.orientation === "x-" || label.orientation === "x+";
+    const overlapping = inlineBounds.filter(
+      (bounds) => boundsOverlap(labelBounds, {
+        minX: bounds.minX - (horizontal ? LABEL_CLEARANCE2 : 0),
+        maxX: bounds.maxX + (horizontal ? LABEL_CLEARANCE2 : 0),
+        minY: bounds.minY - (horizontal ? 0 : LABEL_CLEARANCE2),
+        maxY: bounds.maxY + (horizontal ? 0 : LABEL_CLEARANCE2)
+      })
+    );
+    if (overlapping.length === 0) break;
+    switch (label.orientation) {
+      case "x-":
+        distance7 += labelBounds.maxX - Math.min(...overlapping.map((b) => b.minX)) + LABEL_CLEARANCE2;
+        break;
+      case "x+":
+        distance7 += Math.max(...overlapping.map((b) => b.maxX)) - labelBounds.minX + LABEL_CLEARANCE2;
+        break;
+      case "y-":
+        distance7 += labelBounds.maxY - Math.min(...overlapping.map((b) => b.minY)) + LABEL_CLEARANCE2;
+        break;
+      case "y+":
+        distance7 += Math.max(...overlapping.map((b) => b.maxY)) - labelBounds.minY + LABEL_CLEARANCE2;
+        break;
     }
-    const targetMinX = Math.max(...nearby2.map((bounds) => bounds.maxX));
-    return Math.max(0, targetMinX - labelBounds.minX + LABEL_CLEARANCE2);
   }
-  const nearby = inlineBounds.filter(
-    (bounds) => labelBounds.minX < bounds.maxX && labelBounds.maxX > bounds.minX
-  );
-  if (nearby.length === 0) return 0;
-  if (label.orientation === "y-") {
-    const targetMaxY = Math.min(...nearby.map((bounds) => bounds.minY));
-    return Math.max(0, labelBounds.maxY - targetMaxY + LABEL_CLEARANCE2);
-  }
-  const targetMinY = Math.max(...nearby.map((bounds) => bounds.maxY));
-  return Math.max(0, targetMinY - labelBounds.minY + LABEL_CLEARANCE2);
+  return distance7;
 };
 var moveLabel = (label, orientation, distance7) => {
   const direction = dir(orientation);
@@ -15336,10 +15814,9 @@ var boundsGapOnPerpendicularAxis = (a, b, orientation) => {
   return Math.max(0, a.minX - b.maxX, b.minX - a.maxX);
 };
 var sharesOwnerChip = (label, ownerChipIds, chipIdByPinId) => label.pinIds.some((pinId) => ownerChipIds.has(chipIdByPinId.get(pinId) ?? ""));
-var isGeneratedLabelConnector = (trace) => trace.mspPairId.startsWith("available-net-orientation-") || trace.mspPairId.startsWith("inline-net-label-clearance-");
-var findConnectorTraceIndex = (label, traces) => traces.findIndex((trace) => {
+var findConnectorTraceIndex = (label, traces, connectorTraceIds) => traces.findIndex((trace) => {
   if (trace.globalConnNetId !== label.globalConnNetId) return false;
-  if (!isGeneratedLabelConnector(trace)) return false;
+  if (!connectorTraceIds.has(trace.mspPairId)) return false;
   const first = trace.tracePath[0];
   const last = trace.tracePath.at(-1);
   return Boolean(
@@ -15422,8 +15899,10 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
   inputProblem,
   traces,
   netLabelPlacements,
-  inlineNetLabelPlacements
+  inlineNetLabelPlacements,
+  netLabelConnectorTraceIds = /* @__PURE__ */ new Set()
 }) => {
+  const connectorTraceIds = new Set(netLabelConnectorTraceIds);
   const outputTraces = traces.map((trace) => ({
     ...trace,
     tracePath: trace.tracePath.map((point) => ({ ...point }))
@@ -15467,7 +15946,11 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
             moveLabel(obstacle, trigger.orientation, existingObstacleDistance)
           );
           if (!boundsOverlap(movingBounds, obstacleBounds)) continue;
-          if (!sharesOwnerChip(obstacle, ownerChipIds, chipIdByPinId) || findConnectorTraceIndex(obstacle, outputTraces) === -1 && !canAddConnectorAtAnchor(obstacle, outputTraces, pinMap)) {
+          if (!sharesOwnerChip(obstacle, ownerChipIds, chipIdByPinId) || findConnectorTraceIndex(
+            obstacle,
+            outputTraces,
+            connectorTraceIds
+          ) === -1 && !canAddConnectorAtAnchor(obstacle, outputTraces, pinMap)) {
             failed = true;
             break;
           }
@@ -15539,7 +16022,11 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
     const connectorUpdates = [];
     for (const [labelIndex, movedLabel] of proposals) {
       const label = outputLabels[labelIndex];
-      const connectorIndex = findConnectorTraceIndex(label, outputTraces);
+      const connectorIndex = findConnectorTraceIndex(
+        label,
+        outputTraces,
+        connectorTraceIds
+      );
       if (connectorIndex === -1 && !canAddConnectorAtAnchor(label, outputTraces, pinMap)) {
         failed = true;
         break;
@@ -15589,6 +16076,7 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
       movedLabelIndices.add(labelIndex);
     }
     for (const update of connectorUpdates) {
+      connectorTraceIds.add(update.trace.mspPairId);
       if (update.connectorIndex === -1) outputTraces.push(update.trace);
       else outputTraces[update.connectorIndex] = update.trace;
     }
@@ -15596,7 +16084,8 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
   return {
     traces: outputTraces,
     netLabelPlacements: outputLabels,
-    movedLabelCount: movedLabelIndices.size
+    movedLabelCount: movedLabelIndices.size,
+    netLabelConnectorTraceIds: connectorTraceIds
   };
 };
 
@@ -15798,7 +16287,7 @@ var pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
 };
 
 // lib/solvers/InlineNetLabelSolver/restoreReroutesAroundSupersededLabels.ts
-import { getSegmentIntersection as getSegmentIntersection5 } from "@tscircuit/math-utils/line-intersections";
+import { getSegmentIntersection as getSegmentIntersection6 } from "@tscircuit/math-utils/line-intersections";
 
 // lib/utils/pathIntersectsRenderedLabel.ts
 import {
@@ -15826,31 +16315,31 @@ var pathIntersectsRenderedLabel = (path, label) => {
 };
 
 // lib/solvers/InlineNetLabelSolver/restoreReroutesAroundSupersededLabels.ts
-var EPS15 = 1e-6;
+var EPS16 = 1e-6;
 var getPathLength7 = (path) => path.slice(1).reduce((length, point, pointIndex) => {
   const previousPoint = path[pointIndex];
   return length + Math.abs(point.x - previousPoint.x) + Math.abs(point.y - previousPoint.y);
 }, 0);
 var pathsEqual = (first, second) => first.length === second.length && first.every(
-  (point, index) => Math.abs(point.x - second[index].x) <= EPS15 && Math.abs(point.y - second[index].y) <= EPS15
+  (point, index) => Math.abs(point.x - second[index].x) <= EPS16 && Math.abs(point.y - second[index].y) <= EPS16
 );
-var isStrictlySimpler = (candidate, current) => candidate.length < current.length && getPathLength7(candidate) <= getPathLength7(current) + EPS15;
+var isStrictlySimpler = (candidate, current) => candidate.length < current.length && getPathLength7(candidate) <= getPathLength7(current) + EPS16;
 var getIntersectionKeys = (path, otherPath) => {
-  const intersections = /* @__PURE__ */ new Set();
+  const intersections2 = /* @__PURE__ */ new Set();
   for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
     for (let otherPathIndex = 0; otherPathIndex < otherPath.length - 1; otherPathIndex++) {
-      const point = getSegmentIntersection5(
+      const point = getSegmentIntersection6(
         path[pathIndex],
         path[pathIndex + 1],
         otherPath[otherPathIndex],
         otherPath[otherPathIndex + 1]
       );
       if (point) {
-        intersections.add(`${point.x.toFixed(6)},${point.y.toFixed(6)}`);
+        intersections2.add(`${point.x.toFixed(6)},${point.y.toFixed(6)}`);
       }
     }
   }
-  return intersections;
+  return intersections2;
 };
 var introducesNewCrossings = (candidatePath, currentPath, otherPaths) => otherPaths.some((otherPath) => {
   const currentIntersections = getIntersectionKeys(currentPath, otherPath);
@@ -15927,9 +16416,7 @@ var DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
 var INLINE_NET_LABEL_TRACE_MARGIN = 0.05;
 var INLINE_NET_LABEL_STUB_TRACE_CLEARANCE = 0.05;
 var INLINE_NET_LABEL_MAX_SPAN_JOG = 0.4;
-var AVAILABLE_NET_ORIENTATION_TRACE_PREFIX = "available-net-orientation-";
-var isGeneratedAnchoredLabelConnector = (trace) => trace.mspPairId.startsWith(AVAILABLE_NET_ORIENTATION_TRACE_PREFIX);
-var getPinPairKey2 = (pinIds) => [...pinIds].sort().join("::");
+var getPinPairKey2 = (pinIds) => JSON.stringify([...pinIds].sort());
 var getTraceLength2 = (trace) => {
   let length = 0;
   for (let index = 0; index < trace.tracePath.length - 1; index++) {
@@ -15950,21 +16437,26 @@ var getInlinePlacementBounds = (placement) => {
     maxY: placement.center.y + renderedHeight / 2
   };
 };
-var InlineNetLabelSolver = class extends BaseSolver {
-  inputProblem;
-  traces;
-  inputNetLabelPlacements;
-  completedReroutes;
-  inlineNetLabelPlacements = [];
-  /** Eligible connections still waiting to be processed. */
-  queuedConnections;
-  tracesByPinPairKey;
-  globalConnMap;
-  supersededTraceIdsByGlobalConnNetId = /* @__PURE__ */ new Map();
-  hasAlignedPortOnlyStubs = false;
-  postProcessedOutput;
+var getInlinePlacementKey = (placement) => JSON.stringify([
+  placement.globalConnNetId,
+  [...placement.pinIds].sort(),
+  placement.mspPairId ?? null
+]);
+var terminalStubIntersectsTrace = (path, trace) => {
+  const clearance = INLINE_NET_LABEL_STUB_TRACE_CLEARANCE - GEOMETRY_EPSILON;
+  const bounds = {
+    minX: Math.min(path[0].x, path[1].x) - clearance,
+    maxX: Math.max(path[0].x, path[1].x) + clearance,
+    minY: Math.min(path[0].y, path[1].y) - clearance,
+    maxY: Math.max(path[0].y, path[1].y) + clearance
+  };
+  return doesPathIntersectBounds3(trace.tracePath, bounds);
+};
+var InlineNetLabelSolver = class _InlineNetLabelSolver extends BaseSolver {
   constructor(input) {
     super();
+    this.input = input;
+    this.netLabelConnectorTraceIds = input.netLabelConnectorTraceIds ?? /* @__PURE__ */ new Set();
     this.inputProblem = input.inputProblem;
     this.traces = input.traces;
     this.inputNetLabelPlacements = input.netLabelPlacements;
@@ -15974,7 +16466,11 @@ var InlineNetLabelSolver = class extends BaseSolver {
     ).netConnMap;
     this.queuedConnections = [
       ...this.inputProblem.directConnections.filter(
-        (connection) => connection.allowInlineNetLabel && connection.netId
+        (connection) => connection.allowInlineNetLabel && connection.netId && // An opted-in named net owns all of its connected components.
+        // Do not plan the same pair again through its direct connection.
+        !this.inputProblem.netConnections.some(
+          (net) => net.allowInlineNetLabel && net.netId && connection.pinIds.every((pin) => net.pinIds.includes(pin))
+        )
       ).map((connection) => ({
         kind: "direct_connection",
         connection
@@ -15988,7 +16484,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     ];
     this.tracesByPinPairKey = /* @__PURE__ */ new Map();
     for (const trace of this.traces) {
-      if (isGeneratedAnchoredLabelConnector(trace)) continue;
+      if (this.netLabelConnectorTraceIds.has(trace.mspPairId)) continue;
       const key = getPinPairKey2(trace.pins.map((p) => p.pinId));
       const existing = this.tracesByPinPairKey.get(key);
       if (existing) {
@@ -15998,13 +16494,32 @@ var InlineNetLabelSolver = class extends BaseSolver {
       }
     }
   }
+  input;
+  inputProblem;
+  traces;
+  inputNetLabelPlacements;
+  completedReroutes;
+  inlineNetLabelPlacements = [];
+  /** Eligible connections still waiting to be processed. */
+  queuedConnections;
+  netLabelConnectorTraceIds;
+  tracesByPinPairKey;
+  globalConnMap;
+  inlineConversions = [];
+  hasAlignedPortOnlyStubs = false;
+  postProcessedOutput;
+  refinementComplete = false;
+  refinement;
+  currentProposal;
   getConstructorParams() {
     return [
       {
         inputProblem: this.inputProblem,
         traces: this.traces,
         netLabelPlacements: this.inputNetLabelPlacements,
-        completedReroutes: this.completedReroutes
+        completedReroutes: this.completedReroutes,
+        resolveTraceCollisions: this.input.resolveTraceCollisions,
+        netLabelConnectorTraceIds: this.netLabelConnectorTraceIds
       }
     ];
   }
@@ -16025,16 +16540,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
           netConnections
         )) {
           this.inlineNetLabelPlacements.push(...conversion.placements);
-          const supersededTraceIds = this.supersededTraceIdsByGlobalConnNetId.get(
-            conversion.globalConnNetId
-          ) ?? /* @__PURE__ */ new Set();
-          for (const traceId of conversion.supersededTraceIds) {
-            supersededTraceIds.add(traceId);
-          }
-          this.supersededTraceIdsByGlobalConnNetId.set(
-            conversion.globalConnNetId,
-            supersededTraceIds
-          );
+          this.inlineConversions.push(conversion);
         }
         return;
       }
@@ -16048,11 +16554,12 @@ var InlineNetLabelSolver = class extends BaseSolver {
         });
         if (placement) this.inlineNetLabelPlacements.push(placement);
       } else {
-        const terminalPlacements = connection.pinIds.map(
-          (pinId) => this.computeTerminalInlinePlacement(connection, pinId)
-        );
-        if (terminalPlacements.every((placement) => placement !== null)) {
-          this.inlineNetLabelPlacements.push(...terminalPlacements);
+        for (const pinId of connection.pinIds) {
+          const placement = this.computeTerminalInlinePlacement(
+            connection,
+            pinId
+          );
+          if (placement) this.inlineNetLabelPlacements.push(placement);
         }
       }
       return;
@@ -16071,13 +16578,17 @@ var InlineNetLabelSolver = class extends BaseSolver {
       this.postProcessedOutput = this.buildPostProcessedOutput();
       return;
     }
+    if (this.input.resolveTraceCollisions && !this.refinementComplete) {
+      this.stepTraceRefinement();
+      return;
+    }
     this.solved = true;
     this.stats.inlineNetLabelCount = this.inlineNetLabelPlacements.length;
   }
   /**
    * Plans all opted-in multi-pin nets together. Short routed components can
    * mutually block the outward endpoint stubs that replace them, so tentative
-   * replacements are ignored as obstacles only while their owning net still
+   * replacements are ignored as obstacles only while their connected component still
    * converts successfully. Failed conversions retain both their traces and
    * their conventional labels, and the remaining conversions are retried.
    */
@@ -16118,13 +16629,11 @@ var InlineNetLabelSolver = class extends BaseSolver {
       }));
       const nextIgnoredTraceIds = new Set(
         conversions.flatMap(
-          ({ conversion }) => conversion ? [...conversion.supersededTraceIds] : []
+          ({ conversion }) => conversion.flatMap((component) => [...component.supersededTraceIds])
         )
       );
       if (setsEqual(ignoredTraceIds, nextIgnoredTraceIds)) {
-        return conversions.flatMap(
-          ({ conversion }) => conversion ? [conversion] : []
-        );
+        return conversions.flatMap(({ conversion }) => conversion);
       }
       ignoredTraceIds = nextIgnoredTraceIds;
     }
@@ -16154,7 +16663,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
       // anchored label. They are removed when that label becomes inline, so
       // treating them as routed circuitry would leave text on a deleted wire.
       traces: this.traces.filter(
-        (trace) => !isGeneratedAnchoredLabelConnector(trace)
+        (trace) => !this.netLabelConnectorTraceIds.has(trace.mspPairId)
       )
     }).map((component) => ({
       pinIds: component.pinIds,
@@ -16180,14 +16689,14 @@ var InlineNetLabelSolver = class extends BaseSolver {
    * Converts every conventional label representation for an opted-in named
    * net. Routed connected components become labels on their representative
    * trace; disconnected pins become outward terminal stubs. The conversion is
-   * atomic so one blocked candidate cannot leave mixed label styles on a net.
+   * atomic within each routed component, so replacing its traces cannot strand
+   * a pin. Disconnected components can keep their own label style.
    */
   computeNetConnectionInlinePlacements(connection, ignoredTraceIds, forcedTerminalTraceIds) {
     const components = this.getNetConnectionComponents(connection);
     const globalConnNetId = this.getGlobalConnNetId(connection);
-    if (!globalConnNetId) return null;
-    const inlinePlacements = [];
-    const supersededTraceIds = /* @__PURE__ */ new Set();
+    if (!globalConnNetId) return [];
+    const conversions = [];
     for (const component of components) {
       const shouldUseTerminalStubs = component.traces.some(
         (trace) => forcedTerminalTraceIds.has(trace.mspPairId)
@@ -16205,14 +16714,18 @@ var InlineNetLabelSolver = class extends BaseSolver {
         }
       }
       if (inlinePlacement) {
-        inlinePlacements.push(inlinePlacement);
+        conversions.push({
+          globalConnNetId,
+          placements: [inlinePlacement],
+          supersededTraceIds: /* @__PURE__ */ new Set()
+        });
         continue;
       }
       if (component.traces.length > 0 && !shouldUseTerminalStubs) {
-        return null;
+        continue;
       }
       if (component.labeledPinIds.length !== component.pinIds.length) {
-        return null;
+        continue;
       }
       const terminalPlacements = component.pinIds.map(
         (pinId) => this.computeTerminalInlinePlacement(
@@ -16223,26 +16736,41 @@ var InlineNetLabelSolver = class extends BaseSolver {
         )
       );
       if (terminalPlacements.some((placement) => placement === null)) {
-        return null;
+        continue;
       }
-      inlinePlacements.push(
-        ...terminalPlacements.filter(
-          (placement) => placement !== null
+      conversions.push({
+        globalConnNetId,
+        placements: terminalPlacements,
+        supersededTraceIds: new Set(
+          component.traces.map((trace) => trace.mspPairId)
         )
-      );
-      for (const trace of component.traces) {
-        supersededTraceIds.add(trace.mspPairId);
+      });
+    }
+    return conversions;
+  }
+  /** Prefer the normal gap, then center text in a tighter parallel-wire slot. */
+  getInlineOffsets(anchor, axis, side, width, height, traces, ignoredTraceIds) {
+    const normal = height / 2 + INLINE_NET_LABEL_TRACE_MARGIN;
+    const across = axis === "x" ? "y" : "x";
+    const sign = side === "x+" || side === "y+" ? 1 : -1;
+    let gap = Infinity;
+    for (const trace of traces) {
+      if (ignoredTraceIds.has(trace.mspPairId)) continue;
+      for (const segment of getAxisAlignedSegments2(trace.tracePath)) {
+        if (segment.axis !== axis) continue;
+        if (Math.max(segment.start[axis], segment.end[axis]) <= anchor[axis] - width / 2 || Math.min(segment.start[axis], segment.end[axis]) >= anchor[axis] + width / 2)
+          continue;
+        const distance7 = sign * (segment.start[across] - anchor[across]);
+        if (distance7 > GEOMETRY_EPSILON) gap = Math.min(gap, distance7);
       }
     }
-    return { globalConnNetId, placements: inlinePlacements, supersededTraceIds };
+    return gap > height + GEOMETRY_EPSILON && gap / 2 < normal - GEOMETRY_EPSILON ? [normal, gap / 2] : [normal];
   }
   /**
-   * Converts one conventional endpoint placement into an inline label on a
-   * generated outward stub. The stub follows the pin's true facing direction;
-   * an anchored label may finish in another direction after an elbow, which is
-   * not the direction a terminal stub should leave the pin.
+   * Converts one conventional endpoint placement into an inline label on an
+   * outward stub that follows the pin's true facing direction.
    */
-  computeTerminalInlinePlacement(connection, pinId, knownGlobalConnNetId, ignoredTraceIds = /* @__PURE__ */ new Set()) {
+  computeTerminalInlinePlacement(connection, pinId, knownGlobalConnNetId, ignoredTraceIds = /* @__PURE__ */ new Set(), obstacles) {
     if (!connection.netId) return null;
     const anchoredPlacement = this.inputNetLabelPlacements.find(
       (placement) => placement.netId === connection.netId && placement.pinIds.length === 1 && placement.pinIds[0] === pinId
@@ -16265,7 +16793,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
       start,
       intendedEnd,
       minimumLength: width + 2 * INLINE_NET_LABEL_TRACE_MARGIN,
-      traces: this.traces,
+      traces: obstacles?.traces ?? this.traces,
       ownGlobalConnNetId: globalConnNetId,
       ignoredTraceIds
     });
@@ -16275,42 +16803,52 @@ var InlineNetLabelSolver = class extends BaseSolver {
       x: (start.x + end.x) / 2,
       y: (start.y + end.y) / 2
     };
-    const offset = height / 2 + INLINE_NET_LABEL_TRACE_MARGIN;
     const sides = axis === "x" ? ["y+", "y-"] : ["x-", "x+"];
     for (const side of sides) {
-      const center = side === "y+" ? { x: anchorPoint.x, y: anchorPoint.y + offset } : side === "y-" ? { x: anchorPoint.x, y: anchorPoint.y - offset } : side === "x-" ? { x: anchorPoint.x - offset, y: anchorPoint.y } : { x: anchorPoint.x + offset, y: anchorPoint.y };
-      const halfAlong = width / 2;
-      const halfAcross = height / 2;
-      const bounds = axis === "x" ? {
-        minX: center.x - halfAlong,
-        maxX: center.x + halfAlong,
-        minY: center.y - halfAcross,
-        maxY: center.y + halfAcross
-      } : {
-        minX: center.x - halfAcross,
-        maxX: center.x + halfAcross,
-        minY: center.y - halfAlong,
-        maxY: center.y + halfAlong
-      };
-      if (this.isObstructed(bounds, {
-        ownGlobalConnNetId: globalConnNetId,
-        ignoredTraceIds
-      })) {
-        continue;
-      }
-      return {
-        globalConnNetId,
-        netId: connection.netId,
-        netLabelText,
-        pinIds: [pinId],
-        stubTracePath: [start, end],
-        axis,
+      for (const offset of this.getInlineOffsets(
         anchorPoint,
-        center,
+        axis,
+        side,
         width,
         height,
-        side
-      };
+        obstacles?.traces ?? this.traces,
+        ignoredTraceIds
+      )) {
+        const center = side === "y+" ? { x: anchorPoint.x, y: anchorPoint.y + offset } : side === "y-" ? { x: anchorPoint.x, y: anchorPoint.y - offset } : side === "x-" ? { x: anchorPoint.x - offset, y: anchorPoint.y } : { x: anchorPoint.x + offset, y: anchorPoint.y };
+        const halfAlong = width / 2;
+        const halfAcross = height / 2;
+        const bounds = axis === "x" ? {
+          minX: center.x - halfAlong,
+          maxX: center.x + halfAlong,
+          minY: center.y - halfAcross,
+          maxY: center.y + halfAcross
+        } : {
+          minX: center.x - halfAcross,
+          maxX: center.x + halfAcross,
+          minY: center.y - halfAlong,
+          maxY: center.y + halfAlong
+        };
+        if (this.isObstructed(bounds, {
+          ownGlobalConnNetId: globalConnNetId,
+          ignoredTraceIds,
+          obstacles
+        })) {
+          continue;
+        }
+        return {
+          globalConnNetId,
+          netId: connection.netId,
+          netLabelText,
+          pinIds: [pinId],
+          stubTracePath: [start, end],
+          axis,
+          anchorPoint,
+          center,
+          width,
+          height,
+          side
+        };
+      }
     }
     return null;
   }
@@ -16331,39 +16869,49 @@ var InlineNetLabelSolver = class extends BaseSolver {
       const sides = segment.axis === "x" ? ["y+", "y-"] : ["x-", "x+"];
       for (const side of sides) {
         for (const anchorPoint of getAnchorCandidates(segment, width)) {
-          const center = side === "y+" ? { x: anchorPoint.x, y: anchorPoint.y + offset } : side === "y-" ? { x: anchorPoint.x, y: anchorPoint.y - offset } : side === "x-" ? { x: anchorPoint.x - offset, y: anchorPoint.y } : { x: anchorPoint.x + offset, y: anchorPoint.y };
-          const halfAlong = width / 2;
-          const halfAcross = height / 2;
-          const bounds = segment.axis === "x" ? {
-            minX: center.x - halfAlong,
-            maxX: center.x + halfAlong,
-            minY: center.y - halfAcross,
-            maxY: center.y + halfAcross
-          } : {
-            minX: center.x - halfAcross,
-            maxX: center.x + halfAcross,
-            minY: center.y - halfAlong,
-            maxY: center.y + halfAlong
-          };
-          if (this.isObstructed(bounds, {
-            ownTrace: trace,
-            ownGlobalConnNetId: trace.globalConnNetId,
-            ignoredTraceIds
-          }))
-            continue;
-          return {
-            globalConnNetId: trace.globalConnNetId,
-            netId: connection.netId,
-            netLabelText,
-            mspPairId: trace.mspPairId,
-            pinIds: [...pinIds],
-            axis: segment.axis,
+          for (const offset2 of this.getInlineOffsets(
             anchorPoint,
-            center,
+            segment.axis,
+            side,
             width,
             height,
-            side
-          };
+            this.traces,
+            ignoredTraceIds
+          )) {
+            const center = side === "y+" ? { x: anchorPoint.x, y: anchorPoint.y + offset2 } : side === "y-" ? { x: anchorPoint.x, y: anchorPoint.y - offset2 } : side === "x-" ? { x: anchorPoint.x - offset2, y: anchorPoint.y } : { x: anchorPoint.x + offset2, y: anchorPoint.y };
+            const halfAlong = width / 2;
+            const halfAcross = height / 2;
+            const bounds = segment.axis === "x" ? {
+              minX: center.x - halfAlong,
+              maxX: center.x + halfAlong,
+              minY: center.y - halfAcross,
+              maxY: center.y + halfAcross
+            } : {
+              minX: center.x - halfAcross,
+              maxX: center.x + halfAcross,
+              minY: center.y - halfAlong,
+              maxY: center.y + halfAlong
+            };
+            if (this.isObstructed(bounds, {
+              ownTrace: trace,
+              ownGlobalConnNetId: trace.globalConnNetId,
+              ignoredTraceIds
+            }))
+              continue;
+            return {
+              globalConnNetId: trace.globalConnNetId,
+              netId: connection.netId,
+              netLabelText,
+              mspPairId: trace.mspPairId,
+              pinIds: [...pinIds],
+              axis: segment.axis,
+              anchorPoint,
+              center,
+              width,
+              height,
+              side
+            };
+          }
         }
       }
     }
@@ -16473,7 +17021,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
   isObstructed(bounds, {
     ownTrace,
     ownGlobalConnNetId,
-    ignoredTraceIds = /* @__PURE__ */ new Set()
+    ignoredTraceIds = /* @__PURE__ */ new Set(),
+    obstacles
   }) {
     for (const chip of this.inputProblem.chips) {
       const chipBounds = {
@@ -16487,82 +17036,102 @@ var InlineNetLabelSolver = class extends BaseSolver {
     for (const textBox of this.inputProblem.textBoxes ?? []) {
       if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
     }
-    for (const trace of this.traces) {
+    for (const trace of obstacles?.traces ?? this.traces) {
       if (ignoredTraceIds.has(trace.mspPairId)) continue;
       if (ownTrace && trace.mspPairId === ownTrace.mspPairId) continue;
       if (trace.globalConnNetId === ownGlobalConnNetId) continue;
       if (doesPathIntersectBounds3(trace.tracePath, bounds)) return true;
     }
+    if (obstacles?.anchored.some(
+      (label) => boundsOverlap(bounds, getAnchoredNetLabelRenderedBounds(label))
+    ))
+      return true;
+    if (obstacles?.inline.some(
+      (label) => boundsOverlap(bounds, getInlinePlacementBounds(label)) || label.stubTracePath && label.globalConnNetId !== ownGlobalConnNetId && doesPathIntersectBounds3(label.stubTracePath, bounds)
+    ))
+      return true;
     return false;
   }
-  /**
-   * Net label placements superseded by an inline label. A net gets one label or
-   * the other, never both.
-   */
-  getSupersededNetLabelKeys(placements = this.inlineNetLabelPlacements) {
-    const keys = /* @__PURE__ */ new Set();
-    for (const placement of placements) {
-      keys.add(placement.globalConnNetId);
-    }
-    return keys;
-  }
-  getOutputTraces(supersededNetLabelKeys, supersededTraceIds) {
+  getOutputTraces(placements) {
+    const activeKeys = new Set(placements.map(getInlinePlacementKey));
+    const supersededTraceIds = new Set(
+      this.inlineConversions.filter(
+        (conversion) => conversion.placements.every(
+          (placement) => activeKeys.has(getInlinePlacementKey(placement))
+        )
+      ).flatMap((conversion) => [...conversion.supersededTraceIds])
+    );
     return this.traces.filter(
-      (trace) => !supersededTraceIds.has(trace.mspPairId) && !(supersededNetLabelKeys.has(trace.globalConnNetId) && isGeneratedAnchoredLabelConnector(trace))
+      (trace) => !supersededTraceIds.has(trace.mspPairId) && !(this.netLabelConnectorTraceIds.has(trace.mspPairId) && isLabelRepresentedInline(trace, placements))
     );
   }
-  getInlineGlobalsOverlappingAnchoredLabels({
+  getBlockedInlinePlacements({
     inlineNetLabelPlacements,
-    anchoredNetLabelPlacements
+    anchoredNetLabelPlacements,
+    traces
   }) {
-    const blockedGlobalConnNetIds = /* @__PURE__ */ new Set();
-    for (const inlinePlacement of inlineNetLabelPlacements) {
-      const inlineBounds = getInlinePlacementBounds(inlinePlacement);
-      for (const anchoredPlacement of anchoredNetLabelPlacements) {
-        if (anchoredPlacement.globalConnNetId === inlinePlacement.globalConnNetId) {
-          continue;
-        }
-        const anchoredBounds = getAnchoredNetLabelRenderedBounds(anchoredPlacement);
-        if (boundsOverlap(inlineBounds, anchoredBounds) || inlinePlacement.stubTracePath && doesPathIntersectBounds3(
-          inlinePlacement.stubTracePath,
-          anchoredBounds
-        )) {
-          blockedGlobalConnNetIds.add(inlinePlacement.globalConnNetId);
-          break;
-        }
+    const blockedKeys = /* @__PURE__ */ new Set();
+    for (const inline of inlineNetLabelPlacements) {
+      const bounds = getInlinePlacementBounds(inline);
+      const blockedByLabel = anchoredNetLabelPlacements.some((anchored) => {
+        const anchoredBounds = getAnchoredNetLabelRenderedBounds(anchored);
+        return boundsOverlap(bounds, anchoredBounds) || inline.stubTracePath && doesPathIntersectBounds3(inline.stubTracePath, anchoredBounds);
+      });
+      const blockedByTrace = traces.some(
+        (trace) => trace.globalConnNetId !== inline.globalConnNetId && (doesPathIntersectBounds3(trace.tracePath, bounds) || inline.stubTracePath && terminalStubIntersectsTrace(inline.stubTracePath, trace))
+      );
+      const blockedByInlineWire = inlineNetLabelPlacements.some(
+        (other) => other !== inline && other.globalConnNetId !== inline.globalConnNetId && other.stubTracePath && doesPathIntersectBounds3(other.stubTracePath, bounds)
+      );
+      const blockedByInlineText = inlineNetLabelPlacements.some(
+        (other) => other !== inline && boundsOverlap(bounds, getInlinePlacementBounds(other))
+      );
+      if (blockedByLabel || blockedByTrace || blockedByInlineWire || blockedByInlineText)
+        blockedKeys.add(getInlinePlacementKey(inline));
+    }
+    for (const conversion of this.inlineConversions) {
+      if (conversion.placements.some(
+        (placement) => blockedKeys.has(getInlinePlacementKey(placement))
+      )) {
+        for (const placement of conversion.placements)
+          blockedKeys.add(getInlinePlacementKey(placement));
       }
     }
-    return blockedGlobalConnNetIds;
+    return blockedKeys;
   }
   buildPostProcessedOutput() {
     let activeInlinePlacements = this.inlineNetLabelPlacements;
     while (true) {
-      const supersededNetLabelKeys = this.getSupersededNetLabelKeys(
-        activeInlinePlacements
-      );
-      const supersededTraceIds = new Set(
-        [...supersededNetLabelKeys].flatMap((globalConnNetId) => [
-          ...this.supersededTraceIdsByGlobalConnNetId.get(globalConnNetId) ?? []
-        ])
-      );
       const retainedNetLabelPlacements = this.inputNetLabelPlacements.filter(
-        (placement) => !supersededNetLabelKeys.has(placement.globalConnNetId)
+        (placement) => !isLabelRepresentedInline(placement, activeInlinePlacements)
       );
-      const outputTraces = this.getOutputTraces(
-        supersededNetLabelKeys,
-        supersededTraceIds
+      const outputTraces = this.getOutputTraces(activeInlinePlacements);
+      const { fixedLabels, terminalTraces } = getInlineLabelObstacles(
+        this.inputProblem,
+        activeInlinePlacements
       );
+      const labelCollisionSolver = new NetLabelNetLabelCollisionSolver({
+        inputProblem: this.inputProblem,
+        traces: [...outputTraces, ...terminalTraces],
+        netLabelPlacements: retainedNetLabelPlacements,
+        fixedNetLabelPlacements: fixedLabels,
+        netLabelConnectorTraceIds: this.netLabelConnectorTraceIds,
+        useRenderedLabelBounds: activeInlinePlacements.length > 0
+      });
+      if (activeInlinePlacements.length > 0) labelCollisionSolver.solve();
       const pushed = pushAnchoredNetLabelsAwayFromInlineLabels({
         inputProblem: this.inputProblem,
         traces: outputTraces,
-        netLabelPlacements: retainedNetLabelPlacements,
-        inlineNetLabelPlacements: activeInlinePlacements
+        netLabelPlacements: labelCollisionSolver.solved && !labelCollisionSolver.failed ? labelCollisionSolver.getOutput().netLabelPlacements : retainedNetLabelPlacements,
+        inlineNetLabelPlacements: activeInlinePlacements,
+        netLabelConnectorTraceIds: this.netLabelConnectorTraceIds
       });
-      const blockedGlobalConnNetIds = this.getInlineGlobalsOverlappingAnchoredLabels({
+      let blockedPlacementKeys = this.getBlockedInlinePlacements({
         inlineNetLabelPlacements: activeInlinePlacements,
-        anchoredNetLabelPlacements: pushed.netLabelPlacements
+        anchoredNetLabelPlacements: pushed.netLabelPlacements,
+        traces: pushed.traces
       });
-      if (blockedGlobalConnNetIds.size > 0) {
+      if (blockedPlacementKeys.size > 0) {
         const shiftedInlineTerminalLabels = pushInlineTerminalLabelsAwayFromAnchoredLabels({
           inputProblem: this.inputProblem,
           traces: pushed.traces,
@@ -16573,8 +17142,49 @@ var InlineNetLabelSolver = class extends BaseSolver {
           activeInlinePlacements = shiftedInlineTerminalLabels.inlineNetLabelPlacements;
           continue;
         }
+        const { terminalTraces: terminalTraces2 } = getInlineLabelObstacles(
+          this.inputProblem,
+          activeInlinePlacements
+        );
+        const replanned = activeInlinePlacements.filter(
+          (label) => !label.stubTracePath
+        );
+        const terminals = activeInlinePlacements.filter((label) => label.stubTracePath).sort(
+          (a, b) => Number(blockedPlacementKeys.has(getInlinePlacementKey(b))) - Number(blockedPlacementKeys.has(getInlinePlacementKey(a)))
+        );
+        for (const placement of terminals) {
+          const connection = [
+            ...this.inputProblem.netConnections,
+            ...this.inputProblem.directConnections
+          ].find(
+            (connection2) => connection2.netId === placement.netId && connection2.allowInlineNetLabel
+          );
+          const candidate = connection ? this.computeTerminalInlinePlacement(
+            connection,
+            placement.pinIds[0],
+            placement.globalConnNetId,
+            /* @__PURE__ */ new Set(),
+            {
+              traces: [...pushed.traces, ...terminalTraces2],
+              anchored: pushed.netLabelPlacements,
+              inline: replanned
+            }
+          ) : null;
+          replanned.push(candidate ?? placement);
+        }
+        const byKey = new Map(
+          replanned.map((label) => [getInlinePlacementKey(label), label])
+        );
+        activeInlinePlacements = activeInlinePlacements.map(
+          (label) => byKey.get(getInlinePlacementKey(label)) ?? label
+        );
+        blockedPlacementKeys = this.getBlockedInlinePlacements({
+          inlineNetLabelPlacements: activeInlinePlacements,
+          anchoredNetLabelPlacements: pushed.netLabelPlacements,
+          traces: pushed.traces
+        });
       }
-      if (blockedGlobalConnNetIds.size === 0) {
+      if (blockedPlacementKeys.size === 0) {
         this.inlineNetLabelPlacements = activeInlinePlacements;
         this.stats.pushedAnchoredNetLabelCount = pushed.movedLabelCount;
         const restored = restoreReroutesAroundSupersededLabels({
@@ -16585,17 +17195,141 @@ var InlineNetLabelSolver = class extends BaseSolver {
           completedReroutes: this.completedReroutes
         });
         this.stats.restoredSupersededLabelRerouteCount = restored.restoredTraceCount;
-        return {
+        const output = {
           traces: restored.traces,
+          netLabelConnectorTraceIds: pushed.netLabelConnectorTraceIds,
           netLabelPlacements: pushed.netLabelPlacements,
           inlineNetLabelPlacements: activeInlinePlacements
         };
+        this.inlineNetLabelPlacements = output.inlineNetLabelPlacements;
+        return output;
       }
       activeInlinePlacements = activeInlinePlacements.filter(
-        (placement) => !blockedGlobalConnNetIds.has(placement.globalConnNetId)
+        (placement) => !blockedPlacementKeys.has(getInlinePlacementKey(placement))
+      );
+    }
+  }
+  /** Enumerate nearby moves in the existing order; collect one proposal per step. */
+  *getTraceRefinementProposals(current) {
+    yield* getLocalTraceLabelShifts(this.inputProblem, current);
+    for (const label of current.netLabelPlacements) {
+      if (label.pinIds.length !== 1) continue;
+      const connection = [
+        ...this.inputProblem.netConnections,
+        ...this.inputProblem.directConnections
+      ].find(
+        (connection2) => connection2.allowInlineNetLabel && connection2.netId === label.netId && connection2.pinIds.includes(label.pinIds[0])
+      );
+      if (!connection) continue;
+      const placement = this.computeTerminalInlinePlacement(
+        connection,
+        label.pinIds[0],
+        label.globalConnNetId,
+        /* @__PURE__ */ new Set(),
+        { traces: [], anchored: [], inline: [] }
       );
+      if (placement)
+        yield* getLocalTraceLabelShifts(this.inputProblem, current, [placement]);
     }
   }
+  createRefinementCandidate(proposal) {
+    const traceMap = new Map(
+      proposal.traces.map((trace) => [trace.mspPairId, trace])
+    );
+    const labelKey = (label) => JSON.stringify([label.globalConnNetId, [...label.pinIds].sort()]);
+    const labelMap = new Map(
+      proposal.netLabelPlacements.map((label) => [labelKey(label), label])
+    );
+    const originalTraceIds = new Set(
+      this.traces.map((trace) => trace.mspPairId)
+    );
+    return new _InlineNetLabelSolver({
+      inputProblem: this.inputProblem,
+      traces: [
+        ...this.traces.map((trace) => traceMap.get(trace.mspPairId) ?? trace),
+        ...proposal.traces.filter(
+          (trace) => !originalTraceIds.has(trace.mspPairId)
+        )
+      ],
+      netLabelPlacements: this.inputNetLabelPlacements.map(
+        (label) => labelMap.get(labelKey(label)) ?? label
+      ),
+      completedReroutes: this.completedReroutes,
+      netLabelConnectorTraceIds: proposal.netLabelConnectorTraceIds
+    });
+  }
+  acceptRefinementCandidate(proposal, result) {
+    const current = this.postProcessedOutput;
+    const before = this.refinement.before;
+    const after = getOutputLabelCollisions(result);
+    if (after.some(
+      (collision) => !before.some(
+        (previous) => sameOutputLabelCollision(collision, previous)
+      )
+    ))
+      return false;
+    const movedTraceIds = new Set(
+      proposal.traces.filter((trace, index) => trace !== current.traces[index]).map((trace) => trace.mspPairId)
+    );
+    if (after.some(
+      (collision) => collision.kind === "trace-label" && collision.trace.kind === "routed" && movedTraceIds.has(collision.trace.id)
+    ))
+      return false;
+    if (after.length >= before.length && result.inlineNetLabelPlacements.length <= current.inlineNetLabelPlacements.length)
+      return false;
+    this.postProcessedOutput = result;
+    this.inlineNetLabelPlacements = result.inlineNetLabelPlacements;
+    return true;
+  }
+  stepTraceRefinement() {
+    if (this.activeSubSolver) {
+      this.activeSubSolver.step();
+      if (!this.activeSubSolver.solved && !this.activeSubSolver.failed) return;
+      if (this.activeSubSolver.solved && !this.activeSubSolver.failed && this.acceptRefinementCandidate(
+        this.currentProposal,
+        this.activeSubSolver.getOutput()
+      )) {
+        this.refinement = void 0;
+      }
+      this.activeSubSolver = null;
+      this.currentProposal = void 0;
+      return;
+    }
+    const current = this.postProcessedOutput;
+    if (!this.refinement) {
+      this.refinement = {
+        proposals: this.getTraceRefinementProposals(current),
+        queue: [],
+        collecting: true,
+        before: getOutputLabelCollisions(current)
+      };
+    }
+    const refinement = this.refinement;
+    if (refinement.collecting) {
+      const next2 = refinement.proposals.next();
+      if (!next2.done) {
+        const distance7 = next2.value.traces.reduce(
+          (sum, trace, index) => sum + trace.tracePath.reduce((distance8, point, pointIndex) => {
+            const previous = current.traces[index].tracePath[pointIndex];
+            return distance8 + Math.abs(point.x - previous.x) + Math.abs(point.y - previous.y);
+          }, 0),
+          0
+        );
+        refinement.queue.push({ output: next2.value, distance: distance7 });
+      } else {
+        refinement.queue.sort((a, b) => a.distance - b.distance);
+        refinement.collecting = false;
+      }
+      return;
+    }
+    const next = refinement.queue.shift();
+    if (!next) {
+      this.refinementComplete = true;
+      return;
+    }
+    this.currentProposal = next.output;
+    this.activeSubSolver = this.createRefinementCandidate(next.output);
+  }
   getOutput() {
     if (this.postProcessedOutput) return this.postProcessedOutput;
     return this.buildPostProcessedOutput();
@@ -16774,12 +17508,12 @@ var getCollisionLimitedTerminalStubEnd = ({
       const maxAcross = Math.max(startAcross, endAcross);
       let collisionDistance;
       const isCollinear = Math.abs(startAcross) <= GEOMETRY_EPSILON && Math.abs(endAcross) <= GEOMETRY_EPSILON;
-      if (isCollinear && maxAlong >= -GEOMETRY_EPSILON && minAlong <= intendedLength + GEOMETRY_EPSILON) {
+      if (isCollinear && maxAlong >= -GEOMETRY_EPSILON && minAlong <= intendedLength + INLINE_NET_LABEL_STUB_TRACE_CLEARANCE + GEOMETRY_EPSILON) {
         collisionDistance = Math.max(0, minAlong);
       } else {
         const crossesStubAxis = minAcross <= GEOMETRY_EPSILON && maxAcross >= -GEOMETRY_EPSILON;
         const perpendicularAlong = (startAlong + endAlong) / 2;
-        if (crossesStubAxis && Math.abs(startAlong - endAlong) <= GEOMETRY_EPSILON && perpendicularAlong >= -GEOMETRY_EPSILON && perpendicularAlong <= intendedLength + GEOMETRY_EPSILON) {
+        if (crossesStubAxis && Math.abs(startAlong - endAlong) <= GEOMETRY_EPSILON && perpendicularAlong >= -GEOMETRY_EPSILON && perpendicularAlong <= intendedLength + INLINE_NET_LABEL_STUB_TRACE_CLEARANCE + GEOMETRY_EPSILON) {
           collisionDistance = Math.max(0, perpendicularAlong);
         }
       }
@@ -16889,12 +17623,12 @@ var getTraceRecoveryConnectivityMaps = (inputProblem) => {
 };
 
 // lib/solvers/NetLabelToTraceSolver/reduceTraceCrossings.ts
-var EPS16 = 1e-9;
-var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS16;
-var isVertical5 = (start, end) => Math.abs(start.x - end.x) < EPS16;
+var EPS17 = 1e-9;
+var isHorizontal4 = (start, end) => Math.abs(start.y - end.y) < EPS17;
+var isVertical5 = (start, end) => Math.abs(start.x - end.x) < EPS17;
 var compactConsecutivePoints = (path) => path.filter((point, index) => {
   const previousPoint = path[index - 1];
-  return !previousPoint || Math.abs(point.x - previousPoint.x) >= EPS16 || Math.abs(point.y - previousPoint.y) >= EPS16;
+  return !previousPoint || Math.abs(point.x - previousPoint.x) >= EPS17 || Math.abs(point.y - previousPoint.y) >= EPS17;
 });
 var isValidOrthogonalPath = (path) => {
   if (path.length < 2 || !path.every((point, index) => {
@@ -16932,7 +17666,7 @@ var getEndpointAlignedSegmentCandidates = (tracePath) => {
     }
     const alignedCoordinates = segmentIsVertical ? [previousPoint.x, nextPoint.x] : [previousPoint.y, nextPoint.y];
     for (const alignedCoordinate of alignedCoordinates) {
-      if (Math.abs(alignedCoordinate - (segmentIsVertical ? start.x : start.y)) < EPS16) {
+      if (Math.abs(alignedCoordinate - (segmentIsVertical ? start.x : start.y)) < EPS17) {
         continue;
       }
       const candidate = tracePath.map((point) => ({ ...point }));
@@ -16990,7 +17724,6 @@ var reduceTraceCrossings = ({
 };
 
 // lib/solvers/NetLabelToTraceSolver/NetLabelToTraceSolver.ts
-var AVAILABLE_NET_ORIENTATION_PREFIX = "available-net-orientation-";
 var RECOVERED_TRACE_PREFIX = "net-label-to-trace-";
 var MAX_NAMED_NET_RECOVERY_PERPENDICULAR_OFFSET = 0.05;
 var MAX_ROUTED_COMPONENT_RECOVERY_PERPENDICULAR_OFFSET = 0.25;
@@ -17030,6 +17763,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
   inputProblem;
   outputTraces;
   outputNetLabelPlacements;
+  recoveredTraceIds = /* @__PURE__ */ new Set();
   chipMap;
   pinMap;
   queuedCandidates;
@@ -17246,7 +17980,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
     return candidates;
   }
   isSupersededConnectorTrace(trace, candidate) {
-    if (!trace.mspPairId.startsWith(AVAILABLE_NET_ORIENTATION_PREFIX)) {
+    if (!this.input.netLabelConnectorTraceIds?.has(trace.mspPairId)) {
       return false;
     }
     if (trace.pinIds.length !== 1) return false;
@@ -17296,6 +18030,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
       mspConnectionPairIds: [mspPairId],
       pinIds: [firstPin.pinId, secondPin.pinId]
     };
+    this.recoveredTraceIds.add(mspPairId);
     this.outputTraces = [...retainedTraces, recoveredTrace];
     if (candidate.recoveryMode !== "routed_components") {
       this.outputNetLabelPlacements = this.outputNetLabelPlacements.filter(
@@ -17355,7 +18090,7 @@ var NetLabelToTraceSolver = class extends BaseSolver {
       ...this.getOutput()
     });
     for (const trace of this.outputTraces) {
-      if (!trace.mspPairId.startsWith(RECOVERED_TRACE_PREFIX)) continue;
+      if (!this.recoveredTraceIds.has(trace.mspPairId)) continue;
       graphics.lines.push({
         points: trace.tracePath,
         strokeColor: "green",
@@ -17821,7 +18556,9 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
             inputProblem: instance.inputProblem,
             traces: junctionOutput.traces,
             netLabelPlacements: junctionOutput.netLabelPlacements,
-            completedReroutes
+            completedReroutes,
+            resolveTraceCollisions: true,
+            netLabelConnectorTraceIds: instance.availableNetOrientationSolver.netLabelConnectorTraceIds
           }
         ];
       }