@tscircuit/schematic-trace-solver 0.0.153 → 0.0.155

package/dist/index.js

@@ -5690,22 +5690,8 @@ var getRailAlignmentFallbackCoordinates = ({
   return getDistinctCoordinates(coordinates);
 };
 
-// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/moveRailSegments.ts
-var moveRailSegments = (trace, segments, coordinate) => {
-  const pointsToMove = /* @__PURE__ */ new Set();
-  for (const segment of segments) {
-    pointsToMove.add(segment.segmentIndex);
-    pointsToMove.add(segment.segmentIndex + 1);
-  }
-  const orientation = segments[0].orientation;
-  const tracePath = simplifyPath(
-    trace.tracePath.map((point, index) => {
-      if (!pointsToMove.has(index)) return point;
-      return orientation === "vertical" ? { ...point, x: coordinate } : { ...point, y: coordinate };
-    })
-  );
-  return { ...trace, tracePath };
-};
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getFixedLabelCoordinate.ts
+import { distance as distance4 } from "@tscircuit/math-utils";
 
 // lib/solvers/RailNetLabelCornerPlacementSolver/geometry.ts
 var EPS7 = 1e-6;
@@ -5740,6 +5726,95 @@ var isPointOnSegment = (point, start, end) => {
 };
 var getSegmentOrientation = (a, b) => Math.abs(a.y - b.y) <= EPS7 ? "horizontal" : "vertical";
 
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getFixedLabelCoordinate.ts
+var getTransitivelyConnectedTraceIds = (group, traces) => {
+  const groupNetId = group[0].globalConnNetId;
+  const sameNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId === groupNetId
+  );
+  const connectedTraceIds = new Set(group.map((segment) => segment.traceId));
+  const connectedPinIds = new Set(
+    sameNetTraces.filter((trace) => connectedTraceIds.has(trace.mspPairId)).flatMap((trace) => trace.pinIds)
+  );
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const trace of sameNetTraces) {
+      if (connectedTraceIds.has(trace.mspPairId)) continue;
+      if (!trace.pinIds.some((pinId) => connectedPinIds.has(pinId))) continue;
+      connectedTraceIds.add(trace.mspPairId);
+      for (const pinId of trace.pinIds) connectedPinIds.add(pinId);
+      changed = true;
+    }
+  }
+  return connectedTraceIds;
+};
+var getLabelsLinkedToRailGroup = (group, netLabelPlacements, traces) => {
+  const traceIds = getTransitivelyConnectedTraceIds(group, traces);
+  return netLabelPlacements.filter(
+    (label) => label.mspConnectionPairIds.some((traceId) => traceIds.has(traceId))
+  );
+};
+var getFixedLabelCoordinate = (group, netLabelPlacements, traces) => {
+  const traceMap = new Map(traces.map((trace) => [trace.mspPairId, trace]));
+  const groupTraceIds = new Set(group.map((segment) => segment.traceId));
+  const groupHasOnlySingleRailTraces = [...groupTraceIds].every(
+    (traceId) => traceMap.get(traceId)?.tracePath.length === 4
+  );
+  if (!groupHasOnlySingleRailTraces) return null;
+  const orientation = group[0].orientation;
+  const linkedLabels = getLabelsLinkedToRailGroup(
+    group,
+    netLabelPlacements,
+    traces
+  );
+  const anchoringLabels = linkedLabels.filter(
+    (label) => label.orientation === group[0].componentFacingDirection && label.mspConnectionPairIds.some((traceId) => {
+      const trace = traceMap.get(traceId);
+      return trace && tracePathContainsPoint(trace.tracePath, label.anchorPoint);
+    })
+  );
+  const coordinates = getDistinctCoordinates(
+    anchoringLabels.map(
+      (label) => orientation === "vertical" ? label.anchorPoint.x : label.anchorPoint.y
+    )
+  );
+  if (coordinates.length !== 1) return null;
+  const labelCoordinate = coordinates[0];
+  const coordinate = group.find(
+    (segment) => Math.abs(segment.coordinate - labelCoordinate) <= RAIL_ALIGNMENT_EPSILON
+  )?.coordinate ?? labelCoordinate;
+  const labelIsAnchoredToRoutedBackbone = anchoringLabels.some(
+    (label) => label.mspConnectionPairIds.some(
+      (traceId) => (traceMap.get(traceId)?.tracePath.length ?? 0) > 4
+    )
+  );
+  if (labelIsAnchoredToRoutedBackbone) return coordinate;
+  const coordinateIsLocalToEveryTrace = group.every((segment) => {
+    const trace = traceMap.get(segment.traceId);
+    if (!trace) return false;
+    return Math.abs(segment.coordinate - coordinate) <= distance4(trace.pins[0], trace.pins[1]) + RAIL_ALIGNMENT_EPSILON;
+  });
+  return coordinateIsLocalToEveryTrace ? coordinate : null;
+};
+
+// lib/solvers/TraceCleanupSolver/sameNetRailAlignment/moveRailSegments.ts
+var moveRailSegments = (trace, segments, coordinate) => {
+  const pointsToMove = /* @__PURE__ */ new Set();
+  for (const segment of segments) {
+    if (nearlyEqual(segment.coordinate, coordinate)) continue;
+    pointsToMove.add(segment.segmentIndex);
+    pointsToMove.add(segment.segmentIndex + 1);
+  }
+  const orientation = segments[0].orientation;
+  const tracePath = simplifyPath(
+    trace.tracePath.map((point, index) => {
+      if (!pointsToMove.has(index)) return point;
+      return orientation === "vertical" ? { ...point, x: coordinate } : { ...point, y: coordinate };
+    })
+  );
+  return { ...trace, tracePath };
+};
+
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/preservesLabelAnchors.ts
 var getAnchoredTraceIds = (label, traces) => new Set(
   traces.filter(
@@ -5855,10 +5930,10 @@ var projectPointToPath = (point, path) => {
   let bestDistance = Number.POSITIVE_INFINITY;
   for (let i = 0; i < path.length - 1; i++) {
     const projectedPoint = projectPointToSegment(point, path[i], path[i + 1]);
-    const distance5 = getDistance2(point, projectedPoint);
-    if (distance5 < bestDistance) {
+    const distance7 = getDistance2(point, projectedPoint);
+    if (distance7 < bestDistance) {
       bestPoint = projectedPoint;
-      bestDistance = distance5;
+      bestDistance = distance7;
     }
   }
   return bestPoint;
@@ -5964,13 +6039,18 @@ var evaluateRailGroup = ({
   const originalCoordinates = getDistinctCoordinates(
     group.map((segment) => segment.coordinate)
   );
+  const fixedLabelCoordinate = getFixedLabelCoordinate(
+    group,
+    netLabelPlacements,
+    traces
+  );
   const otherNetTraces = traces.filter(
     (trace) => trace.globalConnNetId !== group[0].globalConnNetId
   );
   const immutableSameNetTraces = traces.filter(
     (trace) => trace.globalConnNetId === group[0].globalConnNetId && !eligibleTraceIds.has(trace.mspPairId)
   );
-  const evaluateCoordinates = (coordinates) => {
+  const evaluateCoordinates = (coordinates, options) => {
     let best = null;
     for (const coordinate of coordinates) {
       const candidateMap = /* @__PURE__ */ new Map();
@@ -6006,7 +6086,9 @@ var evaluateRailGroup = ({
         allCandidateTraces
       );
       if (metrics.otherNetCrossings > baseline.otherNetCrossings) continue;
-      if (!isReadabilityImprovement(metrics, baseline)) continue;
+      if (options?.coordinateIsFixedByLabel ? metrics.turnCount > baseline.turnCount : !isReadabilityImprovement(metrics, baseline)) {
+        continue;
+      }
       const score = {
         ...metrics,
         displacement: group.reduce(
@@ -6022,13 +6104,21 @@ var evaluateRailGroup = ({
         return tracePathChanged(original, candidate2);
       }).map((trace) => trace.mspPairId);
       if (changedTraceIds.length === 0) continue;
-      const candidate = { traces: allCandidateTraces, changedTraceIds, score };
+      const candidate = {
+        traces: allCandidateTraces,
+        changedTraceIds,
+        score
+      };
       if (!best || scoreIsBetter(candidate.score, best.score)) best = candidate;
     }
     return best;
   };
-  const originalCandidate = evaluateCoordinates(originalCoordinates);
+  const originalCandidate = evaluateCoordinates(
+    fixedLabelCoordinate === null ? originalCoordinates : [fixedLabelCoordinate],
+    { coordinateIsFixedByLabel: fixedLabelCoordinate !== null }
+  );
   if (originalCandidate) return originalCandidate;
+  if (fixedLabelCoordinate !== null) return null;
   return evaluateCoordinates(
     getRailAlignmentFallbackCoordinates({
       group,
@@ -6039,6 +6129,7 @@ var evaluateRailGroup = ({
 };
 
 // lib/solvers/TraceCleanupSolver/sameNetRailAlignment/getComponentSideRailSegments.ts
+import { distance as distance5 } from "@tscircuit/math-utils";
 var getMovableRailSegments = (trace) => {
   const segments = [];
   const path = trace.tracePath;
@@ -6083,8 +6174,9 @@ var railIsOutsideComponent = (segment, chip, facingDirection) => {
       return segment.orientation === "horizontal" && segment.coordinate <= minY + RAIL_ALIGNMENT_EPSILON;
   }
 };
-var getComponentSideRailSegments = (trace, chipMap) => {
+var getComponentSideRailSegments = (trace, chipMap, options) => {
   const segments = [];
+  const isLocalConnection = distance5(trace.pins[0], trace.pins[1]) <= (options?.maxMspPairDistance ?? DEFAULT_MAX_MSP_PAIR_DISTANCE);
   for (const segment of getMovableRailSegments(trace)) {
     const associations = trace.pins.flatMap((pin, pinIndex) => {
       const chip = chipMap.get(pin.chipId);
@@ -6102,9 +6194,18 @@ var getComponentSideRailSegments = (trace, chipMap) => {
       ];
     });
     associations.sort((a, b) => a.distanceFromEndpoint - b.distanceFromEndpoint);
-    const association = associations[0];
-    if (!association) continue;
-    segments.push({ ...segment, ...association });
+    const minimumDistance = associations[0]?.distanceFromEndpoint;
+    const nearestAssociationKeys = /* @__PURE__ */ new Set();
+    for (const association of associations) {
+      if (nearestAssociationKeys.size > 0 && (!options?.includeTiedEndpointAssociations || !isLocalConnection)) {
+        break;
+      }
+      if (association.distanceFromEndpoint !== minimumDistance) continue;
+      const associationKey = `${association.componentId}:${association.componentFacingDirection}`;
+      if (nearestAssociationKeys.has(associationKey)) continue;
+      nearestAssociationKeys.add(associationKey);
+      segments.push({ ...segment, ...association });
+    }
   }
   return segments;
 };
@@ -6135,41 +6236,90 @@ var tracesSharePin = (a, b, traceMap) => {
   return traceMap.get(b.traceId).pins.some((pin) => aPinIds.has(pin.pinId));
 };
 var canJoinRailGroup = (start, current, candidate, traceMap, obstacles) => candidate.globalConnNetId === start.globalConnNetId && candidate.orientation === start.orientation && candidate.componentId === start.componentId && candidate.componentFacingDirection === start.componentFacingDirection && (rangesTouchOrOverlap(current, candidate) || tracesSharePin(current, candidate, traceMap)) && corridorIsClear(current, candidate, obstacles);
-var getRailGroups = (traces, eligibleTraceIds, inputProblem, obstacles) => {
+var getRailGroups = (traces, eligibleTraceIds, inputProblem, obstacles, netLabelPlacements) => {
   const chipMap = new Map(inputProblem.chips.map((chip) => [chip.chipId, chip]));
-  const segments = traces.filter((trace) => eligibleTraceIds.has(trace.mspPairId)).flatMap((trace) => getComponentSideRailSegments(trace, chipMap));
   const traceMap = new Map(traces.map((trace) => [trace.mspPairId, trace]));
-  const visited = /* @__PURE__ */ new Set();
-  const groups = [];
-  for (let startIndex = 0; startIndex < segments.length; startIndex++) {
-    if (visited.has(startIndex)) continue;
-    const start = segments[startIndex];
-    const queue = [startIndex];
-    const group = [];
-    visited.add(startIndex);
-    for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
-      const current = segments[queue[queueIndex]];
-      group.push(current);
-      for (let candidateIndex = 0; candidateIndex < segments.length; candidateIndex++) {
-        if (visited.has(candidateIndex)) continue;
-        const candidate = segments[candidateIndex];
-        if (!canJoinRailGroup(start, current, candidate, traceMap, obstacles)) {
-          continue;
+  const eligibleTraces = traces.filter(
+    (trace) => eligibleTraceIds.has(trace.mspPairId)
+  );
+  const collectConnectedGroups = (segments) => {
+    const visited = /* @__PURE__ */ new Set();
+    const connectedGroups = [];
+    for (let startIndex = 0; startIndex < segments.length; startIndex++) {
+      if (visited.has(startIndex)) continue;
+      const start = segments[startIndex];
+      const queue = [startIndex];
+      const group = [];
+      visited.add(startIndex);
+      for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+        const current = segments[queue[queueIndex]];
+        group.push(current);
+        for (let candidateIndex = 0; candidateIndex < segments.length; candidateIndex++) {
+          if (visited.has(candidateIndex)) continue;
+          const candidate = segments[candidateIndex];
+          if (!canJoinRailGroup(start, current, candidate, traceMap, obstacles)) {
+            continue;
+          }
+          visited.add(candidateIndex);
+          queue.push(candidateIndex);
         }
-        visited.add(candidateIndex);
-        queue.push(candidateIndex);
       }
+      connectedGroups.push(group);
     }
+    return connectedGroups;
+  };
+  const groupKey = (group) => [
+    group[0].componentId,
+    group[0].componentFacingDirection,
+    group[0].orientation,
+    ...group.map((segment) => `${segment.traceId}:${segment.segmentIndex}`).sort()
+  ].join("|");
+  const selectedGroups = [];
+  const selectedGroupKeys = /* @__PURE__ */ new Set();
+  const addEligibleGroup = (group, options) => {
     const traceCount = new Set(group.map((segment) => segment.traceId)).size;
+    if (traceCount < 2) return;
+    const fixedLabelCoordinate = getFixedLabelCoordinate(
+      group,
+      netLabelPlacements,
+      traces
+    );
+    if (options?.requireFixedLabel && fixedLabelCoordinate === null) return;
     const hasDifferentCoordinates = group.some(
       (segment) => !nearlyEqual(segment.coordinate, group[0].coordinate)
     );
-    if (traceCount >= 2 && hasDifferentCoordinates) groups.push(group);
+    const hasDifferentFixedLabelCoordinate = fixedLabelCoordinate !== null && !nearlyEqual(fixedLabelCoordinate, group[0].coordinate);
+    if (!hasDifferentCoordinates && !hasDifferentFixedLabelCoordinate) return;
+    const key = groupKey(group);
+    if (selectedGroupKeys.has(key)) return;
+    selectedGroupKeys.add(key);
+    selectedGroups.push(group);
+  };
+  const primarySegments = eligibleTraces.flatMap(
+    (trace) => getComponentSideRailSegments(trace, chipMap)
+  );
+  for (const group of collectConnectedGroups(primarySegments)) {
+    addEligibleGroup(group);
+  }
+  const tiedEndpointSegments = eligibleTraces.flatMap(
+    (trace) => getComponentSideRailSegments(trace, chipMap, {
+      includeTiedEndpointAssociations: true,
+      maxMspPairDistance: inputProblem.maxMspPairDistance
+    })
+  );
+  for (const group of collectConnectedGroups(tiedEndpointSegments)) {
+    addEligibleGroup(group, { requireFixedLabel: true });
   }
-  return groups;
+  return selectedGroups;
 };
 
 // lib/solvers/TraceCleanupSolver/alignSameNetRails.ts
+var getTraceStateKey = (traces) => JSON.stringify(
+  traces.map((trace) => ({
+    mspPairId: trace.mspPairId,
+    tracePath: trace.tracePath
+  }))
+);
 var alignSameNetRails = ({
   inputProblem,
   traces,
@@ -6177,6 +6327,7 @@ var alignSameNetRails = ({
   eligibleTraceIds
 }) => {
   let outputTraces = [...traces];
+  const seenTraceStates = /* @__PURE__ */ new Set([getTraceStateKey(outputTraces)]);
   const obstacles = getObstacleRects(inputProblem);
   const alignedTraceIds = /* @__PURE__ */ new Set();
   let alignedRailGroupCount = 0;
@@ -6189,7 +6340,8 @@ var alignSameNetRails = ({
       outputTraces,
       eligibleTraceIds,
       inputProblem,
-      obstacles
+      obstacles,
+      netLabelPlacements
     );
     let applied = null;
     for (const group of groups) {
@@ -6203,9 +6355,13 @@ var alignSameNetRails = ({
       if (applied) break;
     }
     if (!applied) break;
+    const candidateStateKey = getTraceStateKey(applied.traces);
+    const repeatsSeenState = seenTraceStates.has(candidateStateKey);
+    if (!repeatsSeenState) seenTraceStates.add(candidateStateKey);
     outputTraces = applied.traces;
     alignedRailGroupCount++;
     for (const traceId of applied.changedTraceIds) alignedTraceIds.add(traceId);
+    if (repeatsSeenState) break;
   }
   return {
     traces: outputTraces,
@@ -7801,11 +7957,11 @@ var getLabelHugDistance = (tracePath, obstacleLabel) => {
     obstacleLabel.width,
     obstacleLabel.height
   );
-  let distance5 = 0;
+  let distance7 = 0;
   for (const point of tracePath) {
-    distance5 += getPointDistanceFromRect(point, bounds);
+    distance7 += getPointDistanceFromRect(point, bounds);
   }
-  return distance5;
+  return distance7;
 };
 var getPointDistanceFromRect = (point, rect) => {
   const dx = Math.max(rect.minX - point.x, 0, point.x - rect.maxX);
@@ -8082,16 +8238,16 @@ var Example28Solver = class extends BaseSolver {
     const outward = dir(label.orientation);
     if (outward.x === 0 && outward.y === 0) return null;
     for (let step = 1; step <= LABEL_MAX_OUTWARD_STEPS; step++) {
-      const distance5 = step * LABEL_OUTWARD_STEP;
+      const distance7 = step * LABEL_OUTWARD_STEP;
       const candidate = {
         ...label,
         anchorPoint: {
-          x: label.anchorPoint.x + outward.x * distance5,
-          y: label.anchorPoint.y + outward.y * distance5
+          x: label.anchorPoint.x + outward.x * distance7,
+          y: label.anchorPoint.y + outward.y * distance7
         },
         center: {
-          x: label.center.x + outward.x * distance5,
-          y: label.center.y + outward.y * distance5
+          x: label.center.x + outward.x * distance7,
+          y: label.center.y + outward.y * distance7
         }
       };
       const candidateWithClearance = {
@@ -8960,10 +9116,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   findValidTraceAnchorCandidate(label, orientation, labelIndex) {
     const direction = dir(orientation);
-    const candidatePoints = this.getTraceAnchorCandidatePoints(
-      label,
-      orientation
-    ).sort((a, b) => {
+    const { points } = this.getTraceAnchorCandidates(label, orientation);
+    const candidatePoints = points.sort((a, b) => {
       const aAlongDirection = a.x * direction.x + a.y * direction.y;
       const bAlongDirection = b.x * direction.x + b.y * direction.y;
       return bAlongDirection - aAlongDirection;
@@ -8986,19 +9140,19 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   }
   findValidOutwardTraceAnchorCandidate(label, orientation, labelIndex) {
     const direction = dir(orientation);
-    const candidatePoints = this.getTraceAnchorCandidatePoints(
-      label,
-      orientation
-    ).sort((a, b) => {
+    const preservedColumnAnchor = this.getSearchStartAnchor(label, orientation);
+    const { points, preferNearestBendOnOutwardRow } = this.getTraceAnchorCandidates(label, orientation);
+    const candidatePoints = points.sort((a, b) => {
       const aAlongDirection = a.x * direction.x + a.y * direction.y;
       const bAlongDirection = b.x * direction.x + b.y * direction.y;
-      return bAlongDirection - aAlongDirection;
+      if (!preferNearestBendOnOutwardRow) {
+        return bAlongDirection - aAlongDirection;
+      }
+      const aPerpendicularDistance = isYOrientation(orientation) ? Math.abs(a.x - preservedColumnAnchor.x) : Math.abs(a.y - preservedColumnAnchor.y);
+      const bPerpendicularDistance = isYOrientation(orientation) ? Math.abs(b.x - preservedColumnAnchor.x) : Math.abs(b.y - preservedColumnAnchor.y);
+      return bAlongDirection - aAlongDirection || aPerpendicularDistance - bPerpendicularDistance;
     });
     for (const connectorSource of candidatePoints) {
-      const preservedColumnAnchor = this.getSearchStartAnchor(
-        label,
-        orientation
-      );
       const preservedColumnCandidate = this.createCandidate(
         label,
         {
@@ -9024,10 +9178,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         orientation
       );
       if (outwardDirection.x === 0 && outwardDirection.y === 0) continue;
-      for (let distance5 = LABEL_SEARCH_STEP; distance5 <= this.maxSearchDistance + EPS12; distance5 += LABEL_SEARCH_STEP) {
+      for (let distance7 = LABEL_SEARCH_STEP; distance7 <= this.maxSearchDistance + EPS12; distance7 += LABEL_SEARCH_STEP) {
         const anchorPoint = {
-          x: connectorSource.x + outwardDirection.x * distance5,
-          y: connectorSource.y + outwardDirection.y * distance5
+          x: connectorSource.x + outwardDirection.x * distance7,
+          y: connectorSource.y + outwardDirection.y * distance7
         };
         const candidate = this.createCandidate(
           label,
@@ -9040,7 +9194,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
           label,
           labelIndex,
           "outward-trace-anchor",
-          distance5
+          distance7
         );
         this.recordCandidateResult(result);
         if (result.status === "valid") {
@@ -9051,10 +9205,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
-  getTraceAnchorCandidatePoints(label, orientation) {
+  getTraceAnchorCandidates(label, orientation) {
     const seen = /* @__PURE__ */ new Set();
     const points = [];
-    const connectedTraceIds = new Set(label.mspConnectionPairIds ?? []);
+    const directHostTraceIds = new Set(label.mspConnectionPairIds ?? []);
+    const connectedTraceIds = new Set(directHostTraceIds);
     if (isYOrientation(orientation)) {
       const connectedPinIds = /* @__PURE__ */ new Set();
       for (const traceId of connectedTraceIds) {
@@ -9094,7 +9249,39 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         points.push(point);
       }
     }
-    return points;
+    const direction = dir(orientation);
+    const furthestAlong = Math.max(
+      ...points.map((point) => point.x * direction.x + point.y * direction.y)
+    );
+    const furthestRowPoints = points.filter(
+      (point) => Math.abs(
+        point.x * direction.x + point.y * direction.y - furthestAlong
+      ) <= EPS12
+    );
+    const directHostPinIds = new Set(
+      [...directHostTraceIds].flatMap(
+        (traceId) => this.traceMap[traceId]?.pinIds ?? []
+      )
+    );
+    const adjacentTraces = [...connectedTraceIds].flatMap((traceId) => {
+      if (directHostTraceIds.has(traceId)) return [];
+      const trace = this.traceMap[traceId];
+      if (!trace?.pinIds.some((pinId) => directHostPinIds.has(pinId))) return [];
+      return [trace];
+    });
+    return {
+      points,
+      // Prefer the nearest bend when the outward row is on a trace directly
+      // adjacent to the label's host. Deeper transitive chains keep their
+      // stable trace ordering.
+      preferNearestBendOnOutwardRow: adjacentTraces.some(
+        (trace) => furthestRowPoints.some(
+          (point) => trace.tracePath.some(
+            (tracePoint) => Math.abs(tracePoint.x - point.x) <= EPS12 && Math.abs(tracePoint.y - point.y) <= EPS12
+          )
+        )
+      )
+    };
   }
   sharesVerticalRailWithAny(trace, otherTraces) {
     const verticalRailXs = /* @__PURE__ */ new Set();
@@ -9203,10 +9390,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       phase = "shift",
       stopOnTraceCollision = true
     } = params;
-    for (let distance5 = LABEL_SEARCH_STEP; distance5 <= maxSearchDistance + EPS12; distance5 += LABEL_SEARCH_STEP) {
+    for (let distance7 = LABEL_SEARCH_STEP; distance7 <= maxSearchDistance + EPS12; distance7 += LABEL_SEARCH_STEP) {
       const anchorPoint = {
-        x: baseAnchor.x + direction.x * distance5,
-        y: baseAnchor.y + direction.y * distance5
+        x: baseAnchor.x + direction.x * distance7,
+        y: baseAnchor.y + direction.y * distance7
       };
       const candidate = this.createCandidate(label, anchorPoint, orientation);
       const result = this.evaluateCandidate(
@@ -9214,7 +9401,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         label,
         labelIndex,
         phase,
-        distance5,
+        distance7,
         outwardDistance
       );
       this.recordCandidateResult(result);
@@ -9226,11 +9413,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     }
     return null;
   }
-  evaluateCandidate(candidate, label, labelIndex, phase, distance5, outwardDistance) {
+  evaluateCandidate(candidate, label, labelIndex, phase, distance7, outwardDistance) {
     return {
       ...candidate,
       phase,
-      distance: distance5,
+      distance: distance7,
       outwardDistance,
       selected: false,
       status: this.getCandidateStatus({
@@ -9736,10 +9923,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       if (point.x < bounds.minX - EPS12 || point.x > bounds.maxX + EPS12 || point.y < bounds.minY - EPS12 || point.y > bounds.maxY + EPS12) {
         continue;
       }
-      for (const [side, distance5] of getSideDistances(point, bounds)) {
-        if (distance5 < nearestDistance) {
+      for (const [side, distance7] of getSideDistances(point, bounds)) {
+        if (distance7 < nearestDistance) {
           nearestSide = side;
-          nearestDistance = distance5;
+          nearestDistance = distance7;
         }
       }
     }
@@ -9768,10 +9955,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     let nearestSide = null;
     let nearestDistance = Number.POSITIVE_INFINITY;
     for (const chip of this.chipObstacleSpatialIndex.chips) {
-      for (const [side, distance5] of getSideDistances(point, chip.bounds)) {
-        if (distance5 < nearestDistance) {
+      for (const [side, distance7] of getSideDistances(point, chip.bounds)) {
+        if (distance7 < nearestDistance) {
           nearestSide = side;
-          nearestDistance = distance5;
+          nearestDistance = distance7;
         }
       }
     }
@@ -10354,17 +10541,17 @@ var getTraceLength = (trace) => {
   }
   return length;
 };
-var getPointAtTraceDistance = (trace, distance5) => {
+var getPointAtTraceDistance = (trace, distance7) => {
   let pathDistance = 0;
   for (let i = 0; i < trace.tracePath.length - 1; i++) {
     const start = trace.tracePath[i];
     const end = trace.tracePath[i + 1];
     const segmentLength = getManhattanDistance(start, end);
     const nextDistance = pathDistance + segmentLength;
-    if (distance5 <= nextDistance + EPS13) {
+    if (distance7 <= nextDistance + EPS13) {
       const offset = Math.max(
         0,
-        Math.min(segmentLength, distance5 - pathDistance)
+        Math.min(segmentLength, distance7 - pathDistance)
       );
       const direction = getSegmentDirection(start, end);
       return {
@@ -10489,13 +10676,13 @@ var getCandidateDistances = (traceLength, vertexDistances) => {
   const distances = /* @__PURE__ */ new Set();
   const maxSteps = Math.ceil(traceLength / CANDIDATE_STEP);
   for (let i = 0; i <= maxSteps; i++) {
-    const distance5 = Math.min(traceLength, i * CANDIDATE_STEP);
-    distances.add(roundDistance(distance5));
+    const distance7 = Math.min(traceLength, i * CANDIDATE_STEP);
+    distances.add(roundDistance(distance7));
   }
-  for (const distance5 of vertexDistances) {
-    distances.add(roundDistance(distance5));
+  for (const distance7 of vertexDistances) {
+    distances.add(roundDistance(distance7));
   }
-  return [...distances].filter((distance5) => distance5 >= -EPS13 && distance5 <= traceLength + EPS13).sort((a, b) => a - b);
+  return [...distances].filter((distance7) => distance7 >= -EPS13 && distance7 <= traceLength + EPS13).sort((a, b) => a - b);
 };
 var getOrientationsForPoint = (params) => {
   const { inputProblem, label, point, orientationConstraint } = params;
@@ -10668,7 +10855,7 @@ var getNetLabelHeight = (inputProblem, label) => {
     (nc) => nc.pinIds.some((pid) => label.pinIds.includes(pid))
   )?.netLabelHeight;
 };
-var roundDistance = (distance5) => Number(distance5.toFixed(6));
+var roundDistance = (distance7) => Number(distance7.toFixed(6));
 var isSamePlacement = (label, point, orientation) => Math.abs(point.x - label.anchorPoint.x) <= EPS13 && Math.abs(point.y - label.anchorPoint.y) <= EPS13 && orientation === label.orientation;
 
 // lib/solvers/TraceAnchoredNetLabelOverlapSolver/visualize.ts
@@ -11649,7 +11836,7 @@ ${c.status}`
 };
 
 // lib/solvers/UnroutedTraceRecoverySolver/UnroutedTraceRecoverySolver.ts
-import { distance as distance4, doSegmentsIntersect as doSegmentsIntersect3 } from "@tscircuit/math-utils";
+import { distance as distance6, doSegmentsIntersect as doSegmentsIntersect3 } from "@tscircuit/math-utils";
 var ROUTE_CLEARANCE = 0.2;
 var COORDINATE_TOLERANCE = 1e-9;
 var GROUND_NET_ID = "GND";
@@ -11811,7 +11998,7 @@ var getJunctionCandidates = ({
       facingDirection: pin._facingDirection
     });
     for (const junctionPoint of junctionPoints) {
-      if (distance4(pin, junctionPoint) > maxConnectionDistance) {
+      if (distance6(pin, junctionPoint) > maxConnectionDistance) {
         continue;
       }
       candidates.push(
@@ -12027,7 +12214,7 @@ var UnroutedTraceRecoverySolver = class extends BaseSolver {
     if (connectionPair.globalConnNetId === this.groundGlobalConnNetId) {
       return;
     }
-    if (distance4(connectionPair.pins[0], connectionPair.pins[1]) > this.maxConnectionDistance) {
+    if (distance6(connectionPair.pins[0], connectionPair.pins[1]) > this.maxConnectionDistance) {
       return;
     }
     const obstacles = getObstacleRects(this.inputProblem);
@@ -12139,6 +12326,7 @@ var pathEntersAnyNetLabel = ({
 // 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 getSharedPin = ({
   donorTrace,
   branchTrace
@@ -12178,6 +12366,28 @@ var railIsOnFacingSide = ({
   if (pin._facingDirection === "y+") return railY > pin.y;
   return false;
 };
+var railIsOnSharedPinFacingSide = ({
+  railY,
+  pin
+}) => {
+  if (pin._facingDirection === "y+") return railY > pin.y;
+  if (pin._facingDirection === "y-") return railY < pin.y;
+  return false;
+};
+var getHorizontalPinApproachPoint = ({
+  branchTrace,
+  sharedPin,
+  otherPin
+}) => {
+  if (otherPin._facingDirection !== "x-" && otherPin._facingDirection !== "x+") {
+    return null;
+  }
+  const sharedToOtherPath = branchTrace.pins[0].pinId === sharedPin.pinId ? branchTrace.tracePath : [...branchTrace.tracePath].reverse();
+  const approachPoint = sharedToOtherPath.at(-2);
+  if (!approachPoint || !nearlyEqual(approachPoint.y, otherPin.y)) return null;
+  const approachesFromFacingSide = otherPin._facingDirection === "x-" ? approachPoint.x < otherPin.x : approachPoint.x > otherPin.x;
+  return approachesFromFacingSide ? approachPoint : null;
+};
 var getAttachedLabelIndexes = (trace, netLabelPlacements) => netLabelPlacements.flatMap((label, index) => {
   const labelOwnsTrace = label.mspConnectionPairIds.includes(trace.mspPairId) || label.mspConnectionPairIds.length === 0 && label.globalConnNetId === trace.globalConnNetId;
   return labelOwnsTrace && tracePathContainsPoint(trace.tracePath, label.anchorPoint) ? [index] : [];
@@ -12226,19 +12436,45 @@ var getAlignedBranchPath = ({
   if (branchRail && nearlyEqual(branchRail.start.y, donorRail.start.y)) {
     return null;
   }
-  if (!railIsOnFacingSide({ railY: donorRail.start.y, pin: otherPin })) {
+  const railFacesOtherPin = railIsOnFacingSide({
+    railY: donorRail.start.y,
+    pin: otherPin
+  });
+  const railFacesSharedPin = railIsOnSharedPinFacingSide({
+    railY: donorRail.start.y,
+    pin: sharedPin
+  }) && Math.abs(donorRail.start.y - sharedPin.y) <= MAX_SHARED_PIN_RAIL_OFFSET;
+  if (!railFacesOtherPin && !railFacesSharedPin) {
     return null;
   }
   const junction = getJunctionPoint({ segment: donorRail, sharedPin });
   const extendsDonorRail = donorOtherPin.x < junction.x && otherPin.x > junction.x || donorOtherPin.x > junction.x && otherPin.x < junction.x;
   if (!extendsDonorRail) return null;
-  const sharedToOther = simplifyPath([
-    { x: sharedPin.x, y: sharedPin.y },
-    { x: junction.x, y: sharedPin.y },
-    { x: junction.x, y: junction.y },
-    { x: otherPin.x, y: junction.y },
-    { x: otherPin.x, y: otherPin.y }
-  ]);
+  let sharedToOther;
+  if (!railFacesOtherPin && railFacesSharedPin) {
+    const approachPoint = getHorizontalPinApproachPoint({
+      branchTrace,
+      sharedPin,
+      otherPin
+    });
+    if (!approachPoint) return null;
+    sharedToOther = simplifyPath([
+      { x: sharedPin.x, y: sharedPin.y },
+      { x: junction.x, y: sharedPin.y },
+      { x: junction.x, y: junction.y },
+      { x: approachPoint.x, y: junction.y },
+      { x: approachPoint.x, y: otherPin.y },
+      { x: otherPin.x, y: otherPin.y }
+    ]);
+  } else {
+    sharedToOther = simplifyPath([
+      { x: sharedPin.x, y: sharedPin.y },
+      { x: junction.x, y: sharedPin.y },
+      { x: junction.x, y: junction.y },
+      { x: otherPin.x, y: junction.y },
+      { x: otherPin.x, y: otherPin.y }
+    ]);
+  }
   if (branchTrace.pins[0].pinId === sharedPin.pinId) return sharedToOther;
   return [...sharedToOther].reverse();
 };
@@ -12961,17 +13197,17 @@ var getRequiredOutwardDistance = (label, inlineBounds) => {
   const targetMinY = Math.max(...nearby.map((bounds) => bounds.maxY));
   return Math.max(0, targetMinY - labelBounds.minY + LABEL_CLEARANCE2);
 };
-var moveLabel = (label, orientation, distance5) => {
+var moveLabel = (label, orientation, distance7) => {
   const direction = dir(orientation);
   return {
     ...label,
     anchorPoint: {
-      x: label.anchorPoint.x + direction.x * distance5,
-      y: label.anchorPoint.y + direction.y * distance5
+      x: label.anchorPoint.x + direction.x * distance7,
+      y: label.anchorPoint.y + direction.y * distance7
     },
     center: {
-      x: label.center.x + direction.x * distance5,
-      y: label.center.y + direction.y * distance5
+      x: label.center.x + direction.x * distance7,
+      y: label.center.y + direction.y * distance7
     }
   };
 };
@@ -13096,15 +13332,15 @@ var pushAnchoredNetLabelsAwayFromInlineLabels = ({
   const movedLabelIndices = /* @__PURE__ */ new Set();
   for (let triggerIndex = 0; triggerIndex < outputLabels.length; triggerIndex++) {
     const trigger = outputLabels[triggerIndex];
-    const distance5 = getRequiredOutwardDistance(trigger, inlineBounds);
-    if (distance5 <= POINT_EPSILON || distance5 > MAX_OUTWARD_DISTANCE) continue;
+    const distance7 = getRequiredOutwardDistance(trigger, inlineBounds);
+    if (distance7 <= POINT_EPSILON || distance7 > MAX_OUTWARD_DISTANCE) continue;
     const { group, ownerChipIds } = getContiguousLabelGroup({
       triggerIndex,
       labels: outputLabels,
       chipIdByPinId
     });
     const distances = new Map(
-      [...group].map((labelIndex) => [labelIndex, distance5])
+      [...group].map((labelIndex) => [labelIndex, distance7])
     );
     let failed = false;
     for (let iteration = 0; iteration < outputLabels.length; iteration++) {