@tscircuit/fanout-solver 0.0.58 → 0.0.59

package/README.md

@@ -330,6 +330,11 @@ the solver commit, dataset revision, configuration, solve totals, every sample's
 status and timing, and partial routing/validation counts. Reports are saved after
 every completed sample, including the total selected count to identify incomplete runs.
 Timed-out workers do not retain their in-flight routing counts.
+Every solved case also writes `benchmark-results/<sample-id>.svg`. These SVGs
+are committed so route changes can be reviewed in Git. A run replaces the selected
+cases' snapshots and removes their stale SVGs if they no longer solve; filtered
+runs preserve unselected snapshots. JSON reports and captured inputs remain
+ignored. CI includes the SVGs in its benchmark artifacts.
 Compare reports with the same budgets to track progress. Solved means validated
 AM62L fanout, not RAM fanout or downstream inter-chip routing. Partial, error,
 and timeout rows are benchmark results (exit 0); invalid CLI arguments or report

package/lib/fanout-solver.ts

@@ -1397,9 +1397,14 @@ export class FanoutSolver extends BaseSolver {
     denseRoutingStrategy?: "pad-aligned" | "boundary-aligned"
     lengthMatchingStage?: "before-planes" | "after-planes"
     promotedPlaneReservationBusIds?: readonly string[]
+    preferredBoundaryViaPoints?: ReadonlyMap<number, { x: number; y: number }>
     planeReservationRetryCount?: number
   }): Generator<FanoutWorkYield, MixedTerminationState | null, unknown> {
     if (this.config.allowBlindAndBuriedVias) return null
+    // An outside-package singleton escape can depend on the completed signal
+    // field. Keep those sites as preferences when plane reservations change;
+    // actual conflicts may still move.
+    let boundaryViaPointsForRetry = params.preferredBoundaryViaPoints
     const usePadAlignedDenseRouting =
       params.denseRoutingStrategy !== "boundary-aligned"
     const debugDense = (...values: unknown[]) => {
@@ -1444,9 +1449,12 @@ export class FanoutSolver extends BaseSolver {
       )
     const useConfiguredDensePlaneRouting =
       configuredDensePlaneRouting || useAdaptiveDensePlaneRouting
+    // A completed boundary assignment remains worth repairing jointly after
+    // plane reservations change; a greedy refill can discard that assignment.
     const useAdaptiveJointPlaneSelection =
       useAdaptiveDensePlaneRouting &&
-      (params.planeReservationRetryCount ?? 0) === 0
+      ((params.planeReservationRetryCount ?? 0) === 0 ||
+        Boolean(params.preferredBoundaryViaPoints))
     const matchLengthsAfterPlanes =
       useConfiguredDensePlaneRouting &&
       params.lengthMatchingStage !== "before-planes"
@@ -1871,19 +1879,45 @@ export class FanoutSolver extends BaseSolver {
             )
           })
         : []
+    // A corner singleton on the outward source row must leave before its
+    // surrounding wide bus closes the shared target-layer corridor.
     const throughAllLeadingSingletonBuses = hasThreeWideBoundaryBuses
       ? singletonBoundaryBuses.filter((singletonBus) => {
           const containingWideBus = getContainingWideSourceField(singletonBus)
           const singletonTargetLayer =
             params.busLayerAssignments[singletonBus.busId]
+          if (!containingWideBus || !singletonTargetLayer) return false
           const containingWideLayers =
-            containingWideBus?.routableEscapeLayers ??
-            containingWideBus?.allowedLayers ??
+            containingWideBus.routableEscapeLayers ??
+            containingWideBus.allowedLayers ??
             []
+          const sourceAxis =
+            singletonBus.exitEdge === "left" ||
+            singletonBus.exitEdge === "right"
+              ? "x"
+              : "y"
+          const wideCoordinates = containingWideBus.connections.map(
+            (connection) => connection.sourcePoint[sourceAxis],
+          )
+          const outwardSourceCoordinate =
+            singletonBus.exitEdge === "left" ||
+            singletonBus.exitEdge === "bottom"
+              ? Math.min(...wideCoordinates)
+              : Math.max(...wideCoordinates)
+          const isOnOutwardSourceEdge = singletonBus.connections.every(
+            (connection) =>
+              Math.abs(
+                connection.sourcePoint[sourceAxis] - outwardSourceCoordinate,
+              ) < 1e-9,
+          )
           return Boolean(
-            containingWideBus &&
-              singletonTargetLayer &&
-              !containingWideLayers.includes(singletonTargetLayer),
+            !containingWideLayers.includes(singletonTargetLayer) ||
+              (useAdaptiveDensePlaneRouting &&
+                isOnOutwardSourceEdge &&
+                getCornerBandSide(
+                  singletonBus.exitEdge,
+                  singletonBus.preferredExit,
+                )),
           )
         })
       : []
@@ -1994,6 +2028,8 @@ export class FanoutSolver extends BaseSolver {
             traceWidth: this.config.traceWidth,
             clearance: this.config.clearance,
             maximumSearchStates: 100_000,
+            preferredViaPointsByConnectionIndex:
+              params.preferredBoundaryViaPoints,
             preferredBoundaryPerpendicularSideByBusId,
             preferBoundaryOutwardByBusId,
             additionalObstacles: denseAdditionalObstacles,
@@ -2012,6 +2048,8 @@ export class FanoutSolver extends BaseSolver {
           traceWidth: this.config.traceWidth,
           clearance: this.config.clearance,
           maximumSearchStates: 20_000,
+          preferredViaPointsByConnectionIndex:
+            params.preferredBoundaryViaPoints,
           preferredBoundaryPerpendicularSideByBusId,
           preferBoundaryOutwardByBusId,
           additionalObstacles: denseAdditionalObstacles,
@@ -2070,6 +2108,8 @@ export class FanoutSolver extends BaseSolver {
             traceWidth: this.config.traceWidth,
             clearance: this.config.clearance,
             maximumSearchStates: 100_000,
+            preferredViaPointsByConnectionIndex:
+              params.preferredBoundaryViaPoints,
             preferredBoundaryPerpendicularSideByBusId,
             preferBoundaryOutwardByBusId,
             fixedViaPointsByConnectionIndex: seedViaPoints,
@@ -2221,8 +2261,10 @@ export class FanoutSolver extends BaseSolver {
           allowBoundarySideViaFallback: bus.connections.length === 1,
           preferCornerBoundaryVia: useConfiguredDensePlaneRouting,
           adaptiveWindingRouteOrder,
+          // Retain pad-aligned channels even when plane sites are reserved
+          // adaptively; the boundary grid can fence off a turning wide bus.
           alignWindingGridToPads:
-            usePadAlignedDenseRouting && !useConfiguredDensePlaneRouting,
+            usePadAlignedDenseRouting && !configuredDensePlaneRouting,
           fixedViaFallbackRouteOrderAttempts: adaptiveWindingRouteOrder
             ? 60
             : useConfiguredDensePlaneRouting
@@ -2407,6 +2449,31 @@ export class FanoutSolver extends BaseSolver {
           return false
         }
         matchedPlans.push(...busPlans)
+        if (
+          matchedPlans.length ===
+            boundaryBuses.reduce(
+              (sum, candidate) => sum + candidate.connections.length,
+              0,
+            ) &&
+          matchedPlans.some((plan) => {
+            const bus = boundaryBuses.find(
+              (candidate) => candidate.busId === plan.busId,
+            )
+            if (bus?.connections.length !== 1 || !plan.via) return false
+            const { center } = plan.via
+            return (
+              center.x < bus.componentBounds.minX ||
+              center.x > bus.componentBounds.maxX ||
+              center.y < bus.componentBounds.minY ||
+              center.y > bus.componentBounds.maxY
+            )
+          })
+        )
+          boundaryViaPointsForRetry = new Map(
+            matchedPlans
+              .filter((plan) => plan.via)
+              .map((plan) => [plan.connectionIndex, plan.via!.center]),
+          )
         debugDense("route:complete", bus.busId, busPlans.length)
         return true
       }.bind(this)
@@ -2932,7 +2999,14 @@ export class FanoutSolver extends BaseSolver {
               let alternatePlaneSearchStates = 0
               const maximumAlternatePlaneSearchStates = Number(
                 process.env.FANOUT_DEBUG_ALTERNATE_SEARCH_STATES ??
-                  (useConfiguredDensePlaneRouting ? 3_000_000 : 1_000),
+                  // Keep the initial search short before reserving blocked
+                  // plane sites. Later joint repairs retain the full budget.
+                  (useAdaptiveDensePlaneRouting &&
+                  (params.planeReservationRetryCount ?? 0) === 0
+                    ? 10_000
+                    : useConfiguredDensePlaneRouting
+                      ? 3_000_000
+                      : 1_000),
               )
               const maximumAlternatePlaneRoutes = Number(
                 process.env.FANOUT_DEBUG_ALTERNATE_ROUTE_COUNT ??
@@ -3838,6 +3912,7 @@ export class FanoutSolver extends BaseSolver {
           allowSameNetMerges: this.config.allowSameNetMerges,
           allowMatchingInsideDenseBounds: true,
           allowPairLaneSpreading: true,
+          allowUnconstrainedLaneRerouting: true,
         }
         let matchedLengthResult = matchBusPlanLengths(lengthMatchingParams)
         const shortenedBusIds = new Set<string>()
@@ -3927,6 +4002,7 @@ export class FanoutSolver extends BaseSolver {
         debugDense("promote-reservations", refinedPromotions)
         return yield* this.routeDenseThroughAllMixedTerminationSteps({
           ...params,
+          preferredBoundaryViaPoints: boundaryViaPointsForRetry,
           promotedPlaneReservationBusIds: [
             ...(params.promotedPlaneReservationBusIds ?? []),
             ...refinedPromotions,

package/lib/match-bus-lengths.ts

@@ -8,7 +8,9 @@ import {
   distanceSegmentToSegment,
   segmentsAreClear,
 } from "./geometry"
-import { fanoutPlansAreClear } from "./route-bus"
+import { getCopperLayerNames } from "./layer-names"
+import { fanoutPlansAreClear, fanoutPlansAreMutuallyClear } from "./route-bus"
+import { routeViaMinimalWinding } from "./route-via-minimal-winding"
 import type {
   Bounds,
   FanoutRoutePlan,
@@ -647,6 +649,8 @@ export function matchBusPlanLengths(params: {
   allowMatchingInsideDenseBounds?: boolean
   /** Allow a differential pair's longer lane to move aside before tuning its mate. */
   allowPairLaneSpreading?: boolean
+  /** Allow one unconstrained boundary lane to move around a tuning meander. */
+  allowUnconstrainedLaneRerouting?: boolean
   /**
    * Rejects a geometrically clear candidate when it would make a caller-owned
    * downstream assignment (such as pending plane dogbones) infeasible.
@@ -866,6 +870,124 @@ export function matchBusPlanLengths(params: {
           if (++attempts >= 4) break
         }
       }
+      if (!acceptedPlans && params.allowUnconstrainedLaneRerouting) {
+        // A neighboring singleton may occupy the only tuning window. Keep its
+        // source dogbone, via and boundary endpoint fixed, and reroute only its
+        // target-layer copper around a complete meander. Constrained buses and
+        // plane routes are never displaced by this bounded repair.
+        let rerouteAttempts = 0
+        candidateSearch: for (const targetAddedLength of targetAddedLengths) {
+          const candidates = createTunedPlanCandidates({
+            plan: shortest,
+            bus,
+            targetAddedLength,
+            clearance,
+            sharedBoundary: bus.sharedBoundary,
+            allowInsideDenseBounds: allowMatchingInsideDenseBounds,
+          })
+          for (const candidate of candidates) {
+            if (
+              !fanoutPlansAreClear({
+                plans: [candidate],
+                srj: inputSrj,
+                sharedBoundary,
+                clearance,
+                allowBlindAndBuriedVias,
+                allowSameNetMerges,
+              })
+            )
+              continue
+            const blockers = matchedPlans.filter(
+              (plan) =>
+                plan !== shortest &&
+                !fanoutPlansAreMutuallyClear({
+                  plans: [candidate, plan],
+                  srj: inputSrj,
+                  clearance,
+                  allowSameNetMerges,
+                }),
+            )
+            if (blockers.length !== 1) continue
+            const blocker = blockers[0]!
+            const blockerBus = preparedBuses.find(
+              (prepared) => prepared.busId === blocker.busId,
+            )
+            if (
+              !blockerBus ||
+              blockerBus.termination.type !== "boundary" ||
+              blockerBus.maxLengthSkew !== undefined ||
+              blockerBus.connections.length !== 1 ||
+              !blocker.via ||
+              blocker.additionalVias?.length ||
+              blocker.planeEndpointVia ||
+              blocker.segments.filter(
+                (segment) => segment.layer === blocker.sourceLayer,
+              ).length !== 1
+            )
+              continue
+            const nextPlans = matchedPlans.map((plan) =>
+              plan === shortest ? candidate : plan,
+            )
+            for (const alignGridToPads of [true, false]) {
+              if (rerouteAttempts++ >= 4) break candidateSearch
+              const rerouted = routeViaMinimalWinding({
+                srj: inputSrj,
+                bus: blockerBus,
+                terminals: [
+                  {
+                    connection: blockerBus.connections[0]!,
+                    viaPoint: blocker.via.center,
+                    exitPoint: blocker.exitPoint,
+                  },
+                ],
+                targetLayer: blocker.targetLayer,
+                acceptedPlans: nextPlans.filter((plan) => plan !== blocker),
+                layerNames: getCopperLayerNames(inputSrj.layerCount),
+                traceWidth: blocker.segments[0]!.width,
+                viaDiameter: blocker.via.diameter,
+                viaHoleDiameter: blocker.via.holeDiameter,
+                clearance,
+                allowBlindAndBuriedVias,
+                allowSameNetMerges,
+                gridStepDivisor: 2,
+                alignGridToPads,
+                maximumRouteOrderAttempts: 1,
+                preferTargetDirectedLaneBias: true,
+              })?.[0]
+              if (!rerouted) continue
+              // Rebuild from the original plan to preserve its route identity,
+              // endpoint metadata and physical via span exactly.
+              const repaired = createPlanWithSegments(blocker, [
+                blocker.segments[0]!,
+                ...rerouted.segments.slice(1),
+              ])
+              if (!repaired) continue
+              const repairedPlans = nextPlans.map((plan) =>
+                plan === blocker ? repaired : plan,
+              )
+              if (
+                getBusSkew(
+                  repairedPlans.filter((plan) => plan.busId === bus.busId),
+                ) >
+                  maxLengthSkew + EPSILON ||
+                !fanoutPlansAreClear({
+                  plans: repairedPlans,
+                  srj: inputSrj,
+                  sharedBoundary,
+                  clearance,
+                  allowBlindAndBuriedVias,
+                  allowSameNetMerges,
+                }) ||
+                (candidatePlansAreFeasible &&
+                  !candidatePlansAreFeasible(repairedPlans))
+              )
+                continue
+              acceptedPlans = repairedPlans
+              break candidateSearch
+            }
+          }
+        }
+      }
       if (!acceptedPlans) return { plans: null, failedBus: bus }
       matchedPlans = acceptedPlans
     }

package/lib/route-bus.ts

@@ -3060,9 +3060,9 @@ export function* routeBusAlternativesSteps(
   // A through-via does not have to sit next to the source pad. A narrow bus
   // embedded in another bus's source field can have every local dogbone site
   // occupied while still having a clear source-layer escape. A pair first
-  // relocates its two vias just outside the nearest package edge; a singleton
-  // retains the boundary-side-via fallback. Both forms preserve one via per
-  // signal without weakening any clearance rule.
+  // relocates its two vias just outside the nearest package edge. A singleton
+  // tries the existing boundary-side vias before searching outside the package.
+  // Both forms preserve one via per signal without weakening clearance rules.
   if (
     alternatives.length === 0 &&
     allowBoundarySideViaFallback &&
@@ -3182,6 +3182,46 @@ export function* routeBusAlternativesSteps(
             ),
           )
         : []
+    const singletonMatchedVia =
+      bus.connections.length === 1
+        ? fixedViaPointsByConnectionIndex.get(
+            bus.connections[0]!.connectionIndex,
+          )
+        : undefined
+    const packageEdgeViaCandidates = singletonMatchedVia
+      ? [
+          {
+            distance: sourceCenter.x - bus.componentBounds.minX,
+            point: {
+              x: bus.componentBounds.minX - 2 * insetStep,
+              y: singletonMatchedVia.y,
+            },
+          },
+          {
+            distance: bus.componentBounds.maxX - sourceCenter.x,
+            point: {
+              x: bus.componentBounds.maxX + 2 * insetStep,
+              y: singletonMatchedVia.y,
+            },
+          },
+          {
+            distance: sourceCenter.y - bus.componentBounds.minY,
+            point: {
+              x: singletonMatchedVia.x,
+              y: bus.componentBounds.minY - 2 * insetStep,
+            },
+          },
+          {
+            distance: bus.componentBounds.maxY - sourceCenter.y,
+            point: {
+              x: singletonMatchedVia.x,
+              y: bus.componentBounds.maxY + 2 * insetStep,
+            },
+          },
+        ]
+          .toSorted((first, second) => first.distance - second.distance)
+          .map(({ point }) => [point])
+      : []
     const viaCandidates = [
       ...displacedViaCandidates.map((points) => ({
         points,
@@ -3191,6 +3231,13 @@ export function* routeBusAlternativesSteps(
         points,
         boundarySide: true,
       })),
+      // Preserve existing singleton escapes before trying a short source-layer
+      // route beyond the package. The target layer can then wind to the exit
+      // without a local via being fenced in by an already-routed wide bus.
+      ...packageEdgeViaCandidates.map((points) => ({
+        points,
+        boundarySide: false,
+      })),
     ]
     for (const { points: boundaryViaPoints, boundarySide } of viaCandidates) {
       const boundaryVias = bus.connections.map((connection, index) => ({
@@ -3355,7 +3402,9 @@ export function* routeBusAlternativesSteps(
           )
           return {
             ...sourceLayerPlan,
-            ...(preferCornerBoundaryVia || bus.connections.length > 1
+            ...(preferCornerBoundaryVia ||
+            bus.connections.length > 1 ||
+            !boundarySide
               ? { sourceEscapeSegmentCount: sourceLayerPlan.segments.length }
               : {}),
             targetLayer,

package/package.json

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