@tscircuit/fanout-solver 0.0.37 → 0.0.39

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[]