@tscircuit/fanout-solver 0.0.35 → 0.0.37

package/lib/route-bus.ts

@@ -3,6 +3,12 @@ import type {
   SimpleRouteJson,
   SimplifiedPcbTrace,
 } from "@tscircuit/capacity-autorouter"
+import {
+  getCornerBandSide,
+  getDirectionForExitEdge,
+  getExitEdgeForDirection,
+} from "./boundary-exit"
+import { createFanoutOutputIds } from "./fanout-output-ids"
 import {
   distance,
   distancePointToObstacle,
@@ -10,13 +16,13 @@ import {
   distanceSegmentToObstacle,
   segmentsAreClear,
 } from "./geometry"
-import { createFanoutOutputIds } from "./fanout-output-ids"
 import { getAllRoutedTraceCopper } from "./get-routed-trace-copper"
 import { getLayerSpan } from "./layer-names"
 import {
   connectionsShareElectricalNet,
   obstacleSharesElectricalNet,
 } from "./net-identity"
+import { routeViaMinimalWinding } from "./route-via-minimal-winding"
 import type {
   Bounds,
   FanoutDirection,
@@ -72,6 +78,189 @@ function getPerpendicularAxis(
   return isHorizontal(direction) ? point.y : point.x
 }
 
+function getCornerSide(bus: PreparedBus): "minimum" | "maximum" | undefined {
+  return getCornerBandSide(bus.exitEdge, bus.preferredExit)
+}
+
+function getLocalCornerSide(
+  bus: PreparedBus,
+): "minimum" | "maximum" | undefined {
+  return getCornerBandSide(
+    getExitEdgeForDirection(bus.direction),
+    bus.preferredExit,
+  )
+}
+
+function busUsesCoordinatedWindingChannel(bus: PreparedBus): boolean {
+  return Boolean(
+    bus.exitEdge &&
+      bus.termination.type === "boundary" &&
+      bus.connections.length > 0 &&
+      bus.connections.every(
+        (connection) => connection.hasExplicitLayeredExitTarget === true,
+      ),
+  )
+}
+
+function getStableConnectionIdentity(
+  connection: PreparedConnection["connection"],
+): string {
+  if (
+    "source_trace_id" in connection &&
+    typeof connection.source_trace_id === "string"
+  ) {
+    return connection.source_trace_id
+  }
+  return connection.name
+}
+
+function getWindingTargetRank(params: {
+  bus: PreparedBus
+  connection: PreparedConnection
+  boundaryDirection: FanoutDirection
+  layerNames: readonly string[]
+}): { rank: number; connectionCount: number } {
+  const { bus, connection, boundaryDirection, layerNames } = params
+  const orderedConnections = bus.connections.toSorted((first, second) => {
+    const axisDifference =
+      getPerpendicularAxis(
+        first.exitTargetPoint ?? first.targetPoint,
+        boundaryDirection,
+      ) -
+      getPerpendicularAxis(
+        second.exitTargetPoint ?? second.targetPoint,
+        boundaryDirection,
+      )
+    if (axisDifference !== 0) return axisDifference
+
+    // Equal target coordinates came from distinct target layers and do not
+    // impose a physical order after this bus is collapsed onto one escape
+    // layer. Keep that free choice independent of allowed-layer ordering so
+    // the local fanout can choose a deterministic, via-minimal permutation.
+    const identityDifference = first.connection.name.localeCompare(
+      second.connection.name,
+    )
+    if (identityDifference !== 0) return identityDifference
+
+    const firstStableId = getStableConnectionIdentity(first.connection)
+    const secondStableId = getStableConnectionIdentity(second.connection)
+    const stableIdentityDifference = firstStableId.localeCompare(secondStableId)
+    if (stableIdentityDifference !== 0) return stableIdentityDifference
+
+    const firstLayer = first.exitTargetPoint?.layer
+    const secondLayer = second.exitTargetPoint?.layer
+    return (
+      layerNames.indexOf(firstLayer ?? "") -
+        layerNames.indexOf(secondLayer ?? "") ||
+      first.connectionIndex - second.connectionIndex
+    )
+  })
+  const rank = orderedConnections.findIndex(
+    (candidate) => candidate.connectionIndex === connection.connectionIndex,
+  )
+  if (rank < 0) {
+    throw new Error(
+      `FanoutSolver: connection "${connection.connection.name}" is missing from winding order`,
+    )
+  }
+  return { rank, connectionCount: orderedConnections.length }
+}
+
+function getWindingCrossoverLayer(params: {
+  bus: PreparedBus
+  escapeLayer: string
+}): string | undefined {
+  const { bus, escapeLayer } = params
+  return (bus.routableEscapeLayers ?? bus.allowedLayers)?.find(
+    (layer) => layer !== escapeLayer,
+  )
+}
+
+function getCornerTargetTrack(params: {
+  bus: PreparedBus
+  connection: PreparedConnection
+  cornerExitLaneOffset: number
+  traceWidth: number
+  viaDiameter: number
+  clearance: number
+  layerNames: readonly string[]
+}): number {
+  const {
+    bus,
+    connection,
+    cornerExitLaneOffset,
+    traceWidth,
+    viaDiameter,
+    clearance,
+    layerNames,
+  } = params
+  const side = getCornerSide(bus)
+  if (!side || !bus.exitEdge) {
+    return getPerpendicularAxis(
+      connection.exitTargetPoint ?? connection.targetPoint,
+      bus.direction,
+    )
+  }
+  const boundaryDirection = getDirectionForExitEdge(bus.exitEdge)
+  const boundaryMinimum = isHorizontal(boundaryDirection)
+    ? bus.sharedBoundary.minY
+    : bus.sharedBoundary.minX
+  const boundaryMaximum = isHorizontal(boundaryDirection)
+    ? bus.sharedBoundary.maxY
+    : bus.sharedBoundary.maxX
+  const pitch = Math.max(traceWidth + clearance, viaDiameter + clearance)
+  const baseBandCenter =
+    boundaryMinimum +
+    (boundaryMaximum - boundaryMinimum) * (side === "minimum" ? 0.25 : 0.75)
+  const windingTarget = busUsesCoordinatedWindingChannel(bus)
+    ? getWindingTargetRank({
+        bus,
+        connection,
+        boundaryDirection,
+        layerNames,
+      })
+    : undefined
+  const bandConnectionCount = Math.max(
+    bus.connections.length,
+    bus.cornerBandConnectionCount ?? bus.connections.length,
+    cornerExitLaneOffset + (windingTarget?.connectionCount ?? 0),
+  )
+  const firstTrack = baseBandCenter - ((bandConnectionCount - 1) * pitch) / 2
+  const rank = windingTarget?.rank ?? getConnectionRank(bus, connection)
+  const globalSlot = cornerExitLaneOffset + rank
+  const reverseSlotOrder =
+    !windingTarget &&
+    (side === "maximum") === directionSign(boundaryDirection) > 0
+  const orientedSlot = reverseSlotOrder
+    ? bandConnectionCount - 1 - globalSlot
+    : globalSlot
+  return firstTrack + orientedSlot * pitch
+}
+
+function getCornerLaneOffsets(
+  bus: PreparedBus,
+  acceptedPlans: readonly FanoutRoutePlan[],
+): { exit: number; localChannel: number; boundaryChannel: number } {
+  const side = getCornerSide(bus)
+  if (!side || !bus.exitEdge) {
+    return { exit: 0, localChannel: 0, boundaryChannel: 0 }
+  }
+  const cornerPlans = acceptedPlans.filter(
+    (plan) => plan.exitEdge && plan.cornerBandSide !== undefined,
+  )
+  const plansOnExitEdge = cornerPlans.filter(
+    (plan) => plan.exitEdge === bus.exitEdge && plan.cornerBandSide === side,
+  )
+  const plansOnLocalEdge = cornerPlans.filter(
+    (plan) => plan.direction === bus.direction,
+  )
+  return {
+    exit: plansOnExitEdge.length,
+    localChannel: plansOnLocalEdge.length,
+    boundaryChannel: plansOnExitEdge.length,
+  }
+}
+
 function makePoint(
   axis: number,
   perpendicularAxis: number,
@@ -82,8 +271,11 @@ function makePoint(
     : { x: perpendicularAxis, y: axis }
 }
 
-function getExitAxis(bus: PreparedBus): number {
-  switch (bus.direction) {
+function getExitAxis(
+  bus: PreparedBus,
+  direction: FanoutDirection = bus.direction,
+): number {
+  switch (direction) {
     case "right":
       return bus.sharedBoundary.maxX
     case "left":
@@ -296,10 +488,16 @@ function getPreferredTrack(params: {
   connection: PreparedConnection
   traceWidth: number
 }): number {
-  const preferredTrack = getPerpendicularAxis(
-    params.connection.exitTargetPoint ?? params.connection.targetPoint,
-    params.bus.direction,
-  )
+  const preferredTrack =
+    getCornerSide(params.bus) || busUsesCoordinatedWindingChannel(params.bus)
+      ? getPerpendicularAxis(
+          params.connection.sourcePoint,
+          params.bus.direction,
+        )
+      : getPerpendicularAxis(
+          params.connection.exitTargetPoint ?? params.connection.targetPoint,
+          params.bus.direction,
+        )
   const boundaryMinimum = isHorizontal(params.bus.direction)
     ? params.bus.sharedBoundary.minY
     : params.bus.sharedBoundary.minX
@@ -481,46 +679,31 @@ function chamferOrthogonalPolyline(
   return chamfered
 }
 
-function buildPlan(params: {
+function getInitialViaPoint(params: {
   preparedConnection: PreparedConnection
   bus: PreparedBus
   targetLayer: string
-  track: number
-  exitAxis: number
-  layerNames: string[]
   traceWidth: number
   viaDiameter: number
-  viaHoleDiameter: number
-  viaHandedness: ViaHandedness
-  interstitialEscape: boolean
-  spreadLaneIndex: number
   clearance: number
-  terminateAtVia: boolean
-}): FanoutRoutePlan {
+  viaHandedness: ViaHandedness
+}): Point2D {
   const {
     preparedConnection,
     bus,
     targetLayer,
-    track,
-    exitAxis,
-    layerNames,
     traceWidth,
     viaDiameter,
-    viaHoleDiameter,
-    viaHandedness,
-    interstitialEscape,
-    spreadLaneIndex,
     clearance,
-    terminateAtVia,
+    viaHandedness,
   } = params
   const sourcePoint = {
     x: preparedConnection.sourcePoint.x,
     y: preparedConnection.sourcePoint.y,
   }
-  const sign = directionSign(bus.direction)
+  const targetUsesVia = targetLayer !== preparedConnection.sourceLayer
   const directionalPitch = getDirectionalPitch(bus)
   const perpendicularPitch = getPerpendicularPitch(bus)
-  const targetUsesVia = targetLayer !== preparedConnection.sourceLayer
   const directionalPadSize = isHorizontal(bus.direction)
     ? preparedConnection.sourceObstacle.width
     : preparedConnection.sourceObstacle.height
@@ -539,14 +722,77 @@ function buildPlan(params: {
               1e-3,
           )
   const viaAxis =
-    getAxis(sourcePoint, bus.direction) + sign * initialEscapeDistance
-  const sourcePerpendicularAxis = getPerpendicularAxis(
-    sourcePoint,
-    bus.direction,
-  )
+    getAxis(sourcePoint, bus.direction) +
+    directionSign(bus.direction) * initialEscapeDistance
   const viaPerpendicularAxis =
-    sourcePerpendicularAxis + viaHandedness * perpendicularPitch * 0.5
-  const viaPoint = makePoint(viaAxis, viaPerpendicularAxis, bus.direction)
+    getPerpendicularAxis(sourcePoint, bus.direction) +
+    viaHandedness * perpendicularPitch * 0.5
+  return makePoint(viaAxis, viaPerpendicularAxis, bus.direction)
+}
+
+function buildPlan(params: {
+  preparedConnection: PreparedConnection
+  bus: PreparedBus
+  targetLayer: string
+  track: number
+  exitAxis: number
+  layerNames: string[]
+  traceWidth: number
+  viaDiameter: number
+  viaHoleDiameter: number
+  viaHandedness: ViaHandedness
+  interstitialEscape: boolean
+  spreadLaneIndex: number
+  cornerExitLaneOffset: number
+  cornerLocalChannelLaneOffset: number
+  cornerBoundaryChannelLaneOffset: number
+  clearance: number
+  terminateAtVia: boolean
+}): FanoutRoutePlan {
+  const {
+    preparedConnection,
+    bus,
+    targetLayer,
+    track,
+    exitAxis,
+    layerNames,
+    traceWidth,
+    viaDiameter,
+    viaHoleDiameter,
+    viaHandedness,
+    interstitialEscape,
+    spreadLaneIndex,
+    cornerExitLaneOffset,
+    cornerLocalChannelLaneOffset,
+    cornerBoundaryChannelLaneOffset,
+    clearance,
+    terminateAtVia,
+  } = params
+  const sourcePoint = {
+    x: preparedConnection.sourcePoint.x,
+    y: preparedConnection.sourcePoint.y,
+  }
+  const escapeLayer = targetLayer
+  const windingCrossoverLayer = busUsesCoordinatedWindingChannel(bus)
+    ? getWindingCrossoverLayer({
+        bus,
+        escapeLayer,
+      })
+    : undefined
+  const usesLayeredWindingChannel = Boolean(windingCrossoverLayer)
+  const sign = directionSign(bus.direction)
+  const directionalPitch = getDirectionalPitch(bus)
+  const viaPoint = getInitialViaPoint({
+    preparedConnection,
+    bus,
+    targetLayer,
+    traceWidth,
+    viaDiameter,
+    clearance,
+    viaHandedness,
+  })
+  const viaAxis = getAxis(viaPoint, bus.direction)
+  const viaPerpendicularAxis = getPerpendicularAxis(viaPoint, bus.direction)
   const spreadLaneDistance =
     viaDiameter / 2 +
     traceWidth / 2 +
@@ -567,9 +813,81 @@ function buildPlan(params: {
     ? getAxis(spreadPoint, bus.direction)
     : viaAxis + sign * Math.abs(track - viaPerpendicularAxis)
   const doglegPoint = makePoint(targetLayerDoglegAxis, track, bus.direction)
+  const cornerSide = getCornerSide(bus)
+  const boundaryDirection = bus.exitEdge
+    ? getDirectionForExitEdge(bus.exitEdge)
+    : bus.direction
+  const boundarySign = directionSign(boundaryDirection)
+  const boundaryExitAxis = getExitAxis(bus, boundaryDirection)
+  const boundaryTargetTrack =
+    cornerSide && bus.exitEdge
+      ? getCornerTargetTrack({
+          bus,
+          connection: preparedConnection,
+          cornerExitLaneOffset,
+          traceWidth,
+          viaDiameter,
+          clearance,
+          layerNames,
+        })
+      : usesLayeredWindingChannel
+        ? getPerpendicularAxis(
+            preparedConnection.exitTargetPoint ??
+              preparedConnection.targetPoint,
+            boundaryDirection,
+          )
+        : track
+  const connectionRank = getConnectionRank(bus, preparedConnection)
+  const localCornerSide = getLocalCornerSide(bus)
+  const localChannelLaneIndex =
+    localCornerSide === "maximum"
+      ? cornerLocalChannelLaneOffset + connectionRank
+      : cornerLocalChannelLaneOffset +
+        bus.connections.length -
+        1 -
+        connectionRank
+  const globalBoundarySlot = cornerBoundaryChannelLaneOffset + connectionRank
+  const boundaryBandConnectionCount = Math.max(
+    bus.connections.length,
+    bus.cornerBandConnectionCount ?? bus.connections.length,
+  )
+  const boundaryChannelLaneIndex =
+    boundarySign > 0
+      ? globalBoundarySlot
+      : boundaryBandConnectionCount - 1 - globalBoundarySlot
+  const channelPitch = usesLayeredWindingChannel
+    ? viaDiameter / 2 + traceWidth / 2 + clearance
+    : traceWidth + clearance
+  const channelInset = (laneIndex: number) =>
+    viaDiameter / 2 + traceWidth / 2 + clearance + laneIndex * channelPitch
+  const localChannelAxis =
+    getExitAxis(bus, bus.direction) - sign * channelInset(localChannelLaneIndex)
+  const boundaryChannelAxis =
+    boundaryExitAxis - boundarySign * channelInset(boundaryChannelLaneIndex)
+  const localChannelSourcePoint = makePoint(
+    localChannelAxis,
+    track,
+    bus.direction,
+  )
+  const localChannelTargetPoint = makePoint(
+    boundaryChannelAxis,
+    localChannelAxis,
+    boundaryDirection,
+  )
+  const boundaryChannelTargetPoint = makePoint(
+    boundaryChannelAxis,
+    boundaryTargetTrack,
+    boundaryDirection,
+  )
+  const windingInputTransitionPoint =
+    isHorizontal(bus.direction) !== isHorizontal(boundaryDirection)
+      ? localChannelTargetPoint
+      : makePoint(boundaryChannelAxis, track, boundaryDirection)
   const exitPoint = terminateAtVia
     ? viaPoint
-    : makePoint(exitAxis, track, bus.direction)
+    : cornerSide || usesLayeredWindingChannel
+      ? makePoint(boundaryExitAxis, boundaryTargetTrack, boundaryDirection)
+      : makePoint(exitAxis, track, bus.direction)
   const segments: RoutedSegment[] = []
   const route: SimplifiedPcbTrace["route"] = []
 
@@ -629,25 +947,110 @@ function buildPlan(params: {
     })
   }
 
-  const targetLayerPoints = terminateAtVia
-    ? [viaPoint]
-    : useNestedSpread
-      ? chamferOrthogonalPolyline(
-          [viaPoint, spreadPoint, doglegPoint, exitPoint],
-          Math.max(traceWidth + clearance, traceWidth * 2),
-        )
-      : [viaPoint, doglegPoint, exitPoint]
-  for (let index = 1; index < targetLayerPoints.length; index++) {
-    const previousPoint = targetLayerPoints[index - 1]!
-    const nextPoint = targetLayerPoints[index]!
-    appendSegment(segments, previousPoint, nextPoint, traceWidth, targetLayer)
-    route.push({
-      route_type: "wire",
-      x: nextPoint.x,
-      y: nextPoint.y,
-      width: traceWidth,
-      layer: targetLayer,
-    })
+  const appendLayerPath = (points: Point2D[], layer: string): void => {
+    for (let index = 1; index < points.length; index++) {
+      const previousPoint = points[index - 1]!
+      const nextPoint = points[index]!
+      appendSegment(segments, previousPoint, nextPoint, traceWidth, layer)
+      route.push({
+        route_type: "wire",
+        x: nextPoint.x,
+        y: nextPoint.y,
+        width: traceWidth,
+        layer,
+      })
+    }
+  }
+
+  const additionalVias: NonNullable<FanoutRoutePlan["additionalVias"]> = []
+  if (usesLayeredWindingChannel && windingCrossoverLayer) {
+    const escapePoints = chamferOrthogonalPolyline(
+      [
+        viaPoint,
+        ...(useNestedSpread ? [spreadPoint] : []),
+        doglegPoint,
+        ...(isHorizontal(bus.direction) !== isHorizontal(boundaryDirection)
+          ? [localChannelSourcePoint]
+          : []),
+        windingInputTransitionPoint,
+      ],
+      Math.max(traceWidth + clearance, traceWidth * 2),
+    )
+    appendLayerPath(escapePoints, escapeLayer)
+
+    const appendTransitionVia = (
+      center: Point2D,
+      fromLayer: string,
+      toLayer: string,
+    ): void => {
+      if (fromLayer === toLayer) return
+      additionalVias.push({
+        center,
+        diameter: viaDiameter,
+        holeDiameter: viaHoleDiameter,
+        fromLayer,
+        toLayer,
+        spanLayers: getLayerSpan(fromLayer, toLayer, layerNames),
+      })
+      route.push({
+        route_type: "via",
+        x: center.x,
+        y: center.y,
+        from_layer: fromLayer,
+        to_layer: toLayer,
+        via_diameter: viaDiameter,
+        via_hole_diameter: viaHoleDiameter,
+      })
+      route.push({
+        route_type: "wire",
+        x: center.x,
+        y: center.y,
+        width: traceWidth,
+        layer: toLayer,
+      })
+    }
+
+    appendTransitionVia(
+      windingInputTransitionPoint,
+      escapeLayer,
+      windingCrossoverLayer,
+    )
+    appendLayerPath(
+      [windingInputTransitionPoint, boundaryChannelTargetPoint],
+      windingCrossoverLayer,
+    )
+    appendTransitionVia(
+      boundaryChannelTargetPoint,
+      windingCrossoverLayer,
+      escapeLayer,
+    )
+    appendLayerPath([boundaryChannelTargetPoint, exitPoint], escapeLayer)
+  } else {
+    const targetLayerPoints = terminateAtVia
+      ? [viaPoint]
+      : cornerSide
+        ? chamferOrthogonalPolyline(
+            [
+              viaPoint,
+              ...(useNestedSpread ? [spreadPoint] : []),
+              doglegPoint,
+              localChannelSourcePoint,
+              ...(isHorizontal(bus.direction) !==
+              isHorizontal(boundaryDirection)
+                ? [localChannelTargetPoint]
+                : []),
+              boundaryChannelTargetPoint,
+              exitPoint,
+            ],
+            Math.max(traceWidth + clearance, traceWidth * 2),
+          )
+        : useNestedSpread
+          ? chamferOrthogonalPolyline(
+              [viaPoint, spreadPoint, doglegPoint, exitPoint],
+              Math.max(traceWidth + clearance, traceWidth * 2),
+            )
+          : [viaPoint, doglegPoint, exitPoint]
+    appendLayerPath(targetLayerPoints, escapeLayer)
   }
 
   const outputIds = createFanoutOutputIds({
@@ -663,9 +1066,11 @@ function buildPlan(params: {
     sourceObstacle: preparedConnection.sourceObstacle,
     sourceLayer: preparedConnection.sourceLayer,
     targetPoint: preparedConnection.targetPoint,
-    targetLayer,
+    targetLayer: escapeLayer,
     termination: bus.termination,
     direction: bus.direction,
+    ...(bus.exitEdge ? { exitEdge: bus.exitEdge } : {}),
+    ...(cornerSide ? { cornerBandSide: cornerSide } : {}),
     exitPoint,
     trace: {
       type: "pcb_trace",
@@ -684,6 +1089,7 @@ function buildPlan(params: {
     },
     segments,
     via,
+    ...(additionalVias.length > 0 ? { additionalVias } : {}),
     length: segments.reduce(
       (total, segment) => total + distance(segment.start, segment.end),
       0,
@@ -941,9 +1347,11 @@ function getPlanSegments(plan: FanoutRoutePlan): RoutedSegment[] {
 }
 
 function getPlanVias(plan: FanoutRoutePlan) {
-  return [plan.via, plan.planeEndpointVia].filter(
-    (via): via is NonNullable<FanoutRoutePlan["via"]> => Boolean(via),
-  )
+  return [
+    plan.via,
+    ...(plan.additionalVias ?? []),
+    plan.planeEndpointVia,
+  ].filter((via): via is NonNullable<FanoutRoutePlan["via"]> => Boolean(via))
 }
 
 function planIsStaticallyClear(params: {
@@ -1314,6 +1722,9 @@ function routePlaneTerminatedBus(
             viaHandedness,
             interstitialEscape: !pairChannelFitsVia,
             spreadLaneIndex: 0,
+            cornerExitLaneOffset: 0,
+            cornerLocalChannelLaneOffset: 0,
+            cornerBoundaryChannelLaneOffset: 0,
             clearance,
             terminateAtVia: true,
           })
@@ -1415,6 +1826,7 @@ export function routeBusAlternatives(
 
   const alternatives: FanoutRoutePlan[][] = []
   const seenAlternativeKeys = new Set<string>()
+  const cornerLaneOffsets = getCornerLaneOffsets(bus, acceptedPlans)
 
   const addAlternative = (plans: FanoutRoutePlan[]): void => {
     const key = plans
@@ -1428,6 +1840,75 @@ export function routeBusAlternatives(
     alternatives.push(plans)
   }
 
+  if (busUsesCoordinatedWindingChannel(bus) && bus.exitEdge) {
+    const boundaryDirection = getDirectionForExitEdge(bus.exitEdge)
+    const boundaryExitAxis = getExitAxis(bus, boundaryDirection)
+    const cornerSide = getCornerSide(bus)
+    for (const viaHandedness of viaHandednesses) {
+      const terminals = bus.connections.map((preparedConnection) => {
+        const boundaryTrack = cornerSide
+          ? getCornerTargetTrack({
+              bus,
+              connection: preparedConnection,
+              cornerExitLaneOffset: cornerLaneOffsets.exit,
+              traceWidth,
+              viaDiameter,
+              clearance,
+              layerNames,
+            })
+          : getPerpendicularAxis(
+              preparedConnection.exitTargetPoint ??
+                preparedConnection.targetPoint,
+              boundaryDirection,
+            )
+        return {
+          connection: preparedConnection,
+          viaPoint: getInitialViaPoint({
+            preparedConnection,
+            bus,
+            targetLayer,
+            traceWidth,
+            viaDiameter,
+            clearance,
+            viaHandedness,
+          }),
+          exitPoint: makePoint(
+            boundaryExitAxis,
+            boundaryTrack,
+            boundaryDirection,
+          ),
+        }
+      })
+      const viaMinimalPlans = routeViaMinimalWinding({
+        srj,
+        bus,
+        targetLayer,
+        terminals,
+        acceptedPlans,
+        layerNames,
+        traceWidth,
+        viaDiameter,
+        viaHoleDiameter,
+        clearance,
+        allowSameNetMerges,
+      })
+      if (
+        !viaMinimalPlans ||
+        !fanoutPlansAreClear({
+          plans: [...acceptedPlans, ...viaMinimalPlans],
+          srj,
+          sharedBoundary: bus.sharedBoundary,
+          clearance,
+          allowSameNetMerges,
+        })
+      ) {
+        continue
+      }
+      addAlternative(viaMinimalPlans)
+      if (alternatives.length >= maxAlternatives) return alternatives
+    }
+  }
+
   const searchConnectionOrder = (
     connectionOrder: PreparedConnection[],
     viaHandedness: ViaHandedness,
@@ -1501,6 +1982,9 @@ export function routeBusAlternatives(
           connectionRank,
           bus.connections.length - connectionRank - 1,
         ),
+        cornerExitLaneOffset: cornerLaneOffsets.exit,
+        cornerLocalChannelLaneOffset: cornerLaneOffsets.localChannel,
+        cornerBoundaryChannelLaneOffset: cornerLaneOffsets.boundaryChannel,
         clearance,
         terminateAtVia: false,
       })
@@ -1510,7 +1994,7 @@ export function routeBusAlternatives(
           otherPlans: [...acceptedPlans, ...candidatePlans],
           staticClearanceCache,
           blockingBusCounts,
-          cacheKey: `boundary:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${viaHandedness}:${trackIndex}`,
+          cacheKey: `boundary:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${viaHandedness}:${trackIndex}:${bus.exitEdge ?? "legacy"}:${cornerLaneOffsets.exit}:${cornerLaneOffsets.localChannel}:${cornerLaneOffsets.boundaryChannel}`,
           srj,
           sharedBoundary: bus.sharedBoundary,
           clearance,