@tscircuit/schematic-trace-solver 0.0.181 → 0.0.183

package/dist/index.js

@@ -111,7 +111,7 @@ var arePinsInDifferentSchematicSections = (inputProblem, p1, p2) => {
 };
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection.ts
-var getPinDirection = (pin, chip) => {
+var getPinDirectionCandidates = (pin, chip, connectedPin) => {
   const { x, y } = pin;
   const { center, width, height } = chip;
   const yPlusEdge = center.y + height / 2;
@@ -128,17 +128,34 @@ var getPinDirection = (pin, chip) => {
     xPlusDistance,
     xMinusDistance
   );
-  if (minDistance === yPlusDistance) {
-    return "y+";
-  }
-  if (minDistance === yMinusDistance) {
-    return "y-";
+  const primaryDirection = minDistance === yPlusDistance ? "y+" : minDistance === yMinusDistance ? "y-" : minDistance === xPlusDistance ? "x+" : "x-";
+  const matchingDirections = [
+    { direction: "y+", distance: yPlusDistance },
+    { direction: "y-", distance: yMinusDistance },
+    { direction: "x+", distance: xPlusDistance },
+    { direction: "x-", distance: xMinusDistance }
+  ].filter(({ distance: distance7 }) => Math.abs(distance7 - minDistance) <= 1e-9).map(({ direction }) => direction);
+  const closestDirections = [
+    primaryDirection,
+    ...matchingDirections.filter((direction) => direction !== primaryDirection)
+  ];
+  if (!connectedPin || closestDirections.length <= 1) {
+    return closestDirections;
   }
-  if (minDistance === xPlusDistance) {
-    return "x+";
+  const xDistance = connectedPin.x - pin.x;
+  const yDistance = connectedPin.y - pin.y;
+  const directionTowardConnectedPin = Math.abs(xDistance) >= Math.abs(yDistance) ? xDistance >= 0 ? "x+" : "x-" : yDistance >= 0 ? "y+" : "y-";
+  if (!closestDirections.includes(directionTowardConnectedPin)) {
+    return closestDirections;
   }
-  return "x-";
+  return [
+    directionTowardConnectedPin,
+    ...closestDirections.filter(
+      (direction) => direction !== directionTowardConnectedPin
+    )
+  ];
 };
+var getPinDirection = (pin, chip, connectedPin) => getPinDirectionCandidates(pin, chip, connectedPin)[0];
 
 // lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem.ts
 var visualizeInputProblem = (inputProblem, opts = {}) => {
@@ -1353,6 +1370,38 @@ var pinsFaceEachOther = ({
   }
   return yDistance > 0 ? pin1._facingDirection === "y+" && pin2._facingDirection === "y-" : pin1._facingDirection === "y-" && pin2._facingDirection === "y+";
 };
+var getPathLength = (points) => {
+  let length = 0;
+  for (let i = 0; i < points.length - 1; i++) {
+    length += Math.abs(points[i + 1].x - points[i].x) + Math.abs(points[i + 1].y - points[i].y);
+  }
+  return length;
+};
+var getInitialPathForPins = ({
+  pins,
+  obstacles
+}) => {
+  const [pin1, pin2] = pins;
+  const directShortPath = calculateDirectShortPath(pin1, pin2);
+  const defaultElbow = calculateElbowForPins({
+    pin1,
+    pin2,
+    overshoot: 0.2
+  });
+  const routingDistance = Math.abs(pin1.x - pin2.x) + Math.abs(pin1.y - pin2.y);
+  const adaptiveElbow = calculateElbowForPins({
+    pin1,
+    pin2,
+    overshoot: Math.min(0.2, Math.max(0.02, routingDistance / 4))
+  });
+  const adaptiveElbowIsShorter = getPathLength(adaptiveElbow) < getPathLength(defaultElbow);
+  const defaultElbowBacktracks = getPathLength(defaultElbow) > routingDistance + 1e-9;
+  const shouldUseAdaptiveElbow = findFirstCollision(adaptiveElbow, obstacles) === null && (pinsFaceEachOther({ pin1, pin2 }) && defaultElbowBacktracks && adaptiveElbowIsShorter || findFirstCollision(defaultElbow, obstacles) !== null);
+  return {
+    path: directShortPath ?? (shouldUseAdaptiveElbow ? adaptiveElbow : defaultElbow),
+    isDirectShortPath: directShortPath !== null
+  };
+};
 var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
   pins;
   connectionPair;
@@ -1364,9 +1413,12 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
   aabb;
   baseElbow;
   preferExteriorDetours;
+  reserveNetLabelClearance;
   solvedTracePath = null;
   queue = [];
   visited = /* @__PURE__ */ new Set();
+  inferredPinIndexes = /* @__PURE__ */ new Set();
+  hasAmbiguousPinDirections = false;
   constructor(params) {
     super();
     this.pins = params.pins;
@@ -1374,14 +1426,9 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     this.inputProblem = params.inputProblem;
     this.chipMap = params.chipMap;
     this.preferExteriorDetours = params.preferExteriorDetours ?? true;
-    for (const pin of this.pins) {
-      if (!pin._facingDirection) {
-        const chip = this.chipMap[pin.chipId];
-        pin._facingDirection = getPinDirection(pin, chip);
-      }
-    }
+    this.reserveNetLabelClearance = params.reserveNetLabelClearance ?? true;
     this.obstacles = getObstacleRects(this.inputProblem, {
-      textBoxPadding: this.getTextBoxPaddingForConnectionPair()
+      textBoxPadding: this.reserveNetLabelClearance ? this.getTextBoxPaddingForConnectionPair() : void 0
     });
     this.textObstacles = new Set(this.obstacles.filter(isTextBoxObstacle));
     const endpointChipIds = new Set(this.pins.map((pin) => pin.chipId));
@@ -1390,36 +1437,68 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
         (obstacle) => obstacle.textBox.chipId !== void 0 && endpointChipIds.has(obstacle.textBox.chipId)
       )
     );
-    const [pin1, pin2] = this.pins;
-    const directShortPath = calculateDirectShortPath(pin1, pin2);
-    const defaultElbow = calculateElbowForPins({
-      pin1,
-      pin2,
-      overshoot: 0.2
-    });
-    const routingDistance = Math.abs(pin1.x - pin2.x) + Math.abs(pin1.y - pin2.y);
-    const adaptiveElbow = calculateElbowForPins({
-      pin1,
-      pin2,
-      overshoot: Math.min(0.2, Math.max(0.02, routingDistance / 4))
+    const directionOptions = this.pins.map((pin, pinIndex) => {
+      if (pin._facingDirection) return [pin._facingDirection];
+      this.inferredPinIndexes.add(pinIndex);
+      const connectedPin = this.pins[pinIndex === 0 ? 1 : 0];
+      return getPinDirectionCandidates(
+        pin,
+        this.chipMap[pin.chipId],
+        connectedPin
+      );
     });
-    const adaptiveElbowIsShorter = this.pathLength(adaptiveElbow) < this.pathLength(defaultElbow);
-    const defaultElbowBacktracks = this.pathLength(defaultElbow) > routingDistance + 1e-9;
-    const shouldUseAdaptiveElbow = findFirstCollision(adaptiveElbow, this.obstacles) === null && (pinsFaceEachOther({ pin1, pin2 }) && defaultElbowBacktracks && adaptiveElbowIsShorter || findFirstCollision(defaultElbow, this.obstacles) !== null);
-    this.baseElbow = defaultElbow;
-    if (shouldUseAdaptiveElbow) {
-      this.baseElbow = adaptiveElbow;
+    const directionPairs = directionOptions[0].flatMap(
+      (firstDirection, firstIndex) => directionOptions[1].map((secondDirection, secondIndex) => ({
+        directions: [firstDirection, secondDirection],
+        preferenceIndex: firstIndex + secondIndex
+      }))
+    );
+    this.hasAmbiguousPinDirections = directionOptions.some(
+      (directions) => directions.length > 1
+    );
+    const rankedDirectionPairs = directionPairs.map(({ directions, preferenceIndex }) => {
+      const candidatePins = this.pins.map((pin, index) => ({
+        ...pin,
+        _facingDirection: directions[index]
+      }));
+      const initialPath = getInitialPathForPins({
+        pins: candidatePins,
+        obstacles: this.obstacles
+      });
+      return {
+        directions,
+        baseElbow: initialPath.path,
+        isDirectShortPath: initialPath.isDirectShortPath,
+        preferenceIndex,
+        collisionCount: findFirstCollision(initialPath.path, this.obstacles) === null ? 0 : 1,
+        pathLength: getPathLength(initialPath.path)
+      };
+    }).sort(
+      (first, second) => first.collisionCount - second.collisionCount || first.pathLength - second.pathLength || first.preferenceIndex - second.preferenceIndex
+    );
+    const preferredCandidate = rankedDirectionPairs[0];
+    for (const [pinIndex, pin] of this.pins.entries()) {
+      pin._facingDirection = preferredCandidate.directions[pinIndex];
     }
-    if (directShortPath) {
-      this.baseElbow = directShortPath;
+    const [pin1, pin2] = this.pins;
+    this.baseElbow = preferredCandidate.baseElbow;
+    if (preferredCandidate.isDirectShortPath) {
+      this.solvedTracePath = preferredCandidate.baseElbow;
     }
-    this.solvedTracePath = directShortPath;
     this.aabb = aabbFromPoints(
       { x: pin1.x, y: pin1.y },
       { x: pin2.x, y: pin2.y }
     );
-    this.queue.push({ path: this.baseElbow, collisionRects: /* @__PURE__ */ new Set() });
-    this.visited.add(pathKey(this.baseElbow));
+    for (const candidate of rankedDirectionPairs) {
+      const key = pathKey(candidate.baseElbow);
+      if (this.visited.has(key)) continue;
+      this.visited.add(key);
+      this.queue.push({
+        path: candidate.baseElbow,
+        collisionRects: /* @__PURE__ */ new Set(),
+        directions: candidate.directions
+      });
+    }
   }
   getConstructorParams() {
     return {
@@ -1427,7 +1506,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       pins: this.pins,
       connectionPair: this.connectionPair,
       inputProblem: this.inputProblem,
-      preferExteriorDetours: this.preferExteriorDetours
+      preferExteriorDetours: this.preferExteriorDetours,
+      reserveNetLabelClearance: this.reserveNetLabelClearance
     };
   }
   getTextBoxPaddingForConnectionPair() {
@@ -1490,11 +1570,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     return null;
   }
   pathLength(pts) {
-    let sum = 0;
-    for (let i = 0; i < pts.length - 1; i++) {
-      sum += Math.abs(pts[i + 1].x - pts[i].x) + Math.abs(pts[i + 1].y - pts[i].y);
-    }
-    return sum;
+    return getPathLength(pts);
   }
   getPinBandPenalty(path) {
     let penalty = 0;
@@ -1529,7 +1605,7 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       this.error = "No collision-free path found";
       return;
     }
-    const { path, collisionRects } = state;
+    const { path, collisionRects, directions } = state;
     const [PA, PB] = this.pins;
     const collision = findFirstCollision(path, this.obstacles, {
       excludeRectsForSegment: (segIndex2) => {
@@ -1583,7 +1659,15 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       const last = path[path.length - 1];
       const EPS17 = 1e-9;
       const samePoint = (p, q) => Math.abs(p.x - q.x) < EPS17 && Math.abs(p.y - q.y) < EPS17;
-      if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y })) {
+      if (samePoint(first, { x: PA.x, y: PA.y }) && samePoint(last, { x: PB.x, y: PB.y }) && (!this.hasAmbiguousPinDirections || pathMatchesPinDirections({
+        path,
+        pin1: { ...PA, _facingDirection: directions[0] },
+        pin2: { ...PB, _facingDirection: directions[1] }
+      }))) {
+        for (const pinIndex of this.inferredPinIndexes) {
+          const direction = pinIndex === 0 ? segmentDirection(path[0], path[1]) : segmentDirection(path.at(-1), path.at(-2));
+          if (direction) this.pins[pinIndex]._facingDirection = direction;
+        }
         this.solvedTracePath = path;
         this.solved = true;
       }
@@ -1616,7 +1700,8 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
         nextCollisionRects.add(rect);
         this.queue.push({
           path: detour,
-          collisionRects: nextCollisionRects
+          collisionRects: nextCollisionRects,
+          directions
         });
       }
       return;
@@ -1725,7 +1810,11 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
       (a2, b2) => a2.length - b2.length || a2.pinBandPenalty - b2.pinBandPenalty
     );
     for (const st of newStates) {
-      this.queue.push({ path: st.path, collisionRects: st.collisionRects });
+      this.queue.push({
+        path: st.path,
+        collisionRects: st.collisionRects,
+        directions
+      });
     }
   }
   visualize() {
@@ -1789,6 +1878,7 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
   queuedConnectionPairs;
   chipMap;
   currentConnectionPair = null;
+  retryingWithoutNetLabelClearance = false;
   solvedTracePaths = [];
   failedConnectionPairs = [];
   constructor(params) {
@@ -1813,6 +1903,7 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
     if (this.activeSubSolver?.solved) {
       this.solvedTracePaths.push({
         ...this.currentConnectionPair,
+        pins: this.activeSubSolver.pins,
         tracePath: this.activeSubSolver.solvedTracePath,
         mspConnectionPairIds: [this.currentConnectionPair.mspPairId],
         pinIds: [
@@ -1822,8 +1913,28 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
       });
       this.activeSubSolver = null;
       this.currentConnectionPair = null;
+      this.retryingWithoutNetLabelClearance = false;
     }
     if (this.activeSubSolver?.failed) {
+      if (this.currentConnectionPair && !this.retryingWithoutNetLabelClearance && this.activeSubSolver.hasAmbiguousPinDirections) {
+        const connectionPair2 = this.currentConnectionPair;
+        this.retryingWithoutNetLabelClearance = true;
+        this.activeSubSolver = new SchematicTraceSingleLineSolver2({
+          inputProblem: this.inputProblem,
+          pins: connectionPair2.pins.map((pin) => ({
+            ...pin
+          })),
+          connectionPair: connectionPair2,
+          chipMap: this.chipMap,
+          preferExteriorDetours: shouldPreferExteriorDetours({
+            connectionPair: connectionPair2,
+            allConnectionPairs: this.mspConnectionPairs,
+            inputProblem: this.inputProblem
+          }),
+          reserveNetLabelClearance: false
+        });
+        return;
+      }
       if (this.currentConnectionPair) {
         this.failedConnectionPairs.push({
           ...this.currentConnectionPair,
@@ -1832,6 +1943,7 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
       }
       this.activeSubSolver = null;
       this.currentConnectionPair = null;
+      this.retryingWithoutNetLabelClearance = false;
     }
     if (this.activeSubSolver) {
       this.activeSubSolver.step();
@@ -1843,7 +1955,15 @@ var SchematicTraceLinesSolver = class extends BaseSolver {
       return;
     }
     this.currentConnectionPair = connectionPair;
-    const { pins } = connectionPair;
+    this.retryingWithoutNetLabelClearance = false;
+    const hasAmbiguousCornerPin = connectionPair.pins.some((pin) => {
+      if (pin._facingDirection) return false;
+      const chip = this.chipMap[pin.chipId];
+      return chip && getPinDirectionCandidates(pin, chip).length > 1;
+    });
+    const pins = hasAmbiguousCornerPin ? connectionPair.pins.map((pin) => ({
+      ...pin
+    })) : connectionPair.pins;
     this.activeSubSolver = new SchematicTraceSingleLineSolver2({
       inputProblem: this.inputProblem,
       pins,
@@ -4254,7 +4374,7 @@ var doesPathOverlapTraceStrokes = (path, traces) => {
 // lib/solvers/TraceLabelOverlapAvoidanceSolver/sub-solvers/SingleOverlapSolver/SingleOverlapSolver.ts
 var MAX_TRIES = 5;
 var PATH_LENGTH_EPSILON = 1e-9;
-var getPathLength = (points) => {
+var getPathLength2 = (points) => {
   let length = 0;
   for (let pointIndex = 0; pointIndex < points.length - 1; pointIndex++) {
     const point = points[pointIndex];
@@ -4304,7 +4424,7 @@ var SingleOverlapSolver = class extends BaseSolver {
       );
     }
     this.queuedCandidatePaths = [...candidateByPath.values()].sort((a, b) => {
-      const pathLengthDifference = getPathLength(a) - getPathLength(b);
+      const pathLengthDifference = getPathLength2(a) - getPathLength2(b);
       if (Math.abs(pathLengthDifference) >= PATH_LENGTH_EPSILON) {
         return pathLengthDifference;
       }
@@ -5238,12 +5358,62 @@ var tryConnectPoints = (start, end) => {
 };
 
 // lib/solvers/TraceCleanupSolver/hasCollisionsWithLabels.ts
-var hasCollisionsWithLabels = (pathSegments, labels) => {
+var EPSILON = 1e-9;
+var rangesMeetWithoutOverlap = (firstMin, firstMax, secondMin, secondMax) => firstMax >= secondMin - EPSILON && secondMax >= firstMin - EPSILON && Math.min(firstMax, secondMax) - Math.max(firstMin, secondMin) <= EPSILON;
+var pointsEqual = (first, second) => Math.abs(first.x - second.x) <= EPSILON && Math.abs(first.y - second.y) <= EPSILON;
+var continuesExistingBoundarySegment = ({
+  start,
+  end,
+  label,
+  originalPath
+}) => {
+  const isVertical6 = Math.abs(start.x - end.x) <= EPSILON;
+  const isHorizontal5 = Math.abs(start.y - end.y) <= EPSILON;
+  const isOnBoundary = isVertical6 ? Math.abs(start.x - label.minX) <= EPSILON || Math.abs(start.x - label.maxX) <= EPSILON : isHorizontal5 ? Math.abs(start.y - label.minY) <= EPSILON || Math.abs(start.y - label.maxY) <= EPSILON : false;
+  if (!isOnBoundary) return false;
+  for (let i = 0; i < originalPath.length - 1; i++) {
+    const isEndpointSegment = i === 0 || i === originalPath.length - 2;
+    if (!isEndpointSegment) continue;
+    const originalStart = originalPath[i];
+    const originalEnd = originalPath[i + 1];
+    const innerEndpoint = i === 0 ? originalEnd : originalStart;
+    if (!pointsEqual(start, innerEndpoint) && !pointsEqual(end, innerEndpoint)) {
+      continue;
+    }
+    if (!segmentIntersectsRect(originalStart, originalEnd, label)) continue;
+    if (isVertical6 && Math.abs(originalStart.x - originalEnd.x) <= EPSILON && Math.abs(originalStart.x - start.x) <= EPSILON && rangesMeetWithoutOverlap(
+      Math.min(start.y, end.y),
+      Math.max(start.y, end.y),
+      Math.min(originalStart.y, originalEnd.y),
+      Math.max(originalStart.y, originalEnd.y)
+    )) {
+      return true;
+    }
+    if (isHorizontal5 && Math.abs(originalStart.y - originalEnd.y) <= EPSILON && Math.abs(originalStart.y - start.y) <= EPSILON && rangesMeetWithoutOverlap(
+      Math.min(start.x, end.x),
+      Math.max(start.x, end.x),
+      Math.min(originalStart.x, originalEnd.x),
+      Math.max(originalStart.x, originalEnd.x)
+    )) {
+      return true;
+    }
+  }
+  return false;
+};
+var hasCollisionsWithLabels = (pathSegments, labels, options = {}) => {
   for (let i = 0; i < pathSegments.length - 1; i++) {
     const p1 = pathSegments[i];
     const p2 = pathSegments[i + 1];
     for (const label of labels) {
       if (segmentIntersectsRect(p1, p2, label)) {
+        if (options.originalPath && continuesExistingBoundarySegment({
+          start: p1,
+          end: p2,
+          label,
+          originalPath: options.originalPath
+        })) {
+          continue;
+        }
         return true;
       }
     }
@@ -5300,7 +5470,8 @@ var minimizeTurns = ({
   path,
   obstacles,
   labelBounds,
-  originalPath
+  originalPath,
+  allowLabelBoundaryExtension = false
 }) => {
   if (path.length <= 2) {
     return path;
@@ -5336,7 +5507,8 @@ var minimizeTurns = ({
           const collidesWithObstacles = hasCollisions(connection, obstacles);
           const collidesWithLabels = hasCollisionsWithLabels(
             connection,
-            labelBounds
+            labelBounds,
+            allowLabelBoundaryExtension ? { originalPath } : {}
           );
           if (!collidesWithObstacles && !collidesWithLabels) {
             const newTurns = countTurns(testPath);
@@ -5385,7 +5557,8 @@ var minimizeTurns = ({
             );
             const collidesWithLabels = hasCollisionsWithLabels(
               connectionSegments,
-              labelBounds
+              labelBounds,
+              allowLabelBoundaryExtension ? { originalPath } : {}
             );
             if (!collidesWithObstacles && !collidesWithLabels) {
               const newTurns = countTurns(testPath);
@@ -5420,7 +5593,8 @@ var minimizeTurns = ({
           const collidesWithObstacles = hasCollisions([p1, p3], obstacles);
           const collidesWithLabels = hasCollisionsWithLabels(
             [p1, p3],
-            labelBounds
+            labelBounds,
+            allowLabelBoundaryExtension ? { originalPath } : {}
           );
           if (!collidesWithObstacles && !collidesWithLabels) {
             optimizedPath = testPath;
@@ -5448,7 +5622,7 @@ var getRailOrientation = (a, b) => {
   return null;
 };
 var rangesTouchOrOverlap = (a, b) => Math.min(a.maxAlong, b.maxAlong) - Math.max(a.minAlong, b.minAlong) >= -RAIL_ALIGNMENT_EPSILON;
-var pointsEqual = (a, b) => nearlyEqual(a.x, b.x) && nearlyEqual(a.y, b.y);
+var pointsEqual2 = (a, b) => nearlyEqual(a.x, b.x) && nearlyEqual(a.y, b.y);
 var getDistinctCoordinates = (coordinates) => {
   const distinct = [];
   for (const coordinate of coordinates) {
@@ -5570,6 +5744,19 @@ var shortenExcessiveLabelPaddingDetour = ({
 };
 
 // lib/solvers/TraceCleanupSolver/minimizeTurnsWithFilteredLabels.ts
+var PATH_LENGTH_EPSILON2 = 1e-9;
+var getPathLength3 = (path) => path.slice(1).reduce((length, point, pointIndex) => {
+  const previousPoint = path[pointIndex];
+  return length + Math.abs(point.x - previousPoint.x) + Math.abs(point.y - previousPoint.y);
+}, 0);
+var chooseLengthPreservingBoundaryRoute = ({
+  strictPath,
+  boundaryPath
+}) => {
+  const doesNotAddTurns = countTurns(boundaryPath) <= countTurns(strictPath);
+  const preservesLength = Math.abs(getPathLength3(boundaryPath) - getPathLength3(strictPath)) <= PATH_LENGTH_EPSILON2;
+  return doesNotAddTurns && preservesLength ? boundaryPath : strictPath;
+};
 var minimizeTurnsWithFilteredLabels = ({
   targetMspConnectionPairId,
   traces,
@@ -5632,21 +5819,33 @@ var minimizeTurnsWithFilteredLabels = ({
     minY: nl.center.y - nl.height / 2 - paddingBuffer,
     maxY: nl.center.y + nl.height / 2 + paddingBuffer
   }));
-  const strictPath = minimizeTurns({
-    path: originalPath,
-    obstacles: [...staticObstacles, ...getTraceObstacles2(otherTraces)],
-    labelBounds,
-    originalPath
-  });
-  const relaxedPath = minimizeTurns({
-    path: originalPath,
-    obstacles: [
-      ...staticObstacles,
-      ...getTraceObstacles2(relaxedObstacleTraces)
-    ],
-    labelBounds,
-    originalPath
-  });
+  const minimizeForObstacles = (obstacles) => {
+    const strictPath2 = minimizeTurns({
+      path: originalPath,
+      obstacles,
+      labelBounds,
+      originalPath
+    });
+    const boundaryPath = minimizeTurns({
+      path: originalPath,
+      obstacles,
+      labelBounds,
+      originalPath,
+      allowLabelBoundaryExtension: true
+    });
+    return chooseLengthPreservingBoundaryRoute({
+      strictPath: strictPath2,
+      boundaryPath
+    });
+  };
+  const strictPath = minimizeForObstacles([
+    ...staticObstacles,
+    ...getTraceObstacles2(otherTraces)
+  ]);
+  const relaxedPath = minimizeForObstacles([
+    ...staticObstacles,
+    ...getTraceObstacles2(relaxedObstacleTraces)
+  ]);
   const sameNetTraces = otherTraces.filter(
     (trace) => trace.globalConnNetId === targetTrace.globalConnNetId
   );
@@ -6038,7 +6237,7 @@ var segmentRunsAlongRectBoundary = (start, end, rect) => {
 
 // lib/solvers/Example28Solver/geometry.ts
 var getPathKey = (path) => path.map((point) => `${point.x},${point.y}`).join(";");
-var getPathLength2 = (path) => {
+var getPathLength4 = (path) => {
   let length = 0;
   for (let i = 0; i < path.length - 1; i++) {
     length += Math.abs(path[i + 1].x - path[i].x) + Math.abs(path[i + 1].y - path[i].y);
@@ -6192,7 +6391,7 @@ var getTraceGeometryMetrics = (traces, allTraces) => ({
   ),
   visibleLength: getVisibleTraceLength(traces),
   pathLength: traces.reduce(
-    (sum, trace) => sum + getPathLength2(trace.tracePath),
+    (sum, trace) => sum + getPathLength4(trace.tracePath),
     0
   ),
   otherNetCrossings: countOtherNetCrossings(traces, allTraces)
@@ -6214,7 +6413,7 @@ var isReadabilityImprovement = (candidate, baseline) => candidate.turnCount <= b
 
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/evaluateRailGroup.ts
 var tracePathChanged = (original, candidate) => original.tracePath.length !== candidate.tracePath.length || candidate.tracePath.some(
-  (point, index) => !pointsEqual(point, original.tracePath[index])
+  (point, index) => !pointsEqual2(point, original.tracePath[index])
 );
 var evaluateRailGroup = ({
   group,
@@ -7165,7 +7364,7 @@ var UntangleTraceSubsolver = class extends BaseSolver {
         candidate.traceId
       ).isColliding && (crossing.isInitialBundleCrossing || !candidate.collision.isColliding)
     ).sort(
-      (first, second) => Number(first.collision.isColliding) - Number(second.collision.isColliding) || getPathLength2(first.path) - getPathLength2(second.path)
+      (first, second) => Number(first.collision.isColliding) - Number(second.collision.isColliding) || getPathLength4(first.path) - getPathLength4(second.path)
     );
     const bestCandidate = validCandidates[0];
     if (!bestCandidate) return false;
@@ -7505,7 +7704,7 @@ var rerouteGeneratedNetLabelConnectorCrossings = ({
         chipBounds: [],
         clearance
       }).filter(
-        (candidate) => getPathLength2(candidate.path) <= getPathLength2(trace.tracePath) + EPS12 && countTurns(candidate.path) <= countTurns(trace.tracePath) + 2 && !isPathCollidingWithObstacles(
+        (candidate) => getPathLength4(candidate.path) <= getPathLength4(trace.tracePath) + EPS12 && countTurns(candidate.path) <= countTurns(trace.tracePath) + 2 && !isPathCollidingWithObstacles(
           candidate.path,
           componentAndTextObstacles
         ) && !hasCollisionsWithLabels(candidate.path, foreignLabelBounds) && !isPathColliding(candidate.path, foreignTraces, trace.mspPairId).isColliding && !doesPathCoincideWithTraces(candidate.path, foreignTraces)
@@ -7515,7 +7714,7 @@ var rerouteGeneratedNetLabelConnectorCrossings = ({
       }));
     });
     candidates.sort((first, second) => {
-      const lengthDifference = getPathLength2(first.path) - getPathLength2(second.path);
+      const lengthDifference = getPathLength4(first.path) - getPathLength4(second.path);
       return Math.abs(lengthDifference) > EPS12 ? lengthDifference : countTurns(first.path) - countTurns(second.path);
     });
     const bestCandidate = candidates[0];
@@ -7715,7 +7914,7 @@ var extendVerticalTracePathAtInteriorPoint = ({
   extensionEndPoint
 }) => {
   const sourceIndex = tracePath.findIndex(
-    (point) => pointsEqual(point, sourcePoint)
+    (point) => pointsEqual2(point, sourcePoint)
   );
   if (sourceIndex <= 0 || sourceIndex >= tracePath.length - 1) return null;
   const extensionDirectionY = extensionEndPoint.y - sourcePoint.y;
@@ -8294,7 +8493,7 @@ var scoreTracePath = ({
     labelHugDistance: getLabelHugDistance(tracePath, obstacleLabel),
     traceIntersections: countTraceIntersections(candidateTrace, outputTraces),
     chipBoundaryOverlap: getChipBoundaryOverlap(tracePath, chipObstacles),
-    pathLength: getPathLength2(tracePath)
+    pathLength: getPathLength4(tracePath)
   };
 };
 var countTraceIntersections = (trace, outputTraces) => {
@@ -8758,7 +8957,7 @@ var getConnectorTracePath = (source, target, orientation) => simplifyOrthogonalP
 );
 var simplifyOrthogonalPath = (path) => {
   const deduped = path.filter(
-    (point, index) => index === 0 || !pointsEqual2(point, path[index - 1])
+    (point, index) => index === 0 || !pointsEqual3(point, path[index - 1])
   );
   if (deduped.length < 3) return deduped;
   const simplified = [deduped[0]];
@@ -8774,7 +8973,7 @@ var simplifyOrthogonalPath = (path) => {
   simplified.push(deduped[deduped.length - 1]);
   return simplified;
 };
-var pointsEqual2 = (a, b) => sameX2(a, b) && sameY2(a, b);
+var pointsEqual3 = (a, b) => sameX2(a, b) && sameY2(a, b);
 var sameX2 = (a, b) => Math.abs(a.x - b.x) <= EPS13;
 var sameY2 = (a, b) => Math.abs(a.y - b.y) <= EPS13;
 var getMaxSearchDistance = (inputProblem) => {
@@ -12476,7 +12675,7 @@ var removeConsecutiveDuplicatePoints = (path) => {
   }
   return filteredPath;
 };
-var getPathLength3 = (path) => {
+var getPathLength5 = (path) => {
   let pathLength = 0;
   for (let pointIndex = 0; pointIndex < path.length - 1; pointIndex++) {
     const startPoint = path[pointIndex];
@@ -12560,7 +12759,7 @@ var getPerimeterCandidates = ({
     );
   }
   return candidates.sort(
-    (firstPath, secondPath) => getPathLength3(firstPath) - getPathLength3(secondPath)
+    (firstPath, secondPath) => getPathLength5(firstPath) - getPathLength5(secondPath)
   );
 };
 var getSegmentMidpoint = (startPoint, endPoint) => {
@@ -12665,7 +12864,7 @@ var getJunctionCandidates = ({
     }
   }
   return candidates.sort(
-    (firstPath, secondPath) => getPathLength3(firstPath) - getPathLength3(secondPath)
+    (firstPath, secondPath) => getPathLength5(firstPath) - getPathLength5(secondPath)
   );
 };
 var pathCollidesWithObstacles = ({
@@ -13885,8 +14084,8 @@ var getTracePathStartingAtPin = (trace, pin) => {
   const pathStart = trace.tracePath[0];
   const pathEnd = trace.tracePath.at(-1);
   if (!pathStart || !pathEnd) return null;
-  if (pointsEqual(pathStart, pin)) return trace.tracePath;
-  if (pointsEqual(pathEnd, pin)) return [...trace.tracePath].reverse();
+  if (pointsEqual2(pathStart, pin)) return trace.tracePath;
+  if (pointsEqual2(pathEnd, pin)) return [...trace.tracePath].reverse();
   return null;
 };
 var getPerpendicularPathCrossings = (targetPath, donorPath) => {
@@ -13908,7 +14107,7 @@ var getPerpendicularPathCrossings = (targetPath, donorPath) => {
         donorStart,
         donorEnd
       );
-      if (!intersectionPoint || pointsEqual(intersectionPoint, sharedEndpoint)) {
+      if (!intersectionPoint || pointsEqual2(intersectionPoint, sharedEndpoint)) {
         continue;
       }
       crossings.push({
@@ -13931,7 +14130,7 @@ var buildCollapsedCyclePath = ({
     crossing.intersectionPoint,
     ...targetPath.slice(crossing.targetSegmentIndex + 1)
   ]);
-  if (pointsEqual(targetTrace.tracePath[0], targetPath[0])) {
+  if (pointsEqual2(targetTrace.tracePath[0], targetPath[0])) {
     return pathFromSharedPin;
   }
   return pathFromSharedPin.reverse();
@@ -14379,8 +14578,8 @@ var generateElbowTransitionSimplificationCandidates = ({
 };
 
 // lib/solvers/TraceElbowTransitionSimplificationSolver/TraceElbowTransitionSimplificationSolver.ts
-var PATH_LENGTH_EPSILON2 = 1e-9;
-var getPathLength4 = (points) => points.slice(1).reduce((length, point, pointIndex) => {
+var PATH_LENGTH_EPSILON3 = 1e-9;
+var getPathLength6 = (points) => points.slice(1).reduce((length, point, pointIndex) => {
   const previousPoint = points[pointIndex];
   return length + Math.abs(point.x - previousPoint.x) + Math.abs(point.y - previousPoint.y);
 }, 0);
@@ -14452,8 +14651,8 @@ var TraceElbowTransitionSimplificationSolver = class extends BaseSolver {
           netLabels: this.input.netLabelPlacements
         }).length;
         const isSimplerEquivalentReroute = candidateOverlapCount < initialRerouteOverlapCount && Math.abs(
-          getPathLength4(simplifiedCandidate) - getPathLength4(reroutedPath)
-        ) < PATH_LENGTH_EPSILON2 && simplifiedCandidate.length < reroutedPath.length && preservesLabelAnchors(
+          getPathLength6(simplifiedCandidate) - getPathLength6(reroutedPath)
+        ) < PATH_LENGTH_EPSILON3 && simplifiedCandidate.length < reroutedPath.length && preservesLabelAnchors(
           this.input.netLabelPlacements,
           [completedReroute.initialTrace],
           [candidateTrace]
@@ -14471,7 +14670,7 @@ var TraceElbowTransitionSimplificationSolver = class extends BaseSolver {
         ({ label }) => `${label.globalConnNetId}:${label.netId}`
       )
     );
-    const initialPathLength = getPathLength4(tracePath);
+    const initialPathLength = getPathLength6(tracePath);
     const validCandidates = [...candidateByPath.values()].filter(
       (candidatePath) => {
         const candidateTrace = { ...trace, tracePath: candidatePath };
@@ -14483,7 +14682,7 @@ var TraceElbowTransitionSimplificationSolver = class extends BaseSolver {
           ({ label }) => initialOverlapIds.has(`${label.globalConnNetId}:${label.netId}`)
         );
         const reducesCollisions = candidateOverlaps.length < initialOverlaps.length;
-        const simplifiesGeometry = candidateOverlaps.length === initialOverlaps.length && getPathLength4(candidatePath) <= initialPathLength + PATH_LENGTH_EPSILON2 && candidatePath.length < tracePath.length;
+        const simplifiesGeometry = candidateOverlaps.length === initialOverlaps.length && getPathLength6(candidatePath) <= initialPathLength + PATH_LENGTH_EPSILON3 && candidatePath.length < tracePath.length;
         return candidateOnlyKeepsExistingOverlaps && (reducesCollisions || simplifiesGeometry) && preservesLabelAnchors(
           this.input.netLabelPlacements,
           [trace],
@@ -14498,7 +14697,7 @@ var TraceElbowTransitionSimplificationSolver = class extends BaseSolver {
     validCandidates.sort((a, b) => {
       const overlapDifference = getOverlapCount(a) - getOverlapCount(b);
       if (overlapDifference !== 0) return overlapDifference;
-      return getPathLength4(a) - getPathLength4(b) || a.length - b.length;
+      return getPathLength6(a) - getPathLength6(b) || a.length - b.length;
     });
     const bestCandidate = validCandidates[0];
     if (!bestCandidate) return;
@@ -14741,7 +14940,7 @@ var getInlineBounds = (placement) => {
     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 pointsEqual4 = (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];
@@ -14837,13 +15036,13 @@ var findConnectorTraceIndex = (label, traces) => traces.findIndex((trace) => {
   const first = trace.tracePath[0];
   const last = trace.tracePath.at(-1);
   return Boolean(
-    first && pointsEqual3(first, label.anchorPoint) || last && pointsEqual3(last, label.anchorPoint)
+    first && pointsEqual4(first, label.anchorPoint) || last && pointsEqual4(last, label.anchorPoint)
   );
 });
 var canAddConnectorAtAnchor = (label, traces, pinMap) => {
   if (label.pinIds.some((pinId) => {
     const pin = pinMap[pinId];
-    return pin && pointsEqual3(pin, label.anchorPoint);
+    return pin && pointsEqual4(pin, label.anchorPoint);
   })) {
     return true;
   }
@@ -14853,8 +15052,8 @@ var canAddConnectorAtAnchor = (label, traces, pinMap) => {
 };
 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)) {
+  if (pointsEqual4(tracePath[0], oldAnchor)) tracePath[0] = newAnchor;
+  if (pointsEqual4(tracePath.at(-1), oldAnchor)) {
     tracePath[tracePath.length - 1] = newAnchor;
   }
   return { ...trace, tracePath };
@@ -15048,7 +15247,13 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
         label.anchorPoint,
         movedLabel.anchorPoint
       );
-      const connectorObstructed = inlineBounds.some(
+      const connectorObstructed = outputTraces.some(
+        (trace) => trace.globalConnNetId !== connector.globalConnNetId && findPerpendicularPathCrossings(
+          connector.tracePath,
+          trace.tracePath,
+          { includeTerminalSegments: true }
+        ).length > 0
+      ) || inlineBounds.some(
         (bounds) => pathIntersectsBounds(connector.tracePath, bounds)
       ) || inputProblem.chips.some(
         (chip) => !ownerChipIds.has(chip.chipId) && pathIntersectsBounds(connector.tracePath, {
@@ -15315,14 +15520,14 @@ var pathIntersectsRenderedLabel = (path, label) => {
 
 // lib/solvers/InlineNetLabelSolver/restoreReroutesAroundSupersededLabels.ts
 var EPS15 = 1e-6;
-var getPathLength5 = (path) => path.slice(1).reduce((length, point, pointIndex) => {
+var getPathLength7 = (path) => path.slice(1).reduce((length, point, pointIndex) => {
   const previousPoint = path[pointIndex];
   return length + Math.abs(point.x - previousPoint.x) + Math.abs(point.y - previousPoint.y);
 }, 0);
 var pathsEqual = (first, second) => first.length === second.length && first.every(
   (point, index) => Math.abs(point.x - second[index].x) <= EPS15 && Math.abs(point.y - second[index].y) <= EPS15
 );
-var isStrictlySimpler = (candidate, current) => candidate.length < current.length && getPathLength5(candidate) <= getPathLength5(current) + EPS15;
+var isStrictlySimpler = (candidate, current) => candidate.length < current.length && getPathLength7(candidate) <= getPathLength7(current) + EPS15;
 var getIntersectionKeys = (path, otherPath) => {
   const intersections = /* @__PURE__ */ new Set();
   for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++) {
@@ -16285,22 +16490,22 @@ var getCollisionLimitedTerminalStubEnd = ({
 
 // lib/solvers/NetLabelTraceRecovery/doesTraceRecoveryPathConflict.ts
 import { doSegmentsIntersect as doSegmentsIntersect4 } from "@tscircuit/math-utils";
-var EPSILON = 1e-6;
+var EPSILON2 = 1e-6;
 var isStrictlyBetween2 = ({
   coordinate,
   segmentStartCoordinate,
   segmentEndCoordinate
-}) => coordinate > Math.min(segmentStartCoordinate, segmentEndCoordinate) + EPSILON && coordinate < Math.max(segmentStartCoordinate, segmentEndCoordinate) - EPSILON;
+}) => coordinate > Math.min(segmentStartCoordinate, segmentEndCoordinate) + EPSILON2 && coordinate < Math.max(segmentStartCoordinate, segmentEndCoordinate) - EPSILON2;
 var isStrictInteriorPerpendicularCrossing = ({
   firstSegmentStart,
   firstSegmentEnd,
   secondSegmentStart,
   secondSegmentEnd
 }) => {
-  const firstIsHorizontal = Math.abs(firstSegmentStart.y - firstSegmentEnd.y) <= EPSILON;
-  const firstIsVertical = Math.abs(firstSegmentStart.x - firstSegmentEnd.x) <= EPSILON;
-  const secondIsHorizontal = Math.abs(secondSegmentStart.y - secondSegmentEnd.y) <= EPSILON;
-  const secondIsVertical = Math.abs(secondSegmentStart.x - secondSegmentEnd.x) <= EPSILON;
+  const firstIsHorizontal = Math.abs(firstSegmentStart.y - firstSegmentEnd.y) <= EPSILON2;
+  const firstIsVertical = Math.abs(firstSegmentStart.x - firstSegmentEnd.x) <= EPSILON2;
+  const secondIsHorizontal = Math.abs(secondSegmentStart.y - secondSegmentEnd.y) <= EPSILON2;
+  const secondIsVertical = Math.abs(secondSegmentStart.x - secondSegmentEnd.x) <= EPSILON2;
   let horizontalStart;
   let horizontalEnd;
   if (firstIsHorizontal) {
@@ -16459,7 +16664,7 @@ var reduceTraceCrossings = ({
     globalConnNetId,
     otherTraces
   });
-  let bestPathLength = getPathLength2(tracePath);
+  let bestPathLength = getPathLength4(tracePath);
   for (const candidate of getEndpointAlignedSegmentCandidates(tracePath)) {
     if (!isCandidateValid(candidate)) continue;
     const crossingCount = countOtherNetCrossings2({
@@ -16467,7 +16672,7 @@ var reduceTraceCrossings = ({
       globalConnNetId,
       otherTraces
     });
-    const pathLength = getPathLength2(candidate);
+    const pathLength = getPathLength4(candidate);
     if (crossingCount < bestCrossingCount || crossingCount === bestCrossingCount && pathLength < bestPathLength) {
       bestPath = candidate;
       bestCrossingCount = crossingCount;