@tscircuit/fanout-solver 0.0.49 → 0.0.51

package/lib/route-bus.ts

@@ -19,13 +19,14 @@ import {
 } from "./geometry"
 import { getAllRoutedTraceCopper } from "./get-routed-trace-copper"
 import { getViaSpanLayers } from "./layer-names"
+import { matchComponentDogboneViaSites } from "./match-component-dogbone-via-sites"
 import {
   connectionsShareElectricalNet,
   obstacleSharesElectricalNet,
 } from "./net-identity"
 import {
-  routeViaMinimalWindingAlternativesSteps,
   type RouteViaMinimalWindingProgress,
+  routeViaMinimalWindingAlternativesSteps,
   type ViaMinimalWindingReservedVia,
 } from "./route-via-minimal-winding"
 import type {
@@ -61,6 +62,16 @@ export interface RouteBusParams {
   fixedViaPointsByConnectionIndex?: ReadonlyMap<number, Point2D>
   reservedVias?: readonly ViaMinimalWindingReservedVia[]
   viaMinimalOnly?: boolean
+  /** Permit a singleton to move its provisional via near the boundary. */
+  allowBoundarySideViaFallback?: boolean
+  /** Retry blocked winding terminals ahead of already-routed terminals. */
+  adaptiveWindingRouteOrder?: boolean
+  /** Preserve pad-lattice channels in the automatic dense routing path. */
+  alignWindingGridToPads?: boolean
+  /** Bounds the final fixed-via winding fallback after ordered attempts. */
+  fixedViaFallbackRouteOrderAttempts?: number
+  /** Skip this many otherwise-clear plane escapes when enumerating alternatives. */
+  planeCandidateSkipCount?: number
   /** Dense corner-band phase that preserves existing lane centers when leading lanes are prepended. */
   cornerBandTargetTrackOffset?: number
 }
@@ -1873,6 +1884,24 @@ function planIsClearOfPlans(params: {
   return true
 }
 
+export function fanoutPlansAreMutuallyClear(params: {
+  plans: readonly FanoutRoutePlan[]
+  srj: SimpleRouteJson
+  clearance: number
+  allowSameNetMerges?: boolean
+}): boolean {
+  const { plans, srj, clearance, allowSameNetMerges = false } = params
+  return plans.every((plan, index) =>
+    planIsClearOfPlans({
+      plan,
+      otherPlans: plans.filter((_, otherIndex) => otherIndex !== index),
+      srj,
+      allowSameNetMerges,
+      clearance,
+    }),
+  )
+}
+
 function planIsClear(params: {
   plan: FanoutRoutePlan
   otherPlans: FanoutRoutePlan[]
@@ -1991,11 +2020,27 @@ function routePlaneTerminatedBus(
     allowBlindAndBuriedVias = true,
     allowSameNetMerges = false,
     fixedViaPointsByConnectionIndex,
+    planeCandidateSkipCount = 0,
   } = params
   const sourceObstacle = bus.connections[0]?.sourceObstacle
   if (!sourceObstacle || bus.termination.type !== "plane") return null
   const sourceLayer = bus.connections[0]!.sourceLayer
   if (targetLayer === sourceLayer) return null
+  let remainingPlaneCandidatesToSkip = planeCandidateSkipCount
+  const selectClearPlanePlan = (
+    plans: FanoutRoutePlan[],
+    isClear: (plan: FanoutRoutePlan, index: number) => boolean,
+  ): FanoutRoutePlan | undefined => {
+    for (const [index, plan] of plans.entries()) {
+      if (!isClear(plan, index)) continue
+      if (remainingPlaneCandidatesToSkip > 0) {
+        remainingPlaneCandidatesToSkip--
+        continue
+      }
+      return plan
+    }
+    return undefined
+  }
 
   if (fixedViaPointsByConnectionIndex) {
     const fixedPlans: FanoutRoutePlan[] = []
@@ -2052,19 +2097,21 @@ function routePlaneTerminatedBus(
         ),
         basePlan,
       ]
-      const clearPlan = plansToTry.find((candidatePlan, candidateIndex) =>
-        planIsClear({
-          plan: candidatePlan,
-          otherPlans: [...acceptedPlans, ...fixedPlans],
-          staticClearanceCache,
-          blockingBusCounts,
-          cacheKey: `plane-fixed:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${candidateIndex}`,
-          srj,
-          sharedBoundary: bus.sharedBoundary,
-          clearance,
-          allowBlindAndBuriedVias,
-          allowSameNetMerges,
-        }),
+      const clearPlan = selectClearPlanePlan(
+        plansToTry,
+        (candidatePlan, candidateIndex) =>
+          planIsClear({
+            plan: candidatePlan,
+            otherPlans: [...acceptedPlans, ...fixedPlans],
+            staticClearanceCache,
+            blockingBusCounts,
+            cacheKey: `plane-fixed:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${candidateIndex}`,
+            srj,
+            sharedBoundary: bus.sharedBoundary,
+            clearance,
+            allowBlindAndBuriedVias,
+            allowSameNetMerges,
+          }),
       )
       if (!clearPlan) return null
       fixedPlans.push(clearPlan)
@@ -2128,19 +2175,21 @@ function routePlaneTerminatedBus(
       ),
       viaInPadPlan,
     ]
-    const clearPlan = plansToTry.find((candidatePlan, candidateIndex) =>
-      planIsClear({
-        plan: candidatePlan,
-        otherPlans: acceptedPlans,
-        staticClearanceCache,
-        blockingBusCounts,
-        cacheKey: `plane-via-in-pad:${bus.busId}:${targetLayer}:${candidateIndex}`,
-        srj,
-        sharedBoundary: bus.sharedBoundary,
-        clearance,
-        allowBlindAndBuriedVias,
-        allowSameNetMerges,
-      }),
+    const clearPlan = selectClearPlanePlan(
+      plansToTry,
+      (candidatePlan, candidateIndex) =>
+        planIsClear({
+          plan: candidatePlan,
+          otherPlans: acceptedPlans,
+          staticClearanceCache,
+          blockingBusCounts,
+          cacheKey: `plane-via-in-pad:${bus.busId}:${targetLayer}:${candidateIndex}`,
+          srj,
+          sharedBoundary: bus.sharedBoundary,
+          clearance,
+          allowBlindAndBuriedVias,
+          allowSameNetMerges,
+        }),
     )
     if (clearPlan) return [clearPlan]
   }
@@ -2203,7 +2252,7 @@ function routePlaneTerminatedBus(
           )
           const perpendicularPitch = getPerpendicularPitch(directionalBus)
           const sourceEscapePaths: Point2D[][] = []
-          const maximumCandidatePaths = 32
+          const maximumCandidatePaths = 128
           for (
             let totalSteps = 0;
             totalSteps <= maximumEscapeSteps &&
@@ -2345,19 +2394,21 @@ function routePlaneTerminatedBus(
               ),
               basePlan,
             ]
-            plan = plansToTry.find((candidatePlan, candidateIndex) =>
-              planIsClear({
-                plan: candidatePlan,
-                otherPlans: [...acceptedPlans, ...candidatePlans],
-                staticClearanceCache,
-                blockingBusCounts,
-                cacheKey: `plane:${bus.busId}:${targetLayer}:${direction}:${preparedConnection.connectionIndex}:${viaHandedness}:${pathIndex}:${candidateIndex}`,
-                srj,
-                sharedBoundary: bus.sharedBoundary,
-                clearance,
-                allowBlindAndBuriedVias,
-                allowSameNetMerges,
-              }),
+            plan = selectClearPlanePlan(
+              plansToTry,
+              (candidatePlan, candidateIndex) =>
+                planIsClear({
+                  plan: candidatePlan,
+                  otherPlans: [...acceptedPlans, ...candidatePlans],
+                  staticClearanceCache,
+                  blockingBusCounts,
+                  cacheKey: `plane:${bus.busId}:${targetLayer}:${direction}:${preparedConnection.connectionIndex}:${viaHandedness}:${pathIndex}:${candidateIndex}`,
+                  srj,
+                  sharedBoundary: bus.sharedBoundary,
+                  clearance,
+                  allowBlindAndBuriedVias,
+                  allowSameNetMerges,
+                }),
             )
             if (plan) break
           }
@@ -2400,6 +2451,10 @@ export function* routeBusAlternativesSteps(
     fixedViaPointsByConnectionIndex,
     reservedVias = [],
     viaMinimalOnly = false,
+    allowBoundarySideViaFallback = false,
+    adaptiveWindingRouteOrder = false,
+    alignWindingGridToPads = false,
+    fixedViaFallbackRouteOrderAttempts = 24,
     cornerBandTargetTrackOffset,
   } = params
   if (!Number.isInteger(maxAlternatives) || maxAlternatives < 1) {
@@ -2417,8 +2472,20 @@ export function* routeBusAlternativesSteps(
     return []
   }
   if (bus.termination.type === "plane") {
-    const plan = routePlaneTerminatedBus(params)
-    return plan ? [plan] : []
+    const alternatives: FanoutRoutePlan[][] = []
+    for (
+      let planeCandidateSkipCount = 0;
+      planeCandidateSkipCount < maxAlternatives;
+      planeCandidateSkipCount++
+    ) {
+      const plan = routePlaneTerminatedBus({
+        ...params,
+        planeCandidateSkipCount,
+      })
+      if (!plan) break
+      alternatives.push(plan)
+    }
+    return alternatives
   }
   const exitAxis = getExitAxis(bus)
   const sourceObstacle = bus.connections[0]?.sourceObstacle
@@ -2666,8 +2733,36 @@ export function* routeBusAlternativesSteps(
       useViaInPad: true,
       getViaHandedness: () => 0 as const,
     }
+    const coordinatedViaPoints =
+      fixedViaPointsByConnectionIndex ??
+      (!allowBlindAndBuriedVias &&
+      bus.connections.length >= 8 &&
+      reservedVias.length === 0
+        ? matchComponentDogboneViaSites([bus], {
+            viaDiameter,
+            viaHoleDiameter,
+            traceWidth,
+            clearance,
+            additionalObstacles: srj.obstacles,
+            blockingSegments: acceptedPlans.flatMap((plan) =>
+              getPlanSegments(plan).map((segment) => ({
+                connectionIndex: plan.connectionIndex,
+                segment,
+              })),
+            ),
+            blockingVias: acceptedPlans.flatMap((plan) =>
+              getPlanVias(plan).map((via) => ({
+                connectionIndex: plan.connectionIndex,
+                ...via.center,
+                center: via.center,
+                diameter: via.diameter,
+                spanLayers: via.spanLayers,
+              })),
+            ),
+          })
+        : null)
     const fixedViaTerminalPatterns: CoordinatedTerminalPattern[] =
-      fixedViaPointsByConnectionIndex
+      coordinatedViaPoints
         ? [
             ...Array.from(
               { length: windingTargetOrderCount },
@@ -2676,9 +2771,7 @@ export function* routeBusAlternativesSteps(
                 useViaInPad: false,
                 getViaHandedness: () => 0 as const,
                 getViaPoint: (connection: PreparedConnection) =>
-                  fixedViaPointsByConnectionIndex.get(
-                    connection.connectionIndex,
-                  )!,
+                  coordinatedViaPoints.get(connection.connectionIndex)!,
                 maximumRouteOrderAttempts: 1,
                 windingOrderIndex,
                 preferTargetDirectedLaneBias: true,
@@ -2689,12 +2782,10 @@ export function* routeBusAlternativesSteps(
               useViaInPad: false,
               getViaHandedness: () => 0,
               getViaPoint: (connection) =>
-                fixedViaPointsByConnectionIndex.get(
-                  connection.connectionIndex,
-                )!,
+                coordinatedViaPoints.get(connection.connectionIndex)!,
               // Preserve the existing bounded search after every inexpensive
               // layer-interleave candidate has had one deterministic attempt.
-              maximumRouteOrderAttempts: maximumThroughAllRouteOrderAttempts,
+              maximumRouteOrderAttempts: fixedViaFallbackRouteOrderAttempts,
               windingOrderIndex: 0,
               preferTargetDirectedLaneBias: true,
             },
@@ -2789,9 +2880,13 @@ export function* routeBusAlternativesSteps(
           allowBlindAndBuriedVias,
           allowSameNetMerges,
           maximumRouteOrderAttempts: terminalPattern.maximumRouteOrderAttempts,
+          adaptiveRouteOrder: adaptiveWindingRouteOrder,
+          alignGridToPads:
+            alignWindingGridToPads ||
+            Boolean(coordinatedViaPoints && !fixedViaPointsByConnectionIndex),
           reservedVias,
           gridStepDivisor:
-            fixedViaPointsByConnectionIndex &&
+            coordinatedViaPoints &&
             Math.min(bus.pitchX, bus.pitchY) -
               2 * (viaDiameter / 2 + traceWidth / 2 + clearance) <
               traceWidth + clearance
@@ -2850,6 +2945,204 @@ export function* routeBusAlternativesSteps(
     }
   }
 
+  // A through-via does not have to sit next to the source pad. A singleton
+  // embedded in another bus's source field can have every local dogbone site
+  // occupied while still having a clear top-layer escape. In that case, route
+  // to one via near the boundary and make the short final hop on the requested
+  // escape layer. This retains the one-via invariant and avoids weakening any
+  // clearance rule.
+  if (
+    alternatives.length === 0 &&
+    allowBoundarySideViaFallback &&
+    fixedViaPointsByConnectionIndex &&
+    bus.connections.length === 1 &&
+    bus.exitEdge &&
+    bus.connections[0]!.sourceLayer !== targetLayer
+  ) {
+    const preparedConnection = bus.connections[0]!
+    const boundaryDirection = getDirectionForExitEdge(bus.exitEdge)
+    const boundaryExitAxis = getExitAxis(bus, boundaryDirection)
+    const finalTrack = getBoundaryTargetTrack({
+      bus,
+      connection: preparedConnection,
+      boundaryDirection,
+    })
+    const finalExitPoint = makePoint(
+      boundaryExitAxis,
+      finalTrack,
+      boundaryDirection,
+    )
+    const sourceLayerSrj: SimpleRouteJson = {
+      ...srj,
+      obstacles: srj.obstacles.map((obstacle) =>
+        obstacle === preparedConnection.sourceObstacle ||
+        (distance(obstacle.center, preparedConnection.sourcePoint) <= 1e-7 &&
+          obstacle.layers.includes(preparedConnection.sourceLayer))
+          ? {
+              ...obstacle,
+              connectedTo: [
+                ...obstacle.connectedTo,
+                preparedConnection.connection.name,
+              ],
+            }
+          : obstacle,
+      ),
+    }
+    const insetStep = Math.max(
+      viaDiameter / 2 + clearance,
+      Math.min(bus.pitchX, bus.pitchY) / 2,
+    )
+    for (const multiple of [1, 2, 3, 4, 5]) {
+      const inset = multiple * insetStep
+      const boundaryViaPoint = makePoint(
+        boundaryExitAxis - directionSign(boundaryDirection) * inset,
+        finalTrack,
+        boundaryDirection,
+      )
+      const sourceLayerSteps = routeViaMinimalWindingAlternativesSteps(
+        {
+          srj: sourceLayerSrj,
+          bus,
+          targetLayer: preparedConnection.sourceLayer,
+          terminals: [
+            {
+              connection: preparedConnection,
+              viaPoint: preparedConnection.sourcePoint,
+              exitPoint: boundaryViaPoint,
+            },
+          ],
+          acceptedPlans,
+          layerNames,
+          traceWidth,
+          viaDiameter,
+          viaHoleDiameter,
+          clearance,
+          allowBlindAndBuriedVias,
+          allowSameNetMerges,
+          maximumRouteOrderAttempts: 3,
+          reservedVias,
+          gridStepDivisor: 2,
+          allowSourceLayerRouting: true,
+          alignGridToPads: true,
+        },
+        1,
+        includeVisualization,
+      )
+      let sourceLayerResult = sourceLayerSteps.next()
+      while (!sourceLayerResult.done) {
+        yield {
+          phase: "via-minimal-winding",
+          busId: bus.busId,
+          targetLayer: preparedConnection.sourceLayer,
+          winding: sourceLayerResult.value,
+        }
+        sourceLayerResult = sourceLayerSteps.next()
+      }
+      const sourceLayerPlan = sourceLayerResult.value[0]?.[0]
+      if (!sourceLayerPlan) continue
+      const targetSegment: RoutedSegment = {
+        start: boundaryViaPoint,
+        end: finalExitPoint,
+        width: traceWidth,
+        layer: targetLayer,
+      }
+      const via = {
+        center: boundaryViaPoint,
+        diameter: viaDiameter,
+        holeDiameter: viaHoleDiameter,
+        fromLayer: preparedConnection.sourceLayer,
+        toLayer: targetLayer,
+        spanLayers: getViaSpanLayers({
+          fromLayer: preparedConnection.sourceLayer,
+          toLayer: targetLayer,
+          layerNames,
+          allowBlindAndBuriedVias,
+        }),
+      }
+      const sourceRoute = sourceLayerPlan.trace.route.filter(
+        (item) => item.route_type === "wire",
+      )
+      const plans: FanoutRoutePlan[] = [
+        {
+          ...sourceLayerPlan,
+          targetLayer,
+          exitPoint: finalExitPoint,
+          via,
+          segments: [...sourceLayerPlan.segments, targetSegment],
+          length:
+            sourceLayerPlan.length + distance(boundaryViaPoint, finalExitPoint),
+          trace: {
+            ...sourceLayerPlan.trace,
+            route: [
+              ...sourceRoute,
+              {
+                route_type: "via",
+                ...boundaryViaPoint,
+                from_layer: preparedConnection.sourceLayer,
+                to_layer: targetLayer,
+                via_diameter: viaDiameter,
+                via_hole_diameter: viaHoleDiameter,
+              },
+              {
+                route_type: "wire",
+                ...boundaryViaPoint,
+                width: traceWidth,
+                layer: targetLayer,
+              },
+              {
+                route_type: "wire",
+                ...finalExitPoint,
+                width: traceWidth,
+                layer: targetLayer,
+              },
+            ],
+          },
+        },
+      ]
+      const boundaryViaPlansAreClear = fanoutPlansAreClear({
+        plans: [...acceptedPlans, ...plans],
+        srj,
+        sharedBoundary: bus.sharedBoundary,
+        clearance,
+        allowBlindAndBuriedVias,
+        allowSameNetMerges,
+      })
+      const reservedViasAreClear = reservedVias.every((reserved) => {
+        if (
+          reserved.connectionName === preparedConnection.connection.name ||
+          (allowSameNetMerges &&
+            connectionsShareElectricalNet(
+              srj,
+              reserved.connectionName,
+              preparedConnection.connection.name,
+            ))
+        )
+          return true
+        if (
+          via.spanLayers.some((layer) =>
+            reserved.via.spanLayers.includes(layer),
+          ) &&
+          distance(via.center, reserved.via.center) <
+            (via.diameter + reserved.via.diameter) / 2 + clearance - 1e-9
+        )
+          return false
+        return (
+          !reserved.via.spanLayers.includes(targetLayer) ||
+          distancePointToSegment(
+            reserved.via.center,
+            targetSegment.start,
+            targetSegment.end,
+          ) >=
+            reserved.via.diameter / 2 + traceWidth / 2 + clearance - 1e-9
+        )
+      })
+      if (boundaryViaPlansAreClear && reservedViasAreClear) {
+        addAlternative(plans)
+        return alternatives
+      }
+    }
+  }
+
   if (viaMinimalOnly) return alternatives
 
   const searchConnectionOrder = (