@tscircuit/schematic-trace-solver 0.0.158 → 0.0.160

package/dist/index.js

@@ -363,6 +363,48 @@ var getConnectivityMapsFromInputProblem = (inputProblem) => {
   return { directConnMap, netConnMap };
 };
 
+// lib/solvers/MspConnectionPairSolver/getGroundConnectionPolicy.ts
+import { ConnectivityMap as ConnectivityMap2 } from "connectivity-map";
+var MAX_LOCAL_GROUND_BRANCH_OFFSET = 1;
+var getGroundConnectionPolicy = (inputProblem) => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
+  const groundNetId = netConnMap.getNetConnectedToId("GND");
+  if (!groundNetId) return () => true;
+  const physicalConnMap = new ConnectivityMap2({});
+  for (const connection of inputProblem.directConnections) {
+    physicalConnMap.addConnections([connection.pinIds]);
+  }
+  const pins = new Map(
+    inputProblem.chips.flatMap(
+      (chip) => chip.pins.map((pin) => [pin.pinId, { pin, chip }])
+    )
+  );
+  const groundFacingPins = [...pins.values()].filter(
+    ({ pin, chip }) => chip.pins.length === 2 && netConnMap.getNetConnectedToId(pin.pinId) === groundNetId && (pin._facingDirection ?? getPinDirection(pin, chip)) === "y-"
+  );
+  const hasExplicitParallelGroundRail = groundFacingPins.some(({ pin: a }) => {
+    const group = physicalConnMap.getNetConnectedToId(a.pinId);
+    return group !== void 0 && groundFacingPins.some(
+      ({ pin: b }) => a.pinId !== b.pinId && Math.abs(a.y - b.y) < 1e-6 && Math.abs(a.x - b.x) > 1e-6 && physicalConnMap.getNetConnectedToId(b.pinId) === group
+    );
+  });
+  if (!hasExplicitParallelGroundRail) return () => true;
+  const isGroundFacingTerminal = (pinId) => {
+    const entry = pins.get(pinId);
+    return entry?.chip.pins.length === 2 && !physicalConnMap.getNetConnectedToId(pinId) && (entry.pin._facingDirection ?? getPinDirection(entry.pin, entry.chip)) === "y-";
+  };
+  return (firstPinId, secondPinId) => {
+    if (!groundNetId || netConnMap.getNetConnectedToId(firstPinId) !== groundNetId || netConnMap.getNetConnectedToId(secondPinId) !== groundNetId) {
+      return true;
+    }
+    if (!isGroundFacingTerminal(firstPinId) && !isGroundFacingTerminal(secondPinId))
+      return true;
+    const first = pins.get(firstPinId)?.pin;
+    const second = pins.get(secondPinId)?.pin;
+    return !first || !second || Math.abs(first.y - second.y) <= MAX_LOCAL_GROUND_BRANCH_OFFSET + 1e-6;
+  };
+};
+
 // lib/solvers/MspConnectionPairSolver/getMspConnectionPairsFromPins.ts
 function getOrthogonalMinimumSpanningTree(pins, opts = {}) {
   const n = pins.length;
@@ -512,9 +554,11 @@ var MspConnectionPairSolver = class extends BaseSolver {
   pinMap;
   userNetIdByPinId;
   directConnectionPinPairKeys;
+  canRouteGroundPair;
   constructor({ inputProblem }) {
     super();
     this.inputProblem = inputProblem;
+    this.canRouteGroundPair = getGroundConnectionPolicy(inputProblem);
     this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE;
     const { directConnMap, netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
     this.dcConnMap = directConnMap;
@@ -571,6 +615,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
       const [pin1, pin2] = directlyConnectedPins;
       const p1 = this.pinMap[pin1];
       const p2 = this.pinMap[pin2];
+      if (!this.canRouteGroundPair(pin1, pin2)) return;
       const pinPairKey = getPinPairKey([pin1, pin2]);
       let pairDistance = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y);
       if (this.directConnectionPinPairKeys.has(pinPairKey)) {
@@ -615,7 +660,7 @@ var MspConnectionPairSolver = class extends BaseSolver {
       directlyConnectedPins.map((p) => this.pinMap[p]).filter(Boolean),
       {
         maxDistance: this.maxMspPairDistance,
-        forbidEdge: (a, b) => arePinsInDifferentSchematicSections(
+        forbidEdge: (a, b) => !this.canRouteGroundPair(a.pinId, b.pinId) || arePinsInDifferentSchematicSections(
           this.inputProblem,
           a,
           b
@@ -3136,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;
@@ -3209,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) => {
@@ -4827,6 +4893,7 @@ var LongDistancePairSolver = class extends BaseSolver {
     super();
     this.params = params;
     const { inputProblem, primaryMspConnectionPairs, alreadySolvedTraces } = this.params;
+    const canRouteGroundPair = getGroundConnectionPolicy(inputProblem);
     this.inputProblem = inputProblem;
     this.allSolvedTraces = [...alreadySolvedTraces];
     this.maxMspPairDistance = inputProblem.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE;
@@ -4845,7 +4912,10 @@ var LongDistancePairSolver = class extends BaseSolver {
       }
     }
     this.queuedFailedConnectionPairs = this.params.failedConnectionPairs.filter(
-      (connectionPair) => isLabeledPeripheralConnection({
+      (connectionPair) => canRouteGroundPair(
+        connectionPair.pins[0].pinId,
+        connectionPair.pins[1].pinId
+      ) && isLabeledPeripheralConnection({
         inputProblem: this.inputProblem,
         chipMap: this.chipMap,
         pins: connectionPair.pins
@@ -4865,6 +4935,7 @@ var LongDistancePairSolver = class extends BaseSolver {
         const neighbors = allPinIdsInNet.filter((otherPinId) => otherPinId !== unconnectedPinId).flatMap((otherPinId) => {
           const targetPin = pinMap.get(otherPinId);
           if (!targetPin) return [];
+          if (!canRouteGroundPair(sourcePin.pinId, targetPin.pinId)) return [];
           const isNamedTwoPinConnection = inputProblem.netConnections.some(
             (connection) => connection.pinIds.length === 2 && connection.pinIds.includes(sourcePin.pinId) && connection.pinIds.includes(targetPin.pinId)
           );
@@ -12731,6 +12802,75 @@ var alignSameNetJunctions = ({
   };
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/placeGroundRailLabelsAtOuterEnd.ts
+var placeGroundRailLabelsAtOuterEnd = ({
+  inputProblem,
+  traces,
+  netLabelPlacements
+}) => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
+  const groundNetId = netConnMap.getNetConnectedToId("GND");
+  if (!groundNetId) return netLabelPlacements;
+  const chipMap = new Map(inputProblem.chips.map((chip) => [chip.chipId, chip]));
+  const traceMap = Object.fromEntries(
+    traces.map((trace) => [trace.mspPairId, trace])
+  );
+  const obstacles = getObstacleRects(inputProblem);
+  const output = [...netLabelPlacements];
+  for (const rail of traces) {
+    if (rail.globalConnNetId !== groundNetId) continue;
+    const [a, b] = rail.pins;
+    if (a.chipId === b.chipId || !nearlyEqual(a.y, b.y) || ![a, b].every(
+      (pin) => pin._facingDirection === "y-" && chipMap.get(pin.chipId)?.pins.length === 2
+    ))
+      continue;
+    const path = simplifyPath(rail.tracePath);
+    if (path.length !== 4 || !isVertical2(path[0], path[1]) || !isHorizontal2(path[1], path[2]) || !isVertical2(path[2], path[3]) || path[1].y >= a.y)
+      continue;
+    for (const feed of traces) {
+      if (feed.globalConnNetId !== groundNetId) continue;
+      const shared = feed.pins.find((pin) => rail.pinIds.includes(pin.pinId));
+      const icPin = feed.pins.find(
+        (pin) => !rail.pinIds.includes(pin.pinId) && (chipMap.get(pin.chipId)?.pins.length ?? 0) > 2
+      );
+      if (!shared || !icPin || !nearlyEqual(icPin.y, path[1].y)) continue;
+      const outer = shared.pinId === a.pinId ? b : a;
+      if (Math.abs(outer.x - icPin.x) <= Math.abs(shared.x - icPin.x)) continue;
+      const anchorPoint = { x: outer.x, y: path[1].y };
+      if (!tracePathContainsPoint(rail.tracePath, anchorPoint)) continue;
+      for (let index = 0; index < output.length; index++) {
+        const label = output[index];
+        if (label.globalConnNetId !== groundNetId || label.orientation !== "y-" || !label.mspConnectionPairIds.some(
+          (id) => id === feed.mspPairId || id === rail.mspPairId
+        ) || !tracePathContainsPoint(feed.tracePath, label.anchorPoint) && !tracePathContainsPoint(rail.tracePath, label.anchorPoint))
+          continue;
+        const center = getCenterFromAnchor(
+          anchorPoint,
+          label.orientation,
+          label.width,
+          label.height
+        );
+        const bounds = getRectBounds(center, label.width, label.height);
+        if (obstacles.some((obstacle) => rectsOverlap(bounds, obstacle)) || traceCrossesBoundsInterior(bounds, traceMap) || output.some(
+          (other, otherIndex) => otherIndex !== index && rectsOverlap(
+            bounds,
+            getRectBounds(other.center, other.width, other.height)
+          )
+        ))
+          continue;
+        output[index] = {
+          ...label,
+          anchorPoint,
+          center,
+          mspConnectionPairIds: [rail.mspPairId],
+          pinIds: [...rail.pinIds]
+        };
+      }
+    }
+  }
+  return output;
+};
+
 // lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts
 var SameNetJunctionAlignmentSolver = class extends BaseSolver {
   input;
@@ -12745,7 +12885,11 @@ var SameNetJunctionAlignmentSolver = class extends BaseSolver {
   _step() {
     const result = alignSameNetJunctions(this.input);
     this.outputTraces = result.traces;
-    this.outputNetLabelPlacements = result.netLabelPlacements;
+    this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
+      inputProblem: this.input.inputProblem,
+      traces: result.traces,
+      netLabelPlacements: result.netLabelPlacements
+    });
     this.stats.alignedJunctionCount = result.alignedJunctionCount;
     this.solved = true;
   }
@@ -13572,7 +13716,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,
@@ -13609,20 +13753,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) {
@@ -13630,16 +14001,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) {
@@ -13659,11 +14040,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(
@@ -13692,18 +14105,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)
     );
@@ -13712,6 +14288,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 };
@@ -13720,53 +14297,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;
@@ -13794,7 +14378,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
           };
           if (this.isObstructed(bounds, {
             ownTrace: trace,
-            ownGlobalConnNetId: trace.globalConnNetId
+            ownGlobalConnNetId: trace.globalConnNetId,
+            ignoredTraceIds
           }))
             continue;
           return {
@@ -13802,7 +14387,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
             netId: connection.netId,
             netLabelText,
             mspPairId: trace.mspPairId,
-            pinIds: [...connection.pinIds],
+            pinIds: [...pinIds],
             axis: segment.axis,
             anchorPoint,
             center,
@@ -13819,7 +14404,9 @@ var InlineNetLabelSolver = class extends BaseSolver {
       netLabelText,
       width,
       height,
-      offset
+      offset,
+      pinIds,
+      ignoredTraceIds
     });
     if (spanPlacement) return spanPlacement;
     return null;
@@ -13836,7 +14423,9 @@ var InlineNetLabelSolver = class extends BaseSolver {
     netLabelText,
     width,
     height,
-    offset
+    offset,
+    pinIds,
+    ignoredTraceIds
   }) {
     const path = trace.tracePath;
     if (path.length < 2) return null;
@@ -13886,7 +14475,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 };
@@ -13895,7 +14485,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
           netId: connection.netId,
           netLabelText,
           mspPairId: trace.mspPairId,
-          pinIds: [...connection.pinIds],
+          pinIds: [...pinIds],
           axis,
           anchorPoint,
           center,
@@ -13913,7 +14503,8 @@ var InlineNetLabelSolver = class extends BaseSolver {
    */
   isObstructed(bounds, {
     ownTrace,
-    ownGlobalConnNetId
+    ownGlobalConnNetId,
+    ignoredTraceIds = /* @__PURE__ */ new Set()
   }) {
     for (const chip of this.inputProblem.chips) {
       const chipBounds = {
@@ -13928,9 +14519,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;
   }
@@ -13938,36 +14530,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;
@@ -14102,7 +14752,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];
@@ -14122,7 +14772,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";
@@ -14131,6 +14782,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];