@tscircuit/fanout-solver 0.0.36 → 0.0.38

package/lib/types.ts

@@ -124,9 +124,14 @@ export interface FanoutBusSpec extends SimpleRouteBus {
    * connection's electrical endpoint in SimpleRouteJson.
    *
    * A caller coordinating two fanouts can pass the paired fanout's selected
-   * exit here so both sides aim toward the same track.
+   * exit here so both sides aim toward the same track. When every target also
+   * includes a layer, the solver may use the bus's other allowed layer as an
+   * internal crossover channel, then return every exit to one common bus layer
+   * in the supplied target order.
    */
-  connectionExitTargets?: Readonly<Record<string, Point2D>>
+  connectionExitTargets?: Readonly<
+    Record<string, Point2D & { readonly layer?: string }>
+  >
   /**
    * Defaults to `{ type: "boundary" }`.
    *
@@ -245,6 +250,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
@@ -279,11 +286,15 @@ export interface PreparedConnection {
   sourceObstacle: Obstacle
   targetPoint: ConnectionPoint
   /** Preferred downstream point used to choose the boundary exit track. */
-  exitTargetPoint?: Point2D
+  exitTargetPoint?: Point2D & { readonly layer?: string }
+  /** Whether the caller supplied the layered handoff metadata needed to coordinate winding. */
+  hasExplicitLayeredExitTarget?: boolean
 }
 
 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. */
@@ -292,6 +303,8 @@ export interface PreparedBus {
   cornerBandConnectionCount?: number
   /** Layers to which this bus is allowed to escape. */
   allowedLayers?: readonly string[]
+  /** Bus layers that also survive the solver-wide escape-layer restriction. */
+  routableEscapeLayers?: readonly string[]
   termination: FanoutBusTermination
   connections: PreparedConnection[]
   componentId: string
@@ -341,6 +354,8 @@ export interface FanoutRoutePlan {
   trace: SimplifiedPcbTrace
   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
   planeEndpointSegments?: RoutedSegment[]

package/lib/validate-fanout-solution.ts

@@ -44,9 +44,11 @@ function getPlanSegments(plan: FanoutRoutePlan): RoutedSegment[] {
 }
 
 function getPlanVias(plan: FanoutRoutePlan) {
-  return [plan.via, plan.planeEndpointVia].filter(
-    (via): via is NonNullable<FanoutRoutePlan["via"]> => Boolean(via),
-  )
+  return [
+    plan.via,
+    ...(plan.additionalVias ?? []),
+    plan.planeEndpointVia,
+  ].filter((via): via is NonNullable<FanoutRoutePlan["via"]> => Boolean(via))
 }
 
 function connectionPointsMatch(
@@ -341,13 +343,13 @@ function validatePlanStructure(params: {
           plan,
         )
       }
-      if (
-        previous.layer !== current.layer &&
-        (!plan.via ||
-          !pointsMatch(previous.end, plan.via.center) ||
-          !plan.via.spanLayers.includes(previous.layer) ||
-          !plan.via.spanLayers.includes(current.layer))
-      ) {
+      const transitionVia = getPlanVias(plan).find(
+        (via) =>
+          pointsMatch(previous.end, via.center) &&
+          via.spanLayers.includes(previous.layer) &&
+          via.spanLayers.includes(current.layer),
+      )
+      if (previous.layer !== current.layer && !transitionVia) {
         addIssue(
           issues,
           "disconnected-trace",
@@ -358,6 +360,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,
@@ -919,6 +934,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) ?? []

package/package.json

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