@tscircuit/fanout-solver 0.0.44 → 0.0.46

package/lib/fanout-solver.ts

@@ -446,6 +446,8 @@ export function shouldUseJointBoundaryViaReservation(
   return (
     boundaryBusConnectionCounts.length === 5 ||
     boundaryBusConnectionCounts.length === 6 ||
+    boundaryBusConnectionCounts.length === 7 ||
+    boundaryBusConnectionCounts.length === 8 ||
     (boundaryBusConnectionCounts.length === 4 &&
       new Set(boundaryBusConnectionCounts).size > 1)
   )
@@ -454,10 +456,17 @@ export function shouldUseJointBoundaryViaReservation(
 export function shouldDeferSingletonBoundaryViaReservation(
   boundaryBusConnectionCounts: readonly number[],
 ): boolean {
+  const boundaryBusCount = boundaryBusConnectionCounts.length
+  const singletonBusCount = boundaryBusConnectionCounts.filter(
+    (count) => count === 1,
+  ).length
   return (
-    (boundaryBusConnectionCounts.length === 5 ||
-      boundaryBusConnectionCounts.length === 6) &&
-    boundaryBusConnectionCounts.filter((count) => count === 1).length === 1
+    ((boundaryBusCount === 5 ||
+      boundaryBusCount === 6 ||
+      boundaryBusCount === 7) &&
+      singletonBusCount === 1) ||
+    (boundaryBusCount === 8 &&
+      (singletonBusCount === 1 || singletonBusCount === 2))
   )
 }
 
@@ -467,11 +476,15 @@ export function shouldSearchAdditionalBoundaryRouteTopologies(params: {
   rawSkew: number
   maximumSkew: number
 }): boolean {
-  if (params.boundaryBusCount === 5 || params.boundaryBusCount > 6) {
+  if (params.boundaryBusCount === 5 || params.boundaryBusCount > 8) {
     return false
   }
-  if (params.boundaryBusCount === 6) {
-    // A sixth bus removes enough meander space that a severely skewed wide
+  if (
+    params.boundaryBusCount === 6 ||
+    params.boundaryBusCount === 7 ||
+    params.boundaryBusCount === 8
+  ) {
+    // Six through eight buses remove enough meander space that a severely skewed wide
     // topology can be impossible to tune. Keep the retry away from narrow
     // differential/control groups and from modest deficits that the atomic
     // length matcher can absorb directly.
@@ -486,6 +499,125 @@ export function shouldSearchAdditionalBoundaryRouteTopologies(params: {
   )
 }
 
+interface DenseSingletonBoundaryGeometryBus {
+  busId: string
+  direction: PreparedBus["direction"]
+  exitEdge?: PreparedBus["exitEdge"]
+  preferredExit?: PreparedBus["preferredExit"]
+  connections: readonly {
+    sourcePoint: { x: number; y: number }
+    exitTargetPoint?: { x: number; y: number }
+  }[]
+}
+
+export function getDenseSingletonBoundaryGeometry(
+  bus: DenseSingletonBoundaryGeometryBus,
+): { isCorner: boolean; targetProjection: number } {
+  const connection = bus.connections[0]
+  const target = connection?.exitTargetPoint
+  let targetProjection = 0
+  if (connection && target) {
+    const deltaX = target.x - connection.sourcePoint.x
+    const deltaY = target.y - connection.sourcePoint.y
+    targetProjection =
+      bus.direction === "right"
+        ? deltaX
+        : bus.direction === "left"
+          ? -deltaX
+          : bus.direction === "up"
+            ? deltaY
+            : -deltaY
+  }
+  return {
+    isCorner: Boolean(getCornerBandSide(bus.exitEdge, bus.preferredExit)),
+    targetProjection,
+  }
+}
+
+export function compareDenseSingletonBoundaryDeferralPriority(
+  first: DenseSingletonBoundaryGeometryBus,
+  second: DenseSingletonBoundaryGeometryBus,
+): number {
+  const firstGeometry = getDenseSingletonBoundaryGeometry(first)
+  const secondGeometry = getDenseSingletonBoundaryGeometry(second)
+  return (
+    Number(firstGeometry.isCorner) - Number(secondGeometry.isCorner) ||
+    (firstGeometry.isCorner && secondGeometry.isCorner
+      ? Number(firstGeometry.targetProjection > 0) -
+        Number(secondGeometry.targetProjection > 0)
+      : 0) ||
+    first.busId.localeCompare(second.busId)
+  )
+}
+
+interface DensePairRoutingPriorityBus {
+  componentId: string
+  exitEdge?: PreparedBus["exitEdge"]
+  assignedLayer?: string
+  connections: readonly {
+    sourceLayer: string
+    sourcePoint: { x: number; y: number }
+    exitTargetPoint?: { x: number; y: number; layer?: string }
+  }[]
+}
+
+export function getDenseBoundaryPairRoutingPriorityKeys(params: {
+  boundaryBusCount: number
+  pairBuses: readonly DensePairRoutingPriorityBus[]
+}): number[] | null {
+  const { pairBuses } = params
+  const firstBus = pairBuses[0]
+  const firstSourceLayer = firstBus?.connections[0]?.sourceLayer
+  if (
+    (params.boundaryBusCount !== 7 && params.boundaryBusCount !== 8) ||
+    pairBuses.length !== 3 ||
+    firstBus === undefined ||
+    firstBus.exitEdge === undefined ||
+    firstBus.assignedLayer === undefined ||
+    firstSourceLayer === undefined ||
+    pairBuses.some(
+      (bus) =>
+        bus.connections.length !== 2 ||
+        bus.componentId !== firstBus.componentId ||
+        bus.exitEdge !== firstBus.exitEdge ||
+        bus.assignedLayer !== firstBus.assignedLayer ||
+        bus.connections.some((connection) => {
+          const exitTarget = connection.exitTargetPoint
+          return (
+            connection.sourceLayer !== firstSourceLayer ||
+            exitTarget?.layer !== firstBus.assignedLayer ||
+            !Number.isFinite(connection.sourcePoint.x) ||
+            !Number.isFinite(connection.sourcePoint.y) ||
+            !Number.isFinite(exitTarget?.x) ||
+            !Number.isFinite(exitTarget?.y)
+          )
+        }),
+    )
+  ) {
+    return null
+  }
+
+  const getMaximumSourceToExitTargetDistance = (
+    bus: DensePairRoutingPriorityBus,
+  ): number =>
+    Math.max(
+      ...bus.connections.map((connection) => {
+        const exitTarget = connection.exitTargetPoint!
+        return Math.hypot(
+          exitTarget.x - connection.sourcePoint.x,
+          exitTarget.y - connection.sourcePoint.y,
+        )
+      }),
+    )
+  // A pair is constrained by the lane with the farthest explicit reach. A
+  // mean can hide that lane behind its shorter mate and reverse channel order.
+  // Quantize once so equality is transitive. An epsilon-based pairwise
+  // comparator can otherwise produce A = B, B = C, but A != C.
+  return pairBuses.map((bus) =>
+    Number(getMaximumSourceToExitTargetDistance(bus).toFixed(9)),
+  )
+}
+
 function getCandidateEscapeLayersForBus(params: {
   bus: PreparedBus
   srj: SimpleRouteJson
@@ -774,6 +906,24 @@ export class FanoutSolver extends BaseSolver {
     const useJointBoundaryViaReservation = shouldUseJointBoundaryViaReservation(
       unsortedBoundaryBuses.map((bus) => bus.connections.length),
     )
+    const twoConnectionBoundaryBuses = unsortedBoundaryBuses.filter(
+      (bus) => bus.connections.length === 2,
+    )
+    const pairRoutingPriorityKeys = getDenseBoundaryPairRoutingPriorityKeys({
+      boundaryBusCount: unsortedBoundaryBuses.length,
+      pairBuses: twoConnectionBoundaryBuses.map((bus) => ({
+        ...bus,
+        assignedLayer: params.busLayerAssignments[bus.busId],
+      })),
+    })
+    const pairRoutingPriorityKeyByBusId = pairRoutingPriorityKeys
+      ? new Map(
+          twoConnectionBoundaryBuses.map((bus, index) => [
+            bus.busId,
+            pairRoutingPriorityKeys[index]!,
+          ]),
+        )
+      : null
     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
@@ -784,6 +934,24 @@ export class FanoutSolver extends BaseSolver {
           second.connections.length - first.connections.length
         if (connectionCountDifference !== 0) return connectionCountDifference
       }
+      const firstLayer = params.busLayerAssignments[first.busId]
+      const secondLayer = params.busLayerAssignments[second.busId]
+      const firstPairRoutingPriority = pairRoutingPriorityKeyByBusId?.get(
+        first.busId,
+      )
+      const secondPairRoutingPriority = pairRoutingPriorityKeyByBusId?.get(
+        second.busId,
+      )
+      if (
+        firstPairRoutingPriority !== undefined &&
+        secondPairRoutingPriority !== undefined &&
+        firstPairRoutingPriority !== secondPairRoutingPriority
+      ) {
+        // The third pair can be fenced off by two earlier pair windings. Let
+        // the pair with the shortest farthest-lane boundary reach claim its
+        // channel first without relying on caller-specific bus identifiers.
+        return firstPairRoutingPriority - secondPairRoutingPriority
+      }
       const cornerBandDifference =
         Number(
           Boolean(getCornerBandSide(second.exitEdge, second.preferredExit)),
@@ -814,18 +982,23 @@ export class FanoutSolver extends BaseSolver {
           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 ?? "")
       if (layerDifference !== 0) return -layerDifference
-      if (unsortedBoundaryBuses.length !== 6) return 0
+      if (
+        unsortedBoundaryBuses.length !== 6 &&
+        unsortedBoundaryBuses.length !== 7 &&
+        unsortedBoundaryBuses.length !== 8
+      ) {
+        return 0
+      }
       // The general routing order can differ across the two components as a
       // function of local pad geometry. Keep otherwise-equivalent corner buses
-      // in one deterministic order for the six-bus path so their boundary
-      // lanes do not swap between the two ends of a direct interconnect. Leave
-      // the released four- and five-bus tie behavior unchanged.
+      // in one deterministic order for the six- through eight-bus paths so their
+      // boundary lanes do not swap between the two ends of a direct
+      // interconnect. Leave the released four- and five-bus tie behavior
+      // unchanged.
       return first.busId.localeCompare(second.busId)
     })
     // Preserve the caller/input order for the dense singleton fill. The
@@ -838,7 +1011,7 @@ export class FanoutSolver extends BaseSolver {
     )
     if (
       boundaryBuses.length === 0 ||
-      boundaryBuses.length > 6 ||
+      boundaryBuses.length > 8 ||
       planeBuses.length < 8 ||
       boundaryBuses.some((bus) => !busUsesCoordinatedWinding(bus)) ||
       planeBuses.some((bus) => bus.connections.length !== 1) ||
@@ -856,13 +1029,22 @@ export class FanoutSolver extends BaseSolver {
         ),
       ),
     )
+    const singletonBoundaryBusCount = boundaryBuses.filter(
+      (bus) => bus.connections.length === 1,
+    ).length
+    const useGeometryAwareSingletonOutwardPreference =
+      boundaryBuses.length === 8 && singletonBoundaryBusCount === 2
     const preferredBoundaryPerpendicularSideByBusId = new Map(
       boundaryBuses.map((bus) => [bus.busId, 1 as const]),
     )
     const preferBoundaryOutwardByBusId = new Map(
       boundaryBuses.map((bus) => [
         bus.busId,
-        getExitEdgeForDirection(bus.direction) !== bus.exitEdge,
+        useGeometryAwareSingletonOutwardPreference &&
+        bus.connections.length === 1 &&
+        getCornerBandSide(bus.exitEdge, bus.preferredExit)
+          ? getDenseSingletonBoundaryGeometry(bus).targetProjection > 0
+          : getExitEdgeForDirection(bus.direction) !== bus.exitEdge,
       ]),
     )
     const canShareCopper = (
@@ -885,23 +1067,30 @@ export class FanoutSolver extends BaseSolver {
           ),
       )
     }
-    // Five or six boundary buses, and heterogeneous four-bus groups, leave too little
+    // Five through eight 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.
+    // barrels before routing copper. The least-constrained eligible one-line
+    // bus stays provisional because its flexible site can be rematched around
+    // the wide-bus copper. Prefer a centered singleton, then a corner singleton
+    // whose explicit target lies inward along its local escape direction.
     // Plane sites are likewise rematched around completed boundary plans.
     const boundaryBusConnectionCounts = boundaryBuses.map(
       (bus) => bus.connections.length,
     )
-    const provisionalSingletonBus = shouldDeferSingletonBoundaryViaReservation(
-      boundaryBusConnectionCounts,
+    const singletonBoundaryBuses = boundaryBuses.filter(
+      (bus) => bus.connections.length === 1,
+    )
+    const provisionalSingletonBuses =
+      shouldDeferSingletonBoundaryViaReservation(boundaryBusConnectionCounts)
+        ? singletonBoundaryBuses
+            .toSorted(compareDenseSingletonBoundaryDeferralPriority)
+            .slice(0, 1)
+        : []
+    const provisionalSingletonBusSet = new Set(provisionalSingletonBuses)
+    const initiallyMatchedBoundaryBuses = boundaryBuses.filter(
+      (bus) => !provisionalSingletonBusSet.has(bus),
     )
-      ? boundaryBuses.find((bus) => bus.connections.length === 1)
-      : undefined
-    const initiallyMatchedBoundaryBuses = provisionalSingletonBus
-      ? boundaryBuses.filter((bus) => bus !== provisionalSingletonBus)
-      : boundaryBuses
     const jointViaPoints = useJointBoundaryViaReservation
       ? matchComponentDogboneViaSites(
           [...planeBuses, ...initiallyMatchedBoundaryBuses],

package/lib/match-component-dogbone-via-sites.ts

@@ -525,10 +525,43 @@ function matchComponent(params: {
     }),
   )
   if (entries.some((entry) => entry.candidates.length === 0)) return null
+  // Every solution must include each sole candidate. Seed and validate those
+  // forced choices once so recursive matching only explores genuine choices.
+  const forcedCandidates = entries.flatMap((entry) =>
+    entry.candidates.length === 1 ? [entry.candidates[0]!] : [],
+  )
+  for (
+    let candidateIndex = 0;
+    candidateIndex < forcedCandidates.length;
+    candidateIndex++
+  ) {
+    const candidate = forcedCandidates[candidateIndex]!
+    for (
+      let previousIndex = 0;
+      previousIndex < candidateIndex;
+      previousIndex++
+    ) {
+      if (
+        !candidatesAreMutuallyClear({
+          first: candidate,
+          second: forcedCandidates[previousIndex]!,
+          rules,
+        })
+      ) {
+        return null
+      }
+    }
+  }
 
-  const assignedCandidates = new Map<number, ViaSiteCandidate>()
+  const assignedCandidates = new Map(
+    forcedCandidates.map((candidate) => [candidate.connectionIndex, candidate]),
+  )
   const remaining = new Set(
-    entries.map((entry) => entry.connection.preparedConnection.connectionIndex),
+    entries.flatMap((entry) =>
+      entry.candidates.length > 1
+        ? [entry.connection.preparedConnection.connectionIndex]
+        : [],
+    ),
   )
   const entryByConnectionIndex = new Map(
     entries.map((entry) => [
@@ -537,6 +570,15 @@ function matchComponent(params: {
     ]),
   )
 
+  if (remaining.size === 0) {
+    return new Map(
+      [...assignedCandidates.entries()].map(([connectionIndex, candidate]) => [
+        connectionIndex,
+        { ...candidate.point },
+      ]),
+    )
+  }
+
   const getViableCandidates = (
     entry: ConnectionCandidates,
   ): ViaSiteCandidate[] =>

package/package.json

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