@tscircuit/core 0.0.1651 → 0.0.1652

package/dist/index.js

@@ -17548,108 +17548,6 @@ function buildOutputSimpleRouteJson(params) {
   };
 }
 
-// node_modules/@tscircuit/fanout-solver/lib/geometry.ts
-var EPSILON = 1e-9;
-function obstacleIsCircular(obstacle) {
-  return obstacle.shape === "circle";
-}
-function distance9(a, b) {
-  return Math.hypot(a.x - b.x, a.y - b.y);
-}
-function distancePointToSegment(point6, start, end) {
-  const dx = end.x - start.x;
-  const dy = end.y - start.y;
-  const lengthSquared = dx * dx + dy * dy;
-  const rawT = lengthSquared < EPSILON ? 0 : ((point6.x - start.x) * dx + (point6.y - start.y) * dy) / lengthSquared;
-  const t = Math.max(0, Math.min(1, rawT));
-  return Math.hypot(point6.x - (start.x + t * dx), point6.y - (start.y + t * dy));
-}
-function cross(origin, a, b) {
-  return (a.x - origin.x) * (b.y - origin.y) - (a.y - origin.y) * (b.x - origin.x);
-}
-function segmentsProperlyCross(a, b, c, d) {
-  const d1 = cross(c, d, a);
-  const d2 = cross(c, d, b);
-  const d3 = cross(a, b, c);
-  const d4 = cross(a, b, d);
-  return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
-}
-function distanceSegmentToSegment(firstStart, firstEnd, secondStart, secondEnd) {
-  if (segmentsProperlyCross(firstStart, firstEnd, secondStart, secondEnd)) {
-    return 0;
-  }
-  return Math.min(
-    distancePointToSegment(firstStart, secondStart, secondEnd),
-    distancePointToSegment(firstEnd, secondStart, secondEnd),
-    distancePointToSegment(secondStart, firstStart, firstEnd),
-    distancePointToSegment(secondEnd, firstStart, firstEnd)
-  );
-}
-function pointIsInsideObstacle(point6, obstacle, tolerance = EPSILON) {
-  if (obstacleIsCircular(obstacle)) {
-    return distance9(point6, obstacle.center) <= obstacle.width / 2 + tolerance;
-  }
-  return Math.abs(point6.x - obstacle.center.x) <= obstacle.width / 2 + tolerance && Math.abs(point6.y - obstacle.center.y) <= obstacle.height / 2 + tolerance;
-}
-function distancePointToObstacle(point6, obstacle) {
-  if (obstacleIsCircular(obstacle)) {
-    return Math.max(0, distance9(point6, obstacle.center) - obstacle.width / 2);
-  }
-  const dx = Math.max(
-    Math.abs(point6.x - obstacle.center.x) - obstacle.width / 2,
-    0
-  );
-  const dy = Math.max(
-    Math.abs(point6.y - obstacle.center.y) - obstacle.height / 2,
-    0
-  );
-  return Math.hypot(dx, dy);
-}
-function distanceSegmentToObstacle(segment2, obstacle) {
-  if (obstacleIsCircular(obstacle)) {
-    return Math.max(
-      0,
-      distancePointToSegment(obstacle.center, segment2.start, segment2.end) - obstacle.width / 2
-    );
-  }
-  if (pointIsInsideObstacle(segment2.start, obstacle) || pointIsInsideObstacle(segment2.end, obstacle)) {
-    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 corners = [
-    { x: minX, y: minY },
-    { x: maxX, y: minY },
-    { x: maxX, y: maxY },
-    { x: minX, y: maxY }
-  ];
-  let minimumDistance = Number.POSITIVE_INFINITY;
-  for (let index = 0; index < corners.length; index++) {
-    minimumDistance = Math.min(
-      minimumDistance,
-      distanceSegmentToSegment(
-        segment2.start,
-        segment2.end,
-        corners[index],
-        corners[(index + 1) % corners.length]
-      )
-    );
-  }
-  return minimumDistance;
-}
-function segmentsAreClear(first, second, clearance) {
-  if (first.layer !== second.layer) return true;
-  const requiredDistance = (first.width + second.width) / 2 + clearance;
-  return distanceSegmentToSegment(
-    first.start,
-    first.end,
-    second.start,
-    second.end
-  ) >= requiredDistance - EPSILON;
-}
-
 // node_modules/@tscircuit/fanout-solver/lib/layer-colors.ts
 var COPPER_LAYER_COLORS = [
   "#ef4444",
@@ -17703,7 +17601,7 @@ function getLayerSpan(fromLayer, toLayer, layerNames) {
   return layerNames.slice(firstIndex, lastIndex + 1);
 }
 function generateLayerAssignments(params) {
-  const { busIds, layers, maxAssignments } = params;
+  const { busIds, layers, layersByBusId, maxAssignments } = params;
   if (layers.length === 0) {
     throw new Error("FanoutSolver: no escape layers are available");
   }
@@ -17712,7 +17610,21 @@ function generateLayerAssignments(params) {
       `FanoutSolver: maxLayerCombinations must be positive, received ${maxAssignments}`
     );
   }
-  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
@@ -17722,7 +17634,7 @@ function generateLayerAssignments(params) {
   function addAssignment(layerIndexes) {
     const assignment = {};
     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;
@@ -17734,9 +17646,10 @@ function generateLayerAssignments(params) {
       const layerIndexes = [];
       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);
     }
@@ -17749,33 +17662,148 @@ function generateLayerAssignments(params) {
     return (mixed ^ mixed >>> 15) >>> 0;
   }
   const balancedLayerIndexes = busIds.map(
-    (_, busIndex) => busIndex % layers.length
+    (_, busIndex) => busIndex % availableLayersByBus[busIndex].length
   );
   addAssignment(balancedLayerIndexes);
-  for (let globalShift = 1; globalShift < layers.length && assignments.length < combinationCount; globalShift++) {
+  const maximumAvailableLayerCount = Math.max(
+    ...availableLayersByBus.map((availableLayers) => availableLayers.length)
+  );
+  for (let globalShift = 1; globalShift < maximumAvailableLayerCount && assignments.length < combinationCount; globalShift++) {
     addAssignment(
       balancedLayerIndexes.map(
-        (layerIndex) => (layerIndex + globalShift) % layers.length
+        (layerIndex, busIndex) => (layerIndex + globalShift) % availableLayersByBus[busIndex].length
       )
     );
   }
   for (let busIndex = 0; busIndex < busIds.length && assignments.length < combinationCount; busIndex++) {
-    for (let shift = 1; shift < layers.length && assignments.length < combinationCount; shift++) {
+    for (let shift = 1; shift < availableLayersByBus[busIndex].length && assignments.length < combinationCount; shift++) {
       const layerIndexes = [...balancedLayerIndexes];
-      layerIndexes[busIndex] = (balancedLayerIndexes[busIndex] + shift) % layers.length;
+      layerIndexes[busIndex] = (balancedLayerIndexes[busIndex] + shift) % availableLayersByBus[busIndex].length;
       addAssignment(layerIndexes);
     }
   }
   for (let seed = 1; assignments.length < combinationCount && seed < combinationCount * 20; seed++) {
     addAssignment(
       busIds.map(
-        (_, busIndex) => mix32(seed * 2654435761 + busIndex * 2246822507) % layers.length
+        (_, busIndex) => mix32(seed * 2654435761 + busIndex * 2246822507) % availableLayersByBus[busIndex].length
       )
     );
   }
   return assignments;
 }
 
+// node_modules/@tscircuit/fanout-solver/lib/geometry.ts
+var EPSILON = 1e-9;
+function obstacleIsCircular(obstacle) {
+  return obstacle.shape === "circle";
+}
+function toObstacleLocalPoint(point6, obstacle) {
+  const rotationRadians = -(obstacle.ccwRotationDegrees ?? 0) * Math.PI / 180;
+  const dx = point6.x - obstacle.center.x;
+  const dy = point6.y - obstacle.center.y;
+  return {
+    x: dx * Math.cos(rotationRadians) - dy * Math.sin(rotationRadians),
+    y: dx * Math.sin(rotationRadians) + dy * Math.cos(rotationRadians)
+  };
+}
+function distance9(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function distancePointToSegment(point6, start, end) {
+  const dx = end.x - start.x;
+  const dy = end.y - start.y;
+  const lengthSquared = dx * dx + dy * dy;
+  const rawT = lengthSquared < EPSILON ? 0 : ((point6.x - start.x) * dx + (point6.y - start.y) * dy) / lengthSquared;
+  const t = Math.max(0, Math.min(1, rawT));
+  return Math.hypot(point6.x - (start.x + t * dx), point6.y - (start.y + t * dy));
+}
+function cross(origin, a, b) {
+  return (a.x - origin.x) * (b.y - origin.y) - (a.y - origin.y) * (b.x - origin.x);
+}
+function segmentsProperlyCross(a, b, c, d) {
+  const d1 = cross(c, d, a);
+  const d2 = cross(c, d, b);
+  const d3 = cross(a, b, c);
+  const d4 = cross(a, b, d);
+  return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
+}
+function distanceSegmentToSegment(firstStart, firstEnd, secondStart, secondEnd) {
+  if (segmentsProperlyCross(firstStart, firstEnd, secondStart, secondEnd)) {
+    return 0;
+  }
+  return Math.min(
+    distancePointToSegment(firstStart, secondStart, secondEnd),
+    distancePointToSegment(firstEnd, secondStart, secondEnd),
+    distancePointToSegment(secondStart, firstStart, firstEnd),
+    distancePointToSegment(secondEnd, firstStart, firstEnd)
+  );
+}
+function pointIsInsideObstacle(point6, obstacle, tolerance = EPSILON) {
+  if (obstacleIsCircular(obstacle)) {
+    return distance9(point6, obstacle.center) <= obstacle.width / 2 + tolerance;
+  }
+  const localPoint = toObstacleLocalPoint(point6, obstacle);
+  return Math.abs(localPoint.x) <= obstacle.width / 2 + tolerance && Math.abs(localPoint.y) <= obstacle.height / 2 + tolerance;
+}
+function distancePointToObstacle(point6, obstacle) {
+  if (obstacleIsCircular(obstacle)) {
+    return Math.max(0, distance9(point6, obstacle.center) - obstacle.width / 2);
+  }
+  const localPoint = toObstacleLocalPoint(point6, 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);
+}
+function distanceSegmentToObstacle(segment2, obstacle) {
+  if (obstacleIsCircular(obstacle)) {
+    return Math.max(
+      0,
+      distancePointToSegment(obstacle.center, segment2.start, segment2.end) - obstacle.width / 2
+    );
+  }
+  const localStart = toObstacleLocalPoint(segment2.start, obstacle);
+  const localEnd = toObstacleLocalPoint(segment2.end, obstacle);
+  if (Math.abs(localStart.x) <= obstacle.width / 2 + EPSILON && Math.abs(localStart.y) <= obstacle.height / 2 + EPSILON) {
+    return 0;
+  }
+  if (Math.abs(localEnd.x) <= obstacle.width / 2 + EPSILON && Math.abs(localEnd.y) <= obstacle.height / 2 + EPSILON) {
+    return 0;
+  }
+  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 },
+    { x: maxX, y: maxY },
+    { x: minX, y: maxY }
+  ];
+  let minimumDistance = Number.POSITIVE_INFINITY;
+  for (let index = 0; index < corners.length; index++) {
+    minimumDistance = Math.min(
+      minimumDistance,
+      distanceSegmentToSegment(
+        localStart,
+        localEnd,
+        corners[index],
+        corners[(index + 1) % corners.length]
+      )
+    );
+  }
+  return minimumDistance;
+}
+function segmentsAreClear(first, second, clearance) {
+  if (first.layer !== second.layer) return true;
+  const requiredDistance = (first.width + second.width) / 2 + clearance;
+  return distanceSegmentToSegment(
+    first.start,
+    first.end,
+    second.start,
+    second.end
+  ) >= requiredDistance - EPSILON;
+}
+
 // node_modules/@tscircuit/fanout-solver/lib/prepare-buses.ts
 var FANOUT_BORDER_TARGETS = /* @__PURE__ */ new Set([
   "left",
@@ -18525,6 +18553,122 @@ function prepareFanoutBuses(srj, options) {
   return buses;
 }
 
+// node_modules/@tscircuit/fanout-solver/lib/net-identity.ts
+var identityCache = /* @__PURE__ */ new WeakMap();
+function getConnectionNetKey(connection) {
+  return connection.netConnectionName ?? connection.rootConnectionName ?? connection.name;
+}
+function addTokenNet(tokenNetKeys, token, netKey) {
+  if (!token) return false;
+  const keys = tokenNetKeys.get(token) ?? /* @__PURE__ */ new Set();
+  const sizeBefore = keys.size;
+  keys.add(netKey);
+  tokenNetKeys.set(token, keys);
+  return keys.size !== sizeBefore;
+}
+function getKnownNetKeys(tokenNetKeys, tokens) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    for (const key of tokenNetKeys.get(token) ?? []) keys.add(key);
+  }
+  return keys;
+}
+function createElectricalNetIdentity(srj) {
+  const connectionNetKeys = /* @__PURE__ */ new Map();
+  const tokenNetKeys = /* @__PURE__ */ new Map();
+  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 point6 of connection.pointsToConnect) {
+      addTokenNet(tokenNetKeys, point6.pointId, netKey);
+      addTokenNet(tokenNetKeys, point6.pcb_port_id, netKey);
+    }
+  }
+  for (const trace of srj.traces ?? []) {
+    const netKey = trace.connection_name ? connectionNetKeys.get(trace.connection_name) : void 0;
+    if (!netKey) continue;
+    addTokenNet(tokenNetKeys, trace.pcb_trace_id, netKey);
+    for (const token of trace.connectsTo ?? []) {
+      addTokenNet(tokenNetKeys, token, netKey);
+    }
+  }
+  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 = /* @__PURE__ */ new Map();
+  const findRoot = (netKey) => {
+    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, second) => {
+    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) {
+  const cached = identityCache.get(srj);
+  if (cached) return cached;
+  const identity9 = createElectricalNetIdentity(srj);
+  identityCache.set(srj, identity9);
+  return identity9;
+}
+function connectionsShareElectricalNet(srj, firstConnectionName, secondConnectionName) {
+  const identity9 = getElectricalNetIdentity(srj);
+  const firstNet = identity9.connectionNetKeys.get(firstConnectionName);
+  const secondNet = identity9.connectionNetKeys.get(secondConnectionName);
+  return firstNet !== void 0 && firstNet === secondNet;
+}
+function obstacleSharesElectricalNet(srj, obstacle, connectionName) {
+  const identity9 = getElectricalNetIdentity(srj);
+  const connectionNet = identity9.connectionNetKeys.get(connectionName);
+  if (!connectionNet) return false;
+  return obstacle.connectedTo.some(
+    (token) => identity9.tokenNetKeys.get(token)?.has(connectionNet)
+  );
+}
+
 // node_modules/@tscircuit/fanout-solver/lib/route-bus.ts
 function isHorizontal(direction) {
   return direction === "left" || direction === "right";
@@ -18935,10 +19079,21 @@ function buildPlan(params) {
   };
 }
 function segmentIsClearOfObstacles(params) {
-  const { segment: segment2, plan, segmentIndex, obstacles, clearance } = params;
+  const {
+    segment: segment2,
+    plan,
+    segmentIndex,
+    srj,
+    allowSameNetMerges,
+    obstacles,
+    clearance
+  } = params;
   for (const obstacle of obstacles) {
     if (!obstacle.layers.includes(segment2.layer)) continue;
     if (obstacle.connectedTo.includes(plan.connectionName)) continue;
+    if (allowSameNetMerges && obstacleSharesElectricalNet(srj, obstacle, plan.connectionName)) {
+      continue;
+    }
     if (segmentIndex === 0 && obstacle === plan.sourceObstacle && segment2.layer === plan.sourceLayer) {
       continue;
     }
@@ -18948,8 +19103,8 @@ function segmentIsClearOfObstacles(params) {
   }
   return true;
 }
-function planIsClear(params) {
-  const { plan, otherPlans, srj, sharedBoundary, clearance } = params;
+function planIsStaticallyClear(params) {
+  const { plan, srj, sharedBoundary, clearance, allowSameNetMerges } = params;
   const routableBounds = getRoutableBounds(srj.bounds, sharedBoundary);
   if (!pointIsInsideBounds(plan.exitPoint, routableBounds) || plan.segments.some(
     (segment2) => !pointIsInsideBounds(segment2.start, routableBounds) || !pointIsInsideBounds(segment2.end, routableBounds)
@@ -18961,6 +19116,8 @@ function planIsClear(params) {
       segment: plan.segments[index],
       plan,
       segmentIndex: index,
+      srj,
+      allowSameNetMerges,
       obstacles: srj.obstacles,
       clearance
     })) {
@@ -18972,21 +19129,55 @@ function planIsClear(params) {
       if (!obstacle.layers.some((layer) => plan.via.spanLayers.includes(layer))) {
         continue;
       }
+      if (allowSameNetMerges && obstacleSharesElectricalNet(srj, obstacle, plan.connectionName)) {
+        continue;
+      }
       if (distancePointToObstacle(plan.via.center, obstacle) < plan.via.diameter / 2 + clearance - 1e-9) {
         return false;
       }
     }
   }
+  return true;
+}
+function planIsClearOfPlans(params) {
+  const {
+    plan,
+    otherPlans,
+    srj,
+    allowSameNetMerges,
+    clearance,
+    blockingBusCounts
+  } = params;
   for (const otherPlan of otherPlans) {
+    if (allowSameNetMerges && connectionsShareElectricalNet(
+      srj,
+      plan.connectionName,
+      otherPlan.connectionName
+    )) {
+      continue;
+    }
+    const plansShareSourcePort = plan.sourcePoint.pcb_port_id && plan.sourcePoint.pcb_port_id === otherPlan.sourcePoint.pcb_port_id || plan.sourcePoint.pointId && plan.sourcePoint.pointId === otherPlan.sourcePoint.pointId;
+    if (plansShareSourcePort) continue;
+    const recordBlocker = () => {
+      if (otherPlan.busId === plan.busId) return;
+      blockingBusCounts?.set(
+        otherPlan.busId,
+        (blockingBusCounts.get(otherPlan.busId) ?? 0) + 1
+      );
+    };
     for (const segment2 of plan.segments) {
       for (const otherSegment of otherPlan.segments) {
-        if (!segmentsAreClear(segment2, otherSegment, clearance)) return false;
+        if (!segmentsAreClear(segment2, otherSegment, clearance)) {
+          recordBlocker();
+          return false;
+        }
       }
       if (otherPlan.via?.spanLayers.includes(segment2.layer) && distancePointToSegment(
         otherPlan.via.center,
         segment2.start,
         segment2.end
       ) < otherPlan.via.diameter / 2 + segment2.width / 2 + clearance - 1e-9) {
+        recordBlocker();
         return false;
       }
     }
@@ -18997,18 +19188,52 @@ function planIsClear(params) {
           otherSegment.start,
           otherSegment.end
         ) < plan.via.diameter / 2 + otherSegment.width / 2 + clearance - 1e-9) {
+          recordBlocker();
           return false;
         }
       }
       if (otherPlan.via && plan.via.spanLayers.some(
         (layer) => otherPlan.via.spanLayers.includes(layer)
       ) && distance9(plan.via.center, otherPlan.via.center) < (plan.via.diameter + otherPlan.via.diameter) / 2 + clearance - 1e-9) {
+        recordBlocker();
         return false;
       }
     }
   }
   return true;
 }
+function planIsClear(params) {
+  const {
+    plan,
+    otherPlans,
+    staticClearanceCache,
+    blockingBusCounts,
+    cacheKey,
+    srj,
+    sharedBoundary,
+    clearance,
+    allowSameNetMerges
+  } = params;
+  let staticallyClear = staticClearanceCache?.get(cacheKey);
+  if (staticallyClear === void 0) {
+    staticallyClear = planIsStaticallyClear({
+      plan,
+      srj,
+      sharedBoundary,
+      clearance,
+      allowSameNetMerges
+    });
+    staticClearanceCache?.set(cacheKey, staticallyClear);
+  }
+  return staticallyClear && planIsClearOfPlans({
+    plan,
+    otherPlans,
+    srj,
+    allowSameNetMerges,
+    clearance,
+    blockingBusCounts
+  });
+}
 function routePlaneTerminatedBus(params) {
   const {
     srj,
@@ -19019,7 +19244,10 @@ function routePlaneTerminatedBus(params) {
     traceWidth,
     viaDiameter,
     viaHoleDiameter,
-    clearance
+    clearance,
+    staticClearanceCache,
+    blockingBusCounts,
+    allowSameNetMerges = false
   } = params;
   const sourceObstacle = bus.connections[0]?.sourceObstacle;
   if (!sourceObstacle || bus.termination.type !== "plane") return null;
@@ -19056,9 +19284,13 @@ function routePlaneTerminatedBus(params) {
         if (!planIsClear({
           plan,
           otherPlans: [...acceptedPlans, ...candidatePlans],
+          staticClearanceCache,
+          blockingBusCounts,
+          cacheKey: `plane:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${viaHandedness}`,
           srj,
           sharedBoundary: bus.sharedBoundary,
-          clearance
+          clearance,
+          allowSameNetMerges
         })) {
           orderIsClear = false;
           break;
@@ -19070,7 +19302,7 @@ function routePlaneTerminatedBus(params) {
   }
   return null;
 }
-function routeBus(params) {
+function routeBusAlternatives(params, maxAlternatives = 1) {
   const {
     srj,
     bus,
@@ -19081,14 +19313,23 @@ function routeBus(params) {
     viaDiameter,
     viaHoleDiameter,
     clearance,
-    compactBusTracks
+    compactBusTracks,
+    staticClearanceCache,
+    blockingBusCounts,
+    allowSameNetMerges = false
   } = params;
-  if (bus.termination.type === "plane") {
-    return routePlaneTerminatedBus(params);
-  }
+  if (!Number.isInteger(maxAlternatives) || maxAlternatives < 1) {
+    throw new Error(
+      `FanoutSolver: maxAlternatives must be a positive integer, received ${maxAlternatives}`
+    );
+  }
+  if (bus.termination.type === "plane") {
+    const plan = routePlaneTerminatedBus(params);
+    return plan ? [plan] : [];
+  }
   const exitAxis = getExitAxis(bus);
   const sourceObstacle = bus.connections[0]?.sourceObstacle;
-  if (!sourceObstacle) return [];
+  if (!sourceObstacle) return [[]];
   const directionalPadSize = isHorizontal(bus.direction) ? sourceObstacle.width : sourceObstacle.height;
   const sourceLayer = bus.connections[0].sourceLayer;
   const targetUsesVia = targetLayer !== sourceLayer;
@@ -19096,68 +19337,94 @@ function routeBus(params) {
   const pairChannelFitsVia = getDirectionalPitch(bus) / 2 - directionalPadSize / 2 >= viaDiameter / 2 + clearance - 1e-9;
   const interstitialEscape = targetUsesVia && !outwardEdgeBus && !pairChannelFitsVia;
   const viaHandednesses = targetUsesVia ? pairChannelFitsVia || outwardEdgeBus ? [0] : [1, -1] : [0];
+  const alternatives = [];
+  const seenAlternativeKeys = /* @__PURE__ */ new Set();
+  const addAlternative = (plans) => {
+    const key = plans.map(
+      (plan) => `${plan.connectionIndex}:${plan.targetLayer}:${plan.exitPoint.x}:${plan.exitPoint.y}:${plan.segments.map((segment2) => `${segment2.start.x},${segment2.start.y},${segment2.end.x},${segment2.end.y},${segment2.layer}`).join(";")}`
+    ).join("|");
+    if (seenAlternativeKeys.has(key)) return;
+    seenAlternativeKeys.add(key);
+    alternatives.push(plans);
+  };
+  const searchConnectionOrder = (connectionOrder, viaHandedness, connectionIndex, candidatePlans) => {
+    if (alternatives.length >= maxAlternatives) return;
+    if (connectionIndex >= connectionOrder.length) {
+      addAlternative(candidatePlans);
+      return;
+    }
+    const preparedConnection = connectionOrder[connectionIndex];
+    const connectionRank = getConnectionRank(bus, preparedConnection);
+    const trackCandidates = getTrackCandidates({
+      bus,
+      connection: preparedConnection,
+      preferredTrack: getPreferredTrack({
+        bus,
+        connection: preparedConnection,
+        targetUsesVia,
+        interstitialEscape,
+        compactBusTracks,
+        traceWidth,
+        viaDiameter,
+        clearance
+      }),
+      traceWidth,
+      clearance
+    });
+    for (let trackIndex = 0; trackIndex < trackCandidates.length; trackIndex++) {
+      const track = trackCandidates[trackIndex];
+      const plan = buildPlan({
+        preparedConnection,
+        bus,
+        targetLayer,
+        track: track.value,
+        exitAxis,
+        layerNames,
+        traceWidth,
+        viaDiameter,
+        viaHoleDiameter,
+        viaHandedness,
+        interstitialEscape,
+        spreadLaneIndex: Math.min(
+          connectionRank,
+          bus.connections.length - connectionRank - 1
+        ),
+        clearance,
+        terminateAtVia: false
+      });
+      if (!planIsClear({
+        plan,
+        otherPlans: [...acceptedPlans, ...candidatePlans],
+        staticClearanceCache,
+        blockingBusCounts,
+        cacheKey: `boundary:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${viaHandedness}:${trackIndex}`,
+        srj,
+        sharedBoundary: bus.sharedBoundary,
+        clearance,
+        allowSameNetMerges
+      })) {
+        continue;
+      }
+      searchConnectionOrder(
+        connectionOrder,
+        viaHandedness,
+        connectionIndex + 1,
+        [...candidatePlans, plan]
+      );
+      if (alternatives.length >= maxAlternatives) return;
+      if (maxAlternatives === 1) return;
+    }
+  };
   for (const viaHandedness of viaHandednesses) {
     for (const connectionOrder of getConnectionOrders(bus)) {
-      const candidatePlans = [];
-      let orderIsClear = true;
-      for (const preparedConnection of connectionOrder) {
-        let acceptedPlan = null;
-        for (const track of getTrackCandidates({
-          bus,
-          connection: preparedConnection,
-          preferredTrack: getPreferredTrack({
-            bus,
-            connection: preparedConnection,
-            targetUsesVia,
-            interstitialEscape,
-            compactBusTracks,
-            traceWidth,
-            viaDiameter,
-            clearance
-          }),
-          traceWidth,
-          clearance
-        })) {
-          const plan = buildPlan({
-            preparedConnection,
-            bus,
-            targetLayer,
-            track: track.value,
-            exitAxis,
-            layerNames,
-            traceWidth,
-            viaDiameter,
-            viaHoleDiameter,
-            viaHandedness,
-            interstitialEscape,
-            spreadLaneIndex: Math.min(
-              getConnectionRank(bus, preparedConnection),
-              bus.connections.length - getConnectionRank(bus, preparedConnection) - 1
-            ),
-            clearance,
-            terminateAtVia: false
-          });
-          if (planIsClear({
-            plan,
-            otherPlans: [...acceptedPlans, ...candidatePlans],
-            srj,
-            sharedBoundary: bus.sharedBoundary,
-            clearance
-          })) {
-            acceptedPlan = plan;
-            break;
-          }
-        }
-        if (!acceptedPlan) {
-          orderIsClear = false;
-          break;
-        }
-        candidatePlans.push(acceptedPlan);
-      }
-      if (orderIsClear) return candidatePlans;
+      searchConnectionOrder(connectionOrder, viaHandedness, 0, []);
+      if (alternatives.length >= maxAlternatives) return alternatives;
     }
   }
-  return null;
+  return alternatives;
+}
+function routeBus(params) {
+  return routeBusAlternatives(params, 1)[0] ?? null;
 }
 
 // node_modules/@tscircuit/fanout-solver/lib/route-single-layer-adaptive-exits.ts
@@ -20978,6 +21245,539 @@ function routeSingleLayerWithPushAndShove(params) {
   return paths.map(buildPlan3);
 }
 
+// node_modules/@tscircuit/fanout-solver/lib/validate-fanout-solution.ts
+var EPSILON3 = 1e-6;
+function pointsMatch(first, second) {
+  return distance9(first, second) <= EPSILON3;
+}
+function getPointLayers2(point6) {
+  return "layer" in point6 ? [point6.layer] : point6.layers;
+}
+function connectionPointsMatch(first, second) {
+  return pointsMatch(first, second) && getPointLayers2(first).join("\0") === getPointLayers2(second).join("\0") && first.pointId === second.pointId && first.pcb_port_id === second.pcb_port_id;
+}
+function pointIsOnBoundary(point6, boundary) {
+  const inside = point6.x >= boundary.minX - EPSILON3 && point6.x <= boundary.maxX + EPSILON3 && point6.y >= boundary.minY - EPSILON3 && point6.y <= boundary.maxY + EPSILON3;
+  const onEdge = Math.abs(point6.x - boundary.minX) <= EPSILON3 || Math.abs(point6.x - boundary.maxX) <= EPSILON3 || Math.abs(point6.y - boundary.minY) <= EPSILON3 || Math.abs(point6.y - boundary.maxY) <= EPSILON3;
+  return inside && onEdge;
+}
+function pointIsInsideBounds2(point6, bounds) {
+  return point6.x >= bounds.minX - EPSILON3 && point6.x <= bounds.maxX + EPSILON3 && point6.y >= bounds.minY - EPSILON3 && point6.y <= bounds.maxY + EPSILON3;
+}
+function addIssue(issues, code, message, plan, otherConnectionName) {
+  issues.push({
+    code,
+    message,
+    ...plan ? {
+      connectionName: plan.connectionName,
+      busId: plan.busId
+    } : {},
+    ...otherConnectionName ? { otherConnectionName } : {}
+  });
+}
+function extractTraceSegments(params) {
+  const { trace, plan, issues } = params;
+  const segments = [];
+  let previousWire;
+  let pendingVia;
+  for (const routePoint of trace.route) {
+    if (routePoint.route_type === "via") {
+      if (!previousWire || !pointsMatch(previousWire, routePoint) || previousWire.layer !== routePoint.from_layer) {
+        addIssue(
+          issues,
+          "disconnected-trace",
+          `Trace ${trace.pcb_trace_id} reaches a via without a matching ${routePoint.from_layer} wire endpoint`,
+          plan
+        );
+      }
+      pendingVia = routePoint;
+      continue;
+    }
+    if (routePoint.route_type !== "wire") {
+      addIssue(
+        issues,
+        "unsupported-route-point",
+        `Trace ${trace.pcb_trace_id} contains unsupported ${routePoint.route_type} geometry`,
+        plan
+      );
+      continue;
+    }
+    if (pendingVia) {
+      if (!pointsMatch(routePoint, pendingVia) || routePoint.layer !== pendingVia.to_layer) {
+        addIssue(
+          issues,
+          "disconnected-trace",
+          `Trace ${trace.pcb_trace_id} does not continue from its via on ${pendingVia.to_layer}`,
+          plan
+        );
+      }
+      previousWire = routePoint;
+      pendingVia = void 0;
+      continue;
+    }
+    if (previousWire) {
+      if (previousWire.layer !== routePoint.layer) {
+        addIssue(
+          issues,
+          "disconnected-trace",
+          `Trace ${trace.pcb_trace_id} changes from ${previousWire.layer} to ${routePoint.layer} without a via`,
+          plan
+        );
+      } else if (!pointsMatch(previousWire, routePoint)) {
+        segments.push({
+          start: { x: previousWire.x, y: previousWire.y },
+          end: { x: routePoint.x, y: routePoint.y },
+          width: routePoint.width,
+          layer: routePoint.layer
+        });
+      }
+    }
+    previousWire = routePoint;
+  }
+  if (pendingVia) {
+    addIssue(
+      issues,
+      "disconnected-trace",
+      `Trace ${trace.pcb_trace_id} ends at a via without a wire on ${pendingVia.to_layer}`,
+      plan
+    );
+  }
+  return segments;
+}
+function validatePlanStructure(params) {
+  const { plan, preparedBus, inputSrj, outputSrj, sharedBoundary, issues } = params;
+  const inputConnection = inputSrj.connections[plan.connectionIndex];
+  if (!inputConnection || inputConnection.name !== plan.connectionName) {
+    addIssue(
+      issues,
+      "connection-mismatch",
+      `Plan index ${plan.connectionIndex} does not identify connection ${plan.connectionName}`,
+      plan
+    );
+    return;
+  }
+  const preparedConnection = preparedBus?.connections.find(
+    (connection) => connection.connectionIndex === plan.connectionIndex
+  );
+  if (!preparedConnection || preparedConnection.sourcePointIndex !== plan.sourcePointIndex || !connectionPointsMatch(preparedConnection.sourcePoint, plan.sourcePoint) || preparedConnection.sourceObstacle.obstacleId !== plan.sourceObstacle.obstacleId) {
+    addIssue(
+      issues,
+      "source-mismatch",
+      `Plan ${plan.connectionName} does not start at its prepared component endpoint`,
+      plan
+    );
+  }
+  if (preparedBus?.termination.type !== plan.termination.type) {
+    addIssue(
+      issues,
+      "termination-mismatch",
+      `Plan ${plan.connectionName} does not use its bus termination`,
+      plan
+    );
+  }
+  if (plan.segments.length === 0 || plan.length <= EPSILON3) {
+    addIssue(
+      issues,
+      "not-broken-out",
+      `Plan ${plan.connectionName} has no non-zero escape geometry`,
+      plan
+    );
+  } else {
+    const routableBounds = {
+      minX: Math.min(inputSrj.bounds.minX, sharedBoundary.minX),
+      maxX: Math.max(inputSrj.bounds.maxX, sharedBoundary.maxX),
+      minY: Math.min(inputSrj.bounds.minY, sharedBoundary.minY),
+      maxY: Math.max(inputSrj.bounds.maxY, sharedBoundary.maxY)
+    };
+    if (plan.segments.some(
+      (segment2) => !pointIsInsideBounds2(segment2.start, routableBounds) || !pointIsInsideBounds2(segment2.end, routableBounds)
+    )) {
+      addIssue(
+        issues,
+        "outside-routing-bounds",
+        `Plan ${plan.connectionName} leaves the routable SRJ/shared-boundary area`,
+        plan
+      );
+    }
+    if (!pointsMatch(plan.segments[0].start, plan.sourcePoint)) {
+      addIssue(
+        issues,
+        "disconnected-trace",
+        `Plan ${plan.connectionName} does not start at its source pad`,
+        plan
+      );
+    }
+    if (!pointsMatch(plan.segments.at(-1).end, plan.exitPoint)) {
+      addIssue(
+        issues,
+        "disconnected-trace",
+        `Plan ${plan.connectionName} does not end at its declared exit`,
+        plan
+      );
+    }
+    for (let index = 1; index < plan.segments.length; index++) {
+      const previous = plan.segments[index - 1];
+      const current = plan.segments[index];
+      if (!pointsMatch(previous.end, current.start)) {
+        addIssue(
+          issues,
+          "disconnected-trace",
+          `Plan ${plan.connectionName} has a gap between route segments`,
+          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))) {
+        addIssue(
+          issues,
+          "disconnected-trace",
+          `Plan ${plan.connectionName} changes layers without a connecting via`,
+          plan
+        );
+      }
+    }
+  }
+  const traceSegments = extractTraceSegments({
+    trace: plan.trace,
+    plan,
+    issues
+  });
+  if (traceSegments.length !== plan.segments.length || traceSegments.some((segment2, index) => {
+    const declared = plan.segments[index];
+    return !declared || segment2.layer !== declared.layer || Math.abs(segment2.width - declared.width) > EPSILON3 || !pointsMatch(segment2.start, declared.start) || !pointsMatch(segment2.end, declared.end);
+  })) {
+    addIssue(
+      issues,
+      "trace-plan-mismatch",
+      `Trace ${plan.trace.pcb_trace_id} does not encode its declared route segments`,
+      plan
+    );
+  }
+  const firstRoutePoint = plan.trace.route.find(
+    (routePoint) => "x" in routePoint && "y" in routePoint
+  );
+  const lastRoutePoint = [...plan.trace.route].reverse().find(
+    (routePoint) => "x" in routePoint && "y" in routePoint
+  );
+  if (!firstRoutePoint || !lastRoutePoint || !pointsMatch(firstRoutePoint, plan.sourcePoint) || !pointsMatch(lastRoutePoint, plan.exitPoint)) {
+    addIssue(
+      issues,
+      "disconnected-trace",
+      `Trace ${plan.trace.pcb_trace_id} does not span its source and exit`,
+      plan
+    );
+  }
+  const outputConnection = outputSrj.connections.find(
+    (connection) => connection.name === plan.connectionName
+  );
+  if (plan.termination.type === "boundary") {
+    if (!outputConnection) {
+      addIssue(
+        issues,
+        "output-connection-missing",
+        `Boundary connection ${plan.connectionName} was removed from the output`,
+        plan
+      );
+    } else {
+      const outputSource = outputConnection.pointsToConnect[plan.sourcePointIndex];
+      if (!outputSource || !pointsMatch(outputSource, plan.exitPoint) || !("layer" in outputSource) || outputSource.layer !== plan.targetLayer) {
+        addIssue(
+          issues,
+          "output-exit-mismatch",
+          `Output connection ${plan.connectionName} is not attached to its fanout exit`,
+          plan
+        );
+      }
+      for (let index = 0; index < inputConnection.pointsToConnect.length; index++) {
+        if (index === plan.sourcePointIndex) continue;
+        const inputPoint = inputConnection.pointsToConnect[index];
+        const outputPoint = outputConnection.pointsToConnect[index];
+        if (!inputPoint || !outputPoint || !connectionPointsMatch(inputPoint, outputPoint)) {
+          addIssue(
+            issues,
+            "downstream-endpoint-lost",
+            `Output connection ${plan.connectionName} did not retain downstream endpoint ${index}`,
+            plan
+          );
+        }
+      }
+    }
+  } else if (outputConnection) {
+    addIssue(
+      issues,
+      "plane-connection-retained",
+      `Plane-terminated connection ${plan.connectionName} remains in the output`,
+      plan
+    );
+  }
+}
+function plansHaveConnectedCopper(first, second) {
+  for (const firstSegment of first.segments) {
+    for (const secondSegment of second.segments) {
+      if (firstSegment.layer === secondSegment.layer && distanceSegmentToSegment(
+        firstSegment.start,
+        firstSegment.end,
+        secondSegment.start,
+        secondSegment.end
+      ) <= (firstSegment.width + secondSegment.width) / 2 + EPSILON3) {
+        return true;
+      }
+    }
+    if (second.via?.spanLayers.includes(firstSegment.layer) && distancePointToSegment(
+      second.via.center,
+      firstSegment.start,
+      firstSegment.end
+    ) <= second.via.diameter / 2 + firstSegment.width / 2 + EPSILON3) {
+      return true;
+    }
+  }
+  if (first.via) {
+    for (const secondSegment of second.segments) {
+      if (first.via.spanLayers.includes(secondSegment.layer) && distancePointToSegment(
+        first.via.center,
+        secondSegment.start,
+        secondSegment.end
+      ) <= first.via.diameter / 2 + secondSegment.width / 2 + EPSILON3) {
+        return true;
+      }
+    }
+    if (second.via && first.via.spanLayers.some(
+      (layer) => second.via.spanLayers.includes(layer)
+    ) && distance9(first.via.center, second.via.center) <= (first.via.diameter + second.via.diameter) / 2 + EPSILON3) {
+      return true;
+    }
+  }
+  return false;
+}
+function validateBreakoutConnectivity(params) {
+  const { plans, inputSrj, sharedBoundary, issues } = params;
+  const connectedPlans = /* @__PURE__ */ new Set();
+  const neighboringPlans = /* @__PURE__ */ new Map();
+  for (const plan of plans) neighboringPlans.set(plan, []);
+  for (let firstIndex = 0; firstIndex < plans.length; firstIndex++) {
+    const first = plans[firstIndex];
+    if (first.termination.type === "plane" ? Boolean(first.via) : first.segments.some(
+      (segment2) => pointIsOnBoundary(segment2.start, sharedBoundary) || pointIsOnBoundary(segment2.end, sharedBoundary)
+    )) {
+      connectedPlans.add(first);
+    }
+    for (let secondIndex = firstIndex + 1; secondIndex < plans.length; secondIndex++) {
+      const second = plans[secondIndex];
+      if (!connectionsShareElectricalNet(
+        inputSrj,
+        first.connectionName,
+        second.connectionName
+      ) || !plansHaveConnectedCopper(first, second)) {
+        continue;
+      }
+      neighboringPlans.get(first).push(second);
+      neighboringPlans.get(second).push(first);
+    }
+  }
+  const queue = [...connectedPlans];
+  while (queue.length > 0) {
+    const plan = queue.shift();
+    for (const neighbor of neighboringPlans.get(plan) ?? []) {
+      if (connectedPlans.has(neighbor)) continue;
+      connectedPlans.add(neighbor);
+      queue.push(neighbor);
+    }
+  }
+  for (const plan of plans) {
+    if (connectedPlans.has(plan)) continue;
+    addIssue(
+      issues,
+      "not-broken-out",
+      plan.termination.type === "boundary" ? `Connection ${plan.connectionName} has no continuous same-net copper path to the shared boundary` : `Plane connection ${plan.connectionName} has no terminating via`,
+      plan
+    );
+  }
+  return connectedPlans;
+}
+function validateClearances(params) {
+  const { plans, inputSrj, clearance, issues } = params;
+  for (const plan of plans) {
+    for (let segmentIndex = 0; segmentIndex < plan.segments.length; segmentIndex++) {
+      const segment2 = plan.segments[segmentIndex];
+      for (const obstacle of inputSrj.obstacles) {
+        if (!obstacle.layers.includes(segment2.layer)) continue;
+        if (obstacleSharesElectricalNet(inputSrj, obstacle, plan.connectionName)) {
+          continue;
+        }
+        if (segmentIndex === 0 && obstacle.obstacleId === plan.sourceObstacle.obstacleId && segment2.layer === plan.sourceLayer) {
+          continue;
+        }
+        const actual = distanceSegmentToObstacle(segment2, obstacle);
+        const required = segment2.width / 2 + clearance;
+        if (actual < required - 1e-9) {
+          addIssue(
+            issues,
+            "obstacle-clearance",
+            `Trace ${plan.connectionName} on ${segment2.layer} is ${actual.toFixed(4)}mm from different-net obstacle ${obstacle.obstacleId}; ${required.toFixed(4)}mm is required`,
+            plan
+          );
+        }
+      }
+    }
+    if (plan.via) {
+      for (const obstacle of inputSrj.obstacles) {
+        if (!obstacle.layers.some(
+          (layer) => plan.via.spanLayers.includes(layer)
+        ) || obstacleSharesElectricalNet(inputSrj, obstacle, plan.connectionName)) {
+          continue;
+        }
+        const actual = distancePointToObstacle(plan.via.center, obstacle);
+        const required = plan.via.diameter / 2 + clearance;
+        if (actual < required - 1e-9) {
+          addIssue(
+            issues,
+            "via-obstacle-clearance",
+            `Via ${plan.connectionName} is ${actual.toFixed(4)}mm from different-net obstacle ${obstacle.obstacleId} on its layer span; ${required.toFixed(4)}mm is required`,
+            plan
+          );
+        }
+      }
+    }
+  }
+  for (let firstIndex = 0; firstIndex < plans.length; firstIndex++) {
+    const first = plans[firstIndex];
+    for (let secondIndex = firstIndex + 1; secondIndex < plans.length; secondIndex++) {
+      const second = plans[secondIndex];
+      if (connectionsShareElectricalNet(
+        inputSrj,
+        first.connectionName,
+        second.connectionName
+      )) {
+        continue;
+      }
+      for (const firstSegment of first.segments) {
+        for (const secondSegment of second.segments) {
+          if (!segmentsAreClear(firstSegment, secondSegment, clearance)) {
+            addIssue(
+              issues,
+              "different-net-trace-clearance",
+              `Different-net traces ${first.connectionName} and ${second.connectionName} intersect or violate clearance on ${firstSegment.layer}`,
+              first,
+              second.connectionName
+            );
+          }
+        }
+        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
+          );
+        }
+      }
+      if (first.via) {
+        for (const secondSegment of second.segments) {
+          if (first.via.spanLayers.includes(secondSegment.layer) && distancePointToSegment(
+            first.via.center,
+            secondSegment.start,
+            secondSegment.end
+          ) < first.via.diameter / 2 + secondSegment.width / 2 + clearance - 1e-9) {
+            addIssue(
+              issues,
+              "different-net-trace-via-clearance",
+              `Via ${first.connectionName} violates trace clearance to ${second.connectionName} on ${secondSegment.layer}`,
+              first,
+              second.connectionName
+            );
+          }
+        }
+        if (second.via && first.via.spanLayers.some(
+          (layer) => second.via.spanLayers.includes(layer)
+        ) && distance9(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
+          );
+        }
+      }
+    }
+  }
+}
+function validateFanoutSolution(params) {
+  const {
+    inputSrj,
+    outputSrj,
+    plans,
+    preparedBuses,
+    sharedBoundary,
+    clearance
+  } = params;
+  const issues = [];
+  const plansByConnection = /* @__PURE__ */ new Map();
+  const preparedBusById = new Map(preparedBuses.map((bus) => [bus.busId, bus]));
+  for (const plan of plans) {
+    const connectionPlans = plansByConnection.get(plan.connectionName) ?? [];
+    connectionPlans.push(plan);
+    plansByConnection.set(plan.connectionName, connectionPlans);
+  }
+  for (const connection of inputSrj.connections) {
+    const connectionPlans = plansByConnection.get(connection.name) ?? [];
+    if (connectionPlans.length === 0) {
+      addIssue(
+        issues,
+        "missing-plan",
+        `Connection ${connection.name} has no fanout plan`
+      );
+    } else if (connectionPlans.length > 1) {
+      addIssue(
+        issues,
+        "duplicate-plan",
+        `Connection ${connection.name} has ${connectionPlans.length} fanout plans`,
+        connectionPlans[0]
+      );
+    }
+  }
+  for (const plan of plans) {
+    if (!inputSrj.connections.some(
+      (connection) => connection.name === plan.connectionName
+    )) {
+      addIssue(
+        issues,
+        "unknown-plan",
+        `Plan ${plan.connectionName} is not an input connection`,
+        plan
+      );
+      continue;
+    }
+    validatePlanStructure({
+      plan,
+      preparedBus: preparedBusById.get(plan.busId),
+      inputSrj,
+      outputSrj,
+      sharedBoundary,
+      issues
+    });
+  }
+  const connectedPlans = validateBreakoutConnectivity({
+    plans,
+    inputSrj,
+    sharedBoundary,
+    issues
+  });
+  validateClearances({ plans, inputSrj, clearance, issues });
+  return {
+    valid: issues.length === 0,
+    checkedConnectionCount: inputSrj.connections.length,
+    brokenOutConnectionCount: new Set(
+      [...connectedPlans].map((plan) => plan.connectionName)
+    ).size,
+    issues
+  };
+}
+
 // node_modules/@tscircuit/fanout-solver/lib/fanout-solver.ts
 function resolvePositiveNumber(label, value) {
   if (!Number.isFinite(value) || value <= 0) {
@@ -21033,6 +21833,7 @@ function resolveConfig(srj, options) {
     viaHoleDiameter,
     clearance,
     compactBusTracks: options.compactBusTracks ?? false,
+    allowSameNetMerges: options.allowSameNetMerges ?? false,
     singleLayerPushAndShove: options.singleLayerPushAndShove ?? false,
     singleLayerAdaptiveExits: options.singleLayerAdaptiveExits ?? false,
     borderDistribution,
@@ -21093,44 +21894,8 @@ function getBusDepthInRows(bus) {
     Math.abs(averageSource - outwardCoordinate) / directionalPitch
   );
 }
-function sourceLayerEscapeIsBlocked(params) {
-  const { bus, srj, traceWidth, clearance } = params;
-  for (const connection of bus.connections) {
-    const source = {
-      x: connection.sourcePoint.x,
-      y: connection.sourcePoint.y
-    };
-    const boundaryPoint = (() => {
-      switch (bus.direction) {
-        case "left":
-          return { x: bus.sharedBoundary.minX, y: source.y };
-        case "right":
-          return { x: bus.sharedBoundary.maxX, y: source.y };
-        case "up":
-          return { x: source.x, y: bus.sharedBoundary.maxY };
-        case "down":
-          return { x: source.x, y: bus.sharedBoundary.minY };
-      }
-    })();
-    const directEscapeSegment = {
-      start: source,
-      end: boundaryPoint,
-      width: traceWidth,
-      layer: connection.sourceLayer
-    };
-    for (const obstacle of srj.obstacles) {
-      if (obstacle === connection.sourceObstacle || !obstacle.layers.includes(connection.sourceLayer)) {
-        continue;
-      }
-      if (distanceSegmentToObstacle(directEscapeSegment, obstacle) < traceWidth / 2 + clearance - 1e-9) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
 function createPreferredLayerAssignment(params) {
-  const { buses, escapeLayers, srj, traceWidth, clearance } = params;
+  const { buses, escapeLayers, escapeLayersByBusId } = params;
   const assignment = {};
   const directionsByComponent = /* @__PURE__ */ new Map();
   let nextViaLayerIndex = 0;
@@ -21148,13 +21913,11 @@ function createPreferredLayerAssignment(params) {
       assignment[bus.busId] = bus.termination.layer;
       continue;
     }
-    const viaLayers = escapeLayers.filter((layer) => layer !== sourceLayer);
-    if (escapeLayers.includes(sourceLayer) && busIsOnOutwardComponentEdge2(bus) && !sourceLayerEscapeIsBlocked({
-      bus,
-      srj,
-      traceWidth,
-      clearance
-    })) {
+    const routableEscapeLayers = escapeLayersByBusId[bus.busId] ?? escapeLayers;
+    const viaLayers = routableEscapeLayers.filter(
+      (layer) => layer !== sourceLayer
+    );
+    if (routableEscapeLayers.includes(sourceLayer) && busIsOnOutwardComponentEdge2(bus)) {
       assignment[bus.busId] = sourceLayer;
     } else if (viaLayers.length > 0) {
       const componentDirections = directionsByComponent.get(bus.componentId);
@@ -21182,6 +21945,26 @@ function prioritizeLayerAssignment(params) {
     )
   ].slice(0, maxAssignments);
 }
+function getCandidateEscapeLayersForBus(params) {
+  const { bus, srj, config, staticClearanceCache } = params;
+  const individuallyRoutableLayers = config.escapeLayers.filter(
+    (targetLayer) => routeBus({
+      srj,
+      bus,
+      targetLayer,
+      acceptedPlans: [],
+      layerNames: config.layerNames,
+      traceWidth: config.traceWidth,
+      viaDiameter: config.viaDiameter,
+      viaHoleDiameter: config.viaHoleDiameter,
+      clearance: config.clearance,
+      compactBusTracks: config.compactBusTracks,
+      allowSameNetMerges: config.allowSameNetMerges,
+      staticClearanceCache
+    }) !== null
+  );
+  return individuallyRoutableLayers.length > 0 ? individuallyRoutableLayers : config.escapeLayers;
+}
 var FanoutSolver = class extends BaseSolver {
   constructor(inputSrj, options = {}) {
     super();
@@ -21211,9 +21994,27 @@ var FanoutSolver = class extends BaseSolver {
         (bus) => bus.termination.type === "plane" ? [[bus.busId, bus.termination.layer]] : []
       )
     );
+    const escapeLayersByBusId = Object.fromEntries(
+      this.preparedBuses.flatMap((bus) => {
+        if (bus.termination.type === "plane") return [];
+        return [
+          [
+            bus.busId,
+            getCandidateEscapeLayersForBus({
+              bus,
+              srj: inputSrj,
+              config: this.config,
+              staticClearanceCache: this.routeStaticClearanceCache
+            })
+          ]
+        ];
+      })
+    );
+    this.escapeLayersByBusId = escapeLayersByBusId;
     const generatedAssignments = generateLayerAssignments({
       busIds: boundaryBusIds,
       layers: this.config.escapeLayers,
+      layersByBusId: escapeLayersByBusId,
       maxAssignments: this.config.maxLayerCombinations
     }).map((assignment) => ({
       ...assignment,
@@ -21223,14 +22024,12 @@ var FanoutSolver = class extends BaseSolver {
       preferredAssignment: createPreferredLayerAssignment({
         buses: this.preparedBuses,
         escapeLayers: this.config.escapeLayers,
-        srj: inputSrj,
-        traceWidth: this.config.traceWidth,
-        clearance: this.config.clearance
+        escapeLayersByBusId
       }),
       generatedAssignments,
       maxAssignments: this.config.maxLayerCombinations
     });
-    this.MAX_ITERATIONS = this.layerAssignments.length + 2;
+    this.MAX_ITERATIONS = this.config.maxLayerCombinations + 2;
   }
   inputSrj;
   options;
@@ -21238,14 +22037,48 @@ var FanoutSolver = class extends BaseSolver {
   attempts = [];
   layerAssignments;
   config;
+  escapeLayersByBusId;
+  evaluatedAssignmentKeys = /* @__PURE__ */ new Set();
+  queuedAssignmentKeys = /* @__PURE__ */ new Set();
+  assignmentRepairDepthByKey = /* @__PURE__ */ new Map();
+  pendingRepairAssignments = [];
+  routeStaticClearanceCache = /* @__PURE__ */ new Map();
+  routingPrefixCache = /* @__PURE__ */ new Map();
+  groupedBeamEvaluated = false;
   nextAssignmentIndex = 0;
+  nextGeneratedAssignmentIndex = 0;
   bestAttempt = null;
   getSolverName() {
     return "FanoutSolver";
   }
-  evaluateAssignment(assignmentIndex, busLayerAssignments) {
-    const plans = [];
-    const failedBusIds = [];
+  getValidationBoundary() {
+    if (this.options.sharedBoundary) return this.options.sharedBoundary;
+    const firstBoundary = this.preparedBuses[0]?.sharedBoundary;
+    if (!firstBoundary) return this.inputSrj.bounds;
+    return this.preparedBuses.slice(1).reduce(
+      (boundary, bus) => ({
+        minX: Math.min(boundary.minX, bus.sharedBoundary.minX),
+        maxX: Math.max(boundary.maxX, bus.sharedBoundary.maxX),
+        minY: Math.min(boundary.minY, bus.sharedBoundary.minY),
+        maxY: Math.max(boundary.maxY, bus.sharedBoundary.maxY)
+      }),
+      { ...firstBoundary }
+    );
+  }
+  validateCompletePlans(plans, outputSrj) {
+    return validateFanoutSolution({
+      inputSrj: this.inputSrj,
+      outputSrj,
+      plans,
+      preparedBuses: this.preparedBuses,
+      sharedBoundary: this.getValidationBoundary(),
+      clearance: this.config.clearance
+    });
+  }
+  evaluateAssignmentWithStrategy(assignmentIndex, busLayerAssignments, routingStrategy) {
+    let plans = [];
+    let failedBusIds = [];
+    let blockingBusCounts = /* @__PURE__ */ new Map();
     const isSingleLayerFanout = this.config.escapeLayers.length === 1;
     if (isSingleLayerFanout && this.config.singleLayerPushAndShove) {
       const singleLayerParams = {
@@ -21268,8 +22101,11 @@ var FanoutSolver = class extends BaseSolver {
       }
     }
     const busesInRoutingOrder = [...this.preparedBuses].sort(
-      (a, b) => Number(a.termination.type === "plane") - Number(b.termination.type === "plane") || b.componentObstacles.length - a.componentObstacles.length || (isSingleLayerFanout ? getBusDistanceToBoundary(b) - getBusDistanceToBoundary(a) : b.connections.length - a.connections.length || getBusDistanceToBoundary(a) - getBusDistanceToBoundary(b))
+      (a, b) => Number(a.termination.type === "plane") - Number(b.termination.type === "plane") || (routingStrategy === "group-by-layer" ? (busLayerAssignments[a.busId] ?? "").localeCompare(
+        busLayerAssignments[b.busId] ?? ""
+      ) : 0) || b.componentObstacles.length - a.componentObstacles.length || (isSingleLayerFanout ? getBusDistanceToBoundary(b) - getBusDistanceToBoundary(a) : b.connections.length - a.connections.length || (routingStrategy === "deep-first" ? getBusDistanceToBoundary(b) - getBusDistanceToBoundary(a) : getBusDistanceToBoundary(a) - getBusDistanceToBoundary(b)))
     );
+    let routingPrefixKey = `${routingStrategy}|`;
     for (const bus of isSingleLayerFanout && this.config.singleLayerPushAndShove ? [] : busesInRoutingOrder) {
       const targetLayer = busLayerAssignments[bus.busId];
       if (!targetLayer) {
@@ -21277,6 +22113,15 @@ var FanoutSolver = class extends BaseSolver {
           `FanoutSolver: assignment ${assignmentIndex} has no layer for bus "${bus.busId}"`
         );
       }
+      routingPrefixKey += `${bus.busId.length}:${bus.busId};${targetLayer.length}:${targetLayer};`;
+      const cachedPrefix = this.routingPrefixCache.get(routingPrefixKey);
+      if (cachedPrefix) {
+        plans = [...cachedPrefix.plans];
+        failedBusIds = [...cachedPrefix.failedBusIds];
+        blockingBusCounts = new Map(cachedPrefix.blockingBusCounts);
+        continue;
+      }
+      const currentBusBlockingCounts = /* @__PURE__ */ new Map();
       const busPlans = routeBus({
         srj: this.inputSrj,
         bus,
@@ -21287,13 +22132,45 @@ var FanoutSolver = class extends BaseSolver {
         viaDiameter: this.config.viaDiameter,
         viaHoleDiameter: this.config.viaHoleDiameter,
         clearance: this.config.clearance,
-        compactBusTracks: this.config.compactBusTracks
+        compactBusTracks: this.config.compactBusTracks,
+        allowSameNetMerges: this.config.allowSameNetMerges,
+        staticClearanceCache: this.routeStaticClearanceCache,
+        blockingBusCounts: currentBusBlockingCounts
       });
       if (!busPlans) {
         failedBusIds.push(bus.busId);
-        continue;
+        for (const [blockingBusId, count] of currentBusBlockingCounts) {
+          blockingBusCounts.set(
+            blockingBusId,
+            (blockingBusCounts.get(blockingBusId) ?? 0) + count
+          );
+        }
+      } else {
+        plans.push(...busPlans);
       }
-      plans.push(...busPlans);
+      this.routingPrefixCache.set(routingPrefixKey, {
+        plans: [...plans],
+        failedBusIds: [...failedBusIds],
+        blockingBusCounts: new Map(blockingBusCounts)
+      });
+    }
+    let validationIssues;
+    let outputSrj = buildOutputSimpleRouteJson({
+      inputSrj: this.inputSrj,
+      plans,
+      layerNames: this.config.layerNames
+    });
+    const validation = plans.length === this.inputSrj.connections.length ? this.validateCompletePlans(plans, outputSrj) : null;
+    if (validation && !validation.valid) {
+      validationIssues = validation.issues;
+      plans = [];
+      failedBusIds = this.preparedBuses.map((bus) => bus.busId);
+      blockingBusCounts.clear();
+      outputSrj = buildOutputSimpleRouteJson({
+        inputSrj: this.inputSrj,
+        plans,
+        layerNames: this.config.layerNames
+      });
     }
     const routedBusCount = this.preparedBuses.length - failedBusIds.length;
     const routeLength = plans.reduce((total, plan) => total + plan.length, 0);
@@ -21305,20 +22182,271 @@ var FanoutSolver = class extends BaseSolver {
       routedBusCount,
       routedConnectionCount: plans.length,
       failedBusIds,
-      score
+      score,
+      ...validationIssues ? { validationIssues } : {}
     };
     return {
       summary,
       plans,
-      outputSrj: buildOutputSimpleRouteJson({
-        inputSrj: this.inputSrj,
-        plans,
-        layerNames: this.config.layerNames
-      })
+      blockingBusIds: [...blockingBusCounts.entries()].toSorted(([, firstCount], [, secondCount]) => secondCount - firstCount).map(([busId]) => busId),
+      outputSrj
     };
   }
+  evaluateAssignment(assignmentIndex, busLayerAssignments) {
+    let bestAttempt = this.evaluateAssignmentWithStrategy(
+      assignmentIndex,
+      busLayerAssignments,
+      "default"
+    );
+    if (bestAttempt.summary.routedConnectionCount === this.inputSrj.connections.length) {
+      return bestAttempt;
+    }
+    for (const routingStrategy of ["group-by-layer", "deep-first"]) {
+      const attempt = this.evaluateAssignmentWithStrategy(
+        assignmentIndex,
+        busLayerAssignments,
+        routingStrategy
+      );
+      if (attempt.summary.score < bestAttempt.summary.score) {
+        bestAttempt = attempt;
+      }
+      if (bestAttempt.summary.routedConnectionCount === this.inputSrj.connections.length) {
+        return bestAttempt;
+      }
+    }
+    return bestAttempt;
+  }
+  /**
+   * Search layer assignments and track alternatives together. The regular
+   * assignment loop commits to one route per bus before the next bus is
+   * considered, so a locally-valid track can still starve a later bus. A
+   * bounded beam keeps several grouped-layer route prefixes alive. It also
+   * evaluates multi-connection buses atomically, so one promising route for a
+   * power or signal lane cannot starve a later bus before the solver explores
+   * an alternate layer/track combination.
+   */
+  evaluateGroupedBeam(assignmentIndex, groupByDirection = false) {
+    if (this.config.escapeLayers.length < 2) return null;
+    if (this.preparedBuses.length > 56) return null;
+    const totalConnections = this.inputSrj.connections.length;
+    if (totalConnections > 64) return null;
+    if (new Set(this.preparedBuses.map((bus) => bus.componentId)).size !== 1) {
+      return null;
+    }
+    const busesInSearchOrder = [...this.preparedBuses].sort((a, b) => {
+      const aLayerCount = a.termination.type === "plane" ? 1 : this.escapeLayersByBusId[a.busId]?.length ?? this.config.escapeLayers.length;
+      const bLayerCount = b.termination.type === "plane" ? 1 : this.escapeLayersByBusId[b.busId]?.length ?? this.config.escapeLayers.length;
+      return Number(a.termination.type === "plane") - Number(b.termination.type === "plane") || (groupByDirection ? a.direction.localeCompare(b.direction) : 0) || aLayerCount - bLayerCount || b.componentObstacles.length - a.componentObstacles.length || b.connections.length - a.connections.length || getBusDepthInRows(b) - getBusDepthInRows(a) || a.busId.localeCompare(b.busId);
+    });
+    const isSmallProblem = totalConnections <= 24;
+    const hasMultiConnectionBus = this.preparedBuses.some(
+      (bus) => bus.connections.length > 1
+    );
+    const beamWidth = isSmallProblem ? 48 : totalConnections <= 32 ? 24 : 12;
+    const alternativesPerLayer = isSmallProblem && !hasMultiConnectionBus ? 4 : 1;
+    let states = [{ assignment: {}, plans: [] }];
+    const getStateScore = (state) => {
+      const routeLength = state.plans.reduce(
+        (total, plan) => total + plan.length,
+        0
+      );
+      const viaCount = state.plans.filter((plan) => plan.via).length;
+      return routeLength + viaCount * 0.1 + assignmentLoadPenalty(state.assignment) * 0.01;
+    };
+    for (const bus of busesInSearchOrder) {
+      const nextStates = [];
+      for (const state of states) {
+        const candidateLayers = bus.termination.type === "plane" ? [bus.termination.layer] : this.escapeLayersByBusId[bus.busId] ?? this.config.escapeLayers;
+        const layerLoads = /* @__PURE__ */ new Map();
+        for (const layer of Object.values(state.assignment)) {
+          layerLoads.set(layer, (layerLoads.get(layer) ?? 0) + 1);
+        }
+        const sourceLayer = bus.connections[0]?.sourceLayer;
+        const orderedLayers = candidateLayers.toSorted(
+          (first, second) => (layerLoads.get(first) ?? 0) - (layerLoads.get(second) ?? 0) || Number(first === sourceLayer) - Number(second === sourceLayer) || first.localeCompare(second)
+        );
+        for (const targetLayer of orderedLayers) {
+          const busAlternatives = routeBusAlternatives(
+            {
+              srj: this.inputSrj,
+              bus,
+              targetLayer,
+              acceptedPlans: state.plans,
+              layerNames: this.config.layerNames,
+              traceWidth: this.config.traceWidth,
+              viaDiameter: this.config.viaDiameter,
+              viaHoleDiameter: this.config.viaHoleDiameter,
+              clearance: this.config.clearance,
+              compactBusTracks: this.config.compactBusTracks,
+              allowSameNetMerges: this.config.allowSameNetMerges,
+              staticClearanceCache: this.routeStaticClearanceCache
+            },
+            alternativesPerLayer
+          );
+          for (const busPlans of busAlternatives) {
+            nextStates.push({
+              assignment: {
+                ...state.assignment,
+                [bus.busId]: targetLayer
+              },
+              plans: [...state.plans, ...busPlans]
+            });
+          }
+        }
+      }
+      if (nextStates.length === 0) return null;
+      nextStates.sort((first, second) => {
+        const scoreDifference = getStateScore(first) - getStateScore(second);
+        if (Math.abs(scoreDifference) > 1e-9) return scoreDifference;
+        return JSON.stringify(first.assignment).localeCompare(
+          JSON.stringify(second.assignment)
+        );
+      });
+      const statesByAssignment = /* @__PURE__ */ new Map();
+      states = [];
+      for (const state of nextStates) {
+        const key = JSON.stringify(state.assignment);
+        const sameAssignmentCount = statesByAssignment.get(key) ?? 0;
+        if (sameAssignmentCount >= 2) continue;
+        statesByAssignment.set(key, sameAssignmentCount + 1);
+        states.push(state);
+        if (states.length >= beamWidth) break;
+      }
+    }
+    const bestState = states[0];
+    if (!bestState) return null;
+    const outputSrj = buildOutputSimpleRouteJson({
+      inputSrj: this.inputSrj,
+      plans: bestState.plans,
+      layerNames: this.config.layerNames
+    });
+    if (bestState.plans.length === this.inputSrj.connections.length && !this.validateCompletePlans(bestState.plans, outputSrj).valid) {
+      return null;
+    }
+    const score = bestState.plans.length === this.inputSrj.connections.length ? bestState.plans.reduce((total, plan) => total + plan.length, 0) + bestState.plans.filter((plan) => plan.via).length * 0.1 + assignmentLoadPenalty(bestState.assignment) * 0.01 : Number.POSITIVE_INFINITY;
+    if (!Number.isFinite(score)) return null;
+    const summary = {
+      assignmentIndex,
+      busLayerAssignments: bestState.assignment,
+      routedBusCount: this.preparedBuses.length,
+      routedConnectionCount: bestState.plans.length,
+      failedBusIds: [],
+      score
+    };
+    return {
+      summary,
+      plans: bestState.plans,
+      blockingBusIds: [],
+      outputSrj
+    };
+  }
+  prioritizeFailedBusRepairs(assignment, failedBusIds, blockingBusIds) {
+    const assignmentKey = JSON.stringify(assignment);
+    const repairDepth = this.assignmentRepairDepthByKey.get(assignmentKey) ?? 0;
+    if (repairDepth >= 2) return;
+    const maximumRepairs = 8;
+    const repairs = [];
+    const repairKeys = /* @__PURE__ */ new Set();
+    const addRepair = (repair) => {
+      const key = JSON.stringify(repair);
+      if (repairKeys.has(key) || this.evaluatedAssignmentKeys.has(key) || this.queuedAssignmentKeys.has(key)) {
+        return;
+      }
+      repairKeys.add(key);
+      this.queuedAssignmentKeys.add(key);
+      this.assignmentRepairDepthByKey.set(key, repairDepth + 1);
+      repairs.push(repair);
+    };
+    const repairBusIds = [];
+    for (let index = 0; index < Math.max(failedBusIds.length, blockingBusIds.length); index++) {
+      const failedBusId = failedBusIds[index];
+      const blockingBusId = blockingBusIds[index];
+      if (failedBusId && !repairBusIds.includes(failedBusId)) {
+        repairBusIds.push(failedBusId);
+      }
+      if (blockingBusId && !repairBusIds.includes(blockingBusId)) {
+        repairBusIds.push(blockingBusId);
+      }
+    }
+    for (const failedBusId of failedBusIds) {
+      const failedLayer = assignment[failedBusId];
+      const failedCandidateLayers = this.escapeLayersByBusId[failedBusId];
+      if (!failedLayer || !failedCandidateLayers) continue;
+      for (const blockingBusId of blockingBusIds.slice(0, 4)) {
+        const blockingLayer = assignment[blockingBusId];
+        const blockingCandidateLayers = this.escapeLayersByBusId[blockingBusId];
+        if (!blockingLayer || !blockingCandidateLayers || !failedCandidateLayers.includes(blockingLayer) || !blockingCandidateLayers.includes(failedLayer)) {
+          continue;
+        }
+        addRepair({
+          ...assignment,
+          [failedBusId]: blockingLayer,
+          [blockingBusId]: failedLayer
+        });
+        if (repairs.length >= maximumRepairs) break;
+      }
+      if (repairs.length >= maximumRepairs) break;
+    }
+    for (const busId of repairBusIds) {
+      const currentLayer = assignment[busId];
+      const candidateLayers = this.escapeLayersByBusId[busId];
+      if (!currentLayer || !candidateLayers) continue;
+      const currentLayerIndex = candidateLayers.indexOf(currentLayer);
+      for (let shift = 1; shift < candidateLayers.length; shift++) {
+        const candidateLayer = candidateLayers[(Math.max(currentLayerIndex, 0) + shift) % candidateLayers.length];
+        if (candidateLayer === currentLayer) continue;
+        addRepair({ ...assignment, [busId]: candidateLayer });
+        if (repairs.length >= maximumRepairs) break;
+      }
+      if (repairs.length >= maximumRepairs) break;
+    }
+    this.pendingRepairAssignments.push(...repairs);
+  }
   _step() {
-    const assignment = this.layerAssignments[this.nextAssignmentIndex];
+    if (!this.groupedBeamEvaluated) {
+      this.groupedBeamEvaluated = true;
+      let beamAttempt = this.evaluateGroupedBeam(-1);
+      if (!beamAttempt) {
+        beamAttempt = this.evaluateGroupedBeam(-1, true);
+      }
+      if (beamAttempt) {
+        this.attempts.push(beamAttempt.summary);
+        this.bestAttempt = beamAttempt;
+        this.stats = {
+          assignment: 0,
+          assignmentCount: this.config.maxLayerCombinations,
+          routedBuses: `${beamAttempt.summary.routedBusCount}/${this.preparedBuses.length}`,
+          routedConnections: `${beamAttempt.summary.routedConnectionCount}/${this.inputSrj.connections.length}`,
+          failedBuses: "none",
+          bestScore: beamAttempt.summary.score
+        };
+        this.solved = true;
+        return;
+      }
+    }
+    let assignment;
+    while (!assignment && this.nextAssignmentIndex < this.config.maxLayerCombinations) {
+      const preferGeneratedAssignment = this.nextAssignmentIndex % 3 === 0;
+      let candidate;
+      let candidateCameFromRepairQueue = false;
+      if (preferGeneratedAssignment) {
+        candidate = this.layerAssignments[this.nextGeneratedAssignmentIndex++];
+      } else {
+        candidate = this.pendingRepairAssignments.pop();
+        candidateCameFromRepairQueue = candidate !== void 0;
+      }
+      if (!candidate) {
+        candidate = preferGeneratedAssignment ? this.pendingRepairAssignments.pop() : this.layerAssignments[this.nextGeneratedAssignmentIndex++];
+        candidateCameFromRepairQueue = preferGeneratedAssignment && candidate !== void 0;
+      }
+      if (!candidate) break;
+      const candidateKey = JSON.stringify(candidate);
+      if (candidateCameFromRepairQueue) {
+        this.queuedAssignmentKeys.delete(candidateKey);
+      }
+      if (this.evaluatedAssignmentKeys.has(candidateKey)) continue;
+      assignment = candidate;
+    }
     if (!assignment) {
       if (this.bestAttempt && this.bestAttempt.summary.routedConnectionCount === this.inputSrj.connections.length) {
         this.solved = true;
@@ -21333,13 +22461,21 @@ var FanoutSolver = class extends BaseSolver {
       assignment
     );
     this.nextAssignmentIndex++;
+    this.evaluatedAssignmentKeys.add(JSON.stringify(assignment));
+    if (!this.bestAttempt || attempt.summary.routedConnectionCount >= this.bestAttempt.summary.routedConnectionCount) {
+      this.prioritizeFailedBusRepairs(
+        assignment,
+        attempt.summary.failedBusIds,
+        attempt.blockingBusIds
+      );
+    }
     this.attempts.push(attempt.summary);
     if (!this.bestAttempt || attempt.summary.score < this.bestAttempt.summary.score) {
       this.bestAttempt = attempt;
     }
     this.stats = {
       assignment: attempt.summary.assignmentIndex + 1,
-      assignmentCount: this.layerAssignments.length,
+      assignmentCount: this.config.maxLayerCombinations,
       routedBuses: `${attempt.summary.routedBusCount}/${this.preparedBuses.length}`,
       routedConnections: `${attempt.summary.routedConnectionCount}/${this.inputSrj.connections.length}`,
       failedBuses: attempt.summary.failedBusIds.join(", ") || "none",
@@ -21351,7 +22487,7 @@ var FanoutSolver = class extends BaseSolver {
   }
   computeProgress() {
     if (this.solved || this.failed) return 1;
-    return this.nextAssignmentIndex / this.layerAssignments.length;
+    return this.nextAssignmentIndex / this.config.maxLayerCombinations;
   }
   getConstructorParams() {
     return [this.inputSrj, this.options];
@@ -21362,6 +22498,15 @@ var FanoutSolver = class extends BaseSolver {
         "FanoutSolver: getOutput() called before a complete fanout was solved"
       );
     }
+    const validation = this.validateCompletePlans(
+      this.bestAttempt.plans,
+      this.bestAttempt.outputSrj
+    );
+    if (!validation.valid) {
+      throw new Error(
+        `FanoutSolver: completed output failed validation: ${validation.issues[0]?.message ?? "unknown validation error"}`
+      );
+    }
     return {
       simpleRouteJson: this.bestAttempt.outputSrj,
       fanoutTraces: this.bestAttempt.plans.map((plan) => plan.trace),
@@ -21379,7 +22524,8 @@ var FanoutSolver = class extends BaseSolver {
       busDirections: Object.fromEntries(
         this.preparedBuses.map((bus) => [bus.busId, bus.direction])
       ),
-      attempts: [...this.attempts]
+      attempts: [...this.attempts],
+      validation
     };
   }
   getOutputSimpleRouteJson() {
@@ -31458,7 +32604,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1650",
+  version: "0.0.1651",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -31498,7 +32644,7 @@ var package_default = {
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "0.0.44",
     "@tscircuit/create-fdm-enclosure": "0.0.3",
-    "@tscircuit/fanout-solver": "0.0.16",
+    "@tscircuit/fanout-solver": "0.0.20",
     "@tscircuit/footprinter": "^0.0.409",
     "@tscircuit/image-utils": "^0.0.8",
     "@tscircuit/infer-cable-insertion-point": "^0.0.3",
@@ -31755,7 +32901,7 @@ function Group_applyDrcTolerancesToSimpleRouteJson(simpleRouteJson, drcTolerance
 
 // lib/components/primitive-components/Group/Group_syncFanoutExitsWithGlobalConnections.ts
 var POINT_MATCH_TOLERANCE = 1e-6;
-var pointsMatch = (first, second) => Math.abs(first.x - second.x) <= POINT_MATCH_TOLERANCE && Math.abs(first.y - second.y) <= POINT_MATCH_TOLERANCE && first.layer === second.layer;
+var pointsMatch2 = (first, second) => Math.abs(first.x - second.x) <= POINT_MATCH_TOLERANCE && Math.abs(first.y - second.y) <= POINT_MATCH_TOLERANCE && first.layer === second.layer;
 var removeCompletedFanoutConnections = (simpleRouteJson, routingPcbGroupId) => {
   const connections = simpleRouteJson.connections.filter(
     (connection) => connection.routingPcbGroupId !== routingPcbGroupId
@@ -31827,14 +32973,14 @@ function Group_syncFanoutExitsWithGlobalConnections({
     const globalConnection = baseConnections.find(
       (connection) => connection.routingPcbGroupId !== routingPcbGroupId && connection.source_trace_id === inputConnection.source_trace_id && connection.pointsToConnect.some(
         (globalPoint) => inputConnection.pointsToConnect.some(
-          (inputPoint) => pointsMatch(globalPoint, inputPoint)
+          (inputPoint) => pointsMatch2(globalPoint, inputPoint)
         )
       )
     );
     if (!globalConnection) continue;
     const previousGlobalPointIndex = globalConnection.pointsToConnect.findIndex(
       (globalPoint) => inputConnection.pointsToConnect.some(
-        (inputPoint) => pointsMatch(globalPoint, inputPoint)
+        (inputPoint) => pointsMatch2(globalPoint, inputPoint)
       )
     );
     if (previousGlobalPointIndex < 0) continue;
@@ -31842,7 +32988,7 @@ function Group_syncFanoutExitsWithGlobalConnections({
     const changedPointIndex = outputConnection.pointsToConnect.findIndex(
       (outputPoint, pointIndex) => {
         const inputPoint = inputConnection.pointsToConnect[pointIndex];
-        return inputPoint !== void 0 && !pointsMatch(outputPoint, inputPoint);
+        return inputPoint !== void 0 && !pointsMatch2(outputPoint, inputPoint);
       }
     );
     if (changedPointIndex < 0) continue;
@@ -40195,15 +41341,15 @@ import {
 } from "@tscircuit/copper-pour-solver";
 
 // lib/components/primitive-components/CopperPour/utils/mark-trace-segments-inside-copper-pour.ts
-var EPSILON3 = 1e-9;
+var EPSILON4 = 1e-9;
 var isWireRoutePoint = (routePoint) => routePoint.route_type === "wire";
 var isPointOnSegment = (p, a, b) => {
   const cross3 = (p.y - a.y) * (b.x - a.x) - (p.x - a.x) * (b.y - a.y);
-  if (Math.abs(cross3) > EPSILON3) return false;
+  if (Math.abs(cross3) > EPSILON4) return false;
   const dot = (p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y);
-  if (dot < -EPSILON3) return false;
+  if (dot < -EPSILON4) return false;
   const squaredLength = (b.x - a.x) ** 2 + (b.y - a.y) ** 2;
-  if (dot - squaredLength > EPSILON3) return false;
+  if (dot - squaredLength > EPSILON4) return false;
   return true;
 };
 var isPointInRing = (point6, ring) => {
@@ -40227,7 +41373,7 @@ var isPointInRectPour = (p, pour) => {
   const dy = p.y - center.y;
   const localX = dx * cosR - dy * sinR;
   const localY = dx * sinR + dy * cosR;
-  return Math.abs(localX) <= width / 2 + EPSILON3 && Math.abs(localY) <= height / 2 + EPSILON3;
+  return Math.abs(localX) <= width / 2 + EPSILON4 && Math.abs(localY) <= height / 2 + EPSILON4;
 };
 var isPointInBrepPour = (p, pour) => {
   const outerRing = pour.brep_shape.outer_ring.vertices.map((v) => ({
@@ -40261,7 +41407,7 @@ var isSegmentFullyInsideCopperPour = (start, end, pour) => {
   const dx = end.x - start.x;
   const dy = end.y - start.y;
   const length7 = Math.hypot(dx, dy);
-  if (length7 <= EPSILON3) return false;
+  if (length7 <= EPSILON4) return false;
   const samples = [0, 0.25, 0.5, 0.75, 1];
   return samples.every(
     (t) => isPointInCopperPour(