@tscircuit/core 0.0.1832 → 0.0.1834

package/dist/index.js

@@ -19990,6 +19990,345 @@ function getFanoutExitPositionConfig(exitPosition) {
 // node_modules/@tscircuit/fanout-solver/lib/fanout-solver.ts
 import { BaseSolver } from "@tscircuit/solver-utils";
 
+// node_modules/@tscircuit/fanout-solver/lib/select-compatible-candidates.ts
+function selectCompatibleCandidates(params) {
+  const candidates = params.candidateSets.flat();
+  const count = candidates.length;
+  const compatibility = new Uint8Array(count * count);
+  const emptyDomainIndices = /* @__PURE__ */ new Set();
+  const revisionParent = /* @__PURE__ */ new Map();
+  let nextIndex = 0;
+  const initialDomains = params.candidateSets.map(
+    (set) => set.map(() => nextIndex++)
+  );
+  let searchStates = 0;
+  const compatible = (first, second) => {
+    const index = Math.min(first, second) * count + Math.max(first, second);
+    const cached = compatibility[index];
+    if (cached) return cached === 1;
+    const result2 = params.areCompatible(candidates[first], candidates[second]);
+    compatibility[index] = result2 ? 1 : 2;
+    return result2;
+  };
+  const neighbors = initialDomains.map(() => []);
+  for (let first = 0; first < initialDomains.length; first++) {
+    for (let second = first + 1; second < initialDomains.length; second++) {
+      if (initialDomains[first].some(
+        (a) => initialDomains[second].some((b) => !compatible(a, b))
+      )) {
+        neighbors[first].push(second);
+        neighbors[second].push(first);
+      }
+    }
+  }
+  const propagate = (domains, indices, changed) => {
+    const queue = [];
+    let allDomainsRemainNonempty = true;
+    for (const first of indices) {
+      if (domains[first].length === 0) {
+        emptyDomainIndices.add(first);
+        allDomainsRemainNonempty = false;
+        continue;
+      }
+      for (const second of neighbors[first]) {
+        if (indices.includes(second) && (changed === void 0 || second === changed))
+          queue.push([first, second]);
+      }
+    }
+    for (let cursor = 0; cursor < queue.length; cursor++) {
+      const [first, second] = queue[cursor];
+      if (domains[first].length === 0 || domains[second].length === 0)
+        continue;
+      const retained = domains[first].filter(
+        (candidate) => domains[second].some((other) => compatible(candidate, other))
+      );
+      if (retained.length === domains[first].length) continue;
+      revisionParent.set(first, second);
+      domains[first] = retained;
+      if (retained.length === 0) {
+        emptyDomainIndices.add(first);
+        allDomainsRemainNonempty = false;
+        continue;
+      }
+      for (const neighbor of neighbors[first]) {
+        if (neighbor !== second && indices.includes(neighbor))
+          queue.push([neighbor, first]);
+      }
+    }
+    return allDomainsRemainNonempty;
+  };
+  const allIndices = initialDomains.map((_, index) => index);
+  const getConflictDomainIndices = (seeds) => {
+    const pending = [...seeds];
+    const seen = new Set(pending);
+    for (let cursor = 0; cursor < pending.length; cursor++) {
+      const parent = revisionParent.get(pending[cursor]);
+      if (parent !== void 0 && !seen.has(parent)) {
+        seen.add(parent);
+        pending.push(parent);
+      }
+    }
+    return [...seen];
+  };
+  const rootDomains = initialDomains.map((domain) => [...domain]);
+  if (!propagate(rootDomains, allIndices)) {
+    return {
+      selection: null,
+      searchStates,
+      emptyDomainIndices: [...emptyDomainIndices],
+      conflictDomainIndices: getConflictDomainIndices([...emptyDomainIndices])
+    };
+  }
+  const findLocallyCompatibleSelection = () => {
+    const restartCount = 12;
+    const stepsPerRestart = Math.max(
+      1,
+      Math.min(5e3, Math.floor(params.maximumSearchStates / restartCount))
+    );
+    for (let restart = 0; restart < restartCount; restart++) {
+      const selection = rootDomains.map(
+        (domain, index) => domain[(restart * 17 + index * 7) % domain.length]
+      );
+      for (let step = 0; step < stepsPerRestart; step++) {
+        const conflictCounts = selection.map(() => 0);
+        for (let first = 0; first < selection.length; first++) {
+          for (const second of neighbors[first]) {
+            if (second <= first || compatible(selection[first], selection[second]))
+              continue;
+            conflictCounts[first]++;
+            conflictCounts[second]++;
+          }
+        }
+        const maximumConflictCount = Math.max(...conflictCounts);
+        if (maximumConflictCount === 0) return selection;
+        const conflicted = conflictCounts.map((conflicts, index) => ({ conflicts, index })).filter(({ conflicts }) => conflicts === maximumConflictCount);
+        const selected = conflicted[(step + restart) % conflicted.length].index;
+        const scored = rootDomains[selected].map((candidate, index) => ({
+          candidate,
+          index,
+          conflicts: neighbors[selected].filter(
+            (neighbor) => !compatible(candidate, selection[neighbor])
+          ).length
+        })).toSorted(
+          (first, second) => first.conflicts - second.conflicts || (first.index - step - restart) % rootDomains[selected].length - (second.index - step - restart) % rootDomains[selected].length
+        );
+        selection[selected] = scored[0].candidate;
+      }
+    }
+    return null;
+  };
+  const locallyCompatibleSelection = findLocallyCompatibleSelection();
+  if (locallyCompatibleSelection) {
+    return {
+      selection: locallyCompatibleSelection.map((index) => candidates[index]),
+      searchStates,
+      emptyDomainIndices: [],
+      conflictDomainIndices: []
+    };
+  }
+  const search = (domains, indices, changed) => {
+    if (!propagate(domains, indices, changed)) return null;
+    const pending = new Set(
+      indices.filter((index) => domains[index].length > 1)
+    );
+    const components = [];
+    while (pending.size > 0) {
+      const component = [pending.values().next().value];
+      pending.delete(component[0]);
+      for (let cursor = 0; cursor < component.length; cursor++) {
+        for (const neighbor of neighbors[component[cursor]]) {
+          if (pending.delete(neighbor)) component.push(neighbor);
+        }
+      }
+      components.push(component);
+    }
+    if (components.length > 1) {
+      let combined = domains;
+      for (const component of components) {
+        const solved = search(combined.slice(), component);
+        if (!solved) return null;
+        combined = solved;
+      }
+      return combined;
+    }
+    let selected = -1;
+    for (const index of indices) {
+      if (domains[index].length > 1 && (selected < 0 || domains[index].length < domains[selected].length))
+        selected = index;
+    }
+    if (selected < 0) return domains;
+    const orderedCandidates = domains[selected].map((candidate) => {
+      const supportCounts = neighbors[selected].filter(
+        (neighbor) => indices.includes(neighbor) && domains[neighbor].length > 1
+      ).map(
+        (neighbor) => domains[neighbor].filter((other) => compatible(candidate, other)).length
+      );
+      return {
+        candidate,
+        minimumSupport: Math.min(...supportCounts),
+        totalSupport: supportCounts.reduce((sum, count2) => sum + count2, 0)
+      };
+    }).toSorted(
+      (first, second) => second.minimumSupport - first.minimumSupport || second.totalSupport - first.totalSupport
+    );
+    for (const { candidate } of orderedCandidates) {
+      if (searchStates >= params.maximumSearchStates) return null;
+      searchStates++;
+      const nextDomains = domains.slice();
+      nextDomains[selected] = [candidate];
+      const result2 = search(nextDomains, indices, selected);
+      if (result2) return result2;
+    }
+    return null;
+  };
+  const result = search(rootDomains, allIndices);
+  const diagnosticIndices = emptyDomainIndices.size > 0 || result ? [...emptyDomainIndices] : [
+    allIndices.toSorted(
+      (first, second) => neighbors[second].length - neighbors[first].length || rootDomains[first].length - rootDomains[second].length
+    )[0]
+  ];
+  return {
+    selection: result?.map((domain) => candidates[domain[0]]) ?? null,
+    searchStates,
+    emptyDomainIndices: diagnosticIndices,
+    conflictDomainIndices: result ? [] : getConflictDomainIndices(diagnosticIndices)
+  };
+}
+
+// node_modules/@tscircuit/fanout-solver/lib/refine-adaptive-plane-reservations.ts
+var EPSILON5 = 1e-9;
+function refineAdaptivePlaneReservationCore(params) {
+  const core = params.candidateBusIds.filter(
+    (busId) => !params.activeBusIds.has(busId)
+  );
+  if (core.length < 2) return core;
+  const terminalIndex = core.length - 1;
+  const terminal = params.planeBuses.find(
+    (bus) => bus.busId === core[terminalIndex]
+  );
+  const source = terminal?.connections[0]?.sourcePoint;
+  if (!terminal || !source || terminal.connections.length !== 1 || terminal.termination.type !== "plane")
+    return core;
+  const terminalLayer = terminal.termination.layer;
+  const perpendicularAxis = terminal.direction === "up" || terminal.direction === "down" ? "x" : "y";
+  const parallelAxis = perpendicularAxis === "x" ? "y" : "x";
+  const componentCoordinates = perpendicularAxis === "x" ? terminal.xCoordinates : terminal.yCoordinates;
+  const pitch = perpendicularAxis === "x" ? terminal.pitchX : terminal.pitchY;
+  if (componentCoordinates.length === 0 || !Number.isFinite(pitch) || pitch <= EPSILON5) {
+    return core;
+  }
+  const componentCenter = (Math.min(...componentCoordinates) + Math.max(...componentCoordinates)) / 2;
+  const inwardSign = Math.sign(componentCenter - source[perpendicularAxis]);
+  if (inwardSign === 0) return core;
+  const coreIds = new Set(core);
+  const replacement = params.planeBuses.filter((bus) => {
+    const candidateSource = bus.connections[0]?.sourcePoint;
+    if (bus === terminal || bus.componentId !== terminal.componentId || bus.termination.type !== "plane" || bus.termination.layer !== terminalLayer || bus.direction !== terminal.direction || bus.connections.length !== 1 || !candidateSource || params.activeBusIds.has(bus.busId) || coreIds.has(bus.busId) || Math.abs(candidateSource[parallelAxis] - source[parallelAxis]) > EPSILON5) {
+      return false;
+    }
+    const inwardDistance = (candidateSource[perpendicularAxis] - source[perpendicularAxis]) * inwardSign;
+    return inwardDistance > EPSILON5 && inwardDistance <= pitch + EPSILON5;
+  }).toSorted((first, second) => {
+    const firstSource = first.connections[0].sourcePoint;
+    const secondSource = second.connections[0].sourcePoint;
+    return Math.abs(firstSource[perpendicularAxis] - source[perpendicularAxis]) - Math.abs(
+      secondSource[perpendicularAxis] - source[perpendicularAxis]
+    ) || first.connections[0].connectionIndex - second.connections[0].connectionIndex;
+  })[0];
+  if (!replacement) return core;
+  return core.map(
+    (busId, index) => index === terminalIndex ? replacement.busId : busId
+  );
+}
+
+// node_modules/@tscircuit/fanout-solver/lib/should-use-adaptive-dense-plane-routing.ts
+function getSourceFieldFacingEdge(buses) {
+  const firstBus = buses[0];
+  if (!firstBus || buses.some((bus) => bus.componentId !== firstBus.componentId))
+    return void 0;
+  const sourcePoints = buses.flatMap(
+    (bus) => bus.connections.map((connection) => connection.sourcePoint)
+  );
+  if (sourcePoints.length === 0) return void 0;
+  const center = sourcePoints.reduce(
+    (sum, point6) => ({ x: sum.x + point6.x, y: sum.y + point6.y }),
+    { x: 0, y: 0 }
+  );
+  center.x /= sourcePoints.length;
+  center.y /= sourcePoints.length;
+  const { minX, maxX, minY, maxY } = firstBus.componentBounds;
+  const edgesByDistance = [
+    { edge: "left", distance: Math.abs(center.x - minX) },
+    { edge: "right", distance: Math.abs(maxX - center.x) },
+    { edge: "bottom", distance: Math.abs(center.y - minY) },
+    { edge: "top", distance: Math.abs(maxY - center.y) }
+  ].toSorted((first, second) => first.distance - second.distance);
+  if (Math.abs(edgesByDistance[0].distance - edgesByDistance[1].distance) <= 1e-9)
+    return void 0;
+  return edgesByDistance[0].edge;
+}
+function shouldUseAdaptiveDensePlaneRouting(buses, allowBlindAndBuriedVias) {
+  if (allowBlindAndBuriedVias) return false;
+  const boundaryBuses = buses.filter(
+    (bus) => bus.termination.type === "boundary"
+  );
+  const singletonBoundaryBuses = boundaryBuses.filter(
+    (bus) => bus.connections.length === 1
+  );
+  const pairBoundaryBuses = boundaryBuses.filter(
+    (bus) => bus.connections.length === 2
+  );
+  const wideBoundaryBuses = boundaryBuses.filter(
+    (bus) => bus.connections.length >= 8
+  );
+  const planeCount = buses.filter(
+    (bus) => bus.termination.type === "plane" && bus.connections.length === 1
+  ).length;
+  const sharedExitEdge = wideBoundaryBuses[0]?.exitEdge;
+  if (boundaryBuses.length !== 9 || singletonBoundaryBuses.length !== 3 || pairBoundaryBuses.length !== 3 || wideBoundaryBuses.length !== 3 || planeCount < 64 || sharedExitEdge === void 0 || wideBoundaryBuses.some((bus) => bus.exitEdge !== sharedExitEdge))
+    return false;
+  const sourceFacingEdge = getSourceFieldFacingEdge(wideBoundaryBuses);
+  if (sourceFacingEdge === void 0) return false;
+  const sourceFacesHorizontalEdge = sourceFacingEdge === "left" || sourceFacingEdge === "right";
+  const exitUsesHorizontalEdge = sharedExitEdge === "left" || sharedExitEdge === "right";
+  return sourceFacesHorizontalEdge !== exitUsesHorizontalEdge;
+}
+
+// node_modules/@tscircuit/fanout-solver/lib/fanout-solver.ts
+import { mergeGraphics } from "graphics-debug";
+
+// node_modules/@tscircuit/fanout-solver/lib/add-via-layer-metadata.ts
+function addViaLayerMetadataToTrace(params) {
+  const { trace, layerNames, allowBlindAndBuriedVias } = params;
+  return {
+    ...trace,
+    route: trace.route.map(
+      (routePoint) => routePoint.route_type === "via" && !allowBlindAndBuriedVias ? {
+        ...routePoint,
+        layers: getViaSpanLayers2({
+          fromLayer: routePoint.from_layer,
+          toLayer: routePoint.to_layer,
+          layerNames,
+          allowBlindAndBuriedVias
+        })
+      } : { ...routePoint }
+    )
+  };
+}
+function addViaLayerMetadataToSrj(params) {
+  const { srj, layerNames, allowBlindAndBuriedVias } = params;
+  return {
+    ...srj,
+    traces: (srj.traces ?? []).map(
+      (trace) => addViaLayerMetadataToTrace({
+        trace,
+        layerNames,
+        allowBlindAndBuriedVias
+      })
+    )
+  };
+}
+
 // node_modules/@tscircuit/fanout-solver/lib/boundary-exit.ts
 function getExitEdgeForDirection(direction) {
   switch (direction) {
@@ -20027,117 +20366,284 @@ function getCornerBandSide(exitEdge, preferredExit) {
   return preferredExit.endsWith("-right") ? "maximum" : "minimum";
 }
 
-// node_modules/@tscircuit/fanout-solver/lib/get-routed-trace-copper.ts
-function getRoutedTraceCopper(srj, trace, allowBlindAndBuriedVias = true) {
-  const layerNames = getCopperLayerNames(srj.layerCount);
-  const segments = [];
-  const vias = [];
-  let previousWire;
-  for (const routePoint of trace.route) {
-    if (routePoint.route_type === "via") {
-      vias.push({
-        center: { x: routePoint.x, y: routePoint.y },
-        diameter: routePoint.via_diameter ?? srj.minViaPadDiameter ?? srj.min_via_pad_diameter ?? srj.minViaDiameter ?? srj.minTraceWidth,
-        spanLayers: getRouteViaSpanLayers({
-          fromLayer: routePoint.from_layer,
-          toLayer: routePoint.to_layer,
-          layers: "layers" in routePoint && Array.isArray(routePoint.layers) ? routePoint.layers : void 0,
-          layerNames,
-          allowBlindAndBuriedVias
-        })
-      });
-      previousWire = void 0;
-      continue;
-    }
-    if (routePoint.route_type !== "wire") {
-      previousWire = void 0;
-      continue;
-    }
-    if (previousWire?.layer === routePoint.layer && (previousWire.x !== routePoint.x || previousWire.y !== routePoint.y)) {
-      segments.push({
-        start: { x: previousWire.x, y: previousWire.y },
-        end: { x: routePoint.x, y: routePoint.y },
-        width: Math.max(previousWire.width, routePoint.width),
-        layer: routePoint.layer
-      });
+// node_modules/@tscircuit/fanout-solver/lib/build-output.ts
+function createViaObstacle(plan, layerNames, via, viaIndex) {
+  const zLayers = via.spanLayers.map((layer) => {
+    const layerIndex = layerNames.indexOf(layer);
+    if (layerIndex < 0) {
+      throw new Error(
+        `FanoutSolver: via for "${plan.connectionName}" uses unknown layer "${layer}"`
+      );
     }
-    previousWire = routePoint;
-  }
+    return layerIndex;
+  });
+  const outputIds = createFanoutOutputIds(plan);
   return {
-    trace,
-    connectionName: trace.connection_name,
-    segments,
-    vias
+    obstacleId: viaIndex === "endpoint" ? outputIds.planeEndpointViaObstacleId : viaIndex === 0 ? outputIds.viaObstacleId : `${outputIds.viaObstacleId}:${viaIndex}`,
+    type: "rect",
+    center: via.center,
+    width: via.diameter,
+    height: via.diameter,
+    layers: via.spanLayers,
+    zLayers,
+    __zLayers: zLayers,
+    connectedTo: [plan.connectionName, plan.trace.pcb_trace_id]
   };
 }
-function getAllRoutedTraceCopper(srj, allowBlindAndBuriedVias = true) {
-  return (srj.traces ?? []).map(
-    (trace) => getRoutedTraceCopper(srj, trace, allowBlindAndBuriedVias)
-  );
-}
-
-// node_modules/@tscircuit/fanout-solver/lib/match-component-dogbone-via-sites.ts
-var EPSILON5 = 1e-9;
-var DEFAULT_MAXIMUM_SEARCH_STATES = 1e5;
-function assertGeometryRules(rules) {
-  for (const [name, value] of [
-    ["viaDiameter", rules.viaDiameter],
-    ["traceWidth", rules.traceWidth]
-  ]) {
-    if (!Number.isFinite(value) || value <= 0) {
+function buildOutputSimpleRouteJson(params) {
+  const { inputSrj, plans, layerNames } = params;
+  const outputConnections = inputSrj.connections.map((connection) => ({
+    ...connection,
+    pointsToConnect: connection.pointsToConnect.map((point6) => ({ ...point6 }))
+  }));
+  const viaObstacles = [];
+  const planeTerminatedConnectionNames = /* @__PURE__ */ new Set();
+  for (const plan of plans) {
+    const connection = outputConnections[plan.connectionIndex];
+    if (!connection) {
       throw new Error(
-        `FanoutSolver: dogbone ${name} must be a positive finite number, received ${value}`
+        `FanoutSolver: output connection index ${plan.connectionIndex} is missing`
       );
     }
-  }
-  if (!Number.isFinite(rules.clearance) || rules.clearance < 0) {
-    throw new Error(
-      `FanoutSolver: dogbone clearance must be a non-negative finite number, received ${rules.clearance}`
-    );
-  }
-  if (rules.viaHoleDiameter !== void 0 && (!Number.isFinite(rules.viaHoleDiameter) || rules.viaHoleDiameter <= 0)) {
-    throw new Error(
-      `FanoutSolver: dogbone viaHoleDiameter must be a positive finite number, received ${rules.viaHoleDiameter}`
-    );
-  }
-  if (rules.holeToHoleClearance !== void 0 && (!Number.isFinite(rules.holeToHoleClearance) || rules.holeToHoleClearance < 0)) {
-    throw new Error(
-      `FanoutSolver: dogbone holeToHoleClearance must be a non-negative finite number, received ${rules.holeToHoleClearance}`
-    );
-  }
-  if (rules.holeToHoleClearance !== void 0 && rules.viaHoleDiameter === void 0) {
-    throw new Error(
-      "FanoutSolver: dogbone holeToHoleClearance requires viaHoleDiameter"
-    );
-  }
-  const maximumSearchStates = rules.maximumSearchStates ?? DEFAULT_MAXIMUM_SEARCH_STATES;
-  if (!Number.isInteger(maximumSearchStates) || maximumSearchStates < 1) {
-    throw new Error(
-      `FanoutSolver: dogbone maximumSearchStates must be a positive integer, received ${maximumSearchStates}`
-    );
-  }
-  return maximumSearchStates;
-}
-function uniqueSortedCoordinates(values) {
-  const result = [];
-  for (const value of values.toSorted((first, second) => first - second)) {
-    if (!Number.isFinite(value)) continue;
-    if (result.length === 0 || Math.abs(result.at(-1) - value) > EPSILON5) {
-      result.push(value);
+    const outputIds = createFanoutOutputIds(plan);
+    connection.pointsToConnect[plan.sourcePointIndex] = {
+      x: plan.exitPoint.x,
+      y: plan.exitPoint.y,
+      layer: plan.targetLayer,
+      pointId: plan.termination.type === "plane" ? outputIds.planeExitPointId : outputIds.boundaryExitPointId
+    };
+    if (plan.termination.type === "plane") {
+      planeTerminatedConnectionNames.add(plan.connectionName);
     }
-  }
-  return result;
-}
-function getComponentMatchingInputs(preparedBuses) {
-  const byComponent = /* @__PURE__ */ new Map();
-  const componentByConnectionIndex = /* @__PURE__ */ new Map();
-  const obstacleSetByComponentId = /* @__PURE__ */ new Map();
-  for (const bus of preparedBuses) {
-    let component = byComponent.get(bus.componentId);
-    if (!component) {
-      component = {
-        componentId: bus.componentId,
-        connections: [],
+    if (plan.via) {
+      const viaObstacle = createViaObstacle(plan, layerNames, plan.via, 0);
+      if (viaObstacle) viaObstacles.push(viaObstacle);
+    }
+    for (const [additionalViaIndex, via] of (plan.additionalVias ?? []).entries()) {
+      const viaObstacle = createViaObstacle(
+        plan,
+        layerNames,
+        via,
+        additionalViaIndex + 1
+      );
+      if (viaObstacle) viaObstacles.push(viaObstacle);
+    }
+    if (plan.planeEndpointVia) {
+      const endpointViaObstacle = createViaObstacle(
+        plan,
+        layerNames,
+        plan.planeEndpointVia,
+        "endpoint"
+      );
+      if (endpointViaObstacle) viaObstacles.push(endpointViaObstacle);
+    }
+  }
+  const planTraces = plans.flatMap((plan) => [
+    plan.trace,
+    ...plan.planeEndpointTrace ? [plan.planeEndpointTrace] : []
+  ]);
+  const coordinateRoutePoints = planTraces.flatMap(
+    (trace) => trace.route.filter(
+      (routePoint) => "x" in routePoint && "y" in routePoint
+    )
+  );
+  const boundsMargin = Math.max(
+    inputSrj.defaultObstacleMargin ?? 0,
+    inputSrj.minTraceWidth
+  );
+  const outputBounds = coordinateRoutePoints.length === 0 ? { ...inputSrj.bounds } : {
+    minX: Math.min(
+      inputSrj.bounds.minX,
+      ...coordinateRoutePoints.map(
+        (routePoint) => routePoint.x - boundsMargin
+      )
+    ),
+    maxX: Math.max(
+      inputSrj.bounds.maxX,
+      ...coordinateRoutePoints.map(
+        (routePoint) => routePoint.x + boundsMargin
+      )
+    ),
+    minY: Math.min(
+      inputSrj.bounds.minY,
+      ...coordinateRoutePoints.map(
+        (routePoint) => routePoint.y - boundsMargin
+      )
+    ),
+    maxY: Math.max(
+      inputSrj.bounds.maxY,
+      ...coordinateRoutePoints.map(
+        (routePoint) => routePoint.y + boundsMargin
+      )
+    )
+  };
+  return {
+    ...inputSrj,
+    fanoutPlaneConnectivity: plans.flatMap(
+      (plan) => plan.termination.type === "plane" ? [
+        {
+          connectionName: plan.connectionName,
+          layer: plan.termination.layer
+        }
+      ] : []
+    ),
+    bounds: outputBounds,
+    connections: outputConnections.filter(
+      (connection) => !planeTerminatedConnectionNames.has(connection.name)
+    ),
+    buses: inputSrj.buses?.map((bus) => ({
+      ...bus,
+      connectionNames: bus.connectionNames.filter(
+        (connectionName) => !planeTerminatedConnectionNames.has(connectionName)
+      )
+    })).filter((bus) => bus.connectionNames.length > 0),
+    obstacles: [
+      ...inputSrj.obstacles.map((obstacle) => ({
+        ...obstacle,
+        center: { ...obstacle.center },
+        layers: [...obstacle.layers],
+        connectedTo: [...obstacle.connectedTo]
+      })),
+      ...viaObstacles
+    ],
+    traces: [
+      ...(inputSrj.traces ?? []).map((trace) => ({
+        ...trace,
+        route: trace.route.map((routePoint) => ({ ...routePoint }))
+      })),
+      ...planTraces
+    ]
+  };
+}
+
+// node_modules/@tscircuit/fanout-solver/lib/get-routed-trace-copper.ts
+function getRoutedTraceCopper(srj, trace, allowBlindAndBuriedVias = true) {
+  const layerNames = getCopperLayerNames(srj.layerCount);
+  const segments = [];
+  const vias = [];
+  let previousWire;
+  for (const routePoint of trace.route) {
+    if (routePoint.route_type === "via") {
+      vias.push({
+        center: { x: routePoint.x, y: routePoint.y },
+        diameter: routePoint.via_diameter ?? srj.minViaPadDiameter ?? srj.min_via_pad_diameter ?? srj.minViaDiameter ?? srj.minTraceWidth,
+        spanLayers: getRouteViaSpanLayers({
+          fromLayer: routePoint.from_layer,
+          toLayer: routePoint.to_layer,
+          layers: "layers" in routePoint && Array.isArray(routePoint.layers) ? routePoint.layers : void 0,
+          layerNames,
+          allowBlindAndBuriedVias
+        })
+      });
+      previousWire = void 0;
+      continue;
+    }
+    if (routePoint.route_type !== "wire") {
+      previousWire = void 0;
+      continue;
+    }
+    if (previousWire?.layer === routePoint.layer && (previousWire.x !== routePoint.x || previousWire.y !== routePoint.y)) {
+      segments.push({
+        start: { x: previousWire.x, y: previousWire.y },
+        end: { x: routePoint.x, y: routePoint.y },
+        width: Math.max(previousWire.width, routePoint.width),
+        layer: routePoint.layer
+      });
+    }
+    previousWire = routePoint;
+  }
+  return {
+    trace,
+    connectionName: trace.connection_name,
+    segments,
+    vias
+  };
+}
+function getAllRoutedTraceCopper(srj, allowBlindAndBuriedVias = true) {
+  return (srj.traces ?? []).map(
+    (trace) => getRoutedTraceCopper(srj, trace, allowBlindAndBuriedVias)
+  );
+}
+
+// node_modules/@tscircuit/fanout-solver/lib/get-dogbone-side-variants.ts
+function getDogboneSideVariants(connections, direction) {
+  const axis = direction === "up" || direction === "down" ? "y" : "x";
+  const variants = connections.slice(0, 32).map(({ connectionIndex }) => [connectionIndex]);
+  for (let first = 0; first < connections.length; first++) {
+    for (let second = first + 1; second < connections.length; second++) {
+      if (variants.length >= 32) return variants;
+      const a = connections[first];
+      const b = connections[second];
+      if (Math.abs(a.sourcePoint[axis] - b.sourcePoint[axis]) <= 1e-9) {
+        variants.push([a.connectionIndex, b.connectionIndex]);
+      }
+    }
+  }
+  return variants;
+}
+
+// node_modules/@tscircuit/fanout-solver/lib/match-component-dogbone-via-sites.ts
+var EPSILON6 = 1e-9;
+var DEFAULT_MAXIMUM_SEARCH_STATES = 1e5;
+function assertGeometryRules(rules) {
+  for (const [name, value] of [
+    ["viaDiameter", rules.viaDiameter],
+    ["traceWidth", rules.traceWidth]
+  ]) {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(
+        `FanoutSolver: dogbone ${name} must be a positive finite number, received ${value}`
+      );
+    }
+  }
+  if (!Number.isFinite(rules.clearance) || rules.clearance < 0) {
+    throw new Error(
+      `FanoutSolver: dogbone clearance must be a non-negative finite number, received ${rules.clearance}`
+    );
+  }
+  if (rules.viaHoleDiameter !== void 0 && (!Number.isFinite(rules.viaHoleDiameter) || rules.viaHoleDiameter <= 0)) {
+    throw new Error(
+      `FanoutSolver: dogbone viaHoleDiameter must be a positive finite number, received ${rules.viaHoleDiameter}`
+    );
+  }
+  if (rules.holeToHoleClearance !== void 0 && (!Number.isFinite(rules.holeToHoleClearance) || rules.holeToHoleClearance < 0)) {
+    throw new Error(
+      `FanoutSolver: dogbone holeToHoleClearance must be a non-negative finite number, received ${rules.holeToHoleClearance}`
+    );
+  }
+  if (rules.holeToHoleClearance !== void 0 && rules.viaHoleDiameter === void 0) {
+    throw new Error(
+      "FanoutSolver: dogbone holeToHoleClearance requires viaHoleDiameter"
+    );
+  }
+  const maximumSearchStates = rules.maximumSearchStates ?? DEFAULT_MAXIMUM_SEARCH_STATES;
+  if (!Number.isInteger(maximumSearchStates) || maximumSearchStates < 1) {
+    throw new Error(
+      `FanoutSolver: dogbone maximumSearchStates must be a positive integer, received ${maximumSearchStates}`
+    );
+  }
+  return maximumSearchStates;
+}
+function uniqueSortedCoordinates(values) {
+  const result = [];
+  for (const value of values.toSorted((first, second) => first - second)) {
+    if (!Number.isFinite(value)) continue;
+    if (result.length === 0 || Math.abs(result.at(-1) - value) > EPSILON6) {
+      result.push(value);
+    }
+  }
+  return result;
+}
+function getComponentMatchingInputs(preparedBuses) {
+  const byComponent = /* @__PURE__ */ new Map();
+  const componentByConnectionIndex = /* @__PURE__ */ new Map();
+  const obstacleSetByComponentId = /* @__PURE__ */ new Map();
+  for (const bus of preparedBuses) {
+    let component = byComponent.get(bus.componentId);
+    if (!component) {
+      component = {
+        componentId: bus.componentId,
+        connections: [],
         obstacles: [],
         xCoordinates: [],
         yCoordinates: [],
@@ -20149,10 +20655,10 @@ function getComponentMatchingInputs(preparedBuses) {
     }
     component.xCoordinates.push(...bus.xCoordinates);
     component.yCoordinates.push(...bus.yCoordinates);
-    if (Number.isFinite(bus.pitchX) && bus.pitchX > EPSILON5) {
+    if (Number.isFinite(bus.pitchX) && bus.pitchX > EPSILON6) {
       component.pitchX = Math.min(component.pitchX, bus.pitchX);
     }
-    if (Number.isFinite(bus.pitchY) && bus.pitchY > EPSILON5) {
+    if (Number.isFinite(bus.pitchY) && bus.pitchY > EPSILON6) {
       component.pitchY = Math.min(component.pitchY, bus.pitchY);
     }
     const obstacleSet = obstacleSetByComponentId.get(bus.componentId);
@@ -20199,7 +20705,7 @@ function getComponentMatchingInputs(preparedBuses) {
 }
 function getInterstitialCoordinates(params) {
   const { coordinates, pitch } = params;
-  if (coordinates.length === 0 || !Number.isFinite(pitch) || pitch <= EPSILON5) {
+  if (coordinates.length === 0 || !Number.isFinite(pitch) || pitch <= EPSILON6) {
     return [];
   }
   const interstitialCoordinates = [coordinates[0] - pitch / 2];
@@ -20217,9 +20723,9 @@ function getAdjacentInterstitialCoordinates(params) {
     coordinates,
     pitch
   });
-  const before = interstitialCoordinates.filter((coordinate) => coordinate < sourceCoordinate - EPSILON5).at(-1);
+  const before = interstitialCoordinates.filter((coordinate) => coordinate < sourceCoordinate - EPSILON6).at(-1);
   const after = interstitialCoordinates.find(
-    (coordinate) => coordinate > sourceCoordinate + EPSILON5
+    (coordinate) => coordinate > sourceCoordinate + EPSILON6
   );
   return [before, after].filter(
     (coordinate) => coordinate !== void 0
@@ -20228,25 +20734,25 @@ function getAdjacentInterstitialCoordinates(params) {
 function directSegmentIsStraightOr45(start, end) {
   const absoluteX = Math.abs(end.x - start.x);
   const absoluteY = Math.abs(end.y - start.y);
-  return absoluteX <= EPSILON5 || absoluteY <= EPSILON5 || Math.abs(absoluteX - absoluteY) <= EPSILON5;
+  return absoluteX <= EPSILON6 || absoluteY <= EPSILON6 || Math.abs(absoluteX - absoluteY) <= EPSILON6;
 }
 function getOutwardRank(params) {
   const { source, site, direction } = params;
   const outwardDisplacement = direction === "right" ? site.x - source.x : direction === "left" ? source.x - site.x : direction === "up" ? site.y - source.y : source.y - site.y;
-  return outwardDisplacement > EPSILON5 ? 0 : Math.abs(outwardDisplacement) <= EPSILON5 ? 1 : 2;
+  return outwardDisplacement > EPSILON6 ? 0 : Math.abs(outwardDisplacement) <= EPSILON6 ? 1 : 2;
 }
 function viaSiteClearsObstacles(params) {
   const { point: point6, obstacles, viaDiameter, clearance } = params;
   const requiredClearance = viaDiameter / 2 + clearance;
   return obstacles.every(
-    (obstacle) => distancePointToObstacle(point6, obstacle) >= requiredClearance - EPSILON5
+    (obstacle) => distancePointToObstacle(point6, obstacle) >= requiredClearance - EPSILON6
   );
 }
 function sourceSegmentClearsOtherObstacles(params) {
   const { segment: segment2, sourceObstacle, obstacles, clearance } = params;
   const requiredClearance = segment2.width / 2 + clearance;
   return obstacles.every(
-    (obstacle) => obstacle === sourceObstacle || distanceSegmentToObstacle(segment2, obstacle) >= requiredClearance - EPSILON5
+    (obstacle) => obstacle === sourceObstacle || distanceSegmentToObstacle(segment2, obstacle) >= requiredClearance - EPSILON6
   );
 }
 function getConnectionCandidates(params) {
@@ -20274,7 +20780,7 @@ function getConnectionCandidates(params) {
   ];
   const uniquePoints2 = [];
   for (const point6 of rawPoints) {
-    if (!uniquePoints2.some((candidate) => distance9(candidate, point6) <= EPSILON5)) {
+    if (!uniquePoints2.some((candidate) => distance9(candidate, point6) <= EPSILON6)) {
       uniquePoints2.push(point6);
     }
   }
@@ -20325,7 +20831,7 @@ function getConnectionCandidates(params) {
           point6,
           blocker.segment.start,
           blocker.segment.end
-        ) < viaToTraceClearance - EPSILON5) {
+        ) < viaToTraceClearance - EPSILON6) {
           return false;
         }
         return blocker.segment.layer !== sourceSegment.layer || segmentsAreClear(sourceSegment, blocker.segment, rules.clearance);
@@ -20337,14 +20843,14 @@ function getConnectionCandidates(params) {
         if (blocker.connectionIndex === preparedConnection.connectionIndex) {
           return true;
         }
-        if (distance9(point6, blocker.center) < (rules.viaDiameter + blocker.diameter) / 2 + rules.clearance - EPSILON5) {
+        if (distance9(point6, blocker.center) < (rules.viaDiameter + blocker.diameter) / 2 + rules.clearance - EPSILON6) {
           return false;
         }
         if (blocker.spanLayers.includes(sourceSegment.layer) && distancePointToSegment(
           blocker.center,
           sourceSegment.start,
           sourceSegment.end
-        ) < blocker.diameter / 2 + sourceSegment.width / 2 + rules.clearance - EPSILON5) {
+        ) < blocker.diameter / 2 + sourceSegment.width / 2 + rules.clearance - EPSILON6) {
           return false;
         }
         return true;
@@ -20361,7 +20867,7 @@ function getConnectionCandidates(params) {
   const perpendicularCoordinates = direction === "left" || direction === "right" ? component.yCoordinates : component.xCoordinates;
   const sourcePerpendicularCoordinate = direction === "left" || direction === "right" ? source.y : source.x;
   const perpendicularGridIndex = perpendicularCoordinates.findIndex(
-    (coordinate) => Math.abs(coordinate - sourcePerpendicularCoordinate) <= EPSILON5
+    (coordinate) => Math.abs(coordinate - sourcePerpendicularCoordinate) <= EPSILON6
   );
   const planeCheckerboardSide = perpendicularGridIndex >= 0 ? perpendicularGridIndex % 2 === 0 ? 1 : -1 : void 0;
   const preferredPerpendicularSide = connection.terminationType === "boundary" ? rules.preferredBoundaryPerpendicularSideByBusId?.get(connection.busId) : rules.preferPlaneCheckerboardSites && connection.terminationType === "plane" && (direction === "left" || direction === "right") ? planeCheckerboardSide : void 0;
@@ -20372,10 +20878,10 @@ function getConnectionCandidates(params) {
   const getPerpendicularPreferenceRank = (candidate) => {
     if (preferredPerpendicularSide === void 0) return 0;
     const displacement = direction === "left" || direction === "right" ? candidate.point.y - source.y : candidate.point.x - source.x;
-    return displacement * preferredPerpendicularSide > EPSILON5 ? 0 : Math.abs(displacement) <= EPSILON5 ? 1 : 2;
+    return displacement * preferredPerpendicularSide > EPSILON6 ? 0 : Math.abs(displacement) <= EPSILON6 ? 1 : 2;
   };
   return candidates.toSorted(
-    (first, second) => (preferredViaPoint ? Number(distance9(first.point, preferredViaPoint) > EPSILON5) - Number(distance9(second.point, preferredViaPoint) > EPSILON5) : 0) || (preferOutward ? first.outwardRank - second.outwardRank : second.outwardRank - first.outwardRank) || getPerpendicularPreferenceRank(first) - getPerpendicularPreferenceRank(second) || distance9(source, first.point) - distance9(source, second.point) || first.point.x - second.point.x || first.point.y - second.point.y
+    (first, second) => (preferredViaPoint ? Number(distance9(first.point, preferredViaPoint) > EPSILON6) - Number(distance9(second.point, preferredViaPoint) > EPSILON6) : 0) || (preferOutward ? first.outwardRank - second.outwardRank : second.outwardRank - first.outwardRank) || getPerpendicularPreferenceRank(first) - getPerpendicularPreferenceRank(second) || distance9(source, first.point) - distance9(source, second.point) || first.point.x - second.point.x || first.point.y - second.point.y
   );
 }
 function candidatesAreMutuallyClear(params) {
@@ -20383,7 +20889,7 @@ function candidatesAreMutuallyClear(params) {
   const canShareCopper = rules.canShareCopper?.(first.connectionIndex, second.connectionIndex) ?? false;
   const requiredHoleSeparation = rules.viaHoleDiameter ? rules.viaHoleDiameter + (rules.holeToHoleClearance ?? rules.clearance) : 0;
   const requiredViaSeparation = canShareCopper ? requiredHoleSeparation : Math.max(rules.viaDiameter + rules.clearance, requiredHoleSeparation);
-  if (distance9(first.point, second.point) < requiredViaSeparation - EPSILON5) {
+  if (distance9(first.point, second.point) < requiredViaSeparation - EPSILON6) {
     return false;
   }
   const requiredViaToTraceClearance = rules.viaDiameter / 2 + rules.traceWidth / 2 + rules.clearance;
@@ -20392,11 +20898,11 @@ function candidatesAreMutuallyClear(params) {
       first.point,
       second.sourceSegment.start,
       second.sourceSegment.end
-    ) < requiredViaToTraceClearance - EPSILON5 || distancePointToSegment(
+    ) < requiredViaToTraceClearance - EPSILON6 || distancePointToSegment(
       second.point,
       first.sourceSegment.start,
       first.sourceSegment.end
-    ) < requiredViaToTraceClearance - EPSILON5) {
+    ) < requiredViaToTraceClearance - EPSILON6) {
       return false;
     }
   }
@@ -20538,7 +21044,7 @@ function getComponentDogboneViaSiteCandidates(preparedBuses, rules) {
 }
 
 // node_modules/@tscircuit/fanout-solver/lib/route-via-minimal-winding.ts
-var EPSILON6 = 1e-7;
+var EPSILON7 = 1e-7;
 var MAX_GRID_NODE_COUNT = 12e4;
 var MAX_EXPANDED_STATE_COUNT = 24e4;
 var EXPANDED_STATES_PER_STEP = 5e3;
@@ -20694,7 +21200,7 @@ function getConnectorVariants(start, end) {
   const deltaY = end.y - start.y;
   const absoluteX = Math.abs(deltaX);
   const absoluteY = Math.abs(deltaY);
-  if (absoluteX < EPSILON6 || absoluteY < EPSILON6 || Math.abs(absoluteX - absoluteY) < EPSILON6) {
+  if (absoluteX < EPSILON7 || absoluteY < EPSILON7 || Math.abs(absoluteX - absoluteY) < EPSILON7) {
     return [[start, end]];
   }
   if (absoluteX > absoluteY) {
@@ -20729,18 +21235,18 @@ function compressPath(points) {
 function getSegments(points, width, layer) {
   return points.slice(1).flatMap((point6, index) => {
     const start = points[index];
-    return distance9(start, point6) < EPSILON6 ? [] : [{ start, end: point6, width, layer }];
+    return distance9(start, point6) < EPSILON7 ? [] : [{ start, end: point6, width, layer }];
   });
 }
 function segmentIsStraightOr45Degrees(segment2) {
   const deltaX = Math.abs(segment2.end.x - segment2.start.x);
   const deltaY = Math.abs(segment2.end.y - segment2.start.y);
-  return deltaX < EPSILON6 || deltaY < EPSILON6 || Math.abs(deltaX - deltaY) < EPSILON6;
+  return deltaX < EPSILON7 || deltaY < EPSILON7 || Math.abs(deltaX - deltaY) < EPSILON7;
 }
 function pathHasNoProperSelfCrossing(segments) {
   for (let firstIndex = 0; firstIndex < segments.length; firstIndex++) {
     for (let secondIndex = firstIndex + 2; secondIndex < segments.length; secondIndex++) {
-      if (firstIndex === 0 && secondIndex === segments.length - 1 && distance9(segments[firstIndex].start, segments[secondIndex].end) < EPSILON6) {
+      if (firstIndex === 0 && secondIndex === segments.length - 1 && distance9(segments[firstIndex].start, segments[secondIndex].end) < EPSILON7) {
         continue;
       }
       if (distanceSegmentToSegment(
@@ -20748,7 +21254,7 @@ function pathHasNoProperSelfCrossing(segments) {
         segments[firstIndex].end,
         segments[secondIndex].start,
         segments[secondIndex].end
-      ) < EPSILON6) {
+      ) < EPSILON7) {
         return false;
       }
     }
@@ -20824,7 +21330,7 @@ function buildPlan(params) {
     width: traceWidth,
     layer: connection.sourceLayer
   };
-  const hasSourceDogbone = distance9(sourcePoint, terminal.viaPoint) > EPSILON6;
+  const hasSourceDogbone = distance9(sourcePoint, terminal.viaPoint) > EPSILON7;
   const changesLayer = connection.sourceLayer !== targetLayer;
   const targetSegments = getSegments(targetLayerPoints, traceWidth, targetLayer);
   const spanLayers = getViaSpanLayers2({
@@ -20948,7 +21454,8 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
     preferTargetDirectedLaneBias = false,
     allowSourceLayerRouting = false,
     adaptiveRouteOrder = false,
-    alignGridToPads = false
+    alignGridToPads = false,
+    includeReverseTargetRotation = false
   } = params;
   if (maximumRouteOrderAttempts !== void 0 && (!Number.isInteger(maximumRouteOrderAttempts) || maximumRouteOrderAttempts < 1)) {
     throw new Error(
@@ -21009,6 +21516,18 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
     const margin = (segment2.width + traceWidth) / 2 + clearance;
     return !(Math.max(segment2.start.x, segment2.end.x) < minX - margin || Math.min(segment2.start.x, segment2.end.x) > maxX + margin || Math.max(segment2.start.y, segment2.end.y) < minY - margin || Math.min(segment2.start.y, segment2.end.y) > maxY + margin);
   });
+  if (allowSourceLayerRouting) {
+    blockingSegments.push(
+      ...reservedVias.flatMap(
+        (reserved) => reserved.sourceEscapeSegment?.layer === targetLayer ? [
+          {
+            connectionName: reserved.connectionName,
+            segment: reserved.sourceEscapeSegment
+          }
+        ] : []
+      )
+    );
+  }
   const blockingVias = blockingCopper.vias.filter(({ via }) => {
     if (!via.spanLayers.includes(targetLayer)) return false;
     const margin = via.diameter / 2 + traceWidth / 2 + clearance;
@@ -21065,7 +21584,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
       if (obstacle.connectedTo.includes(connectionName) || allowSameNetMerges && obstacleSharesElectricalNet(srj, obstacle, connectionName)) {
         continue;
       }
-      if (distanceSegmentToObstacle(segment2, obstacle) < requiredObstacleClearance - EPSILON6) {
+      if (distanceSegmentToObstacle(segment2, obstacle) < requiredObstacleClearance - EPSILON7) {
         return false;
       }
     }
@@ -21076,7 +21595,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
         segment2.end,
         blocker.segment.start,
         blocker.segment.end
-      ) < (segment2.width + blocker.segment.width) / 2 + clearance - EPSILON6) {
+      ) < (segment2.width + blocker.segment.width) / 2 + clearance - EPSILON7) {
         return false;
       }
     }
@@ -21090,7 +21609,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
         segment2.end,
         blocker.segment.start,
         blocker.segment.end
-      ) < (segment2.width + blocker.segment.width) / 2 + clearance - EPSILON6) {
+      ) < (segment2.width + blocker.segment.width) / 2 + clearance - EPSILON7) {
         return false;
       }
     }
@@ -21110,7 +21629,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
       if (blocker.via.center.x < segmentMinX - requiredDistance || blocker.via.center.x > segmentMaxX + requiredDistance || blocker.via.center.y < segmentMinY - requiredDistance || blocker.via.center.y > segmentMaxY + requiredDistance) {
         continue;
       }
-      if (distancePointToSegment(blocker.via.center, segment2.start, segment2.end) < requiredDistance - EPSILON6) {
+      if (distancePointToSegment(blocker.via.center, segment2.start, segment2.end) < requiredDistance - EPSILON7) {
         return false;
       }
     }
@@ -21308,10 +21827,10 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
     let expandedBatchPoints = [];
     while (heap.size > 0 && expandedStateCount < MAX_EXPANDED_STATE_COUNT) {
       const current = heap.pop();
-      if (current.score >= bestGoalCost - EPSILON6) break;
+      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) + EPSILON6)
+      if (current.score > currentDistance + heuristic(nodes[current.node].point) + EPSILON7)
         continue;
       expandedStateCount++;
       expandedStatesSinceYield++;
@@ -21339,7 +21858,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
         for (const startConnector of startConnectors) {
           for (const endConnector of endConnectors) {
             const candidateCost = currentDistance - shortestStartLength + startConnector.length + endConnector.length;
-            if (candidateCost >= bestGoalCost - EPSILON6) continue;
+            if (candidateCost >= bestGoalCost - EPSILON7) continue;
             const points = compressPath([
               ...startConnector.points,
               ...gridPoints.slice(1),
@@ -21385,7 +21904,7 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
         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 nextState = nextNode * 9 + directionIndex;
-        if (nextDistance >= distances[nextState] - EPSILON6) continue;
+        if (nextDistance >= distances[nextState] - EPSILON7) continue;
         const edgeIndex = current.node * 8 + directionIndex;
         if (edgeClearance[edgeIndex] === 0) {
           const clear = segmentIsClear({
@@ -21448,9 +21967,9 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
   );
   const meanViaTrack = viaTracks.reduce((sum, track) => sum + track, 0) / viaTracks.length;
   const meanTargetTrack = targetTracks.reduce((sum, track) => sum + track, 0) / targetTracks.length;
-  const viasAreBeforeTargets = Math.max(...viaTracks) < Math.min(...targetTracks) - EPSILON6;
-  const viasAreAfterTargets = Math.min(...viaTracks) > Math.max(...targetTracks) + EPSILON6;
-  const laneBiases = preferTargetDirectedLaneBias ? viasAreBeforeTargets ? [0, 1, -1] : viasAreAfterTargets ? [0, -1, 1] : bus.direction === boundaryDirection && meanTargetTrack > meanViaTrack + EPSILON6 ? [1, 0, -1] : bus.direction === boundaryDirection && meanTargetTrack < meanViaTrack - EPSILON6 ? [-1, 0, 1] : [0, 1, -1] : viasAreBeforeTargets ? [1, 0, -1] : viasAreAfterTargets ? [-1, 0, 1] : [0, 1, -1];
+  const viasAreBeforeTargets = Math.max(...viaTracks) < Math.min(...targetTracks) - EPSILON7;
+  const viasAreAfterTargets = Math.min(...viaTracks) > Math.max(...targetTracks) + EPSILON7;
+  const laneBiases = preferTargetDirectedLaneBias ? viasAreBeforeTargets ? [0, 1, -1] : viasAreAfterTargets ? [0, -1, 1] : bus.direction === boundaryDirection && meanTargetTrack > meanViaTrack + EPSILON7 ? [1, 0, -1] : bus.direction === boundaryDirection && meanTargetTrack < meanViaTrack - EPSILON7 ? [-1, 0, 1] : [0, 1, -1] : viasAreBeforeTargets ? [1, 0, -1] : viasAreAfterTargets ? [-1, 0, 1] : [0, 1, -1];
   const initialRouteOrderFactories = [];
   if (alignGridToPads && preferTargetDirectedLaneBias && viasAreBeforeTargets) {
     initialRouteOrderFactories.push(() => targetOrderedTerminals);
@@ -21462,9 +21981,15 @@ function* routeViaMinimalWindingAlternativesSteps(params, maximumAlternatives =
     ]);
   } else if (viasAreAfterTargets) {
     initialRouteOrderFactories.push(() => [...targetOrderedTerminals].reverse());
+    if (includeReverseTargetRotation && targetOrderedTerminals.length > 2) {
+      initialRouteOrderFactories.push(() => [
+        ...targetOrderedTerminals.slice(0, -1).toReversed(),
+        targetOrderedTerminals.at(-1)
+      ]);
+    }
   }
   initialRouteOrderFactories.push(
-    ...preferTargetDirectedLaneBias && bus.direction === boundaryDirection && meanTargetTrack < meanViaTrack - EPSILON6 && !viasAreBeforeTargets && !viasAreAfterTargets ? [
+    ...preferTargetDirectedLaneBias && bus.direction === boundaryDirection && meanTargetTrack < meanViaTrack - EPSILON7 && !viasAreBeforeTargets && !viasAreAfterTargets ? [
       () => [...targetOrderedTerminals].reverse(),
       () => targetOrderedTerminals
     ] : [
@@ -23037,7 +23562,7 @@ function routePlaneTerminatedBus(params) {
           otherPlans: [...acceptedPlans, ...fixedPlans],
           staticClearanceCache,
           blockingBusCounts,
-          cacheKey: `plane-fixed:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${candidateIndex}`,
+          cacheKey: `plane-fixed:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${fixedViaPoint.x}:${fixedViaPoint.y}:${candidateIndex}`,
           srj,
           sharedBoundary: bus.sharedBoundary,
           clearance,
@@ -23598,6 +24123,36 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
     const dogboneTerminalPatterns = acceptedBoundaryPlansExist && !allowBlindAndBuriedVias ? [...mixedDogboneTerminalPatterns, ...uniformDogboneTerminalPatterns] : [...uniformDogboneTerminalPatterns, ...mixedDogboneTerminalPatterns];
     const unreservedTerminalPatterns = canUseViaInPadTerminals ? planeTerminationsAlreadyOccupyTheFanout ? [viaInPadTerminalPattern, ...dogboneTerminalPatterns] : [...dogboneTerminalPatterns, viaInPadTerminalPattern] : dogboneTerminalPatterns;
     const terminalPatterns = fixedViaPointsByConnectionIndex ? fixedViaTerminalPatterns : [...fixedViaTerminalPatterns, ...unreservedTerminalPatterns];
+    if (!fixedViaPointsByConnectionIndex && !allowBlindAndBuriedVias && bus.connections.length > 1 && bus.connections.every(
+      (connection) => connection.sourceLayer !== targetLayer
+    ) && viaHandednesses.includes(-1) && viaHandednesses.includes(1)) {
+      const variants = getDogboneSideVariants(bus.connections, bus.direction);
+      for (const handedness of viaHandednesses) {
+        for (const flippedIndices of variants) {
+          terminalPatterns.push({
+            label: `local-dogbone-repair-${handedness}-${flippedIndices.join("-")}`,
+            useViaInPad: false,
+            getViaHandedness: () => handedness,
+            maximumRouteOrderAttempts: 6,
+            localDogboneRepair: true,
+            getViaPoint: (connection) => {
+              const point6 = getInitialViaPoint({
+                preparedConnection: connection,
+                bus,
+                targetLayer,
+                traceWidth,
+                viaDiameter,
+                clearance,
+                viaHandedness: handedness
+              });
+              if (!flippedIndices.includes(connection.connectionIndex))
+                return point6;
+              return bus.direction === "up" || bus.direction === "down" ? { x: point6.x, y: 2 * connection.sourcePoint.y - point6.y } : { x: 2 * connection.sourcePoint.x - point6.x, y: point6.y };
+            }
+          });
+        }
+      }
+    }
     const seenTerminalSignatures = /* @__PURE__ */ new Set();
     for (const terminalPattern of terminalPatterns) {
       const terminals = bus.connections.map((preparedConnection) => {
@@ -23640,12 +24195,45 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
         };
       });
       const alignGridToPads = alignWindingGridToPads || Boolean(terminalPattern.getViaPoint && !fixedViaPointsByConnectionIndex);
+      if (terminalPattern.localDogboneRepair && !matchComponentDogboneViaSites([bus], {
+        viaDiameter,
+        viaHoleDiameter,
+        traceWidth,
+        clearance,
+        additionalObstacles: srj.obstacles,
+        fixedViaPointsByConnectionIndex: new Map(
+          terminals.map((terminal) => [
+            terminal.connection.connectionIndex,
+            terminal.viaPoint
+          ])
+        ),
+        blockingSegments: acceptedPlans.flatMap(
+          (plan) => getPlanSegments(plan).map((segment2) => ({
+            connectionIndex: plan.connectionIndex,
+            segment: segment2
+          }))
+        ),
+        blockingVias: [
+          ...acceptedPlans.flatMap(
+            (plan) => getPlanVias2(plan).map((via) => ({
+              connectionIndex: plan.connectionIndex,
+              center: via.center,
+              diameter: via.diameter,
+              spanLayers: via.spanLayers
+            }))
+          ),
+          // These are future connections, not members of the current bus.
+          ...reservedVias.map(({ via }) => ({ connectionIndex: -1, ...via }))
+        ]
+      })) {
+        continue;
+      }
       const gridStepDivisor = terminalPattern.getViaPoint && Math.min(bus.pitchX, bus.pitchY) - 2 * (viaDiameter / 2 + traceWidth / 2 + clearance) < traceWidth + clearance ? 2 : 1;
       const terminalSignature = `${terminals.map(
         (terminal) => `${terminal.connection.connectionIndex}:${terminal.viaPoint.x}:${terminal.viaPoint.y}:${terminal.exitPoint.x}:${terminal.exitPoint.y}`
       ).join(
         "|"
-      )}:${terminalPattern.maximumRouteOrderAttempts ?? "all"}:${gridStepDivisor}:${alignGridToPads}`;
+      )}:${terminalPattern.maximumRouteOrderAttempts ?? "all"}:${gridStepDivisor}:${alignGridToPads}:${Boolean(terminalPattern.localDogboneRepair)}`;
       if (seenTerminalSignatures.has(terminalSignature)) continue;
       seenTerminalSignatures.add(terminalSignature);
       const windingSteps = routeViaMinimalWindingAlternativesSteps(
@@ -23665,6 +24253,7 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
           maximumRouteOrderAttempts: terminalPattern.maximumRouteOrderAttempts,
           adaptiveRouteOrder: adaptiveWindingRouteOrder,
           alignGridToPads,
+          includeReverseTargetRotation: terminalPattern.localDogboneRepair,
           reservedVias,
           gridStepDivisor,
           preferTargetDirectedLaneBias: terminalPattern.preferTargetDirectedLaneBias
@@ -23714,41 +24303,46 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
       }
     }
   }
-  if (alternatives.length === 0 && allowBoundarySideViaFallback && fixedViaPointsByConnectionIndex && bus.connections.length === 1 && bus.exitEdge && bus.connections[0].sourceLayer !== targetLayer) {
-    const preparedConnection = bus.connections[0];
+  if (alternatives.length === 0 && allowBoundarySideViaFallback && fixedViaPointsByConnectionIndex && bus.connections.length <= 2 && bus.exitEdge && bus.connections.every(
+    (connection) => connection.sourceLayer === bus.connections[0].sourceLayer && connection.sourceLayer !== targetLayer
+  )) {
+    const sourceLayer2 = bus.connections[0].sourceLayer;
     const boundaryDirection = getDirectionForExitEdge(bus.exitEdge);
     const boundaryExitAxis = getExitAxis(bus, boundaryDirection);
-    const finalTrack = preferCornerBoundaryVia && getCornerSide(bus) ? getCornerTargetTrack({
-      bus,
-      connection: preparedConnection,
-      cornerExitLaneOffset: cornerLaneOffsets.exit,
-      traceWidth,
-      viaDiameter,
-      clearance,
-      layerNames,
-      targetLayer,
-      cornerBandTargetTrackOffset
-    }) : getBoundaryTargetTrack({
-      bus,
-      connection: preparedConnection,
-      boundaryDirection
-    });
-    const finalExitPoint = makePoint(
-      boundaryExitAxis,
-      finalTrack,
-      boundaryDirection
+    const finalTracks = bus.connections.map(
+      (preparedConnection) => preferCornerBoundaryVia && getCornerSide(bus) ? getCornerTargetTrack({
+        bus,
+        connection: preparedConnection,
+        cornerExitLaneOffset: cornerLaneOffsets.exit,
+        traceWidth,
+        viaDiameter,
+        clearance,
+        layerNames,
+        targetLayer,
+        cornerBandTargetTrackOffset
+      }) : getBoundaryTargetTrack({
+        bus,
+        connection: preparedConnection,
+        boundaryDirection
+      })
+    );
+    const finalExitPoints = finalTracks.map(
+      (track) => makePoint(boundaryExitAxis, track, boundaryDirection)
     );
     const sourceLayerSrj = {
       ...srj,
-      obstacles: srj.obstacles.map(
-        (obstacle) => obstacle === preparedConnection.sourceObstacle || distance9(obstacle.center, preparedConnection.sourcePoint) <= 1e-7 && obstacle.layers.includes(preparedConnection.sourceLayer) ? {
+      obstacles: srj.obstacles.map((obstacle) => {
+        const connection = bus.connections.find(
+          (connection2) => obstacle === connection2.sourceObstacle || distance9(obstacle.center, connection2.sourcePoint) <= 1e-7 && obstacle.layers.includes(connection2.sourceLayer)
+        );
+        return connection ? {
           ...obstacle,
           connectedTo: [
             ...obstacle.connectedTo,
-            preparedConnection.connection.name
+            connection.connection.name
           ]
-        } : obstacle
-      )
+        } : obstacle;
+      })
     };
     const insetStep = Math.max(
       viaDiameter / 2 + clearance,
@@ -23757,34 +24351,104 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
     const cornerSide = preferCornerBoundaryVia ? getCornerSide(bus) : void 0;
     const boundaryViaCandidates = [1, 2, 3, 4, 5].flatMap((multiple) => {
       const inset = multiple * insetStep;
-      const straight = makePoint(
-        boundaryExitAxis - directionSign(boundaryDirection) * inset,
-        finalTrack,
-        boundaryDirection
+      const straight = finalTracks.map(
+        (finalTrack) => makePoint(
+          boundaryExitAxis - directionSign(boundaryDirection) * inset,
+          finalTrack,
+          boundaryDirection
+        )
       );
       if (!cornerSide) return [straight];
       return [
-        makePoint(
-          boundaryExitAxis - directionSign(boundaryDirection) * inset,
-          finalTrack + (cornerSide === "maximum" ? inset : -inset),
-          boundaryDirection
+        finalTracks.map(
+          (finalTrack) => makePoint(
+            boundaryExitAxis - directionSign(boundaryDirection) * inset,
+            finalTrack + (cornerSide === "maximum" ? inset : -inset),
+            boundaryDirection
+          )
         ),
         straight
       ];
     });
-    for (const boundaryViaPoint of boundaryViaCandidates) {
+    const sourceCenter = {
+      x: bus.connections.reduce(
+        (sum, connection) => sum + connection.sourcePoint.x,
+        0
+      ) / bus.connections.length,
+      y: bus.connections.reduce(
+        (sum, connection) => sum + connection.sourcePoint.y,
+        0
+      ) / bus.connections.length
+    };
+    const directions = [
+      { x: -1, y: 0, distance: sourceCenter.x - Math.min(...bus.xCoordinates) },
+      { x: 1, y: 0, distance: Math.max(...bus.xCoordinates) - sourceCenter.x },
+      { x: 0, y: -1, distance: sourceCenter.y - Math.min(...bus.yCoordinates) },
+      { x: 0, y: 1, distance: Math.max(...bus.yCoordinates) - sourceCenter.y }
+    ].toSorted((first, second) => first.distance - second.distance);
+    const displacedViaCandidates = bus.connections.length === 2 ? directions.flatMap(
+      (direction) => [3].map(
+        (multiple) => bus.connections.map((connection) => {
+          const original = fixedViaPointsByConnectionIndex.get(
+            connection.connectionIndex
+          );
+          return {
+            x: original.x + direction.x * multiple * bus.pitchX,
+            y: original.y + direction.y * multiple * bus.pitchY
+          };
+        })
+      )
+    ) : [];
+    const viaCandidates = [
+      ...displacedViaCandidates.map((points) => ({
+        points,
+        boundarySide: false
+      })),
+      ...boundaryViaCandidates.map((points) => ({
+        points,
+        boundarySide: true
+      }))
+    ];
+    for (const { points: boundaryViaPoints, boundarySide } of viaCandidates) {
+      const boundaryVias = bus.connections.map((connection, index) => ({
+        connectionName: connection.connection.name,
+        via: {
+          center: boundaryViaPoints[index],
+          diameter: viaDiameter,
+          spanLayers: getViaSpanLayers2({
+            fromLayer: sourceLayer2,
+            toLayer: targetLayer,
+            layerNames,
+            allowBlindAndBuriedVias
+          })
+        }
+      }));
+      if (boundaryVias.some(
+        (candidate, index) => boundaryVias.some(
+          (other, otherIndex) => index !== otherIndex && (distance9(candidate.via.center, other.via.center) < viaDiameter + clearance - 1e-9 || boundarySide && distancePointToSegment(
+            candidate.via.center,
+            other.via.center,
+            finalExitPoints[otherIndex]
+          ) < viaDiameter / 2 + traceWidth / 2 + clearance - 1e-9)
+        )
+      ))
+        continue;
+      if (boundaryVias.some(
+        ({ via }) => srj.obstacles.some(
+          (obstacle) => obstacle.layers.some((layer) => via.spanLayers.includes(layer)) && distancePointToObstacle(via.center, obstacle) < via.diameter / 2 + clearance - 1e-9
+        )
+      ))
+        continue;
       const sourceLayerSteps = routeViaMinimalWindingAlternativesSteps(
         {
           srj: sourceLayerSrj,
           bus,
-          targetLayer: preparedConnection.sourceLayer,
-          terminals: [
-            {
-              connection: preparedConnection,
-              viaPoint: preparedConnection.sourcePoint,
-              exitPoint: boundaryViaPoint
-            }
-          ],
+          targetLayer: sourceLayer2,
+          terminals: bus.connections.map((preparedConnection, index) => ({
+            connection: preparedConnection,
+            viaPoint: preparedConnection.sourcePoint,
+            exitPoint: boundaryViaPoints[index]
+          })),
           acceptedPlans,
           layerNames,
           traceWidth,
@@ -23793,8 +24457,8 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
           clearance,
           allowBlindAndBuriedVias,
           allowSameNetMerges,
-          maximumRouteOrderAttempts: 3,
-          reservedVias,
+          maximumRouteOrderAttempts: bus.connections.length === 1 ? 3 : 6,
+          reservedVias: bus.connections.length > 1 ? [...reservedVias, ...boundaryVias] : reservedVias,
           gridStepDivisor: 2,
           allowSourceLayerRouting: true,
           alignGridToPads: true
@@ -23807,72 +24471,124 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
         yield {
           phase: "via-minimal-winding",
           busId: bus.busId,
-          targetLayer: preparedConnection.sourceLayer,
+          targetLayer: sourceLayer2,
           winding: sourceLayerResult.value
         };
         sourceLayerResult = sourceLayerSteps.next();
       }
-      const sourceLayerPlan = sourceLayerResult.value[0]?.[0];
-      if (!sourceLayerPlan) continue;
-      const targetSegment = {
-        start: boundaryViaPoint,
-        end: finalExitPoint,
-        width: traceWidth,
-        layer: targetLayer
-      };
-      const via = {
-        center: boundaryViaPoint,
-        diameter: viaDiameter,
-        holeDiameter: viaHoleDiameter,
-        fromLayer: preparedConnection.sourceLayer,
-        toLayer: targetLayer,
-        spanLayers: getViaSpanLayers2({
-          fromLayer: preparedConnection.sourceLayer,
-          toLayer: targetLayer,
-          layerNames,
-          allowBlindAndBuriedVias
-        })
-      };
-      const sourceRoute = sourceLayerPlan.trace.route.filter(
-        (item) => item.route_type === "wire"
-      );
-      const plans = [
-        {
-          ...sourceLayerPlan,
-          ...preferCornerBoundaryVia ? { sourceEscapeSegmentCount: sourceLayerPlan.segments.length } : {},
-          targetLayer,
-          exitPoint: finalExitPoint,
-          via,
-          segments: [...sourceLayerPlan.segments, targetSegment],
-          length: sourceLayerPlan.length + distance9(boundaryViaPoint, finalExitPoint),
-          trace: {
-            ...sourceLayerPlan.trace,
-            route: [
-              ...sourceRoute,
-              {
-                route_type: "via",
-                ...boundaryViaPoint,
-                from_layer: preparedConnection.sourceLayer,
-                to_layer: targetLayer,
-                via_diameter: viaDiameter,
-                via_hole_diameter: viaHoleDiameter
-              },
-              {
-                route_type: "wire",
-                ...boundaryViaPoint,
-                width: traceWidth,
-                layer: targetLayer
-              },
-              {
-                route_type: "wire",
-                ...finalExitPoint,
-                width: traceWidth,
-                layer: targetLayer
-              }
-            ]
-          }
+      const sourceLayerPlans = sourceLayerResult.value[0];
+      if (!sourceLayerPlans || sourceLayerPlans.length !== bus.connections.length)
+        continue;
+      let targetLayerPlans;
+      if (!boundarySide) {
+        const targetSteps = routeViaMinimalWindingAlternativesSteps(
+          {
+            srj,
+            bus,
+            targetLayer,
+            terminals: bus.connections.map((connection, index) => ({
+              connection,
+              viaPoint: boundaryViaPoints[index],
+              exitPoint: finalExitPoints[index]
+            })),
+            acceptedPlans,
+            layerNames,
+            traceWidth,
+            viaDiameter,
+            viaHoleDiameter,
+            clearance,
+            allowBlindAndBuriedVias,
+            allowSameNetMerges,
+            maximumRouteOrderAttempts: 6,
+            reservedVias,
+            gridStepDivisor: 2,
+            alignGridToPads: true
+          },
+          1,
+          includeVisualization
+        );
+        let targetResult = targetSteps.next();
+        while (!targetResult.done) {
+          yield {
+            phase: "via-minimal-winding",
+            busId: bus.busId,
+            targetLayer,
+            winding: targetResult.value
+          };
+          targetResult = targetSteps.next();
+        }
+        targetLayerPlans = targetResult.value[0];
+        if (!targetLayerPlans) continue;
+      }
+      const plans = sourceLayerPlans.map(
+        (sourceLayerPlan, index) => {
+          const boundaryViaPoint = boundaryViaPoints[index];
+          const finalExitPoint = finalExitPoints[index];
+          const targetSegment = {
+            start: boundaryViaPoint,
+            end: finalExitPoint,
+            width: traceWidth,
+            layer: targetLayer
+          };
+          const targetSegments = targetLayerPlans ? targetLayerPlans[index].segments.filter(
+            (segment2) => segment2.layer === targetLayer
+          ) : [targetSegment];
+          const via = {
+            center: boundaryViaPoint,
+            diameter: viaDiameter,
+            holeDiameter: viaHoleDiameter,
+            fromLayer: sourceLayer2,
+            toLayer: targetLayer,
+            spanLayers: getViaSpanLayers2({
+              fromLayer: sourceLayer2,
+              toLayer: targetLayer,
+              layerNames,
+              allowBlindAndBuriedVias
+            })
+          };
+          const sourceRoute = sourceLayerPlan.trace.route.filter(
+            (item) => item.route_type === "wire"
+          );
+          return {
+            ...sourceLayerPlan,
+            ...preferCornerBoundaryVia || bus.connections.length > 1 ? { sourceEscapeSegmentCount: sourceLayerPlan.segments.length } : {},
+            targetLayer,
+            exitPoint: finalExitPoint,
+            via,
+            segments: [...sourceLayerPlan.segments, ...targetSegments],
+            length: sourceLayerPlan.length + targetSegments.reduce(
+              (sum, segment2) => sum + distance9(segment2.start, segment2.end),
+              0
+            ),
+            trace: {
+              ...sourceLayerPlan.trace,
+              route: [
+                ...sourceRoute,
+                {
+                  route_type: "via",
+                  ...boundaryViaPoint,
+                  from_layer: sourceLayer2,
+                  to_layer: targetLayer,
+                  via_diameter: viaDiameter,
+                  via_hole_diameter: viaHoleDiameter
+                },
+                {
+                  route_type: "wire",
+                  ...boundaryViaPoint,
+                  width: traceWidth,
+                  layer: targetLayer
+                },
+                ...targetSegments.map((segment2) => ({
+                  route_type: "wire",
+                  ...segment2.end,
+                  width: traceWidth,
+                  layer: targetLayer
+                }))
+              ]
+            }
+          };
         }
-      ];
+      );
       const boundaryViaPlansAreClear = fanoutPlansAreClear({
         plans: [...acceptedPlans, ...plans],
         srj,
@@ -23881,23 +24597,28 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
         allowBlindAndBuriedVias,
         allowSameNetMerges
       });
-      const reservedViasAreClear = reservedVias.every((reserved) => {
-        if (reserved.connectionName === preparedConnection.connection.name || allowSameNetMerges && connectionsShareElectricalNet(
-          srj,
-          reserved.connectionName,
-          preparedConnection.connection.name
-        ))
-          return true;
-        if (via.spanLayers.some(
-          (layer) => reserved.via.spanLayers.includes(layer)
-        ) && distance9(via.center, reserved.via.center) < (via.diameter + reserved.via.diameter) / 2 + clearance - 1e-9)
-          return false;
-        return !reserved.via.spanLayers.includes(targetLayer) || distancePointToSegment(
-          reserved.via.center,
-          targetSegment.start,
-          targetSegment.end
-        ) >= reserved.via.diameter / 2 + traceWidth / 2 + clearance - 1e-9;
-      });
+      const reservedViasAreClear = plans.every(
+        (plan) => reservedVias.every((reserved) => {
+          const via = plan.via;
+          if (reserved.connectionName === plan.connectionName || allowSameNetMerges && connectionsShareElectricalNet(
+            srj,
+            reserved.connectionName,
+            plan.connectionName
+          ))
+            return true;
+          if (via.spanLayers.some(
+            (layer) => reserved.via.spanLayers.includes(layer)
+          ) && distance9(via.center, reserved.via.center) < (via.diameter + reserved.via.diameter) / 2 + clearance - 1e-9)
+            return false;
+          return plan.segments.every(
+            (segment2) => !reserved.via.spanLayers.includes(segment2.layer) || distancePointToSegment(
+              reserved.via.center,
+              segment2.start,
+              segment2.end
+            ) >= reserved.via.diameter / 2 + traceWidth / 2 + clearance - 1e-9
+          );
+        })
+      );
       if (boundaryViaPlansAreClear && reservedViasAreClear) {
         addAlternative(plans);
         return alternatives;
@@ -23931,326 +24652,92 @@ function* routeBusAlternativesSteps(params, maxAlternatives = 1, includeVisualiz
       })
     ].filter(
       (track, index, tracks) => tracks.findIndex((candidate) => Math.abs(candidate - track) < 1e-9) === index
-    );
-    const trackCandidates = preferredTracks.flatMap(
-      (preferredTrack) => getTrackCandidates({
-        bus,
-        connection: preparedConnection,
-        preferredTrack,
-        traceWidth,
-        clearance
-      })
-    ).filter(
-      (track, index, tracks) => tracks.findIndex(
-        (candidate) => Math.abs(candidate.value - track.value) < 1e-9
-      ) === index
-    );
-    for (let trackIndex = 0; trackIndex < trackCandidates.length; trackIndex++) {
-      const track = trackCandidates[trackIndex];
-      const plan = buildPlan2({
-        preparedConnection,
-        bus,
-        targetLayer,
-        track: track.value,
-        exitAxis,
-        layerNames,
-        traceWidth,
-        viaDiameter,
-        viaHoleDiameter,
-        viaHandedness,
-        interstitialEscape,
-        spreadLaneIndex: Math.min(
-          connectionRank,
-          bus.connections.length - connectionRank - 1
-        ),
-        cornerExitLaneOffset: cornerLaneOffsets.exit,
-        cornerLocalChannelLaneOffset: cornerLaneOffsets.localChannel,
-        cornerBoundaryChannelLaneOffset: cornerLaneOffsets.boundaryChannel,
-        clearance,
-        terminateAtVia: false,
-        allowBlindAndBuriedVias,
-        cornerBandTargetTrackOffset
-      });
-      if (!planIsClear({
-        plan,
-        otherPlans: [...acceptedPlans, ...candidatePlans],
-        staticClearanceCache,
-        blockingBusCounts,
-        cacheKey: `boundary:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${viaHandedness}:${trackIndex}:${bus.exitEdge ?? "legacy"}:${cornerLaneOffsets.exit}:${cornerLaneOffsets.localChannel}:${cornerLaneOffsets.boundaryChannel}:${cornerBandTargetTrackOffset ?? 0}`,
-        srj,
-        sharedBoundary: bus.sharedBoundary,
-        clearance,
-        allowBlindAndBuriedVias,
-        allowSameNetMerges
-      })) {
-        continue;
-      }
-      searchConnectionOrder(
-        connectionOrder,
-        viaHandedness,
-        connectionIndex + 1,
-        [...candidatePlans, plan]
-      );
-      if (alternatives.length >= maxAlternatives) return;
-      if (maxAlternatives === 1) return;
-    }
-  };
-  for (const viaHandedness of viaHandednesses) {
-    for (const connectionOrder of getConnectionOrders(bus)) {
-      searchConnectionOrder(connectionOrder, viaHandedness, 0, []);
-      if (alternatives.length >= maxAlternatives) return alternatives;
-    }
-  }
-  return alternatives;
-}
-function routeBusAlternatives(params, maxAlternatives = 1) {
-  const steps = routeBusAlternativesSteps(params, maxAlternatives);
-  let result = steps.next();
-  while (!result.done) result = steps.next();
-  return result.value;
-}
-function routeBus(params) {
-  return routeBusAlternatives(params, 1)[0] ?? null;
-}
-
-// node_modules/@tscircuit/fanout-solver/lib/shorten-bus-plans.ts
-function shortenBusPlans(params) {
-  const { bus } = params;
-  let plans = [...params.plans];
-  if (bus.maxLengthSkew === void 0) return plans;
-  const busPlans = plans.filter((plan) => plan.busId === bus.busId).toSorted((first, second) => second.length - first.length);
-  for (const plan of busPlans) {
-    const minimumLength = Math.min(
-      ...plans.filter((p) => p.busId === bus.busId).map((p) => p.length)
-    );
-    if (plan.length - minimumLength <= bus.maxLengthSkew) continue;
-    if (!plan.via || plan.additionalVias?.length || plan.planeEndpointVia || plan.segments.filter((segment2) => segment2.layer === plan.sourceLayer).length !== 1)
-      continue;
-    const connection = bus.connections.find(
-      (c) => c.connectionIndex === plan.connectionIndex
-    );
-    for (const alignGridToPads of [true, false]) {
-      const candidate = routeViaMinimalWinding({
-        ...params,
-        bus: {
-          ...bus,
-          connections: [connection],
-          routableEscapeLayers: [plan.targetLayer]
-        },
-        terminals: [
-          { connection, viaPoint: plan.via.center, exitPoint: plan.exitPoint }
-        ],
-        targetLayer: plan.targetLayer,
-        acceptedPlans: plans.filter((p) => p !== plan),
-        allowBlindAndBuriedVias: false,
-        gridStepDivisor: 2,
-        alignGridToPads,
-        maximumRouteOrderAttempts: 1
-      })?.[0];
-      if (!candidate || candidate.length >= plan.length - 1e-6) continue;
-      const nextPlans = plans.map((p) => p === plan ? candidate : p);
-      if (!fanoutPlansAreClear({
-        ...params,
-        plans: nextPlans,
-        allowBlindAndBuriedVias: false
-      }))
-        continue;
-      plans = nextPlans;
-      break;
-    }
-  }
-  return plans;
-}
-
-// node_modules/@tscircuit/fanout-solver/lib/fanout-solver.ts
-import { mergeGraphics } from "graphics-debug";
-
-// node_modules/@tscircuit/fanout-solver/lib/add-via-layer-metadata.ts
-function addViaLayerMetadataToTrace(params) {
-  const { trace, layerNames, allowBlindAndBuriedVias } = params;
-  return {
-    ...trace,
-    route: trace.route.map(
-      (routePoint) => routePoint.route_type === "via" && !allowBlindAndBuriedVias ? {
-        ...routePoint,
-        layers: getViaSpanLayers2({
-          fromLayer: routePoint.from_layer,
-          toLayer: routePoint.to_layer,
-          layerNames,
-          allowBlindAndBuriedVias
-        })
-      } : { ...routePoint }
-    )
-  };
-}
-function addViaLayerMetadataToSrj(params) {
-  const { srj, layerNames, allowBlindAndBuriedVias } = params;
-  return {
-    ...srj,
-    traces: (srj.traces ?? []).map(
-      (trace) => addViaLayerMetadataToTrace({
-        trace,
-        layerNames,
-        allowBlindAndBuriedVias
-      })
-    )
-  };
-}
-
-// node_modules/@tscircuit/fanout-solver/lib/build-output.ts
-function createViaObstacle(plan, layerNames, via, viaIndex) {
-  const zLayers = via.spanLayers.map((layer) => {
-    const layerIndex = layerNames.indexOf(layer);
-    if (layerIndex < 0) {
-      throw new Error(
-        `FanoutSolver: via for "${plan.connectionName}" uses unknown layer "${layer}"`
-      );
-    }
-    return layerIndex;
-  });
-  const outputIds = createFanoutOutputIds(plan);
-  return {
-    obstacleId: viaIndex === "endpoint" ? outputIds.planeEndpointViaObstacleId : viaIndex === 0 ? outputIds.viaObstacleId : `${outputIds.viaObstacleId}:${viaIndex}`,
-    type: "rect",
-    center: via.center,
-    width: via.diameter,
-    height: via.diameter,
-    layers: via.spanLayers,
-    zLayers,
-    __zLayers: zLayers,
-    connectedTo: [plan.connectionName, plan.trace.pcb_trace_id]
-  };
-}
-function buildOutputSimpleRouteJson(params) {
-  const { inputSrj, plans, layerNames } = params;
-  const outputConnections = inputSrj.connections.map((connection) => ({
-    ...connection,
-    pointsToConnect: connection.pointsToConnect.map((point6) => ({ ...point6 }))
-  }));
-  const viaObstacles = [];
-  const planeTerminatedConnectionNames = /* @__PURE__ */ new Set();
-  for (const plan of plans) {
-    const connection = outputConnections[plan.connectionIndex];
-    if (!connection) {
-      throw new Error(
-        `FanoutSolver: output connection index ${plan.connectionIndex} is missing`
-      );
-    }
-    const outputIds = createFanoutOutputIds(plan);
-    connection.pointsToConnect[plan.sourcePointIndex] = {
-      x: plan.exitPoint.x,
-      y: plan.exitPoint.y,
-      layer: plan.targetLayer,
-      pointId: plan.termination.type === "plane" ? outputIds.planeExitPointId : outputIds.boundaryExitPointId
-    };
-    if (plan.termination.type === "plane") {
-      planeTerminatedConnectionNames.add(plan.connectionName);
-    }
-    if (plan.via) {
-      const viaObstacle = createViaObstacle(plan, layerNames, plan.via, 0);
-      if (viaObstacle) viaObstacles.push(viaObstacle);
-    }
-    for (const [additionalViaIndex, via] of (plan.additionalVias ?? []).entries()) {
-      const viaObstacle = createViaObstacle(
-        plan,
+    );
+    const trackCandidates = preferredTracks.flatMap(
+      (preferredTrack) => getTrackCandidates({
+        bus,
+        connection: preparedConnection,
+        preferredTrack,
+        traceWidth,
+        clearance
+      })
+    ).filter(
+      (track, index, tracks) => tracks.findIndex(
+        (candidate) => Math.abs(candidate.value - track.value) < 1e-9
+      ) === index
+    );
+    for (let trackIndex = 0; trackIndex < trackCandidates.length; trackIndex++) {
+      const track = trackCandidates[trackIndex];
+      const plan = buildPlan2({
+        preparedConnection,
+        bus,
+        targetLayer,
+        track: track.value,
+        exitAxis,
         layerNames,
-        via,
-        additionalViaIndex + 1
-      );
-      if (viaObstacle) viaObstacles.push(viaObstacle);
-    }
-    if (plan.planeEndpointVia) {
-      const endpointViaObstacle = createViaObstacle(
+        traceWidth,
+        viaDiameter,
+        viaHoleDiameter,
+        viaHandedness,
+        interstitialEscape,
+        spreadLaneIndex: Math.min(
+          connectionRank,
+          bus.connections.length - connectionRank - 1
+        ),
+        cornerExitLaneOffset: cornerLaneOffsets.exit,
+        cornerLocalChannelLaneOffset: cornerLaneOffsets.localChannel,
+        cornerBoundaryChannelLaneOffset: cornerLaneOffsets.boundaryChannel,
+        clearance,
+        terminateAtVia: false,
+        allowBlindAndBuriedVias,
+        cornerBandTargetTrackOffset
+      });
+      if (!planIsClear({
         plan,
-        layerNames,
-        plan.planeEndpointVia,
-        "endpoint"
+        otherPlans: [...acceptedPlans, ...candidatePlans],
+        staticClearanceCache,
+        blockingBusCounts,
+        cacheKey: `boundary:${bus.busId}:${targetLayer}:${preparedConnection.connectionIndex}:${viaHandedness}:${trackIndex}:${bus.exitEdge ?? "legacy"}:${cornerLaneOffsets.exit}:${cornerLaneOffsets.localChannel}:${cornerLaneOffsets.boundaryChannel}:${cornerBandTargetTrackOffset ?? 0}`,
+        srj,
+        sharedBoundary: bus.sharedBoundary,
+        clearance,
+        allowBlindAndBuriedVias,
+        allowSameNetMerges
+      })) {
+        continue;
+      }
+      searchConnectionOrder(
+        connectionOrder,
+        viaHandedness,
+        connectionIndex + 1,
+        [...candidatePlans, plan]
       );
-      if (endpointViaObstacle) viaObstacles.push(endpointViaObstacle);
+      if (alternatives.length >= maxAlternatives) return;
+      if (maxAlternatives === 1) return;
     }
-  }
-  const planTraces = plans.flatMap((plan) => [
-    plan.trace,
-    ...plan.planeEndpointTrace ? [plan.planeEndpointTrace] : []
-  ]);
-  const coordinateRoutePoints = planTraces.flatMap(
-    (trace) => trace.route.filter(
-      (routePoint) => "x" in routePoint && "y" in routePoint
-    )
-  );
-  const boundsMargin = Math.max(
-    inputSrj.defaultObstacleMargin ?? 0,
-    inputSrj.minTraceWidth
-  );
-  const outputBounds = coordinateRoutePoints.length === 0 ? { ...inputSrj.bounds } : {
-    minX: Math.min(
-      inputSrj.bounds.minX,
-      ...coordinateRoutePoints.map(
-        (routePoint) => routePoint.x - boundsMargin
-      )
-    ),
-    maxX: Math.max(
-      inputSrj.bounds.maxX,
-      ...coordinateRoutePoints.map(
-        (routePoint) => routePoint.x + boundsMargin
-      )
-    ),
-    minY: Math.min(
-      inputSrj.bounds.minY,
-      ...coordinateRoutePoints.map(
-        (routePoint) => routePoint.y - boundsMargin
-      )
-    ),
-    maxY: Math.max(
-      inputSrj.bounds.maxY,
-      ...coordinateRoutePoints.map(
-        (routePoint) => routePoint.y + boundsMargin
-      )
-    )
-  };
-  return {
-    ...inputSrj,
-    fanoutPlaneConnectivity: plans.flatMap(
-      (plan) => plan.termination.type === "plane" ? [
-        {
-          connectionName: plan.connectionName,
-          layer: plan.termination.layer
-        }
-      ] : []
-    ),
-    bounds: outputBounds,
-    connections: outputConnections.filter(
-      (connection) => !planeTerminatedConnectionNames.has(connection.name)
-    ),
-    buses: inputSrj.buses?.map((bus) => ({
-      ...bus,
-      connectionNames: bus.connectionNames.filter(
-        (connectionName) => !planeTerminatedConnectionNames.has(connectionName)
-      )
-    })).filter((bus) => bus.connectionNames.length > 0),
-    obstacles: [
-      ...inputSrj.obstacles.map((obstacle) => ({
-        ...obstacle,
-        center: { ...obstacle.center },
-        layers: [...obstacle.layers],
-        connectedTo: [...obstacle.connectedTo]
-      })),
-      ...viaObstacles
-    ],
-    traces: [
-      ...(inputSrj.traces ?? []).map((trace) => ({
-        ...trace,
-        route: trace.route.map((routePoint) => ({ ...routePoint }))
-      })),
-      ...planTraces
-    ]
   };
+  for (const viaHandedness of viaHandednesses) {
+    for (const connectionOrder of getConnectionOrders(bus)) {
+      searchConnectionOrder(connectionOrder, viaHandedness, 0, []);
+      if (alternatives.length >= maxAlternatives) return alternatives;
+    }
+  }
+  return alternatives;
+}
+function routeBusAlternatives(params, maxAlternatives = 1) {
+  const steps = routeBusAlternativesSteps(params, maxAlternatives);
+  let result = steps.next();
+  while (!result.done) result = steps.next();
+  return result.value;
+}
+function routeBus(params) {
+  return routeBusAlternatives(params, 1)[0] ?? null;
 }
 
 // node_modules/@tscircuit/fanout-solver/lib/match-bus-lengths.ts
-var EPSILON7 = 1e-6;
+var EPSILON8 = 1e-6;
 function pointsMatch2(first, second) {
-  return distance9(first, second) <= EPSILON7;
+  return distance9(first, second) <= EPSILON8;
 }
 function getPlanVias3(plan) {
   return [plan.via, ...plan.additionalVias ?? []].filter(
@@ -24355,26 +24842,26 @@ function splitSegmentAtDenseBounds(params) {
   const deltaY = segment2.end.y - segment2.start.y;
   const splitParameters = [0, 1];
   const addSplitParameter = (parameter) => {
-    if (parameter <= EPSILON7 || parameter >= 1 - EPSILON7) return;
+    if (parameter <= EPSILON8 || parameter >= 1 - EPSILON8) return;
     const point6 = {
       x: segment2.start.x + deltaX * parameter,
       y: segment2.start.y + deltaY * parameter
     };
-    if (point6.x < expandedBounds.minX - EPSILON7 || point6.x > expandedBounds.maxX + EPSILON7 || point6.y < expandedBounds.minY - EPSILON7 || point6.y > expandedBounds.maxY + EPSILON7) {
+    if (point6.x < expandedBounds.minX - EPSILON8 || point6.x > expandedBounds.maxX + EPSILON8 || point6.y < expandedBounds.minY - EPSILON8 || point6.y > expandedBounds.maxY + EPSILON8) {
       return;
     }
     splitParameters.push(parameter);
   };
-  if (Math.abs(deltaX) > EPSILON7) {
+  if (Math.abs(deltaX) > EPSILON8) {
     addSplitParameter((expandedBounds.minX - segment2.start.x) / deltaX);
     addSplitParameter((expandedBounds.maxX - segment2.start.x) / deltaX);
   }
-  if (Math.abs(deltaY) > EPSILON7) {
+  if (Math.abs(deltaY) > EPSILON8) {
     addSplitParameter((expandedBounds.minY - segment2.start.y) / deltaY);
     addSplitParameter((expandedBounds.maxY - segment2.start.y) / deltaY);
   }
   const parameters = splitParameters.toSorted((first, second) => first - second).filter(
-    (parameter, index, values) => index === 0 || Math.abs(parameter - values[index - 1]) > EPSILON7
+    (parameter, index, values) => index === 0 || Math.abs(parameter - values[index - 1]) > EPSILON8
   );
   return parameters.slice(1).map((endParameter, index) => {
     const startParameter = parameters[index];
@@ -24421,7 +24908,7 @@ function hasNonAdjacentSelfIntersection(segments) {
         first.end,
         second.start,
         second.end
-      ) <= EPSILON7) {
+      ) <= EPSILON8) {
         return true;
       }
     }
@@ -24463,7 +24950,7 @@ function replacementCopperIsSelfClear(params) {
     const replacement = segments[replacementIndex];
     for (const [otherIndex, other] of segments.entries()) {
       const requiredCenterlineClearance = replacement.width / 2 + other.width / 2 + clearance;
-      if (getConnectedPathDistance(replacementIndex, otherIndex) <= requiredCenterlineClearance + EPSILON7) {
+      if (getConnectedPathDistance(replacementIndex, otherIndex) <= requiredCenterlineClearance + EPSILON8) {
         continue;
       }
       if (!segmentsAreClear(replacement, other, clearance)) return false;
@@ -24473,7 +24960,7 @@ 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 - EPSILON7) {
+      if (distancePointToSegment(via.center, replacement.start, replacement.end) < via.diameter / 2 + replacement.width / 2 + clearance - EPSILON8) {
         return false;
       }
     }
@@ -24481,7 +24968,7 @@ function replacementCopperIsSelfClear(params) {
   return true;
 }
 function pointIsInsideBounds2(point6, bounds) {
-  return point6.x >= bounds.minX - EPSILON7 && point6.x <= bounds.maxX + EPSILON7 && point6.y >= bounds.minY - EPSILON7 && point6.y <= bounds.maxY + EPSILON7;
+  return point6.x >= bounds.minX - EPSILON8 && point6.x <= bounds.maxX + EPSILON8 && point6.y >= bounds.minY - EPSILON8 && point6.y <= bounds.maxY + EPSILON8;
 }
 function addScaled(point6, vector2, scale3) {
   return {
@@ -24501,9 +24988,9 @@ function createMeanderPoints(params) {
   const dx = segment2.end.x - segment2.start.x;
   const dy = segment2.end.y - segment2.start.y;
   const segmentLength = Math.hypot(dx, dy);
-  if (segmentLength <= EPSILON7) return null;
-  const isAxisAligned = Math.abs(dx) <= EPSILON7 || Math.abs(dy) <= EPSILON7;
-  const isFortyFiveDegree = Math.abs(Math.abs(dx) - Math.abs(dy)) <= EPSILON7;
+  if (segmentLength <= EPSILON8) return null;
+  const isAxisAligned = Math.abs(dx) <= EPSILON8 || Math.abs(dy) <= EPSILON8;
+  const isFortyFiveDegree = Math.abs(Math.abs(dx) - Math.abs(dy)) <= EPSILON8;
   if (!isAxisAligned && !isFortyFiveDegree) return null;
   const tangent = { x: dx / segmentLength, y: dy / segmentLength };
   const normal = {
@@ -24519,11 +25006,11 @@ function createMeanderPoints(params) {
   const toothGap = pitch;
   const occupiedLength = toothCount * toothSpan + Math.max(0, toothCount - 1) * toothGap;
   const minimumLead = pitch / 4;
-  if (occupiedLength + minimumLead * 2 > segmentLength + EPSILON7) {
+  if (occupiedLength + minimumLead * 2 > segmentLength + EPSILON8) {
     return null;
   }
   const minimumAddedLengthPerTooth = 4 * chamfer * (Math.SQRT2 - 1);
-  if (targetAddedLength + EPSILON7 < minimumAddedLengthPerTooth * toothCount) {
+  if (targetAddedLength + EPSILON8 < minimumAddedLengthPerTooth * toothCount) {
     return null;
   }
   const verticalRun = (targetAddedLength / toothCount - minimumAddedLengthPerTooth) / 2;
@@ -24656,10 +25143,10 @@ function* createSpreadLaneCandidates(plan, clearance) {
     (a, b) => distance9(b.segment.start, b.segment.end) - distance9(a.segment.start, a.segment.end)
   )) {
     const length7 = distance9(segment2.start, segment2.end);
-    if (length7 <= EPSILON7) continue;
+    if (length7 <= EPSILON8) continue;
     const dx = Math.abs(segment2.end.x - segment2.start.x);
     const dy = Math.abs(segment2.end.y - segment2.start.y);
-    if (dx > EPSILON7 && dy > EPSILON7 && Math.abs(dx - dy) > EPSILON7) continue;
+    if (dx > EPSILON8 && dy > EPSILON8 && Math.abs(dx - dy) > EPSILON8) continue;
     const tangent = {
       x: (segment2.end.x - segment2.start.x) / length7,
       y: (segment2.end.y - segment2.start.y) / length7
@@ -24729,15 +25216,15 @@ function matchBusPlanLengths(params) {
       }
       const maxLengthSkew = bus.maxLengthSkew;
       const skew = getBusSkew(busPlans);
-      if (skew <= maxLengthSkew + EPSILON7) break;
+      if (skew <= maxLengthSkew + EPSILON8) break;
       const shortest = busPlans.toSorted(
         (first, second) => first.length - second.length || first.connectionName.localeCompare(second.connectionName)
       )[0];
       const longestLength = Math.max(...busPlans.map((plan) => plan.length));
       const deficit = longestLength - shortest.length;
       const minimumRequiredAddition = Math.max(
-        EPSILON7,
-        deficit - maxLengthSkew + EPSILON7
+        EPSILON8,
+        deficit - maxLengthSkew + EPSILON8
       );
       const targetAddedLengths = [
         minimumRequiredAddition,
@@ -24747,8 +25234,8 @@ function matchBusPlanLengths(params) {
         deficit,
         deficit + maxLengthSkew
       ].filter(
-        (value, index, values) => value > EPSILON7 && values.findIndex(
-          (candidate) => Math.abs(candidate - value) < EPSILON7
+        (value, index, values) => value > EPSILON8 && values.findIndex(
+          (candidate) => Math.abs(candidate - value) < EPSILON8
         ) === index
       ).toSorted((first, second) => first - second);
       let acceptedPlans = null;
@@ -24759,7 +25246,7 @@ function matchBusPlanLengths(params) {
         const nextBusPlans = nextPlans.filter(
           (plan) => plan.busId === bus.busId
         );
-        if (getBusSkew(nextBusPlans) > skew + EPSILON7) return null;
+        if (getBusSkew(nextBusPlans) > skew + EPSILON8) return null;
         if (!fanoutPlansAreClear({
           plans: nextPlans,
           srj: inputSrj,
@@ -24793,7 +25280,7 @@ function matchBusPlanLengths(params) {
         const search = (currentPlan, stagesRemaining) => {
           const addedLength = currentPlan.length - shortest.length;
           const remainingAddition = targetAddedLength - addedLength;
-          if (remainingAddition <= EPSILON7) {
+          if (remainingAddition <= EPSILON8) {
             return acceptCandidate(currentPlan);
           }
           if (stagesRemaining <= 0) return null;
@@ -24838,7 +25325,7 @@ function matchBusPlanLengths(params) {
           if (!acceptedPlans) continue;
           break;
         }
-        if (!acceptedPlans && Math.abs(targetAddedLength - minimumRequiredAddition) <= EPSILON7) {
+        if (!acceptedPlans && Math.abs(targetAddedLength - minimumRequiredAddition) <= EPSILON8) {
           acceptedPlans = findMultiSpanCandidate(targetAddedLength);
         }
         if (acceptedPlans) break;
@@ -24880,7 +25367,7 @@ function matchBusPlanLengths(params) {
     const matchedBusPlans = matchedPlans.filter(
       (plan) => plan.busId === bus.busId
     );
-    if (getBusSkew(matchedBusPlans) > bus.maxLengthSkew + EPSILON7) {
+    if (getBusSkew(matchedBusPlans) > bus.maxLengthSkew + EPSILON8) {
       return { plans: null, failedBus: bus };
     }
   }
@@ -25862,7 +26349,7 @@ function prepareFanoutBuses(srj, options) {
 }
 
 // node_modules/@tscircuit/fanout-solver/lib/route-single-layer-adaptive-exits.ts
-var EPSILON8 = 1e-9;
+var EPSILON9 = 1e-9;
 var OBSTACLE_BIN_SIZE = 1;
 var FANOUT_FLOW_DEBUG_ENABLED = globalThis.process?.env?.FANOUT_FLOW_DEBUG === "1";
 function visualizeFlowProgress(params) {
@@ -25943,7 +26430,7 @@ function connectWith45DegreeSegments(start, end) {
   const deltaY = end.y - start.y;
   const absoluteX = Math.abs(deltaX);
   const absoluteY = Math.abs(deltaY);
-  if (absoluteX < EPSILON8 || absoluteY < EPSILON8 || Math.abs(absoluteX - absoluteY) < EPSILON8) {
+  if (absoluteX < EPSILON9 || absoluteY < EPSILON9 || Math.abs(absoluteX - absoluteY) < EPSILON9) {
     return [start, end];
   }
   if (absoluteX > absoluteY) {
@@ -25972,7 +26459,7 @@ function enforceStraightOr45DegreeSegments(points) {
     const start = normalized.at(-1);
     const deltaX = Math.abs(end.x - start.x);
     const deltaY = Math.abs(end.y - start.y);
-    if (deltaX < EPSILON8 || deltaY < EPSILON8 || Math.abs(deltaX - deltaY) < EPSILON8) {
+    if (deltaX < EPSILON9 || deltaY < EPSILON9 || Math.abs(deltaX - deltaY) < EPSILON9) {
       normalized.push(end);
       continue;
     }
@@ -26005,7 +26492,7 @@ function chamferOrthogonalPolyline3(points, requestedChamfer) {
     const next = points[index + 1];
     const incomingLength = distance9(previous, corner);
     const outgoingLength = distance9(corner, next);
-    if (incomingLength < EPSILON8 || outgoingLength < EPSILON8) continue;
+    if (incomingLength < EPSILON9 || outgoingLength < EPSILON9) continue;
     const incoming = {
       x: (corner.x - previous.x) / incomingLength,
       y: (corner.y - previous.y) / incomingLength
@@ -26038,7 +26525,7 @@ function chamferOrthogonalPolyline3(points, requestedChamfer) {
 function getSegments2(points, traceWidth) {
   const segments = [];
   for (let index = 1; index < points.length; index++) {
-    if (distance9(points[index - 1], points[index]) < EPSILON8) continue;
+    if (distance9(points[index - 1], points[index]) < EPSILON9) continue;
     segments.push({
       start: points[index - 1],
       end: points[index],
@@ -26189,7 +26676,7 @@ function* createFlowGridSteps(params) {
   for (let node = 0; node < nodeCount; node++) {
     const point6 = points[node];
     if (getNearbyObstacles(point6).every(
-      (obstacle) => distancePointToObstacle(point6, obstacle) >= requiredObstacleDistance - EPSILON8
+      (obstacle) => distancePointToObstacle(point6, obstacle) >= requiredObstacleDistance - EPSILON9
     )) {
       obstacleFreeNodes[node] = 1;
     }
@@ -26228,7 +26715,7 @@ function* createFlowGridSteps(params) {
         layer: "top"
       };
       if (getNearbyObstacles(segment2.start, segment2.end).some(
-        (obstacle) => distanceSegmentToObstacle(segment2, obstacle) < requiredObstacleDistance - EPSILON8
+        (obstacle) => distanceSegmentToObstacle(segment2, obstacle) < requiredObstacleDistance - EPSILON9
       )) {
         continue;
       }
@@ -26293,7 +26780,7 @@ function* routeDirectionGroupSteps(params) {
     const segments = getSegments2(points, traceWidth);
     return segments.every(
       (segment2) => obstacles.every(
-        (obstacle) => obstacleBelongsToItem(obstacle, item) || distanceSegmentToObstacle(segment2, obstacle) >= requiredObstacleDistance - EPSILON8
+        (obstacle) => obstacleBelongsToItem(obstacle, item) || distanceSegmentToObstacle(segment2, obstacle) >= requiredObstacleDistance - EPSILON9
       )
     ) && segments.every(
       (segment2) => acceptedSegments.every(
@@ -26302,7 +26789,7 @@ function* routeDirectionGroupSteps(params) {
           segment2.end,
           acceptedSegment.start,
           acceptedSegment.end
-        ) >= requiredRouteDistance - EPSILON8
+        ) >= requiredRouteDistance - EPSILON9
       )
     );
   };
@@ -26392,7 +26879,7 @@ function* routeDirectionGroupSteps(params) {
               segment2.end,
               otherSegment.start,
               otherSegment.end
-            ) >= requiredRouteDistance - EPSILON8
+            ) >= requiredRouteDistance - EPSILON9
           )
         )
       );
@@ -26460,7 +26947,7 @@ function* routeDirectionGroupSteps(params) {
           const node = row * columnCount + column;
           if (!freeNodes[node] || terminalNodes.has(node)) continue;
           const point6 = pointForNode(node);
-          if (distanceSegmentToSegment(segment2.start, segment2.end, point6, point6) < requiredRouteDistance - EPSILON8) {
+          if (distanceSegmentToSegment(segment2.start, segment2.end, point6, point6) < requiredRouteDistance - EPSILON9) {
             freeNodes[node] = 0;
           }
         }
@@ -26680,7 +27167,7 @@ function buildPlan3(route, traceWidth) {
 function getConnectorVariants2(start, end) {
   const first = connectWith45DegreeSegments(start, end);
   const second = connectWith45DegreeSegments(end, start).reverse();
-  return first.length === second.length && first.every((point6, index) => distance9(point6, second[index]) < EPSILON8) ? [first] : [first, second];
+  return first.length === second.length && first.every((point6, index) => distance9(point6, second[index]) < EPSILON9) ? [first] : [first, second];
 }
 function plansHaveRequiredClearance(params) {
   const { plans, items, obstacles, traceWidth, clearance } = params;
@@ -26707,7 +27194,7 @@ function plansHaveRequiredClearance(params) {
   for (const [netKey, segments] of uniqueSegmentsByNet) {
     for (const segment2 of segments) {
       for (const obstacle of obstacles) {
-        if (obstacle.connectedTo.includes(netKey) || distanceSegmentToObstacle(segment2, obstacle) >= requiredObstacleDistance - EPSILON8) {
+        if (obstacle.connectedTo.includes(netKey) || distanceSegmentToObstacle(segment2, obstacle) >= requiredObstacleDistance - EPSILON9) {
           continue;
         }
         if (FANOUT_FLOW_DEBUG_ENABLED) {
@@ -26734,7 +27221,7 @@ function plansHaveRequiredClearance(params) {
             first.end,
             second.start,
             second.end
-          ) < requiredRouteDistance - EPSILON8) {
+          ) < requiredRouteDistance - EPSILON9) {
             if (FANOUT_FLOW_DEBUG_ENABLED) {
               console.error("single-layer routes violate copper clearance", {
                 firstNetKey: entries[firstIndex][0],
@@ -26759,10 +27246,10 @@ function plansHaveRequiredClearance(params) {
   return true;
 }
 function getDirectionForBoundaryPoint(point6, boundary) {
-  if (Math.abs(point6.x - boundary.minX) < EPSILON8) return "left";
-  if (Math.abs(point6.x - boundary.maxX) < EPSILON8) return "right";
-  if (Math.abs(point6.y - boundary.minY) < EPSILON8) return "down";
-  if (Math.abs(point6.y - boundary.maxY) < EPSILON8) return "up";
+  if (Math.abs(point6.x - boundary.minX) < EPSILON9) return "left";
+  if (Math.abs(point6.x - boundary.maxX) < EPSILON9) return "right";
+  if (Math.abs(point6.y - boundary.minY) < EPSILON9) return "down";
+  if (Math.abs(point6.y - boundary.maxY) < EPSILON9) return "up";
   return null;
 }
 function* routeWithAdaptiveExitsSteps(params) {
@@ -26852,7 +27339,7 @@ function* routeWithAdaptiveExitsSteps(params) {
         const connectorSegments = getSegments2(connectorPoints, traceWidth);
         const clearsObstacles = connectorSegments.every(
           (segment2) => obstacles.every(
-            (obstacle) => obstacleBelongsToItem(obstacle, mergeItem) || distanceSegmentToObstacle(segment2, obstacle) >= requiredObstacleDistance - EPSILON8
+            (obstacle) => obstacleBelongsToItem(obstacle, mergeItem) || distanceSegmentToObstacle(segment2, obstacle) >= requiredObstacleDistance - EPSILON9
           )
         );
         const clearsRoutes = connectorSegments.every(
@@ -26863,7 +27350,7 @@ function* routeWithAdaptiveExitsSteps(params) {
                 segment2.end,
                 otherSegment.start,
                 otherSegment.end
-              ) >= requiredRouteDistance - EPSILON8
+              ) >= requiredRouteDistance - EPSILON9
             )
           )
         );
@@ -27938,10 +28425,62 @@ function routeSingleLayerWithPushAndShove(params) {
   return paths.map(buildPlan4);
 }
 
+// node_modules/@tscircuit/fanout-solver/lib/runtime-process.ts
+var getRuntimeProcess = (runtime) => runtime.process ?? { env: {} };
+
+// node_modules/@tscircuit/fanout-solver/lib/shorten-bus-plans.ts
+function shortenBusPlans(params) {
+  const { bus } = params;
+  let plans = [...params.plans];
+  if (bus.maxLengthSkew === void 0) return plans;
+  const busPlans = plans.filter((plan) => plan.busId === bus.busId).toSorted((first, second) => second.length - first.length);
+  for (const plan of busPlans) {
+    const minimumLength = Math.min(
+      ...plans.filter((p) => p.busId === bus.busId).map((p) => p.length)
+    );
+    if (plan.length - minimumLength <= bus.maxLengthSkew) continue;
+    if (!plan.via || plan.additionalVias?.length || plan.planeEndpointVia || plan.segments.filter((segment2) => segment2.layer === plan.sourceLayer).length !== 1)
+      continue;
+    const connection = bus.connections.find(
+      (c) => c.connectionIndex === plan.connectionIndex
+    );
+    for (const alignGridToPads of [true, false]) {
+      const candidate = routeViaMinimalWinding({
+        ...params,
+        bus: {
+          ...bus,
+          connections: [connection],
+          routableEscapeLayers: [plan.targetLayer]
+        },
+        terminals: [
+          { connection, viaPoint: plan.via.center, exitPoint: plan.exitPoint }
+        ],
+        targetLayer: plan.targetLayer,
+        acceptedPlans: plans.filter((p) => p !== plan),
+        allowBlindAndBuriedVias: false,
+        gridStepDivisor: 2,
+        alignGridToPads,
+        maximumRouteOrderAttempts: 1
+      })?.[0];
+      if (!candidate || candidate.length >= plan.length - 1e-6) continue;
+      const nextPlans = plans.map((p) => p === plan ? candidate : p);
+      if (!fanoutPlansAreClear({
+        ...params,
+        plans: nextPlans,
+        allowBlindAndBuriedVias: false
+      }))
+        continue;
+      plans = nextPlans;
+      break;
+    }
+  }
+  return plans;
+}
+
 // node_modules/@tscircuit/fanout-solver/lib/validate-fanout-solution.ts
-var EPSILON9 = 1e-6;
+var EPSILON10 = 1e-6;
 function pointsMatch3(first, second) {
-  return distance9(first, second) <= EPSILON9;
+  return distance9(first, second) <= EPSILON10;
 }
 function getPointLayers3(point6) {
   return "layer" in point6 ? [point6.layer] : point6.layers;
@@ -27960,26 +28499,26 @@ function connectionPointsMatch(first, second) {
   return pointsMatch3(first, second) && getPointLayers3(first).join("\0") === getPointLayers3(second).join("\0") && first.pointId === second.pointId && first.pcb_port_id === second.pcb_port_id;
 }
 function pointIsOnBoundary(point6, boundary) {
-  const inside = point6.x >= boundary.minX - EPSILON9 && point6.x <= boundary.maxX + EPSILON9 && point6.y >= boundary.minY - EPSILON9 && point6.y <= boundary.maxY + EPSILON9;
-  const onEdge = Math.abs(point6.x - boundary.minX) <= EPSILON9 || Math.abs(point6.x - boundary.maxX) <= EPSILON9 || Math.abs(point6.y - boundary.minY) <= EPSILON9 || Math.abs(point6.y - boundary.maxY) <= EPSILON9;
+  const inside = point6.x >= boundary.minX - EPSILON10 && point6.x <= boundary.maxX + EPSILON10 && point6.y >= boundary.minY - EPSILON10 && point6.y <= boundary.maxY + EPSILON10;
+  const onEdge = Math.abs(point6.x - boundary.minX) <= EPSILON10 || Math.abs(point6.x - boundary.maxX) <= EPSILON10 || Math.abs(point6.y - boundary.minY) <= EPSILON10 || Math.abs(point6.y - boundary.maxY) <= EPSILON10;
   return inside && onEdge;
 }
 function pointIsOnBoundaryEdge(point6, edge, boundary) {
-  const inside = point6.x >= boundary.minX - EPSILON9 && point6.x <= boundary.maxX + EPSILON9 && point6.y >= boundary.minY - EPSILON9 && point6.y <= boundary.maxY + EPSILON9;
+  const inside = point6.x >= boundary.minX - EPSILON10 && point6.x <= boundary.maxX + EPSILON10 && point6.y >= boundary.minY - EPSILON10 && point6.y <= boundary.maxY + EPSILON10;
   if (!inside) return false;
   switch (edge) {
     case "left":
-      return Math.abs(point6.x - boundary.minX) <= EPSILON9;
+      return Math.abs(point6.x - boundary.minX) <= EPSILON10;
     case "right":
-      return Math.abs(point6.x - boundary.maxX) <= EPSILON9;
+      return Math.abs(point6.x - boundary.maxX) <= EPSILON10;
     case "top":
-      return Math.abs(point6.y - boundary.maxY) <= EPSILON9;
+      return Math.abs(point6.y - boundary.maxY) <= EPSILON10;
     case "bottom":
-      return Math.abs(point6.y - boundary.minY) <= EPSILON9;
+      return Math.abs(point6.y - boundary.minY) <= EPSILON10;
   }
 }
 function pointIsInsideBounds3(point6, bounds) {
-  return point6.x >= bounds.minX - EPSILON9 && point6.x <= bounds.maxX + EPSILON9 && point6.y >= bounds.minY - EPSILON9 && point6.y <= bounds.maxY + EPSILON9;
+  return point6.x >= bounds.minX - EPSILON10 && point6.x <= bounds.maxX + EPSILON10 && point6.y >= bounds.minY - EPSILON10 && point6.y <= bounds.maxY + EPSILON10;
 }
 function addIssue2(issues, code, message, plan, otherConnectionName) {
   issues.push({
@@ -28112,7 +28651,7 @@ function validatePlanStructure(params) {
     );
   }
   const isAllowedViaInPadPlaneTermination = inputSrj.allowViaInPad === true && plan.termination.type === "plane" && plan.via !== void 0 && pointsMatch3(plan.via.center, plan.sourcePoint) && pointsMatch3(plan.exitPoint, plan.sourcePoint);
-  if (!isAllowedViaInPadPlaneTermination && (plan.segments.length === 0 || plan.length <= EPSILON9)) {
+  if (!isAllowedViaInPadPlaneTermination && (plan.segments.length === 0 || plan.length <= EPSILON10)) {
     addIssue2(
       issues,
       "not-broken-out",
@@ -28195,7 +28734,7 @@ function validatePlanStructure(params) {
   });
   if (traceSegments.length !== plan.segments.length || traceSegments.some((segment2, index) => {
     const declared = plan.segments[index];
-    return !declared || segment2.layer !== declared.layer || Math.abs(segment2.width - declared.width) > EPSILON9 || !pointsMatch3(segment2.start, declared.start) || !pointsMatch3(segment2.end, declared.end);
+    return !declared || segment2.layer !== declared.layer || Math.abs(segment2.width - declared.width) > EPSILON10 || !pointsMatch3(segment2.start, declared.start) || !pointsMatch3(segment2.end, declared.end);
   })) {
     addIssue2(
       issues,
@@ -28220,8 +28759,8 @@ function validatePlanStructure(params) {
       });
       if (endpointSegments.length !== plan.planeEndpointSegments.length || endpointSegments.some((segment2, index) => {
         const declared = plan.planeEndpointSegments?.[index];
-        return !declared || segment2.layer !== declared.layer || Math.abs(segment2.width - declared.width) > EPSILON9 || !pointsMatch3(segment2.start, declared.start) || !pointsMatch3(segment2.end, declared.end);
-      }) || distance9(plan.planeEndpointVia.center, plan.targetPoint) <= EPSILON9) {
+        return !declared || segment2.layer !== declared.layer || Math.abs(segment2.width - declared.width) > EPSILON10 || !pointsMatch3(segment2.start, declared.start) || !pointsMatch3(segment2.end, declared.end);
+      }) || distance9(plan.planeEndpointVia.center, plan.targetPoint) <= EPSILON10) {
         addIssue2(
           issues,
           "trace-plan-mismatch",
@@ -28301,7 +28840,7 @@ function plansHaveConnectedCopper(first, second) {
         firstSegment.end,
         secondSegment.start,
         secondSegment.end
-      ) <= (firstSegment.width + secondSegment.width) / 2 + EPSILON9) {
+      ) <= (firstSegment.width + secondSegment.width) / 2 + EPSILON10) {
         return true;
       }
     }
@@ -28310,7 +28849,7 @@ function plansHaveConnectedCopper(first, second) {
         secondVia.center,
         firstSegment.start,
         firstSegment.end
-      ) <= secondVia.diameter / 2 + firstSegment.width / 2 + EPSILON9) {
+      ) <= secondVia.diameter / 2 + firstSegment.width / 2 + EPSILON10) {
         return true;
       }
     }
@@ -28321,14 +28860,14 @@ function plansHaveConnectedCopper(first, second) {
         firstVia.center,
         secondSegment.start,
         secondSegment.end
-      ) <= firstVia.diameter / 2 + secondSegment.width / 2 + EPSILON9) {
+      ) <= firstVia.diameter / 2 + secondSegment.width / 2 + EPSILON10) {
         return true;
       }
     }
     for (const secondVia of secondVias) {
       if (firstVia.spanLayers.some(
         (layer) => secondVia.spanLayers.includes(layer)
-      ) && distance9(firstVia.center, secondVia.center) <= (firstVia.diameter + secondVia.diameter) / 2 + EPSILON9) {
+      ) && distance9(firstVia.center, secondVia.center) <= (firstVia.diameter + secondVia.diameter) / 2 + EPSILON10) {
         return true;
       }
     }
@@ -29037,6 +29576,7 @@ function visualizeSimpleRouteJson(srj) {
 }
 
 // node_modules/@tscircuit/fanout-solver/lib/fanout-solver.ts
+var process = getRuntimeProcess(globalThis);
 var FanoutWorkSolver = class extends BaseSolver {
   constructor(solverName, generator, getVisualization, getStats, getProgress) {
     super();
@@ -29626,7 +30166,10 @@ var FanoutSolver = class extends BaseSolver {
           buses: this.preparedBuses,
           escapeLayers: this.config.escapeLayers,
           escapeLayersByBusId: this.escapeLayersByBusId,
-          preferOrderedCoordinatedWindingLayers: this.config.densePlaneReservationBusIds.length > 0 || this.config.denseUnrestrictedPlaneRoutingBusIds.length > 0
+          preferOrderedCoordinatedWindingLayers: this.config.densePlaneReservationBusIds.length > 0 || this.config.denseUnrestrictedPlaneRoutingBusIds.length > 0 || shouldUseAdaptiveDensePlaneRouting(
+            this.preparedBuses,
+            this.config.allowBlindAndBuriedVias
+          )
         }),
         generatedAssignments,
         maxAssignments: this.config.maxLayerCombinations
@@ -29915,6 +30458,8 @@ var FanoutSolver = class extends BaseSolver {
           "plane-match:incremental-failed",
           "plane-route:alternate-candidate-counts",
           "plane-route:alternate-search",
+          "plane-route:csp",
+          "plane-reservation-core",
           "plane-route:promote-failed",
           "plane-route:alternate-choice",
           "plane-route:promote-zero-candidates",
@@ -29931,7 +30476,13 @@ var FanoutSolver = class extends BaseSolver {
     const unsortedBoundaryBuses = params.busesInRoutingOrder.filter(
       (bus) => bus.termination.type === "boundary"
     );
-    const useConfiguredDensePlaneRouting = this.config.densePlaneReservationBusIds.length > 0 || this.config.denseUnrestrictedPlaneRoutingBusIds.length > 0;
+    const configuredDensePlaneRouting = this.config.densePlaneReservationBusIds.length > 0 || this.config.denseUnrestrictedPlaneRoutingBusIds.length > 0;
+    const useAdaptiveDensePlaneRouting = !configuredDensePlaneRouting && shouldUseAdaptiveDensePlaneRouting(
+      this.preparedBuses,
+      this.config.allowBlindAndBuriedVias
+    );
+    const useConfiguredDensePlaneRouting = configuredDensePlaneRouting || useAdaptiveDensePlaneRouting;
+    const useAdaptiveJointPlaneSelection = useAdaptiveDensePlaneRouting && (params.planeReservationRetryCount ?? 0) === 0;
     const matchLengthsAfterPlanes = useConfiguredDensePlaneRouting && params.lengthMatchingStage !== "before-planes";
     const useJointBoundaryViaReservation = shouldUseJointBoundaryViaReservation(
       unsortedBoundaryBuses.map((bus) => bus.connections.length)
@@ -30078,6 +30629,17 @@ var FanoutSolver = class extends BaseSolver {
       0,
       Number.isFinite(initialPlaneReservationCount) ? initialPlaneReservationCount : 8
     ) : planeBuses;
+    if (params.promotedPlaneReservationBusIds) {
+      activeBoundaryReservationPlaneBuses = [
+        .../* @__PURE__ */ new Set([
+          ...activeBoundaryReservationPlaneBuses,
+          ...planeBuses.filter(
+            (bus) => params.promotedPlaneReservationBusIds.includes(bus.busId)
+          )
+        ])
+      ];
+    }
+    const unroutablePlaneBusIds = /* @__PURE__ */ new Set();
     debugDense(
       "start",
       boundaryBuses.map((bus) => `${bus.busId}:${bus.connections.length}`),
@@ -30110,7 +30672,7 @@ var FanoutSolver = class extends BaseSolver {
     const preferBoundaryOutwardByBusId = new Map(
       boundaryBuses.map((bus) => [
         bus.busId,
-        bus.connections.length === 1 ? hasThreeWideBoundaryBuses && narrowBusIsEmbeddedInWideSourceField(bus) ? true : useGeometryAwareSingletonOutwardPreference && getCornerBandSide(bus.exitEdge, bus.preferredExit) ? getDenseSingletonBoundaryGeometry(bus).targetProjection > 0 : getExitEdgeForDirection(bus.direction) !== bus.exitEdge : bus.exitEdge === "top" && bus.connections.length >= 8 ? false : getExitEdgeForDirection(bus.direction) !== bus.exitEdge
+        bus.connections.length === 1 ? hasThreeWideBoundaryBuses && narrowBusIsEmbeddedInWideSourceField(bus) ? true : useGeometryAwareSingletonOutwardPreference && getCornerBandSide(bus.exitEdge, bus.preferredExit) ? getDenseSingletonBoundaryGeometry(bus).targetProjection > 0 : getExitEdgeForDirection(bus.direction) !== bus.exitEdge : hasThreeWideBoundaryBuses && bus.connections.length >= 8 ? false : getExitEdgeForDirection(bus.direction) !== bus.exitEdge
       ])
     );
     for (const bus of wideBoundaryBuses) {
@@ -30392,6 +30954,14 @@ var FanoutSolver = class extends BaseSolver {
             return [
               {
                 connectionName: connection.connection.name,
+                sourceEscapeSegment: matchedPlans.some(
+                  (plan) => plan.connectionIndex === connection.connectionIndex
+                ) ? void 0 : {
+                  start: connection.sourcePoint,
+                  end: center,
+                  layer: connection.sourceLayer,
+                  width: this.config.traceWidth
+                },
                 via: {
                   center,
                   diameter: this.config.viaDiameter,
@@ -30446,7 +31016,7 @@ var FanoutSolver = class extends BaseSolver {
           fixedViaPointsByConnectionIndex,
           reservedVias: getReservedVias(bus),
           viaMinimalOnly: process.env.FANOUT_DEBUG_ALLOW_EXTRA_VIAS !== "1",
-          allowBoundarySideViaFallback: true,
+          allowBoundarySideViaFallback: bus.connections.length === 1,
           preferCornerBoundaryVia: useConfiguredDensePlaneRouting,
           adaptiveWindingRouteOrder,
           alignWindingGridToPads: usePadAlignedDenseRouting && !useConfiguredDensePlaneRouting,
@@ -30557,7 +31127,21 @@ var FanoutSolver = class extends BaseSolver {
             ))[0];
             if (busPlans) break;
           }
-          if (!busPlans) fixedViaPointsByConnectionIndex = originalPoints;
+          if (!busPlans) {
+            fixedViaPointsByConnectionIndex = originalPoints;
+            if (bus.connections.length === 2) {
+              busPlans = (yield* routeAlternatives(
+                {
+                  ...routeParams,
+                  fixedViaPointsByConnectionIndex: originalPoints,
+                  reservedVias: getReservedVias(bus),
+                  allowBoundarySideViaFallback: true,
+                  fixedViaFallbackRouteOrderAttempts: 1
+                },
+                1
+              ))[0];
+            }
+          }
         }
         if (busPlans && bus.maxLengthSkew !== void 0) {
           const lengths = busPlans.map((plan) => plan.length);
@@ -31162,6 +31746,73 @@ var FanoutSolver = class extends BaseSolver {
                     }))
                   })
                 );
+                if (useAdaptiveJointPlaneSelection) {
+                  const acceptedPlans = [
+                    ...candidatePlans,
+                    ...feasibleAlternatePlanePlans
+                  ];
+                  for (const planeBus of planeBuses) {
+                    if (matchedPlaneBuses.includes(planeBus) || candidateSets.some((set) => set.planeBus === planeBus))
+                      continue;
+                    const candidates = [];
+                    const sites = getComponentDogboneViaSiteCandidates(
+                      [planeBus],
+                      {
+                        viaDiameter: this.config.viaDiameter,
+                        viaHoleDiameter: this.config.viaHoleDiameter,
+                        traceWidth: this.config.traceWidth,
+                        clearance: this.config.clearance,
+                        blockingSegments: acceptedPlans.flatMap(
+                          (plan) => plan.segments.map((segment2) => ({
+                            connectionIndex: plan.connectionIndex,
+                            segment: segment2
+                          }))
+                        ),
+                        blockingVias: acceptedPlans.flatMap(
+                          (plan) => [
+                            plan.via,
+                            ...plan.additionalVias ?? [],
+                            plan.planeEndpointVia
+                          ].filter((via) => via !== void 0).map((via) => ({
+                            connectionIndex: plan.connectionIndex,
+                            center: via.center,
+                            diameter: via.diameter,
+                            spanLayers: via.spanLayers
+                          }))
+                        ),
+                        additionalObstacles: this.routingSrj.obstacles,
+                        preferPlaneCheckerboardSites: true,
+                        canShareCopper
+                      }
+                    );
+                    for (const site of sites) {
+                      const plans = routeBus({
+                        srj: this.routingSrj,
+                        bus: planeBus,
+                        targetLayer: params.busLayerAssignments[planeBus.busId],
+                        acceptedPlans,
+                        layerNames: this.config.layerNames,
+                        traceWidth: this.config.traceWidth,
+                        viaDiameter: this.config.viaDiameter,
+                        viaHoleDiameter: this.config.viaHoleDiameter,
+                        clearance: this.config.clearance,
+                        compactBusTracks: this.config.compactBusTracks,
+                        allowBlindAndBuriedVias: false,
+                        allowSameNetMerges: this.config.allowSameNetMerges,
+                        fixedViaPointsByConnectionIndex: /* @__PURE__ */ new Map([
+                          [site.connectionIndex, site.point]
+                        ])
+                      });
+                      if (plans)
+                        candidates.push({
+                          key: `${planeBus.busId}:local:${candidates.length}`,
+                          planeBus,
+                          plans
+                        });
+                    }
+                    candidateSets.push({ planeBus, candidates });
+                  }
+                }
                 debugDense(
                   "plane-route:alternate-candidate-counts",
                   candidateSets.map((candidateSet) => [
@@ -31169,6 +31820,10 @@ var FanoutSolver = class extends BaseSolver {
                     candidateSet.candidates.length
                   ])
                 );
+                for (const candidateSet of candidateSets) {
+                  if (candidateSet.candidates.length === 0)
+                    unroutablePlaneBusIds.add(candidateSet.planeBus.busId);
+                }
                 const compatibilityByCandidatePair = /* @__PURE__ */ new Map();
                 const candidatesAreCompatible = (first, second) => {
                   const cacheKey = [first.key, second.key].toSorted().join("|");
@@ -31261,10 +31916,70 @@ var FanoutSolver = class extends BaseSolver {
                   );
                   return null;
                 };
-                const selectedCandidates = selectCompatiblePlaneRoutes(
-                  candidateSets,
-                  []
-                );
+                let selectedCandidates;
+                if (useAdaptiveDensePlaneRouting) {
+                  const getUniqueDomains = (sets) => sets.map((set) => [
+                    ...new Map(
+                      set.candidates.map((candidate) => [
+                        JSON.stringify(
+                          candidate.plans.map((plan) => [
+                            plan.segments,
+                            plan.via,
+                            plan.additionalVias,
+                            plan.planeEndpointSegments,
+                            plan.planeEndpointVia
+                          ])
+                        ),
+                        candidate
+                      ])
+                    ).values()
+                  ]);
+                  const runCandidateSelection = (sets, maximumSearchStates = maximumAlternatePlaneSearchStates) => selectCompatibleCandidates({
+                    candidateSets: getUniqueDomains(sets),
+                    maximumSearchStates,
+                    areCompatible: (first, second) => fanoutPlansAreMutuallyClear({
+                      plans: [...first.plans, ...second.plans],
+                      srj: this.routingSrj,
+                      clearance: this.config.clearance,
+                      allowSameNetMerges: this.config.allowSameNetMerges
+                    })
+                  });
+                  const result = runCandidateSelection(candidateSets);
+                  debugDense(
+                    "plane-route:csp",
+                    result.selection ? "complete" : "failed",
+                    result.searchStates,
+                    result.emptyDomainIndices.map(
+                      (index) => candidateSets[index].planeBus.busId
+                    )
+                  );
+                  selectedCandidates = result.selection;
+                  alternatePlaneSearchStates = result.searchStates;
+                  if (!result.selection && useAdaptiveDensePlaneRouting) {
+                    const expanded = result.emptyDomainIndices.map((index) => candidateSets[index].planeBus.busId).filter(
+                      (id) => !orderedAlternatePlaneBuses.some(
+                        (bus) => bus.busId === id
+                      )
+                    );
+                    if (expanded.length > 0) {
+                      debugDense("plane-route:expand-domains", expanded);
+                      return matchViaPointsAroundPlans(
+                        candidatePlans,
+                        /* @__PURE__ */ new Set([...promotedAlternatePlaneBusIds, ...expanded])
+                      );
+                    }
+                  }
+                  if (!result.selection)
+                    for (const index of (params.planeReservationRetryCount ?? 0) === 0 ? result.conflictDomainIndices : result.emptyDomainIndices.slice(0, 1))
+                      unroutablePlaneBusIds.add(
+                        candidateSets[index].planeBus.busId
+                      );
+                } else {
+                  selectedCandidates = selectCompatiblePlaneRoutes(
+                    candidateSets,
+                    []
+                  );
+                }
                 alternatePlanePlans = selectedCandidates ? [
                   ...feasibleAlternatePlanePlans,
                   ...selectedCandidates.flatMap(
@@ -31288,6 +32003,15 @@ var FanoutSolver = class extends BaseSolver {
               );
               if (!alternatePlanePlans) return null;
               feasibleAlternatePlanePlans = alternatePlanePlans;
+              if (useAdaptiveJointPlaneSelection) {
+                matchedPlaneBusesInRoutingOrder = [];
+                return new Map([
+                  ...fixedBoundaryViaPoints,
+                  ...alternatePlanePlans.filter((plan) => plan.via).map(
+                    (plan) => [plan.connectionIndex, plan.via.center]
+                  )
+                ]);
+              }
             }
             let planeBusIdsRoutedWithoutDogbones = /* @__PURE__ */ new Set();
             let allBlockingSegments = [...blockingSegments];
@@ -31679,6 +32403,30 @@ var FanoutSolver = class extends BaseSolver {
         return { plans: matchedPlans, failedBusIds: [] };
       }
     }
+    if (useAdaptiveDensePlaneRouting && unroutablePlaneBusIds.size > 0 && (params.planeReservationRetryCount ?? 0) < 5) {
+      const newlyPromoted = [...unroutablePlaneBusIds].filter(
+        (id) => !activeBoundaryReservationPlaneBuses.some((bus) => bus.busId === id)
+      );
+      const refinedPromotions = (params.planeReservationRetryCount ?? 0) === 0 ? refineAdaptivePlaneReservationCore({
+        candidateBusIds: newlyPromoted,
+        activeBusIds: new Set(
+          activeBoundaryReservationPlaneBuses.map((bus) => bus.busId)
+        ),
+        planeBuses
+      }) : newlyPromoted;
+      if (refinedPromotions.length > 0) {
+        debugDense("plane-reservation-core", refinedPromotions);
+        debugDense("promote-reservations", refinedPromotions);
+        return yield* this.routeDenseThroughAllMixedTerminationSteps({
+          ...params,
+          promotedPlaneReservationBusIds: [
+            ...params.promotedPlaneReservationBusIds ?? [],
+            ...refinedPromotions
+          ],
+          planeReservationRetryCount: (params.planeReservationRetryCount ?? 0) + 1
+        });
+      }
+    }
     if (matchLengthsAfterPlanes) {
       return yield* this.routeDenseThroughAllMixedTerminationSteps({
         ...params,
@@ -45341,7 +46089,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1831",
+  version: "0.0.1833",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -45381,7 +46129,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.54",
+    "@tscircuit/fanout-solver": "0.0.56",
     "@tscircuit/footprinter": "^0.0.426",
     "@tscircuit/image-utils": "^0.0.8",
     "@tscircuit/implicit-copper-pour-solver": "github:tscircuit/implicit-copper-pour-solver#d880f80e4eb7a34d5da5a521f10a63c810d4728b",
@@ -50235,15 +50983,15 @@ import {
 } from "@tscircuit/copper-pour-solver";
 
 // lib/components/primitive-components/CopperPour/utils/mark-trace-segments-inside-copper-pour.ts
-var EPSILON10 = 1e-9;
+var EPSILON11 = 1e-9;
 var isWireRoutePoint = (routePoint) => routePoint.route_type === "wire";
 var isPointOnSegment = (p, a, b) => {
   const cross3 = (p.y - a.y) * (b.x - a.x) - (p.x - a.x) * (b.y - a.y);
-  if (Math.abs(cross3) > EPSILON10) return false;
+  if (Math.abs(cross3) > EPSILON11) return false;
   const dot = (p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y);
-  if (dot < -EPSILON10) return false;
+  if (dot < -EPSILON11) return false;
   const squaredLength = (b.x - a.x) ** 2 + (b.y - a.y) ** 2;
-  if (dot - squaredLength > EPSILON10) return false;
+  if (dot - squaredLength > EPSILON11) return false;
   return true;
 };
 var isPointInRing = (point6, ring) => {
@@ -50267,7 +51015,7 @@ var isPointInRectPour = (p, pour) => {
   const dy = p.y - center.y;
   const localX = dx * cosR - dy * sinR;
   const localY = dx * sinR + dy * cosR;
-  return Math.abs(localX) <= width / 2 + EPSILON10 && Math.abs(localY) <= height / 2 + EPSILON10;
+  return Math.abs(localX) <= width / 2 + EPSILON11 && Math.abs(localY) <= height / 2 + EPSILON11;
 };
 var isPointInBrepPour = (p, pour) => {
   const outerRing = pour.brep_shape.outer_ring.vertices.map((v) => ({
@@ -50301,7 +51049,7 @@ var isSegmentFullyInsideCopperPour = (start, end, pour) => {
   const dx = end.x - start.x;
   const dy = end.y - start.y;
   const length7 = Math.hypot(dx, dy);
-  if (length7 <= EPSILON10) return false;
+  if (length7 <= EPSILON11) return false;
   const samples = [0, 0.25, 0.5, 0.75, 1];
   return samples.every(
     (t) => isPointInCopperPour(