@tscircuit/schematic-trace-solver 0.0.188 → 0.0.190

package/dist/index.d.ts

@@ -1148,6 +1148,8 @@ interface NetLabelNetLabelCollisionSolverParams {
     useRenderedLabelBounds?: boolean;
     /** Already placed labels that are obstacles, but must not be moved. */
     fixedNetLabelPlacements?: NetLabelPlacement[];
+    /** Existing connector identities from AvailableNetOrientationSolver. */
+    netLabelConnectorTraceIds?: ReadonlySet<MspConnectionPairId>;
     inputProblem: InputProblem;
     traces: SolvedTracePath[];
     netLabelPlacements: NetLabelPlacement[];

package/dist/index.js

@@ -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
       ])
     );
   };
@@ -12403,6 +12405,17 @@ 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);
@@ -12565,8 +12578,10 @@ var NetLabelNetLabelCollisionSolver = class extends BaseSolver {
         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,
@@ -13260,7 +13275,7 @@ var UnroutedTraceRecoverySolver = class extends BaseSolver {
 };
 
 // lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts
-import { getSegmentIntersection as getSegmentIntersection3 } from "@tscircuit/math-utils/line-intersections";
+import { getSegmentIntersection as getSegmentIntersection4 } from "@tscircuit/math-utils/line-intersections";
 
 // lib/solvers/SameNetJunctionAlignmentSolver/pathIntersectsAnyNetLabel.ts
 var NET_LABEL_INTERIOR_INSET = 1e-6;
@@ -13579,6 +13594,242 @@ var collapseRedundantSharedEndpointStubs = ({
   return outputTraces;
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts
+import { getSegmentIntersection as getSegmentIntersection3 } from "@tscircuit/math-utils/line-intersections";
+var TRACE_LENGTH_EPSILON = 1e-6;
+var getTracePathStartingAtPin = (trace, pin) => {
+  const pathStart = trace.tracePath[0];
+  const pathEnd = trace.tracePath.at(-1);
+  if (!pathStart || !pathEnd) return null;
+  if (pointsEqual2(pathStart, pin)) return trace.tracePath;
+  if (pointsEqual2(pathEnd, pin)) return [...trace.tracePath].reverse();
+  return null;
+};
+var getPerpendicularPathCrossings = (targetPath, donorPath) => {
+  const crossings = [];
+  const sharedEndpoint = targetPath[0];
+  for (let targetSegmentIndex = 0; targetSegmentIndex < targetPath.length - 1; targetSegmentIndex++) {
+    const targetStart = targetPath[targetSegmentIndex];
+    const targetEnd = targetPath[targetSegmentIndex + 1];
+    const targetOrientation = getRailOrientation(targetStart, targetEnd);
+    if (!targetOrientation) continue;
+    for (let donorSegmentIndex = 0; donorSegmentIndex < donorPath.length - 1; donorSegmentIndex++) {
+      const donorStart = donorPath[donorSegmentIndex];
+      const donorEnd = donorPath[donorSegmentIndex + 1];
+      const donorOrientation = getRailOrientation(donorStart, donorEnd);
+      if (!donorOrientation || donorOrientation === targetOrientation) continue;
+      const intersectionPoint = getSegmentIntersection3(
+        targetStart,
+        targetEnd,
+        donorStart,
+        donorEnd
+      );
+      if (!intersectionPoint || pointsEqual2(intersectionPoint, sharedEndpoint)) {
+        continue;
+      }
+      crossings.push({
+        intersectionPoint,
+        targetSegmentIndex,
+        donorSegmentIndex
+      });
+    }
+  }
+  return crossings;
+};
+var buildCollapsedSelfCyclePath = (path, firstSegmentIndex, secondSegmentIndex) => {
+  const intersectionPoint = getSegmentIntersection3(
+    path[firstSegmentIndex],
+    path[firstSegmentIndex + 1],
+    path[secondSegmentIndex],
+    path[secondSegmentIndex + 1]
+  );
+  if (!intersectionPoint) return path;
+  return simplifyPath([
+    ...path.slice(0, firstSegmentIndex + 1),
+    intersectionPoint,
+    ...path.slice(secondSegmentIndex + 1)
+  ]);
+};
+var buildCollapsedCyclePath = ({
+  targetTrace,
+  targetPath,
+  donorPath,
+  crossing
+}) => {
+  const pathFromSharedPin = simplifyPath([
+    ...donorPath.slice(0, crossing.donorSegmentIndex + 1),
+    crossing.intersectionPoint,
+    ...targetPath.slice(crossing.targetSegmentIndex + 1)
+  ]);
+  if (pointsEqual2(targetTrace.tracePath[0], targetPath[0])) {
+    return pathFromSharedPin;
+  }
+  return pathFromSharedPin.reverse();
+};
+var getNetLabelPlacementsForCycleCollapse = ({
+  targetTrace,
+  tracePath,
+  netLabelPlacements
+}) => {
+  const candidateNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
+    trace: targetTrace,
+    originalTracePath: targetTrace.tracePath,
+    reroutedTracePath: tracePath,
+    netLabelPlacements
+  });
+  for (let labelIndex = 0; labelIndex < netLabelPlacements.length; labelIndex++) {
+    const label = netLabelPlacements[labelIndex];
+    if (label.globalConnNetId !== targetTrace.globalConnNetId) continue;
+    if (!tracePathContainsPoint(targetTrace.tracePath, label.anchorPoint)) {
+      continue;
+    }
+    const candidateLabel = candidateNetLabelPlacements[labelIndex];
+    if (!tracePathContainsPoint(tracePath, candidateLabel.anchorPoint)) {
+      return null;
+    }
+  }
+  const otherNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId !== targetTrace.globalConnNetId
+  );
+  if (pathIntersectsAnyNetLabel({
+    path: tracePath,
+    netLabelPlacements: otherNetLabelPlacements
+  })) {
+    return null;
+  }
+  const sameNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId === targetTrace.globalConnNetId
+  );
+  if (pathEntersAnyNetLabel({
+    path: tracePath,
+    netLabelPlacements: sameNetLabelPlacements
+  })) {
+    return null;
+  }
+  return candidateNetLabelPlacements;
+};
+var candidateIsBetter = (candidate, bestCandidate) => {
+  if (!bestCandidate) return true;
+  const visibleLengthDelta = candidate.netVisibleLength - bestCandidate.netVisibleLength;
+  if (Math.abs(visibleLengthDelta) > TRACE_LENGTH_EPSILON) {
+    return visibleLengthDelta < 0;
+  }
+  return candidate.netVisibleSegmentCount < bestCandidate.netVisibleSegmentCount;
+};
+var getBestCycleCollapseCandidate = ({
+  targetTrace,
+  traces,
+  netLabelPlacements
+}) => {
+  const sameNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId
+  );
+  const baselineNetVisibleLength = getVisibleTraceLength(sameNetTraces);
+  const baselineTargetVisibleLength = getVisibleTraceLength([targetTrace]);
+  let bestCandidate = null;
+  const considerTracePath = (tracePath) => {
+    const candidateTrace = { ...targetTrace, tracePath };
+    const candidateTargetVisibleLength = getVisibleTraceLength([candidateTrace]);
+    if (candidateTargetVisibleLength > baselineTargetVisibleLength + TRACE_LENGTH_EPSILON) {
+      return;
+    }
+    const candidateNetLabelPlacements = getNetLabelPlacementsForCycleCollapse({
+      targetTrace,
+      tracePath,
+      netLabelPlacements
+    });
+    if (!candidateNetLabelPlacements) return;
+    const candidateNetTraces = sameNetTraces.map((trace) => {
+      if (trace.mspPairId === targetTrace.mspPairId) return candidateTrace;
+      return trace;
+    });
+    const netVisibleLength = getVisibleTraceLength(candidateNetTraces);
+    if (netVisibleLength >= baselineNetVisibleLength - TRACE_LENGTH_EPSILON) {
+      return;
+    }
+    const candidate = {
+      tracePath,
+      netLabelPlacements: candidateNetLabelPlacements,
+      netVisibleLength,
+      netVisibleSegmentCount: getVisibleTraceSegmentCount(candidateNetTraces)
+    };
+    if (candidateIsBetter(candidate, bestCandidate)) {
+      bestCandidate = candidate;
+    }
+  };
+  const selfCrossings = findPerpendicularPathCrossings(
+    targetTrace.tracePath,
+    targetTrace.tracePath,
+    { includeTerminalSegments: true }
+  ).filter(
+    ({ pathSegmentIndex, otherPathSegmentIndex }) => pathSegmentIndex < otherPathSegmentIndex
+  );
+  for (const crossing of selfCrossings) {
+    considerTracePath(
+      buildCollapsedSelfCyclePath(
+        targetTrace.tracePath,
+        crossing.pathSegmentIndex,
+        crossing.otherPathSegmentIndex
+      )
+    );
+  }
+  for (const donorTrace of sameNetTraces) {
+    if (donorTrace.mspPairId === targetTrace.mspPairId) continue;
+    const sharedPin = getSharedPin({
+      donorTrace,
+      branchTrace: targetTrace
+    });
+    if (!sharedPin) continue;
+    const targetPath = getTracePathStartingAtPin(targetTrace, sharedPin);
+    const donorPath = getTracePathStartingAtPin(donorTrace, sharedPin);
+    if (!targetPath || !donorPath) continue;
+    const crossings = getPerpendicularPathCrossings(targetPath, donorPath);
+    for (const crossing of crossings) {
+      const tracePath = buildCollapsedCyclePath({
+        targetTrace,
+        targetPath,
+        donorPath,
+        crossing
+      });
+      considerTracePath(tracePath);
+    }
+  }
+  return bestCandidate;
+};
+var collapseSameNetCycles = ({
+  traces,
+  netLabelPlacements
+}) => {
+  const outputTraces = [...traces];
+  let outputNetLabelPlacements = [...netLabelPlacements];
+  let collapsedCycleCount = 0;
+  let traceIndex = 0;
+  while (traceIndex < outputTraces.length) {
+    const targetTrace = outputTraces[traceIndex];
+    const candidate = getBestCycleCollapseCandidate({
+      targetTrace,
+      traces: outputTraces,
+      netLabelPlacements: outputNetLabelPlacements
+    });
+    if (!candidate) {
+      traceIndex++;
+      continue;
+    }
+    outputTraces[traceIndex] = {
+      ...targetTrace,
+      tracePath: candidate.tracePath
+    };
+    outputNetLabelPlacements = candidate.netLabelPlacements;
+    collapsedCycleCount++;
+    traceIndex = 0;
+  }
+  return {
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    collapsedCycleCount
+  };
+};
+
 // lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts
 var MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2;
 var MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET = 0.2;
@@ -13659,8 +13910,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,
@@ -13961,7 +14214,7 @@ var pathsIntersect = (firstPath, secondPath) => {
   }
   for (let firstIndex = 1; firstIndex < firstPath.length; firstIndex++) {
     for (let secondIndex = 1; secondIndex < secondPath.length; secondIndex++) {
-      if (getSegmentIntersection3(
+      if (getSegmentIntersection4(
         firstPath[firstIndex - 1],
         firstPath[firstIndex],
         secondPath[secondIndex - 1],
@@ -14145,7 +14398,7 @@ var candidateIsClear = ({
       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(
+          const point = getSegmentIntersection4(
             path[i - 1],
             path[i],
             otherTrace.tracePath[j - 1],
@@ -14428,225 +14681,22 @@ var alignSameNetJunctions = ({
       }
     }
   }
-  const collapsedSharedEndpointStubs = collapseRedundantSharedEndpointStubs({
+  const cycleCollapse = collapseSameNetCycles({
     traces: outputTraces,
-    netLabelPlacements: outputNetLabelPlacements,
+    netLabelPlacements: outputNetLabelPlacements
+  });
+  outputTraces = collapseRedundantSharedEndpointStubs({
+    traces: cycleCollapse.traces,
+    netLabelPlacements: cycleCollapse.netLabelPlacements,
     netLabelConnectorTraceIds,
     multiPinNetPinIds: getMultiPinNetPinIds(inputProblem)
   });
-  outputTraces = collapsedSharedEndpointStubs;
-  return {
-    traces: outputTraces,
-    netLabelPlacements: outputNetLabelPlacements,
-    alignedJunctionCount
-  };
-};
-
-// lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts
-import { getSegmentIntersection as getSegmentIntersection4 } from "@tscircuit/math-utils/line-intersections";
-var TRACE_LENGTH_EPSILON = 1e-6;
-var getTracePathStartingAtPin = (trace, pin) => {
-  const pathStart = trace.tracePath[0];
-  const pathEnd = trace.tracePath.at(-1);
-  if (!pathStart || !pathEnd) return null;
-  if (pointsEqual2(pathStart, pin)) return trace.tracePath;
-  if (pointsEqual2(pathEnd, pin)) return [...trace.tracePath].reverse();
-  return null;
-};
-var getPerpendicularPathCrossings = (targetPath, donorPath) => {
-  const crossings = [];
-  const sharedEndpoint = targetPath[0];
-  for (let targetSegmentIndex = 0; targetSegmentIndex < targetPath.length - 1; targetSegmentIndex++) {
-    const targetStart = targetPath[targetSegmentIndex];
-    const targetEnd = targetPath[targetSegmentIndex + 1];
-    const targetOrientation = getRailOrientation(targetStart, targetEnd);
-    if (!targetOrientation) continue;
-    for (let donorSegmentIndex = 0; donorSegmentIndex < donorPath.length - 1; donorSegmentIndex++) {
-      const donorStart = donorPath[donorSegmentIndex];
-      const donorEnd = donorPath[donorSegmentIndex + 1];
-      const donorOrientation = getRailOrientation(donorStart, donorEnd);
-      if (!donorOrientation || donorOrientation === targetOrientation) continue;
-      const intersectionPoint = getSegmentIntersection4(
-        targetStart,
-        targetEnd,
-        donorStart,
-        donorEnd
-      );
-      if (!intersectionPoint || pointsEqual2(intersectionPoint, sharedEndpoint)) {
-        continue;
-      }
-      crossings.push({
-        intersectionPoint,
-        targetSegmentIndex,
-        donorSegmentIndex
-      });
-    }
-  }
-  return crossings;
-};
-var buildCollapsedCyclePath = ({
-  targetTrace,
-  targetPath,
-  donorPath,
-  crossing
-}) => {
-  const pathFromSharedPin = simplifyPath([
-    ...donorPath.slice(0, crossing.donorSegmentIndex + 1),
-    crossing.intersectionPoint,
-    ...targetPath.slice(crossing.targetSegmentIndex + 1)
-  ]);
-  if (pointsEqual2(targetTrace.tracePath[0], targetPath[0])) {
-    return pathFromSharedPin;
-  }
-  return pathFromSharedPin.reverse();
-};
-var getNetLabelPlacementsForCycleCollapse = ({
-  targetTrace,
-  tracePath,
-  netLabelPlacements
-}) => {
-  const candidateNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
-    trace: targetTrace,
-    originalTracePath: targetTrace.tracePath,
-    reroutedTracePath: tracePath,
-    netLabelPlacements
-  });
-  for (let labelIndex = 0; labelIndex < netLabelPlacements.length; labelIndex++) {
-    const label = netLabelPlacements[labelIndex];
-    if (label.globalConnNetId !== targetTrace.globalConnNetId) continue;
-    if (!tracePathContainsPoint(targetTrace.tracePath, label.anchorPoint)) {
-      continue;
-    }
-    const candidateLabel = candidateNetLabelPlacements[labelIndex];
-    if (!tracePathContainsPoint(tracePath, candidateLabel.anchorPoint)) {
-      return null;
-    }
-  }
-  const otherNetLabelPlacements = candidateNetLabelPlacements.filter(
-    (label) => label.globalConnNetId !== targetTrace.globalConnNetId
-  );
-  if (pathIntersectsAnyNetLabel({
-    path: tracePath,
-    netLabelPlacements: otherNetLabelPlacements
-  })) {
-    return null;
-  }
-  const sameNetLabelPlacements = candidateNetLabelPlacements.filter(
-    (label) => label.globalConnNetId === targetTrace.globalConnNetId
-  );
-  if (pathEntersAnyNetLabel({
-    path: tracePath,
-    netLabelPlacements: sameNetLabelPlacements
-  })) {
-    return null;
-  }
-  return candidateNetLabelPlacements;
-};
-var candidateIsBetter = (candidate, bestCandidate) => {
-  if (!bestCandidate) return true;
-  const visibleLengthDelta = candidate.netVisibleLength - bestCandidate.netVisibleLength;
-  if (Math.abs(visibleLengthDelta) > TRACE_LENGTH_EPSILON) {
-    return visibleLengthDelta < 0;
-  }
-  return candidate.netVisibleSegmentCount < bestCandidate.netVisibleSegmentCount;
-};
-var getBestCycleCollapseCandidate = ({
-  targetTrace,
-  traces,
-  netLabelPlacements
-}) => {
-  const sameNetTraces = traces.filter(
-    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId
-  );
-  const baselineNetVisibleLength = getVisibleTraceLength(sameNetTraces);
-  const baselineTargetVisibleLength = getVisibleTraceLength([targetTrace]);
-  let bestCandidate = null;
-  for (const donorTrace of sameNetTraces) {
-    if (donorTrace.mspPairId === targetTrace.mspPairId) continue;
-    const sharedPin = getSharedPin({
-      donorTrace,
-      branchTrace: targetTrace
-    });
-    if (!sharedPin) continue;
-    const targetPath = getTracePathStartingAtPin(targetTrace, sharedPin);
-    const donorPath = getTracePathStartingAtPin(donorTrace, sharedPin);
-    if (!targetPath || !donorPath) continue;
-    const crossings = getPerpendicularPathCrossings(targetPath, donorPath);
-    for (const crossing of crossings) {
-      const tracePath = buildCollapsedCyclePath({
-        targetTrace,
-        targetPath,
-        donorPath,
-        crossing
-      });
-      const candidateTrace = { ...targetTrace, tracePath };
-      const candidateTargetVisibleLength = getVisibleTraceLength([
-        candidateTrace
-      ]);
-      if (candidateTargetVisibleLength > baselineTargetVisibleLength + TRACE_LENGTH_EPSILON) {
-        continue;
-      }
-      const candidateNetLabelPlacements = getNetLabelPlacementsForCycleCollapse(
-        {
-          targetTrace,
-          tracePath,
-          netLabelPlacements
-        }
-      );
-      if (!candidateNetLabelPlacements) continue;
-      const candidateNetTraces = sameNetTraces.map((trace) => {
-        if (trace.mspPairId === targetTrace.mspPairId) return candidateTrace;
-        return trace;
-      });
-      const netVisibleLength = getVisibleTraceLength(candidateNetTraces);
-      if (netVisibleLength >= baselineNetVisibleLength - TRACE_LENGTH_EPSILON) {
-        continue;
-      }
-      const netVisibleSegmentCount = getVisibleTraceSegmentCount(candidateNetTraces);
-      const candidate = {
-        tracePath,
-        netLabelPlacements: candidateNetLabelPlacements,
-        netVisibleLength,
-        netVisibleSegmentCount
-      };
-      if (candidateIsBetter(candidate, bestCandidate)) {
-        bestCandidate = candidate;
-      }
-    }
-  }
-  return bestCandidate;
-};
-var collapseSameNetCycles = ({
-  traces,
-  netLabelPlacements
-}) => {
-  const outputTraces = [...traces];
-  let outputNetLabelPlacements = [...netLabelPlacements];
-  let collapsedCycleCount = 0;
-  let traceIndex = 0;
-  while (traceIndex < outputTraces.length) {
-    const targetTrace = outputTraces[traceIndex];
-    const candidate = getBestCycleCollapseCandidate({
-      targetTrace,
-      traces: outputTraces,
-      netLabelPlacements: outputNetLabelPlacements
-    });
-    if (!candidate) {
-      traceIndex++;
-      continue;
-    }
-    outputTraces[traceIndex] = {
-      ...targetTrace,
-      tracePath: candidate.tracePath
-    };
-    outputNetLabelPlacements = candidate.netLabelPlacements;
-    collapsedCycleCount++;
-    traceIndex = 0;
-  }
+  outputNetLabelPlacements = cycleCollapse.netLabelPlacements;
   return {
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,
-    collapsedCycleCount
+    alignedJunctionCount,
+    collapsedCycleCount: cycleCollapse.collapsedCycleCount
   };
 };
 
@@ -14759,18 +14809,14 @@ var SameNetJunctionAlignmentSolver = class extends BaseSolver {
   }
   _step() {
     const alignment = alignSameNetJunctions(this.input);
-    const cycleCollapse = collapseSameNetCycles({
-      traces: alignment.traces,
-      netLabelPlacements: alignment.netLabelPlacements
-    });
-    this.outputTraces = cycleCollapse.traces;
+    this.outputTraces = alignment.traces;
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: cycleCollapse.traces,
-      netLabelPlacements: cycleCollapse.netLabelPlacements
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements
     });
     this.stats.alignedJunctionCount = alignment.alignedJunctionCount;
-    this.stats.collapsedCycleCount = cycleCollapse.collapsedCycleCount;
+    this.stats.collapsedCycleCount = alignment.collapsedCycleCount;
     this.solved = true;
   }
   getOutput() {
@@ -17098,6 +17144,7 @@ var InlineNetLabelSolver = class _InlineNetLabelSolver extends BaseSolver {
         traces: [...outputTraces, ...terminalTraces],
         netLabelPlacements: retainedNetLabelPlacements,
         fixedNetLabelPlacements: fixedLabels,
+        netLabelConnectorTraceIds: this.netLabelConnectorTraceIds,
         useRenderedLabelBounds: activeInlinePlacements.length > 0
       });
       if (activeInlinePlacements.length > 0) labelCollisionSolver.solve();

package/lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts

@@ -1193,6 +1193,7 @@ export class InlineNetLabelSolver extends BaseSolver {
         traces: [...outputTraces, ...terminalTraces],
         netLabelPlacements: retainedNetLabelPlacements,
         fixedNetLabelPlacements: fixedLabels,
+        netLabelConnectorTraceIds: this.netLabelConnectorTraceIds,
         useRenderedLabelBounds: activeInlinePlacements.length > 0,
       })
       if (activeInlinePlacements.length > 0) labelCollisionSolver.solve()

package/lib/solvers/InlineNetLabelSolver/getAnchoredNetLabelRenderedBounds.ts

@@ -19,6 +19,19 @@ export const getAnchoredNetLabelRenderedBounds = (
   placement: NetLabelPlacement,
 ): Bounds => {
   if (placement.orientation !== "x-" && placement.orientation !== "x+") {
+    // Named vertical tags render their long text extent along y. Width-only
+    // placeholders retain the supplied envelope instead.
+    if (placement.netLabelText && placement.width > placement.height) {
+      const width = placement.height
+      const height = placement.width
+      const center = getCenterFromAnchor(
+        placement.anchorPoint,
+        placement.orientation,
+        width,
+        height,
+      )
+      return getRectBounds(center, width, height)
+    }
     return getRectBounds(placement.center, placement.width, placement.height)
   }
 

package/lib/solvers/NetLabelNetLabelCollisionSolver/NetLabelNetLabelCollisionSolver.ts

@@ -2,6 +2,7 @@ import { getAnchoredNetLabelRenderedBounds } from "../InlineNetLabelSolver/getAn
 import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
 import type { InputProblem } from "lib/types/InputProblem"
@@ -96,6 +97,8 @@ export interface NetLabelNetLabelCollisionSolverParams {
   useRenderedLabelBounds?: boolean
   /** Already placed labels that are obstacles, but must not be moved. */
   fixedNetLabelPlacements?: NetLabelPlacement[]
+  /** Existing connector identities from AvailableNetOrientationSolver. */
+  netLabelConnectorTraceIds?: ReadonlySet<MspConnectionPairId>
   inputProblem: InputProblem
   traces: SolvedTracePath[]
   netLabelPlacements: NetLabelPlacement[]
@@ -245,9 +248,15 @@ export class NetLabelNetLabelCollisionSolver extends BaseSolver {
       }
     }
 
-    const isPortOnly = label.mspConnectionPairIds.length === 0
+    // A label on an extended connector must keep that attachment point.
+    const isAnchoredOnConnector = this.traces.some(
+      (trace) =>
+        this.params.netLabelConnectorTraceIds?.has(trace.mspPairId) &&
+        trace.globalConnNetId === label.globalConnNetId &&
+        tracePathContainsPoint(trace.tracePath, label.anchorPoint),
+    )
 
-    if (isPortOnly) {
+    if (label.mspConnectionPairIds.length === 0 || isAnchoredOnConnector) {
       const allOrientations: FacingDirection[] = ["x+", "x-", "y+", "y-"]
       const orderedOrientations = [
         label.orientation,