@tscircuit/fanout-solver 0.0.21 → 0.0.22

package/lib/route-bus.ts

@@ -24,6 +24,7 @@ import type {
   PreparedConnection,
   RoutedSegment,
 } from "./types"
+import { segmentIsLegalTerminalBodyEscape } from "./validate-routed-copper-drc"
 
 export type RouteBusStaticClearanceCache = Map<string, boolean>
 
@@ -38,6 +39,7 @@ export interface RouteBusParams {
   viaHoleDiameter: number
   clearance: number
   compactBusTracks: boolean
+  preferOriginalEndpointTracks?: boolean
   allowSameNetMerges?: boolean
   staticClearanceCache?: RouteBusStaticClearanceCache
   blockingBusCounts?: Map<string, number>
@@ -294,6 +296,7 @@ function getPreferredTrack(params: {
   targetUsesVia: boolean
   interstitialEscape: boolean
   compactBusTracks: boolean
+  preferOriginalEndpointTracks: boolean
   traceWidth: number
   viaDiameter: number
   clearance: number
@@ -304,6 +307,7 @@ function getPreferredTrack(params: {
     targetUsesVia,
     interstitialEscape,
     compactBusTracks,
+    preferOriginalEndpointTracks,
     traceWidth,
     viaDiameter,
     clearance,
@@ -315,6 +319,9 @@ function getPreferredTrack(params: {
     connection.sourcePoint,
     bus.direction,
   )
+  if (preferOriginalEndpointTracks) {
+    return getPerpendicularAxis(connection.targetPoint, bus.direction)
+  }
   if (compactBusTracks) {
     const connectionRank = getConnectionRank(bus, connection)
     const componentCenter =
@@ -635,6 +642,7 @@ function buildPlan(params: {
     sourcePoint: preparedConnection.sourcePoint,
     sourceObstacle: preparedConnection.sourceObstacle,
     sourceLayer: preparedConnection.sourceLayer,
+    targetPoint: preparedConnection.targetPoint,
     targetLayer,
     termination: bus.termination,
     direction: bus.direction,
@@ -663,6 +671,193 @@ function buildPlan(params: {
   }
 }
 
+function getPointLayer(point: PreparedConnection["targetPoint"]): string {
+  const layer = "layer" in point ? point.layer : point.layers[0]
+  if (!layer) {
+    throw new Error("FanoutSolver: plane endpoint has no copper layer")
+  }
+  return layer
+}
+
+function getPlaneEndpointViaCandidates(params: {
+  preparedConnection: PreparedConnection
+  bus: PreparedBus
+  viaDiameter: number
+  clearance: number
+}): Point2D[] {
+  const { preparedConnection, bus, viaDiameter, clearance } = params
+  const { sourcePoint, targetPoint } = preparedConnection
+  const nearbyEndpointLimit = Math.max(bus.pitchX, bus.pitchY) * 0.5
+  if (
+    distance(sourcePoint, targetPoint) <= 1e-6 ||
+    distance(sourcePoint, targetPoint) > nearbyEndpointLimit
+  ) {
+    return []
+  }
+
+  const preferred = (() => {
+    switch (bus.direction) {
+      case "left":
+        return { x: -1, y: 0 }
+      case "right":
+        return { x: 1, y: 0 }
+      case "up":
+        return { x: 0, y: 1 }
+      case "down":
+        return { x: 0, y: -1 }
+    }
+  })()
+  const diagonal = Math.SQRT1_2
+  const directions = [
+    preferred,
+    ...[
+      { x: diagonal, y: diagonal },
+      { x: diagonal, y: -diagonal },
+      { x: -diagonal, y: diagonal },
+      { x: -diagonal, y: -diagonal },
+      { x: 1, y: 0 },
+      { x: -1, y: 0 },
+      { x: 0, y: 1 },
+      { x: 0, y: -1 },
+    ].toSorted(
+      (first, second) =>
+        second.x * preferred.x +
+        second.y * preferred.y -
+        (first.x * preferred.x + first.y * preferred.y),
+    ),
+  ]
+  const minimumRadius = Math.max(viaDiameter, viaDiameter / 2 + clearance)
+  const radii = [
+    minimumRadius,
+    Math.max(minimumRadius, Math.min(bus.pitchX, bus.pitchY) * 0.5),
+    Math.max(minimumRadius, Math.min(bus.pitchX, bus.pitchY) * 0.625),
+    Math.max(minimumRadius, Math.min(bus.pitchX, bus.pitchY) * 0.75),
+  ]
+  const candidates: Point2D[] = []
+  for (const origin of [sourcePoint, targetPoint]) {
+    for (const radius of radii) {
+      for (const direction of directions) {
+        const candidate = {
+          x: origin.x + direction.x * radius,
+          y: origin.y + direction.y * radius,
+        }
+        if (
+          distance(candidate, sourcePoint) <= 1e-6 ||
+          distance(candidate, targetPoint) <= 1e-6 ||
+          candidates.some((existing) => distance(existing, candidate) <= 1e-6)
+        ) {
+          continue
+        }
+        candidates.push(candidate)
+      }
+    }
+  }
+  return candidates
+}
+
+function addPlaneEndpointTerminal(params: {
+  plan: FanoutRoutePlan
+  preparedConnection: PreparedConnection
+  planeLayer: string
+  viaPoint: Point2D
+  layerNames: string[]
+  traceWidth: number
+  viaDiameter: number
+  viaHoleDiameter: number
+}): FanoutRoutePlan {
+  const {
+    plan,
+    preparedConnection,
+    planeLayer,
+    viaPoint,
+    layerNames,
+    traceWidth,
+    viaDiameter,
+    viaHoleDiameter,
+  } = params
+  const targetPoint = {
+    x: preparedConnection.targetPoint.x,
+    y: preparedConnection.targetPoint.y,
+  }
+  const targetEndpointLayer = getPointLayer(preparedConnection.targetPoint)
+  const spanLayers = getLayerSpan(planeLayer, targetEndpointLayer, layerNames)
+  if (!spanLayers.includes(planeLayer)) {
+    throw new Error(
+      `FanoutSolver: via for "${preparedConnection.connection.name}" does not cross plane ${planeLayer}`,
+    )
+  }
+  const planeEndpointSegments: RoutedSegment[] = [
+    {
+      start: viaPoint,
+      end: targetPoint,
+      width: traceWidth,
+      layer: targetEndpointLayer,
+    },
+  ]
+  const via = {
+    center: viaPoint,
+    diameter: viaDiameter,
+    holeDiameter: viaHoleDiameter,
+    fromLayer: planeLayer,
+    toLayer: targetEndpointLayer,
+    spanLayers,
+  }
+  const planeEndpointTrace: SimplifiedPcbTrace = {
+    type: "pcb_trace",
+    pcb_trace_id: `fanout-plane-endpoint:${preparedConnection.connection.name}`,
+    connection_name: preparedConnection.connection.name,
+    connectsTo: [
+      preparedConnection.connection.name,
+      ...(preparedConnection.targetPoint.pointId
+        ? [preparedConnection.targetPoint.pointId]
+        : []),
+      ...(preparedConnection.targetPoint.pcb_port_id
+        ? [preparedConnection.targetPoint.pcb_port_id]
+        : []),
+    ],
+    route: [
+      {
+        route_type: "wire",
+        ...viaPoint,
+        width: traceWidth,
+        layer: planeLayer,
+      },
+      {
+        route_type: "via",
+        ...viaPoint,
+        from_layer: planeLayer,
+        to_layer: targetEndpointLayer,
+        via_diameter: viaDiameter,
+        via_hole_diameter: viaHoleDiameter,
+      },
+      {
+        route_type: "wire",
+        ...viaPoint,
+        width: traceWidth,
+        layer: targetEndpointLayer,
+      },
+      {
+        route_type: "wire",
+        ...targetPoint,
+        width: traceWidth,
+        layer: targetEndpointLayer,
+      },
+    ],
+  }
+  return {
+    ...plan,
+    planeEndpointTrace,
+    planeEndpointSegments,
+    planeEndpointVia: via,
+    length:
+      plan.length +
+      planeEndpointSegments.reduce(
+        (total, segment) => total + distance(segment.start, segment.end),
+        0,
+      ),
+  }
+}
+
 function segmentIsClearOfObstacles(params: {
   segment: RoutedSegment
   plan: FanoutRoutePlan
@@ -690,6 +885,16 @@ function segmentIsClearOfObstacles(params: {
     ) {
       continue
     }
+    if (
+      segmentIsLegalTerminalBodyEscape({
+        inputSrj: srj,
+        segment,
+        bodyObstacle: obstacle,
+        connectionName: plan.connectionName,
+      })
+    ) {
+      continue
+    }
     if (
       segmentIndex === 0 &&
       obstacle === plan.sourceObstacle &&
@@ -707,6 +912,16 @@ function segmentIsClearOfObstacles(params: {
   return true
 }
 
+function getPlanSegments(plan: FanoutRoutePlan): RoutedSegment[] {
+  return [...plan.segments, ...(plan.planeEndpointSegments ?? [])]
+}
+
+function getPlanVias(plan: FanoutRoutePlan) {
+  return [plan.via, plan.planeEndpointVia].filter(
+    (via): via is NonNullable<FanoutRoutePlan["via"]> => Boolean(via),
+  )
+}
+
 function planIsStaticallyClear(params: {
   plan: FanoutRoutePlan
   srj: SimpleRouteJson
@@ -718,7 +933,7 @@ function planIsStaticallyClear(params: {
   const routableBounds = getRoutableBounds(srj.bounds, sharedBoundary)
   if (
     !pointIsInsideBounds(plan.exitPoint, routableBounds) ||
-    plan.segments.some(
+    getPlanSegments(plan).some(
       (segment) =>
         !pointIsInsideBounds(segment.start, routableBounds) ||
         !pointIsInsideBounds(segment.end, routableBounds),
@@ -726,12 +941,13 @@ function planIsStaticallyClear(params: {
   ) {
     return false
   }
-  for (let index = 0; index < plan.segments.length; index++) {
+  const segments = getPlanSegments(plan)
+  for (let index = 0; index < segments.length; index++) {
     if (
       !segmentIsClearOfObstacles({
-        segment: plan.segments[index]!,
+        segment: segments[index]!,
         plan,
-        segmentIndex: index,
+        segmentIndex: index < plan.segments.length ? index : -1,
         srj,
         allowSameNetMerges,
         obstacles: srj.obstacles,
@@ -741,11 +957,9 @@ function planIsStaticallyClear(params: {
       return false
     }
   }
-  if (plan.via) {
+  for (const via of getPlanVias(plan)) {
     for (const obstacle of srj.obstacles) {
-      if (
-        !obstacle.layers.some((layer) => plan.via!.spanLayers.includes(layer))
-      ) {
+      if (!obstacle.layers.some((layer) => via.spanLayers.includes(layer))) {
         continue
       }
       if (
@@ -755,8 +969,8 @@ function planIsStaticallyClear(params: {
         continue
       }
       if (
-        distancePointToObstacle(plan.via.center, obstacle) <
-        plan.via.diameter / 2 + clearance - 1e-9
+        distancePointToObstacle(via.center, obstacle) <
+        via.diameter / 2 + clearance - 1e-9
       ) {
         return false
       }
@@ -806,51 +1020,54 @@ function planIsClearOfPlans(params: {
         (blockingBusCounts.get(otherPlan.busId) ?? 0) + 1,
       )
     }
-    for (const segment of plan.segments) {
-      for (const otherSegment of otherPlan.segments) {
+    const planSegments = getPlanSegments(plan)
+    const otherSegments = getPlanSegments(otherPlan)
+    const planVias = getPlanVias(plan)
+    const otherVias = getPlanVias(otherPlan)
+    for (const segment of planSegments) {
+      for (const otherSegment of otherSegments) {
         if (!segmentsAreClear(segment, otherSegment, clearance)) {
           recordBlocker()
           return false
         }
       }
-      if (
-        otherPlan.via?.spanLayers.includes(segment.layer) &&
-        distancePointToSegment(
-          otherPlan.via.center,
-          segment.start,
-          segment.end,
-        ) <
-          otherPlan.via.diameter / 2 + segment.width / 2 + clearance - 1e-9
-      ) {
-        recordBlocker()
-        return false
+      for (const otherVia of otherVias) {
+        if (
+          otherVia.spanLayers.includes(segment.layer) &&
+          distancePointToSegment(otherVia.center, segment.start, segment.end) <
+            otherVia.diameter / 2 + segment.width / 2 + clearance - 1e-9
+        ) {
+          recordBlocker()
+          return false
+        }
       }
     }
-    if (plan.via) {
-      for (const otherSegment of otherPlan.segments) {
+    for (const planVia of planVias) {
+      for (const otherSegment of otherSegments) {
         if (
-          plan.via.spanLayers.includes(otherSegment.layer) &&
+          planVia.spanLayers.includes(otherSegment.layer) &&
           distancePointToSegment(
-            plan.via.center,
+            planVia.center,
             otherSegment.start,
             otherSegment.end,
           ) <
-            plan.via.diameter / 2 + otherSegment.width / 2 + clearance - 1e-9
+            planVia.diameter / 2 + otherSegment.width / 2 + clearance - 1e-9
         ) {
           recordBlocker()
           return false
         }
       }
-      if (
-        otherPlan.via &&
-        plan.via.spanLayers.some((layer) =>
-          otherPlan.via!.spanLayers.includes(layer),
-        ) &&
-        distance(plan.via.center, otherPlan.via.center) <
-          (plan.via.diameter + otherPlan.via.diameter) / 2 + clearance - 1e-9
-      ) {
-        recordBlocker()
-        return false
+      for (const otherVia of otherVias) {
+        if (
+          planVia.spanLayers.some((layer) =>
+            otherVia.spanLayers.includes(layer),
+          ) &&
+          distance(planVia.center, otherVia.center) <
+            (planVia.diameter + otherVia.diameter) / 2 + clearance - 1e-9
+        ) {
+          recordBlocker()
+          return false
+        }
       }
     }
   }
@@ -971,60 +1188,93 @@ function routePlaneTerminatedBus(
   if (!sourceObstacle || bus.termination.type !== "plane") return null
   const sourceLayer = bus.connections[0]!.sourceLayer
   if (targetLayer === sourceLayer) return null
-  const directionalPadSize = isHorizontal(bus.direction)
-    ? sourceObstacle.width
-    : sourceObstacle.height
-  const pairChannelFitsVia =
-    getDirectionalPitch(bus) / 2 - directionalPadSize / 2 >=
-    viaDiameter / 2 + clearance - 1e-9
-  const viaHandednesses: readonly ViaHandedness[] = pairChannelFitsVia
-    ? [0]
-    : [1, -1]
 
-  for (const viaHandedness of viaHandednesses) {
-    for (const connectionOrder of getConnectionOrders(bus)) {
-      const candidatePlans: FanoutRoutePlan[] = []
-      let orderIsClear = true
-      for (const preparedConnection of connectionOrder) {
-        const sourceTrack = getPerpendicularAxis(
-          preparedConnection.sourcePoint,
-          bus.direction,
-        )
-        const plan = buildPlan({
-          preparedConnection,
-          bus,
-          targetLayer,
-          track: sourceTrack,
-          exitAxis: getExitAxis(bus),
-          layerNames,
-          traceWidth,
-          viaDiameter,
-          viaHoleDiameter,
-          viaHandedness,
-          interstitialEscape: !pairChannelFitsVia,
-          spreadLaneIndex: 0,
-          clearance,
-          terminateAtVia: true,
-        })
-        if (
-          !planIsClear({
-            plan,
-            otherPlans: [...acceptedPlans, ...candidatePlans],
-            staticClearanceCache,
-            blockingBusCounts,
-            cacheKey: `plane:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${viaHandedness}`,
-            srj,
-            sharedBoundary: bus.sharedBoundary,
+  const candidateDirections: FanoutDirection[] = [
+    bus.direction,
+    ...(["left", "right", "up", "down"] as const).filter(
+      (direction) => direction !== bus.direction,
+    ),
+  ]
+  for (const direction of candidateDirections) {
+    const directionalBus =
+      direction === bus.direction ? bus : { ...bus, direction }
+    const directionalPadSize = isHorizontal(direction)
+      ? sourceObstacle.width
+      : sourceObstacle.height
+    const pairChannelFitsVia =
+      getDirectionalPitch(directionalBus) / 2 - directionalPadSize / 2 >=
+      viaDiameter / 2 + clearance - 1e-9
+    const viaHandednesses: readonly ViaHandedness[] = pairChannelFitsVia
+      ? [0]
+      : [1, -1]
+
+    for (const viaHandedness of viaHandednesses) {
+      for (const connectionOrder of getConnectionOrders(directionalBus)) {
+        const candidatePlans: FanoutRoutePlan[] = []
+        let orderIsClear = true
+        for (const preparedConnection of connectionOrder) {
+          const sourceTrack = getPerpendicularAxis(
+            preparedConnection.sourcePoint,
+            direction,
+          )
+          const basePlan = buildPlan({
+            preparedConnection,
+            bus: directionalBus,
+            targetLayer,
+            track: sourceTrack,
+            exitAxis: getExitAxis(directionalBus),
+            layerNames,
+            traceWidth,
+            viaDiameter,
+            viaHoleDiameter,
+            viaHandedness,
+            interstitialEscape: !pairChannelFitsVia,
+            spreadLaneIndex: 0,
             clearance,
-            allowSameNetMerges,
+            terminateAtVia: true,
           })
-        ) {
-          orderIsClear = false
-          break
+          const endpointViaCandidates = getPlaneEndpointViaCandidates({
+            preparedConnection,
+            bus: directionalBus,
+            viaDiameter,
+            clearance,
+          })
+          const plansToTry = [
+            ...endpointViaCandidates.map((viaPoint) =>
+              addPlaneEndpointTerminal({
+                plan: basePlan,
+                preparedConnection,
+                planeLayer: targetLayer,
+                viaPoint,
+                layerNames,
+                traceWidth,
+                viaDiameter,
+                viaHoleDiameter,
+              }),
+            ),
+            basePlan,
+          ]
+          const plan = plansToTry.find((candidatePlan, candidateIndex) =>
+            planIsClear({
+              plan: candidatePlan,
+              otherPlans: [...acceptedPlans, ...candidatePlans],
+              staticClearanceCache,
+              blockingBusCounts,
+              cacheKey: `plane:${bus.busId}:${targetLayer}:${direction}:${preparedConnection.connectionIndex}:${viaHandedness}:${candidateIndex}`,
+              srj,
+              sharedBoundary: bus.sharedBoundary,
+              clearance,
+              allowSameNetMerges,
+            }),
+          )
+          if (!plan) {
+            orderIsClear = false
+            break
+          }
+          candidatePlans.push(plan)
         }
-        candidatePlans.push(plan)
+        if (orderIsClear) return candidatePlans
       }
-      if (orderIsClear) return candidatePlans
     }
   }
 
@@ -1046,6 +1296,7 @@ export function routeBusAlternatives(
     viaHoleDiameter,
     clearance,
     compactBusTracks,
+    preferOriginalEndpointTracks = false,
     staticClearanceCache,
     blockingBusCounts,
     allowSameNetMerges = false,
@@ -1117,6 +1368,7 @@ export function routeBusAlternatives(
         targetUsesVia,
         interstitialEscape,
         compactBusTracks,
+        preferOriginalEndpointTracks,
         traceWidth,
         viaDiameter,
         clearance,

package/lib/route-single-layer-adaptive-exits.ts

@@ -823,6 +823,7 @@ function buildPlan(route: FlowRoute, traceWidth: number): FanoutRoutePlan {
     sourcePoint: item.connection.sourcePoint,
     sourceObstacle: item.connection.sourceObstacle,
     sourceLayer: item.connection.sourceLayer,
+    targetPoint: item.connection.targetPoint,
     targetLayer: "top",
     termination: item.bus.termination,
     direction: item.bus.direction,

package/lib/route-single-layer-push-shove.ts

@@ -756,6 +756,7 @@ function buildPlan(path: RoutedPath): FanoutRoutePlan {
     sourcePoint: item.connection.sourcePoint,
     sourceObstacle: item.connection.sourceObstacle,
     sourceLayer: item.connection.sourceLayer,
+    targetPoint: item.connection.targetPoint,
     targetLayer: "top",
     termination: item.bus.termination,
     direction: item.direction,

package/lib/types.ts

@@ -6,6 +6,8 @@ import type {
   SimpleRouteJson,
   SimplifiedPcbTrace,
 } from "@tscircuit/capacity-autorouter"
+import type { OriginalEndpointConnectivityReport } from "./validate-original-endpoint-connectivity"
+import type { RoutedCopperDrcReport } from "./validate-routed-copper-drc"
 
 export type FanoutDirection = "left" | "right" | "up" | "down"
 
@@ -93,11 +95,20 @@ export interface FanoutSolverOptions {
   sharedBoundary?: Bounds
   escapeLayers?: string[]
   maxLayerCombinations?: number
+  /** Balance layer congestion by routed connection count instead of bus count. */
+  balanceLayerLoadByConnectionCount?: boolean
   traceWidth?: number
   viaDiameter?: number
   viaHoleDiameter?: number
   clearance?: number
   compactBusTracks?: boolean
+  /**
+   * Prefer the perpendicular coordinate of each original downstream endpoint
+   * when assigning boundary tracks. Ordered edge-pad buses can then enter
+   * same-layer pads directly instead of requiring a second global router to
+   * undo compacted fanout tracks.
+   */
+  preferOriginalEndpointTracks?: boolean
   /** Allow branches belonging to the same electrical net to share copper. */
   allowSameNetMerges?: boolean
   singleLayerPushAndShove?: boolean
@@ -108,6 +119,14 @@ export interface FanoutSolverOptions {
    */
   singleLayerAdaptiveExits?: boolean
   borderDistribution?: FanoutBorderDistribution
+  /**
+   * After every source pad is escaped, attempt to physically join the fanout
+   * copper to each original downstream endpoint. Every added trace is audited
+   * with the independent endpoint-connectivity and emitted-copper validators.
+   */
+  completeOriginalEndpoints?: boolean
+  /** Effort passed to the bounded downstream capacity-router pass. */
+  endpointCompletionEffort?: number
 }
 
 export interface FanoutAttemptSummary {
@@ -123,6 +142,8 @@ export interface FanoutAttemptSummary {
 export interface FanoutSolverOutput {
   simpleRouteJson: SimpleRouteJson
   fanoutTraces: SimplifiedPcbTrace[]
+  completionTraces: SimplifiedPcbTrace[]
+  endpointCompletion?: FanoutEndpointCompletionReport
   planeTerminations: FanoutPlaneTermination[]
   busLayerAssignments: Readonly<Record<string, string>>
   busDirections: Readonly<Record<string, FanoutDirection>>
@@ -130,6 +151,16 @@ export interface FanoutSolverOutput {
   validation: FanoutValidationReport
 }
 
+export interface FanoutEndpointCompletionReport {
+  attemptedLocalConnectionCount: number
+  attemptedDownstreamConnectionCount: number
+  completionTraceCount: number
+  searchPassCount: number
+  errors: string[]
+  connectivity: OriginalEndpointConnectivityReport
+  drc: RoutedCopperDrcReport
+}
+
 export interface FanoutValidationIssue {
   code:
     | "missing-plan"
@@ -227,6 +258,7 @@ export interface FanoutRoutePlan {
   sourcePoint: ConnectionPoint
   sourceObstacle: Obstacle
   sourceLayer: string
+  targetPoint: ConnectionPoint
   targetLayer: string
   termination: FanoutBusTermination
   direction: FanoutDirection
@@ -234,6 +266,10 @@ export interface FanoutRoutePlan {
   trace: SimplifiedPcbTrace
   segments: RoutedSegment[]
   via?: RoutedVia
+  /** Optional capacitor-side dogbone reserved and emitted with a plane escape. */
+  planeEndpointTrace?: SimplifiedPcbTrace
+  planeEndpointSegments?: RoutedSegment[]
+  planeEndpointVia?: RoutedVia
   length: number
 }
 
@@ -244,6 +280,20 @@ export interface FanoutPlaneTermination {
   via: RoutedVia
 }
 
+/**
+ * Declares an ideal copper plane used by emitted fanout traces. This metadata
+ * lets independent connectivity validation join same-net vias on the named
+ * layer without inventing a long point-to-point trace across the plane.
+ */
+export interface FanoutPlaneConnectivity {
+  connectionName: string
+  layer: string
+}
+
+export type SimpleRouteJsonWithFanoutPlanes = SimpleRouteJson & {
+  fanoutPlaneConnectivity?: FanoutPlaneConnectivity[]
+}
+
 export interface AssignmentAttempt {
   summary: FanoutAttemptSummary
   plans: FanoutRoutePlan[]