@tscircuit/schematic-trace-solver 0.0.159 → 0.0.161

package/dist/index.js

@@ -3181,6 +3181,50 @@ var SingleNetLabelPlacementSolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/SchematicTraceLinesSolver/getTraceConnectedPinComponents.ts
+var getTraceConnectedPinComponents = ({
+  pinIds,
+  traces
+}) => {
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const pinId of pinIds) adjacency.set(pinId, /* @__PURE__ */ new Set());
+  const relevantTraces = traces.filter((trace) => {
+    if (trace.pins.length !== 2) return false;
+    const [firstPin, secondPin] = trace.pins;
+    return adjacency.has(firstPin.pinId) && adjacency.has(secondPin.pinId);
+  });
+  for (const trace of relevantTraces) {
+    const [firstPin, secondPin] = trace.pins;
+    adjacency.get(firstPin.pinId).add(secondPin.pinId);
+    adjacency.get(secondPin.pinId).add(firstPin.pinId);
+  }
+  const components = [];
+  const visited = /* @__PURE__ */ new Set();
+  for (const pinId of pinIds) {
+    if (visited.has(pinId)) continue;
+    const componentPinIds = [];
+    const pending = [pinId];
+    visited.add(pinId);
+    while (pending.length > 0) {
+      const currentPinId = pending.pop();
+      componentPinIds.push(currentPinId);
+      for (const adjacentPinId of adjacency.get(currentPinId) ?? []) {
+        if (visited.has(adjacentPinId)) continue;
+        visited.add(adjacentPinId);
+        pending.push(adjacentPinId);
+      }
+    }
+    const componentPinIdSet = new Set(componentPinIds);
+    components.push({
+      pinIds: componentPinIds,
+      traces: relevantTraces.filter(
+        (trace) => trace.pins.every((pin) => componentPinIdSet.has(pin.pinId))
+      )
+    });
+  }
+  return components;
+};
+
 // lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts
 var NetLabelPlacementSolver = class extends BaseSolver {
   inputProblem;
@@ -3254,35 +3298,12 @@ var NetLabelPlacementSolver = class extends BaseSolver {
         globalConnNetId
       );
       const pinsInNet = allIdsInNet.filter((id) => pinIdToPinMap.has(id));
-      const adj = {};
-      for (const pid of pinsInNet) adj[pid] = /* @__PURE__ */ new Set();
-      for (const t of byGlobal[globalConnNetId] ?? []) {
-        const a = t.pins[0].pinId;
-        const b = t.pins[1].pinId;
-        if (adj[a] && adj[b]) {
-          adj[a].add(b);
-          adj[b].add(a);
-        }
-      }
-      const visited = /* @__PURE__ */ new Set();
-      for (const pid of pinsInNet) {
-        if (visited.has(pid)) continue;
-        const stack = [pid];
-        const component = /* @__PURE__ */ new Set();
-        visited.add(pid);
-        while (stack.length > 0) {
-          const u = stack.pop();
-          component.add(u);
-          for (const v of adj[u] ?? []) {
-            if (!visited.has(v)) {
-              visited.add(v);
-              stack.push(v);
-            }
-          }
-        }
-        const compTraces = (byGlobal[globalConnNetId] ?? []).filter(
-          (t) => component.has(t.pins[0].pinId) && component.has(t.pins[1].pinId)
-        );
+      for (const traceConnectedComponent of getTraceConnectedPinComponents({
+        pinIds: pinsInNet,
+        traces: byGlobal[globalConnNetId] ?? []
+      })) {
+        const component = new Set(traceConnectedComponent.pinIds);
+        const compTraces = traceConnectedComponent.traces;
         if (compTraces.length > 0) {
           if (compTraces.some((trace) => trace.suppressNetLabel)) continue;
           const lengthOf = (path) => {
@@ -5843,6 +5864,9 @@ var getLabelsLinkedToRailGroup = (group, netLabelPlacements, traces) => {
 var getFixedLabelCoordinate = (group, netLabelPlacements, traces) => {
   const traceMap = new Map(traces.map((trace) => [trace.mspPairId, trace]));
   const groupTraceIds = new Set(group.map((segment) => segment.traceId));
+  const groupIsWithinSingleComponent = [...groupTraceIds].every(
+    (traceId) => traceMap.get(traceId)?.pins.every((pin) => pin.chipId === group[0].componentId) === true
+  );
   const groupHasOnlySingleRailTraces = [...groupTraceIds].every(
     (traceId) => traceMap.get(traceId)?.tracePath.length === 4
   );
@@ -5853,12 +5877,20 @@ var getFixedLabelCoordinate = (group, netLabelPlacements, traces) => {
     netLabelPlacements,
     traces
   );
-  const anchoringLabels = linkedLabels.filter(
-    (label) => label.orientation === group[0].componentFacingDirection && label.mspConnectionPairIds.some((traceId) => {
+  const labelsOrientedAlongRail = new Set(
+    linkedLabels.filter(
+      (label) => orientation === "vertical" && (label.orientation === "y+" || label.orientation === "y-") || orientation === "horizontal" && (label.orientation === "x+" || label.orientation === "x-")
+    )
+  );
+  const anchoringLabels = linkedLabels.filter((label) => {
+    if (label.orientation !== group[0].componentFacingDirection && (!groupIsWithinSingleComponent || !labelsOrientedAlongRail.has(label))) {
+      return false;
+    }
+    return label.mspConnectionPairIds.some((traceId) => {
       const trace = traceMap.get(traceId);
       return trace && tracePathContainsPoint(trace.tracePath, label.anchorPoint);
-    })
-  );
+    });
+  });
   const coordinates = getDistinctCoordinates(
     anchoringLabels.map(
       (label) => orientation === "vertical" ? label.anchorPoint.x : label.anchorPoint.y
@@ -5875,12 +5907,21 @@ var getFixedLabelCoordinate = (group, netLabelPlacements, traces) => {
     )
   );
   if (labelIsAnchoredToRoutedBackbone) return coordinate;
+  if (anchoringLabels.some((label) => labelsOrientedAlongRail.has(label))) {
+    const railGroupSpan = Math.max(...group.map((segment) => segment.maxAlong)) - Math.min(...group.map((segment) => segment.minAlong));
+    const coordinateIsLocalToRailGroup = group.every(
+      (segment) => Math.abs(segment.coordinate - coordinate) <= railGroupSpan + RAIL_ALIGNMENT_EPSILON
+    );
+    if (coordinateIsLocalToRailGroup) return coordinate;
+    return null;
+  }
   const coordinateIsLocalToEveryTrace = group.every((segment) => {
     const trace = traceMap.get(segment.traceId);
     if (!trace) return false;
     return Math.abs(segment.coordinate - coordinate) <= distance4(trace.pins[0], trace.pins[1]) + RAIL_ALIGNMENT_EPSILON;
   });
-  return coordinateIsLocalToEveryTrace ? coordinate : null;
+  if (coordinateIsLocalToEveryTrace) return coordinate;
+  return null;
 };
 
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/moveRailSegments.ts
@@ -8918,6 +8959,9 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const orientations = this.getAvailableOrientations(label);
     if (orientations.length === 0) return false;
     if (!orientations.includes(label.orientation)) return true;
+    if (this.getTextBlockedMultiPinRailTraces(label, orientations[0])) {
+      return true;
+    }
     if (!this.crowdedPortOnlyLabelIndices.has(labelIndex)) return false;
     const bounds = getRectBounds(label.center, label.width, label.height);
     return this.outputNetLabelPlacements.some((otherLabel, otherIndex) => {
@@ -9039,8 +9083,34 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     );
     const isTwoPinNet = netConnection?.pinIds.length === 2;
     const isDistanceSplitVerticalRail = (netConnection?.pinIds.length ?? 0) > 2 && isYOrientation(requiredOrientation) && this.hasPortOnlyLabelOnSameNet(label);
+    const textBlockedMultiPinRailTraces = this.getTextBlockedMultiPinRailTraces(
+      label,
+      requiredOrientation
+    );
     const isPairedSameSidePowerRail = isYOrientation(requiredOrientation) && this.hasOppositeVerticalRailOnSameChipSide(label, requiredOrientation);
+    if (textBlockedMultiPinRailTraces) {
+      const nearbyCandidate = this.findValidNearbyRailCandidate(
+        label,
+        requiredOrientation,
+        labelIndex,
+        textBlockedMultiPinRailTraces
+      );
+      if (nearbyCandidate) return nearbyCandidate;
+    }
     if (orientations.length === 1 && isYOrientation(requiredOrientation) && this.isOutwardHorizontalFallback(label) && this.hasTraceContinuingInOrientation(label, requiredOrientation) && (isDistanceSplitVerticalRail || isPairedSameSidePowerRail)) {
+      const hostRailCandidate = this.findValidTraceAnchorCandidate(
+        label,
+        requiredOrientation,
+        labelIndex
+      );
+      if (hostRailCandidate) {
+        const canUseHostRail = this.canPlaceVerticalLabelOnHostRail(
+          hostRailCandidate,
+          label
+        );
+        if (canUseHostRail) return hostRailCandidate;
+        hostRailCandidate.selected = false;
+      }
       const traceAnchorCandidate2 = this.findValidOutwardTraceAnchorCandidate(
         label,
         requiredOrientation,
@@ -9474,14 +9544,21 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       maxSearchDistance,
       outwardDistance,
       phase = "shift",
-      stopOnTraceCollision = true
+      stopOnTraceCollision = true,
+      connectorSource,
+      startDistance = LABEL_SEARCH_STEP
     } = params;
-    for (let distance7 = LABEL_SEARCH_STEP; distance7 <= maxSearchDistance + EPS12; distance7 += LABEL_SEARCH_STEP) {
+    for (let distance7 = startDistance; distance7 <= maxSearchDistance + EPS12; distance7 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
         x: baseAnchor.x + direction.x * distance7,
         y: baseAnchor.y + direction.y * distance7
       };
-      const candidate = this.createCandidate(label, anchorPoint, orientation);
+      const candidate = this.createCandidate(
+        label,
+        anchorPoint,
+        orientation,
+        connectorSource
+      );
       const result = this.evaluateCandidate(
         candidate,
         label,
@@ -9857,6 +9934,113 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const chipSide = this.getChipSideForPoint(label.anchorPoint);
     return chipSide === "left" && label.orientation === "x-" || chipSide === "right" && label.orientation === "x+";
   }
+  canPlaceVerticalLabelOnHostRail(candidate, label) {
+    const isOnHostRail = label.mspConnectionPairIds.some((traceId) => {
+      const trace = this.traceMap[traceId];
+      return trace && tracePathContainsPoint(trace.tracePath, candidate.anchorPoint);
+    });
+    if (!isOnHostRail) return false;
+    const hostPin = this.pinMap[label.pinIds[0]];
+    if (!hostPin) return false;
+    if (label.pinIds.some(
+      (pinId) => this.pinMap[pinId]?.chipId !== hostPin.chipId
+    )) {
+      return false;
+    }
+    const chip = this.chipObstacleSpatialIndex.chips.find(
+      (chip2) => chip2.chipId === hostPin.chipId
+    );
+    if (!chip) return false;
+    const labelBounds = getRectBounds(
+      candidate.center,
+      candidate.width,
+      candidate.height
+    );
+    if (labelBounds.minY < chip.bounds.minY - EPS12 || labelBounds.maxY > chip.bounds.maxY + EPS12) {
+      return false;
+    }
+    if (candidate.anchorPoint.x >= chip.bounds.minX - EPS12 && candidate.anchorPoint.x <= chip.bounds.maxX + EPS12) {
+      return false;
+    }
+    return chip.pins.every(
+      (pin) => label.pinIds.includes(pin.pinId) || pin.y <= labelBounds.minY + EPS12 || pin.y >= labelBounds.maxY - EPS12
+    );
+  }
+  getTextBlockedMultiPinRailTraces(label, orientation) {
+    if (!isYOrientation(orientation)) return null;
+    const componentId = this.pinMap[label.pinIds[0]]?.chipId;
+    const localTraces = Object.values(this.traceMap).filter(
+      (trace) => trace.globalConnNetId === label.globalConnNetId && trace.pins.every((pin) => pin.chipId === componentId)
+    );
+    const connectedPinIds = new Set(label.pinIds);
+    const connectedTraces = /* @__PURE__ */ new Set();
+    for (let changed = true; changed; ) {
+      changed = false;
+      for (const trace of localTraces) {
+        if (connectedTraces.has(trace)) continue;
+        if (!trace.pinIds.some((pinId) => connectedPinIds.has(pinId))) continue;
+        connectedTraces.add(trace);
+        for (const pinId of trace.pinIds) connectedPinIds.add(pinId);
+        changed = true;
+      }
+    }
+    if (connectedPinIds.size <= 3) return null;
+    const pins = [...connectedPinIds].map((pinId) => this.pinMap[pinId]);
+    const direction = dir(orientation);
+    const pinX = pins[0].x;
+    if (pins.some((pin) => Math.abs(pin.x - pinX) > EPS12)) return null;
+    const sidePins = this.inputProblem.chips.find((chip) => chip.chipId === componentId).pins.filter((pin) => Math.abs(pin.x - pinX) <= EPS12);
+    const minY = Math.min(...pins.map((pin) => pin.y));
+    const maxY = Math.max(...pins.map((pin) => pin.y));
+    if (sidePins.some(
+      (pin) => pin.y >= minY - EPS12 && pin.y <= maxY + EPS12 && !connectedPinIds.has(pin.pinId)
+    ) || orientation === "y-" && minY > Math.min(...sidePins.map((pin) => pin.y)) + EPS12 || orientation === "y+" && maxY < Math.max(...sidePins.map((pin) => pin.y)) - EPS12) {
+      return null;
+    }
+    const outerPinPosition = Math.max(
+      ...pins.map((pin) => pin.x * direction.x + pin.y * direction.y)
+    );
+    const blockedByText = (this.inputProblem.textBoxes ?? []).some(
+      (textBox) => textBox.chipId === componentId && textBox.center.x * direction.x + textBox.center.y * direction.y > outerPinPosition + EPS12
+    );
+    return blockedByText ? [...connectedTraces] : null;
+  }
+  findValidNearbyRailCandidate(label, orientation, labelIndex, localTraces) {
+    if (!isYOrientation(orientation)) return null;
+    const direction = dir(orientation);
+    const connectorY = [
+      ...new Set(localTraces.flatMap((trace) => trace.pinIds))
+    ].map((pinId) => this.pinMap[pinId]).sort((a, b) => b.y * direction.y - a.y * direction.y)[0]?.y;
+    if (connectorY === void 0) return null;
+    const pinX = this.pinMap[label.pinIds[0]].x;
+    const railXs = [
+      ...new Set(
+        localTraces.flatMap((trace) => trace.tracePath.map((point) => point.x))
+      )
+    ].filter((x) => Math.abs(x - pinX) > EPS12).sort((a, b) => Math.abs(a - pinX) - Math.abs(b - pinX));
+    for (const x of railXs) {
+      const connectorSource = { x, y: connectorY };
+      if (!Object.values(this.traceMap).some(
+        (trace) => trace.globalConnNetId === label.globalConnNetId && tracePathContainsPoint(trace.tracePath, connectorSource)
+      )) {
+        continue;
+      }
+      const candidate = this.findValidCandidateInShiftColumn({
+        label,
+        labelIndex,
+        orientation,
+        direction,
+        baseAnchor: connectorSource,
+        maxSearchDistance: this.maxSearchDistance,
+        outwardDistance: 0,
+        stopOnTraceCollision: false,
+        connectorSource,
+        startDistance: 0
+      });
+      if (candidate) return candidate;
+    }
+    return null;
+  }
   hasPortOnlyLabelOnSameNet(label) {
     return this.outputNetLabelPlacements.some(
       (otherLabel) => otherLabel !== label && otherLabel.globalConnNetId === label.globalConnNetId && this.isPortOnlyLabel(otherLabel)
@@ -13695,7 +13879,7 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
       const connectorObstructed = inlineBounds.some(
         (bounds) => pathIntersectsBounds(connector.tracePath, bounds)
       ) || inputProblem.chips.some(
-        (chip) => pathIntersectsBounds(connector.tracePath, {
+        (chip) => !ownerChipIds.has(chip.chipId) && pathIntersectsBounds(connector.tracePath, {
           minX: chip.center.x - chip.width / 2,
           maxX: chip.center.x + chip.width / 2,
           minY: chip.center.y - chip.height / 2,
@@ -13732,20 +13916,247 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
   };
 };
 
+// lib/solvers/InlineNetLabelSolver/pushInlineTerminalLabelsAwayFromAnchoredLabels.ts
+var LABEL_CLEARANCE3 = 0.05;
+var MAX_OUTWARD_DISTANCE2 = 5;
+var getStubDirection2 = (path) => {
+  const [start, end] = path;
+  if (Math.abs(end.x - start.x) >= Math.abs(end.y - start.y)) {
+    return end.x >= start.x ? "x+" : "x-";
+  }
+  return end.y >= start.y ? "y+" : "y-";
+};
+var getLabelBounds3 = (placement) => {
+  const renderedWidth = placement.axis === "y" ? placement.height : placement.width;
+  const renderedHeight = placement.axis === "y" ? placement.width : placement.height;
+  return {
+    minX: placement.center.x - renderedWidth / 2,
+    maxX: placement.center.x + renderedWidth / 2,
+    minY: placement.center.y - renderedHeight / 2,
+    maxY: placement.center.y + renderedHeight / 2
+  };
+};
+var getPathBounds2 = (path) => ({
+  minX: Math.min(...path.map((point) => point.x)),
+  maxX: Math.max(...path.map((point) => point.x)),
+  minY: Math.min(...path.map((point) => point.y)),
+  maxY: Math.max(...path.map((point) => point.y))
+});
+var doesPathIntersectBounds2 = (path, bounds) => {
+  for (let index = 0; index < path.length - 1; index++) {
+    if (boundsOverlap(getPathBounds2([path[index], path[index + 1]]), bounds)) {
+      return true;
+    }
+  }
+  return false;
+};
+var shiftPoint = (point, direction, distance7) => {
+  switch (direction) {
+    case "x+":
+      return { x: point.x + distance7, y: point.y };
+    case "x-":
+      return { x: point.x - distance7, y: point.y };
+    case "y+":
+      return { x: point.x, y: point.y + distance7 };
+    case "y-":
+      return { x: point.x, y: point.y - distance7 };
+  }
+};
+var shiftTerminalPlacement = (placement, direction, distance7) => {
+  const [start, end] = placement.stubTracePath;
+  const shiftedEnd = shiftPoint(end, direction, distance7);
+  return {
+    ...placement,
+    stubTracePath: [start, shiftedEnd],
+    anchorPoint: shiftPoint(placement.anchorPoint, direction, distance7),
+    center: shiftPoint(placement.center, direction, distance7)
+  };
+};
+var getRequiredOutwardDistance2 = (movingBounds, obstacleBounds, direction) => {
+  switch (direction) {
+    case "x+":
+      return obstacleBounds.maxX - movingBounds.minX + LABEL_CLEARANCE3;
+    case "x-":
+      return movingBounds.maxX - obstacleBounds.minX + LABEL_CLEARANCE3;
+    case "y+":
+      return obstacleBounds.maxY - movingBounds.minY + LABEL_CLEARANCE3;
+    case "y-":
+      return movingBounds.maxY - obstacleBounds.minY + LABEL_CLEARANCE3;
+  }
+};
+var pushInlineTerminalLabelsAwayFromAnchoredLabels = ({
+  inputProblem,
+  traces,
+  anchoredNetLabelPlacements,
+  inlineNetLabelPlacements
+}) => {
+  const chipIdByPinId = /* @__PURE__ */ new Map();
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) chipIdByPinId.set(pin.pinId, chip.chipId);
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const [
+    placementIndex,
+    placement
+  ] of inlineNetLabelPlacements.entries()) {
+    if (!placement.stubTracePath || placement.pinIds.length !== 1) continue;
+    const direction = getStubDirection2(placement.stubTracePath);
+    const ownerChipId = chipIdByPinId.get(placement.pinIds[0]);
+    const groupKey = `${ownerChipId ?? placement.pinIds[0]}::${direction}`;
+    const group = groups.get(groupKey) ?? [];
+    group.push({ placementIndex, placement, direction, ownerChipId });
+    groups.set(groupKey, group);
+  }
+  const outputPlacements = [...inlineNetLabelPlacements];
+  let movedGroupCount = 0;
+  for (const group of groups.values()) {
+    const groupPlacementIndices = new Set(
+      group.map(({ placementIndex }) => placementIndex)
+    );
+    const fixedInlinePlacements = outputPlacements.filter(
+      (_, placementIndex) => !groupPlacementIndices.has(placementIndex)
+    );
+    const direction = group[0].direction;
+    let distance7 = 0;
+    for (let iteration = 0; iteration <= anchoredNetLabelPlacements.length; iteration++) {
+      let requiredAdditionalDistance = 0;
+      for (const { placement } of group) {
+        const shiftedPlacement = shiftTerminalPlacement(
+          placement,
+          direction,
+          distance7
+        );
+        const shiftedBounds = getLabelBounds3(shiftedPlacement);
+        for (const anchoredPlacement of anchoredNetLabelPlacements) {
+          if (anchoredPlacement.globalConnNetId === placement.globalConnNetId) {
+            continue;
+          }
+          const anchoredBounds = getLabelBounds3(anchoredPlacement);
+          if (!boundsOverlap(shiftedBounds, anchoredBounds)) continue;
+          requiredAdditionalDistance = Math.max(
+            requiredAdditionalDistance,
+            getRequiredOutwardDistance2(
+              shiftedBounds,
+              anchoredBounds,
+              direction
+            )
+          );
+        }
+      }
+      if (requiredAdditionalDistance <= 0) break;
+      distance7 += requiredAdditionalDistance;
+    }
+    if (distance7 <= 0 || distance7 > MAX_OUTWARD_DISTANCE2) continue;
+    const proposals = group.map(
+      ({ placement }) => shiftTerminalPlacement(placement, direction, distance7)
+    );
+    const hasConflict = proposals.some((proposal, proposalIndex) => {
+      const originalPlacement = group[proposalIndex].placement;
+      const originalEnd = originalPlacement.stubTracePath[1];
+      const shiftedEnd = proposal.stubTracePath[1];
+      const addedStubSegment = [originalEnd, shiftedEnd];
+      const labelBounds = getLabelBounds3(proposal);
+      const ownerChipId = group[proposalIndex].ownerChipId;
+      if (anchoredNetLabelPlacements.some((anchoredPlacement) => {
+        if (anchoredPlacement.globalConnNetId === proposal.globalConnNetId) {
+          return false;
+        }
+        const anchoredBounds = getLabelBounds3(anchoredPlacement);
+        return boundsOverlap(labelBounds, anchoredBounds) || doesPathIntersectBounds2(addedStubSegment, anchoredBounds);
+      })) {
+        return true;
+      }
+      for (const chip of inputProblem.chips) {
+        if (chip.chipId === ownerChipId) continue;
+        const chipBounds = {
+          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
+        };
+        if (boundsOverlap(labelBounds, chipBounds) || doesPathIntersectBounds2(addedStubSegment, chipBounds)) {
+          return true;
+        }
+      }
+      for (const textBox of inputProblem.textBoxes ?? []) {
+        const textBounds = getTextBoxBounds(textBox);
+        if (boundsOverlap(labelBounds, textBounds) || doesPathIntersectBounds2(addedStubSegment, textBounds)) {
+          return true;
+        }
+      }
+      for (const trace of traces) {
+        if (trace.globalConnNetId === proposal.globalConnNetId) continue;
+        if (doesPathIntersectBounds2(trace.tracePath, labelBounds) || doesPathIntersectBounds2(
+          trace.tracePath,
+          getPathBounds2(addedStubSegment)
+        )) {
+          return true;
+        }
+      }
+      for (const fixedPlacement of fixedInlinePlacements) {
+        const fixedBounds = getLabelBounds3(fixedPlacement);
+        if (boundsOverlap(labelBounds, fixedBounds) || doesPathIntersectBounds2(addedStubSegment, fixedBounds) || fixedPlacement.stubTracePath && doesPathIntersectBounds2(fixedPlacement.stubTracePath, labelBounds)) {
+          return true;
+        }
+      }
+      return false;
+    });
+    if (hasConflict) continue;
+    for (const [groupIndex, { placementIndex }] of group.entries()) {
+      outputPlacements[placementIndex] = proposals[groupIndex];
+    }
+    movedGroupCount++;
+  }
+  return {
+    inlineNetLabelPlacements: outputPlacements,
+    movedGroupCount
+  };
+};
+
 // lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts
 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 getTraceLength2 = (trace) => {
+  let length = 0;
+  for (let index = 0; index < trace.tracePath.length - 1; index++) {
+    const start = trace.tracePath[index];
+    const end = trace.tracePath[index + 1];
+    length += Math.abs(end.x - start.x) + Math.abs(end.y - start.y);
+  }
+  return length;
+};
+var setsEqual = (first, second) => first.size === second.size && [...first].every((value) => second.has(value));
+var getInlinePlacementBounds = (placement) => {
+  const renderedWidth = placement.axis === "y" ? placement.height : placement.width;
+  const renderedHeight = placement.axis === "y" ? placement.width : placement.height;
+  return {
+    minX: placement.center.x - renderedWidth / 2,
+    maxX: placement.center.x + renderedWidth / 2,
+    minY: placement.center.y - renderedHeight / 2,
+    maxY: placement.center.y + renderedHeight / 2
+  };
+};
+var getAnchoredPlacementBounds = (placement) => ({
+  minX: placement.center.x - placement.width / 2,
+  maxX: placement.center.x + placement.width / 2,
+  minY: placement.center.y - placement.height / 2,
+  maxY: placement.center.y + placement.height / 2
+});
 var InlineNetLabelSolver = class extends BaseSolver {
   inputProblem;
   traces;
   inputNetLabelPlacements;
   inlineNetLabelPlacements = [];
-  /** Eligible one- or two-pin connections still waiting to be processed. */
+  /** Eligible connections still waiting to be processed. */
   queuedConnections;
   tracesByPinPairKey;
+  globalConnMap;
+  supersededTraceIdsByGlobalConnNetId = /* @__PURE__ */ new Map();
   hasAlignedPortOnlyStubs = false;
   postProcessedOutput;
   constructor(input) {
@@ -13753,16 +14164,26 @@ var InlineNetLabelSolver = class extends BaseSolver {
     this.inputProblem = input.inputProblem;
     this.traces = input.traces;
     this.inputNetLabelPlacements = input.netLabelPlacements;
+    this.globalConnMap = getConnectivityMapsFromInputProblem(
+      this.inputProblem
+    ).netConnMap;
     this.queuedConnections = [
       ...this.inputProblem.directConnections.filter(
         (connection) => connection.allowInlineNetLabel && connection.netId
-      ),
+      ).map((connection) => ({
+        kind: "direct_connection",
+        connection
+      })),
       ...this.inputProblem.netConnections.filter(
-        (connection) => connection.allowInlineNetLabel && connection.pinIds.length >= 1 && connection.pinIds.length <= 2 && connection.netId
-      )
+        (connection) => connection.allowInlineNetLabel && connection.pinIds.length >= 1 && connection.netId
+      ).map((connection) => ({
+        kind: "net_connection",
+        connection
+      }))
     ];
     this.tracesByPinPairKey = /* @__PURE__ */ new Map();
     for (const trace of this.traces) {
+      if (isGeneratedAnchoredLabelConnector(trace)) continue;
       const key = getPinPairKey2(trace.pins.map((p) => p.pinId));
       const existing = this.tracesByPinPairKey.get(key);
       if (existing) {
@@ -13782,11 +14203,43 @@ var InlineNetLabelSolver = class extends BaseSolver {
     ];
   }
   _step() {
-    const connection = this.queuedConnections.shift();
-    if (connection) {
+    const queuedConnection = this.queuedConnections.shift();
+    if (queuedConnection) {
+      if (queuedConnection.kind === "net_connection" && queuedConnection.connection.pinIds.length > 2) {
+        const netConnections = [
+          queuedConnection.connection,
+          ...this.queuedConnections.filter(
+            (queued) => queued.kind === "net_connection" && queued.connection.pinIds.length > 2
+          ).map((queued) => queued.connection)
+        ];
+        this.queuedConnections = this.queuedConnections.filter(
+          (queued) => queued.kind !== "net_connection" || queued.connection.pinIds.length <= 2
+        );
+        for (const conversion of this.computeNetConnectionInlineConversions(
+          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
+          );
+        }
+        return;
+      }
+      const { connection } = queuedConnection;
       const routedTraces = connection.pinIds.length === 2 ? this.tracesByPinPairKey.get(getPinPairKey2(connection.pinIds)) ?? [] : [];
       if (routedTraces.length > 0) {
-        const placement = this.computeInlinePlacement(connection);
+        const placement = this.computeInlinePlacement({
+          connection,
+          trace: routedTraces[0],
+          pinIds: connection.pinIds
+        });
         if (placement) this.inlineNetLabelPlacements.push(placement);
       } else {
         const terminalPlacements = connection.pinIds.map(
@@ -13815,18 +14268,181 @@ var InlineNetLabelSolver = class extends BaseSolver {
     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
+   * converts successfully. Failed conversions retain both their traces and
+   * their conventional labels, and the remaining conversions are retried.
+   */
+  computeNetConnectionInlineConversions(connections) {
+    const prospectiveTraceIdsByConnection = /* @__PURE__ */ new Map();
+    for (const connection of connections) {
+      const prospectiveTraceIds = /* @__PURE__ */ new Set();
+      for (const component of this.getNetConnectionComponents(connection)) {
+        if (component.traces.length === 0) continue;
+        const hasInlinePlacement = component.traces.some(
+          (trace) => Boolean(
+            this.computeInlinePlacement({
+              connection,
+              trace,
+              pinIds: component.pinIds
+            })
+          )
+        );
+        if (!hasInlinePlacement) {
+          for (const trace of component.traces) {
+            prospectiveTraceIds.add(trace.mspPairId);
+          }
+        }
+      }
+      prospectiveTraceIdsByConnection.set(connection, prospectiveTraceIds);
+    }
+    let ignoredTraceIds = new Set(
+      [...prospectiveTraceIdsByConnection.values()].flatMap((ids) => [...ids])
+    );
+    while (true) {
+      const conversions = connections.map((connection) => ({
+        connection,
+        conversion: this.computeNetConnectionInlinePlacements(
+          connection,
+          ignoredTraceIds,
+          prospectiveTraceIdsByConnection.get(connection) ?? /* @__PURE__ */ new Set()
+        )
+      }));
+      const nextIgnoredTraceIds = new Set(
+        conversions.flatMap(
+          ({ conversion }) => conversion ? [...conversion.supersededTraceIds] : []
+        )
+      );
+      if (setsEqual(ignoredTraceIds, nextIgnoredTraceIds)) {
+        return conversions.flatMap(
+          ({ conversion }) => conversion ? [conversion] : []
+        );
+      }
+      ignoredTraceIds = nextIgnoredTraceIds;
+    }
+  }
+  /**
+   * Splits an input net into the connected components created by its solved
+   * traces. This intentionally does not depend on anchored-label placement:
+   * a group whose anchored label failed still has the same routing topology.
+   */
+  getNetConnectionComponents(connection) {
+    const firstPinId = connection.pinIds[0];
+    if (!firstPinId) return [];
+    const canonicalGlobalConnNetId = this.globalConnMap.getNetConnectedToId(firstPinId);
+    if (!canonicalGlobalConnNetId) return [];
+    const inputPinIds = new Set(
+      this.inputProblem.chips.flatMap(
+        (chip) => chip.pins.map((pin) => pin.pinId)
+      )
+    );
+    const pinIdsInGlobalNet = this.globalConnMap.getIdsConnectedToNet(
+      canonicalGlobalConnNetId
+    ).filter((id) => inputPinIds.has(id));
+    const labeledPinIds = new Set(connection.pinIds);
+    return getTraceConnectedPinComponents({
+      pinIds: pinIdsInGlobalNet,
+      // Available-net-orientation traces only connect a pin to its generated
+      // 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)
+      )
+    }).map((component) => ({
+      pinIds: component.pinIds,
+      labeledPinIds: component.pinIds.filter(
+        (pinId) => labeledPinIds.has(pinId)
+      ),
+      traces: component.traces.sort(
+        (a, b) => getTraceLength2(b) - getTraceLength2(a)
+      )
+    })).filter((component) => component.labeledPinIds.length > 0);
+  }
+  getGlobalConnNetId(connection) {
+    const firstPinId = connection.pinIds[0];
+    if (!firstPinId) return void 0;
+    const connectionPinIds = new Set(connection.pinIds);
+    return this.traces.find(
+      (trace) => trace.pins.some((pin) => connectionPinIds.has(pin.pinId))
+    )?.globalConnNetId ?? this.inputNetLabelPlacements.find(
+      (placement) => placement.netId === connection.netId
+    )?.globalConnNetId ?? this.globalConnMap.getNetConnectedToId(firstPinId) ?? void 0;
+  }
+  /**
+   * 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.
+   */
+  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();
+    for (const component of components) {
+      const shouldUseTerminalStubs = component.traces.some(
+        (trace) => forcedTerminalTraceIds.has(trace.mspPairId)
+      );
+      let inlinePlacement = null;
+      if (!shouldUseTerminalStubs) {
+        for (const trace of component.traces) {
+          inlinePlacement = this.computeInlinePlacement({
+            connection,
+            trace,
+            pinIds: component.pinIds,
+            ignoredTraceIds
+          });
+          if (inlinePlacement) break;
+        }
+      }
+      if (inlinePlacement) {
+        inlinePlacements.push(inlinePlacement);
+        continue;
+      }
+      if (component.traces.length > 0 && !shouldUseTerminalStubs) {
+        return null;
+      }
+      if (component.labeledPinIds.length !== component.pinIds.length) {
+        return null;
+      }
+      const terminalPlacements = component.pinIds.map(
+        (pinId) => this.computeTerminalInlinePlacement(
+          connection,
+          pinId,
+          globalConnNetId,
+          ignoredTraceIds
+        )
+      );
+      if (terminalPlacements.some((placement) => placement === null)) {
+        return null;
+      }
+      inlinePlacements.push(
+        ...terminalPlacements.filter(
+          (placement) => placement !== null
+        )
+      );
+      for (const trace of component.traces) {
+        supersededTraceIds.add(trace.mspPairId);
+      }
+    }
+    return { globalConnNetId, placements: inlinePlacements, supersededTraceIds };
+  }
   /**
    * 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.
    */
-  computeTerminalInlinePlacement(connection, pinId) {
+  computeTerminalInlinePlacement(connection, pinId, knownGlobalConnNetId, ignoredTraceIds = /* @__PURE__ */ new Set()) {
     if (!connection.netId) return null;
     const anchoredPlacement = this.inputNetLabelPlacements.find(
       (placement) => placement.netId === connection.netId && placement.pinIds.length === 1 && placement.pinIds[0] === pinId
     );
-    if (!anchoredPlacement) return null;
+    const globalConnNetId = knownGlobalConnNetId ?? anchoredPlacement?.globalConnNetId;
+    if (!globalConnNetId) return null;
     const inputChip = this.inputProblem.chips.find(
       (chip) => chip.pins.some((pin) => pin.pinId === pinId)
     );
@@ -13835,6 +14451,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     const netLabelText = connection.netLabelText?.trim() || void 0;
     const width = connection.inlineNetLabelWidth ?? connection.netLabelWidth ?? estimateInlineNetLabelWidth(netLabelText ?? connection.netId, height);
     const stubLength = Math.max(width + 0.2, 0.6);
+    if (!inputPin && !anchoredPlacement) return null;
     const start = inputPin ? { x: inputPin.x, y: inputPin.y } : anchoredPlacement.anchorPoint;
     const direction = inputPin && inputChip ? inputPin._facingDirection ?? getPinDirection(inputPin, inputChip) : anchoredPlacement.orientation;
     const intendedEnd = direction === "x+" ? { x: start.x + stubLength, y: start.y } : direction === "x-" ? { x: start.x - stubLength, y: start.y } : direction === "y+" ? { x: start.x, y: start.y + stubLength } : { x: start.x, y: start.y - stubLength };
@@ -13843,53 +14460,60 @@ var InlineNetLabelSolver = class extends BaseSolver {
       intendedEnd,
       minimumLength: width + 2 * INLINE_NET_LABEL_TRACE_MARGIN,
       traces: this.traces,
-      ownGlobalConnNetId: anchoredPlacement.globalConnNetId
+      ownGlobalConnNetId: globalConnNetId,
+      ignoredTraceIds
     });
     if (!end) return null;
     const axis = direction === "x+" || direction === "x-" ? "x" : "y";
-    const side = axis === "x" ? "y+" : "x-";
     const anchorPoint = {
       x: (start.x + end.x) / 2,
       y: (start.y + end.y) / 2
     };
     const offset = height / 2 + INLINE_NET_LABEL_TRACE_MARGIN;
-    const center = side === "y+" ? { x: anchorPoint.x, y: anchorPoint.y + offset } : { 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: anchoredPlacement.globalConnNetId
-    })) {
-      return null;
+    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,
+        anchorPoint,
+        center,
+        width,
+        height,
+        side
+      };
     }
-    return {
-      globalConnNetId: anchoredPlacement.globalConnNetId,
-      netId: connection.netId,
-      netLabelText,
-      pinIds: [pinId],
-      stubTracePath: [start, end],
-      axis,
-      anchorPoint,
-      center,
-      width,
-      height,
-      side
-    };
+    return null;
   }
-  computeInlinePlacement(connection) {
-    const traces = this.tracesByPinPairKey.get(getPinPairKey2(connection.pinIds)) ?? [];
-    if (traces.length === 0) return null;
-    const trace = traces[0];
+  computeInlinePlacement({
+    connection,
+    trace,
+    pinIds,
+    ignoredTraceIds = /* @__PURE__ */ new Set()
+  }) {
     const segments = getAxisAlignedSegments(trace.tracePath);
     if (segments.length === 0) return null;
     const height = connection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT;
@@ -13917,7 +14541,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
           };
           if (this.isObstructed(bounds, {
             ownTrace: trace,
-            ownGlobalConnNetId: trace.globalConnNetId
+            ownGlobalConnNetId: trace.globalConnNetId,
+            ignoredTraceIds
           }))
             continue;
           return {
@@ -13925,7 +14550,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
             netId: connection.netId,
             netLabelText,
             mspPairId: trace.mspPairId,
-            pinIds: [...connection.pinIds],
+            pinIds: [...pinIds],
             axis: segment.axis,
             anchorPoint,
             center,
@@ -13942,7 +14567,9 @@ var InlineNetLabelSolver = class extends BaseSolver {
       netLabelText,
       width,
       height,
-      offset
+      offset,
+      pinIds,
+      ignoredTraceIds
     });
     if (spanPlacement) return spanPlacement;
     return null;
@@ -13959,7 +14586,9 @@ var InlineNetLabelSolver = class extends BaseSolver {
     netLabelText,
     width,
     height,
-    offset
+    offset,
+    pinIds,
+    ignoredTraceIds
   }) {
     const path = trace.tracePath;
     if (path.length < 2) return null;
@@ -14009,7 +14638,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
         };
         if (this.isObstructed(bounds, {
           ownTrace: trace,
-          ownGlobalConnNetId: trace.globalConnNetId
+          ownGlobalConnNetId: trace.globalConnNetId,
+          ignoredTraceIds
         }))
           continue;
         const anchorPoint = axis === "x" ? { x: along, y: side === "y+" ? maxY : minY } : { x: side === "x-" ? minX : maxX, y: along };
@@ -14018,7 +14648,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
           netId: connection.netId,
           netLabelText,
           mspPairId: trace.mspPairId,
-          pinIds: [...connection.pinIds],
+          pinIds: [...pinIds],
           axis,
           anchorPoint,
           center,
@@ -14036,7 +14666,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
    */
   isObstructed(bounds, {
     ownTrace,
-    ownGlobalConnNetId
+    ownGlobalConnNetId,
+    ignoredTraceIds = /* @__PURE__ */ new Set()
   }) {
     for (const chip of this.inputProblem.chips) {
       const chipBounds = {
@@ -14051,9 +14682,10 @@ var InlineNetLabelSolver = class extends BaseSolver {
       if (boundsOverlap(bounds, getTextBoxBounds(textBox))) return true;
     }
     for (const trace of this.traces) {
+      if (ignoredTraceIds.has(trace.mspPairId)) continue;
       if (ownTrace && trace.mspPairId === ownTrace.mspPairId) continue;
       if (trace.globalConnNetId === ownGlobalConnNetId) continue;
-      if (doesPathIntersectBounds2(trace.tracePath, bounds)) return true;
+      if (doesPathIntersectBounds3(trace.tracePath, bounds)) return true;
     }
     return false;
   }
@@ -14061,36 +14693,94 @@ var InlineNetLabelSolver = class extends BaseSolver {
    * Net label placements superseded by an inline label. A net gets one label or
    * the other, never both.
    */
-  getSupersededNetLabelKeys() {
+  getSupersededNetLabelKeys(placements = this.inlineNetLabelPlacements) {
     const keys = /* @__PURE__ */ new Set();
-    for (const placement of this.inlineNetLabelPlacements) {
+    for (const placement of placements) {
       keys.add(placement.globalConnNetId);
     }
     return keys;
   }
-  getOutputTraces(supersededNetLabelKeys) {
+  getOutputTraces(supersededNetLabelKeys, supersededTraceIds) {
     return this.traces.filter(
-      (trace) => !(supersededNetLabelKeys.has(trace.globalConnNetId) && trace.mspPairId.startsWith("available-net-orientation-"))
+      (trace) => !supersededTraceIds.has(trace.mspPairId) && !(supersededNetLabelKeys.has(trace.globalConnNetId) && isGeneratedAnchoredLabelConnector(trace))
     );
   }
+  getInlineGlobalsOverlappingAnchoredLabels({
+    inlineNetLabelPlacements,
+    anchoredNetLabelPlacements
+  }) {
+    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 = getAnchoredPlacementBounds(anchoredPlacement);
+        if (boundsOverlap(inlineBounds, anchoredBounds) || inlinePlacement.stubTracePath && doesPathIntersectBounds3(
+          inlinePlacement.stubTracePath,
+          anchoredBounds
+        )) {
+          blockedGlobalConnNetIds.add(inlinePlacement.globalConnNetId);
+          break;
+        }
+      }
+    }
+    return blockedGlobalConnNetIds;
+  }
   buildPostProcessedOutput() {
-    const superseded = this.getSupersededNetLabelKeys();
-    const retainedNetLabelPlacements = this.inputNetLabelPlacements.filter(
-      (placement) => !superseded.has(placement.globalConnNetId)
-    );
-    const outputTraces = this.getOutputTraces(superseded);
-    const pushed = pushAnchoredNetLabelsAwayFromInlineLabels({
-      inputProblem: this.inputProblem,
-      traces: outputTraces,
-      netLabelPlacements: retainedNetLabelPlacements,
-      inlineNetLabelPlacements: this.inlineNetLabelPlacements
-    });
-    this.stats.pushedAnchoredNetLabelCount = pushed.movedLabelCount;
-    return {
-      traces: pushed.traces,
-      netLabelPlacements: pushed.netLabelPlacements,
-      inlineNetLabelPlacements: this.inlineNetLabelPlacements
-    };
+    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)
+      );
+      const outputTraces = this.getOutputTraces(
+        supersededNetLabelKeys,
+        supersededTraceIds
+      );
+      const pushed = pushAnchoredNetLabelsAwayFromInlineLabels({
+        inputProblem: this.inputProblem,
+        traces: outputTraces,
+        netLabelPlacements: retainedNetLabelPlacements,
+        inlineNetLabelPlacements: activeInlinePlacements
+      });
+      const blockedGlobalConnNetIds = this.getInlineGlobalsOverlappingAnchoredLabels({
+        inlineNetLabelPlacements: activeInlinePlacements,
+        anchoredNetLabelPlacements: pushed.netLabelPlacements
+      });
+      if (blockedGlobalConnNetIds.size > 0) {
+        const shiftedInlineTerminalLabels = pushInlineTerminalLabelsAwayFromAnchoredLabels({
+          inputProblem: this.inputProblem,
+          traces: pushed.traces,
+          anchoredNetLabelPlacements: pushed.netLabelPlacements,
+          inlineNetLabelPlacements: activeInlinePlacements
+        });
+        if (shiftedInlineTerminalLabels.movedGroupCount > 0) {
+          activeInlinePlacements = shiftedInlineTerminalLabels.inlineNetLabelPlacements;
+          continue;
+        }
+      }
+      if (blockedGlobalConnNetIds.size === 0) {
+        this.inlineNetLabelPlacements = activeInlinePlacements;
+        this.stats.pushedAnchoredNetLabelCount = pushed.movedLabelCount;
+        return {
+          traces: pushed.traces,
+          netLabelPlacements: pushed.netLabelPlacements,
+          inlineNetLabelPlacements: activeInlinePlacements
+        };
+      }
+      activeInlinePlacements = activeInlinePlacements.filter(
+        (placement) => !blockedGlobalConnNetIds.has(placement.globalConnNetId)
+      );
+    }
   }
   getOutput() {
     if (this.postProcessedOutput) return this.postProcessedOutput;
@@ -14225,7 +14915,7 @@ var getAnchorCandidates = (segment, labelWidth, step = 0.1) => {
   offsets.push(slack / 2, -slack / 2);
   return offsets.map((offset) => pointAt(mid + offset * direction));
 };
-var doesPathIntersectBounds2 = (path, bounds) => {
+var doesPathIntersectBounds3 = (path, bounds) => {
   for (let i = 0; i < path.length - 1; i++) {
     const a = path[i];
     const b = path[i + 1];
@@ -14245,7 +14935,8 @@ var getCollisionLimitedTerminalStubEnd = ({
   intendedEnd,
   minimumLength,
   traces,
-  ownGlobalConnNetId
+  ownGlobalConnNetId,
+  ignoredTraceIds
 }) => {
   const isHorizontal4 = Math.abs(intendedEnd.x - start.x) >= Math.abs(intendedEnd.y - start.y);
   const alongAxis = isHorizontal4 ? "x" : "y";
@@ -14254,6 +14945,7 @@ var getCollisionLimitedTerminalStubEnd = ({
   const intendedLength = Math.abs(intendedEnd[alongAxis] - start[alongAxis]);
   let availableLength = intendedLength;
   for (const trace of traces) {
+    if (ignoredTraceIds.has(trace.mspPairId)) continue;
     if (trace.globalConnNetId === ownGlobalConnNetId) continue;
     for (let segmentIndex = 0; segmentIndex < trace.tracePath.length - 1; segmentIndex++) {
       const segmentStart = trace.tracePath[segmentIndex];