@tscircuit/fanout-solver 0.0.40 → 0.0.42

package/lib/fanout-solver.ts

@@ -440,6 +440,36 @@ function busUsesCoordinatedWinding(bus: PreparedBus): boolean {
   )
 }
 
+export function shouldUseJointBoundaryViaReservation(
+  boundaryBusConnectionCounts: readonly number[],
+): boolean {
+  return (
+    boundaryBusConnectionCounts.length === 5 ||
+    (boundaryBusConnectionCounts.length === 4 &&
+      new Set(boundaryBusConnectionCounts).size > 1)
+  )
+}
+
+export function shouldDeferSingletonBoundaryViaReservation(
+  boundaryBusConnectionCounts: readonly number[],
+): boolean {
+  return (
+    boundaryBusConnectionCounts.length === 5 &&
+    boundaryBusConnectionCounts.filter((count) => count === 1).length === 1
+  )
+}
+
+export function shouldSearchAdditionalBoundaryRouteTopologies(params: {
+  boundaryBusCount: number
+  rawSkew: number
+  maximumSkew: number
+}): boolean {
+  if (params.boundaryBusCount >= 5) return false
+  return (
+    params.rawSkew - params.maximumSkew > Math.max(1, params.maximumSkew * 0.25)
+  )
+}
+
 function getCandidateEscapeLayersForBus(params: {
   bus: PreparedBus
   srj: SimpleRouteJson
@@ -722,48 +752,59 @@ export class FanoutSolver extends BaseSolver {
   }): MixedTerminationState | null {
     if (this.config.allowBlindAndBuriedVias) return null
 
-    const boundaryBuses = params.busesInRoutingOrder
-      .filter((bus) => bus.termination.type === "boundary")
-      .toSorted((first, second) => {
-        const cornerBandDifference =
-          Number(
-            Boolean(getCornerBandSide(second.exitEdge, second.preferredExit)),
-          ) -
-          Number(
-            Boolean(getCornerBandSide(first.exitEdge, first.preferredExit)),
+    const unsortedBoundaryBuses = params.busesInRoutingOrder.filter(
+      (bus) => bus.termination.type === "boundary",
+    )
+    const useJointBoundaryViaReservation = shouldUseJointBoundaryViaReservation(
+      unsortedBoundaryBuses.map((bus) => bus.connections.length),
+    )
+    const boundaryBuses = unsortedBoundaryBuses.toSorted((first, second) => {
+      // Reserve the dense escape field for the widest buses first. Small
+      // control groups can usually route around their copper, while routing
+      // a two-line corner bus first can consume a critical channel needed by
+      // an eight-line winding bus and force the expensive fallback search.
+      if (useJointBoundaryViaReservation) {
+        const connectionCountDifference =
+          second.connections.length - first.connections.length
+        if (connectionCountDifference !== 0) return connectionCountDifference
+      }
+      const cornerBandDifference =
+        Number(
+          Boolean(getCornerBandSide(second.exitEdge, second.preferredExit)),
+        ) -
+        Number(Boolean(getCornerBandSide(first.exitEdge, first.preferredExit)))
+      if (cornerBandDifference !== 0) return cornerBandDifference
+      const firstIsCorner = Boolean(
+        getCornerBandSide(first.exitEdge, first.preferredExit),
+      )
+      if (!firstIsCorner) {
+        const getSourceSpan = (bus: PreparedBus): number => {
+          const xCoordinates = bus.connections.map(
+            (connection) => connection.sourcePoint.x,
+          )
+          const yCoordinates = bus.connections.map(
+            (connection) => connection.sourcePoint.y,
+          )
+          return (
+            Math.max(...xCoordinates) -
+            Math.min(...xCoordinates) +
+            Math.max(...yCoordinates) -
+            Math.min(...yCoordinates)
           )
-        if (cornerBandDifference !== 0) return cornerBandDifference
-        const firstIsCorner = Boolean(
-          getCornerBandSide(first.exitEdge, first.preferredExit),
-        )
-        if (!firstIsCorner) {
-          const getSourceSpan = (bus: PreparedBus): number => {
-            const xCoordinates = bus.connections.map(
-              (connection) => connection.sourcePoint.x,
-            )
-            const yCoordinates = bus.connections.map(
-              (connection) => connection.sourcePoint.y,
-            )
-            return (
-              Math.max(...xCoordinates) -
-              Math.min(...xCoordinates) +
-              Math.max(...yCoordinates) -
-              Math.min(...yCoordinates)
-            )
-          }
-          const sourceSpanDifference =
-            getSourceSpan(second) - getSourceSpan(first)
-          if (Math.abs(sourceSpanDifference) > 1e-9) {
-            return sourceSpanDifference
-          }
         }
-        const firstLayer = params.busLayerAssignments[first.busId]
-        const secondLayer = params.busLayerAssignments[second.busId]
-        const layerDifference =
-          this.config.layerNames.indexOf(firstLayer ?? "") -
-          this.config.layerNames.indexOf(secondLayer ?? "")
-        return -layerDifference
-      })
+        const sourceSpanDifference =
+          getSourceSpan(second) - getSourceSpan(first)
+        if (Math.abs(sourceSpanDifference) > 1e-9) {
+          return sourceSpanDifference
+        }
+      }
+      const firstLayer = params.busLayerAssignments[first.busId]
+      const secondLayer = params.busLayerAssignments[second.busId]
+      const layerDifference =
+        this.config.layerNames.indexOf(firstLayer ?? "") -
+        this.config.layerNames.indexOf(secondLayer ?? "")
+      return -layerDifference
+    })
     // Preserve the caller/input order for the dense singleton fill. The
     // general routing sort is useful for heterogeneous buses, but ordering a
     // regular BGA power field by obstacle depth creates artificial local
@@ -774,7 +815,7 @@ export class FanoutSolver extends BaseSolver {
     )
     if (
       boundaryBuses.length === 0 ||
-      boundaryBuses.length > 4 ||
+      boundaryBuses.length > 5 ||
       planeBuses.length < 8 ||
       boundaryBuses.some((bus) => !busUsesCoordinatedWinding(bus)) ||
       planeBuses.some((bus) => bus.connections.length !== 1) ||
@@ -821,9 +862,41 @@ export class FanoutSolver extends BaseSolver {
           ),
       )
     }
-    const seedViaPoints = matchComponentDogboneViaSites(
-      [...planeBuses, boundaryBuses[0]!],
-      {
+    // Five boundary buses, and heterogeneous four-bus groups, leave too little
+    // slack for incremental site allocation: a valid early trace can consume
+    // the last dogbone site of a later narrow bus. Reserve the multi-line bus
+    // barrels before routing copper. A single one-line bus stays provisional
+    // because its flexible site can be rematched around the wide-bus copper.
+    // Plane sites are likewise rematched around completed boundary plans.
+    const boundaryBusConnectionCounts = boundaryBuses.map(
+      (bus) => bus.connections.length,
+    )
+    const provisionalSingletonBus = shouldDeferSingletonBoundaryViaReservation(
+      boundaryBusConnectionCounts,
+    )
+      ? boundaryBuses.find((bus) => bus.connections.length === 1)
+      : undefined
+    const initiallyMatchedBoundaryBuses = provisionalSingletonBus
+      ? boundaryBuses.filter((bus) => bus !== provisionalSingletonBus)
+      : boundaryBuses
+    const jointViaPoints = useJointBoundaryViaReservation
+      ? matchComponentDogboneViaSites(
+          [...planeBuses, ...initiallyMatchedBoundaryBuses],
+          {
+            viaDiameter: this.config.viaDiameter,
+            viaHoleDiameter: this.config.viaHoleDiameter,
+            traceWidth: this.config.traceWidth,
+            clearance: this.config.clearance,
+            maximumSearchStates: 100_000,
+            preferredBoundaryPerpendicularSideByBusId,
+            preferBoundaryOutwardByBusId,
+            canShareCopper,
+          },
+        )
+      : null
+    const seedViaPoints =
+      jointViaPoints ??
+      matchComponentDogboneViaSites([...planeBuses, boundaryBuses[0]!], {
         viaDiameter: this.config.viaDiameter,
         viaHoleDiameter: this.config.viaHoleDiameter,
         traceWidth: this.config.traceWidth,
@@ -832,8 +905,7 @@ export class FanoutSolver extends BaseSolver {
         preferredBoundaryPerpendicularSideByBusId,
         preferBoundaryOutwardByBusId,
         canShareCopper,
-      },
-    )
+      })
     if (seedViaPoints) {
       let fixedViaPointsByConnectionIndex: ReadonlyMap<
         number,
@@ -901,7 +973,11 @@ export class FanoutSolver extends BaseSolver {
           const lengths = busPlans.map((plan) => plan.length)
           const rawSkew = Math.max(...lengths) - Math.min(...lengths)
           const needsRouteDiversity =
-            rawSkew - bus.maxLengthSkew > Math.max(1, bus.maxLengthSkew * 0.25)
+            shouldSearchAdditionalBoundaryRouteTopologies({
+              boundaryBusCount: boundaryBuses.length,
+              rawSkew,
+              maximumSkew: bus.maxLengthSkew,
+            })
           // Only pay for additional A* variants when the first topology is so
           // skewed that compact meanders are unlikely to absorb the deficit.
           // This keeps already-near-matched buses on the single-attempt path.
@@ -948,21 +1024,32 @@ export class FanoutSolver extends BaseSolver {
           candidateIndex++
         ) {
           const candidateBus = remainingBoundaryBuses[candidateIndex]!
-          const extendedViaPoints = matchComponentDogboneViaSites(
-            [...planeBuses, ...routedBoundaryBuses, candidateBus],
-            {
-              viaDiameter: this.config.viaDiameter,
-              viaHoleDiameter: this.config.viaHoleDiameter,
-              traceWidth: this.config.traceWidth,
-              clearance: this.config.clearance,
-              maximumSearchStates: 100_000,
-              preferredBoundaryPerpendicularSideByBusId,
-              preferBoundaryOutwardByBusId,
-              fixedViaPointsByConnectionIndex: fixedViaPointsByConnectionIndex,
-              blockingSegments,
-              canShareCopper,
-            },
+          const candidateHasFixedViaPoints = candidateBus.connections.every(
+            (connection) =>
+              fixedViaPointsByConnectionIndex.has(connection.connectionIndex),
           )
+          const extendedViaPoints =
+            jointViaPoints && candidateHasFixedViaPoints
+              ? // The joint map is deliberately kept intact so getReservedVias()
+                // blocks every already-reserved future through-barrel during A*.
+                // Provisional singleton and plane dogbones are rematched later.
+                new Map(fixedViaPointsByConnectionIndex)
+              : matchComponentDogboneViaSites(
+                  [...planeBuses, ...routedBoundaryBuses, candidateBus],
+                  {
+                    viaDiameter: this.config.viaDiameter,
+                    viaHoleDiameter: this.config.viaHoleDiameter,
+                    traceWidth: this.config.traceWidth,
+                    clearance: this.config.clearance,
+                    maximumSearchStates: 100_000,
+                    preferredBoundaryPerpendicularSideByBusId,
+                    preferBoundaryOutwardByBusId,
+                    fixedViaPointsByConnectionIndex:
+                      fixedViaPointsByConnectionIndex,
+                    blockingSegments,
+                    canShareCopper,
+                  },
+                )
           if (!extendedViaPoints) continue
           const previousFixedViaPoints = fixedViaPointsByConnectionIndex
           const previousPlanCount = matchedPlans.length

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/fanout-solver",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "description": "BGA fanout solver with coordinated bus-layer escapes for SimpleRouteJson",
   "module": "lib/index.ts",
   "type": "module",