@tscircuit/schematic-trace-solver 0.0.182 → 0.0.184

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 = ({
@@ -13031,24 +13230,228 @@ var findNearestSharedPinExitRail = ({
   return nearestRail;
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/getSharedPin.ts
+var getSharedPin = ({
+  donorTrace,
+  branchTrace
+}) => {
+  const branchPinIds = new Set(branchTrace.pins.map((pin) => pin.pinId));
+  return donorTrace.pins.find((pin) => branchPinIds.has(pin.pinId)) ?? null;
+};
+
+// lib/solvers/SameNetJunctionAlignmentSolver/collapseRedundantSharedEndpointStubs.ts
+var getSegmentAxis3 = (start, end) => {
+  if (nearlyEqual(start.x, end.x)) return "y";
+  if (nearlyEqual(start.y, end.y)) return "x";
+  return null;
+};
+var getPathFromSharedPin = ({
+  trace,
+  sharedPinId
+}) => {
+  const tracePath = simplifyPath(trace.tracePath);
+  if (trace.pins[0]?.pinId === sharedPinId) return tracePath;
+  return tracePath.reverse();
+};
+var traceCanLoseSharedPrefix = ({
+  trace,
+  sharedPrefix,
+  netLabelPlacements
+}) => {
+  return !netLabelPlacements.some(
+    (label) => label.mspConnectionPairIds.includes(trace.mspPairId) && tracePathContainsPoint(sharedPrefix, label.anchorPoint)
+  );
+};
+var getTraceWithoutSharedPrefix = ({
+  trace,
+  pathFromSharedPin,
+  sharedPinId,
+  branchPoint
+}) => {
+  const branchSegmentIndex = pathFromSharedPin.findIndex((point, index) => {
+    const nextPoint = pathFromSharedPin[index + 1];
+    if (!nextPoint) return false;
+    return tracePathContainsPoint([point, nextPoint], branchPoint);
+  });
+  if (branchSegmentIndex < 0) return null;
+  const pathFromJunction = simplifyPath([
+    branchPoint,
+    ...pathFromSharedPin.slice(branchSegmentIndex + 1)
+  ]);
+  let tracePath = pathFromJunction;
+  if (trace.pins[0]?.pinId !== sharedPinId) {
+    tracePath = pathFromJunction.reverse();
+  }
+  return { ...trace, tracePath };
+};
+var collapseRedundantSharedEndpointStubs = ({
+  traces,
+  netLabelPlacements,
+  netLabelConnectorTraceIds,
+  multiPinNetPinIds
+}) => {
+  const outputTraces = [...traces];
+  for (let firstIndex = 0; firstIndex < outputTraces.length; firstIndex++) {
+    const firstTrace = outputTraces[firstIndex];
+    if (netLabelConnectorTraceIds.has(firstTrace.mspPairId)) continue;
+    for (let secondIndex = firstIndex + 1; secondIndex < outputTraces.length; secondIndex++) {
+      const secondTrace = outputTraces[secondIndex];
+      if (netLabelConnectorTraceIds.has(secondTrace.mspPairId) || firstTrace.globalConnNetId !== secondTrace.globalConnNetId) {
+        continue;
+      }
+      const sharedPin = getSharedPin({
+        donorTrace: firstTrace,
+        branchTrace: secondTrace
+      });
+      if (!sharedPin || !multiPinNetPinIds.has(sharedPin.pinId)) continue;
+      const firstPath = getPathFromSharedPin({
+        trace: firstTrace,
+        sharedPinId: sharedPin.pinId
+      });
+      const secondPath = getPathFromSharedPin({
+        trace: secondTrace,
+        sharedPinId: sharedPin.pinId
+      });
+      if (firstPath.length < 2 || secondPath.length < 2) continue;
+      const departureAxis = getSegmentAxis3(firstPath[0], firstPath[1]);
+      const secondDepartureAxis = getSegmentAxis3(secondPath[0], secondPath[1]);
+      if (!departureAxis || departureAxis !== secondDepartureAxis) continue;
+      const firstDepartureDirection = firstPath[1][departureAxis] - firstPath[0][departureAxis];
+      const secondDepartureDirection = secondPath[1][departureAxis] - secondPath[0][departureAxis];
+      if (!pointsEqual2(firstPath[1], secondPath[1]) && Math.sign(firstDepartureDirection) === Math.sign(secondDepartureDirection)) {
+        let traceIndexToCollapse2 = secondIndex;
+        let traceToCollapse2 = secondTrace;
+        let pathToCollapse2 = secondPath;
+        if (Math.abs(firstDepartureDirection) < Math.abs(secondDepartureDirection)) {
+          traceIndexToCollapse2 = firstIndex;
+          traceToCollapse2 = firstTrace;
+          pathToCollapse2 = firstPath;
+        }
+        const branchPoint2 = pathToCollapse2[1];
+        if (!traceCanLoseSharedPrefix({
+          trace: traceToCollapse2,
+          sharedPrefix: [pathToCollapse2[0], branchPoint2],
+          netLabelPlacements
+        })) {
+          if (traceIndexToCollapse2 === firstIndex) {
+            traceIndexToCollapse2 = secondIndex;
+            traceToCollapse2 = secondTrace;
+            pathToCollapse2 = secondPath;
+          } else {
+            traceIndexToCollapse2 = firstIndex;
+            traceToCollapse2 = firstTrace;
+            pathToCollapse2 = firstPath;
+          }
+        }
+        if (!traceCanLoseSharedPrefix({
+          trace: traceToCollapse2,
+          sharedPrefix: [pathToCollapse2[0], branchPoint2],
+          netLabelPlacements
+        })) {
+          continue;
+        }
+        const collapsedTrace2 = getTraceWithoutSharedPrefix({
+          trace: traceToCollapse2,
+          pathFromSharedPin: pathToCollapse2,
+          sharedPinId: sharedPin.pinId,
+          branchPoint: branchPoint2
+        });
+        if (!collapsedTrace2) continue;
+        outputTraces[traceIndexToCollapse2] = collapsedTrace2;
+        break;
+      }
+      if (firstPath.length < 3 || secondPath.length < 3) continue;
+      if (!pointsEqual2(firstPath[1], secondPath[1])) continue;
+      const railAxis = getSegmentAxis3(firstPath[1], firstPath[2]);
+      const secondRailAxis = getSegmentAxis3(secondPath[1], secondPath[2]);
+      if (!railAxis || railAxis !== secondRailAxis || railAxis === departureAxis) {
+        continue;
+      }
+      const firstRailDirection = firstPath[2][railAxis] - firstPath[1][railAxis];
+      const secondRailDirection = secondPath[2][railAxis] - secondPath[1][railAxis];
+      const railsHaveSameDirection = Math.sign(firstRailDirection) === Math.sign(secondRailDirection);
+      const sharedStub = firstPath.slice(0, 2);
+      if (!railsHaveSameDirection && !nearlyEqual(
+        Math.abs(firstRailDirection),
+        Math.abs(secondRailDirection)
+      ) && netLabelPlacements.some(
+        (label) => label.globalConnNetId === firstTrace.globalConnNetId && tracePathContainsPoint(sharedStub, label.anchorPoint)
+      )) {
+        continue;
+      }
+      let traceIndexToCollapse = secondIndex;
+      let traceToCollapse = secondTrace;
+      let pathToCollapse = secondPath;
+      let branchPoint = firstPath[1];
+      if (railsHaveSameDirection && Math.abs(firstRailDirection) < Math.abs(secondRailDirection)) {
+        traceIndexToCollapse = firstIndex;
+        traceToCollapse = firstTrace;
+        pathToCollapse = firstPath;
+        branchPoint = firstPath[2];
+      } else if (railsHaveSameDirection) {
+        branchPoint = secondPath[2];
+      }
+      const sharedPrefix = [pathToCollapse[0], pathToCollapse[1], branchPoint];
+      if (!traceCanLoseSharedPrefix({
+        trace: traceToCollapse,
+        sharedPrefix,
+        netLabelPlacements
+      })) {
+        if (traceIndexToCollapse === firstIndex) {
+          traceIndexToCollapse = secondIndex;
+          traceToCollapse = secondTrace;
+          pathToCollapse = secondPath;
+        } else {
+          traceIndexToCollapse = firstIndex;
+          traceToCollapse = firstTrace;
+          pathToCollapse = firstPath;
+        }
+      }
+      if (!traceCanLoseSharedPrefix({
+        trace: traceToCollapse,
+        sharedPrefix: [pathToCollapse[0], pathToCollapse[1], branchPoint],
+        netLabelPlacements
+      })) {
+        continue;
+      }
+      const collapsedTrace = getTraceWithoutSharedPrefix({
+        trace: traceToCollapse,
+        pathFromSharedPin: pathToCollapse,
+        sharedPinId: sharedPin.pinId,
+        branchPoint
+      });
+      if (!collapsedTrace) continue;
+      outputTraces[traceIndexToCollapse] = collapsedTrace;
+      break;
+    }
+  }
+  return outputTraces;
+};
+
 // lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts
 var MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2;
 var MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET = 0.2;
 var MAX_SHARED_PIN_RAIL_OFFSET = 0.05;
 var MAX_SHARED_ENDPOINT_RAIL_OFFSET = 0.8;
 var MIN_RETURN_STEM_LENGTH = 0.05;
-var getSegmentAxis3 = (start, end) => {
+var getMultiPinNetPinIds = (inputProblem) => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem);
+  const inputPinIds = new Set(
+    inputProblem.chips.flatMap((chip) => chip.pins.map((pin) => pin.pinId))
+  );
+  return new Set(
+    [...inputPinIds].filter((pinId) => {
+      const globalNetId = netConnMap.getNetConnectedToId(pinId);
+      if (!globalNetId) return false;
+      return netConnMap.getIdsConnectedToNet(globalNetId).filter((connectedId) => inputPinIds.has(connectedId)).length > 2;
+    })
+  );
+};
+var getSegmentAxis4 = (start, end) => {
   if (isHorizontal2(start, end)) return "x";
   if (isVertical2(start, end)) return "y";
   return null;
 };
-var getSharedPin = ({
-  donorTrace,
-  branchTrace
-}) => {
-  const branchPinIds = new Set(branchTrace.pins.map((pin) => pin.pinId));
-  return donorTrace.pins.find((pin) => branchPinIds.has(pin.pinId)) ?? null;
-};
 var getOtherPin = ({
   trace,
   sharedPin
@@ -13274,8 +13677,8 @@ var getAlignedSharedEndpointRailPath = ({
   const donorPath = pathFromShared(donorTrace);
   const branchPath = pathFromShared(branchTrace);
   if (donorPath.length < 3 || branchPath.length < 4) return null;
-  const donorDepartureAxis = getSegmentAxis3(donorPath[0], donorPath[1]);
-  const branchDepartureAxis = getSegmentAxis3(branchPath[0], branchPath[1]);
+  const donorDepartureAxis = getSegmentAxis4(donorPath[0], donorPath[1]);
+  const branchDepartureAxis = getSegmentAxis4(branchPath[0], branchPath[1]);
   if (!donorDepartureAxis || donorDepartureAxis !== branchDepartureAxis) {
     return null;
   }
@@ -13283,8 +13686,8 @@ var getAlignedSharedEndpointRailPath = ({
   const branchDeparture = branchPath[1][branchDepartureAxis] - branchPath[0][branchDepartureAxis];
   if (Math.sign(donorDeparture) !== Math.sign(branchDeparture)) return null;
   let railIndex = 1;
-  let donorRailAxis = getSegmentAxis3(donorPath[1], donorPath[2]);
-  let branchRailAxis = getSegmentAxis3(branchPath[1], branchPath[2]);
+  let donorRailAxis = getSegmentAxis4(donorPath[1], donorPath[2]);
+  let branchRailAxis = getSegmentAxis4(branchPath[1], branchPath[2]);
   if (!donorRailAxis || donorRailAxis !== branchRailAxis || donorRailAxis === donorDepartureAxis) {
     return null;
   }
@@ -13292,11 +13695,11 @@ var getAlignedSharedEndpointRailPath = ({
   if (firstRailsAreAligned) {
     railIndex++;
     if (!donorPath[railIndex + 2] || !branchPath[railIndex + 2]) return null;
-    donorRailAxis = getSegmentAxis3(
+    donorRailAxis = getSegmentAxis4(
       donorPath[railIndex],
       donorPath[railIndex + 1]
     );
-    branchRailAxis = getSegmentAxis3(
+    branchRailAxis = getSegmentAxis4(
       branchPath[railIndex],
       branchPath[railIndex + 1]
     );
@@ -13304,7 +13707,7 @@ var getAlignedSharedEndpointRailPath = ({
   }
   let branchParallelRailCount = 0;
   for (let index = 1; index < branchPath.length - 2; index++) {
-    if (getSegmentAxis3(branchPath[index], branchPath[index + 1]) === branchRailAxis) {
+    if (getSegmentAxis4(branchPath[index], branchPath[index + 1]) === branchRailAxis) {
       branchParallelRailCount++;
     }
   }
@@ -13346,13 +13749,13 @@ var getAlignedAttachedLabelConnectorPath = ({
     const junction = connectorPath[0];
     const turn = connectorPath[1];
     const railEnd = connectorPath[2];
-    const departureAxis = getSegmentAxis3(junction, turn);
-    const railAxis = getSegmentAxis3(turn, railEnd);
+    const departureAxis = getSegmentAxis4(junction, turn);
+    const railAxis = getSegmentAxis4(turn, railEnd);
     if (!departureAxis || !railAxis || departureAxis === railAxis) return null;
     const donorSegmentIndex = donorTrace.tracePath.findIndex(
       (point, index, path) => {
         const next = path[index + 1];
-        return next && getSegmentAxis3(point, next) === departureAxis && tracePathContainsPoint([point, next], junction) && tracePathContainsPoint([point, next], turn);
+        return next && getSegmentAxis4(point, next) === departureAxis && tracePathContainsPoint([point, next], junction) && tracePathContainsPoint([point, next], turn);
       }
     );
     if (donorSegmentIndex < 0) return null;
@@ -13365,7 +13768,7 @@ var getAlignedAttachedLabelConnectorPath = ({
       donorSegmentIndex > 0 ? [donorTrace.tracePath[donorSegmentIndex - 1], donorSegmentStart] : null,
       donorSegmentIndex + 2 < donorTrace.tracePath.length ? [donorSegmentEnd, donorTrace.tracePath[donorSegmentIndex + 2]] : null
     ].flatMap(
-      (segment) => segment && getSegmentAxis3(segment[0], segment[1]) === railAxis ? [segment] : []
+      (segment) => segment && getSegmentAxis4(segment[0], segment[1]) === railAxis ? [segment] : []
     );
     if (adjacentDonorRails.length === 0) return null;
     const railCoordinateAxis = railAxis === "x" ? "y" : "x";
@@ -13448,7 +13851,7 @@ var preserveAttachedLabelConnectorJunctions = ({
     if (!movedJunction) return null;
     const neighborIndex = endpointIndex === 0 ? 1 : endpointIndex - 1;
     const neighbor = connector.tracePath[neighborIndex];
-    if (!neighbor || getSegmentAxis3(originalJunction, neighbor) !== getSegmentAxis3(movedJunction, neighbor)) {
+    if (!neighbor || getSegmentAxis4(originalJunction, neighbor) !== getSegmentAxis4(movedJunction, neighbor)) {
       return null;
     }
     const movedConnector = {
@@ -13871,6 +14274,13 @@ var alignSameNetJunctions = ({
       }
     }
   }
+  const collapsedSharedEndpointStubs = collapseRedundantSharedEndpointStubs({
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    netLabelConnectorTraceIds,
+    multiPinNetPinIds: getMultiPinNetPinIds(inputProblem)
+  });
+  outputTraces = collapsedSharedEndpointStubs;
   return {
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,
@@ -13885,8 +14295,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 +14318,7 @@ var getPerpendicularPathCrossings = (targetPath, donorPath) => {
         donorStart,
         donorEnd
       );
-      if (!intersectionPoint || pointsEqual(intersectionPoint, sharedEndpoint)) {
+      if (!intersectionPoint || pointsEqual2(intersectionPoint, sharedEndpoint)) {
         continue;
       }
       crossings.push({
@@ -13931,7 +14341,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 +14789,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 +14862,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 +14881,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 +14893,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 +14908,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 +15151,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 +15247,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 +15263,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 };
@@ -15321,14 +15731,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++) {
@@ -16291,22 +16701,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) {
@@ -16465,7 +16875,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({
@@ -16473,7 +16883,7 @@ var reduceTraceCrossings = ({
       globalConnNetId,
       otherTraces
     });
-    const pathLength = getPathLength2(candidate);
+    const pathLength = getPathLength4(candidate);
     if (crossingCount < bestCrossingCount || crossingCount === bestCrossingCount && pathLength < bestPathLength) {
       bestPath = candidate;
       bestCrossingCount = crossingCount;