@tscircuit/fanout-solver 0.0.37 → 0.0.39

package/lib/types.ts

@@ -9,6 +9,24 @@ import type {
 import type { OriginalEndpointConnectivityReport } from "./validate-original-endpoint-connectivity"
 import type { RoutedCopperDrcReport } from "./validate-routed-copper-drc"
 
+type CapacityRoutePoint = SimplifiedPcbTrace["route"][number]
+
+export type FanoutViaRoutePoint = Extract<
+  CapacityRoutePoint,
+  { route_type: "via" }
+> & {
+  /** Physical copper layers occupied by the via barrel. */
+  layers?: string[]
+}
+
+export type FanoutRoutePoint =
+  | Exclude<CapacityRoutePoint, { route_type: "via" }>
+  | FanoutViaRoutePoint
+
+export type FanoutSimplifiedPcbTrace = Omit<SimplifiedPcbTrace, "route"> & {
+  route: FanoutRoutePoint[]
+}
+
 export type FanoutDirection = "left" | "right" | "up" | "down"
 
 export type FanoutEdge = "left" | "right" | "top" | "bottom"
@@ -171,6 +189,12 @@ export interface FanoutSolverOptions {
   viaHoleDiameter?: number
   clearance?: number
   compactBusTracks?: boolean
+  /**
+   * Permit vias whose physical barrel only spans their logical route-layer
+   * transition. Defaults to true for compatibility. Set false for boards that
+   * manufacture every routed via through the complete copper stack.
+   */
+  allowBlindAndBuriedVias?: boolean
   /** Allow branches belonging to the same electrical net to share copper. */
   allowSameNetMerges?: boolean
   singleLayerPushAndShove?: boolean
@@ -207,9 +231,9 @@ export interface FanoutAttemptSummary {
 }
 
 export interface FanoutSolverOutput {
-  simpleRouteJson: SimpleRouteJson
-  fanoutTraces: SimplifiedPcbTrace[]
-  completionTraces: SimplifiedPcbTrace[]
+  simpleRouteJson: SimpleRouteJsonWithFanoutPlanes
+  fanoutTraces: FanoutSimplifiedPcbTrace[]
+  completionTraces: FanoutSimplifiedPcbTrace[]
   endpointCompletion?: FanoutEndpointCompletionReport
   planeTerminations: FanoutPlaneTermination[]
   busLayerAssignments: Readonly<Record<string, string>>
@@ -250,6 +274,8 @@ export interface FanoutValidationIssue {
     | "different-net-trace-clearance"
     | "different-net-trace-via-clearance"
     | "different-net-via-clearance"
+    | "plan-length-mismatch"
+    | "bus-length-skew"
   message: string
   connectionName?: string
   otherConnectionName?: string
@@ -291,6 +317,8 @@ export interface PreparedConnection {
 
 export interface PreparedBus {
   busId: string
+  /** Maximum permitted routed copper length difference in millimeters. */
+  maxLengthSkew?: number
   direction: FanoutDirection
   preferredExit?: FanoutBorderTarget
   /** Explicit final boundary edge. Omitted for legacy direction-based exits. */
@@ -347,13 +375,13 @@ export interface FanoutRoutePlan {
   /** Lower/left or upper/right band reserved along `exitEdge`. */
   cornerBandSide?: "minimum" | "maximum"
   exitPoint: Point2D
-  trace: SimplifiedPcbTrace
+  trace: FanoutSimplifiedPcbTrace
   segments: RoutedSegment[]
   via?: RoutedVia
   /** Additional layer transitions used by an explicit winding channel. */
   additionalVias?: RoutedVia[]
   /** Optional capacitor-side dogbone reserved and emitted with a plane escape. */
-  planeEndpointTrace?: SimplifiedPcbTrace
+  planeEndpointTrace?: FanoutSimplifiedPcbTrace
   planeEndpointSegments?: RoutedSegment[]
   planeEndpointVia?: RoutedVia
   length: number
@@ -376,12 +404,16 @@ export interface FanoutPlaneConnectivity {
   layer: string
 }
 
-export type SimpleRouteJsonWithFanoutPlanes = SimpleRouteJson & {
+export type SimpleRouteJsonWithFanoutPlanes = Omit<
+  SimpleRouteJson,
+  "traces"
+> & {
+  traces?: FanoutSimplifiedPcbTrace[]
   fanoutPlaneConnectivity?: FanoutPlaneConnectivity[]
 }
 
 export interface AssignmentAttempt {
   summary: FanoutAttemptSummary
   plans: FanoutRoutePlan[]
-  outputSrj: SimpleRouteJson
+  outputSrj: SimpleRouteJsonWithFanoutPlanes
 }

package/lib/validate-fanout-solution.ts

@@ -288,7 +288,17 @@ function validatePlanStructure(params: {
       plan,
     )
   }
-  if (plan.segments.length === 0 || plan.length <= EPSILON) {
+  const isAllowedViaInPadPlaneTermination =
+    (inputSrj as SimpleRouteJson & { allowViaInPad?: boolean })
+      .allowViaInPad === true &&
+    plan.termination.type === "plane" &&
+    plan.via !== undefined &&
+    pointsMatch(plan.via.center, plan.sourcePoint) &&
+    pointsMatch(plan.exitPoint, plan.sourcePoint)
+  if (
+    !isAllowedViaInPadPlaneTermination &&
+    (plan.segments.length === 0 || plan.length <= EPSILON)
+  ) {
     addIssue(
       issues,
       "not-broken-out",
@@ -316,7 +326,10 @@ function validatePlanStructure(params: {
         plan,
       )
     }
-    if (!pointsMatch(plan.segments[0]!.start, plan.sourcePoint)) {
+    if (
+      plan.segments[0] &&
+      !pointsMatch(plan.segments[0].start, plan.sourcePoint)
+    ) {
       addIssue(
         issues,
         "disconnected-trace",
@@ -324,7 +337,10 @@ function validatePlanStructure(params: {
         plan,
       )
     }
-    if (!pointsMatch(plan.segments.at(-1)!.end, plan.exitPoint)) {
+    if (
+      plan.segments.at(-1) &&
+      !pointsMatch(plan.segments.at(-1)!.end, plan.exitPoint)
+    ) {
       addIssue(
         issues,
         "disconnected-trace",
@@ -360,6 +376,19 @@ function validatePlanStructure(params: {
     }
   }
 
+  const measuredLength = [
+    ...plan.segments,
+    ...(plan.planeEndpointSegments ?? []),
+  ].reduce((total, segment) => total + distance(segment.start, segment.end), 0)
+  if (Math.abs(measuredLength - plan.length) > 1e-6) {
+    addIssue(
+      issues,
+      "plan-length-mismatch",
+      `Plan ${plan.connectionName} declares ${plan.length.toFixed(6)}mm but contains ${measuredLength.toFixed(6)}mm of routed copper`,
+      plan,
+    )
+  }
+
   const traceSegments = extractTraceSegments({
     trace: plan.trace,
     plan,
@@ -654,9 +683,10 @@ function validateClearances(params: {
   plans: readonly FanoutRoutePlan[]
   inputSrj: SimpleRouteJson
   clearance: number
+  allowBlindAndBuriedVias: boolean
   issues: FanoutValidationIssue[]
 }): void {
-  const { plans, inputSrj, clearance, issues } = params
+  const { plans, inputSrj, clearance, allowBlindAndBuriedVias, issues } = params
   for (const plan of plans) {
     const segments = getPlanSegments(plan)
     for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex++) {
@@ -718,7 +748,10 @@ function validateClearances(params: {
       }
     }
 
-    for (const traceCopper of getAllRoutedTraceCopper(inputSrj)) {
+    for (const traceCopper of getAllRoutedTraceCopper(
+      inputSrj,
+      allowBlindAndBuriedVias,
+    )) {
       if (
         plan.connectionName === traceCopper.connectionName ||
         connectionsShareElectricalNet(
@@ -904,6 +937,7 @@ export function validateFanoutSolution(params: {
   preparedBuses: readonly PreparedBus[]
   sharedBoundary: Bounds
   clearance: number
+  allowBlindAndBuriedVias?: boolean
 }): FanoutValidationReport {
   const {
     inputSrj,
@@ -912,6 +946,7 @@ export function validateFanoutSolution(params: {
     preparedBuses,
     sharedBoundary,
     clearance,
+    allowBlindAndBuriedVias = true,
   } = params
   const issues: FanoutValidationIssue[] = []
   const plansByConnection = new Map<string, FanoutRoutePlan[]>()
@@ -921,6 +956,21 @@ export function validateFanoutSolution(params: {
     connectionPlans.push(plan)
     plansByConnection.set(plan.connectionName, connectionPlans)
   }
+  for (const bus of preparedBuses) {
+    if (bus.maxLengthSkew === undefined) continue
+    const busPlans = plans.filter((plan) => plan.busId === bus.busId)
+    if (busPlans.length < 2) continue
+    const lengths = busPlans.map((plan) => plan.length)
+    const skew = Math.max(...lengths) - Math.min(...lengths)
+    if (skew > bus.maxLengthSkew + 1e-6) {
+      addIssue(
+        issues,
+        "bus-length-skew",
+        `Bus ${bus.busId} has ${skew.toFixed(6)}mm routed-length skew; ${bus.maxLengthSkew.toFixed(6)}mm is allowed`,
+        busPlans[0],
+      )
+    }
+  }
 
   for (const connection of inputSrj.connections) {
     const connectionPlans = plansByConnection.get(connection.name) ?? []
@@ -968,7 +1018,13 @@ export function validateFanoutSolution(params: {
     sharedBoundary,
     issues,
   })
-  validateClearances({ plans, inputSrj, clearance, issues })
+  validateClearances({
+    plans,
+    inputSrj,
+    clearance,
+    allowBlindAndBuriedVias,
+    issues,
+  })
 
   return {
     valid: issues.length === 0,

package/lib/validate-routed-copper-drc.ts

@@ -3,6 +3,7 @@ import type {
   SimplifiedPcbTrace,
 } from "@tscircuit/capacity-autorouter"
 import {
+  circleFitsInsideObstacle,
   distance,
   distancePointToObstacle,
   distancePointToSegment,
@@ -10,7 +11,7 @@ import {
   pointIsInsideObstacle,
   segmentsAreClear,
 } from "./geometry"
-import { getCopperLayerNames, getLayerSpan } from "./layer-names"
+import { getCopperLayerNames, getRouteViaSpanLayers } from "./layer-names"
 import {
   connectionsShareElectricalNet,
   obstacleSharesElectricalNet,
@@ -120,9 +121,17 @@ function extractTraceCopper(params: {
   trace: SimplifiedPcbTrace
   connectionName: string
   layerNames: string[]
+  allowBlindAndBuriedVias: boolean
   issues: RoutedCopperDrcIssue[]
 }): TraceCopper {
-  const { srj, trace, connectionName, layerNames, issues } = params
+  const {
+    srj,
+    trace,
+    connectionName,
+    layerNames,
+    allowBlindAndBuriedVias,
+    issues,
+  } = params
   const segments: RoutedSegment[] = []
   const vias: RoutedVia[] = []
   let previousWire:
@@ -134,11 +143,16 @@ function extractTraceCopper(params: {
 
   for (const routePoint of trace.route) {
     if (routePoint.route_type === "via") {
-      const spanLayers = getLayerSpan(
-        routePoint.from_layer,
-        routePoint.to_layer,
+      const 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,
+      })
       vias.push({
         center: { x: routePoint.x, y: routePoint.y },
         diameter:
@@ -231,8 +245,14 @@ export function validateRoutedCopperDrc(params: {
   inputSrj: SimpleRouteJson
   routedSrj: SimpleRouteJson
   clearance: number
+  allowBlindAndBuriedVias?: boolean
 }): RoutedCopperDrcReport {
-  const { inputSrj, routedSrj, clearance } = params
+  const {
+    inputSrj,
+    routedSrj,
+    clearance,
+    allowBlindAndBuriedVias = true,
+  } = params
   const issues: RoutedCopperDrcIssue[] = []
   const layerNames = getCopperLayerNames(routedSrj.layerCount)
   const traceCopper: TraceCopper[] = []
@@ -267,6 +287,7 @@ export function validateRoutedCopperDrc(params: {
         trace,
         connectionName,
         layerNames,
+        allowBlindAndBuriedVias,
         issues,
       }),
     )
@@ -309,7 +330,25 @@ export function validateRoutedCopperDrc(params: {
       const coincidentEndpoint = originalAndRoutedEndpoints.find(
         ({ point }) => distance(via.center, point) <= EPSILON,
       )
-      if (coincidentEndpoint) {
+      const isAllowedContainedViaInPad =
+        (inputSrj as SimpleRouteJson & { allowViaInPad?: boolean })
+          .allowViaInPad === true &&
+        inputSrj.obstacles.some(
+          (obstacle) =>
+            obstacle.layers.some((layer) => via.spanLayers.includes(layer)) &&
+            obstacleSharesElectricalNet(
+              inputSrj,
+              obstacle,
+              copper.connectionName,
+            ) &&
+            circleFitsInsideObstacle({
+              center: via.center,
+              diameter: via.diameter,
+              obstacle,
+              tolerance: EPSILON,
+            }),
+        )
+      if (coincidentEndpoint && !isAllowedContainedViaInPad) {
         addIssue(issues, {
           code: "via-at-endpoint",
           traceId: copper.trace.pcb_trace_id,

package/package.json

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