@tscircuit/schematic-trace-solver 0.0.183 → 0.0.184

package/dist/index.js

@@ -13230,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
@@ -13473,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;
   }
@@ -13482,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;
   }
@@ -13491,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]
     );
@@ -13503,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++;
     }
   }
@@ -13545,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;
@@ -13564,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";
@@ -13647,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 = {
@@ -14070,6 +14274,13 @@ var alignSameNetJunctions = ({
       }
     }
   }
+  const collapsedSharedEndpointStubs = collapseRedundantSharedEndpointStubs({
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    netLabelConnectorTraceIds,
+    multiPinNetPinIds: getMultiPinNetPinIds(inputProblem)
+  });
+  outputTraces = collapsedSharedEndpointStubs;
   return {
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,

package/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -2,6 +2,7 @@ import type { Point } from "@tscircuit/math-utils"
 import { getSegmentIntersection } from "@tscircuit/math-utils/line-intersections"
 import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
 import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import { getConnectivityMapsFromInputProblem } from "lib/solvers/MspConnectionPairSolver/getConnectivityMapFromInputProblem"
 import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
@@ -20,7 +21,7 @@ import {
   isVertical,
   nearlyEqual,
 } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
-import type { InputPin, InputProblem } from "lib/types/InputProblem"
+import type { InputPin, InputProblem, PinId } from "lib/types/InputProblem"
 import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
 import {
   pathEntersAnyNetLabel,
@@ -31,6 +32,8 @@ import {
   getPinFacingAxis,
   isCoordinateOnPinFacingSide,
 } from "./findNearestSharedPinExitRail"
+import { collapseRedundantSharedEndpointStubs } from "./collapseRedundantSharedEndpointStubs"
+import { getSharedPin } from "./getSharedPin"
 
 interface AlignSameNetJunctionsInput {
   inputProblem: InputProblem
@@ -57,23 +60,30 @@ const MAX_SHARED_PIN_RAIL_OFFSET = 0.05
 const MAX_SHARED_ENDPOINT_RAIL_OFFSET = 0.8
 const MIN_RETURN_STEM_LENGTH = 0.05
 
+const getMultiPinNetPinIds = (inputProblem: InputProblem) => {
+  const { netConnMap } = getConnectivityMapsFromInputProblem(inputProblem)
+  const inputPinIds = new Set<PinId>(
+    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
+      )
+    }),
+  )
+}
+
 const getSegmentAxis = (start: Point, end: Point) => {
   if (isHorizontal(start, end)) return "x" as const
   if (isVertical(start, end)) return "y" as const
   return null
 }
 
-export const getSharedPin = ({
-  donorTrace,
-  branchTrace,
-}: {
-  donorTrace: SolvedTracePath
-  branchTrace: SolvedTracePath
-}): (InputPin & { chipId: string }) | null => {
-  const branchPinIds = new Set(branchTrace.pins.map((pin) => pin.pinId))
-  return donorTrace.pins.find((pin) => branchPinIds.has(pin.pinId)) ?? null
-}
-
 const getOtherPin = ({
   trace,
   sharedPin,
@@ -1301,6 +1311,14 @@ export const alignSameNetJunctions = ({
     }
   }
 
+  const collapsedSharedEndpointStubs = collapseRedundantSharedEndpointStubs({
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    netLabelConnectorTraceIds,
+    multiPinNetPinIds: getMultiPinNetPinIds(inputProblem),
+  })
+  outputTraces = collapsedSharedEndpointStubs
+
   return {
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,

package/lib/solvers/SameNetJunctionAlignmentSolver/collapseRedundantSharedEndpointStubs.ts

@@ -0,0 +1,267 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { PinId } from "lib/types/InputProblem"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { MspConnectionPairId } from "lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import {
+  nearlyEqual,
+  pointsEqual,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import { tracePathContainsPoint } from "lib/solvers/RailNetLabelCornerPlacementSolver/geometry"
+import { getSharedPin } from "./getSharedPin"
+
+const getSegmentAxis = (start: Point, end: Point) => {
+  if (nearlyEqual(start.x, end.x)) return "y" as const
+  if (nearlyEqual(start.y, end.y)) return "x" as const
+  return null
+}
+
+const getPathFromSharedPin = ({
+  trace,
+  sharedPinId,
+}: {
+  trace: SolvedTracePath
+  sharedPinId: PinId
+}) => {
+  const tracePath = simplifyPath(trace.tracePath)
+  if (trace.pins[0]?.pinId === sharedPinId) return tracePath
+  return tracePath.reverse()
+}
+
+const traceCanLoseSharedPrefix = ({
+  trace,
+  sharedPrefix,
+  netLabelPlacements,
+}: {
+  trace: SolvedTracePath
+  sharedPrefix: Point[]
+  netLabelPlacements: NetLabelPlacement[]
+}) => {
+  return !netLabelPlacements.some(
+    (label) =>
+      label.mspConnectionPairIds.includes(trace.mspPairId) &&
+      tracePathContainsPoint(sharedPrefix, label.anchorPoint),
+  )
+}
+
+const getTraceWithoutSharedPrefix = ({
+  trace,
+  pathFromSharedPin,
+  sharedPinId,
+  branchPoint,
+}: {
+  trace: SolvedTracePath
+  pathFromSharedPin: Point[]
+  sharedPinId: PinId
+  branchPoint: Point
+}) => {
+  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 }
+}
+
+export const collapseRedundantSharedEndpointStubs = ({
+  traces,
+  netLabelPlacements,
+  netLabelConnectorTraceIds,
+  multiPinNetPinIds,
+}: {
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  netLabelConnectorTraceIds: ReadonlySet<MspConnectionPairId>
+  multiPinNetPinIds: ReadonlySet<PinId>
+}) => {
+  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 = getSegmentAxis(firstPath[0]!, firstPath[1]!)
+      const secondDepartureAxis = getSegmentAxis(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 (
+        !pointsEqual(firstPath[1]!, secondPath[1]!) &&
+        Math.sign(firstDepartureDirection) ===
+          Math.sign(secondDepartureDirection)
+      ) {
+        let traceIndexToCollapse = secondIndex
+        let traceToCollapse = secondTrace
+        let pathToCollapse = secondPath
+        if (
+          Math.abs(firstDepartureDirection) < Math.abs(secondDepartureDirection)
+        ) {
+          traceIndexToCollapse = firstIndex
+          traceToCollapse = firstTrace
+          pathToCollapse = firstPath
+        }
+        const branchPoint = pathToCollapse[1]!
+        if (
+          !traceCanLoseSharedPrefix({
+            trace: traceToCollapse,
+            sharedPrefix: [pathToCollapse[0]!, branchPoint],
+            netLabelPlacements,
+          })
+        ) {
+          if (traceIndexToCollapse === firstIndex) {
+            traceIndexToCollapse = secondIndex
+            traceToCollapse = secondTrace
+            pathToCollapse = secondPath
+          } else {
+            traceIndexToCollapse = firstIndex
+            traceToCollapse = firstTrace
+            pathToCollapse = firstPath
+          }
+        }
+        if (
+          !traceCanLoseSharedPrefix({
+            trace: traceToCollapse,
+            sharedPrefix: [pathToCollapse[0]!, branchPoint],
+            netLabelPlacements,
+          })
+        ) {
+          continue
+        }
+        const collapsedTrace = getTraceWithoutSharedPrefix({
+          trace: traceToCollapse,
+          pathFromSharedPin: pathToCollapse,
+          sharedPinId: sharedPin.pinId,
+          branchPoint,
+        })
+        if (!collapsedTrace) continue
+        outputTraces[traceIndexToCollapse] = collapsedTrace
+        break
+      }
+      if (firstPath.length < 3 || secondPath.length < 3) continue
+      if (!pointsEqual(firstPath[1]!, secondPath[1]!)) continue
+
+      const railAxis = getSegmentAxis(firstPath[1]!, firstPath[2]!)
+      const secondRailAxis = getSegmentAxis(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
+}

package/lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts

@@ -11,7 +11,7 @@ import {
   pointsEqual,
 } from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
 import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
-import { getSharedPin } from "./alignSameNetJunctions"
+import { getSharedPin } from "./getSharedPin"
 import {
   pathEntersAnyNetLabel,
   pathIntersectsAnyNetLabel,