@tscircuit/schematic-trace-solver 0.0.175 → 0.0.176

package/dist/index.js

@@ -8866,6 +8866,8 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   inputProblem;
   traces;
   netLabelPlacements;
+  /** Exact provenance for connector traces created by this solver. */
+  netLabelConnectorTraceIds = /* @__PURE__ */ new Set();
   outputNetLabelPlacements;
   queuedLabelIndices = [];
   currentLabelIndex = null;
@@ -9116,6 +9118,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     };
     this.traces.push(connectorTrace);
     this.traceMap[mspPairId] = connectorTrace;
+    this.netLabelConnectorTraceIds.add(mspPairId);
   }
   finish() {
     this.currentLabelIndex = null;
@@ -9438,7 +9441,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         foundConnectedTrace = false;
         for (const trace of Object.values(this.traceMap)) {
           if (connectedTraceIds.has(trace.mspPairId)) continue;
-          if (trace.mspPairId.startsWith("available-net-orientation-")) continue;
+          if (this.netLabelConnectorTraceIds.has(trace.mspPairId)) continue;
           if (trace.globalConnNetId !== label.globalConnNetId) continue;
           if (!trace.pinIds.some((pinId) => connectedPinIds.has(pinId)))
             continue;
@@ -12673,11 +12676,99 @@ var pathEntersAnyNetLabel = ({
   return false;
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/findNearestSharedPinExitRail.ts
+var getPinFacingAxis = (pin) => {
+  if (!pin._facingDirection) return null;
+  return dir(pin._facingDirection).x === 0 ? "y" : "x";
+};
+var isCoordinateOnPinFacingSide = ({
+  coordinate,
+  axis,
+  pin
+}) => {
+  if (!pin._facingDirection) return false;
+  const facingVector = dir(pin._facingDirection);
+  return (coordinate - pin[axis]) * facingVector[axis] > 0;
+};
+var getSegmentAxis2 = (start, end) => {
+  if (isHorizontal2(start, end)) return "x";
+  if (isVertical2(start, end)) return "y";
+  return null;
+};
+var getAxisAlignedSegments = (path) => {
+  const segments = [];
+  for (let index = 0; index < path.length - 1; index++) {
+    const start = path[index];
+    const end = path[index + 1];
+    const axis = getSegmentAxis2(start, end);
+    if (!axis) continue;
+    const coordinateAxis = axis === "x" ? "y" : "x";
+    segments.push({ start, end, axis, coordinate: start[coordinateAxis] });
+  }
+  return segments;
+};
+var getPinExitPoint = ({
+  pin,
+  departureAxis,
+  railCoordinate
+}) => departureAxis === "x" ? { x: railCoordinate, y: pin.y } : { x: pin.x, y: railCoordinate };
+var findNearestSharedPinExitRail = ({
+  donorPath,
+  branchDepartureSegment,
+  sharedPin,
+  adjacentPin
+}) => {
+  const departureAxis = getPinFacingAxis(sharedPin);
+  if (!departureAxis) return null;
+  const railAxis = departureAxis === "x" ? "y" : "x";
+  const branchDeparture = getAxisAlignedSegments(branchDepartureSegment)[0];
+  if (!branchDeparture || branchDeparture.axis !== departureAxis) return null;
+  let nearestRail = null;
+  let nearestDistance = Number.POSITIVE_INFINITY;
+  for (const segment of getAxisAlignedSegments(donorPath)) {
+    if (segment.axis !== railAxis) continue;
+    if (!isCoordinateOnPinFacingSide({
+      coordinate: segment.coordinate,
+      axis: departureAxis,
+      pin: sharedPin
+    })) {
+      continue;
+    }
+    const sharedPinExit = getPinExitPoint({
+      pin: sharedPin,
+      departureAxis,
+      railCoordinate: segment.coordinate
+    });
+    const adjacentPinExit = getPinExitPoint({
+      pin: adjacentPin,
+      departureAxis,
+      railCoordinate: segment.coordinate
+    });
+    if (!tracePathContainsPoint([segment.start, segment.end], sharedPinExit) || !tracePathContainsPoint([segment.start, segment.end], adjacentPinExit) || !tracePathContainsPoint(
+      [branchDeparture.start, branchDeparture.end],
+      sharedPinExit
+    )) {
+      continue;
+    }
+    const distance7 = Math.abs(segment.coordinate - sharedPin[departureAxis]);
+    if (distance7 >= nearestDistance) continue;
+    nearestRail = { segment, sharedPinExit };
+    nearestDistance = distance7;
+  }
+  return nearestRail;
+};
+
 // 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) => {
+  if (isHorizontal2(start, end)) return "x";
+  if (isVertical2(start, end)) return "y";
+  return null;
+};
 var getSharedPin = ({
   donorTrace,
   branchTrace
@@ -12830,11 +12921,366 @@ var getAlignedBranchPath = ({
   if (branchTrace.pins[0].pinId === sharedPin.pinId) return sharedToOther;
   return [...sharedToOther].reverse();
 };
+var getAlignedParallelPinExitPath = ({
+  donorTrace,
+  branchTrace
+}) => {
+  const sharedPin = getSharedPin({ donorTrace, branchTrace });
+  if (!sharedPin) return null;
+  const adjacentPin = getOtherPin({ trace: donorTrace, sharedPin });
+  const targetPin = getOtherPin({ trace: branchTrace, sharedPin });
+  if (!adjacentPin || !targetPin) return null;
+  const facing = sharedPin._facingDirection;
+  const departureAxis = getPinFacingAxis(sharedPin);
+  if (!facing || !departureAxis) return null;
+  const stemAxis = departureAxis === "x" ? "y" : "x";
+  if (adjacentPin.chipId !== sharedPin.chipId || adjacentPin._facingDirection !== facing || !nearlyEqual(adjacentPin[departureAxis], sharedPin[departureAxis]) || getPinFacingAxis(targetPin) !== stemAxis) {
+    return null;
+  }
+  const adjacentPinOffset = Math.abs(
+    adjacentPin[stemAxis] - sharedPin[stemAxis]
+  );
+  if (adjacentPinOffset > MAX_ALIGNED_LOAD_PIN_OFFSET && !nearlyEqual(adjacentPinOffset, MAX_ALIGNED_LOAD_PIN_OFFSET)) {
+    return null;
+  }
+  const branchStartsAtSharedPin = branchTrace.pins[0].pinId === sharedPin.pinId;
+  let sharedToTargetPath = simplifyPath(branchTrace.tracePath);
+  if (!branchStartsAtSharedPin) sharedToTargetPath.reverse();
+  if (sharedToTargetPath.length < 2) return null;
+  const branchDepartureSegment = [
+    sharedToTargetPath[0],
+    sharedToTargetPath[1]
+  ];
+  const sharedExitRail = findNearestSharedPinExitRail({
+    donorPath: donorTrace.tracePath,
+    branchDepartureSegment,
+    sharedPin,
+    adjacentPin
+  });
+  if (!sharedExitRail) return null;
+  const alignedRailCoordinate = adjacentPin[stemAxis];
+  if (!isCoordinateOnPinFacingSide({
+    coordinate: alignedRailCoordinate,
+    axis: stemAxis,
+    pin: targetPin
+  })) {
+    return null;
+  }
+  const alignedStemExit = {
+    ...sharedExitRail.sharedPinExit,
+    [stemAxis]: alignedRailCoordinate
+  };
+  const targetApproach = {
+    x: targetPin.x,
+    y: targetPin.y,
+    [stemAxis]: alignedRailCoordinate
+  };
+  const candidate = simplifyPath([
+    { x: sharedPin.x, y: sharedPin.y },
+    sharedExitRail.sharedPinExit,
+    alignedStemExit,
+    targetApproach,
+    { x: targetPin.x, y: targetPin.y }
+  ]);
+  return branchStartsAtSharedPin ? candidate : candidate.reverse();
+};
+var getAlignedSharedEndpointRailPath = ({
+  donorTrace,
+  branchTrace,
+  netLabelConnectorTraceIds
+}) => {
+  if (netLabelConnectorTraceIds.has(donorTrace.mspPairId) || netLabelConnectorTraceIds.has(branchTrace.mspPairId)) {
+    return null;
+  }
+  const sharedPin = getSharedPin({ donorTrace, branchTrace });
+  if (!sharedPin) return null;
+  const pathFromShared = (trace) => {
+    const path = simplifyPath(trace.tracePath);
+    return trace.pins[0].pinId === sharedPin.pinId ? path : [...path].reverse();
+  };
+  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]);
+  if (!donorDepartureAxis || donorDepartureAxis !== branchDepartureAxis) {
+    return null;
+  }
+  const donorDeparture = donorPath[1][donorDepartureAxis] - donorPath[0][donorDepartureAxis];
+  const branchDeparture = branchPath[1][branchDepartureAxis] - branchPath[0][branchDepartureAxis];
+  if (Math.sign(donorDeparture) !== Math.sign(branchDeparture)) return null;
+  const donorRailAxis = getSegmentAxis3(donorPath[1], donorPath[2]);
+  const branchRailAxis = getSegmentAxis3(branchPath[1], branchPath[2]);
+  if (!donorRailAxis || donorRailAxis !== branchRailAxis || donorRailAxis === donorDepartureAxis) {
+    return null;
+  }
+  let branchParallelRailCount = 0;
+  for (let index = 1; index < branchPath.length - 2; index++) {
+    if (getSegmentAxis3(branchPath[index], branchPath[index + 1]) === branchRailAxis) {
+      branchParallelRailCount++;
+    }
+  }
+  if (branchParallelRailCount !== 1) return null;
+  const railCoordinateAxis = donorRailAxis === "x" ? "y" : "x";
+  const donorCoordinate = donorPath[1][railCoordinateAxis];
+  const branchCoordinate = branchPath[1][railCoordinateAxis];
+  const railOffset = Math.abs(donorCoordinate - branchCoordinate);
+  if (nearlyEqual(donorCoordinate, branchCoordinate) || railOffset > MAX_SHARED_ENDPOINT_RAIL_OFFSET) {
+    return null;
+  }
+  const donorRange = [
+    donorPath[1][donorRailAxis],
+    donorPath[2][donorRailAxis]
+  ].sort((a, b) => a - b);
+  const branchRange = [
+    branchPath[1][branchRailAxis],
+    branchPath[2][branchRailAxis]
+  ].sort((a, b) => a - b);
+  const railsTouchAfterAlignment = Math.min(donorRange[1], branchRange[1]) >= Math.max(donorRange[0], branchRange[0]) - 1e-6;
+  if (!railsTouchAfterAlignment) return null;
+  const candidateFromShared = simplifyPath(
+    branchPath.map(
+      (point, index) => index === 1 || index === 2 ? { ...point, [railCoordinateAxis]: donorCoordinate } : point
+    )
+  );
+  return branchTrace.pins[0].pinId === sharedPin.pinId ? candidateFromShared : candidateFromShared.reverse();
+};
+var getAlignedAttachedLabelConnectorPath = ({
+  donorTrace,
+  connectorTrace,
+  netLabelConnectorTraceIds
+}) => {
+  if (netLabelConnectorTraceIds.has(donorTrace.mspPairId) || !netLabelConnectorTraceIds.has(connectorTrace.mspPairId)) {
+    return null;
+  }
+  const findCandidate = (connectorPath) => {
+    if (connectorPath.length < 3) return null;
+    const junction = connectorPath[0];
+    const turn = connectorPath[1];
+    const railEnd = connectorPath[2];
+    const departureAxis = getSegmentAxis3(junction, turn);
+    const railAxis = getSegmentAxis3(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);
+      }
+    );
+    if (donorSegmentIndex < 0) return null;
+    const donorSegmentStart = donorTrace.tracePath[donorSegmentIndex];
+    const donorSegmentEnd = donorTrace.tracePath[donorSegmentIndex + 1];
+    if (nearlyEqual(junction.x, donorSegmentStart.x) && nearlyEqual(junction.y, donorSegmentStart.y) || nearlyEqual(junction.x, donorSegmentEnd.x) && nearlyEqual(junction.y, donorSegmentEnd.y)) {
+      return null;
+    }
+    const adjacentDonorRails = [
+      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] : []
+    );
+    if (adjacentDonorRails.length === 0) return null;
+    const railCoordinateAxis = railAxis === "x" ? "y" : "x";
+    const connectorRailCoordinate = turn[railCoordinateAxis];
+    const connectorRange = [turn[railAxis], railEnd[railAxis]].sort(
+      (a, b) => a - b
+    );
+    const donorRail = adjacentDonorRails.map((segment) => ({
+      segment,
+      coordinate: segment[0][railCoordinateAxis],
+      offset: Math.abs(
+        segment[0][railCoordinateAxis] - connectorRailCoordinate
+      )
+    })).filter(({ segment, offset }) => {
+      if (offset > MAX_SHARED_ENDPOINT_RAIL_OFFSET) return false;
+      const donorRange = [segment[0][railAxis], segment[1][railAxis]].sort(
+        (a, b) => a - b
+      );
+      const overlapStart = Math.max(donorRange[0], connectorRange[0]);
+      const overlapEnd = Math.min(donorRange[1], connectorRange[1]);
+      return overlapEnd >= overlapStart - 1e-6 && Math.abs(overlapEnd - overlapStart) <= 1e-6;
+    }).sort((a, b) => a.offset - b.offset)[0];
+    if (!donorRail || nearlyEqual(donorRail.offset, 0)) return null;
+    return simplifyPath(
+      connectorPath.map(
+        (point, index) => index === 1 || index === 2 ? { ...point, [railCoordinateAxis]: donorRail.coordinate } : point
+      )
+    );
+  };
+  const forwardPath = simplifyPath(connectorTrace.tracePath);
+  const forwardCandidate = findCandidate(forwardPath);
+  if (forwardCandidate) return forwardCandidate;
+  const reverseCandidate = findCandidate([...forwardPath].reverse());
+  return reverseCandidate ? reverseCandidate.reverse() : null;
+};
+var pathsIntersect = (firstPath, secondPath) => {
+  if (firstPath.some((point) => tracePathContainsPoint(secondPath, point)) || secondPath.some((point) => tracePathContainsPoint(firstPath, point))) {
+    return true;
+  }
+  for (let firstIndex = 1; firstIndex < firstPath.length; firstIndex++) {
+    for (let secondIndex = 1; secondIndex < secondPath.length; secondIndex++) {
+      if (getSegmentIntersection3(
+        firstPath[firstIndex - 1],
+        firstPath[firstIndex],
+        secondPath[secondIndex - 1],
+        secondPath[secondIndex]
+      )) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var preserveAttachedLabelConnectorJunctions = ({
+  originalTrace,
+  candidateTrace,
+  traces,
+  netLabelConnectorTraceIds
+}) => {
+  let outputTraces = traces.map(
+    (trace) => trace.mspPairId === originalTrace.mspPairId ? candidateTrace : trace
+  );
+  for (const connector of traces) {
+    if (connector.mspPairId === originalTrace.mspPairId || !netLabelConnectorTraceIds.has(connector.mspPairId) || connector.globalConnNetId !== originalTrace.globalConnNetId || !pathsIntersect(originalTrace.tracePath, connector.tracePath) || pathsIntersect(candidateTrace.tracePath, connector.tracePath)) {
+      continue;
+    }
+    const endpointIndex = [0, connector.tracePath.length - 1].find(
+      (index) => tracePathContainsPoint(
+        originalTrace.tracePath,
+        connector.tracePath[index]
+      )
+    );
+    if (endpointIndex === void 0) return null;
+    const originalJunction = connector.tracePath[endpointIndex];
+    const movedJunction = getMovedAnchorPointForReroute(
+      originalJunction,
+      originalTrace.tracePath,
+      candidateTrace.tracePath
+    );
+    if (!movedJunction) return null;
+    const neighborIndex = endpointIndex === 0 ? 1 : endpointIndex - 1;
+    const neighbor = connector.tracePath[neighborIndex];
+    if (!neighbor || getSegmentAxis3(originalJunction, neighbor) !== getSegmentAxis3(movedJunction, neighbor)) {
+      return null;
+    }
+    const movedConnector = {
+      ...connector,
+      tracePath: connector.tracePath.map(
+        (point, index) => index === endpointIndex ? movedJunction : point
+      )
+    };
+    if (!pathsIntersect(candidateTrace.tracePath, movedConnector.tracePath)) {
+      return null;
+    }
+    outputTraces = outputTraces.map(
+      (trace) => trace.mspPairId === connector.mspPairId ? movedConnector : trace
+    );
+  }
+  return outputTraces;
+};
+var getPerpendicularPinRail = ({
+  trace,
+  endpointPin
+}) => {
+  const otherPin = getOtherPin({ trace, sharedPin: endpointPin });
+  if (!otherPin) return null;
+  const startsAtEndpoint = trace.pins[0].pinId === endpointPin.pinId;
+  let endpointToOtherPath = simplifyPath(trace.tracePath);
+  if (!startsAtEndpoint) endpointToOtherPath.reverse();
+  if (endpointToOtherPath.length !== 3) return null;
+  const [endpoint, railPoint, other] = endpointToOtherPath;
+  const endpointFacing = endpointPin._facingDirection;
+  if (endpointFacing === "y+" || endpointFacing === "y-") {
+    if (otherPin._facingDirection !== "x+" && otherPin._facingDirection !== "x-") {
+      return null;
+    }
+    if (!isVertical2(endpoint, railPoint) || !isHorizontal2(railPoint, other) || !railIsOnFacingSide({ railY: railPoint.y, pin: endpointPin })) {
+      return null;
+    }
+    const approachesOtherFromFacingSide2 = otherPin._facingDirection === "x-" ? railPoint.x < otherPin.x : railPoint.x > otherPin.x;
+    return approachesOtherFromFacingSide2 ? { railCoordinate: railPoint.y } : null;
+  }
+  if (endpointFacing !== "x+" && endpointFacing !== "x-") return null;
+  if (otherPin._facingDirection !== "y+" && otherPin._facingDirection !== "y-") {
+    return null;
+  }
+  if (!isHorizontal2(endpoint, railPoint) || !isVertical2(railPoint, other)) {
+    return null;
+  }
+  const railIsOnEndpointFacingSide = endpointFacing === "x+" ? railPoint.x > endpointPin.x : railPoint.x < endpointPin.x;
+  const approachesOtherFromFacingSide = otherPin._facingDirection === "y+" ? railPoint.y > otherPin.y : railPoint.y < otherPin.y;
+  return railIsOnEndpointFacingSide && approachesOtherFromFacingSide ? { railCoordinate: railPoint.x } : null;
+};
+var getAlignedPerpendicularEndpointBusPath = ({
+  donorTrace,
+  branchTrace,
+  traces
+}) => {
+  const sharedPin = getSharedPin({ donorTrace, branchTrace });
+  if (!sharedPin) return null;
+  const returnPin = getOtherPin({ trace: branchTrace, sharedPin });
+  if (!returnPin) return null;
+  const getOtherSameNetTracesAtPin = (pin) => traces.filter(
+    (trace) => trace.mspPairId !== branchTrace.mspPairId && trace.globalConnNetId === branchTrace.globalConnNetId && trace.pinIds.includes(pin.pinId)
+  );
+  const sharedDonorTraces = getOtherSameNetTracesAtPin(sharedPin);
+  const returnDonorTraces = getOtherSameNetTracesAtPin(returnPin);
+  if (sharedDonorTraces.length !== 1 || sharedDonorTraces[0].mspPairId !== donorTrace.mspPairId || returnDonorTraces.length !== 1) {
+    return null;
+  }
+  const sharedRail = getPerpendicularPinRail({
+    trace: donorTrace,
+    endpointPin: sharedPin
+  });
+  if (!sharedRail) return null;
+  const facing = sharedPin._facingDirection;
+  const verticalEndpoints = facing === "y+" || facing === "y-";
+  const horizontalEndpoints = facing === "x+" || facing === "x-";
+  if (!verticalEndpoints && !horizontalEndpoints) return null;
+  if (verticalEndpoints !== (returnPin._facingDirection === "y+" || returnPin._facingDirection === "y-")) {
+    return null;
+  }
+  const branchStartsAtSharedPin = branchTrace.pins[0].pinId === sharedPin.pinId;
+  let sharedToReturnPath = simplifyPath(branchTrace.tracePath);
+  if (!branchStartsAtSharedPin) sharedToReturnPath.reverse();
+  if (sharedToReturnPath.length !== 6) return null;
+  const expectedSegmentOrientations = verticalEndpoints ? ["V", "H", "V", "H", "V"] : ["H", "V", "H", "V", "H"];
+  const actualSegmentOrientations = sharedToReturnPath.slice(1).map(
+    (point, index) => isHorizontal2(sharedToReturnPath[index], point) ? "H" : isVertical2(sharedToReturnPath[index], point) ? "V" : "D"
+  );
+  if (actualSegmentOrientations.some(
+    (orientation, index) => orientation !== expectedSegmentOrientations[index]
+  )) {
+    return null;
+  }
+  const returnRail = getPerpendicularPinRail({
+    trace: returnDonorTraces[0],
+    endpointPin: returnPin
+  });
+  if (!returnRail) return null;
+  const candidate = verticalEndpoints ? simplifyPath([
+    { x: sharedPin.x, y: sharedPin.y },
+    { x: sharedPin.x, y: sharedRail.railCoordinate },
+    { x: sharedToReturnPath[2].x, y: sharedRail.railCoordinate },
+    { x: sharedToReturnPath[3].x, y: returnRail.railCoordinate },
+    { x: returnPin.x, y: returnRail.railCoordinate },
+    { x: returnPin.x, y: returnPin.y }
+  ]) : simplifyPath([
+    { x: sharedPin.x, y: sharedPin.y },
+    { x: sharedRail.railCoordinate, y: sharedPin.y },
+    { x: sharedRail.railCoordinate, y: sharedToReturnPath[2].y },
+    { x: returnRail.railCoordinate, y: sharedToReturnPath[3].y },
+    { x: returnRail.railCoordinate, y: returnPin.y },
+    { x: returnPin.x, y: returnPin.y }
+  ]);
+  return branchStartsAtSharedPin ? candidate : candidate.reverse();
+};
 var candidateIsClear = ({
   candidateTrace,
   originalTrace,
   traces,
   inputProblem,
+  originalNetLabelPlacements,
   candidateNetLabelPlacements,
   attachedLabelIndexes
 }) => {
@@ -12877,6 +13323,53 @@ var candidateIsClear = ({
   )) {
     return false;
   }
+  const labelHitsTrace = (label, trace) => pathIntersectsAnyNetLabel({
+    path: trace.tracePath,
+    netLabelPlacements: [label]
+  });
+  for (const labelIndex of attachedLabelIndexes) {
+    const originalLabel = originalNetLabelPlacements[labelIndex];
+    const candidateLabel = candidateNetLabelPlacements[labelIndex];
+    const originalBounds = getRectBounds(
+      originalLabel.center,
+      originalLabel.width,
+      originalLabel.height
+    );
+    const candidateBounds = getRectBounds(
+      candidateLabel.center,
+      candidateLabel.width,
+      candidateLabel.height
+    );
+    for (const trace of traces) {
+      if (trace.globalConnNetId === candidateLabel.globalConnNetId) continue;
+      if (labelHitsTrace(candidateLabel, trace) && !labelHitsTrace(originalLabel, trace)) {
+        return false;
+      }
+    }
+    for (const obstacle of obstacles) {
+      if (rectsOverlap(candidateBounds, obstacle) && !rectsOverlap(originalBounds, obstacle)) {
+        return false;
+      }
+    }
+    for (let otherIndex = 0; otherIndex < candidateNetLabelPlacements.length; otherIndex++) {
+      if (otherIndex === labelIndex) continue;
+      const originalOther = originalNetLabelPlacements[otherIndex];
+      const candidateOther = candidateNetLabelPlacements[otherIndex];
+      const originalOtherBounds = getRectBounds(
+        originalOther.center,
+        originalOther.width,
+        originalOther.height
+      );
+      const candidateOtherBounds = getRectBounds(
+        candidateOther.center,
+        candidateOther.width,
+        candidateOther.height
+      );
+      if (rectsOverlap(candidateBounds, candidateOtherBounds) && !rectsOverlap(originalBounds, originalOtherBounds)) {
+        return false;
+      }
+    }
+  }
   const otherNetLabelPlacements = candidateNetLabelPlacements.filter(
     (label) => label.globalConnNetId !== candidateTrace.globalConnNetId
   );
@@ -12960,13 +13453,14 @@ var getAlignedReturnBranchPath = ({
 var alignSameNetJunctions = ({
   inputProblem,
   traces,
-  netLabelPlacements
+  netLabelPlacements,
+  netLabelConnectorTraceIds
 }) => {
   let outputTraces = [...traces];
   let outputNetLabelPlacements = [...netLabelPlacements];
   let alignedJunctionCount = 0;
+  const alignedBranchTraceIds = /* @__PURE__ */ new Set();
   for (const alignReturnBranches of [false, true]) {
-    const alignedBranchTraceIds = /* @__PURE__ */ new Set();
     const donorTraceIds = traces.map((trace) => trace.mspPairId);
     const pendingDonorTraceIds = new Set(donorTraceIds);
     for (let donorIndex = 0; donorIndex < donorTraceIds.length; donorIndex++) {
@@ -12979,13 +13473,40 @@ var alignSameNetJunctions = ({
         if (alignedBranchTraceIds.has(branchTrace.mspPairId)) continue;
         if (donorTrace.mspPairId === branchTrace.mspPairId) continue;
         if (donorTrace.globalConnNetId !== branchTrace.globalConnNetId) continue;
-        const candidatePaths = alignReturnBranches ? [1, 0.5, 0.25].map(
-          (returnStemScale) => getAlignedReturnBranchPath({
+        const donorIsLabelConnector = netLabelConnectorTraceIds.has(
+          donorTrace.mspPairId
+        );
+        const branchIsLabelConnector = netLabelConnectorTraceIds.has(
+          branchTrace.mspPairId
+        );
+        const candidatePaths = branchIsLabelConnector ? alignReturnBranches && !donorIsLabelConnector ? [
+          getAlignedAttachedLabelConnectorPath({
+            donorTrace,
+            connectorTrace: branchTrace,
+            netLabelConnectorTraceIds
+          })
+        ] : [] : donorIsLabelConnector ? [] : alignReturnBranches ? [
+          ...[1, 0.5, 0.25].map(
+            (returnStemScale) => getAlignedReturnBranchPath({
+              donorTrace,
+              branchTrace,
+              returnStemScale
+            })
+          ),
+          getAlignedPerpendicularEndpointBusPath({
+            donorTrace,
+            branchTrace,
+            traces: outputTraces
+          }),
+          getAlignedSharedEndpointRailPath({
             donorTrace,
             branchTrace,
-            returnStemScale
+            netLabelConnectorTraceIds
           })
-        ) : [getAlignedBranchPath({ donorTrace, branchTrace })];
+        ] : [
+          getAlignedBranchPath({ donorTrace, branchTrace }),
+          getAlignedParallelPinExitPath({ donorTrace, branchTrace })
+        ];
         for (const candidatePath of candidatePaths) {
           if (!candidatePath) continue;
           const candidateTrace = { ...branchTrace, tracePath: candidatePath };
@@ -13009,20 +13530,47 @@ var alignSameNetJunctions = ({
             netLabelPlacements: outputNetLabelPlacements,
             attachedLabelIndexes
           });
+          const candidateTraces = preserveAttachedLabelConnectorJunctions({
+            originalTrace: branchTrace,
+            candidateTrace,
+            traces: outputTraces,
+            netLabelConnectorTraceIds
+          });
+          if (!candidateTraces) continue;
           if (!candidateIsClear({
             candidateTrace,
             originalTrace: branchTrace,
-            traces: outputTraces,
+            traces: candidateTraces,
             inputProblem,
+            originalNetLabelPlacements: outputNetLabelPlacements,
             candidateNetLabelPlacements,
             attachedLabelIndexes
           })) {
             continue;
           }
-          outputTraces = outputTraces.map((trace) => {
-            if (trace.mspPairId === branchTrace.mspPairId) return candidateTrace;
-            return trace;
+          const movedConnectorsAreClear = candidateTraces.every((trace) => {
+            if (trace.mspPairId === branchTrace.mspPairId || !netLabelConnectorTraceIds.has(trace.mspPairId)) {
+              return true;
+            }
+            const originalConnector = outputTraces.find(
+              (originalTrace) => originalTrace.mspPairId === trace.mspPairId
+            );
+            if (originalConnector.tracePath === trace.tracePath) return true;
+            return candidateIsClear({
+              candidateTrace: trace,
+              originalTrace: originalConnector,
+              traces: candidateTraces,
+              inputProblem,
+              originalNetLabelPlacements: outputNetLabelPlacements,
+              candidateNetLabelPlacements,
+              attachedLabelIndexes: getAttachedLabelIndexes(
+                originalConnector,
+                outputNetLabelPlacements
+              )
+            });
           });
+          if (!movedConnectorsAreClear) continue;
+          outputTraces = candidateTraces;
           outputNetLabelPlacements = candidateNetLabelPlacements;
           alignedBranchTraceIds.add(branchTrace.mspPairId);
           alignedJunctionCount++;
@@ -13834,7 +14382,7 @@ var alignPortOnlyInlineNetLabelStubs = ({
 };
 
 // lib/solvers/InlineNetLabelSolver/getAxisAlignedSegments.ts
-var getAxisAlignedSegments = (path, epsilon = 1e-6) => {
+var getAxisAlignedSegments2 = (path, epsilon = 1e-6) => {
   const segments = [];
   let runStart = null;
   let runAxis = null;
@@ -14972,7 +15520,7 @@ var InlineNetLabelSolver = class extends BaseSolver {
     pinIds,
     ignoredTraceIds = /* @__PURE__ */ new Set()
   }) {
-    const segments = getAxisAlignedSegments(trace.tracePath);
+    const segments = getAxisAlignedSegments2(trace.tracePath);
     if (segments.length === 0) return null;
     const height = connection.inlineNetLabelHeight ?? DEFAULT_INLINE_NET_LABEL_HEIGHT;
     const netLabelText = connection.netLabelText?.trim() || void 0;
@@ -16289,9 +16837,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           inputTracePaths: instance.availableNetOrientationSolver.traces,
           globalConnMap: instance.mspConnectionPairSolver.globalConnMap,
           traceIdsToShift: new Set(
-            instance.availableNetOrientationSolver.traces.filter(
-              (trace) => trace.mspPairId.startsWith("available-net-orientation-")
-            ).map((trace) => trace.mspPairId)
+            instance.availableNetOrientationSolver.netLabelConnectorTraceIds
           )
         }
       ]
@@ -16450,7 +16996,8 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           {
             inputProblem: instance.inputProblem,
             traces: instance.netLabelNetLabelCollisionSolver.traces,
-            netLabelPlacements: collisionOutput.netLabelPlacements
+            netLabelPlacements: collisionOutput.netLabelPlacements,
+            netLabelConnectorTraceIds: instance.availableNetOrientationSolver.netLabelConnectorTraceIds
           }
         ];
       }