@tscircuit/fanout-solver 0.0.17 → 0.0.19

package/lib/geometry.ts

@@ -3,12 +3,27 @@ import type { Point2D, RoutedSegment } from "./types"
 
 const EPSILON = 1e-9
 
-type ShapeAwareObstacle = Obstacle & { shape?: "circle" }
+type ShapeAwareObstacle = Obstacle & {
+  shape?: "circle"
+  ccwRotationDegrees?: number
+}
 
 function obstacleIsCircular(obstacle: Obstacle): boolean {
   return (obstacle as ShapeAwareObstacle).shape === "circle"
 }
 
+function toObstacleLocalPoint(point: Point2D, obstacle: Obstacle): Point2D {
+  const rotationRadians =
+    (-((obstacle as ShapeAwareObstacle).ccwRotationDegrees ?? 0) * Math.PI) /
+    180
+  const dx = point.x - obstacle.center.x
+  const dy = point.y - obstacle.center.y
+  return {
+    x: dx * Math.cos(rotationRadians) - dy * Math.sin(rotationRadians),
+    y: dx * Math.sin(rotationRadians) + dy * Math.cos(rotationRadians),
+  }
+}
+
 export function distance(a: Point2D, b: Point2D): number {
   return Math.hypot(a.x - b.x, a.y - b.y)
 }
@@ -76,9 +91,10 @@ export function pointIsInsideObstacle(
   if (obstacleIsCircular(obstacle)) {
     return distance(point, obstacle.center) <= obstacle.width / 2 + tolerance
   }
+  const localPoint = toObstacleLocalPoint(point, obstacle)
   return (
-    Math.abs(point.x - obstacle.center.x) <= obstacle.width / 2 + tolerance &&
-    Math.abs(point.y - obstacle.center.y) <= obstacle.height / 2 + tolerance
+    Math.abs(localPoint.x) <= obstacle.width / 2 + tolerance &&
+    Math.abs(localPoint.y) <= obstacle.height / 2 + tolerance
   )
 }
 
@@ -89,14 +105,9 @@ export function distancePointToObstacle(
   if (obstacleIsCircular(obstacle)) {
     return Math.max(0, distance(point, obstacle.center) - obstacle.width / 2)
   }
-  const dx = Math.max(
-    Math.abs(point.x - obstacle.center.x) - obstacle.width / 2,
-    0,
-  )
-  const dy = Math.max(
-    Math.abs(point.y - obstacle.center.y) - obstacle.height / 2,
-    0,
-  )
+  const localPoint = toObstacleLocalPoint(point, obstacle)
+  const dx = Math.max(Math.abs(localPoint.x) - obstacle.width / 2, 0)
+  const dy = Math.max(Math.abs(localPoint.y) - obstacle.height / 2, 0)
   return Math.hypot(dx, dy)
 }
 
@@ -111,16 +122,24 @@ export function distanceSegmentToObstacle(
         obstacle.width / 2,
     )
   }
+  const localStart = toObstacleLocalPoint(segment.start, obstacle)
+  const localEnd = toObstacleLocalPoint(segment.end, obstacle)
+  if (
+    Math.abs(localStart.x) <= obstacle.width / 2 + EPSILON &&
+    Math.abs(localStart.y) <= obstacle.height / 2 + EPSILON
+  ) {
+    return 0
+  }
   if (
-    pointIsInsideObstacle(segment.start, obstacle) ||
-    pointIsInsideObstacle(segment.end, obstacle)
+    Math.abs(localEnd.x) <= obstacle.width / 2 + EPSILON &&
+    Math.abs(localEnd.y) <= obstacle.height / 2 + EPSILON
   ) {
     return 0
   }
-  const minX = obstacle.center.x - obstacle.width / 2
-  const maxX = obstacle.center.x + obstacle.width / 2
-  const minY = obstacle.center.y - obstacle.height / 2
-  const maxY = obstacle.center.y + obstacle.height / 2
+  const minX = -obstacle.width / 2
+  const maxX = obstacle.width / 2
+  const minY = -obstacle.height / 2
+  const maxY = obstacle.height / 2
   const corners = [
     { x: minX, y: minY },
     { x: maxX, y: minY },
@@ -133,8 +152,8 @@ export function distanceSegmentToObstacle(
     minimumDistance = Math.min(
       minimumDistance,
       distanceSegmentToSegment(
-        segment.start,
-        segment.end,
+        localStart,
+        localEnd,
         corners[index]!,
         corners[(index + 1) % corners.length]!,
       ),

package/lib/index.ts

@@ -1,6 +1,7 @@
 export { FanoutSolver } from "./fanout-solver"
 export { getCopperLayerColor } from "./layer-colors"
 export { getCopperLayerNames } from "./layer-names"
+export { validateFanoutSolution } from "./validate-fanout-solution"
 export type {
   Bounds,
   FanoutAttemptSummary,
@@ -15,6 +16,10 @@ export type {
   FanoutDirection,
   FanoutEdge,
   FanoutPlaneTermination,
+  FanoutRoutePlan,
   FanoutSolverOptions,
   FanoutSolverOutput,
+  FanoutValidationIssue,
+  FanoutValidationReport,
+  PreparedBus,
 } from "./types"

package/lib/layer-names.ts

@@ -37,9 +37,10 @@ export function getLayerSpan(
 export function generateLayerAssignments(params: {
   busIds: string[]
   layers: string[]
+  layersByBusId?: Readonly<Record<string, readonly string[]>>
   maxAssignments: number
 }): Array<Readonly<Record<string, string>>> {
-  const { busIds, layers, maxAssignments } = params
+  const { busIds, layers, layersByBusId, maxAssignments } = params
   if (layers.length === 0) {
     throw new Error("FanoutSolver: no escape layers are available")
   }
@@ -49,7 +50,22 @@ export function generateLayerAssignments(params: {
     )
   }
 
-  const rawCombinationCount = layers.length ** busIds.length
+  const availableLayersByBus = busIds.map(
+    (busId) => layersByBusId?.[busId] ?? layers,
+  )
+  const busWithoutLayersIndex = availableLayersByBus.findIndex(
+    (availableLayers) => availableLayers.length === 0,
+  )
+  if (busWithoutLayersIndex >= 0) {
+    throw new Error(
+      `FanoutSolver: no escape layers are available for bus "${busIds[busWithoutLayersIndex]}"`,
+    )
+  }
+
+  const rawCombinationCount = availableLayersByBus.reduce(
+    (count, availableLayers) => count * availableLayers.length,
+    1,
+  )
   const combinationCount = Math.min(
     maxAssignments,
     Number.isFinite(rawCombinationCount) ? rawCombinationCount : maxAssignments,
@@ -60,7 +76,8 @@ export function generateLayerAssignments(params: {
   function addAssignment(layerIndexes: number[]): void {
     const assignment: Record<string, string> = {}
     for (let busIndex = 0; busIndex < busIds.length; busIndex++) {
-      assignment[busIds[busIndex]!] = layers[layerIndexes[busIndex]!]!
+      assignment[busIds[busIndex]!] =
+        availableLayersByBus[busIndex]![layerIndexes[busIndex]!]!
     }
     const key = JSON.stringify(assignment)
     if (seenAssignments.has(key)) return
@@ -73,9 +90,10 @@ export function generateLayerAssignments(params: {
       const layerIndexes: number[] = []
       let remaining = ordinal
       for (let busIndex = 0; busIndex < busIds.length; busIndex++) {
-        const digit = remaining % layers.length
-        remaining = Math.floor(remaining / layers.length)
-        layerIndexes.push((digit + busIndex) % layers.length)
+        const layerCount = availableLayersByBus[busIndex]!.length
+        const digit = remaining % layerCount
+        remaining = Math.floor(remaining / layerCount)
+        layerIndexes.push((digit + busIndex) % layerCount)
       }
       addAssignment(layerIndexes)
     }
@@ -90,17 +108,22 @@ export function generateLayerAssignments(params: {
   }
 
   const balancedLayerIndexes = busIds.map(
-    (_, busIndex) => busIndex % layers.length,
+    (_, busIndex) => busIndex % availableLayersByBus[busIndex]!.length,
   )
   addAssignment(balancedLayerIndexes)
+  const maximumAvailableLayerCount = Math.max(
+    ...availableLayersByBus.map((availableLayers) => availableLayers.length),
+  )
   for (
     let globalShift = 1;
-    globalShift < layers.length && assignments.length < combinationCount;
+    globalShift < maximumAvailableLayerCount &&
+    assignments.length < combinationCount;
     globalShift++
   ) {
     addAssignment(
       balancedLayerIndexes.map(
-        (layerIndex) => (layerIndex + globalShift) % layers.length,
+        (layerIndex, busIndex) =>
+          (layerIndex + globalShift) % availableLayersByBus[busIndex]!.length,
       ),
     )
   }
@@ -111,12 +134,14 @@ export function generateLayerAssignments(params: {
   ) {
     for (
       let shift = 1;
-      shift < layers.length && assignments.length < combinationCount;
+      shift < availableLayersByBus[busIndex]!.length &&
+      assignments.length < combinationCount;
       shift++
     ) {
       const layerIndexes = [...balancedLayerIndexes]
       layerIndexes[busIndex] =
-        (balancedLayerIndexes[busIndex]! + shift) % layers.length
+        (balancedLayerIndexes[busIndex]! + shift) %
+        availableLayersByBus[busIndex]!.length
       addAssignment(layerIndexes)
     }
   }
@@ -128,7 +153,8 @@ export function generateLayerAssignments(params: {
     addAssignment(
       busIds.map(
         (_, busIndex) =>
-          mix32(seed * 0x9e3779b1 + busIndex * 0x85ebca6b) % layers.length,
+          mix32(seed * 0x9e3779b1 + busIndex * 0x85ebca6b) %
+          availableLayersByBus[busIndex]!.length,
       ),
     )
   }

package/lib/net-identity.ts

@@ -0,0 +1,163 @@
+import type {
+  Obstacle,
+  SimpleRouteConnection,
+  SimpleRouteJson,
+} from "@tscircuit/capacity-autorouter"
+
+interface ElectricalNetIdentity {
+  connectionNetKeys: Map<string, string>
+  tokenNetKeys: Map<string, Set<string>>
+}
+
+const identityCache = new WeakMap<SimpleRouteJson, ElectricalNetIdentity>()
+
+export function getConnectionNetKey(connection: SimpleRouteConnection): string {
+  return (
+    connection.netConnectionName ??
+    connection.rootConnectionName ??
+    connection.name
+  )
+}
+
+function addTokenNet(
+  tokenNetKeys: Map<string, Set<string>>,
+  token: string | undefined,
+  netKey: string,
+): boolean {
+  if (!token) return false
+  const keys = tokenNetKeys.get(token) ?? new Set<string>()
+  const sizeBefore = keys.size
+  keys.add(netKey)
+  tokenNetKeys.set(token, keys)
+  return keys.size !== sizeBefore
+}
+
+function getKnownNetKeys(
+  tokenNetKeys: Map<string, Set<string>>,
+  tokens: readonly string[],
+): Set<string> {
+  const keys = new Set<string>()
+  for (const token of tokens) {
+    for (const key of tokenNetKeys.get(token) ?? []) keys.add(key)
+  }
+  return keys
+}
+
+function createElectricalNetIdentity(
+  srj: SimpleRouteJson,
+): ElectricalNetIdentity {
+  const connectionNetKeys = new Map<string, string>()
+  const tokenNetKeys = new Map<string, Set<string>>()
+
+  for (const connection of srj.connections) {
+    const netKey = getConnectionNetKey(connection)
+    connectionNetKeys.set(connection.name, netKey)
+    addTokenNet(tokenNetKeys, connection.name, netKey)
+    addTokenNet(tokenNetKeys, connection.rootConnectionName, netKey)
+    addTokenNet(tokenNetKeys, connection.netConnectionName, netKey)
+    for (const point of connection.pointsToConnect) {
+      addTokenNet(tokenNetKeys, point.pointId, netKey)
+      addTokenNet(tokenNetKeys, point.pcb_port_id, netKey)
+    }
+  }
+
+  for (const trace of srj.traces ?? []) {
+    const netKey = trace.connection_name
+      ? connectionNetKeys.get(trace.connection_name)
+      : undefined
+    if (!netKey) continue
+    addTokenNet(tokenNetKeys, trace.pcb_trace_id, netKey)
+    for (const token of trace.connectsTo ?? []) {
+      addTokenNet(tokenNetKeys, token, netKey)
+    }
+  }
+
+  // Obstacle metadata often contains both a connection id and a lower-level
+  // connectivity id. Propagate the known net across that metadata so another
+  // pad that only names the connectivity id is still recognized as same-net.
+  for (let pass = 0; pass < 2; pass++) {
+    let changed = false
+    for (const obstacle of srj.obstacles) {
+      const netKeys = getKnownNetKeys(tokenNetKeys, obstacle.connectedTo)
+      if (netKeys.size !== 1) continue
+      const netKey = [...netKeys][0]!
+      for (const token of obstacle.connectedTo) {
+        changed = addTokenNet(tokenNetKeys, token, netKey) || changed
+      }
+    }
+    if (!changed) break
+  }
+
+  const parentByNetKey = new Map<string, string>()
+  const findRoot = (netKey: string): string => {
+    const parent = parentByNetKey.get(netKey) ?? netKey
+    parentByNetKey.set(netKey, parent)
+    if (parent === netKey) return netKey
+    const root = findRoot(parent)
+    parentByNetKey.set(netKey, root)
+    return root
+  }
+  const union = (first: string, second: string): void => {
+    const firstRoot = findRoot(first)
+    const secondRoot = findRoot(second)
+    if (firstRoot !== secondRoot) parentByNetKey.set(secondRoot, firstRoot)
+  }
+  for (const netKeys of tokenNetKeys.values()) {
+    const [firstNetKey, ...otherNetKeys] = [...netKeys]
+    if (!firstNetKey) continue
+    for (const otherNetKey of otherNetKeys) union(firstNetKey, otherNetKey)
+  }
+  for (const connectedTokens of [
+    ...srj.obstacles.map((obstacle) => obstacle.connectedTo),
+    ...(srj.traces ?? []).map((trace) => trace.connectsTo ?? []),
+  ]) {
+    const [firstNetKey, ...otherNetKeys] = [
+      ...getKnownNetKeys(tokenNetKeys, connectedTokens),
+    ]
+    if (!firstNetKey) continue
+    for (const otherNetKey of otherNetKeys) union(firstNetKey, otherNetKey)
+  }
+  for (const [connectionName, netKey] of connectionNetKeys) {
+    connectionNetKeys.set(connectionName, findRoot(netKey))
+  }
+  for (const [token, netKeys] of tokenNetKeys) {
+    tokenNetKeys.set(
+      token,
+      new Set([...netKeys].map((netKey) => findRoot(netKey))),
+    )
+  }
+
+  return { connectionNetKeys, tokenNetKeys }
+}
+
+function getElectricalNetIdentity(srj: SimpleRouteJson): ElectricalNetIdentity {
+  const cached = identityCache.get(srj)
+  if (cached) return cached
+  const identity = createElectricalNetIdentity(srj)
+  identityCache.set(srj, identity)
+  return identity
+}
+
+export function connectionsShareElectricalNet(
+  srj: SimpleRouteJson,
+  firstConnectionName: string,
+  secondConnectionName: string,
+): boolean {
+  const identity = getElectricalNetIdentity(srj)
+  const firstNet = identity.connectionNetKeys.get(firstConnectionName)
+  const secondNet = identity.connectionNetKeys.get(secondConnectionName)
+  return firstNet !== undefined && firstNet === secondNet
+}
+
+export function obstacleSharesElectricalNet(
+  srj: SimpleRouteJson,
+  obstacle: Obstacle,
+  connectionName: string,
+): boolean {
+  const identity = getElectricalNetIdentity(srj)
+  const connectionNet = identity.connectionNetKeys.get(connectionName)
+  if (!connectionNet) return false
+  return obstacle.connectedTo.some((token) =>
+    identity.tokenNetKeys.get(token)?.has(connectionNet),
+  )
+}