@tscircuit/schematic-trace-solver 0.0.146 → 0.0.148

package/dist/index.d.ts

@@ -88,6 +88,12 @@ interface InputDirectConnection {
     pinIds: [PinId, PinId];
     netId?: string;
     netLabelWidth?: number;
+    /**
+     * Width of the conventional anchored label to use only when an inline label
+     * cannot be placed. Unlike `netLabelWidth`, this does not affect whether or
+     * how the point-to-point connection is routed.
+     */
+    fallbackNetLabelWidth?: number;
     /**
      * When true, this point-to-point connection may be labeled with an "inline
      * net label": the net name is drawn parallel to (and offset from) the routed
@@ -116,6 +122,7 @@ interface InputNetConnection {
     netId: string;
     pinIds: Array<PinId>;
     netLabelWidth?: number;
+    fallbackNetLabelWidth?: number;
     netLabelHeight?: number;
     /**
      * When true, a named one- or two-pin net may use inline labels. A single-pin
@@ -221,7 +228,6 @@ declare class SchematicTraceSingleLineSolver2 extends BaseSolver {
     });
     getConstructorParams(): ConstructorParameters<typeof SchematicTraceSingleLineSolver2>[0];
     private getTextBoxPaddingForConnectionPair;
-    private getNetLabelWidthForConnectionPair;
     private getNetLabelHeightForConnectionPair;
     private axisOfSegment;
     private pathLength;
@@ -855,7 +861,6 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private getSearchDistanceLimit;
     private getLateralColumnMaxDistance;
     private createCandidate;
-    private getNetLabelWidth;
     private getNetLabelHeight;
     private getCandidateStatus;
     private isAcceptableTraceAnchorChipCollision;

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) {
@@ -6333,6 +6352,51 @@ var generateLShapeRerouteCandidates = ({
   }
   return [[i1_padded, c2, i2_padded]];
 };
+var generatePerimeterCornerTraceDetours = ({
+  trace,
+  chipBounds,
+  clearance
+}) => {
+  if (trace.tracePath.length < 4 || chipBounds.length === 0) return [];
+  const start = trace.tracePath[0];
+  const firstEscape = trace.tracePath[1];
+  const lastEscape = trace.tracePath.at(-2);
+  const end = trace.tracePath.at(-1);
+  const minX = Math.min(...chipBounds.map((bounds) => bounds.minX)) - clearance;
+  const maxX = Math.max(...chipBounds.map((bounds) => bounds.maxX)) + clearance;
+  const minY = Math.min(...chipBounds.map((bounds) => bounds.minY)) - clearance;
+  const maxY = Math.max(...chipBounds.map((bounds) => bounds.maxY)) + clearance;
+  const candidates = [];
+  for (const channelX of [minX, maxX]) {
+    for (const channelY of [minY, maxY]) {
+      candidates.push({
+        traceId: trace.mspPairId,
+        path: simplifyPath([
+          start,
+          firstEscape,
+          { x: firstEscape.x, y: channelY },
+          { x: channelX, y: channelY },
+          { x: channelX, y: lastEscape.y },
+          lastEscape,
+          end
+        ])
+      });
+      candidates.push({
+        traceId: trace.mspPairId,
+        path: simplifyPath([
+          start,
+          firstEscape,
+          { x: channelX, y: firstEscape.y },
+          { x: channelX, y: channelY },
+          { x: lastEscape.x, y: channelY },
+          lastEscape,
+          end
+        ])
+      });
+    }
+  }
+  return candidates;
+};
 var generatePerpendicularTraceDetours = ({
   trace,
   segmentIndex,
@@ -6644,7 +6708,8 @@ var UntangleTraceSubsolver = class extends BaseSolver {
         const otherTrace = traces[secondIndex];
         if (trace.globalConnNetId === otherTrace.globalConnNetId) continue;
         const isInitialBundleCrossing = this._isTraceBundle(trace, otherTrace);
-        if (!isInitialBundleCrossing && !this.reroutedTraceIds.has(trace.mspPairId) && !this.reroutedTraceIds.has(otherTrace.mspPairId)) {
+        const isEligibleInitialCrossing = this.input.eligibleTraceIds?.has(trace.mspPairId) === true || this.input.eligibleTraceIds?.has(otherTrace.mspPairId) === true;
+        if (!isInitialBundleCrossing && !isEligibleInitialCrossing && !this.reroutedTraceIds.has(trace.mspPairId) && !this.reroutedTraceIds.has(otherTrace.mspPairId)) {
           continue;
         }
         const crossings = findPerpendicularPathCrossings(
@@ -6687,6 +6752,16 @@ var UntangleTraceSubsolver = class extends BaseSolver {
         obstacleEnd: crossing.trace.tracePath[crossing.segmentIndex + 1],
         chipBounds,
         clearance: this.input.paddingBuffer
+      }),
+      ...generatePerimeterCornerTraceDetours({
+        trace: crossing.trace,
+        chipBounds,
+        clearance: this.input.paddingBuffer
+      }),
+      ...generatePerimeterCornerTraceDetours({
+        trace: crossing.otherTrace,
+        chipBounds,
+        clearance: this.input.paddingBuffer
       })
     ];
     const chipObstacles = getObstacleRects(this.input.inputProblem).filter(
@@ -8527,13 +8602,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 +8837,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 +9275,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 +9297,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 +9356,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 +9411,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 +9427,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 +10625,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;
   }
@@ -13781,6 +13859,42 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
     definePipelineStep("traceCleanupSolver", TraceCleanupSolver, (instance) => {
       const prevSolverOutput = instance.traceElbowTransitionSimplificationSolver.getOutput();
       const traces = prevSolverOutput.traces;
+      const overlapShiftSolver = instance.traceOverlapShiftSolver;
+      const inlineLabelNetIds = new Set(
+        [
+          ...instance.inputProblem.directConnections,
+          ...instance.inputProblem.netConnections
+        ].filter((connection) => connection.allowInlineNetLabel).map((connection) => connection.netId)
+      );
+      const traceIdsInNewCrossingsAfterOverlapShift = /* @__PURE__ */ new Set();
+      for (let traceIndex = 0; traceIndex < overlapShiftSolver.inputTracePaths.length; traceIndex++) {
+        const inputTrace = overlapShiftSolver.inputTracePaths[traceIndex];
+        const shiftedTrace = overlapShiftSolver.correctedTraceMap[inputTrace.mspPairId];
+        for (let otherTraceIndex = traceIndex + 1; otherTraceIndex < overlapShiftSolver.inputTracePaths.length; otherTraceIndex++) {
+          const otherInputTrace = overlapShiftSolver.inputTracePaths[otherTraceIndex];
+          if (inputTrace.globalConnNetId === otherInputTrace.globalConnNetId) {
+            continue;
+          }
+          if (!inlineLabelNetIds.has(inputTrace.userNetId ?? "") && !inlineLabelNetIds.has(otherInputTrace.userNetId ?? "")) {
+            continue;
+          }
+          const otherShiftedTrace = overlapShiftSolver.correctedTraceMap[otherInputTrace.mspPairId];
+          const crossingCountBeforeShift = findPerpendicularPathCrossings(
+            inputTrace.tracePath,
+            otherInputTrace.tracePath
+          ).length;
+          const crossingCountAfterShift = findPerpendicularPathCrossings(
+            shiftedTrace.tracePath,
+            otherShiftedTrace.tracePath
+          ).length;
+          if (crossingCountAfterShift > crossingCountBeforeShift) {
+            traceIdsInNewCrossingsAfterOverlapShift.add(inputTrace.mspPairId);
+            traceIdsInNewCrossingsAfterOverlapShift.add(
+              otherInputTrace.mspPairId
+            );
+          }
+        }
+      }
       const labelMergingOutput = instance.traceLabelOverlapAvoidanceSolver.labelMergingSolver.getOutput();
       return [
         {
@@ -13788,7 +13902,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           allTraces: traces,
           allLabelPlacements: labelMergingOutput.netLabelPlacements,
           mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
-          paddingBuffer: 0.1
+          paddingBuffer: 0.1,
+          eligibleTraceIds: traceIdsInNewCrossingsAfterOverlapShift
         }
       ];
     }),

package/lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts

@@ -16,6 +16,7 @@ import type {
   InputProblem,
 } from "lib/types/InputProblem"
 import { dir, type FacingDirection } from "lib/utils/dir"
+import { getNetLabelWidthForConnection } from "lib/utils/getNetLabelWidthForConnection"
 import { rectIntersectsAnyTextBox } from "lib/utils/textBoxBounds"
 import {
   EPS,
@@ -180,13 +181,23 @@ export class AvailableNetOrientationSolver 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: number | undefined
     if (blockedLabelWidth !== undefined) {
       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 !== undefined) {
@@ -481,7 +492,11 @@ export class AvailableNetOrientationSolver extends BaseSolver {
 
     const { width, height } = getDimsForOrientation({
       orientation,
-      netLabelWidth: this.getNetLabelWidth(label),
+      netLabelWidth: getNetLabelWidthForConnection({
+        inputProblem: this.inputProblem,
+        netId: label.netId,
+        pinIds: label.pinIds,
+      }),
       netLabelHeight: this.getNetLabelHeight(label),
     })
 
@@ -1094,7 +1109,11 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   private labelIntersectsDifferentNetTrace(label: NetLabelPlacement) {
     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(
@@ -1118,7 +1137,11 @@ export class AvailableNetOrientationSolver 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),
     })
 
@@ -1197,7 +1220,11 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   ) {
     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 =
@@ -1278,7 +1305,11 @@ export class AvailableNetOrientationSolver extends BaseSolver {
   ): CandidateLabel {
     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 {
@@ -1291,29 +1322,6 @@ export class AvailableNetOrientationSolver extends BaseSolver {
     }
   }
 
-  private getNetLabelWidth(label: NetLabelPlacement) {
-    if (label.netId) {
-      const ncWidth = this.inputProblem.netConnections.find(
-        (connection) => connection.netId === label.netId,
-      )?.netLabelWidth
-      if (ncWidth !== undefined) return ncWidth
-
-      const dcWidthByNetId = this.inputProblem.directConnections.find(
-        (dc) => dc.netId === label.netId,
-      )?.netLabelWidth
-      if (dcWidthByNetId !== undefined) return dcWidthByNetId
-    }
-
-    const dcWidthByPinId = this.inputProblem.directConnections.find((dc) =>
-      dc.pinIds.some((pid) => label.pinIds.includes(pid)),
-    )?.netLabelWidth
-    if (dcWidthByPinId !== undefined) return dcWidthByPinId
-
-    return this.inputProblem.netConnections.find((nc) =>
-      nc.pinIds.some((pid) => label.pinIds.includes(pid)),
-    )?.netLabelWidth
-  }
-
   private getNetLabelHeight(label: NetLabelPlacement) {
     if (label.netId) {
       const ncHeight = this.inputProblem.netConnections.find(

package/lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver.ts

@@ -9,6 +9,7 @@ import type { GraphicsObject } from "graphics-debug"
 import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { getConnectivityMapsFromInputProblem } from "../MspConnectionPairSolver/getConnectivityMapFromInputProblem"
+import { getNetLabelWidthForConnection } from "lib/utils/getNetLabelWidthForConnection"
 
 /**
  * A group of traces that have at least one overlapping segment and
@@ -261,31 +262,15 @@ export class NetLabelPlacementSolver extends BaseSolver {
   private getNetLabelWidthForGroup(
     group: OverlappingSameNetTraceGroup,
   ): number | undefined {
-    if (group.netId) {
-      const ncWidth = this.inputProblem.netConnections.find(
-        (nc) => nc.netId === group.netId,
-      )?.netLabelWidth
-      if (ncWidth !== undefined) return ncWidth
-
-      const dcWidthByNetId = this.inputProblem.directConnections.find(
-        (dc) => dc.netId === group.netId,
-      )?.netLabelWidth
-      if (dcWidthByNetId !== undefined) 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 !== undefined) 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,
+    })
   }
 
   private getNetLabelHeightForGroup(

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -7,6 +7,7 @@ import { getDimsForOrientation } from "lib/solvers/NetLabelPlacementSolver/Singl
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import type { InputChip, InputProblem } from "lib/types/InputProblem"
 import type { FacingDirection } from "lib/utils/dir"
+import { getNetLabelWidthForConnection } from "lib/utils/getNetLabelWidthForConnection"
 import { getTextBoxBounds, type RectPadding } from "lib/utils/textBoxBounds"
 import { getPinDirection } from "../SchematicTraceSingleLineSolver/getPinDirection"
 import { calculateDirectShortPath } from "./calculateDirectShortPath"
@@ -201,7 +202,12 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     const orientations =
       this.inputProblem.availableNetLabelOrientations[netId] ??
       (["x+", "x-", "y+", "y-"] as FacingDirection[])
-    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: Required<RectPadding> = {
       minX: 0,
@@ -239,28 +245,6 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     return padding
   }
 
-  private getNetLabelWidthForConnectionPair(netId: string) {
-    const ncWidth = this.inputProblem.netConnections.find(
-      (nc) => nc.netId === netId,
-    )?.netLabelWidth
-    if (ncWidth !== undefined) return ncWidth
-
-    const dcWidthByNetId = this.inputProblem.directConnections.find(
-      (dc) => dc.netId === netId,
-    )?.netLabelWidth
-    if (dcWidthByNetId !== undefined) 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 !== undefined) return dcWidthByPinId
-
-    return this.inputProblem.netConnections.find((nc) =>
-      nc.pinIds.some((pid) => pinIds.includes(pid)),
-    )?.netLabelWidth
-  }
-
   private getNetLabelHeightForConnectionPair(netId: string) {
     const ncHeight = this.inputProblem.netConnections.find(
       (nc) => nc.netId === netId,