@tscircuit/core 0.0.1849 → 0.0.1850

package/dist/index.js

@@ -21600,6 +21600,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
     allowSameNetMerges = false,
     maximumRouteOrderAttempts,
     reservedVias = [],
+    softReservedVias = [],
     gridStepDivisor = 1,
     preferTargetDirectedLaneBias = false,
     allowSourceLayerRouting = false,
@@ -21647,6 +21648,36 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
       point: { x: gridMinX + column * gridStep, y: gridMinY + row * gridStep }
     };
   });
+  const softViaCosts = softReservedVias.length ? new Float32Array(nodeCount) : void 0;
+  if (softViaCosts) {
+    for (const { via } of softReservedVias) {
+      if (!via.spanLayers.includes(targetLayer)) continue;
+      const radius = via.diameter / 2 + traceWidth / 2 + clearance;
+      const minimumColumn = Math.max(
+        0,
+        Math.ceil((via.center.x - radius - gridMinX) / gridStep)
+      );
+      const maximumColumn = Math.min(
+        columnCount - 1,
+        Math.floor((via.center.x + radius - gridMinX) / gridStep)
+      );
+      const minimumRow = Math.max(
+        0,
+        Math.ceil((via.center.y - radius - gridMinY) / gridStep)
+      );
+      const maximumRow = Math.min(
+        rowCount - 1,
+        Math.floor((via.center.y + radius - gridMinY) / gridStep)
+      );
+      for (let row = minimumRow; row <= maximumRow; row++) {
+        for (let column = minimumColumn; column <= maximumColumn; column++) {
+          const index = row * columnCount + column;
+          if (distance9(nodes[index].point, via.center) < radius)
+            softViaCosts[index] = softViaCosts[index] + 25 * gridStep;
+        }
+      }
+    }
+  }
   const sampledGridPoints = includeVisualization ? nodes.filter(
     (_, index) => index % Math.max(1, Math.ceil(nodes.length / 1e3)) === 0
   ).map((node) => node.point) : [];
@@ -22052,7 +22083,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
           boundaryDirection
         );
         const lanePenalty = laneBias === 0 ? 0 : laneBias > 0 ? Math.max(0, targetTrack - nextTrack) * 0.2 : Math.max(0, nextTrack - targetTrack) * 0.2;
-        const nextDistance = currentDistance + (deltaColumn !== 0 && deltaRow !== 0 ? gridStep * Math.SQRT2 : gridStep) + (addsTurn ? gridStep * 0.2 : 0) + lanePenalty;
+        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;
         const edgeIndex = current.node * 8 + directionIndex;
@@ -22440,6 +22471,59 @@ function getWindingCrossoverLayer(params) {
     (layer) => layer !== escapeLayer
   );
 }
+function getDistributedBoundaryTargetTracks(params) {
+  const { bus, boundaryDirection, traceWidth, clearance } = params;
+  if (getCornerSide(bus) || !busUsesCoordinatedWindingChannel(bus))
+    return void 0;
+  const layers = new Set(
+    bus.connections.map(
+      (connection) => connection.exitTargetPoint?.layer ?? getPointLayer2(connection.targetPoint)
+    )
+  );
+  if (layers.size < 2) return void 0;
+  const minimum = isHorizontal(boundaryDirection) ? bus.sharedBoundary.minY : bus.sharedBoundary.minX;
+  const maximum = isHorizontal(boundaryDirection) ? bus.sharedBoundary.maxY : bus.sharedBoundary.maxX;
+  const tracks = bus.connections.map(
+    (connection) => Math.max(
+      minimum,
+      Math.min(
+        maximum,
+        getPerpendicularAxis2(
+          connection.exitTargetPoint ?? connection.targetPoint,
+          boundaryDirection
+        )
+      )
+    )
+  ).toSorted((a, b) => a - b);
+  const pitch = traceWidth + clearance;
+  if (tracks.every(
+    (track, index) => index === 0 || track - tracks[index - 1] >= pitch - 1e-9
+  ))
+    return void 0;
+  if (maximum - minimum < (tracks.length - 1) * pitch - 1e-9) return void 0;
+  const blocks = [];
+  for (const [index, track] of tracks.entries()) {
+    blocks.push({ start: index, count: 1, mean: track - index * pitch });
+    while (blocks.length > 1 && blocks.at(-2).mean > blocks.at(-1).mean) {
+      const second = blocks.pop();
+      const first = blocks.pop();
+      blocks.push({
+        start: first.start,
+        count: first.count + second.count,
+        mean: (first.mean * first.count + second.mean * second.count) / (first.count + second.count)
+      });
+    }
+  }
+  for (const block of blocks) {
+    const mean = Math.max(
+      minimum,
+      Math.min(maximum - (tracks.length - 1) * pitch, block.mean)
+    );
+    for (let index = block.start; index < block.start + block.count; index++)
+      tracks[index] = mean + index * pitch;
+  }
+  return tracks;
+}
 function getBoundaryTargetTrack(params) {
   const requestedTrack = getPerpendicularAxis2(
     params.connection.exitTargetPoint ?? params.connection.targetPoint,
@@ -22447,6 +22531,19 @@ function getBoundaryTargetTrack(params) {
   );
   const boundaryMinimum = isHorizontal(params.boundaryDirection) ? params.bus.sharedBoundary.minY : params.bus.sharedBoundary.minX;
   const boundaryMaximum = isHorizontal(params.boundaryDirection) ? params.bus.sharedBoundary.maxY : params.bus.sharedBoundary.maxX;
+  const distributedTracks = params.traceWidth !== void 0 && params.clearance !== void 0 ? getDistributedBoundaryTargetTracks({
+    ...params,
+    traceWidth: params.traceWidth,
+    clearance: params.clearance
+  }) : void 0;
+  if (distributedTracks && params.layerNames && params.targetLayer) {
+    const { rank } = getWindingTargetRank({
+      ...params,
+      layerNames: params.layerNames,
+      targetLayer: params.targetLayer
+    });
+    return distributedTracks[rank];
+  }
   return Math.max(boundaryMinimum, Math.min(boundaryMaximum, requestedTrack));
 }
 function getCornerTargetTrack(params) {
@@ -22936,7 +23033,11 @@ function buildPlan2(params) {
   }) : usesLayeredWindingChannel ? getBoundaryTargetTrack({
     bus,
     connection: preparedConnection,
-    boundaryDirection
+    boundaryDirection,
+    traceWidth,
+    clearance,
+    layerNames,
+    targetLayer
   }) : track;
   const connectionRank = getConnectionRank(bus, preparedConnection);
   const localCornerSide = getLocalCornerSide(bus);
@@ -24019,6 +24120,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
     stopAfterFirstRejectedViaMinimalCandidate = false,
     fixedViaPointsByConnectionIndex,
     reservedVias = [],
+    softReservedVias = [],
     viaMinimalOnly = false,
     allowBoundarySideViaFallback = false,
     preferCornerBoundaryVia = false,
@@ -24113,7 +24215,12 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
       })
     );
     const maximumThroughAllRouteOrderAttempts = 24;
-    const windingTargetOrderCount = cornerSide ? getWindingTargetOrders({
+    const windingTargetOrderCount = cornerSide || getDistributedBoundaryTargetTracks({
+      bus,
+      boundaryDirection,
+      traceWidth,
+      clearance
+    }) ? getWindingTargetOrders({
       bus,
       boundaryDirection,
       layerNames,
@@ -24217,7 +24324,12 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
       useViaInPad: true,
       getViaHandedness: () => 0
     };
-    const coordinatedViaPoints = fixedViaPointsByConnectionIndex ?? (!allowBlindAndBuriedVias && bus.connections.length >= 8 && reservedVias.length === 0 ? matchComponentDogboneViaSites([bus], {
+    const coordinatedViaPoints = fixedViaPointsByConnectionIndex ?? (!allowBlindAndBuriedVias && (bus.connections.length >= 8 || getDistributedBoundaryTargetTracks({
+      bus,
+      boundaryDirection,
+      traceWidth,
+      clearance
+    })) && reservedVias.length === 0 ? matchComponentDogboneViaSites([bus], {
       viaDiameter,
       viaHoleDiameter,
       traceWidth,
@@ -24321,7 +24433,12 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
         }) : getBoundaryTargetTrack({
           bus,
           connection: preparedConnection,
-          boundaryDirection
+          boundaryDirection,
+          traceWidth,
+          clearance,
+          layerNames,
+          targetLayer,
+          windingOrderIndex: terminalPattern.windingOrderIndex
         });
         return {
           connection: preparedConnection,
@@ -24405,6 +24522,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
           alignGridToPads,
           includeReverseTargetRotation: terminalPattern.localDogboneRepair,
           reservedVias,
+          softReservedVias,
           gridStepDivisor,
           preferTargetDirectedLaneBias: terminalPattern.preferTargetDirectedLaneBias
         },
@@ -24473,7 +24591,11 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
       }) : getBoundaryTargetTrack({
         bus,
         connection: preparedConnection,
-        boundaryDirection
+        boundaryDirection,
+        traceWidth,
+        clearance,
+        layerNames,
+        targetLayer
       })
     );
     const finalExitPoints = finalTracks.map(
@@ -24549,7 +24671,50 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
         })
       )
     ) : [];
+    const matchedVias = bus.connections.map(
+      (connection) => fixedViaPointsByConnectionIndex.get(connection.connectionIndex)
+    );
+    const packageEdgeViaCandidates = [
+      {
+        distance: sourceCenter.x - bus.componentBounds.minX,
+        axis: "x",
+        value: bus.componentBounds.minX - 2 * insetStep
+      },
+      {
+        distance: bus.componentBounds.maxX - sourceCenter.x,
+        axis: "x",
+        value: bus.componentBounds.maxX + 2 * insetStep
+      },
+      {
+        distance: sourceCenter.y - bus.componentBounds.minY,
+        axis: "y",
+        value: bus.componentBounds.minY - 2 * insetStep
+      },
+      {
+        distance: bus.componentBounds.maxY - sourceCenter.y,
+        axis: "y",
+        value: bus.componentBounds.maxY + 2 * insetStep
+      }
+    ].toSorted((a, b) => a.distance - b.distance).flatMap(({ axis, value }) => {
+      const otherAxis = axis === "x" ? "y" : "x";
+      const mean = matchedVias.reduce((sum, via) => sum + via[otherAxis], 0) / matchedVias.length;
+      const order = matchedVias.map((via, index) => ({ index, track: via[otherAxis] })).toSorted((a, b) => a.track - b.track || a.index - b.index);
+      const pitch = viaDiameter + clearance;
+      const points = matchedVias.map((via, index) => ({
+        ...via,
+        [axis]: value,
+        [otherAxis]: order.length === 2 && Math.abs(order[1].track - order[0].track) < pitch ? mean + (order.findIndex((v) => v.index === index) - 0.5) * pitch : via[otherAxis]
+      }));
+      return points.length === 2 ? [points, [points[1], points[0]]] : [points];
+    });
+    const preferPackageEdgeVias = bus.connections.length === 2 && Boolean(getCornerSide(bus));
     const viaCandidates = [
+      ...(preferPackageEdgeVias ? packageEdgeViaCandidates : []).map(
+        (points) => ({
+          points,
+          boundarySide: false
+        })
+      ),
       ...displacedViaCandidates.map((points) => ({
         points,
         boundarySide: false
@@ -24557,7 +24722,16 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
       ...boundaryViaCandidates.map((points) => ({
         points,
         boundarySide: true
-      }))
+      })),
+      // Preserve existing centered and singleton escapes before trying a short
+      // source-layer route beyond the package. The target layer can then wind to the exit
+      // without a local via being fenced in by an already-routed wide bus.
+      ...(!preferPackageEdgeVias ? packageEdgeViaCandidates : []).map(
+        (points) => ({
+          points,
+          boundarySide: false
+        })
+      )
     ];
     for (const { points: boundaryViaPoints, boundarySide } of viaCandidates) {
       const boundaryVias = bus.connections.map((connection, index) => ({
@@ -24608,6 +24782,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
           allowBlindAndBuriedVias,
           allowSameNetMerges,
           maximumRouteOrderAttempts: bus.connections.length === 1 ? 3 : 6,
+          softReservedVias,
           reservedVias: bus.connections.length > 1 ? [...reservedVias, ...boundaryVias] : reservedVias,
           gridStepDivisor: 2,
           allowSourceLayerRouting: true,
@@ -24651,6 +24826,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
             allowSameNetMerges,
             maximumRouteOrderAttempts: 6,
             reservedVias,
+            softReservedVias,
             gridStepDivisor: 2,
             alignGridToPads: true
           },
@@ -24701,7 +24877,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
           );
           return {
             ...sourceLayerPlan,
-            ...preferCornerBoundaryVia || bus.connections.length > 1 ? { sourceEscapeSegmentCount: sourceLayerPlan.segments.length } : {},
+            ...preferCornerBoundaryVia || bus.connections.length > 1 || !boundarySide ? { sourceEscapeSegmentCount: sourceLayerPlan.segments.length } : {},
             targetLayer,
             exitPoint: finalExitPoint,
             via,
@@ -25511,6 +25687,99 @@ function matchBusPlanLengths(params) {
           if (++attempts >= 4) break;
         }
       }
+      if (!acceptedPlans && params.allowUnconstrainedLaneRerouting) {
+        let rerouteAttempts = 0;
+        candidateSearch: for (const targetAddedLength of targetAddedLengths) {
+          const candidates = createTunedPlanCandidates({
+            plan: shortest,
+            bus,
+            targetAddedLength,
+            clearance,
+            sharedBoundary: bus.sharedBoundary,
+            allowInsideDenseBounds: allowMatchingInsideDenseBounds
+          });
+          for (const candidate of candidates) {
+            if (!fanoutPlansAreClear({
+              plans: [candidate],
+              srj: inputSrj,
+              sharedBoundary,
+              clearance,
+              allowBlindAndBuriedVias,
+              allowSameNetMerges
+            }))
+              continue;
+            const blockers = matchedPlans.filter(
+              (plan) => plan !== shortest && !fanoutPlansAreMutuallyClear({
+                plans: [candidate, plan],
+                srj: inputSrj,
+                clearance,
+                allowSameNetMerges
+              })
+            );
+            if (blockers.length !== 1) continue;
+            const blocker = blockers[0];
+            const blockerBus = preparedBuses.find(
+              (prepared) => prepared.busId === blocker.busId
+            );
+            if (!blockerBus || blockerBus.termination.type !== "boundary" || blockerBus.maxLengthSkew !== void 0 || blockerBus.connections.length !== 1 || !blocker.via || blocker.additionalVias?.length || blocker.planeEndpointVia || blocker.segments.filter(
+              (segment2) => segment2.layer === blocker.sourceLayer
+            ).length !== 1)
+              continue;
+            const nextPlans = matchedPlans.map(
+              (plan) => plan === shortest ? candidate : plan
+            );
+            for (const alignGridToPads of [true, false]) {
+              if (rerouteAttempts++ >= 4) break candidateSearch;
+              const rerouted = routeViaMinimalWinding({
+                srj: inputSrj,
+                bus: blockerBus,
+                terminals: [
+                  {
+                    connection: blockerBus.connections[0],
+                    viaPoint: blocker.via.center,
+                    exitPoint: blocker.exitPoint
+                  }
+                ],
+                targetLayer: blocker.targetLayer,
+                acceptedPlans: nextPlans.filter((plan) => plan !== blocker),
+                layerNames: getCopperLayerNames(inputSrj.layerCount),
+                traceWidth: blocker.segments[0].width,
+                viaDiameter: blocker.via.diameter,
+                viaHoleDiameter: blocker.via.holeDiameter,
+                clearance,
+                allowBlindAndBuriedVias,
+                allowSameNetMerges,
+                gridStepDivisor: 2,
+                alignGridToPads,
+                maximumRouteOrderAttempts: 1,
+                preferTargetDirectedLaneBias: true
+              })?.[0];
+              if (!rerouted) continue;
+              const repaired = createPlanWithSegments(blocker, [
+                blocker.segments[0],
+                ...rerouted.segments.slice(1)
+              ]);
+              if (!repaired) continue;
+              const repairedPlans = nextPlans.map(
+                (plan) => plan === blocker ? repaired : plan
+              );
+              if (getBusSkew(
+                repairedPlans.filter((plan) => plan.busId === bus.busId)
+              ) > maxLengthSkew + EPSILON8 || !fanoutPlansAreClear({
+                plans: repairedPlans,
+                srj: inputSrj,
+                sharedBoundary,
+                clearance,
+                allowBlindAndBuriedVias,
+                allowSameNetMerges
+              }) || candidatePlansAreFeasible && !candidatePlansAreFeasible(repairedPlans))
+                continue;
+              acceptedPlans = repairedPlans;
+              break candidateSearch;
+            }
+          }
+        }
+      }
       if (!acceptedPlans) return { plans: null, failedBus: bus };
       matchedPlans = acceptedPlans;
     }
@@ -30598,6 +30867,7 @@ var FanoutSolver = class extends BaseSolver {
    */
   *routeDenseThroughAllMixedTerminationSteps(params) {
     if (this.config.allowBlindAndBuriedVias) return null;
+    let boundaryViaPointsForRetry = params.preferredBoundaryViaPoints;
     const usePadAlignedDenseRouting = params.denseRoutingStrategy !== "boundary-aligned";
     const debugDense = (...values) => {
       if (process.env.FANOUT_DEBUG_DENSE === "1") {
@@ -30632,7 +30902,7 @@ var FanoutSolver = class extends BaseSolver {
       this.config.allowBlindAndBuriedVias
     );
     const useConfiguredDensePlaneRouting = configuredDensePlaneRouting || useAdaptiveDensePlaneRouting;
-    const useAdaptiveJointPlaneSelection = useAdaptiveDensePlaneRouting && (params.planeReservationRetryCount ?? 0) === 0;
+    const useAdaptiveJointPlaneSelection = useAdaptiveDensePlaneRouting && ((params.planeReservationRetryCount ?? 0) === 0 || Boolean(params.preferredBoundaryViaPoints));
     const matchLengthsAfterPlanes = useConfiguredDensePlaneRouting && params.lengthMatchingStage !== "before-planes";
     const useJointBoundaryViaReservation = shouldUseJointBoundaryViaReservation(
       unsortedBoundaryBuses.map((bus) => bus.connections.length)
@@ -30895,9 +31165,23 @@ var FanoutSolver = class extends BaseSolver {
     const throughAllLeadingSingletonBuses = hasThreeWideBoundaryBuses ? singletonBoundaryBuses.filter((singletonBus) => {
       const containingWideBus = getContainingWideSourceField(singletonBus);
       const singletonTargetLayer = params.busLayerAssignments[singletonBus.busId];
-      const containingWideLayers = containingWideBus?.routableEscapeLayers ?? containingWideBus?.allowedLayers ?? [];
+      if (!containingWideBus || !singletonTargetLayer) return false;
+      const containingWideLayers = containingWideBus.routableEscapeLayers ?? containingWideBus.allowedLayers ?? [];
+      const sourceAxis = singletonBus.exitEdge === "left" || singletonBus.exitEdge === "right" ? "x" : "y";
+      const wideCoordinates = containingWideBus.connections.map(
+        (connection) => connection.sourcePoint[sourceAxis]
+      );
+      const outwardSourceCoordinate = singletonBus.exitEdge === "left" || singletonBus.exitEdge === "bottom" ? Math.min(...wideCoordinates) : Math.max(...wideCoordinates);
+      const isOnOutwardSourceEdge = singletonBus.connections.every(
+        (connection) => Math.abs(
+          connection.sourcePoint[sourceAxis] - outwardSourceCoordinate
+        ) < 1e-9
+      );
       return Boolean(
-        containingWideBus && singletonTargetLayer && !containingWideLayers.includes(singletonTargetLayer)
+        !containingWideLayers.includes(singletonTargetLayer) || useAdaptiveDensePlaneRouting && isOnOutwardSourceEdge && getCornerBandSide(
+          singletonBus.exitEdge,
+          singletonBus.preferredExit
+        )
       );
     }) : [];
     const throughAllLeadingCompanionBuses = throughAllLeadingSingletonBuses.flatMap((singletonBus) => {
@@ -30940,8 +31224,15 @@ var FanoutSolver = class extends BaseSolver {
       ...process.env.FANOUT_DEBUG_PROVISIONAL_NARROW === "1" ? boundaryBuses.filter((bus) => bus.connections.length < 8) : [],
       ...singletonDeferralCandidates.filter((bus) => {
         const containingBus = getContainingWideSourceField(bus);
-        const sharesContainingBusLayer = usePadAlignedDenseRouting && !useConfiguredDensePlaneRouting && containingBus && params.busLayerAssignments[containingBus.busId] === params.busLayerAssignments[bus.busId];
-        return !leadingWideSingletonBuses.includes(bus) && !sharesContainingBusLayer;
+        const sourcePoint = bus.connections[0].sourcePoint;
+        const componentCenter = {
+          x: (bus.componentBounds.minX + bus.componentBounds.maxX) / 2,
+          y: (bus.componentBounds.minY + bus.componentBounds.maxY) / 2
+        };
+        const boundaryDirection = bus.exitEdge ? getDirectionForExitEdge(bus.exitEdge) : bus.direction;
+        const inwardProjection = boundaryDirection === "right" ? componentCenter.x - sourcePoint.x : boundaryDirection === "left" ? sourcePoint.x - componentCenter.x : boundaryDirection === "up" ? componentCenter.y - sourcePoint.y : sourcePoint.y - componentCenter.y;
+        const reserveEmbeddedSourceEscape = usePadAlignedDenseRouting && !useConfiguredDensePlaneRouting && containingBus && (params.busLayerAssignments[containingBus.busId] === params.busLayerAssignments[bus.busId] || inwardProjection > 1e-9);
+        return !leadingWideSingletonBuses.includes(bus) && !reserveEmbeddedSourceEscape;
       }),
       ...hasThreeWideBoundaryBuses ? boundaryBuses.filter(
         (bus) => bus.connections.length === 2 && !narrowBusOverlapsWideTargetSpan(bus) && !leadingWideSingletonBuses.includes(bus)
@@ -30972,6 +31263,7 @@ var FanoutSolver = class extends BaseSolver {
         traceWidth: this.config.traceWidth,
         clearance: this.config.clearance,
         maximumSearchStates: 1e5,
+        preferredViaPointsByConnectionIndex: params.preferredBoundaryViaPoints,
         preferredBoundaryPerpendicularSideByBusId,
         preferBoundaryOutwardByBusId,
         additionalObstacles: denseAdditionalObstacles,
@@ -30987,6 +31279,7 @@ var FanoutSolver = class extends BaseSolver {
         traceWidth: this.config.traceWidth,
         clearance: this.config.clearance,
         maximumSearchStates: 2e4,
+        preferredViaPointsByConnectionIndex: params.preferredBoundaryViaPoints,
         preferredBoundaryPerpendicularSideByBusId,
         preferBoundaryOutwardByBusId,
         additionalObstacles: denseAdditionalObstacles,
@@ -31034,6 +31327,7 @@ var FanoutSolver = class extends BaseSolver {
             traceWidth: this.config.traceWidth,
             clearance: this.config.clearance,
             maximumSearchStates: 1e5,
+            preferredViaPointsByConnectionIndex: params.preferredBoundaryViaPoints,
             preferredBoundaryPerpendicularSideByBusId,
             preferBoundaryOutwardByBusId,
             fixedViaPointsByConnectionIndex: seedViaPoints,
@@ -31084,6 +31378,74 @@ var FanoutSolver = class extends BaseSolver {
           bus
         ])
       ];
+      const areAdjacentInvertedNarrowBuses = (first, second) => {
+        if (!usePadAlignedDenseRouting || useConfiguredDensePlaneRouting || first.componentId !== second.componentId || first.exitEdge !== second.exitEdge || first.direction !== second.direction || getCornerBandSide(first.exitEdge, first.preferredExit) !== getCornerBandSide(second.exitEdge, second.preferredExit) || params.busLayerAssignments[first.busId] !== params.busLayerAssignments[second.busId] || getContainingWideSourceField(first) !== getContainingWideSourceField(second) || !getContainingWideSourceField(first))
+          return false;
+        const firstCenter = {
+          x: first.connections.reduce(
+            (sum, connection) => sum + connection.sourcePoint.x,
+            0
+          ) / first.connections.length,
+          y: first.connections.reduce(
+            (sum, connection) => sum + connection.sourcePoint.y,
+            0
+          ) / first.connections.length
+        };
+        const secondCenter = {
+          x: second.connections.reduce(
+            (sum, connection) => sum + connection.sourcePoint.x,
+            0
+          ) / second.connections.length,
+          y: second.connections.reduce(
+            (sum, connection) => sum + connection.sourcePoint.y,
+            0
+          ) / second.connections.length
+        };
+        if (Math.hypot(
+          firstCenter.x - secondCenter.x,
+          firstCenter.y - secondCenter.y
+        ) > 1.5 * Math.min(first.pitchX, first.pitchY))
+          return false;
+        const axis = first.exitEdge === "left" || first.exitEdge === "right" ? "y" : "x";
+        const targetTrack = (bus) => bus.connections.reduce(
+          (sum, connection) => sum + (connection.exitTargetPoint ?? connection.targetPoint)[axis],
+          0
+        ) / bus.connections.length;
+        return (firstCenter[axis] - secondCenter[axis]) * (targetTrack(first) - targetTrack(second)) < -1e-9;
+      };
+      const centeredPairPromotionGroups = /* @__PURE__ */ new Set();
+      for (const singleton of multiLayerLeadingSingletonBuses) {
+        if (getCornerBandSide(singleton.exitEdge, singleton.preferredExit))
+          continue;
+        for (const pair of boundaryBuses) {
+          if (pair.connections.length !== 2 || !areAdjacentInvertedNarrowBuses(pair, singleton))
+            continue;
+          const pairIndex = denseBoundaryBusesInRoutingOrder.indexOf(pair);
+          const singletonIndex = denseBoundaryBusesInRoutingOrder.indexOf(singleton);
+          if (pairIndex > singletonIndex) {
+            denseBoundaryBusesInRoutingOrder.splice(pairIndex, 1);
+            denseBoundaryBusesInRoutingOrder.splice(singletonIndex, 0, pair);
+            centeredPairPromotionGroups.add(
+              `${pair.componentId}:${pair.exitEdge}`
+            );
+          }
+        }
+      }
+      for (const pair of boundaryBuses) {
+        if (!centeredPairPromotionGroups.has(
+          `${pair.componentId}:${pair.exitEdge}`
+        ) || pair.connections.length !== 2 || !getCornerBandSide(pair.exitEdge, pair.preferredExit))
+          continue;
+        for (const singleton of singletonBoundaryBuses) {
+          if (!areAdjacentInvertedNarrowBuses(singleton, pair)) continue;
+          const singletonIndex = denseBoundaryBusesInRoutingOrder.indexOf(singleton);
+          const pairIndex = denseBoundaryBusesInRoutingOrder.indexOf(pair);
+          if (singletonIndex > pairIndex) {
+            denseBoundaryBusesInRoutingOrder.splice(singletonIndex, 1);
+            denseBoundaryBusesInRoutingOrder.splice(pairIndex, 0, singleton);
+          }
+        }
+      }
       let fixedViaPointsByConnectionIndex = seedViaPoints;
       let matchedPlans = [];
       let matchedRoutingSucceeded = true;
@@ -31169,7 +31531,9 @@ var FanoutSolver = class extends BaseSolver {
           allowBoundarySideViaFallback: bus.connections.length === 1,
           preferCornerBoundaryVia: useConfiguredDensePlaneRouting,
           adaptiveWindingRouteOrder,
-          alignWindingGridToPads: usePadAlignedDenseRouting && !useConfiguredDensePlaneRouting,
+          // Retain pad-aligned channels even when plane sites are reserved
+          // adaptively; the boundary grid can fence off a turning wide bus.
+          alignWindingGridToPads: usePadAlignedDenseRouting && !configuredDensePlaneRouting,
           fixedViaFallbackRouteOrderAttempts: adaptiveWindingRouteOrder ? 60 : useConfiguredDensePlaneRouting ? 6 : 24,
           cornerBandTargetTrackOffset: getCornerBandTargetTrackOffset(bus)
         };
@@ -31194,6 +31558,7 @@ var FanoutSolver = class extends BaseSolver {
           (candidate) => candidate.connections.length < 8 && getContainingWideSourceField(candidate) === bus && matchedPlans.some((plan) => plan.busId === candidate.busId)
         );
         const preferSingleLayerWinding = useConfiguredDensePlaneRouting && singleLayerBus !== bus && !embeddedNarrowBusAlreadyRouted;
+        let usedSoftPlaneRepair = false;
         let busPlans = (yield* routeAlternatives(
           preferSingleLayerWinding ? { ...routeParams, bus: singleLayerBus } : routeParams,
           1
@@ -31293,6 +31658,71 @@ var FanoutSolver = class extends BaseSolver {
             }
           }
         }
+        if (!busPlans && bus.connections.length >= 8 && boundaryBuses.some(
+          (candidate) => candidate.connections.length >= 8 && matchedPlans.some((plan) => plan.busId === candidate.busId)
+        )) {
+          const committedNames = new Set(
+            matchedPlans.map((plan) => plan.connectionName)
+          );
+          const futurePlaneNames = new Set(
+            this.preparedBuses.filter((candidate) => candidate.termination.type === "plane").flatMap(
+              (candidate) => candidate.connections.map(
+                (connection) => connection.connection.name
+              )
+            ).filter((name) => !committedNames.has(name))
+          );
+          const freePlans = (yield* routeAlternatives(
+            {
+              ...routeParams,
+              fixedViaPointsByConnectionIndex: void 0,
+              reservedVias: routeParams.reservedVias.filter(
+                (reserved) => !futurePlaneNames.has(reserved.connectionName)
+              ),
+              softReservedVias: routeParams.reservedVias.filter(
+                (reserved) => futurePlaneNames.has(reserved.connectionName)
+              )
+            },
+            1
+          ))[0];
+          if (freePlans) {
+            const allPlans = [...matchedPlans, ...freePlans];
+            const rematchedPoints = matchComponentDogboneViaSites(
+              this.preparedBuses,
+              {
+                viaDiameter: this.config.viaDiameter,
+                viaHoleDiameter: this.config.viaHoleDiameter,
+                traceWidth: this.config.traceWidth,
+                clearance: this.config.clearance,
+                maximumSearchStates: 3e6,
+                preferredBoundaryPerpendicularSideByBusId,
+                preferBoundaryOutwardByBusId,
+                fixedViaPointsByConnectionIndex: new Map(
+                  allPlans.filter((plan) => plan.via).map((plan) => [plan.connectionIndex, plan.via.center])
+                ),
+                preferredViaPointsByConnectionIndex: fixedViaPointsByConnectionIndex,
+                blockingSegments: allPlans.flatMap(
+                  (plan) => plan.segments.map((segment2) => ({
+                    connectionIndex: plan.connectionIndex,
+                    segment: segment2
+                  }))
+                ),
+                additionalObstacles: this.routingSrj.obstacles,
+                preferPlaneCheckerboardSites: useConfiguredDensePlaneRouting,
+                canShareCopper
+              }
+            );
+            debugDense(
+              "free-sites:rematched",
+              bus.busId,
+              rematchedPoints?.size ?? "failed"
+            );
+            if (rematchedPoints) {
+              busPlans = freePlans;
+              fixedViaPointsByConnectionIndex = rematchedPoints;
+              usedSoftPlaneRepair = true;
+            }
+          }
+        }
         if (busPlans && bus.maxLengthSkew !== void 0) {
           const lengths = busPlans.map((plan) => plan.length);
           const rawSkew = Math.max(...lengths) - Math.min(...lengths);
@@ -31302,7 +31732,7 @@ var FanoutSolver = class extends BaseSolver {
             rawSkew,
             maximumSkew: bus.maxLengthSkew
           });
-          if (needsRouteDiversity && !matchLengthsAfterPlanes) {
+          if (needsRouteDiversity && !matchLengthsAfterPlanes && !usedSoftPlaneRepair) {
             busPlans = (yield* routeAlternatives(routeParams, 3)).toSorted(
               (first, second) => {
                 const firstLengths = first.map((plan) => plan.length);
@@ -31317,6 +31747,20 @@ var FanoutSolver = class extends BaseSolver {
           return false;
         }
         matchedPlans.push(...busPlans);
+        if (matchedPlans.length === boundaryBuses.reduce(
+          (sum, candidate) => sum + candidate.connections.length,
+          0
+        ) && matchedPlans.some((plan) => {
+          const bus2 = boundaryBuses.find(
+            (candidate) => candidate.busId === plan.busId
+          );
+          if (bus2?.connections.length !== 1 || !plan.via) return false;
+          const { center } = plan.via;
+          return center.x < bus2.componentBounds.minX || center.x > bus2.componentBounds.maxX || center.y < bus2.componentBounds.minY || center.y > bus2.componentBounds.maxY;
+        }))
+          boundaryViaPointsForRetry = new Map(
+            matchedPlans.filter((plan) => plan.via).map((plan) => [plan.connectionIndex, plan.via.center])
+          );
         debugDense("route:complete", bus.busId, busPlans.length);
         return true;
       }.bind(this);
@@ -31753,7 +32197,9 @@ var FanoutSolver = class extends BaseSolver {
               }
               let alternatePlaneSearchStates = 0;
               const maximumAlternatePlaneSearchStates = Number(
-                process.env.FANOUT_DEBUG_ALTERNATE_SEARCH_STATES ?? (useConfiguredDensePlaneRouting ? 3e6 : 1e3)
+                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)
               );
               const maximumAlternatePlaneRoutes = Number(
                 process.env.FANOUT_DEBUG_ALTERNATE_ROUTE_COUNT ?? (useConfiguredDensePlaneRouting ? 128 : 8)
@@ -32494,7 +32940,8 @@ var FanoutSolver = class extends BaseSolver {
           allowBlindAndBuriedVias: false,
           allowSameNetMerges: this.config.allowSameNetMerges,
           allowMatchingInsideDenseBounds: true,
-          allowPairLaneSpreading: true
+          allowPairLaneSpreading: true,
+          allowUnconstrainedLaneRerouting: true
         };
         let matchedLengthResult = matchBusPlanLengths(lengthMatchingParams);
         const shortenedBusIds = /* @__PURE__ */ new Set();
@@ -32569,6 +33016,7 @@ var FanoutSolver = class extends BaseSolver {
         debugDense("promote-reservations", refinedPromotions);
         return yield* this.routeDenseThroughAllMixedTerminationSteps({
           ...params,
+          preferredBoundaryViaPoints: boundaryViaPointsForRetry,
           promotedPlaneReservationBusIds: [
             ...params.promotedPlaneReservationBusIds ?? [],
             ...refinedPromotions
@@ -46511,7 +46959,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1848",
+  version: "0.0.1849",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -46551,7 +46999,7 @@ var package_default = {
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "^0.0.52",
     "@tscircuit/create-fdm-enclosure": "0.0.4",
-    "@tscircuit/fanout-solver": "0.0.58",
+    "@tscircuit/fanout-solver": "0.0.60",
     "@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.1849",
+  "version": "0.0.1850",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -41,7 +41,7 @@
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "^0.0.52",
     "@tscircuit/create-fdm-enclosure": "0.0.4",
-    "@tscircuit/fanout-solver": "0.0.58",
+    "@tscircuit/fanout-solver": "0.0.60",
     "@tscircuit/footprinter": "^0.0.426",
     "@tscircuit/image-utils": "^0.0.8",
     "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#a5cbbda0cd65fd4707c5c1af25779837c25aba92",