@tscircuit/schematic-trace-solver 0.0.145 → 0.0.147

package/dist/index.js

@@ -678,6 +678,50 @@ import "graphics-debug";
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts
 import { calculateElbow as calculateElbow2 } from "calculate-elbow";
 
+// lib/utils/getNetLabelWidthForConnection.ts
+var getConfiguredWidth = (connections, includeFallbackNetLabelWidth) => {
+  const explicitWidth = connections.find(
+    (connection) => connection?.netLabelWidth !== void 0
+  )?.netLabelWidth;
+  if (explicitWidth !== void 0) return explicitWidth;
+  if (!includeFallbackNetLabelWidth) return void 0;
+  return connections.find(
+    (connection) => connection?.fallbackNetLabelWidth !== void 0
+  )?.fallbackNetLabelWidth;
+};
+var getNetLabelWidthForConnection = ({
+  inputProblem,
+  netId,
+  pinIds,
+  includeFallbackNetLabelWidth = true
+}) => {
+  if (netId) {
+    const widthByNetId = getConfiguredWidth(
+      [
+        inputProblem.netConnections.find(
+          (connection) => connection.netId === netId
+        ),
+        inputProblem.directConnections.find(
+          (connection) => connection.netId === netId
+        )
+      ],
+      includeFallbackNetLabelWidth
+    );
+    if (widthByNetId !== void 0) return widthByNetId;
+  }
+  return getConfiguredWidth(
+    [
+      inputProblem.directConnections.find(
+        (connection) => connection.pinIds.some((pinId) => pinIds.includes(pinId))
+      ),
+      inputProblem.netConnections.find(
+        (connection) => connection.pinIds.some((pinId) => pinIds.includes(pinId))
+      )
+    ],
+    includeFallbackNetLabelWidth
+  );
+};
+
 // lib/utils/textBoxBounds.ts
 function getTextBoxBounds(textBox, padding = {}) {
   return {
@@ -1281,7 +1325,12 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     const netId = this.connectionPair?.userNetId;
     if (!netId) return {};
     const orientations = this.inputProblem.availableNetLabelOrientations[netId] ?? ["x+", "x-", "y+", "y-"];
-    const netLabelWidth = this.getNetLabelWidthForConnectionPair(netId);
+    const netLabelWidth = getNetLabelWidthForConnection({
+      inputProblem: this.inputProblem,
+      netId,
+      pinIds: this.pins.map((pin) => pin.pinId),
+      includeFallbackNetLabelWidth: false
+    });
     const netLabelHeight = this.getNetLabelHeightForConnectionPair(netId);
     const padding = {
       minX: 0,
@@ -1315,24 +1364,6 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     }
     return padding;
   }
-  getNetLabelWidthForConnectionPair(netId) {
-    const ncWidth = this.inputProblem.netConnections.find(
-      (nc) => nc.netId === netId
-    )?.netLabelWidth;
-    if (ncWidth !== void 0) return ncWidth;
-    const dcWidthByNetId = this.inputProblem.directConnections.find(
-      (dc) => dc.netId === netId
-    )?.netLabelWidth;
-    if (dcWidthByNetId !== void 0) return dcWidthByNetId;
-    const pinIds = this.pins.map((p) => p.pinId);
-    const dcWidthByPinId = this.inputProblem.directConnections.find(
-      (dc) => dc.pinIds.some((pid) => pinIds.includes(pid))
-    )?.netLabelWidth;
-    if (dcWidthByPinId !== void 0) return dcWidthByPinId;
-    return this.inputProblem.netConnections.find(
-      (nc) => nc.pinIds.some((pid) => pinIds.includes(pid))
-    )?.netLabelWidth;
-  }
   getNetLabelHeightForConnectionPair(netId) {
     const ncHeight = this.inputProblem.netConnections.find(
       (nc) => nc.netId === netId
@@ -3217,27 +3248,15 @@ var NetLabelPlacementSolver = class extends BaseSolver {
     return groups;
   }
   getNetLabelWidthForGroup(group) {
-    if (group.netId) {
-      const ncWidth = this.inputProblem.netConnections.find(
-        (nc) => nc.netId === group.netId
-      )?.netLabelWidth;
-      if (ncWidth !== void 0) return ncWidth;
-      const dcWidthByNetId = this.inputProblem.directConnections.find(
-        (dc) => dc.netId === group.netId
-      )?.netLabelWidth;
-      if (dcWidthByNetId !== void 0) return dcWidthByNetId;
-    }
     const pinIds = group.overlappingTraces?.pins.map((p) => p.pinId) ?? [];
     if (group.portOnlyPinId) {
       pinIds.push(group.portOnlyPinId);
     }
-    const dcWidthByPinId = this.inputProblem.directConnections.find(
-      (dc) => dc.pinIds.some((pid) => pinIds.includes(pid))
-    )?.netLabelWidth;
-    if (dcWidthByPinId !== void 0) return dcWidthByPinId;
-    return this.inputProblem.netConnections.find(
-      (nc) => nc.pinIds.some((pid) => pinIds.includes(pid))
-    )?.netLabelWidth;
+    return getNetLabelWidthForConnection({
+      inputProblem: this.inputProblem,
+      netId: group.netId,
+      pinIds
+    });
   }
   getNetLabelHeightForGroup(group) {
     if (group.netId) {
@@ -8527,13 +8546,21 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       const bY = this.outputNetLabelPlacements[b].anchorPoint.y;
       return requiredOrientation === "y+" ? bY - aY : aY - bY;
     });
-    const blockedLabelWidth = this.getNetLabelWidth(blockedLabel);
+    const blockedLabelWidth = getNetLabelWidthForConnection({
+      inputProblem: this.inputProblem,
+      netId: blockedLabel.netId,
+      pinIds: blockedLabel.pinIds
+    });
     let columnLabelIndex;
     if (blockedLabelWidth !== void 0) {
       columnLabelIndex = labelsToOrder.find((index) => {
         if (index === blockedStandaloneLabelIndex) return false;
         const label = this.outputNetLabelPlacements[index];
-        return this.getNetLabelWidth(label) === blockedLabelWidth;
+        return getNetLabelWidthForConnection({
+          inputProblem: this.inputProblem,
+          netId: label.netId,
+          pinIds: label.pinIds
+        }) === blockedLabelWidth;
       });
     }
     if (columnLabelIndex !== void 0) {
@@ -8754,7 +8781,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     if (!chip) return null;
     const { width, height } = getDimsForOrientation({
       orientation,
-      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelWidth: getNetLabelWidthForConnection({
+        inputProblem: this.inputProblem,
+        netId: label.netId,
+        pinIds: label.pinIds
+      }),
       netLabelHeight: this.getNetLabelHeight(label)
     });
     const nextPinToRight = this.outputNetLabelPlacements.map((otherLabel, index) => ({
@@ -9188,7 +9219,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   labelIntersectsDifferentNetTrace(label) {
     const { width, height } = getDimsForOrientation({
       orientation: label.orientation,
-      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelWidth: getNetLabelWidthForConnection({
+        inputProblem: this.inputProblem,
+        netId: label.netId,
+        pinIds: label.pinIds
+      }),
       netLabelHeight: this.getNetLabelHeight(label)
     });
     const center = getCenterFromAnchor(
@@ -9206,7 +9241,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     const anchorPoint = this.getWickOffsetAnchor(label.anchorPoint, orientation);
     const { width, height } = getDimsForOrientation({
       orientation,
-      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelWidth: getNetLabelWidthForConnection({
+        inputProblem: this.inputProblem,
+        netId: label.netId,
+        pinIds: label.pinIds
+      }),
       netLabelHeight: this.getNetLabelHeight(label)
     });
     const searchStartAnchor = this.getSideOffsetAnchor({
@@ -9261,7 +9300,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   getSearchDistanceLimit(label, orientation) {
     const { width, height } = getDimsForOrientation({
       orientation,
-      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelWidth: getNetLabelWidthForConnection({
+        inputProblem: this.inputProblem,
+        netId: label.netId,
+        pinIds: label.pinIds
+      }),
       netLabelHeight: this.getNetLabelHeight(label)
     });
     const labelLength = orientation === "y+" || orientation === "y-" ? height : width;
@@ -9312,7 +9355,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   createCandidate(label, anchorPoint, orientation, connectorSource) {
     const { width, height } = getDimsForOrientation({
       orientation,
-      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelWidth: getNetLabelWidthForConnection({
+        inputProblem: this.inputProblem,
+        netId: label.netId,
+        pinIds: label.pinIds
+      }),
       netLabelHeight: this.getNetLabelHeight(label)
     });
     return {
@@ -9324,25 +9371,6 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       center: getCenterFromAnchor(anchorPoint, orientation, width, height)
     };
   }
-  getNetLabelWidth(label) {
-    if (label.netId) {
-      const ncWidth = this.inputProblem.netConnections.find(
-        (connection) => connection.netId === label.netId
-      )?.netLabelWidth;
-      if (ncWidth !== void 0) return ncWidth;
-      const dcWidthByNetId = this.inputProblem.directConnections.find(
-        (dc) => dc.netId === label.netId
-      )?.netLabelWidth;
-      if (dcWidthByNetId !== void 0) return dcWidthByNetId;
-    }
-    const dcWidthByPinId = this.inputProblem.directConnections.find(
-      (dc) => dc.pinIds.some((pid) => label.pinIds.includes(pid))
-    )?.netLabelWidth;
-    if (dcWidthByPinId !== void 0) return dcWidthByPinId;
-    return this.inputProblem.netConnections.find(
-      (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
-    )?.netLabelWidth;
-  }
   getNetLabelHeight(label) {
     if (label.netId) {
       const ncHeight = this.inputProblem.netConnections.find(
@@ -10541,18 +10569,12 @@ var getChipBounds = (inputProblem) => {
   };
 };
 var getNetLabelWidth = (inputProblem, label) => {
-  const ncWidthByNetId = inputProblem.netConnections.find(
-    (connection) => connection.netId === label.netId
-  )?.netLabelWidth;
-  if (ncWidthByNetId !== void 0) return ncWidthByNetId;
-  const dcWidth = inputProblem.directConnections.find(
-    (dc) => dc.pinIds.some((pid) => label.pinIds.includes(pid))
-  )?.netLabelWidth;
-  if (dcWidth !== void 0) return dcWidth;
-  const ncWidthByPinId = inputProblem.netConnections.find(
-    (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
-  )?.netLabelWidth;
-  if (ncWidthByPinId !== void 0) return ncWidthByPinId;
+  const configuredWidth = getNetLabelWidthForConnection({
+    inputProblem,
+    netId: label.netId,
+    pinIds: label.pinIds
+  });
+  if (configuredWidth !== void 0) return configuredWidth;
   if (label.orientation === "y+" || label.orientation === "y-") {
     return label.height;
   }
@@ -10958,10 +10980,10 @@ function isPointOnPath(point, path) {
 }
 function buildMergedObstacleLabel(seedLabel, allLabels) {
   const TOUCH_MARGIN = 0.01;
-  const getBounds3 = (l) => getRectBounds(l.center, l.width, l.height);
+  const getBounds4 = (l) => getRectBounds(l.center, l.width, l.height);
   const touches = (a, b) => {
-    const ba = getBounds3(a);
-    const bb = getBounds3(b);
+    const ba = getBounds4(a);
+    const bb = getBounds4(b);
     return ba.minX <= bb.maxX + TOUCH_MARGIN && ba.maxX >= bb.minX - TOUCH_MARGIN && ba.minY <= bb.maxY + TOUCH_MARGIN && ba.maxY >= bb.minY - TOUCH_MARGIN;
   };
   const group = /* @__PURE__ */ new Set([seedLabel]);
@@ -10978,7 +11000,7 @@ function buildMergedObstacleLabel(seedLabel, allLabels) {
   }
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
   for (const l of group) {
-    const b = getBounds3(l);
+    const b = getBounds4(l);
     if (b.minX < minX) minX = b.minX;
     if (b.minY < minY) minY = b.minY;
     if (b.maxX > maxX) maxX = b.maxX;
@@ -12789,6 +12811,365 @@ var alignPortOnlyInlineNetLabelStubs = ({
   return alignedPlacements;
 };
 
+// lib/solvers/InlineNetLabelSolver/pushAnchoredNetLabelsAwayFromInlineLabels.ts
+var LABEL_CLEARANCE2 = 0.05;
+var POINT_EPSILON = 1e-6;
+var CONTIGUOUS_LABEL_GAP = 0.01;
+var MAX_OUTWARD_DISTANCE = 5;
+var getBounds3 = (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 pointsEqual3 = (a, b) => Math.abs(a.x - b.x) <= POINT_EPSILON && Math.abs(a.y - b.y) <= POINT_EPSILON;
+var pathIntersectsBounds = (path, bounds) => {
+  for (let index = 0; index < path.length - 1; index++) {
+    const start = path[index];
+    const end = path[index + 1];
+    const segmentBounds = {
+      minX: Math.min(start.x, end.x),
+      maxX: Math.max(start.x, end.x),
+      minY: Math.min(start.y, end.y),
+      maxY: Math.max(start.y, end.y)
+    };
+    if (boundsOverlap(segmentBounds, bounds)) return true;
+  }
+  return false;
+};
+var isPointOnPath2 = (point, path) => {
+  for (let index = 0; index < path.length - 1; index++) {
+    const start = path[index];
+    const end = path[index + 1];
+    const minX = Math.min(start.x, end.x) - POINT_EPSILON;
+    const maxX = Math.max(start.x, end.x) + POINT_EPSILON;
+    const minY = Math.min(start.y, end.y) - POINT_EPSILON;
+    const maxY = Math.max(start.y, end.y) + POINT_EPSILON;
+    const isHorizontal4 = Math.abs(start.y - end.y) <= POINT_EPSILON;
+    const isVertical5 = Math.abs(start.x - end.x) <= POINT_EPSILON;
+    if ((isHorizontal4 && Math.abs(point.y - start.y) <= POINT_EPSILON || isVertical5 && Math.abs(point.x - start.x) <= POINT_EPSILON) && point.x >= minX && point.x <= maxX && point.y >= minY && point.y <= maxY) {
+      return true;
+    }
+  }
+  return false;
+};
+var getRequiredOutwardDistance = (label, inlineBounds) => {
+  const labelBounds = getBounds3(label);
+  if (label.orientation === "x-" || label.orientation === "x+") {
+    const nearby2 = inlineBounds.filter(
+      (bounds) => labelBounds.minY < bounds.maxY && labelBounds.maxY > bounds.minY
+    );
+    if (nearby2.length === 0) return 0;
+    if (label.orientation === "x-") {
+      const targetMaxX = Math.min(...nearby2.map((bounds) => bounds.minX));
+      return Math.max(0, labelBounds.maxX - targetMaxX + LABEL_CLEARANCE2);
+    }
+    const targetMinX = Math.max(...nearby2.map((bounds) => bounds.maxX));
+    return Math.max(0, targetMinX - labelBounds.minX + LABEL_CLEARANCE2);
+  }
+  const nearby = inlineBounds.filter(
+    (bounds) => labelBounds.minX < bounds.maxX && labelBounds.maxX > bounds.minX
+  );
+  if (nearby.length === 0) return 0;
+  if (label.orientation === "y-") {
+    const targetMaxY = Math.min(...nearby.map((bounds) => bounds.minY));
+    return Math.max(0, labelBounds.maxY - targetMaxY + LABEL_CLEARANCE2);
+  }
+  const targetMinY = Math.max(...nearby.map((bounds) => bounds.maxY));
+  return Math.max(0, targetMinY - labelBounds.minY + LABEL_CLEARANCE2);
+};
+var moveLabel = (label, orientation, distance5) => {
+  const direction = dir(orientation);
+  return {
+    ...label,
+    anchorPoint: {
+      x: label.anchorPoint.x + direction.x * distance5,
+      y: label.anchorPoint.y + direction.y * distance5
+    },
+    center: {
+      x: label.center.x + direction.x * distance5,
+      y: label.center.y + direction.y * distance5
+    }
+  };
+};
+var getDistanceToShoveBoundsPast = (obstacleBounds, movingBounds, orientation) => {
+  switch (orientation) {
+    case "x-":
+      return obstacleBounds.maxX - movingBounds.minX + LABEL_CLEARANCE2;
+    case "x+":
+      return movingBounds.maxX - obstacleBounds.minX + LABEL_CLEARANCE2;
+    case "y-":
+      return obstacleBounds.maxY - movingBounds.minY + LABEL_CLEARANCE2;
+    case "y+":
+      return movingBounds.maxY - obstacleBounds.minY + LABEL_CLEARANCE2;
+  }
+};
+var boundsGapOnPerpendicularAxis = (a, b, orientation) => {
+  if (orientation === "x-" || orientation === "x+") {
+    return Math.max(0, a.minY - b.maxY, b.minY - a.maxY);
+  }
+  return Math.max(0, a.minX - b.maxX, b.minX - a.maxX);
+};
+var sharesOwnerChip = (label, ownerChipIds, chipIdByPinId) => label.pinIds.some((pinId) => ownerChipIds.has(chipIdByPinId.get(pinId) ?? ""));
+var isGeneratedLabelConnector = (trace) => trace.mspPairId.startsWith("available-net-orientation-") || trace.mspPairId.startsWith("inline-net-label-clearance-");
+var findConnectorTraceIndex = (label, traces) => traces.findIndex((trace) => {
+  if (trace.globalConnNetId !== label.globalConnNetId) return false;
+  if (!isGeneratedLabelConnector(trace)) return false;
+  const first = trace.tracePath[0];
+  const last = trace.tracePath.at(-1);
+  return Boolean(
+    first && pointsEqual3(first, label.anchorPoint) || last && pointsEqual3(last, label.anchorPoint)
+  );
+});
+var canAddConnectorAtAnchor = (label, traces, pinMap) => {
+  if (label.pinIds.some((pinId) => {
+    const pin = pinMap[pinId];
+    return pin && pointsEqual3(pin, label.anchorPoint);
+  })) {
+    return true;
+  }
+  return traces.some(
+    (trace) => trace.globalConnNetId === label.globalConnNetId && isPointOnPath2(label.anchorPoint, trace.tracePath)
+  );
+};
+var moveConnectorEndpoint = (trace, oldAnchor, newAnchor) => {
+  const tracePath = trace.tracePath.map((point) => ({ ...point }));
+  if (pointsEqual3(tracePath[0], oldAnchor)) tracePath[0] = newAnchor;
+  if (pointsEqual3(tracePath.at(-1), oldAnchor)) {
+    tracePath[tracePath.length - 1] = newAnchor;
+  }
+  return { ...trace, tracePath };
+};
+var createConnectorTrace = ({
+  label,
+  labelIndex,
+  newAnchor,
+  pinMap
+}) => {
+  const mspPairId = `inline-net-label-clearance-${labelIndex}-${label.netId ?? label.globalConnNetId}`;
+  return {
+    mspPairId,
+    dcConnNetId: label.dcConnNetId ?? label.globalConnNetId,
+    globalConnNetId: label.globalConnNetId,
+    userNetId: label.netId,
+    pins: getTracePins(label, pinMap),
+    tracePath: [label.anchorPoint, newAnchor],
+    mspConnectionPairIds: [mspPairId],
+    pinIds: label.pinIds
+  };
+};
+var getContiguousLabelGroup = ({
+  triggerIndex,
+  labels,
+  chipIdByPinId
+}) => {
+  const trigger = labels[triggerIndex];
+  const ownerChipIds = new Set(
+    trigger.pinIds.flatMap((pinId) => {
+      const chipId = chipIdByPinId.get(pinId);
+      return chipId ? [chipId] : [];
+    })
+  );
+  const candidates = labels.map((label, labelIndex) => ({ label, labelIndex })).filter(
+    ({ label }) => label.orientation === trigger.orientation && label.mspConnectionPairIds.length === 0 && sharesOwnerChip(label, ownerChipIds, chipIdByPinId)
+  );
+  const group = /* @__PURE__ */ new Set([triggerIndex]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const { label, labelIndex } of candidates) {
+      if (group.has(labelIndex)) continue;
+      if ([...group].some(
+        (memberIndex) => boundsGapOnPerpendicularAxis(
+          getBounds3(labels[memberIndex]),
+          getBounds3(label),
+          trigger.orientation
+        ) <= CONTIGUOUS_LABEL_GAP
+      )) {
+        group.add(labelIndex);
+        changed = true;
+      }
+    }
+  }
+  return { group, ownerChipIds };
+};
+var pushAnchoredNetLabelsAwayFromInlineLabels = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+  inlineNetLabelPlacements
+}) => {
+  const outputTraces = traces.map((trace) => ({
+    ...trace,
+    tracePath: trace.tracePath.map((point) => ({ ...point }))
+  }));
+  const outputLabels = netLabelPlacements.map((label) => ({ ...label }));
+  const inlineBounds = inlineNetLabelPlacements.map(getBounds3);
+  const pinMap = getPinMap(inputProblem);
+  const chipIdByPinId = /* @__PURE__ */ new Map();
+  for (const chip of inputProblem.chips) {
+    for (const pin of chip.pins) chipIdByPinId.set(pin.pinId, chip.chipId);
+  }
+  const movedLabelIndices = /* @__PURE__ */ new Set();
+  for (let triggerIndex = 0; triggerIndex < outputLabels.length; triggerIndex++) {
+    const trigger = outputLabels[triggerIndex];
+    const distance5 = getRequiredOutwardDistance(trigger, inlineBounds);
+    if (distance5 <= POINT_EPSILON || distance5 > MAX_OUTWARD_DISTANCE) continue;
+    const { group, ownerChipIds } = getContiguousLabelGroup({
+      triggerIndex,
+      labels: outputLabels,
+      chipIdByPinId
+    });
+    const distances = new Map(
+      [...group].map((labelIndex) => [labelIndex, distance5])
+    );
+    let failed = false;
+    for (let iteration = 0; iteration < outputLabels.length; iteration++) {
+      let adjustedObstacle = false;
+      for (const [movingIndex, movingDistance] of distances) {
+        const movingBounds = getBounds3(
+          moveLabel(
+            outputLabels[movingIndex],
+            trigger.orientation,
+            movingDistance
+          )
+        );
+        for (let obstacleIndex = 0; obstacleIndex < outputLabels.length; obstacleIndex++) {
+          if (group.has(obstacleIndex)) continue;
+          const obstacle = outputLabels[obstacleIndex];
+          const existingObstacleDistance = distances.get(obstacleIndex) ?? 0;
+          const obstacleBounds = getBounds3(
+            moveLabel(obstacle, trigger.orientation, existingObstacleDistance)
+          );
+          if (!boundsOverlap(movingBounds, obstacleBounds)) continue;
+          if (!sharesOwnerChip(obstacle, ownerChipIds, chipIdByPinId) || findConnectorTraceIndex(obstacle, outputTraces) === -1 && !canAddConnectorAtAnchor(obstacle, outputTraces, pinMap)) {
+            failed = true;
+            break;
+          }
+          const shoveDistance = getDistanceToShoveBoundsPast(
+            getBounds3(obstacle),
+            movingBounds,
+            trigger.orientation
+          );
+          if (shoveDistance > MAX_OUTWARD_DISTANCE || shoveDistance <= existingObstacleDistance + POINT_EPSILON) {
+            failed = true;
+            break;
+          }
+          distances.set(obstacleIndex, shoveDistance);
+          adjustedObstacle = true;
+        }
+        if (failed) break;
+      }
+      if (failed || !adjustedObstacle) break;
+    }
+    if (failed) continue;
+    const proposals = /* @__PURE__ */ new Map();
+    for (const [labelIndex, labelDistance] of distances) {
+      proposals.set(
+        labelIndex,
+        moveLabel(
+          outputLabels[labelIndex],
+          trigger.orientation,
+          labelDistance
+        )
+      );
+    }
+    const finalLabelAt = (labelIndex) => proposals.get(labelIndex) ?? outputLabels[labelIndex];
+    for (const [labelIndex, movedLabel] of proposals) {
+      const movedBounds = getBounds3(movedLabel);
+      if (inlineBounds.some((bounds) => boundsOverlap(movedBounds, bounds))) {
+        failed = true;
+        break;
+      }
+      if (inputProblem.chips.some(
+        (chip) => boundsOverlap(movedBounds, {
+          minX: chip.center.x - chip.width / 2,
+          maxX: chip.center.x + chip.width / 2,
+          minY: chip.center.y - chip.height / 2,
+          maxY: chip.center.y + chip.height / 2
+        })
+      ) || (inputProblem.textBoxes ?? []).some(
+        (textBox) => boundsOverlap(movedBounds, getTextBoxBounds(textBox))
+      )) {
+        failed = true;
+        break;
+      }
+      if (outputLabels.some(
+        (_, otherIndex) => otherIndex !== labelIndex && boundsOverlap(movedBounds, getBounds3(finalLabelAt(otherIndex)))
+      )) {
+        failed = true;
+        break;
+      }
+      if (outputTraces.some(
+        (trace) => trace.globalConnNetId !== movedLabel.globalConnNetId && pathIntersectsBounds(trace.tracePath, movedBounds)
+      )) {
+        failed = true;
+        break;
+      }
+    }
+    if (failed) continue;
+    const connectorUpdates = [];
+    for (const [labelIndex, movedLabel] of proposals) {
+      const label = outputLabels[labelIndex];
+      const connectorIndex = findConnectorTraceIndex(label, outputTraces);
+      if (connectorIndex === -1 && !canAddConnectorAtAnchor(label, outputTraces, pinMap)) {
+        failed = true;
+        break;
+      }
+      const connector = connectorIndex === -1 ? createConnectorTrace({
+        label,
+        labelIndex,
+        newAnchor: movedLabel.anchorPoint,
+        pinMap
+      }) : moveConnectorEndpoint(
+        outputTraces[connectorIndex],
+        label.anchorPoint,
+        movedLabel.anchorPoint
+      );
+      const connectorObstructed = inlineBounds.some(
+        (bounds) => pathIntersectsBounds(connector.tracePath, bounds)
+      ) || inputProblem.chips.some(
+        (chip) => pathIntersectsBounds(connector.tracePath, {
+          minX: chip.center.x - chip.width / 2,
+          maxX: chip.center.x + chip.width / 2,
+          minY: chip.center.y - chip.height / 2,
+          maxY: chip.center.y + chip.height / 2
+        })
+      ) || (inputProblem.textBoxes ?? []).some(
+        (textBox) => pathIntersectsBounds(connector.tracePath, getTextBoxBounds(textBox))
+      ) || outputLabels.some(
+        (_, otherIndex) => otherIndex !== labelIndex && pathIntersectsBounds(
+          connector.tracePath,
+          getBounds3(finalLabelAt(otherIndex))
+        )
+      );
+      if (connectorObstructed) {
+        failed = true;
+        break;
+      }
+      connectorUpdates.push({ labelIndex, connectorIndex, trace: connector });
+    }
+    if (failed) continue;
+    for (const [labelIndex, movedLabel] of proposals) {
+      outputLabels[labelIndex] = movedLabel;
+      movedLabelIndices.add(labelIndex);
+    }
+    for (const update of connectorUpdates) {
+      if (update.connectorIndex === -1) outputTraces.push(update.trace);
+      else outputTraces[update.connectorIndex] = update.trace;
+    }
+  }
+  return {
+    traces: outputTraces,
+    netLabelPlacements: outputLabels,
+    movedLabelCount: movedLabelIndices.size
+  };
+};
+
 // lib/solvers/InlineNetLabelSolver/InlineNetLabelSolver.ts
 var DEFAULT_INLINE_NET_LABEL_HEIGHT = 0.18;
 var INLINE_NET_LABEL_TRACE_MARGIN = 0.05;
@@ -12803,6 +13184,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
   queuedConnections;
   tracesByPinPairKey;
   hasAlignedPortOnlyStubs = false;
+  postProcessedOutput;
   constructor(input) {
     super();
     this.inputProblem = input.inputProblem;
@@ -12863,6 +13245,10 @@ var InlineNetLabelSolver = class extends BaseSolver {
       this.hasAlignedPortOnlyStubs = true;
       return;
     }
+    if (!this.postProcessedOutput) {
+      this.postProcessedOutput = this.buildPostProcessedOutput();
+      return;
+    }
     this.solved = true;
     this.stats.inlineNetLabelCount = this.inlineNetLabelPlacements.length;
   }
@@ -13109,19 +13495,29 @@ var InlineNetLabelSolver = class extends BaseSolver {
       (trace) => !(supersededNetLabelKeys.has(trace.globalConnNetId) && trace.mspPairId.startsWith("available-net-orientation-"))
     );
   }
-  getOutput() {
+  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 {
-      // AvailableNetOrientationSolver may have routed an elbow from a port to
-      // the anchored label that this inline placement supersedes. Keep the
-      // actual net trace, but discard that now-orphaned label connector.
-      traces: this.getOutputTraces(superseded),
-      netLabelPlacements: this.inputNetLabelPlacements.filter(
-        (placement) => !superseded.has(placement.globalConnNetId)
-      ),
+      traces: pushed.traces,
+      netLabelPlacements: pushed.netLabelPlacements,
       inlineNetLabelPlacements: this.inlineNetLabelPlacements
     };
   }
+  getOutput() {
+    if (this.postProcessedOutput) return this.postProcessedOutput;
+    return this.buildPostProcessedOutput();
+  }
   visualize() {
     const graphics = visualizeInputProblem(this.inputProblem);
     graphics.lines ??= [];