@tscircuit/fanout-solver 0.0.38 → 0.0.40

package/lib/geometry.ts

@@ -98,6 +98,27 @@ export function pointIsInsideObstacle(
   )
 }
 
+export function circleFitsInsideObstacle(params: {
+  center: Point2D
+  diameter: number
+  obstacle: Obstacle
+  tolerance?: number
+}): boolean {
+  const { center, diameter, obstacle, tolerance = EPSILON } = params
+  const radius = diameter / 2
+  if (obstacleIsCircular(obstacle)) {
+    return (
+      distance(center, obstacle.center) + radius <=
+      obstacle.width / 2 + tolerance
+    )
+  }
+  const localCenter = toObstacleLocalPoint(center, obstacle)
+  return (
+    Math.abs(localCenter.x) + radius <= obstacle.width / 2 + tolerance &&
+    Math.abs(localCenter.y) + radius <= obstacle.height / 2 + tolerance
+  )
+}
+
 export function distancePointToObstacle(
   point: Point2D,
   obstacle: Obstacle,

package/lib/get-routed-trace-copper.ts

@@ -2,7 +2,7 @@ import type {
   SimpleRouteJson,
   SimplifiedPcbTrace,
 } from "@tscircuit/capacity-autorouter"
-import { getCopperLayerNames, getLayerSpan } from "./layer-names"
+import { getCopperLayerNames, getRouteViaSpanLayers } from "./layer-names"
 import type { Point2D, RoutedSegment } from "./types"
 
 export interface RoutedTraceVia {
@@ -21,6 +21,7 @@ export interface RoutedTraceCopper {
 export function getRoutedTraceCopper(
   srj: SimpleRouteJson,
   trace: SimplifiedPcbTrace,
+  allowBlindAndBuriedVias = true,
 ): RoutedTraceCopper {
   const layerNames = getCopperLayerNames(srj.layerCount)
   const segments: RoutedSegment[] = []
@@ -39,11 +40,16 @@ export function getRoutedTraceCopper(
           srj.min_via_pad_diameter ??
           srj.minViaDiameter ??
           srj.minTraceWidth,
-        spanLayers: getLayerSpan(
-          routePoint.from_layer,
-          routePoint.to_layer,
+        spanLayers: getRouteViaSpanLayers({
+          fromLayer: routePoint.from_layer,
+          toLayer: routePoint.to_layer,
+          layers:
+            "layers" in routePoint && Array.isArray(routePoint.layers)
+              ? (routePoint.layers as string[])
+              : undefined,
           layerNames,
-        ),
+          allowBlindAndBuriedVias,
+        }),
       })
       previousWire = undefined
       continue
@@ -78,6 +84,9 @@ export function getRoutedTraceCopper(
 
 export function getAllRoutedTraceCopper(
   srj: SimpleRouteJson,
+  allowBlindAndBuriedVias = true,
 ): RoutedTraceCopper[] {
-  return (srj.traces ?? []).map((trace) => getRoutedTraceCopper(srj, trace))
+  return (srj.traces ?? []).map((trace) =>
+    getRoutedTraceCopper(srj, trace, allowBlindAndBuriedVias),
+  )
 }

package/lib/index.ts

@@ -24,10 +24,13 @@ export type {
   FanoutPlaneConnectivity,
   FanoutPlaneTermination,
   FanoutRoutePlan,
+  FanoutRoutePoint,
+  FanoutSimplifiedPcbTrace,
   FanoutSolverOptions,
   FanoutSolverOutput,
   FanoutValidationIssue,
   FanoutValidationReport,
+  FanoutViaRoutePoint,
   Point2D,
   PreparedBus,
   SimpleRouteJsonWithFanoutPlanes,

package/lib/layer-names.ts

@@ -34,6 +34,46 @@ export function getLayerSpan(
   return layerNames.slice(firstIndex, lastIndex + 1)
 }
 
+export function getViaSpanLayers(params: {
+  fromLayer: string
+  toLayer: string
+  layerNames: string[]
+  allowBlindAndBuriedVias: boolean
+}): string[] {
+  const { fromLayer, toLayer, layerNames, allowBlindAndBuriedVias } = params
+  const logicalSpan = getLayerSpan(fromLayer, toLayer, layerNames)
+  return allowBlindAndBuriedVias ? logicalSpan : [...layerNames]
+}
+
+export function getRouteViaSpanLayers(params: {
+  fromLayer: string
+  toLayer: string
+  layers?: readonly string[]
+  layerNames: string[]
+  allowBlindAndBuriedVias: boolean
+}): string[] {
+  const { fromLayer, toLayer, layers, layerNames, allowBlindAndBuriedVias } =
+    params
+  const configuredSpan = getViaSpanLayers({
+    fromLayer,
+    toLayer,
+    layerNames,
+    allowBlindAndBuriedVias,
+  })
+  if (!layers) return configuredSpan
+  if (
+    layers.length === 0 ||
+    !layers.includes(fromLayer) ||
+    !layers.includes(toLayer) ||
+    layers.some((layer) => !layerNames.includes(layer))
+  ) {
+    throw new Error(
+      `FanoutSolver: route via from "${fromLayer}" to "${toLayer}" has an invalid physical layer span`,
+    )
+  }
+  return [...layers]
+}
+
 export function generateLayerAssignments(params: {
   busIds: string[]
   layers: string[]

package/lib/match-bus-lengths.ts

@@ -42,21 +42,46 @@ function rebuildTraceRoute(
   const lastOriginalWire = plan.trace.route.findLast(
     (point) => point.route_type === "wire",
   )
+  const getWireMetadata = (
+    wire: typeof firstOriginalWire,
+  ): Partial<
+    Extract<SimplifiedPcbTrace["route"][number], { route_type: "wire" }>
+  > => {
+    if (wire?.route_type !== "wire") return {}
+    const metadata: Partial<
+      Extract<SimplifiedPcbTrace["route"][number], { route_type: "wire" }>
+    > = { ...wire }
+    delete metadata.route_type
+    delete metadata.x
+    delete metadata.y
+    delete metadata.width
+    delete metadata.layer
+    return metadata
+  }
+  const vias = getPlanVias(plan)
+  const startsWithSourceVia =
+    pointsMatch(firstSegment.start, plan.sourcePoint) &&
+    firstSegment.layer !== plan.sourceLayer &&
+    vias.some(
+      (via) =>
+        pointsMatch(via.center, firstSegment.start) &&
+        via.spanLayers.includes(plan.sourceLayer) &&
+        via.spanLayers.includes(firstSegment.layer),
+    )
+  const initialLayer = startsWithSourceVia
+    ? plan.sourceLayer
+    : firstSegment.layer
   const route: SimplifiedPcbTrace["route"] = [
     {
+      ...getWireMetadata(firstOriginalWire),
       route_type: "wire",
       ...firstSegment.start,
       width: firstSegment.width,
-      layer: firstSegment.layer,
-      ...(firstOriginalWire?.route_type === "wire" &&
-      firstOriginalWire.start_pcb_port_id
-        ? { start_pcb_port_id: firstOriginalWire.start_pcb_port_id }
-        : {}),
+      layer: initialLayer,
     },
   ]
   let currentPoint = firstSegment.start
-  let currentLayer = firstSegment.layer
-  const vias = getPlanVias(plan)
+  let currentLayer = initialLayer
 
   for (const [segmentIndex, segment] of segments.entries()) {
     if (!pointsMatch(currentPoint, segment.start)) return null
@@ -85,15 +110,13 @@ function rebuildTraceRoute(
       currentLayer = segment.layer
     }
     route.push({
+      ...(segmentIndex === segments.length - 1
+        ? getWireMetadata(lastOriginalWire)
+        : {}),
       route_type: "wire",
       ...segment.end,
       width: segment.width,
       layer: segment.layer,
-      ...(segmentIndex === segments.length - 1 &&
-      lastOriginalWire?.route_type === "wire" &&
-      lastOriginalWire.end_pcb_port_id
-        ? { end_pcb_port_id: lastOriginalWire.end_pcb_port_id }
-        : {}),
     })
     currentPoint = segment.end
   }
@@ -131,6 +154,67 @@ function pointIsOutsideDenseBounds(
   )
 }
 
+function splitSegmentAtDenseBounds(params: {
+  segment: RoutedSegment
+  bounds: Bounds
+  margin: number
+}): RoutedSegment[] {
+  const { segment, bounds, margin } = params
+  const expandedBounds = {
+    minX: bounds.minX - margin,
+    maxX: bounds.maxX + margin,
+    minY: bounds.minY - margin,
+    maxY: bounds.maxY + margin,
+  }
+  const deltaX = segment.end.x - segment.start.x
+  const deltaY = segment.end.y - segment.start.y
+  const splitParameters = [0, 1]
+  const addSplitParameter = (parameter: number): void => {
+    if (parameter <= EPSILON || parameter >= 1 - EPSILON) return
+    const point = {
+      x: segment.start.x + deltaX * parameter,
+      y: segment.start.y + deltaY * parameter,
+    }
+    if (
+      point.x < expandedBounds.minX - EPSILON ||
+      point.x > expandedBounds.maxX + EPSILON ||
+      point.y < expandedBounds.minY - EPSILON ||
+      point.y > expandedBounds.maxY + EPSILON
+    ) {
+      return
+    }
+    splitParameters.push(parameter)
+  }
+  if (Math.abs(deltaX) > EPSILON) {
+    addSplitParameter((expandedBounds.minX - segment.start.x) / deltaX)
+    addSplitParameter((expandedBounds.maxX - segment.start.x) / deltaX)
+  }
+  if (Math.abs(deltaY) > EPSILON) {
+    addSplitParameter((expandedBounds.minY - segment.start.y) / deltaY)
+    addSplitParameter((expandedBounds.maxY - segment.start.y) / deltaY)
+  }
+  const parameters = splitParameters
+    .toSorted((first, second) => first - second)
+    .filter(
+      (parameter, index, values) =>
+        index === 0 || Math.abs(parameter - values[index - 1]!) > EPSILON,
+    )
+  return parameters.slice(1).map((endParameter, index) => {
+    const startParameter = parameters[index]!
+    return {
+      ...segment,
+      start: {
+        x: segment.start.x + deltaX * startParameter,
+        y: segment.start.y + deltaY * startParameter,
+      },
+      end: {
+        x: segment.start.x + deltaX * endParameter,
+        y: segment.start.y + deltaY * endParameter,
+      },
+    }
+  })
+}
+
 function getDenseCopperBounds(bus: PreparedBus): Bounds {
   return bus.componentObstacles.reduce<Bounds>(
     (bounds, obstacle) => ({
@@ -364,8 +448,18 @@ function createTunedPlanCandidates(params: {
   targetAddedLength: number
   clearance: number
   sharedBoundary: Bounds
+  allowInsideDenseBounds?: boolean
+  denseBoundarySplitApplied?: boolean
 }): FanoutRoutePlan[] {
-  const { plan, bus, targetAddedLength, clearance, sharedBoundary } = params
+  const {
+    plan,
+    bus,
+    targetAddedLength,
+    clearance,
+    sharedBoundary,
+    allowInsideDenseBounds = false,
+    denseBoundarySplitApplied = false,
+  } = params
   const candidates: FanoutRoutePlan[] = []
   const denseCopperBounds = getDenseCopperBounds(bus)
   const denseMargin = plan.segments[0]?.width
@@ -405,6 +499,7 @@ function createTunedPlanCandidates(params: {
             continue
           }
           if (
+            !allowInsideDenseBounds &&
             points
               .slice(1, -1)
               .some(
@@ -447,7 +542,22 @@ function createTunedPlanCandidates(params: {
       }
     }
   }
-  return candidates
+  if (denseBoundarySplitApplied) return candidates
+  const splitSegments = plan.segments.flatMap((segment) =>
+    splitSegmentAtDenseBounds({
+      segment,
+      bounds: denseCopperBounds,
+      margin: denseMargin,
+    }),
+  )
+  const splitPlan = createPlanWithSegments(plan, splitSegments)
+  if (!splitPlan) return candidates
+  const splitCandidates = createTunedPlanCandidates({
+    ...params,
+    plan: splitPlan,
+    denseBoundarySplitApplied: true,
+  })
+  return [...candidates, ...splitCandidates]
 }
 
 function getBusSkew(plans: readonly FanoutRoutePlan[]): number {
@@ -466,7 +576,19 @@ export function matchBusPlanLengths(params: {
   inputSrj: SimpleRouteJson
   sharedBoundary: Bounds
   clearance: number
+  allowBlindAndBuriedVias?: boolean
   allowSameNetMerges?: boolean
+  /**
+   * Allows tuning on target-layer copper inside the component pad envelope.
+   * Intended only for coordinated dense routing whose complete copper is
+   * revalidated and whose remaining dogbone capacity is checked atomically.
+   */
+  allowMatchingInsideDenseBounds?: boolean
+  /**
+   * Rejects a geometrically clear candidate when it would make a caller-owned
+   * downstream assignment (such as pending plane dogbones) infeasible.
+   */
+  candidatePlansAreFeasible?: (plans: readonly FanoutRoutePlan[]) => boolean
 }):
   | { plans: FanoutRoutePlan[]; failedBus?: never }
   | { plans: null; failedBus: PreparedBus } {
@@ -475,7 +597,10 @@ export function matchBusPlanLengths(params: {
     inputSrj,
     sharedBoundary,
     clearance,
+    allowBlindAndBuriedVias = true,
     allowSameNetMerges = false,
+    allowMatchingInsideDenseBounds = false,
+    candidatePlansAreFeasible,
   } = params
   let matchedPlans = [...params.plans]
   const constrainedBuses = preparedBuses.filter(
@@ -524,6 +649,95 @@ export function matchBusPlanLengths(params: {
         )
         .toSorted((first, second) => first - second)
       let acceptedPlans: FanoutRoutePlan[] | null = null
+      const acceptCandidate = (
+        candidate: FanoutRoutePlan,
+      ): FanoutRoutePlan[] | null => {
+        const nextPlans = matchedPlans.map((plan) =>
+          plan === shortest ? candidate : plan,
+        )
+        const nextBusPlans = nextPlans.filter(
+          (plan) => plan.busId === bus.busId,
+        )
+        if (getBusSkew(nextBusPlans) > skew + EPSILON) return null
+        if (
+          !fanoutPlansAreClear({
+            plans: nextPlans,
+            srj: inputSrj,
+            sharedBoundary,
+            clearance,
+            allowBlindAndBuriedVias,
+            allowSameNetMerges,
+          })
+        ) {
+          return null
+        }
+        if (
+          candidatePlansAreFeasible &&
+          !candidatePlansAreFeasible(nextPlans)
+        ) {
+          return null
+        }
+        return nextPlans
+      }
+      const findMultiSpanCandidate = (
+        targetAddedLength: number,
+      ): FanoutRoutePlan[] | null => {
+        const maximumSearchStates = 320
+        const maximumCandidatesPerState = 48
+        let searchedStateCount = 0
+        const sampleCandidates = (
+          candidates: readonly FanoutRoutePlan[],
+        ): FanoutRoutePlan[] => {
+          if (candidates.length <= maximumCandidatesPerState) {
+            return [...candidates]
+          }
+          return Array.from(
+            { length: maximumCandidatesPerState },
+            (_, sampleIndex) =>
+              candidates[
+                Math.floor(
+                  (sampleIndex * candidates.length) / maximumCandidatesPerState,
+                )
+              ]!,
+          )
+        }
+        const search = (
+          currentPlan: FanoutRoutePlan,
+          stagesRemaining: number,
+        ): FanoutRoutePlan[] | null => {
+          const addedLength = currentPlan.length - shortest.length
+          const remainingAddition = targetAddedLength - addedLength
+          if (remainingAddition <= EPSILON) {
+            return acceptCandidate(currentPlan)
+          }
+          if (stagesRemaining <= 0) return null
+          const stageAddedLength = remainingAddition / stagesRemaining
+          const candidates = sampleCandidates(
+            createTunedPlanCandidates({
+              plan: currentPlan,
+              bus,
+              targetAddedLength: stageAddedLength,
+              clearance,
+              sharedBoundary: bus.sharedBoundary,
+              allowInsideDenseBounds: allowMatchingInsideDenseBounds,
+            }),
+          )
+          for (const candidate of candidates) {
+            searchedStateCount++
+            if (searchedStateCount > maximumSearchStates) return null
+            if (!acceptCandidate(candidate)) continue
+            const result = search(candidate, stagesRemaining - 1)
+            if (result) return result
+          }
+          return null
+        }
+        for (let stageCount = 2; stageCount <= 8; stageCount++) {
+          const result = search(shortest, stageCount)
+          if (result) return result
+          if (searchedStateCount > maximumSearchStates) break
+        }
+        return null
+      }
       for (const targetAddedLength of targetAddedLengths) {
         const candidates = createTunedPlanCandidates({
           plan: shortest,
@@ -531,30 +745,19 @@ export function matchBusPlanLengths(params: {
           targetAddedLength,
           clearance,
           sharedBoundary: bus.sharedBoundary,
+          allowInsideDenseBounds: allowMatchingInsideDenseBounds,
         })
         for (const candidate of candidates) {
-          const nextPlans = matchedPlans.map((plan) =>
-            plan === shortest ? candidate : plan,
-          )
-          const nextBusPlans = nextPlans.filter(
-            (plan) => plan.busId === bus.busId,
-          )
-          const nextSkew = getBusSkew(nextBusPlans)
-          if (nextSkew > skew + EPSILON) continue
-          if (
-            !fanoutPlansAreClear({
-              plans: nextPlans,
-              srj: inputSrj,
-              sharedBoundary,
-              clearance,
-              allowSameNetMerges,
-            })
-          ) {
-            continue
-          }
-          acceptedPlans = nextPlans
+          acceptedPlans = acceptCandidate(candidate)
+          if (!acceptedPlans) continue
           break
         }
+        if (
+          !acceptedPlans &&
+          Math.abs(targetAddedLength - minimumRequiredAddition) <= EPSILON
+        ) {
+          acceptedPlans = findMultiSpanCandidate(targetAddedLength)
+        }
         if (acceptedPlans) break
       }
       if (!acceptedPlans) return { plans: null, failedBus: bus }