@tscircuit/core 0.0.1853 → 0.0.1855

package/dist/index.js

@@ -18308,6 +18308,10 @@ function distanceSegmentToObstacle(segment2, obstacle) {
 function segmentsAreClear(first, second, clearance) {
   if (first.layer !== second.layer) return true;
   const requiredDistance = (first.width + second.width) / 2 + clearance;
+  const broadPhaseDistance = requiredDistance + EPSILON;
+  if (Math.min(first.start.x, first.end.x) - Math.max(second.start.x, second.end.x) > broadPhaseDistance || Math.min(second.start.x, second.end.x) - Math.max(first.start.x, first.end.x) > broadPhaseDistance || Math.min(first.start.y, first.end.y) - Math.max(second.start.y, second.end.y) > broadPhaseDistance || Math.min(second.start.y, second.end.y) - Math.max(first.start.y, first.end.y) > broadPhaseDistance) {
+    return true;
+  }
   return distanceSegmentToSegment(
     first.start,
     first.end,
@@ -21755,6 +21759,13 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
   }));
   const boundaryDirection = getDirectionForExitEdge(bus.exitEdge);
   const sharesNet = (first, second) => first === second || allowSameNetMerges && connectionsShareElectricalNet(srj, first, second);
+  const boundedBlockingSegments = blockingSegments.map((blocker) => ({
+    ...blocker,
+    minX: Math.min(blocker.segment.start.x, blocker.segment.end.x),
+    maxX: Math.max(blocker.segment.start.x, blocker.segment.end.x),
+    minY: Math.min(blocker.segment.start.y, blocker.segment.end.y),
+    maxY: Math.max(blocker.segment.start.y, blocker.segment.end.y)
+  }));
   const allBlockingVias = [...blockingVias, ...terminalVias];
   const maximumViaToTraceDistance = allBlockingVias.reduce(
     (maximum, { via }) => Math.max(maximum, via.diameter / 2 + traceWidth / 2 + clearance),
@@ -21776,6 +21787,10 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
   const segmentIsClear = (params2) => {
     const { segment: segment2, terminal, acceptedAttemptSegments } = params2;
     const connectionName = terminal.connection.connection.name;
+    const segmentMinX = Math.min(segment2.start.x, segment2.end.x);
+    const segmentMaxX = Math.max(segment2.start.x, segment2.end.x);
+    const segmentMinY = Math.min(segment2.start.y, segment2.end.y);
+    const segmentMaxY = Math.max(segment2.start.y, segment2.end.y);
     const requiredObstacleClearance = segment2.width / 2 + clearance;
     for (const obstacle of targetLayerObstacleIndex.querySegment(
       segment2,
@@ -21788,21 +21803,25 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
         return false;
       }
     }
-    for (const blocker of blockingSegments) {
+    for (const blocker of boundedBlockingSegments) {
       if (sharesNet(connectionName, blocker.connectionName)) continue;
+      const margin = (segment2.width + blocker.segment.width) / 2 + clearance;
+      if (segmentMaxX + margin < blocker.minX || segmentMinX - margin > blocker.maxX || segmentMaxY + margin < blocker.minY || segmentMinY - margin > blocker.maxY) {
+        continue;
+      }
       if (distanceSegmentToSegment(
         segment2.start,
         segment2.end,
         blocker.segment.start,
         blocker.segment.end
-      ) < (segment2.width + blocker.segment.width) / 2 + clearance - EPSILON7) {
+      ) < margin - EPSILON7) {
         return false;
       }
     }
     for (const blocker of acceptedAttemptSegments) {
       if (sharesNet(connectionName, blocker.connectionName)) continue;
       const margin = (segment2.width + blocker.segment.width) / 2 + clearance;
-      if (Math.max(segment2.start.x, segment2.end.x) + margin < Math.min(blocker.segment.start.x, blocker.segment.end.x) || Math.min(segment2.start.x, segment2.end.x) - margin > Math.max(blocker.segment.start.x, blocker.segment.end.x) || Math.max(segment2.start.y, segment2.end.y) + margin < Math.min(blocker.segment.start.y, blocker.segment.end.y) || Math.min(segment2.start.y, segment2.end.y) - margin > Math.max(blocker.segment.start.y, blocker.segment.end.y))
+      if (segmentMaxX + margin < Math.min(blocker.segment.start.x, blocker.segment.end.x) || segmentMinX - margin > Math.max(blocker.segment.start.x, blocker.segment.end.x) || segmentMaxY + margin < Math.min(blocker.segment.start.y, blocker.segment.end.y) || segmentMinY - margin > Math.max(blocker.segment.start.y, blocker.segment.end.y))
         continue;
       if (distanceSegmentToSegment(
         segment2.start,
@@ -21818,10 +21837,6 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
       if (distancePointToSegment(other.exitPoint, segment2.start, segment2.end) < traceWidth + clearance - EPSILON7)
         return false;
     }
-    const segmentMinX = Math.min(segment2.start.x, segment2.end.x);
-    const segmentMaxX = Math.max(segment2.start.x, segment2.end.x);
-    const segmentMinY = Math.min(segment2.start.y, segment2.end.y);
-    const segmentMaxY = Math.max(segment2.start.y, segment2.end.y);
     for (let viaIndex = getFirstViaAtOrAfterX(
       segmentMinX - maximumViaToTraceDistance
     ); viaIndex < viasByX.length; viaIndex++) {
@@ -21992,16 +22007,25 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
     );
     const previous = new Int32Array(stateCount).fill(-1);
     const heap = new MinHeap();
-    const heuristic = (point6) => {
+    const remainingDistances = new Float64Array(nodeCount);
+    const lanePenalties = new Float64Array(nodeCount);
+    const targetTrack = getPerpendicularAxis(
+      terminal.exitPoint,
+      boundaryDirection
+    );
+    for (let nodeIndex = 0; nodeIndex < nodeCount; nodeIndex++) {
+      const point6 = nodes[nodeIndex].point;
       const deltaX = Math.abs(point6.x - terminal.exitPoint.x);
       const deltaY = Math.abs(point6.y - terminal.exitPoint.y);
-      return Math.max(deltaX, deltaY) + (Math.SQRT2 - 1) * Math.min(deltaX, deltaY);
-    };
+      remainingDistances[nodeIndex] = Math.max(deltaX, deltaY) + (Math.SQRT2 - 1) * Math.min(deltaX, deltaY);
+      const nextTrack = getPerpendicularAxis(point6, boundaryDirection);
+      lanePenalties[nodeIndex] = laneBias === 0 ? 0 : laneBias > 0 ? Math.max(0, targetTrack - nextTrack) * 0.2 : Math.max(0, nextTrack - targetTrack) * 0.2;
+    }
     for (const start of starts) {
       const state = start.nodeIndex * 9 + 8;
       if (start.length >= distances[state]) continue;
       distances[state] = start.length;
-      const remaining = heuristic(nodes[start.nodeIndex].point);
+      const remaining = remainingDistances[start.nodeIndex];
       heap.push({
         node: start.nodeIndex,
         direction: 8,
@@ -22018,6 +22042,13 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
       [0, -1],
       [1, -1]
     ];
+    const nextDirectionsByIncoming = Array.from(
+      { length: 9 },
+      (_, incoming) => directions.flatMap((_2, directionIndex) => {
+        const delta = Math.abs(incoming - directionIndex);
+        return incoming === 8 || Math.min(delta, 8 - delta) <= 1 ? [directionIndex] : [];
+      })
+    );
     const startsByNode = /* @__PURE__ */ new Map();
     for (const start of starts) {
       const values = startsByNode.get(start.nodeIndex) ?? [];
@@ -22035,7 +22066,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
       if (current.score >= bestGoalCost - EPSILON7) break;
       const state = current.node * 9 + current.direction;
       const currentDistance = distances[state];
-      if (current.score > currentDistance + heuristic(nodes[current.node].point) + EPSILON7)
+      if (current.score > currentDistance + remainingDistances[current.node] + EPSILON7)
         continue;
       expandedStateCount++;
       expandedStatesSinceYield++;
@@ -22085,13 +22116,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
         }
       }
       const node = nodes[current.node];
-      for (let directionIndex = 0; directionIndex < directions.length; directionIndex++) {
-        if (current.direction !== 8) {
-          const rawDirectionDelta = Math.abs(current.direction - directionIndex);
-          if (Math.min(rawDirectionDelta, 8 - rawDirectionDelta) > 1) {
-            continue;
-          }
-        }
+      for (const directionIndex of nextDirectionsByIncoming[current.direction]) {
         const [deltaColumn, deltaRow] = directions[directionIndex];
         const column = node.column + deltaColumn;
         const row = node.row + deltaRow;
@@ -22101,12 +22126,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
         const nextNode = row * columnCount + column;
         const nextPoint = nodes[nextNode].point;
         const addsTurn = current.direction !== 8 && current.direction !== directionIndex;
-        const nextTrack = getPerpendicularAxis(nextPoint, boundaryDirection);
-        const targetTrack = getPerpendicularAxis(
-          terminal.exitPoint,
-          boundaryDirection
-        );
-        const lanePenalty = laneBias === 0 ? 0 : laneBias > 0 ? Math.max(0, targetTrack - nextTrack) * 0.2 : Math.max(0, nextTrack - targetTrack) * 0.2;
+        const lanePenalty = lanePenalties[nextNode];
         const nextDistance = currentDistance + (deltaColumn !== 0 && deltaRow !== 0 ? gridStep * Math.SQRT2 : gridStep) + (addsTurn ? gridStep * 0.2 : 0) + lanePenalty + (softViaCosts?.[nextNode] ?? 0);
         const nextState = nextNode * 9 + directionIndex;
         if (nextDistance >= distances[nextState] - EPSILON7) continue;
@@ -22128,7 +22148,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
         if (edgeClearance[edgeIndex] === 2) continue;
         distances[nextState] = nextDistance;
         previous[nextState] = state;
-        const remaining = heuristic(nextPoint);
+        const remaining = remainingDistances[nextNode];
         heap.push({
           node: nextNode,
           direction: directionIndex,
@@ -22236,6 +22256,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
   };
   const alternatives = [];
   const seenAlternativeKeys = /* @__PURE__ */ new Set();
+  const failedSearches = /* @__PURE__ */ new Map();
   let routeOrderAttemptCount = 0;
   for (const routeOrder of adaptiveRouteOrders()) {
     for (const laneBias of laneBiases) {
@@ -22248,13 +22269,33 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
       let failed = false;
       for (let terminalIndex = 0; terminalIndex < routeOrder.length; terminalIndex++) {
         const terminal = routeOrder[terminalIndex];
+        const failedSearchKey = JSON.stringify([
+          terminals.indexOf(terminal),
+          laneBias,
+          acceptedAttemptSegments.map(({ connectionName: connectionName2, segment: segment2 }) => [
+            connectionName2,
+            segment2.start.x,
+            segment2.start.y,
+            segment2.end.x,
+            segment2.end.y,
+            segment2.width,
+            segment2.layer
+          ])
+        ]);
+        const cachedFailure = failedSearches.get(failedSearchKey);
         const connectionSteps = routeOneSteps({
           terminal,
           acceptedAttemptSegments,
           laneBias
         });
-        let connectionResult = connectionSteps.next();
-        let searchBatch = 0;
+        let connectionResult = cachedFailure === void 0 ? connectionSteps.next() : {
+          done: true,
+          value: {
+            points: null,
+            expandedStateCount: cachedFailure.expandedStateCount
+          }
+        };
+        let searchBatch = cachedFailure?.searchBatch ?? 0;
         let expandedStateCount = 0;
         while (!connectionResult.done) {
           expandedStateCount = connectionResult.value.expandedStateCount;
@@ -22296,6 +22337,10 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
           } : {}
         };
         if (!points) {
+          failedSearches.set(failedSearchKey, {
+            expandedStateCount: finalExpandedStateCount,
+            searchBatch
+          });
           if (adaptiveRouteOrder && maximumRouteOrderAttempts !== void 0 && terminalIndex > 0) {
             const others = routeOrder.filter(
               (candidate) => candidate !== terminal
@@ -23630,6 +23675,8 @@ function planIsClearOfPlans(params) {
     clearance,
     blockingBusCounts
   } = params;
+  const planSegments = getPlanSegments(plan);
+  const planVias = getPlanVias2(plan);
   for (const otherPlan of otherPlans) {
     if (allowSameNetMerges && connectionsShareElectricalNet(
       srj,
@@ -23647,9 +23694,7 @@ function planIsClearOfPlans(params) {
         (blockingBusCounts.get(otherPlan.busId) ?? 0) + 1
       );
     };
-    const planSegments = getPlanSegments(plan);
     const otherSegments = getPlanSegments(otherPlan);
-    const planVias = getPlanVias2(plan);
     const otherVias = getPlanVias2(otherPlan);
     for (const segment2 of planSegments) {
       for (const otherSegment of otherSegments) {
@@ -24180,6 +24225,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
     adaptiveWindingRouteOrder = false,
     alignWindingGridToPads = false,
     fixedViaFallbackRouteOrderAttempts = 24,
+    allowFixedViaReservedExitFallback = false,
     cornerBandTargetTrackOffset
   } = params;
   if (!Number.isInteger(maxAlternatives) || maxAlternatives < 1) {
@@ -24448,7 +24494,23 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
           reserveTerminalExitPoints: !preferTargetDirectedLaneBias,
           allowLayerInterleaving: true
         }))
-      ).flat() : []
+      ).flat() : [],
+      // A single-layer target permutation can also let an early lane
+      // close a future terminal's exit gap. Keep the original attempts
+      // first, then retry the same fixed sites with every exit reserved.
+      ...allowFixedViaReservedExitFallback && fixedViaPointsByConnectionIndex && !getCornerSide(bus) && windingTargetOrderCount === 1 && bus.connections.length > 2 ? [true, false].map((preferTargetDirectedLaneBias) => ({
+        label: `fixed-vias-reserved-exits-${preferTargetDirectedLaneBias}`,
+        useViaInPad: false,
+        getViaHandedness: () => 0,
+        getViaPoint: (connection) => coordinatedViaPoints.get(connection.connectionIndex),
+        maximumRouteOrderAttempts: Math.min(
+          maximumThroughAllRouteOrderAttempts,
+          fixedViaFallbackRouteOrderAttempts
+        ),
+        windingOrderIndex: 0,
+        preferTargetDirectedLaneBias,
+        reserveTerminalExitPoints: true
+      })) : []
     ] : [];
     const planeTerminationsAlreadyOccupyTheFanout = acceptedPlans.some(
       (plan) => plan.termination.type === "plane"
@@ -31097,7 +31159,9 @@ var FanoutSolver = class extends BaseSolver {
       this.config.allowBlindAndBuriedVias
     );
     const useConfiguredDensePlaneRouting = configuredDensePlaneRouting || useAdaptiveDensePlaneRouting;
-    const useAdaptiveJointPlaneSelection = useAdaptiveDensePlaneRouting && ((params.planeReservationRetryCount ?? 0) === 0 || Boolean(params.preferredBoundaryViaPoints));
+    const useBoundaryRecovery = params.boundaryRecovery !== void 0;
+    const useJointPlaneRepair = useConfiguredDensePlaneRouting || useBoundaryRecovery;
+    const useJointPlaneSelection = useBoundaryRecovery || useAdaptiveDensePlaneRouting && ((params.planeReservationRetryCount ?? 0) === 0 || Boolean(params.preferredBoundaryViaPoints));
     const matchLengthsAfterPlanes = useConfiguredDensePlaneRouting && params.lengthMatchingStage !== "before-planes";
     const useJointBoundaryViaReservation = shouldUseJointBoundaryViaReservation(
       unsortedBoundaryBuses.map((bus) => bus.connections.length)
@@ -31252,7 +31316,7 @@ var FanoutSolver = class extends BaseSolver {
         return first.busId.localeCompare(second.busId);
       }
     );
-    const debugBoundaryOrder = process.env.FANOUT_DEBUG_BOUNDARY_ORDER?.split(",") ?? (process.env.FANOUT_DEBUG_FIRST_BOUNDARY_BUS ? [process.env.FANOUT_DEBUG_FIRST_BOUNDARY_BUS] : []);
+    const debugBoundaryOrder = process.env.FANOUT_DEBUG_BOUNDARY_ORDER?.split(",") ?? (process.env.FANOUT_DEBUG_FIRST_BOUNDARY_BUS ? [process.env.FANOUT_DEBUG_FIRST_BOUNDARY_BUS] : params.boundaryRecovery ? [params.boundaryRecovery.busId] : []);
     const boundaryBuses = debugBoundaryOrder.length > 0 ? initiallySortedBoundaryBuses.toSorted((first, second) => {
       const firstIndex = debugBoundaryOrder.indexOf(first.busId);
       const secondIndex = debugBoundaryOrder.indexOf(second.busId);
@@ -31289,6 +31353,7 @@ var FanoutSolver = class extends BaseSolver {
       ];
     }
     const unroutablePlaneBusIds = /* @__PURE__ */ new Set();
+    let failedWideBoundaryBus;
     debugDense(
       "start",
       boundaryBuses.map((bus) => `${bus.busId}:${bus.connections.length}`),
@@ -31348,6 +31413,16 @@ var FanoutSolver = class extends BaseSolver {
       if (entersNeighboringSourceField)
         preferBoundaryOutwardByBusId.set(bus.busId, false);
     }
+    if (params.boundaryRecovery) {
+      preferredBoundaryPerpendicularSideByBusId.set(
+        params.boundaryRecovery.busId,
+        params.boundaryRecovery.perpendicularSide
+      );
+      preferBoundaryOutwardByBusId.set(
+        params.boundaryRecovery.busId,
+        params.boundaryRecovery.preferOutward
+      );
+    }
     const debugFlippedBoundaryBus = process.env.FANOUT_DEBUG_FLIP_BOUNDARY_BUS;
     if (debugFlippedBoundaryBus) {
       preferredBoundaryPerpendicularSideByBusId.set(debugFlippedBoundaryBus, -1);
@@ -31796,6 +31871,7 @@ var FanoutSolver = class extends BaseSolver {
           allowBoundarySideViaFallback: bus.connections.length === 1,
           preferCornerBoundaryVia: useConfiguredDensePlaneRouting,
           adaptiveWindingRouteOrder,
+          allowFixedViaReservedExitFallback: useBoundaryRecovery,
           // Retain pad-aligned channels even when plane sites are reserved
           // adaptively; the boundary grid can fence off a turning wide bus.
           alignWindingGridToPads: usePadAlignedDenseRouting && !configuredDensePlaneRouting,
@@ -32089,6 +32165,7 @@ var FanoutSolver = class extends BaseSolver {
           }
         }
         if (!busPlans) {
+          if (bus.connections.length >= 8) failedWideBoundaryBus ??= bus;
           debugDense("route:failed", bus.busId);
           return false;
         }
@@ -32371,6 +32448,7 @@ var FanoutSolver = class extends BaseSolver {
         let feasibleAlternatePlanePlans = [];
         const matchViaPointsAroundPlans = (candidatePlans, promotedAlternatePlaneBusIds = /* @__PURE__ */ new Set()) => {
           feasibleAlternatePlanePlans = [];
+          matchedPlaneBusesInRoutingOrder = null;
           const fixedBoundaryViaPoints = new Map(
             candidatePlans.flatMap(
               (plan) => plan.via ? [[plan.connectionIndex, plan.via.center]] : []
@@ -32420,9 +32498,9 @@ var FanoutSolver = class extends BaseSolver {
           });
           if (retainedViaPoints)
             return new Map([...fixedBoundaryViaPoints, ...retainedViaPoints]);
-          if (useConfiguredDensePlaneRouting || process.env.FANOUT_DEBUG_INCREMENTAL_PLANE_MATCH === "1") {
+          if (useJointPlaneRepair || process.env.FANOUT_DEBUG_INCREMENTAL_PLANE_MATCH === "1") {
             let incrementalViaPoints = new Map(fixedBoundaryViaPoints);
-            const matchedPlaneBuses = [...activeBoundaryReservationPlaneBuses];
+            const matchedPlaneBuses = useBoundaryRecovery ? [] : [...activeBoundaryReservationPlaneBuses];
             for (const planeBus of matchedPlaneBuses) {
               for (const connection of planeBus.connections) {
                 const reservedPoint = fixedViaPointsByConnectionIndex.get(
@@ -32538,14 +32616,14 @@ var FanoutSolver = class extends BaseSolver {
                 "plane-match:preflight-failed",
                 independentlyUnmatchablePlaneBuses.map((bus) => bus.busId)
               );
-              if (!useConfiguredDensePlaneRouting && process.env.FANOUT_DEBUG_ROUTE_UNMATCHED_PLANES !== "1") {
+              if (!useJointPlaneRepair && process.env.FANOUT_DEBUG_ROUTE_UNMATCHED_PLANES !== "1") {
                 return null;
               }
               let alternatePlaneSearchStates = 0;
               const maximumAlternatePlaneSearchStates = Number(
                 process.env.FANOUT_DEBUG_ALTERNATE_SEARCH_STATES ?? // Keep the initial search short before reserving blocked
                 // plane sites. Later joint repairs retain the full budget.
-                (useAdaptiveDensePlaneRouting && (params.planeReservationRetryCount ?? 0) === 0 ? 1e4 : useConfiguredDensePlaneRouting ? 3e6 : 1e3)
+                (useAdaptiveDensePlaneRouting && (params.planeReservationRetryCount ?? 0) === 0 ? 1e4 : useConfiguredDensePlaneRouting ? 3e6 : useBoundaryRecovery ? 1e4 : 1e3)
               );
               const maximumAlternatePlaneRoutes = Number(
                 process.env.FANOUT_DEBUG_ALTERNATE_ROUTE_COUNT ?? (useConfiguredDensePlaneRouting ? 128 : 8)
@@ -32674,7 +32752,7 @@ var FanoutSolver = class extends BaseSolver {
                 return null;
               };
               let alternatePlanePlans;
-              if (useConfiguredDensePlaneRouting || process.env.FANOUT_DEBUG_EXACT_COVER_ALTERNATES === "1") {
+              if (useJointPlaneRepair || process.env.FANOUT_DEBUG_EXACT_COVER_ALTERNATES === "1") {
                 const candidateSets = orderedAlternatePlaneBuses.map(
                   (planeBus) => ({
                     planeBus,
@@ -32688,7 +32766,7 @@ var FanoutSolver = class extends BaseSolver {
                     }))
                   })
                 );
-                if (useAdaptiveJointPlaneSelection) {
+                if (useJointPlaneSelection) {
                   const acceptedPlans = [
                     ...candidatePlans,
                     ...feasibleAlternatePlanePlans
@@ -32945,7 +33023,7 @@ var FanoutSolver = class extends BaseSolver {
               );
               if (!alternatePlanePlans) return null;
               feasibleAlternatePlanePlans = alternatePlanePlans;
-              if (useAdaptiveJointPlaneSelection) {
+              if (useJointPlaneSelection) {
                 matchedPlaneBusesInRoutingOrder = [];
                 return new Map([
                   ...fixedBoundaryViaPoints,
@@ -33383,6 +33461,27 @@ var FanoutSolver = class extends BaseSolver {
         denseRoutingStrategy: "boundary-aligned"
       });
       if (boundaryAlignedState) return boundaryAlignedState;
+      if (!useBoundaryRecovery && failedWideBoundaryBus) {
+        const busId = failedWideBoundaryBus.busId;
+        const outward = preferBoundaryOutwardByBusId.get(busId) ?? true;
+        const side = preferredBoundaryPerpendicularSideByBusId.get(busId) ?? 1;
+        for (const [preferOutward, perpendicularSide] of [
+          [!outward, -side],
+          [!outward, side],
+          [outward, -side],
+          [outward, side]
+        ]) {
+          const recoveredState = yield* this.routeDenseThroughAllMixedTerminationSteps({
+            ...params,
+            boundaryRecovery: {
+              busId,
+              preferOutward,
+              perpendicularSide
+            }
+          });
+          if (recoveredState) return recoveredState;
+        }
+      }
     }
     if (!usePadAlignedDenseRouting || process.env.FANOUT_DEBUG_DENSE_ONLY === "1")
       return null;
@@ -47305,7 +47404,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1852",
+  version: "0.0.1854",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -47340,12 +47439,12 @@ var package_default = {
     "@tscircuit/alphabet": "0.0.25",
     "@tscircuit/bga-fanout-solver": "github:tscircuit/bga-fanout-solver#247c835cb8d69b65e53891dcf869731079415b39",
     "@tscircuit/capacity-autorouter": "^0.0.885",
-    "@tscircuit/checks": "^0.0.183",
+    "@tscircuit/checks": "^0.0.184",
     "@tscircuit/circuit-json-util": "^0.0.106",
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "^0.0.52",
     "@tscircuit/create-fdm-enclosure": "0.0.4",
-    "@tscircuit/fanout-solver": "0.0.62",
+    "@tscircuit/fanout-solver": "0.0.64",
     "@tscircuit/footprinter": "^0.0.426",
     "@tscircuit/image-utils": "^0.0.8",
     "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#a5cbbda0cd65fd4707c5c1af25779837c25aba92",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.1853",
+  "version": "0.0.1855",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -36,12 +36,12 @@
     "@tscircuit/alphabet": "0.0.25",
     "@tscircuit/bga-fanout-solver": "github:tscircuit/bga-fanout-solver#247c835cb8d69b65e53891dcf869731079415b39",
     "@tscircuit/capacity-autorouter": "^0.0.885",
-    "@tscircuit/checks": "^0.0.183",
+    "@tscircuit/checks": "^0.0.184",
     "@tscircuit/circuit-json-util": "^0.0.106",
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "^0.0.52",
     "@tscircuit/create-fdm-enclosure": "0.0.4",
-    "@tscircuit/fanout-solver": "0.0.62",
+    "@tscircuit/fanout-solver": "0.0.64",
     "@tscircuit/footprinter": "^0.0.426",
     "@tscircuit/image-utils": "^0.0.8",
     "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#a5cbbda0cd65fd4707c5c1af25779837c25aba92",