@tscircuit/core 0.0.1850 → 0.0.1852

package/dist/index.js

@@ -21192,6 +21192,24 @@ function getComponentDogboneViaSiteCandidates(preparedBuses, rules) {
     )
   );
 }
+function* getSingleDogboneViaSiteRepairs(bus, rules, fixedViaPointsByConnectionIndex) {
+  const sites = getComponentDogboneViaSiteCandidates([bus], rules);
+  let remainingAttempts = 24;
+  for (const connection of bus.connections.toReversed()) {
+    const original = fixedViaPointsByConnectionIndex.get(
+      connection.connectionIndex
+    );
+    if (!original) continue;
+    for (const candidate of sites) {
+      if (candidate.connectionIndex !== connection.connectionIndex || distance9(candidate.point, original) <= EPSILON6)
+        continue;
+      if (remainingAttempts-- <= 0) return;
+      const replacement = new Map(fixedViaPointsByConnectionIndex);
+      replacement.set(connection.connectionIndex, candidate.point);
+      yield replacement;
+    }
+  }
+}
 
 // node_modules/@tscircuit/fanout-solver/lib/route-via-minimal-winding.ts
 var EPSILON7 = 1e-7;
@@ -21606,7 +21624,8 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
     allowSourceLayerRouting = false,
     adaptiveRouteOrder = false,
     alignGridToPads = false,
-    includeReverseTargetRotation = false
+    includeReverseTargetRotation = false,
+    reserveTerminalExitPoints = false
   } = params;
   if (maximumRouteOrderAttempts !== void 0 && (!Number.isInteger(maximumRouteOrderAttempts) || maximumRouteOrderAttempts < 1)) {
     throw new Error(
@@ -21794,6 +21813,11 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
         return false;
       }
     }
+    for (const other of reserveTerminalExitPoints ? terminals : []) {
+      if (sharesNet(connectionName, other.connection.connection.name)) continue;
+      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);
@@ -22442,6 +22466,35 @@ function getWindingTargetOrders(params) {
     candidateOrders.push(adjacentExtension);
   }
   candidateOrders.push(legacyOrderedConnections);
+  const ordinaryOrderCount = new Set(
+    candidateOrders.map(
+      (order) => order.map((candidate) => candidate.connectionIndex).join(",")
+    )
+  ).size;
+  if (!getCornerSide(bus) && bus.connections.length <= 8 && orderedLayers.length > 1) {
+    const layerSequences = orderedLayers.map(
+      (layer) => connectionsByLayer.get(layer).toSorted(compareWithinLayer)
+    );
+    const offsets = layerSequences.map(() => 0);
+    const current = [];
+    const append = () => {
+      if (candidateOrders.length >= 128) return;
+      if (current.length === bus.connections.length) {
+        candidateOrders.push([...current]);
+        return;
+      }
+      for (let layer = 0; layer < layerSequences.length; layer++) {
+        const next = layerSequences[layer][offsets[layer]];
+        if (!next) continue;
+        offsets[layer]++;
+        current.push(next);
+        append();
+        current.pop();
+        offsets[layer]--;
+      }
+    };
+    append();
+  }
   const seenOrders = /* @__PURE__ */ new Set();
   const orders = candidateOrders.filter((order) => {
     const key = order.map((candidate) => candidate.connectionIndex).join(",");
@@ -22449,7 +22502,7 @@ function getWindingTargetOrders(params) {
     seenOrders.add(key);
     return true;
   });
-  return { orders, legacyOrder: legacyOrderedConnections };
+  return { orders, legacyOrder: legacyOrderedConnections, ordinaryOrderCount };
 }
 function getWindingTargetRank(params) {
   const { connection, windingOrderIndex = 0 } = params;
@@ -22496,7 +22549,7 @@ function getDistributedBoundaryTargetTracks(params) {
     )
   ).toSorted((a, b) => a - b);
   const pitch = traceWidth + clearance;
-  if (tracks.every(
+  if (!params.allowLayerInterleaving && tracks.every(
     (track, index) => index === 0 || track - tracks[index - 1] >= pitch - 1e-9
   ))
     return void 0;
@@ -24215,17 +24268,22 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
       })
     );
     const maximumThroughAllRouteOrderAttempts = 24;
-    const windingTargetOrderCount = cornerSide || getDistributedBoundaryTargetTracks({
-      bus,
-      boundaryDirection,
-      traceWidth,
-      clearance
-    }) ? getWindingTargetOrders({
+    const usesDistributedWindingTargets = Boolean(
+      cornerSide || getDistributedBoundaryTargetTracks({
+        bus,
+        boundaryDirection,
+        traceWidth,
+        clearance
+      })
+    );
+    const windingTargetOrders = getWindingTargetOrders({
       bus,
       boundaryDirection,
       layerNames,
       targetLayer
-    }).orders.length : 1;
+    });
+    const windingTargetOrderCount = windingTargetOrders.orders.length;
+    const ordinaryWindingTargetOrderCount = usesDistributedWindingTargets ? windingTargetOrders.ordinaryOrderCount : 1;
     const uniformDogboneTerminalPatterns = viaHandednesses.map((viaHandedness) => ({
       label: `uniform-${viaHandedness}`,
       useViaInPad: false,
@@ -24353,7 +24411,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
     }) : null);
     const fixedViaTerminalPatterns = coordinatedViaPoints ? [
       ...Array.from(
-        { length: windingTargetOrderCount },
+        { length: ordinaryWindingTargetOrderCount },
         (_, windingOrderIndex) => ({
           label: `component-matched-vias-winding-${windingOrderIndex}`,
           useViaInPad: false,
@@ -24374,7 +24432,23 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
         maximumRouteOrderAttempts: fixedViaFallbackRouteOrderAttempts,
         windingOrderIndex: 0,
         preferTargetDirectedLaneBias: true
-      }
+      },
+      // Keep ordinary fixed-site attempts first. Forward retries reserve
+      // future exits so an earlier lane cannot close their final gap.
+      ...!getCornerSide(bus) && windingTargetOrderCount > 1 ? Array.from(
+        { length: windingTargetOrderCount },
+        (_, windingOrderIndex) => [true, false].map((preferTargetDirectedLaneBias) => ({
+          label: `expanded-winding-${windingOrderIndex}-${preferTargetDirectedLaneBias}`,
+          useViaInPad: false,
+          getViaHandedness: () => 0,
+          getViaPoint: (connection) => coordinatedViaPoints.get(connection.connectionIndex),
+          maximumRouteOrderAttempts: 1,
+          windingOrderIndex,
+          preferTargetDirectedLaneBias,
+          reserveTerminalExitPoints: !preferTargetDirectedLaneBias,
+          allowLayerInterleaving: true
+        }))
+      ).flat() : []
     ] : [];
     const planeTerminationsAlreadyOccupyTheFanout = acceptedPlans.some(
       (plan) => plan.termination.type === "plane"
@@ -24415,6 +24489,21 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
         }
       }
     }
+    if (alignWindingGridToPads && cornerSide) {
+      const layerLocalExitOffset = getCornerLaneOffsets(
+        bus,
+        acceptedPlans.filter((plan) => plan.targetLayer === targetLayer)
+      ).exit;
+      if (layerLocalExitOffset !== cornerLaneOffsets.exit) {
+        terminalPatterns.push(
+          ...terminalPatterns.map((pattern) => ({
+            ...pattern,
+            label: `${pattern.label}-layer-local-corner`,
+            cornerExitLaneOffset: layerLocalExitOffset
+          }))
+        );
+      }
+    }
     const seenTerminalSignatures = /* @__PURE__ */ new Set();
     for (const terminalPattern of terminalPatterns) {
       const terminals = bus.connections.map((preparedConnection) => {
@@ -24422,7 +24511,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
         const boundaryTrack = cornerSide ? getCornerTargetTrack({
           bus,
           connection: preparedConnection,
-          cornerExitLaneOffset: cornerLaneOffsets.exit,
+          cornerExitLaneOffset: terminalPattern.cornerExitLaneOffset ?? cornerLaneOffsets.exit,
           traceWidth,
           viaDiameter,
           clearance,
@@ -24431,6 +24520,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
           windingOrderIndex: terminalPattern.windingOrderIndex,
           cornerBandTargetTrackOffset
         }) : getBoundaryTargetTrack({
+          allowLayerInterleaving: terminalPattern.allowLayerInterleaving,
           bus,
           connection: preparedConnection,
           boundaryDirection,
@@ -24500,7 +24590,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
         (terminal) => `${terminal.connection.connectionIndex}:${terminal.viaPoint.x}:${terminal.viaPoint.y}:${terminal.exitPoint.x}:${terminal.exitPoint.y}`
       ).join(
         "|"
-      )}:${terminalPattern.maximumRouteOrderAttempts ?? "all"}:${gridStepDivisor}:${alignGridToPads}:${Boolean(terminalPattern.localDogboneRepair)}`;
+      )}:${terminalPattern.maximumRouteOrderAttempts ?? "all"}:${gridStepDivisor}:${alignGridToPads}:${Boolean(terminalPattern.localDogboneRepair)}:${Boolean(terminalPattern.preferTargetDirectedLaneBias)}:${Boolean(terminalPattern.reserveTerminalExitPoints)}`;
       if (seenTerminalSignatures.has(terminalSignature)) continue;
       seenTerminalSignatures.add(terminalSignature);
       const windingSteps = routeViaMinimalWindingAlternativesSteps(
@@ -24523,6 +24613,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
           includeReverseTargetRotation: terminalPattern.localDogboneRepair,
           reservedVias,
           softReservedVias,
+          reserveTerminalExitPoints: terminalPattern.reserveTerminalExitPoints,
           gridStepDivisor,
           preferTargetDirectedLaneBias: terminalPattern.preferTargetDirectedLaneBias
         },
@@ -25286,7 +25377,23 @@ function replacementCopperIsSelfClear(params) {
       if (pointsMatch2(via.center, replacement.start) || pointsMatch2(via.center, replacement.end)) {
         continue;
       }
-      if (distancePointToSegment(via.center, replacement.start, replacement.end) < via.diameter / 2 + replacement.width / 2 + clearance - EPSILON8) {
+      const viaClearance = via.diameter / 2 + replacement.width / 2 + clearance;
+      const connectsThroughShortStub = (direction) => {
+        let point6 = direction === -1 ? replacement.start : replacement.end;
+        let pathDistance = 0;
+        for (let index = replacementIndex + direction; index >= 0 && index < segments.length; index += direction) {
+          const segment2 = segments[index];
+          if (segment2.layer !== replacement.layer) return false;
+          const connectedEnd = direction === -1 ? segment2.end : segment2.start;
+          if (!pointsMatch2(point6, connectedEnd)) return false;
+          pathDistance += distance9(segment2.start, segment2.end);
+          if (pathDistance > viaClearance + EPSILON8) return false;
+          point6 = direction === -1 ? segment2.start : segment2.end;
+          if (pointsMatch2(point6, via.center)) return true;
+        }
+        return false;
+      };
+      if (distancePointToSegment(via.center, replacement.start, replacement.end) < viaClearance - EPSILON8 && !connectsThroughShortStub(-1) && !connectsThroughShortStub(1)) {
         return false;
       }
     }
@@ -30289,7 +30396,92 @@ function createInitialLayerAssignment(params) {
       assignment[bus.busId] = sourceLayer;
     } else if (viaLayers.length > 0) {
       if (preferOrderedCoordinatedWindingLayers && busUsesCoordinatedWinding(bus)) {
-        assignment[bus.busId] = viaLayers[0];
+        const cornerSide = getCornerBandSide(bus.exitEdge, bus.preferredExit);
+        const getBoundaryCongestion = (layer) => {
+          if (!bus.exitEdge || bus.connections.length < 8) return 0;
+          const horizontalEdge = bus.exitEdge === "left" || bus.exitEdge === "right";
+          const axis = horizontalEdge ? "y" : "x";
+          const minimum = horizontalEdge ? bus.sharedBoundary.minY : bus.sharedBoundary.minX;
+          const maximum = horizontalEdge ? bus.sharedBoundary.maxY : bus.sharedBoundary.maxX;
+          if (!cornerSide) {
+            const tracks = bus.connections.map((connection) => {
+              const target = connection.exitTargetPoint ?? connection.targetPoint;
+              return Math.max(minimum, Math.min(maximum, target[axis]));
+            });
+            const bandMinimum = Math.min(...tracks);
+            const bandMaximum = Math.max(...tracks);
+            const forwardAxis = horizontalEdge ? "x" : "y";
+            const sign = bus.exitEdge === "right" || bus.exitEdge === "top" ? 1 : -1;
+            const sourceNearEnd = Math.min(
+              ...bus.connections.map(
+                (connection) => sign * connection.sourcePoint[forwardAxis]
+              )
+            );
+            const sourceMinimum = Math.min(
+              ...bus.connections.map(
+                (connection) => connection.sourcePoint[axis]
+              )
+            );
+            const sourceMaximum = Math.max(
+              ...bus.connections.map(
+                (connection) => connection.sourcePoint[axis]
+              )
+            );
+            return buses.reduce((count, other) => {
+              const otherCorner = getCornerBandSide(
+                other.exitEdge,
+                other.preferredExit
+              );
+              if (other === bus || other.termination.type !== "boundary" || other.componentId !== bus.componentId || other.exitEdge !== bus.exitEdge || !otherCorner || getCommonExplicitExitTargetLayer(other) !== layer)
+                return count;
+              const center = minimum + (maximum - minimum) * (otherCorner === "minimum" ? 0.25 : 0.75);
+              const halfWidth = (Math.max(
+                other.connections.length,
+                other.cornerBandConnectionCount ?? 0
+              ) - 1) * Math.max(
+                params.traceWidth + params.clearance,
+                params.viaDiameter + params.clearance
+              ) / 2;
+              const margin = params.traceWidth + params.clearance;
+              const overlapsBoundaryBand = bandMaximum + margin >= center - halfWidth && bandMinimum - margin <= center + halfWidth;
+              const crossesSourceField = Math.max(
+                ...other.connections.map(
+                  (connection) => sign * connection.sourcePoint[forwardAxis]
+                )
+              ) < sourceNearEnd - 1e-9 && Math.min(
+                ...other.connections.map(
+                  (connection) => connection.sourcePoint[axis]
+                )
+              ) <= sourceMaximum + margin && Math.max(
+                ...other.connections.map(
+                  (connection) => connection.sourcePoint[axis]
+                )
+              ) >= sourceMinimum - margin;
+              return count + (overlapsBoundaryBand || crossesSourceField ? other.connections.length : 0);
+            }, 0);
+          }
+          const bandCenter = minimum + (maximum - minimum) * (cornerSide === "minimum" ? 0.25 : 0.75);
+          const pitch = Math.max(
+            params.traceWidth + params.clearance,
+            params.viaDiameter + params.clearance
+          );
+          const bandHalfWidth = (Math.max(
+            bus.connections.length,
+            bus.cornerBandConnectionCount ?? 0
+          ) - 1) * pitch / 2;
+          return buses.reduce((count, other) => {
+            if (other === bus || other.termination.type !== "boundary" || other.componentId !== bus.componentId || other.exitEdge !== bus.exitEdge || getCornerBandSide(other.exitEdge, other.preferredExit) || getCommonExplicitExitTargetLayer(other) !== layer)
+              return count;
+            return count + other.connections.filter((connection) => {
+              const target = connection.exitTargetPoint ?? connection.targetPoint;
+              const track = Math.max(minimum, Math.min(maximum, target[axis]));
+              return Math.abs(track - bandCenter) <= bandHalfWidth + params.traceWidth + params.clearance;
+            }).length;
+          }, 0);
+        };
+        assignment[bus.busId] = viaLayers.toSorted(
+          (first, second) => getBoundaryCongestion(first) - getBoundaryCongestion(second)
+        )[0];
         continue;
       }
       const componentDirections = directionsByComponent.get(bus.componentId);
@@ -30585,6 +30777,9 @@ var FanoutSolver = class extends BaseSolver {
           buses: this.preparedBuses,
           escapeLayers: this.config.escapeLayers,
           escapeLayersByBusId: this.escapeLayersByBusId,
+          traceWidth: this.config.traceWidth,
+          viaDiameter: this.config.viaDiameter,
+          clearance: this.config.clearance,
           preferOrderedCoordinatedWindingLayers: this.config.densePlaneReservationBusIds.length > 0 || this.config.denseUnrestrictedPlaneRoutingBusIds.length > 0 || shouldUseAdaptiveDensePlaneRouting(
             this.preparedBuses,
             this.config.allowBlindAndBuriedVias
@@ -30926,6 +31121,40 @@ var FanoutSolver = class extends BaseSolver {
     const wideBoundaryBuses = unsortedBoundaryBuses.filter(
       (bus) => bus.connections.length >= 8
     );
+    const adjacentCenteredFieldByTurningBus = /* @__PURE__ */ new Map();
+    if (usePadAlignedDenseRouting && !configuredDensePlaneRouting) {
+      for (const bus of wideBoundaryBuses) {
+        if (!getCornerBandSide(bus.exitEdge, bus.preferredExit) || new Set(bus.routableEscapeLayers ?? bus.allowedLayers ?? []).size !== 1)
+          continue;
+        const axis = bus.direction === "up" || bus.direction === "down" ? "y" : "x";
+        const track = axis === "x" ? "y" : "x";
+        const sign = bus.direction === "up" || bus.direction === "right" ? 1 : -1;
+        const forwardEnd = Math.max(
+          ...bus.connections.map((c) => sign * c.sourcePoint[axis])
+        );
+        const minTrack = Math.min(
+          ...bus.connections.map((c) => c.sourcePoint[track])
+        );
+        const maxTrack = Math.max(
+          ...bus.connections.map((c) => c.sourcePoint[track])
+        );
+        const pitch = axis === "x" ? bus.pitchX : bus.pitchY;
+        const field = wideBoundaryBuses.find((candidate) => {
+          if (candidate === bus || candidate.componentId !== bus.componentId || candidate.exitEdge !== bus.exitEdge || getCornerBandSide(candidate.exitEdge, candidate.preferredExit))
+            return false;
+          const nearEnd = Math.min(
+            ...candidate.connections.map((c) => sign * c.sourcePoint[axis])
+          );
+          const gap = nearEnd - forwardEnd;
+          return gap >= -1e-9 && gap <= pitch + 1e-9 && Math.min(
+            ...candidate.connections.map((c) => c.sourcePoint[track])
+          ) <= maxTrack + 1e-9 && Math.max(
+            ...candidate.connections.map((c) => c.sourcePoint[track])
+          ) >= minTrack - 1e-9;
+        });
+        if (field) adjacentCenteredFieldByTurningBus.set(bus, field);
+      }
+    }
     const hasThreeWideBoundaryBuses = useConfiguredDensePlaneRouting && wideBoundaryBuses.length === 3;
     const getBoundaryTargetSpan = (bus) => {
       const coordinates = bus.connections.map((connection) => {
@@ -31378,8 +31607,29 @@ var FanoutSolver = class extends BaseSolver {
           bus
         ])
       ];
+      for (const [bus] of adjacentCenteredFieldByTurningBus) {
+        const axis = bus.direction === "up" || bus.direction === "down" ? "y" : "x";
+        const sign = bus.direction === "up" || bus.direction === "right" ? 1 : -1;
+        const backwardEnd = Math.min(
+          ...bus.connections.map(
+            (connection) => sign * connection.sourcePoint[axis]
+          )
+        );
+        const index = denseBoundaryBusesInRoutingOrder.indexOf(bus);
+        const earlierCornerIndex = denseBoundaryBusesInRoutingOrder.findIndex(
+          (candidate) => candidate !== bus && candidate.connections.length >= 8 && candidate.componentId === bus.componentId && candidate.direction === bus.direction && Math.max(
+            ...candidate.connections.map(
+              (connection) => sign * connection.sourcePoint[axis]
+            )
+          ) <= backwardEnd + 1e-9 && candidate.exitEdge === bus.exitEdge && getCornerBandSide(candidate.exitEdge, candidate.preferredExit) === getCornerBandSide(bus.exitEdge, bus.preferredExit)
+        );
+        if (earlierCornerIndex >= 0 && earlierCornerIndex < index) {
+          denseBoundaryBusesInRoutingOrder.splice(index, 1);
+          denseBoundaryBusesInRoutingOrder.splice(earlierCornerIndex, 0, 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))
+        if (!usePadAlignedDenseRouting || 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(
@@ -31414,7 +31664,7 @@ var FanoutSolver = class extends BaseSolver {
         return (firstCenter[axis] - secondCenter[axis]) * (targetTrack(first) - targetTrack(second)) < -1e-9;
       };
       const centeredPairPromotionGroups = /* @__PURE__ */ new Set();
-      for (const singleton of multiLayerLeadingSingletonBuses) {
+      for (const singleton of leadingWideSingletonBuses) {
         if (getCornerBandSide(singleton.exitEdge, singleton.preferredExit))
           continue;
         for (const pair of boundaryBuses) {
@@ -31446,6 +31696,21 @@ var FanoutSolver = class extends BaseSolver {
           }
         }
       }
+      for (const field of adjacentCenteredFieldByTurningBus.values()) {
+        for (const pair of boundaryBuses) {
+          if (pair.connections.length !== 2 || getContainingWideSourceField(pair) !== field)
+            continue;
+          for (const singleton of singletonBoundaryBuses) {
+            if (!areAdjacentInvertedNarrowBuses(singleton, pair)) continue;
+            const pairIndex = denseBoundaryBusesInRoutingOrder.indexOf(pair);
+            const singletonIndex = denseBoundaryBusesInRoutingOrder.indexOf(singleton);
+            if (singletonIndex > pairIndex) {
+              denseBoundaryBusesInRoutingOrder.splice(singletonIndex, 1);
+              denseBoundaryBusesInRoutingOrder.splice(pairIndex, 0, singleton);
+            }
+          }
+        }
+      }
       let fixedViaPointsByConnectionIndex = seedViaPoints;
       let matchedPlans = [];
       let matchedRoutingSucceeded = true;
@@ -31558,7 +31823,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 usedRepairedViaSites = false;
         let busPlans = (yield* routeAlternatives(
           preferSingleLayerWinding ? { ...routeParams, bus: singleLayerBus } : routeParams,
           1
@@ -31658,14 +31923,95 @@ 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)
+        if (!busPlans && useAdaptiveDensePlaneRouting && bus.connections.length >= 8 && getCornerBandSide(bus.exitEdge, bus.preferredExit) && new Set(bus.routableEscapeLayers ?? bus.allowedLayers ?? []).size === 1 && !matchedPlans.some(
+          (plan) => wideBoundaryBuses.some(
+            (candidate) => candidate.busId === plan.busId
+          )
         )) {
+          const reservedVias = getReservedVias(bus);
+          const siteRepairs = getSingleDogboneViaSiteRepairs(
+            bus,
+            {
+              viaDiameter: this.config.viaDiameter,
+              viaHoleDiameter: this.config.viaHoleDiameter,
+              traceWidth: this.config.traceWidth,
+              clearance: this.config.clearance,
+              additionalObstacles: this.routingSrj.obstacles,
+              blockingSegments: [
+                ...matchedPlans.flatMap(
+                  (plan) => plan.segments.map((segment2) => ({
+                    connectionIndex: plan.connectionIndex,
+                    segment: segment2
+                  }))
+                ),
+                ...reservedVias.flatMap(
+                  (reserved) => reserved.sourceEscapeSegment ? [
+                    {
+                      connectionIndex: -1,
+                      segment: reserved.sourceEscapeSegment
+                    }
+                  ] : []
+                )
+              ],
+              blockingVias: [
+                ...matchedPlans.flatMap(
+                  (plan) => plan.via ? [{ connectionIndex: plan.connectionIndex, ...plan.via }] : []
+                ),
+                ...reservedVias.map((reserved) => ({
+                  connectionIndex: -1,
+                  ...reserved.via
+                }))
+              ]
+            },
+            fixedViaPointsByConnectionIndex
+          );
+          for (const replacementPoints of siteRepairs) {
+            const replacementPlans = (yield* routeAlternatives(
+              {
+                ...routeParams,
+                fixedViaPointsByConnectionIndex: replacementPoints,
+                reservedVias,
+                fixedViaFallbackRouteOrderAttempts: 1
+              },
+              1
+            ))[0];
+            if (!replacementPlans) continue;
+            busPlans = replacementPlans;
+            fixedViaPointsByConnectionIndex = replacementPoints;
+            usedRepairedViaSites = true;
+            break;
+          }
+        }
+        if (!busPlans && useAdaptiveDensePlaneRouting && bus.connections.length >= 8 && getCornerBandSide(bus.exitEdge, bus.preferredExit)) {
+          busPlans = (yield* routeAlternatives(
+            {
+              ...routeParams,
+              fixedViaPointsByConnectionIndex: void 0,
+              reservedVias: getReservedVias(bus)
+            },
+            1
+          ))[0];
+          if (busPlans) {
+            usedRepairedViaSites = true;
+            fixedViaPointsByConnectionIndex = new Map([
+              ...fixedViaPointsByConnectionIndex,
+              ...busPlans.filter((plan) => plan.via).map(
+                (plan) => [plan.connectionIndex, plan.via.center]
+              )
+            ]);
+          }
+          debugDense("local-sites", bus.busId, busPlans?.length ?? "failed");
+        }
+        if (!busPlans && bus.connections.length >= 8 && (adjacentCenteredFieldByTurningBus.has(bus) || 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(
+          const provisionalReservationNames = new Set(
+            this.preparedBuses.filter(
+              (candidate) => candidate.termination.type === "plane" || candidate === adjacentCenteredFieldByTurningBus.get(bus)
+            ).flatMap(
               (candidate) => candidate.connections.map(
                 (connection) => connection.connection.name
               )
@@ -31676,10 +32022,10 @@ var FanoutSolver = class extends BaseSolver {
               ...routeParams,
               fixedViaPointsByConnectionIndex: void 0,
               reservedVias: routeParams.reservedVias.filter(
-                (reserved) => !futurePlaneNames.has(reserved.connectionName)
+                (reserved) => !provisionalReservationNames.has(reserved.connectionName)
               ),
               softReservedVias: routeParams.reservedVias.filter(
-                (reserved) => futurePlaneNames.has(reserved.connectionName)
+                (reserved) => provisionalReservationNames.has(reserved.connectionName)
               )
             },
             1
@@ -31719,7 +32065,7 @@ var FanoutSolver = class extends BaseSolver {
             if (rematchedPoints) {
               busPlans = freePlans;
               fixedViaPointsByConnectionIndex = rematchedPoints;
-              usedSoftPlaneRepair = true;
+              usedRepairedViaSites = true;
             }
           }
         }
@@ -31732,7 +32078,7 @@ var FanoutSolver = class extends BaseSolver {
             rawSkew,
             maximumSkew: bus.maxLengthSkew
           });
-          if (needsRouteDiversity && !matchLengthsAfterPlanes && !usedSoftPlaneRepair) {
+          if (needsRouteDiversity && !matchLengthsAfterPlanes && !usedRepairedViaSites) {
             busPlans = (yield* routeAlternatives(routeParams, 3)).toSorted(
               (first, second) => {
                 const firstLengths = first.map((plan) => plan.length);
@@ -46959,7 +47305,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1849",
+  version: "0.0.1851",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -46999,7 +47345,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.60",
+    "@tscircuit/fanout-solver": "0.0.62",
     "@tscircuit/footprinter": "^0.0.426",
     "@tscircuit/image-utils": "^0.0.8",
     "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#a5cbbda0cd65fd4707c5c1af25779837c25aba92",
@@ -47014,7 +47360,7 @@ var package_default = {
     "@tscircuit/ngspice-spice-engine": "^0.0.20",
     "@tscircuit/props": "^0.0.646",
     "@tscircuit/schematic-match-adapt": "^0.0.18",
-    "@tscircuit/schematic-trace-solver": "^0.0.183",
+    "@tscircuit/schematic-trace-solver": "^0.0.186",
     "@tscircuit/solver-utils": "^0.0.16",
     "@tscircuit/soup-util": "^0.0.41",
     "@tscircuit/winding-breakout-point-solver": "github:tscircuit/winding-breakout-point-solver#202dbe9eb0088633b6fa094120dba6f2f41f8803",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.1850",
+  "version": "0.0.1852",
   "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.60",
+    "@tscircuit/fanout-solver": "0.0.62",
     "@tscircuit/footprinter": "^0.0.426",
     "@tscircuit/image-utils": "^0.0.8",
     "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#a5cbbda0cd65fd4707c5c1af25779837c25aba92",
@@ -56,7 +56,7 @@
     "@tscircuit/ngspice-spice-engine": "^0.0.20",
     "@tscircuit/props": "^0.0.646",
     "@tscircuit/schematic-match-adapt": "^0.0.18",
-    "@tscircuit/schematic-trace-solver": "^0.0.183",
+    "@tscircuit/schematic-trace-solver": "^0.0.186",
     "@tscircuit/solver-utils": "^0.0.16",
     "@tscircuit/soup-util": "^0.0.41",
     "@tscircuit/winding-breakout-point-solver": "github:tscircuit/winding-breakout-point-solver#202dbe9eb0088633b6fa094120dba6f2f41f8803",