@tscircuit/fanout-solver 0.0.46 → 0.0.48

package/lib/fanout-solver.ts

@@ -448,6 +448,7 @@ export function shouldUseJointBoundaryViaReservation(
     boundaryBusConnectionCounts.length === 6 ||
     boundaryBusConnectionCounts.length === 7 ||
     boundaryBusConnectionCounts.length === 8 ||
+    boundaryBusConnectionCounts.length === 9 ||
     (boundaryBusConnectionCounts.length === 4 &&
       new Set(boundaryBusConnectionCounts).size > 1)
   )
@@ -466,25 +467,96 @@ export function shouldDeferSingletonBoundaryViaReservation(
       boundaryBusCount === 7) &&
       singletonBusCount === 1) ||
     (boundaryBusCount === 8 &&
-      (singletonBusCount === 1 || singletonBusCount === 2))
+      (singletonBusCount === 1 || singletonBusCount === 2)) ||
+    (boundaryBusCount === 9 && singletonBusCount >= 1 && singletonBusCount <= 3)
   )
 }
 
+export function getDenseSingletonDeferralCandidateCount(
+  boundaryBusConnectionCounts: readonly number[],
+): number {
+  if (
+    !shouldDeferSingletonBoundaryViaReservation(boundaryBusConnectionCounts)
+  ) {
+    return 0
+  }
+  const singletonBusCount = boundaryBusConnectionCounts.filter(
+    (count) => count === 1,
+  ).length
+  return Math.max(1, singletonBusCount - 1)
+}
+
+interface DenseSourceFieldBus {
+  componentId: string
+  exitEdge?: PreparedBus["exitEdge"]
+  allowedLayers?: readonly string[]
+  routableEscapeLayers?: readonly string[]
+  connections: readonly { sourcePoint: { x: number; y: number } }[]
+}
+
+export function isDenseSingletonEmbeddedInMultiLayerWideBus(params: {
+  singletonBus: DenseSourceFieldBus
+  singletonTargetLayer: string
+  wideBuses: readonly DenseSourceFieldBus[]
+}): boolean {
+  const sourcePoint = params.singletonBus.connections[0]?.sourcePoint
+  if (params.singletonBus.connections.length !== 1 || !sourcePoint) return false
+  return params.wideBuses.some((wideBus) => {
+    const wideLayers =
+      wideBus.routableEscapeLayers ?? wideBus.allowedLayers ?? []
+    if (
+      wideBus.connections.length < 8 ||
+      wideBus.componentId !== params.singletonBus.componentId ||
+      wideBus.exitEdge !== params.singletonBus.exitEdge ||
+      wideLayers.length < 2 ||
+      !wideLayers.includes(params.singletonTargetLayer)
+    ) {
+      return false
+    }
+    const sourceXs = wideBus.connections.map(
+      (connection) => connection.sourcePoint.x,
+    )
+    const sourceYs = wideBus.connections.map(
+      (connection) => connection.sourcePoint.y,
+    )
+    return (
+      sourcePoint.x >= Math.min(...sourceXs) - 1e-9 &&
+      sourcePoint.x <= Math.max(...sourceXs) + 1e-9 &&
+      sourcePoint.y >= Math.min(...sourceYs) - 1e-9 &&
+      sourcePoint.y <= Math.max(...sourceYs) + 1e-9
+    )
+  })
+}
+
+export function getDenseLeadingCornerBandTargetTrackOffset(params: {
+  leadingLaneCount: number
+  traceWidth: number
+  viaDiameter: number
+  clearance: number
+}): number {
+  const cornerPitch = Math.max(
+    params.traceWidth + params.clearance,
+    params.viaDiameter + params.clearance,
+  )
+  return (-params.leadingLaneCount * cornerPitch) / 2
+}
+
 export function shouldSearchAdditionalBoundaryRouteTopologies(params: {
   boundaryBusCount: number
   connectionCount: number
   rawSkew: number
   maximumSkew: number
 }): boolean {
-  if (params.boundaryBusCount === 5 || params.boundaryBusCount > 8) {
+  if (params.boundaryBusCount === 5 || params.boundaryBusCount > 9) {
     return false
   }
   if (
     params.boundaryBusCount === 6 ||
     params.boundaryBusCount === 7 ||
-    params.boundaryBusCount === 8
+    params.boundaryBusCount === 8 ||
+    params.boundaryBusCount === 9
   ) {
-    // Six through eight buses remove enough meander space that a severely skewed wide
+    // Six through nine 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.
@@ -537,6 +609,21 @@ export function getDenseSingletonBoundaryGeometry(
 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
+      ? firstGeometry.targetProjection - secondGeometry.targetProjection
+      : 0) ||
+    first.busId.localeCompare(second.busId)
+  )
+}
+
+function compareReleasedDenseSingletonBoundaryDeferralPriority(
+  first: DenseSingletonBoundaryGeometryBus,
+  second: DenseSingletonBoundaryGeometryBus,
 ): number {
   const firstGeometry = getDenseSingletonBoundaryGeometry(first)
   const secondGeometry = getDenseSingletonBoundaryGeometry(second)
@@ -569,7 +656,9 @@ export function getDenseBoundaryPairRoutingPriorityKeys(params: {
   const firstBus = pairBuses[0]
   const firstSourceLayer = firstBus?.connections[0]?.sourceLayer
   if (
-    (params.boundaryBusCount !== 7 && params.boundaryBusCount !== 8) ||
+    (params.boundaryBusCount !== 7 &&
+      params.boundaryBusCount !== 8 &&
+      params.boundaryBusCount !== 9) ||
     pairBuses.length !== 3 ||
     firstBus === undefined ||
     firstBus.exitEdge === undefined ||
@@ -989,13 +1078,14 @@ export class FanoutSolver extends BaseSolver {
       if (
         unsortedBoundaryBuses.length !== 6 &&
         unsortedBoundaryBuses.length !== 7 &&
-        unsortedBoundaryBuses.length !== 8
+        unsortedBoundaryBuses.length !== 8 &&
+        unsortedBoundaryBuses.length !== 9
       ) {
         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- through eight-bus paths so their
+      // in one deterministic order for the six- through nine-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.
@@ -1011,7 +1101,7 @@ export class FanoutSolver extends BaseSolver {
     )
     if (
       boundaryBuses.length === 0 ||
-      boundaryBuses.length > 8 ||
+      boundaryBuses.length > 9 ||
       planeBuses.length < 8 ||
       boundaryBuses.some((bus) => !busUsesCoordinatedWinding(bus)) ||
       planeBuses.some((bus) => bus.connections.length !== 1) ||
@@ -1029,11 +1119,15 @@ export class FanoutSolver extends BaseSolver {
         ),
       ),
     )
-    const singletonBoundaryBusCount = boundaryBuses.filter(
-      (bus) => bus.connections.length === 1,
+    const boundaryBusConnectionCounts = boundaryBuses.map(
+      (bus) => bus.connections.length,
+    )
+    const singletonBoundaryBusCount = boundaryBusConnectionCounts.filter(
+      (connectionCount) => connectionCount === 1,
     ).length
     const useGeometryAwareSingletonOutwardPreference =
-      boundaryBuses.length === 8 && singletonBoundaryBusCount === 2
+      singletonBoundaryBusCount > 1 &&
+      shouldDeferSingletonBoundaryViaReservation(boundaryBusConnectionCounts)
     const preferredBoundaryPerpendicularSideByBusId = new Map(
       boundaryBuses.map((bus) => [bus.busId, 1 as const]),
     )
@@ -1067,29 +1161,93 @@ export class FanoutSolver extends BaseSolver {
           ),
       )
     }
-    // Five through eight boundary buses, and heterogeneous four-bus groups, leave too little
+    // Five through nine 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. 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.
+    // barrels before routing copper. Classify the least-constrained eligible
+    // one-line buses as deferral candidates, preferring a centered singleton,
+    // then a corner singleton whose explicit target lies inward along its local
+    // escape direction. A candidate embedded in a multi-layer wide-bus source
+    // field must instead reserve an outward dogbone and route before that wide
+    // bus; the remaining candidates stay provisional and can be rematched
+    // around completed copper.
     // Plane sites are likewise rematched around completed boundary plans.
-    const boundaryBusConnectionCounts = boundaryBuses.map(
-      (bus) => bus.connections.length,
-    )
     const singletonBoundaryBuses = boundaryBuses.filter(
       (bus) => bus.connections.length === 1,
     )
-    const provisionalSingletonBuses =
+    const singletonDeferralCandidates =
       shouldDeferSingletonBoundaryViaReservation(boundaryBusConnectionCounts)
         ? singletonBoundaryBuses
-            .toSorted(compareDenseSingletonBoundaryDeferralPriority)
-            .slice(0, 1)
+            .toSorted(
+              boundaryBuses.length === 9
+                ? compareDenseSingletonBoundaryDeferralPriority
+                : compareReleasedDenseSingletonBoundaryDeferralPriority,
+            )
+            .slice(
+              0,
+              getDenseSingletonDeferralCandidateCount(
+                boundaryBusConnectionCounts,
+              ),
+            )
         : []
-    const provisionalSingletonBusSet = new Set(provisionalSingletonBuses)
+    const leadingWideSingletonBuses =
+      boundaryBuses.length === 9
+        ? singletonDeferralCandidates.filter((singletonBus) => {
+            const singletonTargetLayer =
+              params.busLayerAssignments[singletonBus.busId]
+            return Boolean(
+              singletonTargetLayer &&
+                isDenseSingletonEmbeddedInMultiLayerWideBus({
+                  singletonBus,
+                  singletonTargetLayer,
+                  wideBuses: boundaryBuses,
+                }),
+            )
+          })
+        : []
+    const leadingLaneCountByWideCornerBand = new Map<string, number>()
+    if (boundaryBuses.length === 9 && leadingWideSingletonBuses.length > 0) {
+      for (const bus of leadingWideSingletonBuses) {
+        preferBoundaryOutwardByBusId.set(bus.busId, true)
+        const side = getCornerBandSide(bus.exitEdge, bus.preferredExit)
+        if (!bus.exitEdge || !side) continue
+        const bandKey = `${bus.exitEdge}:${side}`
+        const sharesBandWithWideBus = boundaryBuses.some((candidate) => {
+          if (candidate === bus || candidate.connections.length < 8)
+            return false
+          return (
+            candidate.exitEdge === bus.exitEdge &&
+            getCornerBandSide(candidate.exitEdge, candidate.preferredExit) ===
+              side
+          )
+        })
+        if (!sharesBandWithWideBus) continue
+        leadingLaneCountByWideCornerBand.set(
+          bandKey,
+          (leadingLaneCountByWideCornerBand.get(bandKey) ?? 0) +
+            bus.connections.length,
+        )
+      }
+    }
+    const viaProvisionalSingletonBusSet = new Set(
+      singletonDeferralCandidates.filter(
+        (bus) => !leadingWideSingletonBuses.includes(bus),
+      ),
+    )
+    const getCornerBandTargetTrackOffset = (bus: PreparedBus): number => {
+      const side = getCornerBandSide(bus.exitEdge, bus.preferredExit)
+      if (!bus.exitEdge || !side) return 0
+      const leadingLaneCount =
+        leadingLaneCountByWideCornerBand.get(`${bus.exitEdge}:${side}`) ?? 0
+      return getDenseLeadingCornerBandTargetTrackOffset({
+        leadingLaneCount,
+        traceWidth: this.config.traceWidth,
+        viaDiameter: this.config.viaDiameter,
+        clearance: this.config.clearance,
+      })
+    }
     const initiallyMatchedBoundaryBuses = boundaryBuses.filter(
-      (bus) => !provisionalSingletonBusSet.has(bus),
+      (bus) => !viaProvisionalSingletonBusSet.has(bus),
     )
     const jointViaPoints = useJointBoundaryViaReservation
       ? matchComponentDogboneViaSites(
@@ -1119,6 +1277,12 @@ export class FanoutSolver extends BaseSolver {
         canShareCopper,
       })
     if (seedViaPoints) {
+      const denseBoundaryBusesInRoutingOrder = [
+        ...leadingWideSingletonBuses,
+        ...boundaryBuses.filter(
+          (bus) => !leadingWideSingletonBuses.includes(bus),
+        ),
+      ]
       let fixedViaPointsByConnectionIndex: ReadonlyMap<
         number,
         { x: number; y: number }
@@ -1179,6 +1343,7 @@ export class FanoutSolver extends BaseSolver {
           fixedViaPointsByConnectionIndex,
           reservedVias: getReservedVias(bus),
           viaMinimalOnly: true,
+          cornerBandTargetTrackOffset: getCornerBandTargetTrackOffset(bus),
         } as const
         let busPlans = routeBusAlternatives(routeParams, 1)[0]
         if (busPlans && bus.maxLengthSkew !== undefined) {
@@ -1215,14 +1380,14 @@ export class FanoutSolver extends BaseSolver {
         return true
       }
 
-      const firstBoundaryBus = boundaryBuses[0]!
+      const firstBoundaryBus = denseBoundaryBusesInRoutingOrder[0]!
       const routedBoundaryBuses: PreparedBus[] = []
       if (routeMatchedBoundaryBus(firstBoundaryBus)) {
         routedBoundaryBuses.push(firstBoundaryBus)
       } else {
         matchedRoutingSucceeded = false
       }
-      const remainingBoundaryBuses = boundaryBuses.slice(1)
+      const remainingBoundaryBuses = denseBoundaryBusesInRoutingOrder.slice(1)
       while (matchedRoutingSucceeded && remainingBoundaryBuses.length > 0) {
         const blockingSegments = matchedPlans.flatMap((plan) =>
           plan.segments.map((segment) => ({

package/lib/route-bus.ts

@@ -60,6 +60,8 @@ export interface RouteBusParams {
   fixedViaPointsByConnectionIndex?: ReadonlyMap<number, Point2D>
   reservedVias?: readonly ViaMinimalWindingReservedVia[]
   viaMinimalOnly?: boolean
+  /** Dense corner-band phase that preserves existing lane centers when leading lanes are prepended. */
+  cornerBandTargetTrackOffset?: number
 }
 
 interface TrackCandidate {
@@ -287,6 +289,24 @@ function getWindingCrossoverLayer(params: {
   )
 }
 
+export function getBoundaryTargetTrack(params: {
+  bus: PreparedBus
+  connection: PreparedConnection
+  boundaryDirection: FanoutDirection
+}): number {
+  const requestedTrack = getPerpendicularAxis(
+    params.connection.exitTargetPoint ?? params.connection.targetPoint,
+    params.boundaryDirection,
+  )
+  const boundaryMinimum = isHorizontal(params.boundaryDirection)
+    ? params.bus.sharedBoundary.minY
+    : params.bus.sharedBoundary.minX
+  const boundaryMaximum = isHorizontal(params.boundaryDirection)
+    ? params.bus.sharedBoundary.maxY
+    : params.bus.sharedBoundary.maxX
+  return Math.max(boundaryMinimum, Math.min(boundaryMaximum, requestedTrack))
+}
+
 function getCornerTargetTrack(params: {
   bus: PreparedBus
   connection: PreparedConnection
@@ -297,6 +317,7 @@ function getCornerTargetTrack(params: {
   layerNames: readonly string[]
   targetLayer: string
   windingOrderIndex?: number
+  cornerBandTargetTrackOffset?: number
 }): number {
   const {
     bus,
@@ -308,6 +329,7 @@ function getCornerTargetTrack(params: {
     layerNames,
     targetLayer,
     windingOrderIndex,
+    cornerBandTargetTrackOffset = 0,
   } = params
   const side = getCornerSide(bus)
   if (!side || !bus.exitEdge) {
@@ -326,7 +348,8 @@ function getCornerTargetTrack(params: {
   const pitch = Math.max(traceWidth + clearance, viaDiameter + clearance)
   const baseBandCenter =
     boundaryMinimum +
-    (boundaryMaximum - boundaryMinimum) * (side === "minimum" ? 0.25 : 0.75)
+    (boundaryMaximum - boundaryMinimum) * (side === "minimum" ? 0.25 : 0.75) +
+    cornerBandTargetTrackOffset
   const windingTarget = busUsesCoordinatedWindingChannel(bus)
     ? getWindingTargetRank({
         bus,
@@ -945,6 +968,7 @@ function buildPlan(params: {
   allowBlindAndBuriedVias: boolean
   initialViaPoint?: Point2D
   sourceEscapePath?: readonly Point2D[]
+  cornerBandTargetTrackOffset?: number
 }): FanoutRoutePlan {
   const {
     preparedConnection,
@@ -967,6 +991,7 @@ function buildPlan(params: {
     allowBlindAndBuriedVias,
     initialViaPoint,
     sourceEscapePath,
+    cornerBandTargetTrackOffset,
   } = params
   const sourcePoint = {
     x: preparedConnection.sourcePoint.x,
@@ -1048,13 +1073,14 @@ function buildPlan(params: {
           clearance,
           layerNames,
           targetLayer,
+          cornerBandTargetTrackOffset,
         })
       : usesLayeredWindingChannel
-        ? getPerpendicularAxis(
-            preparedConnection.exitTargetPoint ??
-              preparedConnection.targetPoint,
+        ? getBoundaryTargetTrack({
+            bus,
+            connection: preparedConnection,
             boundaryDirection,
-          )
+          })
         : track
   const connectionRank = getConnectionRank(bus, preparedConnection)
   const localCornerSide = getLocalCornerSide(bus)
@@ -2365,6 +2391,7 @@ export function routeBusAlternatives(
     fixedViaPointsByConnectionIndex,
     reservedVias = [],
     viaMinimalOnly = false,
+    cornerBandTargetTrackOffset,
   } = params
   if (!Number.isInteger(maxAlternatives) || maxAlternatives < 1) {
     throw new Error(
@@ -2698,12 +2725,13 @@ export function routeBusAlternatives(
               layerNames,
               targetLayer,
               windingOrderIndex: terminalPattern.windingOrderIndex,
+              cornerBandTargetTrackOffset,
             })
-          : getPerpendicularAxis(
-              preparedConnection.exitTargetPoint ??
-                preparedConnection.targetPoint,
+          : getBoundaryTargetTrack({
+              bus,
+              connection: preparedConnection,
               boundaryDirection,
-            )
+            })
         return {
           connection: preparedConnection,
           viaPoint: terminalPattern.getViaPoint
@@ -2882,6 +2910,7 @@ export function routeBusAlternatives(
         clearance,
         terminateAtVia: false,
         allowBlindAndBuriedVias,
+        cornerBandTargetTrackOffset,
       })
       if (
         !planIsClear({
@@ -2889,7 +2918,7 @@ export function routeBusAlternatives(
           otherPlans: [...acceptedPlans, ...candidatePlans],
           staticClearanceCache,
           blockingBusCounts,
-          cacheKey: `boundary:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${viaHandedness}:${trackIndex}:${bus.exitEdge ?? "legacy"}:${cornerLaneOffsets.exit}:${cornerLaneOffsets.localChannel}:${cornerLaneOffsets.boundaryChannel}`,
+          cacheKey: `boundary:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${viaHandedness}:${trackIndex}:${bus.exitEdge ?? "legacy"}:${cornerLaneOffsets.exit}:${cornerLaneOffsets.localChannel}:${cornerLaneOffsets.boundaryChannel}:${cornerBandTargetTrackOffset ?? 0}`,
           srj,
           sharedBoundary: bus.sharedBoundary,
           clearance,

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@tscircuit/fanout-solver",
-  "version": "0.0.46",
+  "version": "0.0.48",
   "description": "BGA fanout solver with coordinated bus-layer escapes for SimpleRouteJson",
   "module": "lib/index.ts",
   "type": "module",
   "files": [
     "lib"
   ],
+  "workspaces": [
+    "scripts/generate-repro"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -28,6 +31,7 @@
     "typecheck": "bunx tsc --noEmit",
     "test": "bun test",
     "benchmark": "bun benchmarks/run-benchmark.ts",
+    "generate:repro04": "bun scripts/generate-repro/generate-repro04.tsx",
     "benchmark:srj29": "./benchmark.sh",
     "render:dataset": "bun scripts/render-dataset-pngs.ts",
     "format": "biome format --write .",
@@ -44,7 +48,12 @@
     "@tsci/tscircuit.dataset-srj29-bga-decoupling": "github:tscircuit/dataset-srj29-bga-decoupling#bfdf7bc",
     "@tscircuit/alphabet": "0.0.25",
     "@tscircuit/circuit-json-util": "0.0.97",
+    "@tscircuit/copper-pour-solver": "0.0.51",
     "@tscircuit/footprinter": "0.0.394",
+    "@tscircuit/infer-cable-insertion-point": "0.0.4",
+    "@tscircuit/miniflex": "0.0.4",
+    "@tscircuit/schematic-trace-solver": "0.0.175",
+    "@tscircuit/soup-util": "0.0.41",
     "@types/bun": "1.3.14",
     "@types/react": "19.2.14",
     "@types/react-dom": "19.2.3",
@@ -52,12 +61,16 @@
     "circuit-json": "0.0.455",
     "circuit-json-to-connectivity-map": "0.0.23",
     "circuit-to-svg": "0.0.364",
-    "format-si-unit": "0.0.7",
+    "connectivity-map": "1.0.0",
+    "flatbush": "4.5.0",
+    "format-si-unit": "0.0.12",
+    "minicssgrid": "0.0.9",
     "react": "19.2.8",
     "react-cosmos": "7.3.0",
     "react-cosmos-plugin-vite": "7.3.0",
     "react-dom": "19.2.8",
     "schematic-symbols": "0.0.231",
+    "spicey": "0.0.14",
     "vite": "8.1.5"
   },
   "peerDependencies": {