@tscircuit/schematic-trace-solver 0.0.114 → 0.0.116

package/dist/index.d.ts

@@ -146,17 +146,11 @@ type RectPadding = {
     maxY?: number;
 };
 
-type RectBounds = {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-};
-type ChipObstacleRect = RectBounds & {
+type ChipObstacleRect = Bounds & {
     kind: "chip";
     chipId: string;
 };
-type TextBoxObstacleRect = RectBounds & {
+type TextBoxObstacleRect = Bounds & {
     kind: "text_box";
     textBox: NonNullable<InputProblem["textBoxes"]>[number];
 };
@@ -1053,6 +1047,24 @@ declare class UnroutedTraceRecoverySolver extends BaseSolver {
     visualize(): graphics_debug.GraphicsObject;
 }
 
+interface SameNetJunctionAlignmentSolverInput {
+    inputProblem: InputProblem;
+    traces: SolvedTracePath[];
+    netLabelPlacements: NetLabelPlacement[];
+}
+/** Turns separate same-net load traces into one shared rail with short junction branches. */
+declare class SameNetJunctionAlignmentSolver extends BaseSolver {
+    private input;
+    outputTraces: SolvedTracePath[];
+    constructor(input: SameNetJunctionAlignmentSolverInput);
+    _step(): void;
+    getOutput(): {
+        traces: SolvedTracePath[];
+        netLabelPlacements: NetLabelPlacement[];
+    };
+    visualize(): GraphicsObject;
+}
+
 /**
  * Pipeline solver that runs a series of solvers to find the best schematic layout.
  * Coordinates the entire layout process from chip partitioning through final packing.
@@ -1087,13 +1099,14 @@ declare class SchematicTracePipelineSolver extends BaseSolver {
     netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver;
     traceCleanupSolver2?: TraceCleanupSolver;
     netLabelNetLabelCollisionSolver?: NetLabelNetLabelCollisionSolver;
+    sameNetJunctionAlignmentSolver?: SameNetJunctionAlignmentSolver;
     startTimeOfPhase: Record<string, number>;
     endTimeOfPhase: Record<string, number>;
     timeSpentOnPhase: Record<string, number>;
     firstIterationOfPhase: Record<string, number>;
     inputProblem: InputProblem;
     hideRatsNet: boolean;
-    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof UnroutedTraceRecoverySolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof RailNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver> | PipelineStep<typeof NetLabelNetLabelCollisionSolver>)[];
+    pipelineDef: (PipelineStep<typeof MspConnectionPairSolver> | PipelineStep<typeof SchematicTraceLinesSolver> | PipelineStep<typeof LongDistancePairSolver> | PipelineStep<typeof UnroutedTraceRecoverySolver> | PipelineStep<typeof TraceOverlapShiftSolver> | PipelineStep<typeof NetLabelPlacementSolver> | PipelineStep<typeof TraceLabelOverlapAvoidanceSolver> | PipelineStep<typeof TraceCleanupSolver> | PipelineStep<typeof Example28Solver> | PipelineStep<typeof AvailableNetOrientationSolver> | PipelineStep<typeof RailNetLabelCornerPlacementSolver> | PipelineStep<typeof TraceAnchoredNetLabelOverlapSolver> | PipelineStep<typeof NetLabelTraceCollisionSolver> | PipelineStep<typeof NetLabelNetLabelCollisionSolver> | PipelineStep<typeof SameNetJunctionAlignmentSolver>)[];
     constructor(inputProblem: InputProblem, opts?: Options);
     getConstructorParams(): ConstructorParameters<typeof SchematicTracePipelineSolver>;
     currentPipelineStepIndex: number;

package/dist/index.js

@@ -1116,6 +1116,9 @@ var generateInternalSegmentCollisionDetours = ({
   ]).filter(hasOnlyNonzeroOrthogonalSegments);
 };
 
+// lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts
+import { boundsDistance } from "@tscircuit/math-utils";
+
 // lib/solvers/GuidelinesSolver/getInputChipBounds.ts
 function getInputChipBounds(chip) {
   const halfWidth = chip.width / 2;
@@ -1129,6 +1132,7 @@ function getInputChipBounds(chip) {
 }
 
 // lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect.ts
+var MIN_ROUTABLE_OBSTACLE_GAP = 0.05;
 var isTextBoxObstacle = (obstacle) => obstacle.kind === "text_box";
 var chipToRect = (chip) => {
   const b = getInputChipBounds(chip);
@@ -1137,7 +1141,17 @@ var chipToRect = (chip) => {
 var getObstacleRects = (problem, opts = {}) => {
   const chipRects = problem.chips.map(chipToRect);
   const textBoxRects = (problem.textBoxes ?? []).map((textBox) => {
-    const b = getTextBoxBounds(textBox, opts.textBoxPadding);
+    const textBounds = getTextBoxBounds(textBox, opts.textBoxPadding);
+    const attachedChipBounds = chipRects.find(
+      (chip) => chip.chipId === textBox.chipId
+    );
+    const gap = attachedChipBounds ? boundsDistance(textBounds, attachedChipBounds) : Number.POSITIVE_INFINITY;
+    const b = attachedChipBounds && gap > 0 && gap < MIN_ROUTABLE_OBSTACLE_GAP ? {
+      minX: Math.min(textBounds.minX, attachedChipBounds.maxX),
+      maxX: Math.max(textBounds.maxX, attachedChipBounds.minX),
+      minY: Math.min(textBounds.minY, attachedChipBounds.maxY),
+      maxY: Math.max(textBounds.maxY, attachedChipBounds.minY)
+    } : textBounds;
     return {
       kind: "text_box",
       textBox,
@@ -1207,9 +1221,9 @@ var SchematicTraceSingleLineSolver2 = class extends BaseSolver {
     this.textObstacles = new Set(this.obstacles.filter(isTextBoxObstacle));
     const endpointChipIds = new Set(this.pins.map((pin) => pin.chipId));
     this.endpointTextObstacles = new Set(
-      endpointChipIds.size > 1 ? this.obstacles.filter(isTextBoxObstacle).filter(
+      this.obstacles.filter(isTextBoxObstacle).filter(
         (obstacle) => obstacle.textBox.chipId !== void 0 && endpointChipIds.has(obstacle.textBox.chipId)
-      ) : []
+      )
     );
     const [pin1, pin2] = this.pins;
     const directShortPath = calculateDirectShortPath(pin1, pin2);
@@ -10703,6 +10717,222 @@ var UnroutedTraceRecoverySolver = class extends BaseSolver {
   }
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/pathIntersectsAnyNetLabel.ts
+var pathIntersectsAnyNetLabel = ({
+  path,
+  netLabelPlacements
+}) => {
+  for (const label of netLabelPlacements) {
+    const labelBounds = getRectBounds(label.center, label.width, label.height);
+    for (let index = 0; index < path.length - 1; index++) {
+      if (segmentIntersectsRect2(path[index], path[index + 1], labelBounds)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+// lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts
+var MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2;
+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
+}) => trace.pins.find((pin) => pin.pinId !== sharedPin.pinId) ?? null;
+var getLongestHorizontalSegment = (trace) => {
+  let longest = null;
+  for (let index = 0; index < trace.tracePath.length - 1; index++) {
+    const start = trace.tracePath[index];
+    const end = trace.tracePath[index + 1];
+    if (!isHorizontal2(start, end)) continue;
+    if (!longest || Math.abs(end.x - start.x) > Math.abs(longest.end.x - longest.start.x)) {
+      longest = { start, end };
+    }
+  }
+  return longest;
+};
+var getJunctionPoint = ({
+  segment,
+  sharedPin
+}) => {
+  const startDistance = Math.abs(segment.start.x - sharedPin.x);
+  const endDistance = Math.abs(segment.end.x - sharedPin.x);
+  if (startDistance <= endDistance) return segment.start;
+  return segment.end;
+};
+var railIsOnFacingSide = ({
+  railY,
+  pin
+}) => {
+  if (pin._facingDirection === "y+") return railY > pin.y;
+  return false;
+};
+var getAlignedBranchPath = ({
+  donorTrace,
+  branchTrace
+}) => {
+  const sharedPin = getSharedPin({ donorTrace, branchTrace });
+  if (!sharedPin) return null;
+  const donorOtherPin = getOtherPin({ trace: donorTrace, sharedPin });
+  if (!donorOtherPin) return null;
+  const otherPin = getOtherPin({ trace: branchTrace, sharedPin });
+  if (!otherPin) return null;
+  if (Math.abs(sharedPin.y - otherPin.y) > MAX_ALIGNED_LOAD_PIN_OFFSET) {
+    return null;
+  }
+  const donorRail = getLongestHorizontalSegment(donorTrace);
+  if (!donorRail) return null;
+  const branchRail = getLongestHorizontalSegment(branchTrace);
+  if (branchRail && nearlyEqual(branchRail.start.y, donorRail.start.y)) {
+    return null;
+  }
+  if (!railIsOnFacingSide({ railY: donorRail.start.y, pin: otherPin })) {
+    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 }
+  ]);
+  if (branchTrace.pins[0].pinId === sharedPin.pinId) return sharedToOther;
+  return [...sharedToOther].reverse();
+};
+var candidateIsClear = ({
+  candidateTrace,
+  traces,
+  inputProblem,
+  netLabelPlacements
+}) => {
+  const obstacles = getObstacleRects(inputProblem);
+  if (isPathCollidingWithObstacles(candidateTrace.tracePath, obstacles)) {
+    return false;
+  }
+  const otherNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId !== candidateTrace.globalConnNetId
+  );
+  if (doesPathCoincideWithTraces(candidateTrace.tracePath, otherNetTraces)) {
+    return false;
+  }
+  return !pathIntersectsAnyNetLabel({
+    path: candidateTrace.tracePath,
+    netLabelPlacements
+  });
+};
+var alignSameNetJunctions = ({
+  inputProblem,
+  traces,
+  netLabelPlacements
+}) => {
+  let outputTraces = [...traces];
+  const alignedBranchTraceIds = /* @__PURE__ */ new Set();
+  let alignedJunctionCount = 0;
+  for (const donorTraceId of traces.map((trace) => trace.mspPairId)) {
+    const donorTrace = outputTraces.find(
+      (trace) => trace.mspPairId === donorTraceId
+    );
+    for (const branchTrace of outputTraces) {
+      if (alignedBranchTraceIds.has(branchTrace.mspPairId)) continue;
+      if (donorTrace.mspPairId === branchTrace.mspPairId) continue;
+      if (donorTrace.globalConnNetId !== branchTrace.globalConnNetId) continue;
+      const candidatePath = getAlignedBranchPath({ donorTrace, branchTrace });
+      if (!candidatePath) continue;
+      const candidateTrace = { ...branchTrace, tracePath: candidatePath };
+      const originalPair = [donorTrace, branchTrace];
+      const candidatePair = [donorTrace, candidateTrace];
+      const removesVisibleSegment = getVisibleTraceSegmentCount(candidatePair) < getVisibleTraceSegmentCount(originalPair);
+      const shortensVisibleTrace = getVisibleTraceLength(candidatePair) < getVisibleTraceLength(originalPair) && !nearlyEqual(
+        getVisibleTraceLength(candidatePair),
+        getVisibleTraceLength(originalPair)
+      );
+      if (!removesVisibleSegment && !shortensVisibleTrace) {
+        continue;
+      }
+      if (!candidateIsClear({
+        candidateTrace,
+        traces: outputTraces,
+        inputProblem,
+        netLabelPlacements
+      })) {
+        continue;
+      }
+      outputTraces = outputTraces.map((trace) => {
+        if (trace.mspPairId === branchTrace.mspPairId) return candidateTrace;
+        return trace;
+      });
+      alignedBranchTraceIds.add(branchTrace.mspPairId);
+      alignedJunctionCount++;
+    }
+  }
+  return { traces: outputTraces, alignedJunctionCount };
+};
+
+// lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts
+var SameNetJunctionAlignmentSolver = class extends BaseSolver {
+  input;
+  outputTraces;
+  constructor(input) {
+    super();
+    this.input = input;
+    this.outputTraces = input.traces;
+  }
+  _step() {
+    const result = alignSameNetJunctions(this.input);
+    this.outputTraces = result.traces;
+    this.stats.alignedJunctionCount = result.alignedJunctionCount;
+    this.solved = true;
+  }
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.input.netLabelPlacements
+    };
+  }
+  visualize() {
+    const graphics = visualizeInputProblem(this.input.inputProblem);
+    graphics.lines ??= [];
+    graphics.rects ??= [];
+    graphics.points ??= [];
+    for (const trace of this.outputTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple"
+      });
+    }
+    for (const label of this.input.netLabelPlacements) {
+      const labelRect = {
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: getColorFromString(label.globalConnNetId, 0.35),
+        strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+        label: `netId: ${label.netId}
+globalConnNetId: ${label.globalConnNetId}`
+      };
+      graphics.rects.push(labelRect);
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: getColorFromString(label.globalConnNetId, 0.9),
+        label: `anchorPoint
+orientation: ${label.orientation}`
+      });
+    }
+    return graphics;
+  }
+};
+
 // lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts
 function definePipelineStep(solverName, solverClass, getConstructorParams, opts = {}) {
   return {
@@ -10733,6 +10963,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
   netLabelTraceCollisionSolver;
   traceCleanupSolver2;
   netLabelNetLabelCollisionSolver;
+  sameNetJunctionAlignmentSolver;
   startTimeOfPhase;
   endTimeOfPhase;
   timeSpentOnPhase;
@@ -11005,6 +11236,20 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
           netLabelPlacements: instance.netLabelTraceCollisionSolver.getOutput().netLabelPlacements
         }
       ]
+    ),
+    definePipelineStep(
+      "sameNetJunctionAlignmentSolver",
+      SameNetJunctionAlignmentSolver,
+      (instance) => {
+        const collisionOutput = instance.netLabelNetLabelCollisionSolver.getOutput();
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: instance.netLabelNetLabelCollisionSolver.traces,
+            netLabelPlacements: collisionOutput.netLabelPlacements
+          }
+        ];
+      }
     )
   ];
   constructor(inputProblem, opts) {

package/lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts

@@ -0,0 +1,71 @@
+import type { GraphicsObject, Rect } from "graphics-debug"
+import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
+import type { InputProblem } from "lib/types/InputProblem"
+import { getColorFromString } from "lib/utils/getColorFromString"
+import { alignSameNetJunctions } from "./alignSameNetJunctions"
+
+interface SameNetJunctionAlignmentSolverInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+/** Turns separate same-net load traces into one shared rail with short junction branches. */
+export class SameNetJunctionAlignmentSolver extends BaseSolver {
+  private input: SameNetJunctionAlignmentSolverInput
+  outputTraces: SolvedTracePath[]
+
+  constructor(input: SameNetJunctionAlignmentSolverInput) {
+    super()
+    this.input = input
+    this.outputTraces = input.traces
+  }
+
+  override _step() {
+    const result = alignSameNetJunctions(this.input)
+    this.outputTraces = result.traces
+    this.stats.alignedJunctionCount = result.alignedJunctionCount
+    this.solved = true
+  }
+
+  getOutput() {
+    return {
+      traces: this.outputTraces,
+      netLabelPlacements: this.input.netLabelPlacements,
+    }
+  }
+
+  override visualize(): GraphicsObject {
+    const graphics = visualizeInputProblem(this.input.inputProblem)
+    graphics.lines ??= []
+    graphics.rects ??= []
+    graphics.points ??= []
+    for (const trace of this.outputTraces) {
+      graphics.lines.push({
+        points: trace.tracePath,
+        strokeColor: "purple",
+      })
+    }
+    for (const label of this.input.netLabelPlacements) {
+      const labelRect: Rect & { strokeColor: string } = {
+        center: label.center,
+        width: label.width,
+        height: label.height,
+        fill: getColorFromString(label.globalConnNetId, 0.35),
+        strokeColor: getColorFromString(label.globalConnNetId, 0.9),
+        label: `netId: ${label.netId}\nglobalConnNetId: ${label.globalConnNetId}`,
+      }
+      graphics.rects.push(labelRect)
+      graphics.points.push({
+        x: label.anchorPoint.x,
+        y: label.anchorPoint.y,
+        color: getColorFromString(label.globalConnNetId, 0.9),
+        label: `anchorPoint\norientation: ${label.orientation}`,
+      })
+    }
+    return graphics
+  }
+}

package/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -0,0 +1,223 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { isPathCollidingWithObstacles } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/collisions"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { simplifyPath } from "lib/solvers/TraceCleanupSolver/simplifyPath"
+import {
+  getVisibleTraceLength,
+  getVisibleTraceSegmentCount,
+  isHorizontal,
+  nearlyEqual,
+} from "lib/solvers/TraceCleanupSolver/sameNetRailAlignment/geometry"
+import type { InputPin, InputProblem } from "lib/types/InputProblem"
+import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
+import { pathIntersectsAnyNetLabel } from "./pathIntersectsAnyNetLabel"
+
+interface AlignSameNetJunctionsInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+}
+
+interface HorizontalSegment {
+  start: Point
+  end: Point
+}
+
+const MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2
+
+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,
+}: {
+  trace: SolvedTracePath
+  sharedPin: InputPin
+}) => trace.pins.find((pin) => pin.pinId !== sharedPin.pinId) ?? null
+
+const getLongestHorizontalSegment = (
+  trace: SolvedTracePath,
+): HorizontalSegment | null => {
+  let longest: HorizontalSegment | null = null
+  for (let index = 0; index < trace.tracePath.length - 1; index++) {
+    const start = trace.tracePath[index]!
+    const end = trace.tracePath[index + 1]!
+    if (!isHorizontal(start, end)) continue
+    if (
+      !longest ||
+      Math.abs(end.x - start.x) > Math.abs(longest.end.x - longest.start.x)
+    ) {
+      longest = { start, end }
+    }
+  }
+  return longest
+}
+
+const getJunctionPoint = ({
+  segment,
+  sharedPin,
+}: {
+  segment: HorizontalSegment
+  sharedPin: Point
+}) => {
+  const startDistance = Math.abs(segment.start.x - sharedPin.x)
+  const endDistance = Math.abs(segment.end.x - sharedPin.x)
+  if (startDistance <= endDistance) return segment.start
+  return segment.end
+}
+
+const railIsOnFacingSide = ({
+  railY,
+  pin,
+}: {
+  railY: number
+  pin: InputPin
+}) => {
+  if (pin._facingDirection === "y+") return railY > pin.y
+  return false
+}
+
+const getAlignedBranchPath = ({
+  donorTrace,
+  branchTrace,
+}: {
+  donorTrace: SolvedTracePath
+  branchTrace: SolvedTracePath
+}): Point[] | null => {
+  const sharedPin = getSharedPin({ donorTrace, branchTrace })
+  if (!sharedPin) return null
+  const donorOtherPin = getOtherPin({ trace: donorTrace, sharedPin })
+  if (!donorOtherPin) return null
+  const otherPin = getOtherPin({ trace: branchTrace, sharedPin })
+  if (!otherPin) return null
+  if (Math.abs(sharedPin.y - otherPin.y) > MAX_ALIGNED_LOAD_PIN_OFFSET) {
+    return null
+  }
+
+  const donorRail = getLongestHorizontalSegment(donorTrace)
+  if (!donorRail) return null
+  const branchRail = getLongestHorizontalSegment(branchTrace)
+  if (branchRail && nearlyEqual(branchRail.start.y, donorRail.start.y)) {
+    return null
+  }
+  if (!railIsOnFacingSide({ railY: donorRail.start.y, pin: otherPin })) {
+    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 },
+  ])
+
+  if (branchTrace.pins[0].pinId === sharedPin.pinId) return sharedToOther
+  return [...sharedToOther].reverse()
+}
+
+const candidateIsClear = ({
+  candidateTrace,
+  traces,
+  inputProblem,
+  netLabelPlacements,
+}: {
+  candidateTrace: SolvedTracePath
+  traces: SolvedTracePath[]
+  inputProblem: InputProblem
+  netLabelPlacements: NetLabelPlacement[]
+}) => {
+  const obstacles = getObstacleRects(inputProblem)
+  if (isPathCollidingWithObstacles(candidateTrace.tracePath, obstacles)) {
+    return false
+  }
+
+  const otherNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId !== candidateTrace.globalConnNetId,
+  )
+  if (doesPathCoincideWithTraces(candidateTrace.tracePath, otherNetTraces)) {
+    return false
+  }
+
+  return !pathIntersectsAnyNetLabel({
+    path: candidateTrace.tracePath,
+    netLabelPlacements,
+  })
+}
+
+export const alignSameNetJunctions = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+}: AlignSameNetJunctionsInput) => {
+  let outputTraces = [...traces]
+  const alignedBranchTraceIds = new Set<string>()
+  let alignedJunctionCount = 0
+
+  // Reuse each aligned branch as the rail for the next load in the chain.
+  for (const donorTraceId of traces.map((trace) => trace.mspPairId)) {
+    const donorTrace = outputTraces.find(
+      (trace) => trace.mspPairId === donorTraceId,
+    )!
+    for (const branchTrace of outputTraces) {
+      if (alignedBranchTraceIds.has(branchTrace.mspPairId)) continue
+      if (donorTrace.mspPairId === branchTrace.mspPairId) continue
+      if (donorTrace.globalConnNetId !== branchTrace.globalConnNetId) continue
+
+      const candidatePath = getAlignedBranchPath({ donorTrace, branchTrace })
+      if (!candidatePath) continue
+      const candidateTrace = { ...branchTrace, tracePath: candidatePath }
+      const originalPair = [donorTrace, branchTrace]
+      const candidatePair = [donorTrace, candidateTrace]
+      const removesVisibleSegment =
+        getVisibleTraceSegmentCount(candidatePair) <
+        getVisibleTraceSegmentCount(originalPair)
+      const shortensVisibleTrace =
+        getVisibleTraceLength(candidatePair) <
+          getVisibleTraceLength(originalPair) &&
+        !nearlyEqual(
+          getVisibleTraceLength(candidatePair),
+          getVisibleTraceLength(originalPair),
+        )
+      if (!removesVisibleSegment && !shortensVisibleTrace) {
+        continue
+      }
+      if (
+        !candidateIsClear({
+          candidateTrace,
+          traces: outputTraces,
+          inputProblem,
+          netLabelPlacements,
+        })
+      ) {
+        continue
+      }
+
+      outputTraces = outputTraces.map((trace) => {
+        if (trace.mspPairId === branchTrace.mspPairId) return candidateTrace
+        return trace
+      })
+      alignedBranchTraceIds.add(branchTrace.mspPairId)
+      alignedJunctionCount++
+    }
+  }
+
+  return { traces: outputTraces, alignedJunctionCount }
+}

package/lib/solvers/SameNetJunctionAlignmentSolver/pathIntersectsAnyNetLabel.ts

@@ -0,0 +1,22 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { segmentIntersectsRect } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/collisions"
+import { getRectBounds } from "lib/solvers/NetLabelPlacementSolver/SingleNetLabelPlacementSolver/geometry"
+
+export const pathIntersectsAnyNetLabel = ({
+  path,
+  netLabelPlacements,
+}: {
+  path: Point[]
+  netLabelPlacements: NetLabelPlacement[]
+}) => {
+  for (const label of netLabelPlacements) {
+    const labelBounds = getRectBounds(label.center, label.width, label.height)
+    for (let index = 0; index < path.length - 1; index++) {
+      if (segmentIntersectsRect(path[index], path[index + 1], labelBounds)) {
+        return true
+      }
+    }
+  }
+  return false
+}