@tscircuit/fanout-solver 0.0.21 → 0.0.22

package/lib/validate-fanout-solution.ts

@@ -24,6 +24,7 @@ import type {
   PreparedBus,
   RoutedSegment,
 } from "./types"
+import { segmentIsLegalTerminalBodyEscape } from "./validate-routed-copper-drc"
 
 const EPSILON = 1e-6
 
@@ -35,6 +36,16 @@ function getPointLayers(point: ConnectionPoint): string[] {
   return "layer" in point ? [point.layer] : point.layers
 }
 
+function getPlanSegments(plan: FanoutRoutePlan): RoutedSegment[] {
+  return [...plan.segments, ...(plan.planeEndpointSegments ?? [])]
+}
+
+function getPlanVias(plan: FanoutRoutePlan) {
+  return [plan.via, plan.planeEndpointVia].filter(
+    (via): via is NonNullable<FanoutRoutePlan["via"]> => Boolean(via),
+  )
+}
+
 function connectionPointsMatch(
   first: ConnectionPoint,
   second: ConnectionPoint,
@@ -322,6 +333,52 @@ function validatePlanStructure(params: {
     )
   }
 
+  if (
+    plan.planeEndpointTrace ||
+    plan.planeEndpointSegments ||
+    plan.planeEndpointVia
+  ) {
+    if (
+      !plan.planeEndpointTrace ||
+      !plan.planeEndpointSegments ||
+      !plan.planeEndpointVia
+    ) {
+      addIssue(
+        issues,
+        "trace-plan-mismatch",
+        `Plane endpoint geometry for ${plan.connectionName} is incomplete`,
+        plan,
+      )
+    } else {
+      const endpointSegments = extractTraceSegments({
+        trace: plan.planeEndpointTrace,
+        plan,
+        issues,
+      })
+      if (
+        endpointSegments.length !== plan.planeEndpointSegments.length ||
+        endpointSegments.some((segment, index) => {
+          const declared = plan.planeEndpointSegments?.[index]
+          return (
+            !declared ||
+            segment.layer !== declared.layer ||
+            Math.abs(segment.width - declared.width) > EPSILON ||
+            !pointsMatch(segment.start, declared.start) ||
+            !pointsMatch(segment.end, declared.end)
+          )
+        }) ||
+        distance(plan.planeEndpointVia.center, plan.targetPoint) <= EPSILON
+      ) {
+        addIssue(
+          issues,
+          "trace-plan-mismatch",
+          `Trace ${plan.planeEndpointTrace.pcb_trace_id} does not encode a valid offset plane-to-endpoint dogbone`,
+          plan,
+        )
+      }
+    }
+  }
+
   const firstRoutePoint = plan.trace.route.find(
     (routePoint): routePoint is Extract<typeof routePoint, { x: number }> =>
       "x" in routePoint && "y" in routePoint,
@@ -409,8 +466,12 @@ function plansHaveConnectedCopper(
   first: FanoutRoutePlan,
   second: FanoutRoutePlan,
 ): boolean {
-  for (const firstSegment of first.segments) {
-    for (const secondSegment of second.segments) {
+  const firstSegments = getPlanSegments(first)
+  const secondSegments = getPlanSegments(second)
+  const firstVias = getPlanVias(first)
+  const secondVias = getPlanVias(second)
+  for (const firstSegment of firstSegments) {
+    for (const secondSegment of secondSegments) {
       if (
         firstSegment.layer === secondSegment.layer &&
         distanceSegmentToSegment(
@@ -424,41 +485,44 @@ function plansHaveConnectedCopper(
         return true
       }
     }
-    if (
-      second.via?.spanLayers.includes(firstSegment.layer) &&
-      distancePointToSegment(
-        second.via.center,
-        firstSegment.start,
-        firstSegment.end,
-      ) <=
-        second.via.diameter / 2 + firstSegment.width / 2 + EPSILON
-    ) {
-      return true
+    for (const secondVia of secondVias) {
+      if (
+        secondVia.spanLayers.includes(firstSegment.layer) &&
+        distancePointToSegment(
+          secondVia.center,
+          firstSegment.start,
+          firstSegment.end,
+        ) <=
+          secondVia.diameter / 2 + firstSegment.width / 2 + EPSILON
+      ) {
+        return true
+      }
     }
   }
-  if (first.via) {
-    for (const secondSegment of second.segments) {
+  for (const firstVia of firstVias) {
+    for (const secondSegment of secondSegments) {
       if (
-        first.via.spanLayers.includes(secondSegment.layer) &&
+        firstVia.spanLayers.includes(secondSegment.layer) &&
         distancePointToSegment(
-          first.via.center,
+          firstVia.center,
           secondSegment.start,
           secondSegment.end,
         ) <=
-          first.via.diameter / 2 + secondSegment.width / 2 + EPSILON
+          firstVia.diameter / 2 + secondSegment.width / 2 + EPSILON
       ) {
         return true
       }
     }
-    if (
-      second.via &&
-      first.via.spanLayers.some((layer) =>
-        second.via!.spanLayers.includes(layer),
-      ) &&
-      distance(first.via.center, second.via.center) <=
-        (first.via.diameter + second.via.diameter) / 2 + EPSILON
-    ) {
-      return true
+    for (const secondVia of secondVias) {
+      if (
+        firstVia.spanLayers.some((layer) =>
+          secondVia.spanLayers.includes(layer),
+        ) &&
+        distance(firstVia.center, secondVia.center) <=
+          (firstVia.diameter + secondVia.diameter) / 2 + EPSILON
+      ) {
+        return true
+      }
     }
   }
   return false
@@ -541,12 +605,9 @@ function validateClearances(params: {
 }): void {
   const { plans, inputSrj, clearance, issues } = params
   for (const plan of plans) {
-    for (
-      let segmentIndex = 0;
-      segmentIndex < plan.segments.length;
-      segmentIndex++
-    ) {
-      const segment = plan.segments[segmentIndex]!
+    const segments = getPlanSegments(plan)
+    for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex++) {
+      const segment = segments[segmentIndex]!
       for (const obstacle of inputSrj.obstacles) {
         if (!obstacle.layers.includes(segment.layer)) continue
         if (
@@ -561,6 +622,16 @@ function validateClearances(params: {
         ) {
           continue
         }
+        if (
+          segmentIsLegalTerminalBodyEscape({
+            inputSrj,
+            segment,
+            bodyObstacle: obstacle,
+            connectionName: plan.connectionName,
+          })
+        ) {
+          continue
+        }
         const actual = distanceSegmentToObstacle(segment, obstacle)
         const required = segment.width / 2 + clearance
         if (actual < required - 1e-9) {
@@ -573,18 +644,16 @@ function validateClearances(params: {
         }
       }
     }
-    if (plan.via) {
+    for (const via of getPlanVias(plan)) {
       for (const obstacle of inputSrj.obstacles) {
         if (
-          !obstacle.layers.some((layer) =>
-            plan.via!.spanLayers.includes(layer),
-          ) ||
+          !obstacle.layers.some((layer) => via.spanLayers.includes(layer)) ||
           obstacleSharesElectricalNet(inputSrj, obstacle, plan.connectionName)
         ) {
           continue
         }
-        const actual = distancePointToObstacle(plan.via.center, obstacle)
-        const required = plan.via.diameter / 2 + clearance
+        const actual = distancePointToObstacle(via.center, obstacle)
+        const required = via.diameter / 2 + clearance
         if (actual < required - 1e-9) {
           addIssue(
             issues,
@@ -614,8 +683,12 @@ function validateClearances(params: {
       ) {
         continue
       }
-      for (const firstSegment of first.segments) {
-        for (const secondSegment of second.segments) {
+      const firstSegments = getPlanSegments(first)
+      const secondSegments = getPlanSegments(second)
+      const firstVias = getPlanVias(first)
+      const secondVias = getPlanVias(second)
+      for (const firstSegment of firstSegments) {
+        for (const secondSegment of secondSegments) {
           if (!segmentsAreClear(firstSegment, secondSegment, clearance)) {
             addIssue(
               issues,
@@ -626,37 +699,36 @@ function validateClearances(params: {
             )
           }
         }
-        if (
-          second.via?.spanLayers.includes(firstSegment.layer) &&
-          distancePointToSegment(
-            second.via.center,
-            firstSegment.start,
-            firstSegment.end,
-          ) <
-            second.via.diameter / 2 + firstSegment.width / 2 + clearance - 1e-9
-        ) {
-          addIssue(
-            issues,
-            "different-net-trace-via-clearance",
-            `Trace ${first.connectionName} violates via clearance to ${second.connectionName} on ${firstSegment.layer}`,
-            first,
-            second.connectionName,
-          )
+        for (const secondVia of secondVias) {
+          if (
+            secondVia.spanLayers.includes(firstSegment.layer) &&
+            distancePointToSegment(
+              secondVia.center,
+              firstSegment.start,
+              firstSegment.end,
+            ) <
+              secondVia.diameter / 2 + firstSegment.width / 2 + clearance - 1e-9
+          ) {
+            addIssue(
+              issues,
+              "different-net-trace-via-clearance",
+              `Trace ${first.connectionName} violates via clearance to ${second.connectionName} on ${firstSegment.layer}`,
+              first,
+              second.connectionName,
+            )
+          }
         }
       }
-      if (first.via) {
-        for (const secondSegment of second.segments) {
+      for (const firstVia of firstVias) {
+        for (const secondSegment of secondSegments) {
           if (
-            first.via.spanLayers.includes(secondSegment.layer) &&
+            firstVia.spanLayers.includes(secondSegment.layer) &&
             distancePointToSegment(
-              first.via.center,
+              firstVia.center,
               secondSegment.start,
               secondSegment.end,
             ) <
-              first.via.diameter / 2 +
-                secondSegment.width / 2 +
-                clearance -
-                1e-9
+              firstVia.diameter / 2 + secondSegment.width / 2 + clearance - 1e-9
           ) {
             addIssue(
               issues,
@@ -667,21 +739,22 @@ function validateClearances(params: {
             )
           }
         }
-        if (
-          second.via &&
-          first.via.spanLayers.some((layer) =>
-            second.via!.spanLayers.includes(layer),
-          ) &&
-          distance(first.via.center, second.via.center) <
-            (first.via.diameter + second.via.diameter) / 2 + clearance - 1e-9
-        ) {
-          addIssue(
-            issues,
-            "different-net-via-clearance",
-            `Vias ${first.connectionName} and ${second.connectionName} violate clearance on an overlapping layer span`,
-            first,
-            second.connectionName,
-          )
+        for (const secondVia of secondVias) {
+          if (
+            firstVia.spanLayers.some((layer) =>
+              secondVia.spanLayers.includes(layer),
+            ) &&
+            distance(firstVia.center, secondVia.center) <
+              (firstVia.diameter + secondVia.diameter) / 2 + clearance - 1e-9
+          ) {
+            addIssue(
+              issues,
+              "different-net-via-clearance",
+              `Vias ${first.connectionName} and ${second.connectionName} violate clearance on an overlapping layer span`,
+              first,
+              second.connectionName,
+            )
+          }
         }
       }
     }

package/lib/validate-original-endpoint-connectivity.ts

@@ -19,7 +19,11 @@ import {
   getConnectionNetKey,
   obstacleSharesElectricalNet,
 } from "./net-identity"
-import type { Point2D, RoutedSegment } from "./types"
+import type {
+  Point2D,
+  RoutedSegment,
+  SimpleRouteJsonWithFanoutPlanes,
+} from "./types"
 
 const EPSILON = 1e-6
 
@@ -64,11 +68,17 @@ interface ViaCopper {
   layers: string[]
 }
 
+interface PlaneCopper {
+  type: "plane"
+  layer: string
+}
+
 type CopperPrimitive =
   | EndpointCopper
   | ObstacleCopper
   | SegmentCopper
   | ViaCopper
+  | PlaneCopper
 
 function getPointLayers(point: ConnectionPoint): string[] {
   return "layer" in point ? [point.layer] : point.layers
@@ -124,6 +134,21 @@ function extractTraceCopper(
 }
 
 function primitivesTouch(first: CopperPrimitive, second: CopperPrimitive) {
+  if (first.type === "plane" && second.type === "plane") {
+    return first.layer === second.layer
+  }
+  if (first.type === "plane" && second.type === "via") {
+    return second.layers.includes(first.layer)
+  }
+  if (first.type === "via" && second.type === "plane") {
+    return primitivesTouch(second, first)
+  }
+  if (first.type === "plane" && second.type === "segment") {
+    return first.layer === second.segment.layer
+  }
+  if (first.type === "segment" && second.type === "plane") {
+    return primitivesTouch(second, first)
+  }
   if (first.type === "endpoint" && second.type === "endpoint") {
     return (
       layersOverlap(first.layers, second.layers) &&
@@ -265,6 +290,8 @@ export function validateOriginalEndpointConnectivity(params: {
   routedSrj: SimpleRouteJson
 }): OriginalEndpointConnectivityReport {
   const { inputSrj, routedSrj } = params
+  const planeConnectivity = (routedSrj as SimpleRouteJsonWithFanoutPlanes)
+    .fanoutPlaneConnectivity
   const layerNames = getCopperLayerNames(routedSrj.layerCount)
   const connectionsByNet = new Map<string, SimpleRouteConnection[]>()
   for (const connection of inputSrj.connections) {
@@ -303,10 +330,24 @@ export function validateOriginalEndpointConnectivity(params: {
         traceBelongsToNet(inputSrj, trace, representativeConnection),
       )
       .flatMap((trace) => extractTraceCopper(trace, layerNames))
+    const planeCopper: PlaneCopper[] = [
+      ...new Set(
+        (planeConnectivity ?? []).flatMap((plane) =>
+          connectionsShareElectricalNet(
+            inputSrj,
+            plane.connectionName,
+            representativeConnection.name,
+          )
+            ? [plane.layer]
+            : [],
+        ),
+      ),
+    ].map((layer) => ({ type: "plane", layer }))
     const copper: CopperPrimitive[] = [
       ...endpointCopper,
       ...obstacleCopper,
       ...routeCopper,
+      ...planeCopper,
     ]
     const connectedCopper = new DisjointSet(copper.length)
     for (let firstIndex = 0; firstIndex < copper.length; firstIndex++) {

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

@@ -23,6 +23,7 @@ export type RoutedCopperDrcIssueCode =
   | "unknown-trace-connection"
   | "unsupported-route-point"
   | "disconnected-trace"
+  | "via-at-endpoint"
   | "trace-obstacle-clearance"
   | "via-obstacle-clearance"
   | "different-net-trace-clearance"
@@ -61,7 +62,7 @@ interface TraceCopper {
   vias: RoutedVia[]
 }
 
-function isLegalTerminalBodyEscape(params: {
+export function segmentIsLegalTerminalBodyEscape(params: {
   inputSrj: SimpleRouteJson
   segment: RoutedSegment
   bodyObstacle: SimpleRouteJson["obstacles"][number]
@@ -235,6 +236,14 @@ export function validateRoutedCopperDrc(params: {
   const issues: RoutedCopperDrcIssue[] = []
   const layerNames = getCopperLayerNames(routedSrj.layerCount)
   const traceCopper: TraceCopper[] = []
+  const originalAndRoutedEndpoints = [inputSrj, routedSrj].flatMap((srj) =>
+    srj.connections.flatMap((connection) =>
+      connection.pointsToConnect.map((point) => ({
+        connectionName: connection.name,
+        point,
+      })),
+    ),
+  )
 
   for (const trace of routedSrj.traces ?? []) {
     const connectionName = trace.connection_name
@@ -273,7 +282,7 @@ export function validateRoutedCopperDrc(params: {
           continue
         }
         if (
-          isLegalTerminalBodyEscape({
+          segmentIsLegalTerminalBodyEscape({
             inputSrj,
             segment,
             bodyObstacle: obstacle,
@@ -297,6 +306,18 @@ export function validateRoutedCopperDrc(params: {
       }
     }
     for (const via of copper.vias) {
+      const coincidentEndpoint = originalAndRoutedEndpoints.find(
+        ({ point }) => distance(via.center, point) <= EPSILON,
+      )
+      if (coincidentEndpoint) {
+        addIssue(issues, {
+          code: "via-at-endpoint",
+          traceId: copper.trace.pcb_trace_id,
+          connectionName: copper.connectionName,
+          otherConnectionName: coincidentEndpoint.connectionName,
+          message: `Via in ${copper.trace.pcb_trace_id} is placed directly at an original or routed connection endpoint`,
+        })
+      }
       for (const obstacle of inputSrj.obstacles) {
         if (
           !obstacle.layers.some((layer) => via.spanLayers.includes(layer)) ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/fanout-solver",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "description": "BGA fanout solver with coordinated bus-layer escapes for SimpleRouteJson",
   "module": "lib/index.ts",
   "type": "module",
@@ -41,7 +41,7 @@
   "devDependencies": {
     "@biomejs/biome": "2.5.5",
     "@tsci/tscircuit.dataset-srj19-bga-passive-overlays": "github:tscircuit/dataset-srj19#c1206f3",
-    "@tsci/tscircuit.dataset-srj29-bga-decoupling": "github:tscircuit/dataset-srj29-bga-decoupling#a8a1e74",
+    "@tsci/tscircuit.dataset-srj29-bga-decoupling": "github:tscircuit/dataset-srj29-bga-decoupling#bfdf7bc",
     "@tscircuit/footprinter": "0.0.394",
     "@types/bun": "1.3.14",
     "@types/react": "19.2.14",