@tscircuit/schematic-trace-solver 0.0.97 → 0.0.98

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
+}

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

@@ -0,0 +1,108 @@
+import type { Point } from "@tscircuit/math-utils"
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import type { RailOrientation, RailSegment } from "./types"
+
+export const RAIL_ALIGNMENT_EPSILON = 2e-3
+
+export const nearlyEqual = (a: number, b: number) =>
+  Math.abs(a - b) < RAIL_ALIGNMENT_EPSILON
+
+export const isHorizontal = (a: Point, b: Point) => nearlyEqual(a.y, b.y)
+
+export const isVertical = (a: Point, b: Point) => nearlyEqual(a.x, b.x)
+
+const isPositiveLength = (a: Point, b: Point) =>
+  Math.abs(a.x - b.x) >= RAIL_ALIGNMENT_EPSILON ||
+  Math.abs(a.y - b.y) >= RAIL_ALIGNMENT_EPSILON
+
+export const getRailOrientation = (
+  a: Point,
+  b: Point,
+): RailOrientation | null => {
+  if (!isPositiveLength(a, b)) return null
+  if (isVertical(a, b)) return "vertical"
+  if (isHorizontal(a, b)) return "horizontal"
+  return null
+}
+
+export const rangesTouchOrOverlap = (a: RailSegment, b: RailSegment) =>
+  Math.min(a.maxAlong, b.maxAlong) - Math.max(a.minAlong, b.minAlong) >=
+  -RAIL_ALIGNMENT_EPSILON
+
+export const pointsEqual = (a: Point, b: Point) =>
+  nearlyEqual(a.x, b.x) && nearlyEqual(a.y, b.y)
+
+export const getDistinctCoordinates = (coordinates: number[]) => {
+  const distinct: number[] = []
+  for (const coordinate of coordinates) {
+    if (!distinct.some((item) => nearlyEqual(item, coordinate))) {
+      distinct.push(coordinate)
+    }
+  }
+  return distinct
+}
+
+interface Interval {
+  coordinate: number
+  min: number
+  max: number
+}
+
+const getMergedIntervalLength = (intervals: Interval[]) => {
+  const groups: Interval[][] = []
+  for (const interval of intervals) {
+    const group = groups.find((items) =>
+      nearlyEqual(items[0]!.coordinate, interval.coordinate),
+    )
+    if (group) group.push(interval)
+    else groups.push([interval])
+  }
+
+  return groups.reduce((total, group) => {
+    const sorted = [...group].sort((a, b) => a.min - b.min)
+    let groupLength = 0
+    let currentMin = sorted[0]!.min
+    let currentMax = sorted[0]!.max
+
+    for (const interval of sorted.slice(1)) {
+      if (interval.min <= currentMax + RAIL_ALIGNMENT_EPSILON) {
+        currentMax = Math.max(currentMax, interval.max)
+      } else {
+        groupLength += currentMax - currentMin
+        currentMin = interval.min
+        currentMax = interval.max
+      }
+    }
+
+    return total + groupLength + currentMax - currentMin
+  }, 0)
+}
+
+/** Returns rendered length after overlapping collinear runs are merged. */
+export const getVisibleTraceLength = (traces: SolvedTracePath[]) => {
+  const horizontal: Interval[] = []
+  const vertical: Interval[] = []
+
+  for (const trace of traces) {
+    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)) {
+        horizontal.push({
+          coordinate: start.y,
+          min: Math.min(start.x, end.x),
+          max: Math.max(start.x, end.x),
+        })
+      } else if (isVertical(start, end)) {
+        vertical.push({
+          coordinate: start.x,
+          min: Math.min(start.y, end.y),
+          max: Math.max(start.y, end.y),
+        })
+      }
+    }
+  }
+
+  return getMergedIntervalLength(horizontal) + getMergedIntervalLength(vertical)
+}

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

@@ -0,0 +1,121 @@
+import type { SolvedTracePath } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceLinesSolver"
+import { getPinDirection } from "lib/solvers/SchematicTraceLinesSolver/SchematicTraceSingleLineSolver/getPinDirection"
+import type { InputChip } from "lib/types/InputProblem"
+import type { FacingDirection } from "lib/utils/dir"
+import { getRailOrientation, RAIL_ALIGNMENT_EPSILON } from "./geometry"
+import type { RailSegment } from "./types"
+
+type UnassociatedRailSegment = Omit<
+  RailSegment,
+  "componentId" | "componentFacingDirection"
+>
+
+const getMovableRailSegments = (
+  trace: SolvedTracePath,
+): UnassociatedRailSegment[] => {
+  const segments: UnassociatedRailSegment[] = []
+  const path = trace.tracePath
+
+  for (let segmentIndex = 1; segmentIndex < path.length - 2; segmentIndex++) {
+    const previous = path[segmentIndex - 1]!
+    const start = path[segmentIndex]!
+    const end = path[segmentIndex + 1]!
+    const next = path[segmentIndex + 2]!
+    const orientation = getRailOrientation(start, end)
+    if (!orientation) continue
+
+    const previousOrientation = getRailOrientation(previous, start)
+    const nextOrientation = getRailOrientation(end, next)
+    if (!previousOrientation || !nextOrientation) continue
+    if (previousOrientation === orientation || nextOrientation === orientation)
+      continue
+
+    const alongValues =
+      orientation === "vertical" ? [start.y, end.y] : [start.x, end.x]
+    segments.push({
+      traceId: trace.mspPairId,
+      segmentIndex,
+      globalConnNetId: trace.globalConnNetId,
+      orientation,
+      coordinate: orientation === "vertical" ? start.x : start.y,
+      minAlong: Math.min(...alongValues),
+      maxAlong: Math.max(...alongValues),
+    })
+  }
+
+  return segments
+}
+
+const railIsOutsideComponent = (
+  segment: UnassociatedRailSegment,
+  chip: InputChip,
+  facingDirection: FacingDirection,
+) => {
+  const minX = chip.center.x - chip.width / 2
+  const maxX = chip.center.x + chip.width / 2
+  const minY = chip.center.y - chip.height / 2
+  const maxY = chip.center.y + chip.height / 2
+
+  switch (facingDirection) {
+    case "x-":
+      return (
+        segment.orientation === "vertical" &&
+        segment.coordinate <= minX + RAIL_ALIGNMENT_EPSILON
+      )
+    case "x+":
+      return (
+        segment.orientation === "vertical" &&
+        segment.coordinate >= maxX - RAIL_ALIGNMENT_EPSILON
+      )
+    case "y+":
+      return (
+        segment.orientation === "horizontal" &&
+        segment.coordinate >= maxY - RAIL_ALIGNMENT_EPSILON
+      )
+    case "y-":
+      return (
+        segment.orientation === "horizontal" &&
+        segment.coordinate <= minY + RAIL_ALIGNMENT_EPSILON
+      )
+  }
+}
+
+/** Associates each movable internal rail with the nearest component endpoint. */
+export const getComponentSideRailSegments = (
+  trace: SolvedTracePath,
+  chipMap: Map<string, InputChip>,
+): RailSegment[] => {
+  const segments: RailSegment[] = []
+
+  for (const segment of getMovableRailSegments(trace)) {
+    const associations = trace.pins.flatMap((pin, pinIndex) => {
+      const chip = chipMap.get(pin.chipId)
+      if (!chip) return []
+
+      const componentFacingDirection =
+        pin._facingDirection ?? getPinDirection(pin, chip)
+      if (!railIsOutsideComponent(segment, chip, componentFacingDirection)) {
+        return []
+      }
+
+      return [
+        {
+          componentId: chip.chipId,
+          componentFacingDirection,
+          distanceFromEndpoint:
+            pinIndex === 0
+              ? segment.segmentIndex
+              : trace.tracePath.length - 2 - segment.segmentIndex,
+        },
+      ]
+    })
+
+    associations.sort((a, b) => a.distanceFromEndpoint - b.distanceFromEndpoint)
+    const association = associations[0]
+    if (!association) continue
+
+    segments.push({ ...segment, ...association })
+  }
+
+  return segments
+}