@tscircuit/schematic-trace-solver 0.0.189 → 0.0.190

package/dist/index.js

@@ -13275,7 +13275,7 @@ var UnroutedTraceRecoverySolver = class extends BaseSolver {
 };
 
 // lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts
-import { getSegmentIntersection as getSegmentIntersection3 } from "@tscircuit/math-utils/line-intersections";
+import { getSegmentIntersection as getSegmentIntersection4 } from "@tscircuit/math-utils/line-intersections";
 
 // lib/solvers/SameNetJunctionAlignmentSolver/pathIntersectsAnyNetLabel.ts
 var NET_LABEL_INTERIOR_INSET = 1e-6;
@@ -13594,6 +13594,242 @@ var collapseRedundantSharedEndpointStubs = ({
   return outputTraces;
 };
 
+// lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts
+import { getSegmentIntersection as getSegmentIntersection3 } from "@tscircuit/math-utils/line-intersections";
+var TRACE_LENGTH_EPSILON = 1e-6;
+var getTracePathStartingAtPin = (trace, pin) => {
+  const pathStart = trace.tracePath[0];
+  const pathEnd = trace.tracePath.at(-1);
+  if (!pathStart || !pathEnd) return null;
+  if (pointsEqual2(pathStart, pin)) return trace.tracePath;
+  if (pointsEqual2(pathEnd, pin)) return [...trace.tracePath].reverse();
+  return null;
+};
+var getPerpendicularPathCrossings = (targetPath, donorPath) => {
+  const crossings = [];
+  const sharedEndpoint = targetPath[0];
+  for (let targetSegmentIndex = 0; targetSegmentIndex < targetPath.length - 1; targetSegmentIndex++) {
+    const targetStart = targetPath[targetSegmentIndex];
+    const targetEnd = targetPath[targetSegmentIndex + 1];
+    const targetOrientation = getRailOrientation(targetStart, targetEnd);
+    if (!targetOrientation) continue;
+    for (let donorSegmentIndex = 0; donorSegmentIndex < donorPath.length - 1; donorSegmentIndex++) {
+      const donorStart = donorPath[donorSegmentIndex];
+      const donorEnd = donorPath[donorSegmentIndex + 1];
+      const donorOrientation = getRailOrientation(donorStart, donorEnd);
+      if (!donorOrientation || donorOrientation === targetOrientation) continue;
+      const intersectionPoint = getSegmentIntersection3(
+        targetStart,
+        targetEnd,
+        donorStart,
+        donorEnd
+      );
+      if (!intersectionPoint || pointsEqual2(intersectionPoint, sharedEndpoint)) {
+        continue;
+      }
+      crossings.push({
+        intersectionPoint,
+        targetSegmentIndex,
+        donorSegmentIndex
+      });
+    }
+  }
+  return crossings;
+};
+var buildCollapsedSelfCyclePath = (path, firstSegmentIndex, secondSegmentIndex) => {
+  const intersectionPoint = getSegmentIntersection3(
+    path[firstSegmentIndex],
+    path[firstSegmentIndex + 1],
+    path[secondSegmentIndex],
+    path[secondSegmentIndex + 1]
+  );
+  if (!intersectionPoint) return path;
+  return simplifyPath([
+    ...path.slice(0, firstSegmentIndex + 1),
+    intersectionPoint,
+    ...path.slice(secondSegmentIndex + 1)
+  ]);
+};
+var buildCollapsedCyclePath = ({
+  targetTrace,
+  targetPath,
+  donorPath,
+  crossing
+}) => {
+  const pathFromSharedPin = simplifyPath([
+    ...donorPath.slice(0, crossing.donorSegmentIndex + 1),
+    crossing.intersectionPoint,
+    ...targetPath.slice(crossing.targetSegmentIndex + 1)
+  ]);
+  if (pointsEqual2(targetTrace.tracePath[0], targetPath[0])) {
+    return pathFromSharedPin;
+  }
+  return pathFromSharedPin.reverse();
+};
+var getNetLabelPlacementsForCycleCollapse = ({
+  targetTrace,
+  tracePath,
+  netLabelPlacements
+}) => {
+  const candidateNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
+    trace: targetTrace,
+    originalTracePath: targetTrace.tracePath,
+    reroutedTracePath: tracePath,
+    netLabelPlacements
+  });
+  for (let labelIndex = 0; labelIndex < netLabelPlacements.length; labelIndex++) {
+    const label = netLabelPlacements[labelIndex];
+    if (label.globalConnNetId !== targetTrace.globalConnNetId) continue;
+    if (!tracePathContainsPoint(targetTrace.tracePath, label.anchorPoint)) {
+      continue;
+    }
+    const candidateLabel = candidateNetLabelPlacements[labelIndex];
+    if (!tracePathContainsPoint(tracePath, candidateLabel.anchorPoint)) {
+      return null;
+    }
+  }
+  const otherNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId !== targetTrace.globalConnNetId
+  );
+  if (pathIntersectsAnyNetLabel({
+    path: tracePath,
+    netLabelPlacements: otherNetLabelPlacements
+  })) {
+    return null;
+  }
+  const sameNetLabelPlacements = candidateNetLabelPlacements.filter(
+    (label) => label.globalConnNetId === targetTrace.globalConnNetId
+  );
+  if (pathEntersAnyNetLabel({
+    path: tracePath,
+    netLabelPlacements: sameNetLabelPlacements
+  })) {
+    return null;
+  }
+  return candidateNetLabelPlacements;
+};
+var candidateIsBetter = (candidate, bestCandidate) => {
+  if (!bestCandidate) return true;
+  const visibleLengthDelta = candidate.netVisibleLength - bestCandidate.netVisibleLength;
+  if (Math.abs(visibleLengthDelta) > TRACE_LENGTH_EPSILON) {
+    return visibleLengthDelta < 0;
+  }
+  return candidate.netVisibleSegmentCount < bestCandidate.netVisibleSegmentCount;
+};
+var getBestCycleCollapseCandidate = ({
+  targetTrace,
+  traces,
+  netLabelPlacements
+}) => {
+  const sameNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId
+  );
+  const baselineNetVisibleLength = getVisibleTraceLength(sameNetTraces);
+  const baselineTargetVisibleLength = getVisibleTraceLength([targetTrace]);
+  let bestCandidate = null;
+  const considerTracePath = (tracePath) => {
+    const candidateTrace = { ...targetTrace, tracePath };
+    const candidateTargetVisibleLength = getVisibleTraceLength([candidateTrace]);
+    if (candidateTargetVisibleLength > baselineTargetVisibleLength + TRACE_LENGTH_EPSILON) {
+      return;
+    }
+    const candidateNetLabelPlacements = getNetLabelPlacementsForCycleCollapse({
+      targetTrace,
+      tracePath,
+      netLabelPlacements
+    });
+    if (!candidateNetLabelPlacements) return;
+    const candidateNetTraces = sameNetTraces.map((trace) => {
+      if (trace.mspPairId === targetTrace.mspPairId) return candidateTrace;
+      return trace;
+    });
+    const netVisibleLength = getVisibleTraceLength(candidateNetTraces);
+    if (netVisibleLength >= baselineNetVisibleLength - TRACE_LENGTH_EPSILON) {
+      return;
+    }
+    const candidate = {
+      tracePath,
+      netLabelPlacements: candidateNetLabelPlacements,
+      netVisibleLength,
+      netVisibleSegmentCount: getVisibleTraceSegmentCount(candidateNetTraces)
+    };
+    if (candidateIsBetter(candidate, bestCandidate)) {
+      bestCandidate = candidate;
+    }
+  };
+  const selfCrossings = findPerpendicularPathCrossings(
+    targetTrace.tracePath,
+    targetTrace.tracePath,
+    { includeTerminalSegments: true }
+  ).filter(
+    ({ pathSegmentIndex, otherPathSegmentIndex }) => pathSegmentIndex < otherPathSegmentIndex
+  );
+  for (const crossing of selfCrossings) {
+    considerTracePath(
+      buildCollapsedSelfCyclePath(
+        targetTrace.tracePath,
+        crossing.pathSegmentIndex,
+        crossing.otherPathSegmentIndex
+      )
+    );
+  }
+  for (const donorTrace of sameNetTraces) {
+    if (donorTrace.mspPairId === targetTrace.mspPairId) continue;
+    const sharedPin = getSharedPin({
+      donorTrace,
+      branchTrace: targetTrace
+    });
+    if (!sharedPin) continue;
+    const targetPath = getTracePathStartingAtPin(targetTrace, sharedPin);
+    const donorPath = getTracePathStartingAtPin(donorTrace, sharedPin);
+    if (!targetPath || !donorPath) continue;
+    const crossings = getPerpendicularPathCrossings(targetPath, donorPath);
+    for (const crossing of crossings) {
+      const tracePath = buildCollapsedCyclePath({
+        targetTrace,
+        targetPath,
+        donorPath,
+        crossing
+      });
+      considerTracePath(tracePath);
+    }
+  }
+  return bestCandidate;
+};
+var collapseSameNetCycles = ({
+  traces,
+  netLabelPlacements
+}) => {
+  const outputTraces = [...traces];
+  let outputNetLabelPlacements = [...netLabelPlacements];
+  let collapsedCycleCount = 0;
+  let traceIndex = 0;
+  while (traceIndex < outputTraces.length) {
+    const targetTrace = outputTraces[traceIndex];
+    const candidate = getBestCycleCollapseCandidate({
+      targetTrace,
+      traces: outputTraces,
+      netLabelPlacements: outputNetLabelPlacements
+    });
+    if (!candidate) {
+      traceIndex++;
+      continue;
+    }
+    outputTraces[traceIndex] = {
+      ...targetTrace,
+      tracePath: candidate.tracePath
+    };
+    outputNetLabelPlacements = candidate.netLabelPlacements;
+    collapsedCycleCount++;
+    traceIndex = 0;
+  }
+  return {
+    traces: outputTraces,
+    netLabelPlacements: outputNetLabelPlacements,
+    collapsedCycleCount
+  };
+};
+
 // lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts
 var MAX_ALIGNED_LOAD_PIN_OFFSET = 0.2;
 var MAX_SAME_NET_LABEL_BOUNDARY_RAIL_OFFSET = 0.2;
@@ -13978,7 +14214,7 @@ var pathsIntersect = (firstPath, secondPath) => {
   }
   for (let firstIndex = 1; firstIndex < firstPath.length; firstIndex++) {
     for (let secondIndex = 1; secondIndex < secondPath.length; secondIndex++) {
-      if (getSegmentIntersection3(
+      if (getSegmentIntersection4(
         firstPath[firstIndex - 1],
         firstPath[firstIndex],
         secondPath[secondIndex - 1],
@@ -14162,7 +14398,7 @@ var candidateIsClear = ({
       const intersections2 = /* @__PURE__ */ new Set();
       for (let i = 1; i < path.length; i++) {
         for (let j = 1; j < otherTrace.tracePath.length; j++) {
-          const point = getSegmentIntersection3(
+          const point = getSegmentIntersection4(
             path[i - 1],
             path[i],
             otherTrace.tracePath[j - 1],
@@ -14445,225 +14681,22 @@ var alignSameNetJunctions = ({
       }
     }
   }
-  const collapsedSharedEndpointStubs = collapseRedundantSharedEndpointStubs({
+  const cycleCollapse = collapseSameNetCycles({
     traces: outputTraces,
-    netLabelPlacements: outputNetLabelPlacements,
+    netLabelPlacements: outputNetLabelPlacements
+  });
+  outputTraces = collapseRedundantSharedEndpointStubs({
+    traces: cycleCollapse.traces,
+    netLabelPlacements: cycleCollapse.netLabelPlacements,
     netLabelConnectorTraceIds,
     multiPinNetPinIds: getMultiPinNetPinIds(inputProblem)
   });
-  outputTraces = collapsedSharedEndpointStubs;
-  return {
-    traces: outputTraces,
-    netLabelPlacements: outputNetLabelPlacements,
-    alignedJunctionCount
-  };
-};
-
-// lib/solvers/SameNetJunctionAlignmentSolver/collapseSameNetCycles.ts
-import { getSegmentIntersection as getSegmentIntersection4 } from "@tscircuit/math-utils/line-intersections";
-var TRACE_LENGTH_EPSILON = 1e-6;
-var getTracePathStartingAtPin = (trace, pin) => {
-  const pathStart = trace.tracePath[0];
-  const pathEnd = trace.tracePath.at(-1);
-  if (!pathStart || !pathEnd) return null;
-  if (pointsEqual2(pathStart, pin)) return trace.tracePath;
-  if (pointsEqual2(pathEnd, pin)) return [...trace.tracePath].reverse();
-  return null;
-};
-var getPerpendicularPathCrossings = (targetPath, donorPath) => {
-  const crossings = [];
-  const sharedEndpoint = targetPath[0];
-  for (let targetSegmentIndex = 0; targetSegmentIndex < targetPath.length - 1; targetSegmentIndex++) {
-    const targetStart = targetPath[targetSegmentIndex];
-    const targetEnd = targetPath[targetSegmentIndex + 1];
-    const targetOrientation = getRailOrientation(targetStart, targetEnd);
-    if (!targetOrientation) continue;
-    for (let donorSegmentIndex = 0; donorSegmentIndex < donorPath.length - 1; donorSegmentIndex++) {
-      const donorStart = donorPath[donorSegmentIndex];
-      const donorEnd = donorPath[donorSegmentIndex + 1];
-      const donorOrientation = getRailOrientation(donorStart, donorEnd);
-      if (!donorOrientation || donorOrientation === targetOrientation) continue;
-      const intersectionPoint = getSegmentIntersection4(
-        targetStart,
-        targetEnd,
-        donorStart,
-        donorEnd
-      );
-      if (!intersectionPoint || pointsEqual2(intersectionPoint, sharedEndpoint)) {
-        continue;
-      }
-      crossings.push({
-        intersectionPoint,
-        targetSegmentIndex,
-        donorSegmentIndex
-      });
-    }
-  }
-  return crossings;
-};
-var buildCollapsedCyclePath = ({
-  targetTrace,
-  targetPath,
-  donorPath,
-  crossing
-}) => {
-  const pathFromSharedPin = simplifyPath([
-    ...donorPath.slice(0, crossing.donorSegmentIndex + 1),
-    crossing.intersectionPoint,
-    ...targetPath.slice(crossing.targetSegmentIndex + 1)
-  ]);
-  if (pointsEqual2(targetTrace.tracePath[0], targetPath[0])) {
-    return pathFromSharedPin;
-  }
-  return pathFromSharedPin.reverse();
-};
-var getNetLabelPlacementsForCycleCollapse = ({
-  targetTrace,
-  tracePath,
-  netLabelPlacements
-}) => {
-  const candidateNetLabelPlacements = moveAttachedLabelsToReroutedTrace({
-    trace: targetTrace,
-    originalTracePath: targetTrace.tracePath,
-    reroutedTracePath: tracePath,
-    netLabelPlacements
-  });
-  for (let labelIndex = 0; labelIndex < netLabelPlacements.length; labelIndex++) {
-    const label = netLabelPlacements[labelIndex];
-    if (label.globalConnNetId !== targetTrace.globalConnNetId) continue;
-    if (!tracePathContainsPoint(targetTrace.tracePath, label.anchorPoint)) {
-      continue;
-    }
-    const candidateLabel = candidateNetLabelPlacements[labelIndex];
-    if (!tracePathContainsPoint(tracePath, candidateLabel.anchorPoint)) {
-      return null;
-    }
-  }
-  const otherNetLabelPlacements = candidateNetLabelPlacements.filter(
-    (label) => label.globalConnNetId !== targetTrace.globalConnNetId
-  );
-  if (pathIntersectsAnyNetLabel({
-    path: tracePath,
-    netLabelPlacements: otherNetLabelPlacements
-  })) {
-    return null;
-  }
-  const sameNetLabelPlacements = candidateNetLabelPlacements.filter(
-    (label) => label.globalConnNetId === targetTrace.globalConnNetId
-  );
-  if (pathEntersAnyNetLabel({
-    path: tracePath,
-    netLabelPlacements: sameNetLabelPlacements
-  })) {
-    return null;
-  }
-  return candidateNetLabelPlacements;
-};
-var candidateIsBetter = (candidate, bestCandidate) => {
-  if (!bestCandidate) return true;
-  const visibleLengthDelta = candidate.netVisibleLength - bestCandidate.netVisibleLength;
-  if (Math.abs(visibleLengthDelta) > TRACE_LENGTH_EPSILON) {
-    return visibleLengthDelta < 0;
-  }
-  return candidate.netVisibleSegmentCount < bestCandidate.netVisibleSegmentCount;
-};
-var getBestCycleCollapseCandidate = ({
-  targetTrace,
-  traces,
-  netLabelPlacements
-}) => {
-  const sameNetTraces = traces.filter(
-    (trace) => trace.globalConnNetId === targetTrace.globalConnNetId
-  );
-  const baselineNetVisibleLength = getVisibleTraceLength(sameNetTraces);
-  const baselineTargetVisibleLength = getVisibleTraceLength([targetTrace]);
-  let bestCandidate = null;
-  for (const donorTrace of sameNetTraces) {
-    if (donorTrace.mspPairId === targetTrace.mspPairId) continue;
-    const sharedPin = getSharedPin({
-      donorTrace,
-      branchTrace: targetTrace
-    });
-    if (!sharedPin) continue;
-    const targetPath = getTracePathStartingAtPin(targetTrace, sharedPin);
-    const donorPath = getTracePathStartingAtPin(donorTrace, sharedPin);
-    if (!targetPath || !donorPath) continue;
-    const crossings = getPerpendicularPathCrossings(targetPath, donorPath);
-    for (const crossing of crossings) {
-      const tracePath = buildCollapsedCyclePath({
-        targetTrace,
-        targetPath,
-        donorPath,
-        crossing
-      });
-      const candidateTrace = { ...targetTrace, tracePath };
-      const candidateTargetVisibleLength = getVisibleTraceLength([
-        candidateTrace
-      ]);
-      if (candidateTargetVisibleLength > baselineTargetVisibleLength + TRACE_LENGTH_EPSILON) {
-        continue;
-      }
-      const candidateNetLabelPlacements = getNetLabelPlacementsForCycleCollapse(
-        {
-          targetTrace,
-          tracePath,
-          netLabelPlacements
-        }
-      );
-      if (!candidateNetLabelPlacements) continue;
-      const candidateNetTraces = sameNetTraces.map((trace) => {
-        if (trace.mspPairId === targetTrace.mspPairId) return candidateTrace;
-        return trace;
-      });
-      const netVisibleLength = getVisibleTraceLength(candidateNetTraces);
-      if (netVisibleLength >= baselineNetVisibleLength - TRACE_LENGTH_EPSILON) {
-        continue;
-      }
-      const netVisibleSegmentCount = getVisibleTraceSegmentCount(candidateNetTraces);
-      const candidate = {
-        tracePath,
-        netLabelPlacements: candidateNetLabelPlacements,
-        netVisibleLength,
-        netVisibleSegmentCount
-      };
-      if (candidateIsBetter(candidate, bestCandidate)) {
-        bestCandidate = candidate;
-      }
-    }
-  }
-  return bestCandidate;
-};
-var collapseSameNetCycles = ({
-  traces,
-  netLabelPlacements
-}) => {
-  const outputTraces = [...traces];
-  let outputNetLabelPlacements = [...netLabelPlacements];
-  let collapsedCycleCount = 0;
-  let traceIndex = 0;
-  while (traceIndex < outputTraces.length) {
-    const targetTrace = outputTraces[traceIndex];
-    const candidate = getBestCycleCollapseCandidate({
-      targetTrace,
-      traces: outputTraces,
-      netLabelPlacements: outputNetLabelPlacements
-    });
-    if (!candidate) {
-      traceIndex++;
-      continue;
-    }
-    outputTraces[traceIndex] = {
-      ...targetTrace,
-      tracePath: candidate.tracePath
-    };
-    outputNetLabelPlacements = candidate.netLabelPlacements;
-    collapsedCycleCount++;
-    traceIndex = 0;
-  }
+  outputNetLabelPlacements = cycleCollapse.netLabelPlacements;
   return {
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,
-    collapsedCycleCount
+    alignedJunctionCount,
+    collapsedCycleCount: cycleCollapse.collapsedCycleCount
   };
 };
 
@@ -14776,18 +14809,14 @@ var SameNetJunctionAlignmentSolver = class extends BaseSolver {
   }
   _step() {
     const alignment = alignSameNetJunctions(this.input);
-    const cycleCollapse = collapseSameNetCycles({
-      traces: alignment.traces,
-      netLabelPlacements: alignment.netLabelPlacements
-    });
-    this.outputTraces = cycleCollapse.traces;
+    this.outputTraces = alignment.traces;
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: cycleCollapse.traces,
-      netLabelPlacements: cycleCollapse.netLabelPlacements
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements
     });
     this.stats.alignedJunctionCount = alignment.alignedJunctionCount;
-    this.stats.collapsedCycleCount = cycleCollapse.collapsedCycleCount;
+    this.stats.collapsedCycleCount = alignment.collapsedCycleCount;
     this.solved = true;
   }
   getOutput() {

package/lib/solvers/SameNetJunctionAlignmentSolver/SameNetJunctionAlignmentSolver.ts

@@ -7,7 +7,6 @@ import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/
 import type { InputProblem } from "lib/types/InputProblem"
 import { getColorFromString } from "lib/utils/getColorFromString"
 import { alignSameNetJunctions } from "./alignSameNetJunctions"
-import { collapseSameNetCycles } from "./collapseSameNetCycles"
 import { placeGroundRailLabelsAtOuterEnd } from "./placeGroundRailLabelsAtOuterEnd"
 
 interface SameNetJunctionAlignmentSolverInput {
@@ -32,18 +31,14 @@ export class SameNetJunctionAlignmentSolver extends BaseSolver {
 
   override _step() {
     const alignment = alignSameNetJunctions(this.input)
-    const cycleCollapse = collapseSameNetCycles({
-      traces: alignment.traces,
-      netLabelPlacements: alignment.netLabelPlacements,
-    })
-    this.outputTraces = cycleCollapse.traces
+    this.outputTraces = alignment.traces
     this.outputNetLabelPlacements = placeGroundRailLabelsAtOuterEnd({
       inputProblem: this.input.inputProblem,
-      traces: cycleCollapse.traces,
-      netLabelPlacements: cycleCollapse.netLabelPlacements,
+      traces: alignment.traces,
+      netLabelPlacements: alignment.netLabelPlacements,
     })
     this.stats.alignedJunctionCount = alignment.alignedJunctionCount
-    this.stats.collapsedCycleCount = cycleCollapse.collapsedCycleCount
+    this.stats.collapsedCycleCount = alignment.collapsedCycleCount
     this.solved = true
   }
 

package/lib/solvers/SameNetJunctionAlignmentSolver/alignSameNetJunctions.ts

@@ -34,6 +34,7 @@ import {
   isCoordinateOnPinFacingSide,
 } from "./findNearestSharedPinExitRail"
 import { collapseRedundantSharedEndpointStubs } from "./collapseRedundantSharedEndpointStubs"
+import { collapseSameNetCycles } from "./collapseSameNetCycles"
 import { getSharedPin } from "./getSharedPin"
 
 interface AlignSameNetJunctionsInput {
@@ -1314,17 +1315,24 @@ export const alignSameNetJunctions = ({
     }
   }
 
-  const collapsedSharedEndpointStubs = collapseRedundantSharedEndpointStubs({
+  // Shared-stub collapse can remove the common pin from one trace path, so
+  // collapse cycles while both paths still expose their shared endpoint.
+  const cycleCollapse = collapseSameNetCycles({
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,
+  })
+  outputTraces = collapseRedundantSharedEndpointStubs({
+    traces: cycleCollapse.traces,
+    netLabelPlacements: cycleCollapse.netLabelPlacements,
     netLabelConnectorTraceIds,
     multiPinNetPinIds: getMultiPinNetPinIds(inputProblem),
   })
-  outputTraces = collapsedSharedEndpointStubs
+  outputNetLabelPlacements = cycleCollapse.netLabelPlacements
 
   return {
     traces: outputTraces,
     netLabelPlacements: outputNetLabelPlacements,
     alignedJunctionCount,
+    collapsedCycleCount: cycleCollapse.collapsedCycleCount,
   }
 }