@tscircuit/schematic-trace-solver 0.0.136 → 0.0.140

package/.github/workflows/bun-pver-release.yml

@@ -7,6 +7,10 @@ on:
     paths:
       - 'lib/**'
   workflow_dispatch:
+permissions:
+  contents: write
+  id-token: write
+  pull-requests: write
 jobs:
   publish:
     runs-on: ubuntu-latest
@@ -18,14 +22,14 @@ jobs:
         uses: oven-sh/setup-bun@v2
         with:
           bun-version: 1.3.1
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v6
         with:
-          node-version: 20
+          node-version: 24
           registry-url: https://registry.npmjs.org/
+          package-manager-cache: false
       - run: npm install -g pver
       - run: bun install --frozen-lockfile
       - run: bun run build
       - run: pver release
         env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
           GITHUB_TOKEN: ${{ secrets.TSCIRCUIT_BOT_GITHUB_TOKEN }}

package/dist/index.d.ts

@@ -787,6 +787,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private chipObstacleSpatialIndex;
     private maxSearchDistance;
     private pinMap;
+    private obstacleIndex;
     constructor(params: AvailableNetOrientationSolverParams);
     getConstructorParams(): ConstructorParameters<typeof AvailableNetOrientationSolver>[0];
     _step(): void;
@@ -824,6 +825,7 @@ declare class AvailableNetOrientationSolver extends BaseSolver {
     private findValidLateralShiftedCandidate;
     private findValidCandidateInShiftColumn;
     private evaluateCandidate;
+    private recordCandidateResult;
     private getCandidateConnectorTrace;
     private isStandaloneSinglePinNetLabel;
     private labelIntersectsDifferentNetTrace;
@@ -1117,6 +1119,7 @@ interface SameNetJunctionAlignmentSolverInput {
 declare class SameNetJunctionAlignmentSolver extends BaseSolver {
     private input;
     outputTraces: SolvedTracePath[];
+    outputNetLabelPlacements: NetLabelPlacement[];
     constructor(input: SameNetJunctionAlignmentSolverInput);
     _step(): void;
     getOutput(): {

package/dist/index.js

@@ -7159,6 +7159,65 @@ var moveAttachedLabelsToReroutedTrace = ({
     }
   };
 });
+var moveNetLabelConnectorsToReroutedTraces = ({
+  originalTraces,
+  reroutedTraces,
+  netLabelPlacements
+}) => {
+  const traces = [...reroutedTraces];
+  const reroutedTraceMap = new Map(
+    reroutedTraces.map((trace) => [trace.mspPairId, trace])
+  );
+  const labels = netLabelPlacements.map((label) => {
+    const originalHostTrace = originalTraces.find((trace) => {
+      if (!label.mspConnectionPairIds.includes(trace.mspPairId)) return false;
+      const reroutedTrace = reroutedTraceMap.get(trace.mspPairId);
+      if (!reroutedTrace) return false;
+      return reroutedTrace.tracePath !== trace.tracePath;
+    });
+    if (!originalHostTrace) return label;
+    const reroutedHostTrace = reroutedTraceMap.get(originalHostTrace.mspPairId);
+    const connectorIndex = originalTraces.findIndex((trace) => {
+      if (trace.mspPairId === originalHostTrace.mspPairId) return false;
+      if (trace.globalConnNetId !== label.globalConnNetId) return false;
+      if (!tracePathContainsPoint(trace.tracePath, label.anchorPoint)) {
+        return false;
+      }
+      return label.pinIds.every((pinId) => trace.pinIds.includes(pinId));
+    });
+    if (connectorIndex < 0) return label;
+    const connector = originalTraces[connectorIndex];
+    const originalJunction = connector.tracePath.find(
+      (point) => tracePathContainsPoint(originalHostTrace.tracePath, point)
+    );
+    if (!originalJunction) return label;
+    const reroutedJunction = getMovedAnchorPointForReroute(
+      originalJunction,
+      originalHostTrace.tracePath,
+      reroutedHostTrace.tracePath
+    );
+    if (!reroutedJunction) return label;
+    const delta = {
+      x: reroutedJunction.x - originalJunction.x,
+      y: reroutedJunction.y - originalJunction.y
+    };
+    const movedConnector = {
+      ...connector,
+      tracePath: connector.tracePath.map((point) => ({
+        x: point.x + delta.x,
+        y: point.y + delta.y
+      }))
+    };
+    traces[connectorIndex] = movedConnector;
+    return moveAttachedLabelsToReroutedTrace({
+      trace: connector,
+      originalTracePath: connector.tracePath,
+      reroutedTracePath: movedConnector.tracePath,
+      netLabelPlacements: [label]
+    })[0];
+  });
+  return { traces, netLabelPlacements: labels };
+};
 
 // lib/solvers/Example28Solver/doesPathRunAlongChipBoundary.ts
 var doesPathRunAlongChipBoundary = (path, chipObstacles) => {
@@ -7951,6 +8010,7 @@ var createPortOnlyLabelConnectorTrace = ({
 
 // lib/solvers/AvailableNetOrientationSolver/constants.ts
 var LABEL_SEARCH_STEP = 0.05;
+var MAX_RECORDED_CANDIDATES = 2e3;
 var WICK_CLEARANCE = 1e-3;
 var EPS12 = 1e-9;
 var TRACE_BOUNDARY_TOLERANCE = WICK_CLEARANCE + EPS12;
@@ -8007,14 +8067,6 @@ var segmentCrossesBoundsInterior = (p1, p2, bounds) => {
   }
   return false;
 };
-var tracePathCrossesAnyBounds = (tracePath, bounds) => {
-  for (let i = 0; i < tracePath.length - 1; i++) {
-    if (segmentCrossesBoundsInterior(tracePath[i], tracePath[i + 1], bounds)) {
-      return true;
-    }
-  }
-  return false;
-};
 var tracePathIntersectsBounds = (tracePath, bounds) => {
   for (let i = 0; i < tracePath.length - 1; i++) {
     if (segmentIntersectsRect2(tracePath[i], tracePath[i + 1], bounds)) {
@@ -8184,6 +8236,145 @@ var ensureGraphicsArrays = (graphics) => {
   if (!graphics.texts) graphics.texts = [];
 };
 
+// lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationObstacleIndex.ts
+import Flatbush2 from "flatbush";
+var AvailableNetOrientationObstacleIndex = class {
+  chipObstacleSpatialIndex;
+  labelIndex = null;
+  traceSegmentIndex = null;
+  traceSegments = [];
+  constructor(params) {
+    this.chipObstacleSpatialIndex = params.chipObstacleSpatialIndex;
+    this.rebuild(params);
+  }
+  rebuild(params) {
+    this.labelIndex = this.buildLabelIndex(params.netLabelPlacements);
+    this.traceSegments = this.getTraceSegments(params.traces);
+    this.traceSegmentIndex = this.buildTraceSegmentIndex(this.traceSegments);
+  }
+  getLabelIndicesInBounds(bounds) {
+    if (!this.labelIndex) return [];
+    return this.labelIndex.search(
+      bounds.minX,
+      bounds.minY,
+      bounds.maxX,
+      bounds.maxY
+    );
+  }
+  getTraceSegmentsInBounds(bounds) {
+    if (!this.traceSegmentIndex) return [];
+    const searchBounds = getPaddedBounds(bounds, EPS12);
+    return this.traceSegmentIndex.search(
+      searchBounds.minX,
+      searchBounds.minY,
+      searchBounds.maxX,
+      searchBounds.maxY
+    ).map((segmentIndex) => this.traceSegments[segmentIndex]);
+  }
+  getLabelIndicesNearTracePath(tracePath) {
+    const labelIndices = /* @__PURE__ */ new Set();
+    for (let pointIndex = 0; pointIndex < tracePath.length - 1; pointIndex++) {
+      const segmentBounds = getPaddedBounds(
+        getSegmentBounds(tracePath[pointIndex], tracePath[pointIndex + 1]),
+        EPS12
+      );
+      for (const labelIndex of this.getLabelIndicesInBounds(segmentBounds)) {
+        labelIndices.add(labelIndex);
+      }
+    }
+    return [...labelIndices].sort((a, b) => a - b);
+  }
+  doesTracePathCrossChip(tracePath) {
+    for (let pointIndex = 0; pointIndex < tracePath.length - 1; pointIndex++) {
+      const start = tracePath[pointIndex];
+      const end = tracePath[pointIndex + 1];
+      const nearbyChips = this.chipObstacleSpatialIndex.getChipsInBounds(
+        getPaddedBounds(getSegmentBounds(start, end), EPS12)
+      );
+      for (const chip of nearbyChips) {
+        if (segmentCrossesBoundsInterior(start, end, chip.bounds)) return true;
+      }
+    }
+    return false;
+  }
+  doesTraceCrossBoundsInterior(bounds) {
+    for (const segment of this.getTraceSegmentsInBounds(bounds)) {
+      if (segmentCrossesBoundsInterior(segment.start, segment.end, bounds)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  doesTraceIntersectBounds(params) {
+    for (const segment of this.getTraceSegmentsInBounds(params.bounds)) {
+      if (segment.trace.globalConnNetId === params.excludedGlobalConnNetId) {
+        continue;
+      }
+      if (segmentIntersectsRect2(segment.start, segment.end, params.bounds)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  buildLabelIndex(netLabelPlacements) {
+    if (netLabelPlacements.length === 0) return null;
+    const labelIndex = new Flatbush2(netLabelPlacements.length);
+    for (const label of netLabelPlacements) {
+      labelIndex.add(
+        label.center.x - label.width / 2,
+        label.center.y - label.height / 2,
+        label.center.x + label.width / 2,
+        label.center.y + label.height / 2
+      );
+    }
+    labelIndex.finish();
+    return labelIndex;
+  }
+  getTraceSegments(traces) {
+    const traceSegments = [];
+    for (const trace of traces) {
+      for (let pointIndex = 0; pointIndex < trace.tracePath.length - 1; pointIndex++) {
+        traceSegments.push({
+          trace,
+          start: trace.tracePath[pointIndex],
+          end: trace.tracePath[pointIndex + 1]
+        });
+      }
+    }
+    return traceSegments;
+  }
+  buildTraceSegmentIndex(traceSegments) {
+    if (traceSegments.length === 0) return null;
+    const traceSegmentIndex = new Flatbush2(traceSegments.length);
+    for (const segment of traceSegments) {
+      traceSegmentIndex.add(
+        Math.min(segment.start.x, segment.end.x),
+        Math.min(segment.start.y, segment.end.y),
+        Math.max(segment.start.x, segment.end.x),
+        Math.max(segment.start.y, segment.end.y)
+      );
+    }
+    traceSegmentIndex.finish();
+    return traceSegmentIndex;
+  }
+};
+function getSegmentBounds(start, end) {
+  return {
+    minX: Math.min(start.x, end.x),
+    minY: Math.min(start.y, end.y),
+    maxX: Math.max(start.x, end.x),
+    maxY: Math.max(start.y, end.y)
+  };
+}
+function getPaddedBounds(bounds, padding) {
+  return {
+    minX: bounds.minX - padding,
+    minY: bounds.minY - padding,
+    maxX: bounds.maxX + padding,
+    maxY: bounds.maxY + padding
+  };
+}
+
 // lib/solvers/AvailableNetOrientationSolver/AvailableNetOrientationSolver.ts
 var LABEL_TRACE_CLEARANCE2 = 0.1;
 var AvailableNetOrientationSolver = class extends BaseSolver {
@@ -8202,6 +8393,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   chipObstacleSpatialIndex;
   maxSearchDistance;
   pinMap;
+  obstacleIndex;
   constructor(params) {
     super();
     this.inputProblem = params.inputProblem;
@@ -8214,6 +8406,11 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     this.pinMap = getPinMap(params.inputProblem);
     this.chipObstacleSpatialIndex = params.inputProblem._chipObstacleSpatialIndex ?? new ChipObstacleSpatialIndex(params.inputProblem.chips);
     this.maxSearchDistance = getMaxSearchDistance(params.inputProblem);
+    this.obstacleIndex = new AvailableNetOrientationObstacleIndex({
+      chipObstacleSpatialIndex: this.chipObstacleSpatialIndex,
+      netLabelPlacements: this.outputNetLabelPlacements,
+      traces: this.traces
+    });
     this.crowdedPortOnlyLabelIndices = this.getCrowdedPortOnlyLabelIndices();
     this.queuedLabelIndices = this.getProcessableLabelIndices();
     this.setCurrentLabel(this.queuedLabelIndices[0] ?? null);
@@ -8395,6 +8592,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       ...toNetLabelPlacementPatch(candidate)
     };
     this.addConnectorTrace(label, candidate, labelIndex);
+    this.obstacleIndex.rebuild({
+      netLabelPlacements: this.outputNetLabelPlacements,
+      traces: this.traces
+    });
   }
   addConnectorTrace(label, candidate, labelIndex) {
     if (candidate.phase === "trace-anchor") return;
@@ -8557,7 +8758,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         anchorY - label.anchorPoint.y,
         anchorX - label.anchorPoint.x
       );
-      this.currentCandidateResults.push(result);
+      this.recordCandidateResult(result);
       if (result.status !== "valid") continue;
       result.selected = true;
       return result;
@@ -8592,7 +8793,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         labelIndex,
         "rotate"
       );
-      this.currentCandidateResults.push(result);
+      this.recordCandidateResult(result);
       if (result.status === "valid") {
         result.selected = true;
         return result;
@@ -8617,7 +8818,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         labelIndex,
         "trace-anchor"
       );
-      this.currentCandidateResults.push(result);
+      this.recordCandidateResult(result);
       if (result.status === "valid") {
         result.selected = true;
         return result;
@@ -8654,7 +8855,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         labelIndex,
         "outward-trace-anchor"
       );
-      this.currentCandidateResults.push(preservedColumnResult);
+      this.recordCandidateResult(preservedColumnResult);
       if (preservedColumnResult.status === "valid") {
         preservedColumnResult.selected = true;
         return preservedColumnResult;
@@ -8682,7 +8883,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
           "outward-trace-anchor",
           distance5
         );
-        this.currentCandidateResults.push(result);
+        this.recordCandidateResult(result);
         if (result.status === "valid") {
           result.selected = true;
           return result;
@@ -8807,7 +9008,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
         distance5,
         outwardDistance
       );
-      this.currentCandidateResults.push(result);
+      this.recordCandidateResult(result);
       if (result.status === "valid") {
         result.selected = true;
         return result;
@@ -8831,6 +9032,18 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       })
     };
   }
+  recordCandidateResult(candidate) {
+    this.stats.candidateEvaluations = (this.stats.candidateEvaluations ?? 0) + 1;
+    if (this.currentCandidateResults.length < MAX_RECORDED_CANDIDATES) {
+      this.currentCandidateResults.push(candidate);
+    } else if (candidate.status === "valid") {
+      this.currentCandidateResults[MAX_RECORDED_CANDIDATES - 1] = candidate;
+    }
+    this.stats.maxRecordedCandidates = Math.max(
+      this.stats.maxRecordedCandidates ?? 0,
+      this.currentCandidateResults.length
+    );
+  }
   getCandidateConnectorTrace(label, candidate, labelIndex) {
     if (this.crowdedPortOnlyLabelIndices.has(labelIndex) && this.getChipSideForPoint(label.anchorPoint) === "top" && isYOrientation(candidate.orientation)) {
       return simplifyOrthogonalPath([
@@ -9070,12 +9283,12 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
       },
       labelIndex
     );
-    for (const chip of this.chipObstacleSpatialIndex.chips) {
-      if (tracePathCrossesAnyBounds(connectorTrace, chip.bounds)) {
-        return "chip-collision";
-      }
+    if (this.obstacleIndex.doesTracePathCrossChip(connectorTrace)) {
+      return "chip-collision";
     }
-    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+    for (const i of this.obstacleIndex.getLabelIndicesNearTracePath(
+      connectorTrace
+    )) {
       if (i === labelIndex) continue;
       if (this.shouldIgnorePendingCrowdedLabel(labelIndex, i)) continue;
       const otherLabel = this.outputNetLabelPlacements[i];
@@ -9117,7 +9330,7 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     if (rectIntersectsAnyTextBox(bounds, this.inputProblem)) {
       return "text-collision";
     }
-    if (traceCrossesBoundsInterior(bounds, this.traceMap)) {
+    if (this.obstacleIndex.doesTraceCrossBoundsInterior(bounds)) {
       return "trace-collision";
     }
     if (this.isTraceTooCloseToLabel(bounds, label)) {
@@ -9131,13 +9344,10 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
   isTraceTooCloseToLabel(bounds, label) {
     if (!this.shouldCheckTraceClearanceForLabel(label)) return false;
     const clearanceBounds = this.getLabelTraceClearanceBounds(bounds);
-    for (const trace of Object.values(this.traceMap)) {
-      if (trace.globalConnNetId === label.globalConnNetId) continue;
-      if (tracePathIntersectsBounds(trace.tracePath, clearanceBounds)) {
-        return true;
-      }
-    }
-    return false;
+    return this.obstacleIndex.doesTraceIntersectBounds({
+      bounds: clearanceBounds,
+      excludedGlobalConnNetId: label.globalConnNetId
+    });
   }
   getLabelTraceClearanceBounds(bounds) {
     return {
@@ -9220,7 +9430,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     return this.crowdedPortOnlyLabelIndices.has(labelIndex) && this.crowdedPortOnlyLabelIndices.has(otherLabelIndex) && this.queuedLabelIndices.includes(otherLabelIndex);
   }
   intersectsAnyOtherNetLabel(bounds, labelIndex) {
-    for (let i = 0; i < this.outputNetLabelPlacements.length; i++) {
+    const searchBounds = {
+      minX: bounds.minX - LABEL_SEARCH_STEP,
+      minY: bounds.minY - LABEL_SEARCH_STEP,
+      maxX: bounds.maxX + LABEL_SEARCH_STEP,
+      maxY: bounds.maxY + LABEL_SEARCH_STEP
+    };
+    const nearbyLabelIndices = this.obstacleIndex.getLabelIndicesInBounds(searchBounds).sort((a, b) => a - b);
+    for (const i of nearbyLabelIndices) {
       if (i === labelIndex) continue;
       if (this.shouldIgnorePendingCrowdedLabel(labelIndex, i)) continue;
       const label = this.outputNetLabelPlacements[i];
@@ -9234,7 +9451,14 @@ var AvailableNetOrientationSolver = class extends BaseSolver {
     return false;
   }
   sharesChipBoundary(bounds) {
-    for (const chip of this.chipObstacleSpatialIndex.chips) {
+    const boundarySearchBounds = {
+      minX: bounds.minX - WICK_CLEARANCE - EPS12,
+      minY: bounds.minY - WICK_CLEARANCE - EPS12,
+      maxX: bounds.maxX + WICK_CLEARANCE + EPS12,
+      maxY: bounds.maxY + WICK_CLEARANCE + EPS12
+    };
+    const nearbyChips = this.chipObstacleSpatialIndex.getChipsInBounds(boundarySearchBounds);
+    for (const chip of nearbyChips) {
       const chipBounds = chip.bounds;
       const adjacentToVerticalSide = Math.abs(bounds.minX - chipBounds.maxX) <= WICK_CLEARANCE + EPS12 || Math.abs(bounds.maxX - chipBounds.minX) <= WICK_CLEARANCE + EPS12;
       const adjacentToHorizontalSide = Math.abs(bounds.minY - chipBounds.maxY) <= WICK_CLEARANCE + EPS12 || Math.abs(bounds.maxY - chipBounds.minY) <= WICK_CLEARANCE + EPS12;
@@ -11749,6 +11973,35 @@ var railIsOnFacingSide = ({
   if (pin._facingDirection === "y+") return railY > pin.y;
   return false;
 };
+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] : [];
+});
+var moveAttachedLabels = ({
+  trace,
+  reroutedTracePath,
+  netLabelPlacements,
+  attachedLabelIndexes
+}) => {
+  const attachedLabels = attachedLabelIndexes.map(
+    (index) => netLabelPlacements[index]
+  );
+  const movedAttachedLabels = moveAttachedLabelsToReroutedTrace({
+    trace,
+    originalTracePath: trace.tracePath,
+    reroutedTracePath,
+    netLabelPlacements: attachedLabels
+  });
+  const movedLabelByIndex = new Map(
+    attachedLabelIndexes.map((labelIndex, index) => [
+      labelIndex,
+      movedAttachedLabels[index]
+    ])
+  );
+  return netLabelPlacements.map(
+    (label, index) => movedLabelByIndex.get(index) ?? label
+  );
+};
 var getAlignedBranchPath = ({
   donorTrace,
   branchTrace
@@ -11789,7 +12042,8 @@ var candidateIsClear = ({
   originalTrace,
   traces,
   inputProblem,
-  netLabelPlacements
+  candidateNetLabelPlacements,
+  attachedLabelIndexes
 }) => {
   const obstacles = getObstacleRects(inputProblem);
   if (isPathCollidingWithObstacles(candidateTrace.tracePath, obstacles)) {
@@ -11801,14 +12055,15 @@ var candidateIsClear = ({
   if (doesPathCoincideWithTraces(candidateTrace.tracePath, otherNetTraces)) {
     return false;
   }
-  const candidateTraces = traces.map((trace) => {
-    if (trace.mspPairId === originalTrace.mspPairId) return candidateTrace;
-    return trace;
-  });
-  if (!preservesLabelAnchors(netLabelPlacements, traces, candidateTraces)) {
+  if (!attachedLabelIndexes.every(
+    (index) => tracePathContainsPoint(
+      candidateTrace.tracePath,
+      candidateNetLabelPlacements[index].anchorPoint
+    )
+  )) {
     return false;
   }
-  const otherNetLabelPlacements = netLabelPlacements.filter(
+  const otherNetLabelPlacements = candidateNetLabelPlacements.filter(
     (label) => label.globalConnNetId !== candidateTrace.globalConnNetId
   );
   if (pathIntersectsAnyNetLabel({
@@ -11817,7 +12072,7 @@ var candidateIsClear = ({
   })) {
     return false;
   }
-  const sameNetLabelPlacements = netLabelPlacements.filter(
+  const sameNetLabelPlacements = candidateNetLabelPlacements.filter(
     (label) => label.globalConnNetId === candidateTrace.globalConnNetId
   );
   if (!pathIntersectsAnyNetLabel({
@@ -11843,9 +12098,14 @@ var alignSameNetJunctions = ({
   netLabelPlacements
 }) => {
   let outputTraces = [...traces];
+  let outputNetLabelPlacements = [...netLabelPlacements];
   const alignedBranchTraceIds = /* @__PURE__ */ new Set();
   let alignedJunctionCount = 0;
-  for (const donorTraceId of traces.map((trace) => trace.mspPairId)) {
+  const donorTraceIds = traces.map((trace) => trace.mspPairId);
+  const pendingDonorTraceIds = new Set(donorTraceIds);
+  for (let donorIndex = 0; donorIndex < donorTraceIds.length; donorIndex++) {
+    const donorTraceId = donorTraceIds[donorIndex];
+    pendingDonorTraceIds.delete(donorTraceId);
     const donorTrace = outputTraces.find(
       (trace) => trace.mspPairId === donorTraceId
     );
@@ -11866,12 +12126,23 @@ var alignSameNetJunctions = ({
       if (!removesVisibleSegment && !shortensVisibleTrace) {
         continue;
       }
+      const attachedLabelIndexes = getAttachedLabelIndexes(
+        branchTrace,
+        outputNetLabelPlacements
+      );
+      const candidateNetLabelPlacements = moveAttachedLabels({
+        trace: branchTrace,
+        reroutedTracePath: candidatePath,
+        netLabelPlacements: outputNetLabelPlacements,
+        attachedLabelIndexes
+      });
       if (!candidateIsClear({
         candidateTrace,
         originalTrace: branchTrace,
         traces: outputTraces,
         inputProblem,
-        netLabelPlacements
+        candidateNetLabelPlacements,
+        attachedLabelIndexes
       })) {
         continue;
       }
@@ -11879,32 +12150,44 @@ var alignSameNetJunctions = ({
         if (trace.mspPairId === branchTrace.mspPairId) return candidateTrace;
         return trace;
       });
+      outputNetLabelPlacements = candidateNetLabelPlacements;
       alignedBranchTraceIds.add(branchTrace.mspPairId);
       alignedJunctionCount++;
+      if (!pendingDonorTraceIds.has(branchTrace.mspPairId)) {
+        donorTraceIds.push(branchTrace.mspPairId);
+        pendingDonorTraceIds.add(branchTrace.mspPairId);
+      }
     }
   }
-  return { traces: outputTraces, alignedJunctionCount };
+  return {
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    alignedJunctionCount
+  };
 };
 
 // lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts
 var SameNetJunctionAlignmentSolver = class extends BaseSolver {
   input;
   outputTraces;
+  outputNetLabelPlacements;
   constructor(input) {
     super();
     this.input = input;
     this.outputTraces = input.traces;
+    this.outputNetLabelPlacements = input.netLabelPlacements;
   }
   _step() {
     const result = alignSameNetJunctions(this.input);
     this.outputTraces = result.traces;
+    this.outputNetLabelPlacements = result.netLabelPlacements;
     this.stats.alignedJunctionCount = result.alignedJunctionCount;
     this.solved = true;
   }
   getOutput() {
     return {
       traces: this.outputTraces,
-      netLabelPlacements: this.input.netLabelPlacements
+      netLabelPlacements: this.outputNetLabelPlacements
     };
   }
   visualize() {
@@ -11918,7 +12201,7 @@ var SameNetJunctionAlignmentSolver = class extends BaseSolver {
         strokeColor: "purple"
       });
     }
-    for (const label of this.input.netLabelPlacements) {
+    for (const label of this.outputNetLabelPlacements) {
       const labelRect = {
         center: label.center,
         width: label.width,
@@ -12904,11 +13187,16 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
       (instance) => {
         const previousOutput = instance.preAlignmentNetLabelTraceCollisionSolver.getOutput();
         const alignmentOutput = instance.traceCleanupSolver2.getOutput();
+        const connectorMovement = moveNetLabelConnectorsToReroutedTraces({
+          originalTraces: previousOutput.traces,
+          reroutedTraces: alignmentOutput.traces,
+          netLabelPlacements: previousOutput.netLabelPlacements
+        });
         const previousTraceMap = new Map(
           previousOutput.traces.map((trace) => [trace.mspPairId, trace])
         );
-        let netLabelPlacements = previousOutput.netLabelPlacements;
-        for (const trace of alignmentOutput.traces) {
+        let netLabelPlacements = connectorMovement.netLabelPlacements;
+        for (const trace of connectorMovement.traces) {
           const previousTrace = previousTraceMap.get(trace.mspPairId);
           if (!previousTrace || previousTrace.tracePath === trace.tracePath) {
             continue;
@@ -12928,7 +13216,7 @@ var SchematicTracePipelineSolver = class extends BaseSolver {
         return [
           {
             inputProblem: instance.inputProblem,
-            traces: alignmentOutput.traces,
+            traces: connectorMovement.traces,
             netLabelPlacements
           }
         ];