@tscircuit/schematic-trace-solver 0.0.97 → 0.0.99

package/lib/solvers/MspConnectionPairSolver/MspConnectionPairSolver.ts

@@ -1,3 +1,6 @@
+import { distance } from "@tscircuit/math-utils"
+import type { ConnectivityMap } from "connectivity-map"
+import type { GraphicsObject } from "graphics-debug"
 import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type {
   InputChip,
@@ -5,17 +8,17 @@ import type {
   InputProblem,
   PinId,
 } from "lib/types/InputProblem"
-import { ConnectivityMap } from "connectivity-map"
-import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
-import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
-import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCenterLines"
-import type { GraphicsObject } from "graphics-debug"
 import { getColorFromString } from "lib/utils/getColorFromString"
-import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
 import { arePinsInDifferentSchematicSections } from "../../utils/arePinsInDifferentSchematicSections"
+import { visualizeInputProblem } from "../SchematicTracePipelineSolver/visualizeInputProblem"
+import { doesPairCrossRestrictedCenterLines } from "./doesPairCrossRestrictedCenterLines"
+import { getConnectivityMapsFromInputProblem } from "./getConnectivityMapFromInputProblem"
+import { getOrthogonalMinimumSpanningTree } from "./getMspConnectionPairsFromPins"
 
 export type MspConnectionPairId = string
 
+const getPinPairKey = (pinIds: [PinId, PinId]) => [...pinIds].sort().join("::")
+
 export type MspConnectionPair = {
   mspPairId: MspConnectionPairId
   dcConnNetId: string
@@ -36,6 +39,7 @@ export class MspConnectionPairSolver extends BaseSolver {
 
   pinMap: Record<string, InputPin & { chipId: string }>
   userNetIdByPinId: Record<string, string | undefined>
+  directConnectionPinPairKeys: Set<string>
 
   constructor({ inputProblem }: { inputProblem: InputProblem }) {
     super()
@@ -62,7 +66,9 @@ export class MspConnectionPairSolver extends BaseSolver {
 
     // Build a mapping from PinId to user-provided netId (if any)
     this.userNetIdByPinId = {}
+    this.directConnectionPinPairKeys = new Set()
     for (const dc of inputProblem.directConnections) {
+      this.directConnectionPinPairKeys.add(getPinPairKey(dc.pinIds))
       if (dc.netId) {
         const [a, b] = dc.pinIds
         this.userNetIdByPinId[a] = dc.netId
@@ -105,9 +111,13 @@ export class MspConnectionPairSolver extends BaseSolver {
       const [pin1, pin2] = directlyConnectedPins
       const p1 = this.pinMap[pin1!]!
       const p2 = this.pinMap[pin2!]!
-      // Enforce max pair distance (use Manhattan to match orthogonal routing metric)
-      const manhattanDist = Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
-      if (manhattanDist > this.maxMspPairDistance) {
+      const pinPairKey = getPinPairKey([pin1!, pin2!])
+      // Explicit source traces are classified by straight-line distance when
+      // their input is created; named nets retain the orthogonal route metric.
+      const pairDistance = this.directConnectionPinPairKeys.has(pinPairKey)
+        ? distance(p1, p2)
+        : Math.abs(p1.x - p2.x) + Math.abs(p1.y - p2.y)
+      if (pairDistance > this.maxMspPairDistance) {
         // Too far apart; skip creating an MSP pair for this net
         return
       }

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/SchematicTraceSingleLineSolver2.ts

@@ -16,6 +16,7 @@ import {
   isVertical,
   segmentOverlapsRectBoundary,
 } from "./collisions"
+import { generateEndpointCollisionDetours } from "./generateEndpointCollisionDetours"
 import {
   type Axis,
   aabbFromPoints,
@@ -357,6 +358,35 @@ export class SchematicTraceSingleLineSolver2 extends BaseSolver {
     const isFirstSegment = segIndex === 0
     const isLastSegment = segIndex === path.length - 2
 
+    if (path.length === 3 && (isFirstSegment || isLastSegment)) {
+      const detours = generateEndpointCollisionDetours({
+        path,
+        collidingSegmentIndex: segIndex,
+        obstacle: rect,
+      })
+        .filter((detour) => {
+          const key = pathKey(detour)
+          if (this.visited.has(key)) return false
+          this.visited.add(key)
+          return true
+        })
+        .sort(
+          (a, b) =>
+            this.pathLength(a) - this.pathLength(b) ||
+            this.getPinBandPenalty(a) - this.getPinBandPenalty(b),
+        )
+
+      for (const detour of detours) {
+        const nextCollisionRects = new Set(collisionRects)
+        nextCollisionRects.add(rect)
+        this.queue.push({
+          path: detour,
+          collisionRects: nextCollisionRects,
+        })
+      }
+      return
+    }
+
     if (isFirstSegment) {
       // If first segment collides, move the second segment instead
       if (path.length < 3) {

package/lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/generateEndpointCollisionDetours.ts

@@ -0,0 +1,84 @@
+import type { Point } from "@tscircuit/math-utils"
+import { isHorizontal, isVertical } from "./collisions"
+import { type Axis, midBetweenPointAndRect } from "./mid"
+import type { ObstacleRect } from "./rect"
+
+const getSegmentAxis = (start: Point, end: Point): Axis | null => {
+  if (isVertical(start, end)) return "x"
+  if (isHorizontal(start, end)) return "y"
+  return null
+}
+
+const hasOnlyNonzeroOrthogonalSegments = (path: Point[]) =>
+  path.every((point, index) => {
+    const nextPoint = path[index + 1]
+    if (!nextPoint) return true
+    if (!isHorizontal(point, nextPoint) && !isVertical(point, nextPoint)) {
+      return false
+    }
+    return Math.abs(point.x - nextPoint.x) + Math.abs(point.y - nextPoint.y) > 0
+  })
+
+export const generateEndpointCollisionDetours = ({
+  path,
+  collidingSegmentIndex,
+  obstacle,
+}: {
+  path: Point[]
+  collidingSegmentIndex: number
+  obstacle: ObstacleRect
+}): Point[][] => {
+  if (path.length !== 3) return []
+
+  const lastSegmentIndex = path.length - 2
+  if (
+    collidingSegmentIndex !== 0 &&
+    collidingSegmentIndex !== lastSegmentIndex
+  ) {
+    return []
+  }
+
+  const shouldReverse = collidingSegmentIndex === lastSegmentIndex
+  const orderedPath = shouldReverse ? [...path].reverse() : path
+  const [start, corner, end] = orderedPath
+  const firstSegmentAxis = getSegmentAxis(start!, corner!)
+  const secondSegmentAxis = getSegmentAxis(corner!, end!)
+  if (!firstSegmentAxis || !secondSegmentAxis) return []
+  if (firstSegmentAxis === secondSegmentAxis) return []
+
+  const escapeCoordinates = [
+    ...midBetweenPointAndRect(secondSegmentAxis, start!, obstacle),
+    ...midBetweenPointAndRect(secondSegmentAxis, end!, obstacle),
+  ]
+  const detourCoordinates = [
+    ...midBetweenPointAndRect(firstSegmentAxis, start!, obstacle),
+    ...midBetweenPointAndRect(firstSegmentAxis, end!, obstacle),
+  ]
+
+  const detours: Point[][] = []
+  for (const escapeCoordinate of [...new Set(escapeCoordinates)]) {
+    for (const detourCoordinate of [...new Set(detourCoordinates)]) {
+      const orderedDetour =
+        firstSegmentAxis === "y"
+          ? [
+              start!,
+              { x: escapeCoordinate, y: start!.y },
+              { x: escapeCoordinate, y: detourCoordinate },
+              { x: end!.x, y: detourCoordinate },
+              end!,
+            ]
+          : [
+              start!,
+              { x: start!.x, y: escapeCoordinate },
+              { x: detourCoordinate, y: escapeCoordinate },
+              { x: detourCoordinate, y: end!.y },
+              end!,
+            ]
+
+      const detour = shouldReverse ? orderedDetour.reverse() : orderedDetour
+      if (hasOnlyNonzeroOrthogonalSegments(detour)) detours.push(detour)
+    }
+  }
+
+  return detours
+}

package/lib/solvers/SchematicTracePipelineSolver/SchematicTracePipelineSolver.ts

@@ -79,7 +79,9 @@ export class SchematicTracePipelineSolver extends BaseSolver {
   availableNetOrientationSolver?: AvailableNetOrientationSolver
   railNetLabelCornerPlacementSolver?: RailNetLabelCornerPlacementSolver
   traceAnchoredNetLabelOverlapSolver?: TraceAnchoredNetLabelOverlapSolver
+  preAlignmentNetLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
   netLabelTraceCollisionSolver?: NetLabelTraceCollisionSolver
+  traceCleanupSolver2?: TraceCleanupSolver
   netLabelNetLabelCollisionSolver?: NetLabelNetLabelCollisionSolver
 
   startTimeOfPhase: Record<string, number>
@@ -291,7 +293,7 @@ export class SchematicTracePipelineSolver extends BaseSolver {
       ],
     ),
     definePipelineStep(
-      "netLabelTraceCollisionSolver",
+      "preAlignmentNetLabelTraceCollisionSolver",
       NetLabelTraceCollisionSolver,
       (instance) => [
         {
@@ -303,6 +305,48 @@ export class SchematicTracePipelineSolver extends BaseSolver {
         },
       ],
     ),
+    definePipelineStep(
+      "traceCleanupSolver2",
+      TraceCleanupSolver,
+      (instance) => {
+        const collisionOutput =
+          instance.preAlignmentNetLabelTraceCollisionSolver!.getOutput()
+        const labelMergingOutput =
+          instance.traceLabelOverlapAvoidanceSolver!.labelMergingSolver!.getOutput()
+
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            allTraces: collisionOutput.traces,
+            allLabelPlacements: collisionOutput.netLabelPlacements,
+            mergedLabelNetIdMap: labelMergingOutput.mergedLabelNetIdMap,
+            paddingBuffer: 0.1,
+            operations: ["aligning_same_net_rails"],
+            eligibleTraceIds: new Set(
+              instance
+                .traceCleanupSolver!.getOutput()
+                .traces.map((trace) => trace.mspPairId),
+            ),
+          },
+        ]
+      },
+    ),
+    definePipelineStep(
+      "netLabelTraceCollisionSolver",
+      NetLabelTraceCollisionSolver,
+      (instance) => {
+        const previousCollisionOutput =
+          instance.preAlignmentNetLabelTraceCollisionSolver!.getOutput()
+
+        return [
+          {
+            inputProblem: instance.inputProblem,
+            traces: instance.traceCleanupSolver2!.getOutput().traces,
+            netLabelPlacements: previousCollisionOutput.netLabelPlacements,
+          },
+        ]
+      },
+    ),
     definePipelineStep(
       "netLabelNetLabelCollisionSolver",
       NetLabelNetLabelCollisionSolver,

package/lib/solvers/TraceCleanupSolver/TraceCleanupSolver.ts

@@ -6,16 +6,25 @@ import { BaseSolver } from "lib/solvers/BaseSolver/BaseSolver"
 import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
 import { visualizeInputProblem } from "lib/solvers/SchematicTracePipelineSolver/visualizeInputProblem"
 import type { NetLabelPlacement } from "../NetLabelPlacementSolver/NetLabelPlacementSolver"
+import { alignSameNetRails } from "./alignSameNetRails"
+
+export type TraceCleanupOperation =
+  | "untangling_traces"
+  | "minimizing_turns"
+  | "balancing_l_shapes"
+  | "aligning_same_net_rails"
 
 /**
  * Defines the input structure for the TraceCleanupSolver.
  */
-interface TraceCleanupSolverInput {
+export interface TraceCleanupSolverInput {
   inputProblem: InputProblem
   allTraces: SolvedTracePath[]
   allLabelPlacements: NetLabelPlacement[]
   mergedLabelNetIdMap: Record<string, Set<string>>
   paddingBuffer: number
+  operations?: readonly TraceCleanupOperation[]
+  eligibleTraceIds?: ReadonlySet<string>
 }
 
 import { UntangleTraceSubsolver } from "./sub-solver/UntangleTraceSubsolver"
@@ -24,10 +33,11 @@ import { is4PointRectangle } from "./is4PointRectangle"
 /**
  * Represents the different stages or steps within the trace cleanup pipeline.
  */
-type PipelineStep =
-  | "minimizing_turns"
-  | "balancing_l_shapes"
-  | "untangling_traces"
+const DEFAULT_OPERATIONS: readonly TraceCleanupOperation[] = [
+  "untangling_traces",
+  "minimizing_turns",
+  "balancing_l_shapes",
+]
 
 /**
  * The TraceCleanupSolver is responsible for improving the aesthetics and readability of schematic traces.
@@ -42,7 +52,9 @@ export class TraceCleanupSolver extends BaseSolver {
   private outputTraces: SolvedTracePath[]
   private traceIdQueue: string[]
   private tracesMap: Map<string, SolvedTracePath>
-  private pipelineStep: PipelineStep = "untangling_traces"
+  private operations: readonly TraceCleanupOperation[]
+  private operationIndex = 0
+  private pipelineStep: TraceCleanupOperation | null
   private activeTraceId: string | null = null // New property
   override activeSubSolver: BaseSolver | null = null
 
@@ -51,6 +63,8 @@ export class TraceCleanupSolver extends BaseSolver {
     this.input = solverInput
     this.outputTraces = [...solverInput.allTraces]
     this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]))
+    this.operations = solverInput.operations ?? DEFAULT_OPERATIONS
+    this.pipelineStep = this.operations[0] ?? null
     this.traceIdQueue = Array.from(
       solverInput.allTraces.map((e) => e.mspPairId),
     )
@@ -66,14 +80,19 @@ export class TraceCleanupSolver extends BaseSolver {
         this.outputTraces = output.traces
         this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]))
         this.activeSubSolver = null
-        this.pipelineStep = "minimizing_turns"
+        this._advancePipeline()
       } else if (this.activeSubSolver.failed) {
         this.activeSubSolver = null
-        this.pipelineStep = "minimizing_turns"
+        this._advancePipeline()
       }
       return
     }
 
+    if (!this.pipelineStep) {
+      this.solved = true
+      return
+    }
+
     switch (this.pipelineStep) {
       case "untangling_traces":
         this._runUntangleTracesStep()
@@ -84,9 +103,19 @@ export class TraceCleanupSolver extends BaseSolver {
       case "balancing_l_shapes":
         this._runBalanceLShapesStep()
         break
+      case "aligning_same_net_rails":
+        this._runAlignSameNetRailsStep()
+        break
     }
   }
 
+  private _advancePipeline() {
+    this.operationIndex++
+    this.pipelineStep = this.operations[this.operationIndex] ?? null
+    this.traceIdQueue = this.outputTraces.map((trace) => trace.mspPairId)
+    if (this.pipelineStep) this.activeTraceId = null
+  }
+
   private _runUntangleTracesStep() {
     this.activeSubSolver = new UntangleTraceSubsolver({
       ...this.input,
@@ -96,10 +125,7 @@ export class TraceCleanupSolver extends BaseSolver {
 
   private _runMinimizeTurnsStep() {
     if (this.traceIdQueue.length === 0) {
-      this.pipelineStep = "balancing_l_shapes"
-      this.traceIdQueue = Array.from(
-        this.input.allTraces.map((e) => e.mspPairId),
-      )
+      this._advancePipeline()
       return
     }
 
@@ -108,7 +134,7 @@ export class TraceCleanupSolver extends BaseSolver {
 
   private _runBalanceLShapesStep() {
     if (this.traceIdQueue.length === 0) {
-      this.solved = true
+      this._advancePipeline()
       return
     }
 
@@ -146,6 +172,22 @@ export class TraceCleanupSolver extends BaseSolver {
     this.outputTraces = Array.from(this.tracesMap.values())
   }
 
+  private _runAlignSameNetRailsStep() {
+    const alignment = alignSameNetRails({
+      inputProblem: this.input.inputProblem,
+      traces: this.outputTraces,
+      netLabelPlacements: this.input.allLabelPlacements,
+      eligibleTraceIds:
+        this.input.eligibleTraceIds ??
+        new Set(this.outputTraces.map((trace) => trace.mspPairId)),
+    })
+    this.outputTraces = alignment.traces
+    this.tracesMap = new Map(this.outputTraces.map((t) => [t.mspPairId, t]))
+    this.stats.alignedRailGroupCount = alignment.alignedRailGroupCount
+    this.stats.alignedTraceCount = alignment.alignedTraceCount
+    this._advancePipeline()
+  }
+
   getOutput() {
     return {
       traces: this.outputTraces,

package/lib/solvers/TraceCleanupSolver/alignSameNetRails.ts

@@ -0,0 +1,66 @@
+import type { NetLabelPlacement } from "lib/solvers/NetLabelPlacementSolver/NetLabelPlacementSolver"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getObstacleRects } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import type { InputProblem } from "lib/types/InputProblem"
+import { evaluateRailGroup } from "./sameNetRailAlignment/evaluateRailGroup"
+import { getRailGroups } from "./sameNetRailAlignment/getRailGroups"
+import type { AlignmentCandidate } from "./sameNetRailAlignment/types"
+
+interface AlignSameNetRailsInput {
+  inputProblem: InputProblem
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  eligibleTraceIds: ReadonlySet<string>
+}
+
+export const alignSameNetRails = ({
+  inputProblem,
+  traces,
+  netLabelPlacements,
+  eligibleTraceIds,
+}: AlignSameNetRailsInput): {
+  traces: SolvedTracePath[]
+  alignedRailGroupCount: number
+  alignedTraceCount: number
+} => {
+  let outputTraces = [...traces]
+  const obstacles = getObstacleRects(inputProblem)
+  const alignedTraceIds = new Set<string>()
+  let alignedRailGroupCount = 0
+  const maximumPasses = Math.max(
+    1,
+    traces.reduce((sum, trace) => sum + trace.tracePath.length, 0),
+  )
+
+  for (let pass = 0; pass < maximumPasses; pass++) {
+    const groups = getRailGroups(
+      outputTraces,
+      eligibleTraceIds,
+      inputProblem,
+      obstacles,
+    )
+    let applied: AlignmentCandidate | null = null
+
+    for (const group of groups) {
+      applied = evaluateRailGroup({
+        group,
+        traces: outputTraces,
+        netLabelPlacements,
+        obstacles,
+        eligibleTraceIds,
+      })
+      if (applied) break
+    }
+    if (!applied) break
+
+    outputTraces = applied.traces
+    alignedRailGroupCount++
+    for (const traceId of applied.changedTraceIds) alignedTraceIds.add(traceId)
+  }
+
+  return {
+    traces: outputTraces,
+    alignedRailGroupCount,
+    alignedTraceCount: alignedTraceIds.size,
+  }
+}

package/lib/solvers/TraceCleanupSolver/sameNetRailAlignment/evaluateRailGroup.ts

@@ -0,0 +1,124 @@
+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 type { ObstacleRect } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver2/rect"
+import { detectTraceLabelOverlap } from "lib/solvers/TraceLabelOverlapAvoidanceSolver/detectTraceLabelOverlap"
+import { doesPathCoincideWithTraces } from "lib/utils/doesPathCoincideWithTraces"
+import { getDistinctCoordinates, pointsEqual } from "./geometry"
+import { moveRailSegments } from "./moveRailSegments"
+import { preservesLabelAnchors } from "./preservesLabelAnchors"
+import {
+  getTraceGeometryMetrics,
+  isReadabilityImprovement,
+  scoreIsBetter,
+} from "./scoreRailAlignment"
+import type { AlignmentCandidate, AlignmentScore, RailSegment } from "./types"
+
+interface EvaluateRailGroupInput {
+  group: RailSegment[]
+  traces: SolvedTracePath[]
+  netLabelPlacements: NetLabelPlacement[]
+  obstacles: ObstacleRect[]
+  eligibleTraceIds: ReadonlySet<string>
+}
+
+const tracePathChanged = (
+  original: SolvedTracePath,
+  candidate: SolvedTracePath,
+) =>
+  original.tracePath.length !== candidate.tracePath.length ||
+  candidate.tracePath.some(
+    (point, index) => !pointsEqual(point, original.tracePath[index]!),
+  )
+
+export const evaluateRailGroup = ({
+  group,
+  traces,
+  netLabelPlacements,
+  obstacles,
+  eligibleTraceIds,
+}: EvaluateRailGroupInput): AlignmentCandidate | null => {
+  const groupTraceIds = new Set(group.map((segment) => segment.traceId))
+  const originalGroupTraces = traces.filter((trace) =>
+    groupTraceIds.has(trace.mspPairId),
+  )
+  const baseline = getTraceGeometryMetrics(originalGroupTraces, traces)
+  const coordinates = getDistinctCoordinates(
+    group.map((segment) => segment.coordinate),
+  )
+  const otherNetTraces = traces.filter(
+    (trace) => trace.globalConnNetId !== group[0]!.globalConnNetId,
+  )
+  const immutableSameNetTraces = traces.filter(
+    (trace) =>
+      trace.globalConnNetId === group[0]!.globalConnNetId &&
+      !eligibleTraceIds.has(trace.mspPairId),
+  )
+
+  let best: AlignmentCandidate | null = null
+  for (const coordinate of coordinates) {
+    const candidateMap = new Map<string, SolvedTracePath>()
+
+    for (const trace of originalGroupTraces) {
+      const candidateTrace = moveRailSegments(
+        trace,
+        group.filter((segment) => segment.traceId === trace.mspPairId),
+        coordinate,
+      )
+      candidateMap.set(trace.mspPairId, candidateTrace)
+    }
+
+    const candidateTraces = [...candidateMap.values()]
+    const allCandidateTraces = traces.map(
+      (trace) => candidateMap.get(trace.mspPairId) ?? trace,
+    )
+    const candidatesAreClear = candidateTraces.every(
+      (candidate) =>
+        !isPathCollidingWithObstacles(candidate.tracePath, obstacles) &&
+        detectTraceLabelOverlap({
+          traces: [candidate],
+          netLabels: netLabelPlacements,
+        }).length === 0 &&
+        !doesPathCoincideWithTraces(candidate.tracePath, otherNetTraces) &&
+        !doesPathCoincideWithTraces(
+          candidate.tracePath,
+          immutableSameNetTraces.filter(
+            (trace) => trace.mspPairId !== candidate.mspPairId,
+          ),
+        ),
+    )
+    if (!candidatesAreClear) continue
+    if (
+      !preservesLabelAnchors(netLabelPlacements, traces, allCandidateTraces)
+    ) {
+      continue
+    }
+
+    const metrics = getTraceGeometryMetrics(candidateTraces, allCandidateTraces)
+    if (metrics.otherNetCrossings > baseline.otherNetCrossings) continue
+    if (!isReadabilityImprovement(metrics, baseline)) continue
+
+    const score: AlignmentScore = {
+      ...metrics,
+      displacement: group.reduce(
+        (sum, segment) => sum + Math.abs(segment.coordinate - coordinate),
+        0,
+      ),
+      coordinate,
+    }
+    const changedTraceIds = candidateTraces
+      .filter((candidate) => {
+        const original = traces.find(
+          (trace) => trace.mspPairId === candidate.mspPairId,
+        )!
+        return tracePathChanged(original, candidate)
+      })
+      .map((trace) => trace.mspPairId)
+    if (changedTraceIds.length === 0) continue
+
+    const candidate = { traces: allCandidateTraces, changedTraceIds, score }
+    if (!best || scoreIsBetter(candidate.score, best.score)) best = candidate
+  }
+
+  return best
+}