@tscircuit/core 0.0.2024 → 0.0.2026

package/dist/index.js

@@ -3280,10 +3280,70 @@ var getAxisAlignedRectFromPolygon = (points) => {
   };
 };
 
+// lib/utils/obstacles/getCircumscribedRectFromCircularPcbKeepoutOutline.ts
+var MINIMUM_CIRCULAR_OUTLINE_POINT_COUNT = 12;
+var MINIMUM_CIRCULAR_OUTLINE_ASPECT_RATIO = 0.99;
+var MAXIMUM_RADIUS_VARIATION_RATIO = 1e-3;
+var getCircumscribedRectFromCircularPcbKeepoutOutline = (keepout) => {
+  const { outline, stroke_width } = keepout;
+  const firstPoint = outline[0];
+  const lastPoint = outline.at(-1);
+  if (!firstPoint || !lastPoint) return null;
+  if (firstPoint.x !== lastPoint.x || firstPoint.y !== lastPoint.y) return null;
+  const centerlinePoints = outline.slice(0, -1);
+  if (centerlinePoints.length < MINIMUM_CIRCULAR_OUTLINE_POINT_COUNT)
+    return null;
+  const minX = Math.min(...centerlinePoints.map(({ x }) => x));
+  const maxX = Math.max(...centerlinePoints.map(({ x }) => x));
+  const minY = Math.min(...centerlinePoints.map(({ y }) => y));
+  const maxY = Math.max(...centerlinePoints.map(({ y }) => y));
+  const centerlineWidth = maxX - minX;
+  const centerlineHeight = maxY - minY;
+  const centerlineDiameter = Math.max(centerlineWidth, centerlineHeight);
+  if (!Number.isFinite(centerlineDiameter) || centerlineDiameter <= 0 || Math.min(centerlineWidth, centerlineHeight) / centerlineDiameter < MINIMUM_CIRCULAR_OUTLINE_ASPECT_RATIO) {
+    return null;
+  }
+  const center = { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+  const radii = centerlinePoints.map(
+    ({ x, y }) => Math.hypot(x - center.x, y - center.y)
+  );
+  if (Math.max(...radii) - Math.min(...radii) > centerlineDiameter * MAXIMUM_RADIUS_VARIATION_RATIO) {
+    return null;
+  }
+  const angles = centerlinePoints.map(
+    ({ x, y }) => Math.atan2(y - center.y, x - center.x)
+  );
+  const angularSteps = angles.map((angle, angleIndex) => {
+    const nextAngle = angles[(angleIndex + 1) % angles.length];
+    return Math.atan2(Math.sin(nextAngle - angle), Math.cos(nextAngle - angle));
+  });
+  const traversalDirection = Math.sign(angularSteps[0]);
+  if (traversalDirection === 0 || angularSteps.some(
+    (angularStep) => Math.sign(angularStep) !== traversalDirection || Math.abs(angularStep) > 4 * Math.PI / centerlinePoints.length
+  )) {
+    return null;
+  }
+  const outerDiameter = centerlineDiameter + stroke_width;
+  return { center, width: outerDiameter, height: outerDiameter };
+};
+
 // lib/utils/obstacles/getObstaclesFromPcbKeepoutOutline.ts
 var getObstaclesFromPcbKeepoutOutline = (keepout, componentId) => {
   const { outline, stroke_width } = keepout;
   if (!Number.isFinite(stroke_width) || stroke_width <= 0) return [];
+  const circularKeepoutRect = getCircumscribedRectFromCircularPcbKeepoutOutline(keepout);
+  if (circularKeepoutRect) {
+    return [
+      {
+        obstacleId: keepout.pcb_keepout_id,
+        componentId,
+        type: "rect",
+        layers: keepout.layers,
+        ...circularKeepoutRect,
+        connectedTo: []
+      }
+    ];
+  }
   const obstacles = [];
   for (let segmentIndex = 0; segmentIndex < outline.length - 1; segmentIndex++) {
     const start = outline[segmentIndex];
@@ -3548,8 +3608,7 @@ var getObstaclesFromCircuitJson = (circuitJson, connMap) => {
       if (element.shape === "circle") {
         obstacles.push({
           componentId: pcbComponentId,
-          // @ts-ignore
-          type: "oval",
+          type: "rect",
           layers: element.layers,
           center: {
             x: element.center.x,
@@ -6218,10 +6277,10 @@ function addTraceTeardrops(route, contacts) {
       result.push(start);
       continue;
     }
-    const atDistance = (distance23) => ({
+    const atDistance = (distance25) => ({
       route_type: "wire",
-      x: start.x + (end.x - start.x) * distance23 / length8,
-      y: start.y + (end.y - start.y) * distance23 / length8,
+      x: start.x + (end.x - start.x) * distance25 / length8,
+      y: start.y + (end.y - start.y) * distance25 / length8,
       width: start.width,
       layer: start.layer
     });
@@ -6744,11 +6803,11 @@ function Trace_doInitialPcbTraceRender(trace) {
       const closestNetBPort = getClosest(netAPort, netBPorts);
       const netAPortPosition = netAPort._getGlobalPcbPositionBeforeLayout();
       const netBPortPosition = closestNetBPort._getGlobalPcbPositionBeforeLayout();
-      const distance23 = Math.sqrt(
+      const distance25 = Math.sqrt(
         (netAPortPosition.x - netBPortPosition.x) ** 2 + (netAPortPosition.y - netBPortPosition.y) ** 2
       );
-      if (distance23 < closestDistance) {
-        closestDistance = distance23;
+      if (distance25 < closestDistance) {
+        closestDistance = distance25;
         closestPortPair = [netAPort, closestNetBPort];
       }
     }
@@ -12959,7 +13018,7 @@ var createComponentsFromCircuitJson = ({
       const schematicSymbolId = schematicComponent?.schematic_symbol_id;
       const parentSymbol = typeof schematicSymbolId === "string" ? schematicSymbolsByImportedId.get(schematicSymbolId) : void 0;
       if (parentSymbol && schematicComponent?.is_box_with_pins === true && elm.center && elm.side_of_component) {
-        const distance23 = elm.distance_from_component_edge;
+        const distance25 = elm.distance_from_component_edge;
         const facingDirection = getFacingDirectionFromSide(
           elm.side_of_component
         );
@@ -12967,8 +13026,8 @@ var createComponentsFromCircuitJson = ({
         const directionVector = getUnitVectorFromDirection2(facingDirection);
         const stemDirection = elm.facing_direction === facingDirection ? 1 : -1;
         const portCenter = {
-          x: elm.center.x + directionVector.x * distance23 * stemDirection,
-          y: elm.center.y + directionVector.y * distance23 * stemDirection
+          x: elm.center.x + directionVector.x * distance25 * stemDirection,
+          y: elm.center.y + directionVector.y * distance25 * stemDirection
         };
         const sourcePort = sourcePortsByImportedId.get(elm.source_port_id);
         const aliases = Array.from(
@@ -17737,15 +17796,15 @@ var Capacitor_addPolarityFabricationSymbols = (capacitor) => {
     source_port_id: negatives[0].source_port_id
   });
   if (!positive || !negative) return;
-  const distance23 = Math.hypot(negative.x - positive.x, negative.y - positive.y);
-  if (distance23 < 1e-6) return;
+  const distance25 = Math.hypot(negative.x - positive.x, negative.y - positive.y);
+  if (distance25 < 1e-6) return;
   const frame = compose7(
     translate5((positive.x + negative.x) / 2, (positive.y + negative.y) / 2),
     rotate4(Math.atan2(negative.y - positive.y, negative.x - positive.x))
   );
   const point6 = (x, y) => applyToPoint26(frame, { x, y });
-  const offset = distance23 / 4;
-  const halfSize = Math.min(distance23 * 0.12, 0.3);
+  const offset = distance25 / 4;
+  const halfSize = Math.min(distance25 * 0.12, 0.3);
   const routes = [
     [point6(-offset - halfSize, 0), point6(-offset + halfSize, 0)],
     [point6(-offset, -halfSize), point6(-offset, halfSize)],
@@ -19570,7 +19629,7 @@ import {
   groupProps
 } from "@tscircuit/props";
 import {
-  distance as distance16
+  distance as distance18
 } from "circuit-json";
 import Debug15 from "debug";
 
@@ -38814,9 +38873,9 @@ function getFreeBoundaryTracks(params) {
   for (const via of vias) {
     if (!via.spanLayers.includes(targetLayer2)) continue;
     const radius = via.diameter / 2 + traceWidth / 2 + clearance;
-    const distance23 = Math.abs(via.center[across] - edge);
-    if (distance23 >= radius) continue;
-    const extent = Math.sqrt(radius * radius - distance23 * distance23);
+    const distance25 = Math.abs(via.center[across] - edge);
+    if (distance25 >= radius) continue;
+    const extent = Math.sqrt(radius * radius - distance25 * distance25);
     blocked.push([via.center[along] - extent, via.center[along] + extent]);
   }
   const gaps = [];
@@ -50507,6 +50566,8 @@ function getPresetAutoroutingConfig(autorouterConfig, platformConfig) {
       };
     case "bus-lanes":
       return { local: true, groupMode: "subcircuit", preset: "bus_lanes" };
+    case "dogbone":
+      return { local: true, groupMode: "subcircuit", preset: "dogbone" };
     case "fanout":
       return {
         local: true,
@@ -50569,11 +50630,1027 @@ function getPresetAutoroutingConfig(autorouterConfig, platformConfig) {
   }
 }
 
-// node_modules/@tscircuit/bus-lanes-solver/lib/bus-lanes-solver.ts
+// node_modules/@tscircuit/dogbone-solver/lib/dogbone-fanout-solver.ts
+import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
+
+// node_modules/@tscircuit/dogbone-solver/node_modules/@tscircuit/fanout-solver/lib/geometry.ts
+var EPSILON24 = 1e-9;
+function obstacleIsCircular2(obstacle) {
+  return obstacle.shape === "circle";
+}
+function toObstacleLocalPoint2(point6, obstacle) {
+  const rotationRadians = -(obstacle.ccwRotationDegrees ?? 0) * Math.PI / 180;
+  const dx = point6.x - obstacle.center.x;
+  const dy = point6.y - obstacle.center.y;
+  return {
+    x: dx * Math.cos(rotationRadians) - dy * Math.sin(rotationRadians),
+    y: dx * Math.sin(rotationRadians) + dy * Math.cos(rotationRadians)
+  };
+}
+function distance12(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function distancePointToSegment2(point6, start, end) {
+  const dx = end.x - start.x;
+  const dy = end.y - start.y;
+  const lengthSquared = dx * dx + dy * dy;
+  const rawT = lengthSquared < EPSILON24 ? 0 : ((point6.x - start.x) * dx + (point6.y - start.y) * dy) / lengthSquared;
+  const t = Math.max(0, Math.min(1, rawT));
+  return Math.hypot(point6.x - (start.x + t * dx), point6.y - (start.y + t * dy));
+}
+function cross2(origin, a, b) {
+  return (a.x - origin.x) * (b.y - origin.y) - (a.y - origin.y) * (b.x - origin.x);
+}
+function segmentsProperlyCross2(a, b, c, d) {
+  const d1 = cross2(c, d, a);
+  const d2 = cross2(c, d, b);
+  const d3 = cross2(a, b, c);
+  const d4 = cross2(a, b, d);
+  return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
+}
+function distanceSegmentToSegment2(firstStart, firstEnd, secondStart, secondEnd) {
+  if (segmentsProperlyCross2(firstStart, firstEnd, secondStart, secondEnd)) {
+    return 0;
+  }
+  return Math.min(
+    distancePointToSegment2(firstStart, secondStart, secondEnd),
+    distancePointToSegment2(firstEnd, secondStart, secondEnd),
+    distancePointToSegment2(secondStart, firstStart, firstEnd),
+    distancePointToSegment2(secondEnd, firstStart, firstEnd)
+  );
+}
+function distancePointToObstacle2(point6, obstacle) {
+  if (obstacleIsCircular2(obstacle)) {
+    return Math.max(0, distance12(point6, obstacle.center) - obstacle.width / 2);
+  }
+  const localPoint = toObstacleLocalPoint2(point6, obstacle);
+  const dx = Math.max(Math.abs(localPoint.x) - obstacle.width / 2, 0);
+  const dy = Math.max(Math.abs(localPoint.y) - obstacle.height / 2, 0);
+  return Math.hypot(dx, dy);
+}
+function distanceSegmentToObstacle2(segment2, obstacle) {
+  if (obstacleIsCircular2(obstacle)) {
+    return Math.max(
+      0,
+      distancePointToSegment2(obstacle.center, segment2.start, segment2.end) - obstacle.width / 2
+    );
+  }
+  const localStart = toObstacleLocalPoint2(segment2.start, obstacle);
+  const localEnd = toObstacleLocalPoint2(segment2.end, obstacle);
+  if (Math.abs(localStart.x) <= obstacle.width / 2 + EPSILON24 && Math.abs(localStart.y) <= obstacle.height / 2 + EPSILON24) {
+    return 0;
+  }
+  if (Math.abs(localEnd.x) <= obstacle.width / 2 + EPSILON24 && Math.abs(localEnd.y) <= obstacle.height / 2 + EPSILON24) {
+    return 0;
+  }
+  const minX = -obstacle.width / 2;
+  const maxX = obstacle.width / 2;
+  const minY = -obstacle.height / 2;
+  const maxY = obstacle.height / 2;
+  const corners = [
+    { x: minX, y: minY },
+    { x: maxX, y: minY },
+    { x: maxX, y: maxY },
+    { x: minX, y: maxY }
+  ];
+  let minimumDistance = Number.POSITIVE_INFINITY;
+  for (let index = 0; index < corners.length; index++) {
+    minimumDistance = Math.min(
+      minimumDistance,
+      distanceSegmentToSegment2(
+        localStart,
+        localEnd,
+        corners[index],
+        corners[(index + 1) % corners.length]
+      )
+    );
+  }
+  return minimumDistance;
+}
+function segmentsAreClear2(first, second, clearance) {
+  if (first.layer !== second.layer) return true;
+  const requiredDistance = (first.width + second.width) / 2 + clearance;
+  const broadPhaseDistance = requiredDistance + EPSILON24;
+  if (Math.min(first.start.x, first.end.x) - Math.max(second.start.x, second.end.x) > broadPhaseDistance || Math.min(second.start.x, second.end.x) - Math.max(first.start.x, first.end.x) > broadPhaseDistance || Math.min(first.start.y, first.end.y) - Math.max(second.start.y, second.end.y) > broadPhaseDistance || Math.min(second.start.y, second.end.y) - Math.max(first.start.y, first.end.y) > broadPhaseDistance) {
+    return true;
+  }
+  return distanceSegmentToSegment2(
+    first.start,
+    first.end,
+    second.start,
+    second.end
+  ) >= requiredDistance - EPSILON24;
+}
+
+// node_modules/@tscircuit/dogbone-solver/node_modules/@tscircuit/fanout-solver/lib/match-component-dogbone-via-sites.ts
+var EPSILON25 = 1e-9;
+var DEFAULT_MAXIMUM_SEARCH_STATES2 = 1e5;
+function assertGeometryRules2(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_STATES2;
+  if (!Number.isInteger(maximumSearchStates) || maximumSearchStates < 1) {
+    throw new Error(
+      `FanoutSolver: dogbone maximumSearchStates must be a positive integer, received ${maximumSearchStates}`
+    );
+  }
+  return maximumSearchStates;
+}
+function uniqueSortedCoordinates2(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) > EPSILON25) {
+      result.push(value);
+    }
+  }
+  return result;
+}
+function getComponentMatchingInputs2(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: [],
+        pitchX: Number.POSITIVE_INFINITY,
+        pitchY: Number.POSITIVE_INFINITY
+      };
+      byComponent.set(bus.componentId, component);
+      obstacleSetByComponentId.set(bus.componentId, /* @__PURE__ */ new Set());
+    }
+    component.xCoordinates.push(...bus.xCoordinates);
+    component.yCoordinates.push(...bus.yCoordinates);
+    if (Number.isFinite(bus.pitchX) && bus.pitchX > EPSILON25) {
+      component.pitchX = Math.min(component.pitchX, bus.pitchX);
+    }
+    if (Number.isFinite(bus.pitchY) && bus.pitchY > EPSILON25) {
+      component.pitchY = Math.min(component.pitchY, bus.pitchY);
+    }
+    const obstacleSet = obstacleSetByComponentId.get(bus.componentId);
+    for (const obstacle of bus.componentObstacles) {
+      if (!obstacleSet.has(obstacle)) {
+        obstacleSet.add(obstacle);
+        component.obstacles.push(obstacle);
+      }
+    }
+    for (const preparedConnection of bus.connections) {
+      const existingComponent = componentByConnectionIndex.get(
+        preparedConnection.connectionIndex
+      );
+      if (existingComponent !== void 0) {
+        if (existingComponent !== bus.componentId) {
+          throw new Error(
+            `FanoutSolver: connection index ${preparedConnection.connectionIndex} belongs to multiple components`
+          );
+        }
+        continue;
+      }
+      componentByConnectionIndex.set(
+        preparedConnection.connectionIndex,
+        bus.componentId
+      );
+      component.connections.push({
+        preparedConnection,
+        busId: bus.busId,
+        direction: bus.direction,
+        terminationType: bus.termination.type
+      });
+    }
+  }
+  return [...byComponent.values()].map((component) => ({
+    ...component,
+    connections: component.connections.toSorted(
+      (first, second) => first.preparedConnection.connectionIndex - second.preparedConnection.connectionIndex
+    ),
+    xCoordinates: uniqueSortedCoordinates2(component.xCoordinates),
+    yCoordinates: uniqueSortedCoordinates2(component.yCoordinates)
+  })).toSorted(
+    (first, second) => first.componentId.localeCompare(second.componentId)
+  );
+}
+function getInterstitialCoordinates2(params) {
+  const { coordinates, pitch } = params;
+  if (coordinates.length === 0 || !Number.isFinite(pitch) || pitch <= EPSILON25) {
+    return [];
+  }
+  const interstitialCoordinates = [coordinates[0] - pitch / 2];
+  for (let index = 1; index < coordinates.length; index++) {
+    interstitialCoordinates.push(
+      (coordinates[index - 1] + coordinates[index]) / 2
+    );
+  }
+  interstitialCoordinates.push(coordinates.at(-1) + pitch / 2);
+  return uniqueSortedCoordinates2(interstitialCoordinates);
+}
+function getAdjacentInterstitialCoordinates2(params) {
+  const { sourceCoordinate, coordinates, pitch } = params;
+  const interstitialCoordinates = getInterstitialCoordinates2({
+    coordinates,
+    pitch
+  });
+  const before = interstitialCoordinates.filter((coordinate) => coordinate < sourceCoordinate - EPSILON25).at(-1);
+  const after = interstitialCoordinates.find(
+    (coordinate) => coordinate > sourceCoordinate + EPSILON25
+  );
+  return [before, after].filter(
+    (coordinate) => coordinate !== void 0
+  );
+}
+function directSegmentIsStraightOr452(start, end) {
+  const absoluteX = Math.abs(end.x - start.x);
+  const absoluteY = Math.abs(end.y - start.y);
+  return absoluteX <= EPSILON25 || absoluteY <= EPSILON25 || Math.abs(absoluteX - absoluteY) <= EPSILON25;
+}
+function getOutwardRank2(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 > EPSILON25 ? 0 : Math.abs(outwardDisplacement) <= EPSILON25 ? 1 : 2;
+}
+function viaSiteClearsObstacles2(params) {
+  const { point: point6, obstacles, viaDiameter, clearance } = params;
+  const requiredClearance = viaDiameter / 2 + clearance;
+  return obstacles.every(
+    (obstacle) => distancePointToObstacle2(point6, obstacle) >= requiredClearance - EPSILON25
+  );
+}
+function sourceSegmentClearsOtherObstacles2(params) {
+  const { segment: segment2, sourceObstacle, obstacles, clearance } = params;
+  const requiredClearance = segment2.width / 2 + clearance;
+  return obstacles.every(
+    (obstacle) => obstacle === sourceObstacle || distanceSegmentToObstacle2(segment2, obstacle) >= requiredClearance - EPSILON25
+  );
+}
+function getConnectionCandidates2(params) {
+  const { connection, component, rules } = params;
+  const { preparedConnection, direction } = connection;
+  const obstacles = rules.additionalObstacles ? [.../* @__PURE__ */ new Set([...component.obstacles, ...rules.additionalObstacles])] : component.obstacles;
+  const source = {
+    x: preparedConnection.sourcePoint.x,
+    y: preparedConnection.sourcePoint.y
+  };
+  const adjacentX = getAdjacentInterstitialCoordinates2({
+    sourceCoordinate: source.x,
+    coordinates: component.xCoordinates,
+    pitch: component.pitchX
+  });
+  const adjacentY = getAdjacentInterstitialCoordinates2({
+    sourceCoordinate: source.y,
+    coordinates: component.yCoordinates,
+    pitch: component.pitchY
+  });
+  const rawPoints = [
+    ...adjacentX.map((x) => ({ x, y: source.y })),
+    ...adjacentY.map((y) => ({ x: source.x, y })),
+    ...adjacentX.flatMap((x) => adjacentY.map((y) => ({ x, y })))
+  ];
+  const uniquePoints2 = [];
+  for (const point6 of rawPoints) {
+    if (!uniquePoints2.some((candidate) => distance12(candidate, point6) <= EPSILON25)) {
+      uniquePoints2.push(point6);
+    }
+  }
+  const fixedViaPoint = rules.fixedViaPointsByConnectionIndex?.get(
+    preparedConnection.connectionIndex
+  );
+  const candidatePoints = fixedViaPoint ? [fixedViaPoint] : uniquePoints2;
+  const candidates = [];
+  for (const point6 of candidatePoints) {
+    if (connection.terminationType === "plane" && !directSegmentIsStraightOr452(source, point6)) {
+      continue;
+    }
+    if (!viaSiteClearsObstacles2({
+      point: point6,
+      obstacles,
+      viaDiameter: rules.viaDiameter,
+      clearance: rules.clearance
+    })) {
+      continue;
+    }
+    const sourceSegment = {
+      start: source,
+      end: point6,
+      width: rules.traceWidth,
+      layer: preparedConnection.sourceLayer
+    };
+    if (!sourceSegmentClearsOtherObstacles2({
+      segment: sourceSegment,
+      sourceObstacle: preparedConnection.sourceObstacle,
+      obstacles,
+      clearance: rules.clearance
+    })) {
+      continue;
+    }
+    const candidateClearsRoutedCopper = (rules.blockingSegments ?? []).every(
+      (blocker) => {
+        if (blocker.connectionIndex === preparedConnection.connectionIndex) {
+          return true;
+        }
+        if (rules.canShareCopper?.(
+          preparedConnection.connectionIndex,
+          blocker.connectionIndex
+        )) {
+          return true;
+        }
+        const viaToTraceClearance = rules.viaDiameter / 2 + blocker.segment.width / 2 + rules.clearance;
+        if (distancePointToSegment2(
+          point6,
+          blocker.segment.start,
+          blocker.segment.end
+        ) < viaToTraceClearance - EPSILON25) {
+          return false;
+        }
+        return blocker.segment.layer !== sourceSegment.layer || segmentsAreClear2(sourceSegment, blocker.segment, rules.clearance);
+      }
+    );
+    if (!candidateClearsRoutedCopper) continue;
+    const candidateClearsRoutedVias = (rules.blockingVias ?? []).every(
+      (blocker) => {
+        if (blocker.connectionIndex === preparedConnection.connectionIndex) {
+          return true;
+        }
+        if (distance12(point6, blocker.center) < (rules.viaDiameter + blocker.diameter) / 2 + rules.clearance - EPSILON25) {
+          return false;
+        }
+        if (blocker.spanLayers.includes(sourceSegment.layer) && distancePointToSegment2(
+          blocker.center,
+          sourceSegment.start,
+          sourceSegment.end
+        ) < blocker.diameter / 2 + sourceSegment.width / 2 + rules.clearance - EPSILON25) {
+          return false;
+        }
+        return true;
+      }
+    );
+    if (!candidateClearsRoutedVias) continue;
+    candidates.push({
+      connectionIndex: preparedConnection.connectionIndex,
+      point: point6,
+      sourceSegment,
+      outwardRank: getOutwardRank2({ source, site: point6, direction })
+    });
+  }
+  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) <= EPSILON25
+  );
+  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;
+  const preferOutward = connection.terminationType === "boundary" ? rules.preferBoundaryOutwardByBusId?.get(connection.busId) ?? true : true;
+  const preferredViaPoint = rules.preferredViaPointsByConnectionIndex?.get(
+    preparedConnection.connectionIndex
+  );
+  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 > EPSILON25 ? 0 : Math.abs(displacement) <= EPSILON25 ? 1 : 2;
+  };
+  return candidates.toSorted(
+    (first, second) => (preferredViaPoint ? Number(distance12(first.point, preferredViaPoint) > EPSILON25) - Number(distance12(second.point, preferredViaPoint) > EPSILON25) : 0) || (preferOutward ? first.outwardRank - second.outwardRank : second.outwardRank - first.outwardRank) || getPerpendicularPreferenceRank(first) - getPerpendicularPreferenceRank(second) || distance12(source, first.point) - distance12(source, second.point) || first.point.x - second.point.x || first.point.y - second.point.y
+  );
+}
+function candidatesAreMutuallyClear2(params) {
+  const { first, second, rules } = 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 (distance12(first.point, second.point) < requiredViaSeparation - EPSILON25) {
+    return false;
+  }
+  const requiredViaToTraceClearance = rules.viaDiameter / 2 + rules.traceWidth / 2 + rules.clearance;
+  if (!canShareCopper) {
+    if (distancePointToSegment2(
+      first.point,
+      second.sourceSegment.start,
+      second.sourceSegment.end
+    ) < requiredViaToTraceClearance - EPSILON25 || distancePointToSegment2(
+      second.point,
+      first.sourceSegment.start,
+      first.sourceSegment.end
+    ) < requiredViaToTraceClearance - EPSILON25) {
+      return false;
+    }
+  }
+  if (canShareCopper) return true;
+  return segmentsAreClear2(
+    first.sourceSegment,
+    second.sourceSegment,
+    rules.clearance
+  );
+}
+function matchComponent2(params) {
+  const { component, rules, consumeSearchState } = params;
+  const entries = component.connections.map(
+    (connection) => ({
+      connection,
+      candidates: getConnectionCandidates2({ connection, component, rules })
+    })
+  );
+  if (entries.some((entry) => entry.candidates.length === 0)) return null;
+  const compatibilityCache = /* @__PURE__ */ new Map();
+  const candidatesAreCompatible = (first, second) => {
+    const cached = compatibilityCache.get(first)?.get(second);
+    if (cached !== void 0) return cached;
+    const compatible = candidatesAreMutuallyClear2({ first, second, rules });
+    const firstCache = compatibilityCache.get(first) ?? /* @__PURE__ */ new Map();
+    firstCache.set(second, compatible);
+    compatibilityCache.set(first, firstCache);
+    const secondCache = compatibilityCache.get(second) ?? /* @__PURE__ */ new Map();
+    secondCache.set(first, compatible);
+    compatibilityCache.set(second, secondCache);
+    return compatible;
+  };
+  const forcedCandidates = entries.flatMap(
+    (entry) => entry.candidates.length === 1 ? [entry.candidates[0]] : []
+  );
+  for (let candidateIndex = 0; candidateIndex < forcedCandidates.length; candidateIndex++) {
+    const candidate = forcedCandidates[candidateIndex];
+    for (let previousIndex = 0; previousIndex < candidateIndex; previousIndex++) {
+      if (!candidatesAreCompatible(candidate, forcedCandidates[previousIndex])) {
+        return null;
+      }
+    }
+  }
+  const assignedCandidates = new Map(
+    forcedCandidates.map((candidate) => [candidate.connectionIndex, candidate])
+  );
+  const remaining = new Set(
+    entries.flatMap(
+      (entry) => entry.candidates.length > 1 ? [entry.connection.preparedConnection.connectionIndex] : []
+    )
+  );
+  const entryByConnectionIndex = new Map(
+    entries.map((entry) => [
+      entry.connection.preparedConnection.connectionIndex,
+      entry
+    ])
+  );
+  if (remaining.size === 0) {
+    return new Map(
+      [...assignedCandidates.entries()].map(([connectionIndex, candidate]) => [
+        connectionIndex,
+        { ...candidate.point }
+      ])
+    );
+  }
+  const getViableCandidates = (entry) => entry.candidates.filter(
+    (candidate) => [...assignedCandidates.values()].every(
+      (assignedCandidate) => candidatesAreCompatible(candidate, assignedCandidate)
+    )
+  );
+  const augmentMatching = () => {
+    if (!consumeSearchState()) return false;
+    if (remaining.size === 0) return true;
+    let selectedEntry;
+    let selectedCandidates = [];
+    for (const connectionIndex2 of [...remaining].toSorted(
+      (first, second) => first - second
+    )) {
+      const entry = entryByConnectionIndex.get(connectionIndex2);
+      const viableCandidates = getViableCandidates(entry);
+      if (viableCandidates.length === 0) return false;
+      if (!selectedEntry || viableCandidates.length < selectedCandidates.length || viableCandidates.length === selectedCandidates.length && connectionIndex2 < selectedEntry.connection.preparedConnection.connectionIndex) {
+        selectedEntry = entry;
+        selectedCandidates = viableCandidates;
+      }
+    }
+    const connectionIndex = selectedEntry.connection.preparedConnection.connectionIndex;
+    remaining.delete(connectionIndex);
+    for (const candidate of selectedCandidates) {
+      assignedCandidates.set(connectionIndex, candidate);
+      if (augmentMatching()) return true;
+      assignedCandidates.delete(connectionIndex);
+    }
+    remaining.add(connectionIndex);
+    return false;
+  };
+  if (!augmentMatching()) return null;
+  return new Map(
+    [...assignedCandidates.entries()].toSorted(([first], [second]) => first - second).map(([connectionIndex, candidate]) => [
+      connectionIndex,
+      { ...candidate.point }
+    ])
+  );
+}
+function matchComponentDogboneViaSites2(preparedBuses, rules) {
+  const maximumSearchStates = assertGeometryRules2(rules);
+  if (preparedBuses.length === 0) return /* @__PURE__ */ new Map();
+  let consumedSearchStates = 0;
+  const consumeSearchState = () => {
+    consumedSearchStates++;
+    return consumedSearchStates <= maximumSearchStates;
+  };
+  const result = /* @__PURE__ */ new Map();
+  for (const component of getComponentMatchingInputs2(preparedBuses)) {
+    const componentResult = matchComponent2({
+      component,
+      rules,
+      consumeSearchState
+    });
+    if (!componentResult) return null;
+    for (const [connectionIndex, point6] of componentResult) {
+      result.set(connectionIndex, point6);
+    }
+  }
+  return result;
+}
+
+// node_modules/@tscircuit/dogbone-solver/node_modules/@tscircuit/fanout-solver/lib/route-reserved-via-buses.ts
+import {
+  PortfolioSingleIntraNodeSolver as PortfolioSingleIntraNodeSolver2
+} from "@tscircuit/capacity-autorouter";
 import { BaseSolver as BaseSolver4 } from "@tscircuit/solver-utils";
 
+// node_modules/@tscircuit/dogbone-solver/node_modules/@tscircuit/fanout-solver/lib/subsolver-request.ts
+import { BaseSolver as BaseSolver5 } from "@tscircuit/solver-utils";
+
+// node_modules/@tscircuit/dogbone-solver/node_modules/@tscircuit/fanout-solver/lib/fanout-solver.ts
+import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
+import { mergeGraphics as mergeGraphics2 } from "graphics-debug";
+
+// node_modules/@tscircuit/dogbone-solver/node_modules/@tscircuit/fanout-solver/lib/match-angularly-ordered-local-vias.ts
+var TAU2 = Math.PI * 2;
+
+// node_modules/@tscircuit/dogbone-solver/node_modules/@tscircuit/fanout-solver/lib/route-single-layer-adaptive-exits.ts
+var FANOUT_FLOW_DEBUG_ENABLED2 = globalThis.process?.env?.FANOUT_FLOW_DEBUG === "1";
+
+// node_modules/@tscircuit/dogbone-solver/node_modules/@tscircuit/fanout-solver/lib/runtime-process.ts
+var getRuntimeProcess2 = (runtime) => runtime.process ?? { env: {} };
+
+// node_modules/@tscircuit/dogbone-solver/node_modules/@tscircuit/fanout-solver/lib/fanout-solver.ts
+var process2 = getRuntimeProcess2(globalThis);
+
+// node_modules/@tscircuit/dogbone-solver/lib/dogbone-fanout-solver.ts
+import { layer_ref as layer_ref3 } from "circuit-json";
+
+// node_modules/@tscircuit/dogbone-solver/lib/get-via-board-layers.ts
+function getViaBoardLayers2(layerCount) {
+  if (layerCount <= 1) return ["top"];
+  return [
+    "top",
+    ...Array.from(
+      { length: layerCount - 2 },
+      (_, index) => `inner${index + 1}`
+    ),
+    "bottom"
+  ];
+}
+
+// node_modules/@tscircuit/dogbone-solver/lib/dogbone-fanout-solver.ts
+var DogboneFanoutSolver = class extends BaseSolver7 {
+  constructor(params) {
+    super();
+    this.params = params;
+    this.MAX_ITERATIONS = params.input.connections.length * 2 + 10;
+    this.steps = this.solveSteps();
+  }
+  params;
+  phase = "preparing";
+  sources = [];
+  sites = /* @__PURE__ */ new Map();
+  traces = [];
+  steps;
+  getConstructorParams() {
+    return [this.params];
+  }
+  _step() {
+    try {
+      if (this.steps.next().done) {
+        this.phase = "complete";
+        this.progress = 1;
+        this.solved = true;
+      }
+    } catch (error) {
+      this.error = error instanceof Error ? error.message : String(error);
+      this.failed = true;
+    }
+  }
+  getOutput() {
+    if (!this.solved)
+      throw new Error(this.error ?? "Dogbone fanout is not solved");
+    return this.traces;
+  }
+  visualize() {
+    return {
+      rects: this.params.input.obstacles.filter((pad) => pad.shape !== "circle").map((pad) => ({
+        center: pad.center,
+        width: pad.width,
+        height: pad.height,
+        fill: "rgba(200,40,40,0.3)"
+      })),
+      circles: [
+        ...this.params.input.obstacles.filter((pad) => pad.shape === "circle").map((pad) => ({
+          center: pad.center,
+          radius: pad.width / 2,
+          fill: "rgba(200,40,40,0.3)"
+        })),
+        ...[...this.sites.values()].map((center) => ({
+          center,
+          radius: (this.params.input.minViaPadDiameter ?? this.params.input.minViaDiameter ?? 0.6) / 2,
+          fill: "orange"
+        }))
+      ],
+      lines: [...this.sites].map(([index, via]) => ({
+        points: [this.sources[index].port, via],
+        strokeColor: "orange",
+        strokeWidth: this.params.input.minTraceWidth
+      }))
+    };
+  }
+  *solveSteps() {
+    const { input, fanoutRoutingLayers } = this.params;
+    const traceWidth = input.minTraceWidth;
+    const clearance = input.minTraceToPadEdgeClearance ?? 0.1;
+    const viaDiameter = input.minViaPadDiameter ?? input.minViaDiameter ?? 0.6;
+    const holeDiameter = input.minViaHoleDiameter ?? 0.3;
+    const viaClearance = input.minViaEdgeToPadEdgeClearance ?? clearance;
+    const boardEdgeClearance = input.minBoardEdgeClearance ?? clearance;
+    const holeClearance = input.minViaHoleEdgeToViaHoleEdgeClearance ?? clearance;
+    this.sources = input.connections.map((connection) => {
+      const point6 = connection.pointsToConnect.find(
+        (point7) => point7.pcb_port_id && input.obstacles.some(
+          (pad2) => pad2.componentId && Math.hypot(pad2.center.x - point7.x, pad2.center.y - point7.y) < 1e-6
+        )
+      );
+      if (!point6?.pcb_port_id)
+        throw new Error(
+          `Dogbone connection ${connection.name} has no source pad`
+        );
+      const pad = input.obstacles.find(
+        (pad2) => pad2.componentId && Math.hypot(pad2.center.x - point6.x, pad2.center.y - point6.y) < 1e-6
+      );
+      return {
+        port: {
+          pcb_port_id: point6.pcb_port_id,
+          pcb_component_id: pad.componentId,
+          x: point6.x,
+          y: point6.y,
+          layers: [layer_ref3.parse(point6.layer)]
+        },
+        sourceTraceId: connection.source_trace_id
+      };
+    });
+    const sources = this.sources;
+    const layers = getViaBoardLayers2(input.layerCount);
+    const allowedLayers = fanoutRoutingLayers ?? layers;
+    if (allowedLayers.some(
+      (layer) => !layers.some((boardLayer) => boardLayer === layer)
+    ))
+      throw new Error("Dogbone fanout targets an unavailable board layer");
+    const buses = [];
+    const targets = sources.map(({ port, sourceTraceId }, connectionIndex) => {
+      const sourceObstacle = input.obstacles.find(
+        (obstacle) => obstacle.componentId === port.pcb_component_id && Math.hypot(obstacle.center.x - port.x, obstacle.center.y - port.y) < 1e-6
+      );
+      if (!sourceObstacle)
+        throw new Error(
+          "Dogbone fanout requires a component pad at each source port"
+        );
+      if (port.layers.length !== 1 || !layers.includes(port.layers[0])) {
+        throw new Error("Dogbone fanout requires a single-layer SMT source pad");
+      }
+      const sourceLayer = port.layers[0];
+      const targetLayer2 = allowedLayers.find((layer) => layer !== sourceLayer);
+      if (!targetLayer2)
+        throw new Error(
+          "Dogbone fanout requires a legal layer distinct from the source pad"
+        );
+      let bus = buses.find(
+        (bus2) => bus2.componentId === sourceObstacle.componentId
+      );
+      if (!bus) {
+        const pads = input.obstacles.filter(
+          (obstacle) => obstacle.componentId === sourceObstacle.componentId
+        );
+        const xs = [
+          ...new Set(pads.map((pad) => Math.round(pad.center.x * 1e6) / 1e6))
+        ].sort((a, b) => a - b);
+        const ys = [
+          ...new Set(pads.map((pad) => Math.round(pad.center.y * 1e6) / 1e6))
+        ].sort((a, b) => a - b);
+        if (xs.length < 2 || ys.length < 2)
+          throw new Error("Dogbone fanout requires a two-dimensional pad grid");
+        const pitch = (coordinates) => Math.min(...coordinates.slice(1).map((v, i) => v - coordinates[i]));
+        bus = {
+          busId: sourceObstacle.componentId,
+          componentId: sourceObstacle.componentId,
+          componentObstacles: pads,
+          connections: [],
+          direction: "down",
+          termination: { type: "boundary" },
+          componentBounds: {
+            minX: xs[0],
+            maxX: xs.at(-1),
+            minY: ys[0],
+            maxY: ys.at(-1)
+          },
+          sharedBoundary: input.bounds,
+          xCoordinates: xs,
+          yCoordinates: ys,
+          pitchX: pitch(xs),
+          pitchY: pitch(ys)
+        };
+        buses.push(bus);
+      }
+      const sourcePoint = {
+        x: port.x,
+        y: port.y,
+        layer: sourceLayer,
+        pcb_port_id: port.pcb_port_id
+      };
+      bus.connections.push({
+        connectionIndex,
+        connection: { name: port.pcb_port_id, pointsToConnect: [sourcePoint] },
+        sourcePoint,
+        sourcePointIndex: 0,
+        sourceLayer,
+        sourceObstacle,
+        targetPoint: sourcePoint
+      });
+      return { sourceTraceId, port, sourceLayer, targetLayer: targetLayer2 };
+    });
+    const sites = this.sites;
+    const blockingSegments = [];
+    const blockingVias = [];
+    for (const bus of buses) {
+      this.phase = "assigning_sites";
+      yield;
+      const assignment = matchComponentDogboneViaSites2([bus], {
+        traceWidth,
+        clearance: Math.max(clearance, viaClearance),
+        viaDiameter,
+        viaHoleDiameter: holeDiameter,
+        holeToHoleClearance: holeClearance,
+        additionalObstacles: input.obstacles,
+        blockingSegments,
+        blockingVias
+      });
+      if (!assignment || assignment.size !== bus.connections.length)
+        throw new Error(
+          "No complete local dogbone assignment within clearance/search limits"
+        );
+      for (const connection of bus.connections) {
+        const connectionIndex = connection.connectionIndex;
+        const via = assignment.get(connectionIndex);
+        sites.set(connectionIndex, via);
+        blockingSegments.push({
+          connectionIndex,
+          segment: {
+            start: connection.sourcePoint,
+            end: via,
+            width: traceWidth,
+            layer: connection.sourceLayer
+          }
+        });
+        blockingVias.push({
+          connectionIndex,
+          center: via,
+          diameter: viaDiameter,
+          spanLayers: layers
+        });
+      }
+    }
+    this.phase = "creating_traces";
+    for (const [
+      index,
+      { sourceTraceId, port, sourceLayer, targetLayer: targetLayer2 }
+    ] of targets.entries()) {
+      const via = sites.get(index);
+      const dx = Math.abs(via.x - port.x), dy = Math.abs(via.y - port.y);
+      if (dx > 1e-6 && dy > 1e-6 && Math.abs(dx - dy) > 1e-6)
+        throw new Error(
+          "Dogbone fanout requires straight or 45-degree local escapes"
+        );
+      const margin = viaDiameter / 2 + boardEdgeClearance;
+      if (via.x < input.bounds.minX + margin || via.x > input.bounds.maxX - margin || via.y < input.bounds.minY + margin || via.y > input.bounds.maxY - margin)
+        throw new Error("Dogbone via violates board-edge clearance");
+      this.traces.push({
+        type: "pcb_trace",
+        pcb_trace_id: `dogbone_${port.pcb_port_id}`,
+        source_trace_id: sourceTraceId,
+        connectsTo: [port.pcb_port_id],
+        route: [
+          {
+            route_type: "wire",
+            x: port.x,
+            y: port.y,
+            layer: sourceLayer,
+            width: traceWidth
+          },
+          { route_type: "wire", ...via, layer: sourceLayer, width: traceWidth },
+          {
+            route_type: "via",
+            ...via,
+            from_layer: sourceLayer,
+            to_layer: targetLayer2,
+            via_diameter: viaDiameter,
+            via_hole_diameter: holeDiameter,
+            layers
+          },
+          { route_type: "wire", ...via, layer: targetLayer2, width: traceWidth },
+          { route_type: "wire", ...via, layer: targetLayer2, width: traceWidth }
+        ]
+      });
+      this.progress = (index + 1) / targets.length;
+      yield;
+    }
+  }
+};
+
+// node_modules/@tscircuit/dogbone-solver/lib/dogbone-autorouter.ts
+var DogboneAutorouter = class {
+  constructor(params, callbacks = {}) {
+    this.params = params;
+    this.callbacks = callbacks;
+    this.solver = new DogboneFanoutSolver(params);
+  }
+  params;
+  callbacks;
+  get input() {
+    return this.params.input;
+  }
+  isRouting = false;
+  solver;
+  timer;
+  listeners = [];
+  finishSolver() {
+    this.callbacks.onSolverEnded?.({
+      solverName: "DogboneFanoutSolver",
+      solved: this.solver.solved,
+      failed: this.solver.failed,
+      iterations: this.solver.iterations,
+      error: this.solver.error
+    });
+  }
+  getTraces() {
+    return this.solver.getOutput().map((trace) => {
+      const connection = this.params.input.connections.find(
+        (connection2) => connection2.pointsToConnect.some(
+          (point6) => point6.pcb_port_id && trace.connectsTo?.includes(point6.pcb_port_id)
+        )
+      );
+      if (!connection)
+        throw new Error("Dogbone fanout lost its source connection");
+      return {
+        ...trace,
+        connection_name: connection.name,
+        source_trace_id: connection.source_trace_id,
+        connectsTo: [
+          .../* @__PURE__ */ new Set([
+            ...trace.connectsTo ?? [],
+            ...connection.routingPcbGroupId ? connection.pointsToConnect.flatMap(
+              (point6) => !point6.pcb_port_id && point6.pointId ? [point6.pointId] : []
+            ) : [`${trace.pcb_trace_id}_exit`]
+          ])
+        ]
+      };
+    });
+  }
+  getOutputSimpleRouteJson() {
+    const traces = this.getTraces();
+    return {
+      ...this.params.input,
+      traces,
+      connections: this.params.input.connections.map((connection) => {
+        const trace = traces.find(
+          (trace2) => trace2.connection_name === connection.name
+        );
+        if (!trace) return connection;
+        const exit = trace.route.at(-1);
+        if (exit.route_type !== "wire")
+          throw new Error("Dogbone fanout lost its exit");
+        return {
+          ...connection,
+          pointsToConnect: connection.pointsToConnect.map((point6) => {
+            const isHandoff = !point6.pcb_port_id;
+            const relocate = connection.routingPcbGroupId ? isHandoff : Boolean(
+              point6.pcb_port_id && trace.connectsTo?.includes(point6.pcb_port_id)
+            );
+            if (!relocate) return point6;
+            if (connection.routingPcbGroupId)
+              return { ...point6, x: exit.x, y: exit.y, layer: exit.layer };
+            const { pcb_port_id: _port, ...handoff } = point6;
+            return {
+              ...handoff,
+              pointId: `${trace.pcb_trace_id}_exit`,
+              x: exit.x,
+              y: exit.y,
+              layer: exit.layer
+            };
+          })
+        };
+      })
+    };
+  }
+  on(event, callback) {
+    this.listeners.push({
+      event,
+      callback
+    });
+  }
+  emit(event) {
+    for (const listener of this.listeners)
+      if (listener.event === event.type) listener.callback(event);
+  }
+  start() {
+    if (this.isRouting) return;
+    this.isRouting = true;
+    this.callbacks.onSolverStarted?.({
+      solverName: "DogboneFanoutSolver",
+      solverParams: this.params,
+      solverConstructorArgs: this.solver.getConstructorParams()
+    });
+    const tick = () => {
+      if (!this.isRouting) return;
+      try {
+        for (let i = 0; i < 16 && !this.solver.solved && !this.solver.failed; i++)
+          this.solver.step();
+        this.emit({
+          type: "progress",
+          steps: this.solver.iterations,
+          progress: this.solver.progress,
+          phase: this.solver.phase,
+          debugGraphics: this.solver.visualize()
+        });
+        if (!this.isRouting) return;
+        if (this.solver.failed) {
+          this.finishSolver();
+          this.isRouting = false;
+          this.emit({
+            type: "error",
+            error: new Error(this.solver.error ?? "Dogbone routing failed")
+          });
+          return;
+        }
+        if (this.solver.solved) {
+          this.finishSolver();
+          this.isRouting = false;
+          this.emit({ type: "complete", traces: this.getTraces() });
+          return;
+        }
+        this.timer = setTimeout(tick, 0);
+      } catch (error) {
+        this.isRouting = false;
+        this.emit({
+          type: "error",
+          error: error instanceof Error ? error : new Error(String(error))
+        });
+      }
+    };
+    this.timer = setTimeout(tick, 0);
+  }
+  stop() {
+    this.isRouting = false;
+    if (this.timer) clearTimeout(this.timer);
+  }
+  solveSync() {
+    this.solver.solve();
+    if (this.solver.failed)
+      throw new Error(this.solver.error ?? "Dogbone routing failed");
+    return this.getTraces();
+  }
+};
+
+// node_modules/@tscircuit/bus-lanes-solver/lib/bus-lanes-solver.ts
+import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
+
 // node_modules/@tscircuit/bus-lanes-solver/lib/geometry.ts
-var distance12 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+var distance14 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
 function pointSegmentDistance(p, edge) {
   const [a, b] = edge, dx = b.x - a.x, dy = b.y - a.y, t = Math.max(
     0,
@@ -50584,10 +51661,10 @@ function pointSegmentDistance(p, edge) {
   );
   return Math.hypot(p.x - a.x - t * dx, p.y - a.y - t * dy);
 }
-var cross2 = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+var cross3 = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
 function segmentDistance(ab, cd) {
   const [a, b] = ab, [c, d] = cd;
-  if (Math.max(a.x, b.x) >= Math.min(c.x, d.x) && Math.max(c.x, d.x) >= Math.min(a.x, b.x) && Math.max(a.y, b.y) >= Math.min(c.y, d.y) && Math.max(c.y, d.y) >= Math.min(a.y, b.y) && cross2(a, b, c) * cross2(a, b, d) <= 0 && cross2(c, d, a) * cross2(c, d, b) <= 0)
+  if (Math.max(a.x, b.x) >= Math.min(c.x, d.x) && Math.max(c.x, d.x) >= Math.min(a.x, b.x) && Math.max(a.y, b.y) >= Math.min(c.y, d.y) && Math.max(c.y, d.y) >= Math.min(a.y, b.y) && cross3(a, b, c) * cross3(a, b, d) <= 0 && cross3(c, d, a) * cross3(c, d, b) <= 0)
     return 0;
   return Math.min(
     pointSegmentDistance(a, cd),
@@ -50596,10 +51673,10 @@ function segmentDistance(ab, cd) {
     pointSegmentDistance(d, ab)
   );
 }
-var length = (path) => path.slice(1).reduce((sum, p, i) => sum + distance12(path[i], p), 0);
+var length = (path) => path.slice(1).reduce((sum, p, i) => sum + distance14(path[i], p), 0);
 function simplify(path) {
   return path.filter(
-    (p, i) => !i || i === path.length - 1 || Math.abs(cross2(path[i - 1], p, path[i + 1])) > 1e-9
+    (p, i) => !i || i === path.length - 1 || Math.abs(cross3(path[i - 1], p, path[i + 1])) > 1e-9
   );
 }
 
@@ -50643,7 +51720,7 @@ function fixedCopper(input) {
           throw Error("Fixed trace changes layer without a via");
         result.push({ a: p, b: q, radius: p.width / 2, layer: p.layer, owners });
       }
-      if (q && p.route_type !== q.route_type && distance12(p, q) > 1e-10) {
+      if (q && p.route_type !== q.route_type && distance14(p, q) > 1e-10) {
         const wire = p.route_type === "wire" ? p : q;
         result.push({
           a: p,
@@ -50763,7 +51840,7 @@ var VectorScene = class {
         );
       } else {
         const r = c.radius + this.margin + epsilon;
-        for (const p of distance12(c.a, c.b) < 1e-9 ? [c.a] : [c.a, c.b])
+        for (const p of distance14(c.a, c.b) < 1e-9 ? [c.a] : [c.a, c.b])
           for (const [x, y] of [
             [1, k],
             [k, 1],
@@ -50851,7 +51928,7 @@ var VectorVisibilitySearch = class {
     this.start = start;
     this.end = end;
     this.vertices = [start, end];
-    this.open.push({ id: 0, g: 0, f: distance12(start, end) });
+    this.open.push({ id: 0, g: 0, f: distance14(start, end) });
     this.best.set(0, 0);
   }
   scene;
@@ -50911,7 +51988,7 @@ var VectorVisibilitySearch = class {
     const from = this.vertices[cur.id];
     for (let id = 1; id < this.vertices.length; id++) {
       if (id === cur.id) continue;
-      const to = this.vertices[id], lower = cur.g + distance12(from, to);
+      const to = this.vertices[id], lower = cur.g + distance14(from, to);
       if (lower >= (this.best.get(id) ?? Infinity) - 1e-9) continue;
       const candidates = connectors(from, to).sort(
         (a, b) => length(a) - length(b)
@@ -50924,7 +52001,7 @@ var VectorVisibilitySearch = class {
         this.open.push({
           id,
           g,
-          f: g + distance12(to, this.end),
+          f: g + distance14(to, this.end),
           parent: cur,
           edge: path
         });
@@ -51166,9 +52243,9 @@ function tuneLengths(input, traces, targets) {
     const clearance = input.minTraceToPadEdgeClearance ?? input.defaultObstacleMargin ?? 0.075;
     const returnSpacing = Math.max(width + clearance, 3 * width);
     const pitch = 2 * (returnSpacing + 2 * width);
-    const segments = t.route.slice(1).map((p, i) => ({ i, span: distance12(t.route[i], p) })).sort((a, b) => b.span - a.span);
+    const segments = t.route.slice(1).map((p, i) => ({ i, span: distance14(t.route[i], p) })).sort((a, b) => b.span - a.span);
     for (const { i } of segments) {
-      const a = t.route[i], b = t.route[i + 1], span = distance12(a, b);
+      const a = t.route[i], b = t.route[i + 1], span = distance14(a, b);
       if (span < 0.01) continue;
       const ux = (b.x - a.x) / span, uy = (b.y - a.y) / span;
       const maximumTeeth = Math.floor(span * 0.9 / pitch);
@@ -51268,7 +52345,7 @@ function tuneLengths(input, traces, targets) {
 function tuningPathIsSelfClear(path, required) {
   const cumulative = [0];
   for (let i = 1; i < path.length; i++)
-    cumulative.push(cumulative[i - 1] + distance12(path[i - 1], path[i]));
+    cumulative.push(cumulative[i - 1] + distance14(path[i - 1], path[i]));
   for (let i = 0; i < path.length - 1; i++)
     for (let j = i + 2; j < path.length - 1; j++) {
       if (cumulative[j] - cumulative[i + 1] <= required + 1e-8) continue;
@@ -51306,7 +52383,7 @@ var layerColors = {
 var layerColor = (layer) => layerColors[layer] ?? "#64748b";
 
 // node_modules/@tscircuit/bus-lanes-solver/lib/bus-lanes-solver.ts
-var BusLanesSolver = class extends BaseSolver4 {
+var BusLanesSolver = class extends BaseSolver8 {
   input;
   options;
   phase = "validate";
@@ -51516,7 +52593,7 @@ var BusLanesSolver = class extends BaseSolver4 {
       const t = this.traces.find((t2) => t2.connection_name === c.name);
       if (!t) throw Error("Missing lane");
       const scene = this.scene(c);
-      if (distance12(t.route[0], c.pointsToConnect[0]) > 1e-8 || distance12(t.route.at(-1), c.pointsToConnect[1]) > 1e-8)
+      if (distance14(t.route[0], c.pointsToConnect[0]) > 1e-8 || distance14(t.route.at(-1), c.pointsToConnect[1]) > 1e-8)
         throw Error("Broken lane endpoints");
       for (let i = 1; i < t.route.length; i++) {
         const a = t.route[i - 1], b = t.route[i], dx = Math.abs(a.x - b.x), dy = Math.abs(a.y - b.y);
@@ -51581,7 +52658,7 @@ var BusLanesSolver = class extends BaseSolver4 {
         });
         continue;
       }
-      if (distance12(c.a, c.b) < 1e-9)
+      if (distance14(c.a, c.b) < 1e-9)
         circles.push({
           center: c.a,
           radius: c.radius,
@@ -51742,7 +52819,7 @@ import { CreateFdmEnclosureSolver } from "@tscircuit/create-fdm-enclosure";
 // node_modules/@tscircuit/implicit-copper-pour-solver/lib/implicit-copper-pour-pipeline-solver.ts
 import {
   BasePipelineSolver,
-  BaseSolver as BaseSolver5,
+  BaseSolver as BaseSolver9,
   definePipelineStep
 } from "@tscircuit/solver-utils";
 
@@ -51760,7 +52837,7 @@ import { applyToPoint as applyToPoint30, compose as compose11, scale as scale2,
 // node_modules/@tscircuit/implicit-copper-pour-solver/lib/geometry.ts
 import {
   clamp,
-  distance as distance13,
+  distance as distance15,
   doBoundsOverlap as doBoundsOverlap2,
   getBoundsFromPoints as getBoundsFromPoints3,
   getUnitVectorFromPointAToB as getUnitVectorFromPointAToB2,
@@ -51809,7 +52886,7 @@ var distanceToPolygon = (point6, polygon) => {
 var distanceToPrimitive = (primitive, px, py) => {
   const point6 = { x: px, y: py };
   if (primitive.kind === "circle") {
-    return Math.max(distance13(point6, primitive) - primitive.radius, 0);
+    return Math.max(distance15(point6, primitive) - primitive.radius, 0);
   }
   if (primitive.kind === "segment") {
     return Math.max(
@@ -51860,7 +52937,7 @@ var getClosestPointOnPrimitive = (primitive, point6) => {
       const start = primitive.points[index];
       const end = primitive.points[(index + 1) % primitive.points.length];
       const candidate = pointToSegmentClosestPoint(point6, start, end);
-      const candidateDistance = distance13(point6, candidate);
+      const candidateDistance = distance15(point6, candidate);
       if (candidateDistance < bestDistance) {
         bestDistance = candidateDistance;
         closestPoint = candidate;
@@ -52916,7 +53993,7 @@ var prepareCircuitJson = (input) => {
 
 // node_modules/@tscircuit/implicit-copper-pour-solver/lib/simplify-polygon-edges.ts
 import {
-  distance as distance14,
+  distance as distance16,
   doSegmentsIntersect,
   onSegment,
   pointToSegmentDistance as pointToSegmentDistance2
@@ -52979,8 +54056,8 @@ var simplifyOpenPath = (points, tolerance) => {
     const point6 = points[index];
     const next = points[index + 1];
     const shortestLeg = Math.min(
-      distance14(point6, previous),
-      distance14(next, point6)
+      distance16(point6, previous),
+      distance16(next, point6)
     );
     if (repeatsTurnDirection || shortestLeg > tolerance) {
       anchorIndices.push(index);
@@ -53029,8 +54106,8 @@ var normalizePolygon = (polygon) => {
 };
 var isPointStrictlyInsideSegment = (point6, start, end) => {
   if (pointsEqual(point6, start) || pointsEqual(point6, end)) return false;
-  const cross4 = crossProduct(start, end, point6);
-  if (Math.abs(cross4) > 1e-9) return false;
+  const cross5 = crossProduct(start, end, point6);
+  if (Math.abs(cross5) > 1e-9) return false;
   return onSegment(start, point6, end);
 };
 var splitEdgesAtVertices = (polygon, allVertices) => {
@@ -53382,7 +54459,7 @@ var mergeSolverGraphics = (source, overlay) => {
 };
 
 // node_modules/@tscircuit/implicit-copper-pour-solver/lib/implicit-copper-pour-pipeline-solver.ts
-var PrepareCircuitJsonSolver = class extends BaseSolver5 {
+var PrepareCircuitJsonSolver = class extends BaseSolver9 {
   constructor(input) {
     super();
     this.input = input;
@@ -53398,7 +54475,7 @@ var PrepareCircuitJsonSolver = class extends BaseSolver5 {
     return this.output;
   }
 };
-var AssignGridCellsSolver = class extends BaseSolver5 {
+var AssignGridCellsSolver = class extends BaseSolver9 {
   constructor(input) {
     super();
     this.input = input;
@@ -53421,7 +54498,7 @@ var AssignGridCellsSolver = class extends BaseSolver5 {
     return this.output;
   }
 };
-var TracePowerPolygonsSolver = class extends BaseSolver5 {
+var TracePowerPolygonsSolver = class extends BaseSolver9 {
   constructor(input) {
     super();
     this.input = input;
@@ -53457,7 +54534,7 @@ var TracePowerPolygonsSolver = class extends BaseSolver5 {
     };
   }
 };
-var SimplifyPolygonEdgesSolver = class extends BaseSolver5 {
+var SimplifyPolygonEdgesSolver = class extends BaseSolver9 {
   constructor(input) {
     super();
     this.input = input;
@@ -53595,13 +54672,13 @@ import { LayoutPipelineSolver } from "@tscircuit/matchpack";
 import { SchematicTracePipelineSolver } from "@tscircuit/schematic-trace-solver";
 
 // node_modules/@tscircuit/via-stitch-solver/lib/solvers/ViaStitchSolver.ts
-import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver10 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/via-stitch-solver/lib/geometry/brep-point-containment.ts
 var POINT_EPSILON = 1e-8;
 var isPointOnSegment = (point6, start, end) => {
-  const cross4 = (point6.y - start.y) * (end.x - start.x) - (point6.x - start.x) * (end.y - start.y);
-  if (Math.abs(cross4) > POINT_EPSILON) return false;
+  const cross5 = (point6.y - start.y) * (end.x - start.x) - (point6.x - start.x) * (end.y - start.y);
+  if (Math.abs(cross5) > POINT_EPSILON) return false;
   const dot = (point6.x - start.x) * (end.x - start.x) + (point6.y - start.y) * (end.y - start.y);
   if (dot < -POINT_EPSILON) return false;
   const squaredLength = (end.x - start.x) ** 2 + (end.y - start.y) ** 2;
@@ -53922,7 +54999,7 @@ var getGridCoordinates = ({
   }
   return coordinates;
 };
-var ViaStitchSolver = class extends BaseSolver6 {
+var ViaStitchSolver = class extends BaseSolver10 {
   constructor(input) {
     super();
     this.input = input;
@@ -54069,6 +55146,7 @@ var ViaStitchSolver = class extends BaseSolver6 {
 // lib/solvers.ts
 import { PackSolver2 } from "calculate-packing";
 var SOLVERS = {
+  DogboneFanoutSolver,
   BusLanesSolver,
   PackSolver2,
   LayoutPipelineSolver,
@@ -54532,6 +55610,27 @@ var localAutorouterStrategies = /* @__PURE__ */ new Map([
     createFanoutAutorouterStrategy("single_layer_fanout")
   ],
   ["fanout", createFanoutAutorouterStrategy("fanout")],
+  [
+    "dogbone",
+    {
+      name: "dogbone",
+      preserveOutputTraces: true,
+      followUpAutorouter: "default",
+      cacheable: false,
+      getSolverName: () => "DogboneFanoutSolver",
+      create: ({
+        simpleRouteJson,
+        fanoutRoutingLayers,
+        onSolverStarted,
+        onSolverEnded
+      }) => {
+        return new DogboneAutorouter(
+          { input: simpleRouteJson, fanoutRoutingLayers },
+          { onSolverStarted, onSolverEnded }
+        );
+      }
+    }
+  ],
   [
     "bus_lanes",
     {
@@ -61008,19 +62107,19 @@ import Debug12 from "debug";
 import { isValidElement as isValidElement2 } from "react";
 
 // lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/segment-intersection.ts
-var cross3 = (ax, ay, bx, by) => {
+var cross4 = (ax, ay, bx, by) => {
   return ax * by - ay * bx;
 };
 function segmentIntersection(p1, p2, q1, q2, tol) {
   const r = { x: p2.x - p1.x, y: p2.y - p1.y };
   const s = { x: q2.x - q1.x, y: q2.y - q1.y };
-  const rxs = cross3(r.x, r.y, s.x, s.y);
+  const rxs = cross4(r.x, r.y, s.x, s.y);
   const q_p = { x: q1.x - p1.x, y: q1.y - p1.y };
-  const q_pxr = cross3(q_p.x, q_p.y, r.x, r.y);
+  const q_pxr = cross4(q_p.x, q_p.y, r.x, r.y);
   if (Math.abs(rxs) < tol && Math.abs(q_pxr) < tol) return null;
   if (Math.abs(rxs) < tol && Math.abs(q_pxr) >= tol) return null;
-  const t = cross3(q_p.x, q_p.y, s.x, s.y) / rxs;
-  const u = cross3(q_p.x, q_p.y, r.x, r.y) / rxs;
+  const t = cross4(q_p.x, q_p.y, s.x, s.y) / rxs;
+  const u = cross4(q_p.x, q_p.y, r.x, r.y) / rxs;
   if (t < -tol || t > 1 + tol || u < -tol || u > 1 + tol) return null;
   return { x: p1.x + t * r.x, y: p1.y + t * r.y };
 }
@@ -61213,8 +62312,8 @@ function isParallel(e1, e2, tol = TOL2) {
   const L1 = Math.hypot(v1.x, v1.y);
   const L2 = Math.hypot(v2.x, v2.y);
   if (L1 < tol || L2 < tol) return true;
-  const cross4 = v1.x * v2.y - v1.y * v2.x;
-  return Math.abs(cross4) <= tol * L1 * L2;
+  const cross5 = v1.x * v2.y - v1.y * v2.x;
+  return Math.abs(cross5) <= tol * L1 * L2;
 }
 function incidentEdgesAtPoint(trace, p, tol = TOL2) {
   return trace.edges.filter(
@@ -64481,6 +65580,16 @@ function Group_getRoutingPhasePlans(group) {
       nets: nets.filter((net) => breakoutByNet.get(net) === breakout),
       traces: breakoutTraces
     };
+    if (breakout.isDogboneFanout && breakoutProps2.pcbTracePaths === void 0) {
+      breakoutPlans.push({
+        ...breakoutPlan,
+        // Keep the local fanout outline while allowing dogbone sites outside
+        // the pad bounding box to use the full board routing bounds.
+        routingBounds: void 0,
+        fanoutBounds: routingBounds
+      });
+      continue;
+    }
     if (breakout._parsedProps.pcbTracePaths !== void 0) {
       breakoutPlans.push({
         ...breakoutPlan,
@@ -64553,7 +65662,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.2023",
+  version: "0.0.2025",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -64594,6 +65703,7 @@ var package_default = {
     "@tscircuit/common": "^0.0.20",
     "@tscircuit/copper-pour-solver": "^0.0.62",
     "@tscircuit/create-fdm-enclosure": "0.0.4",
+    "@tscircuit/dogbone-solver": "https://jscdn.tscircuit.com/@tscircuit/dogbone-solver/0.0.1.tgz",
     "@tscircuit/fanout-solver": "0.0.78",
     "@tscircuit/flex-utils": "https://jscdn.tscircuit.com/@tscircuit/flex-utils/0.0.5.tgz",
     "@tscircuit/footprinter": "^0.0.426",
@@ -65021,7 +66131,6 @@ function Group_syncFanoutExitsWithGlobalConnections({
         ) ? [{ globalConnection, pointIndex, previousPoint }] : []
       )
     );
-    if (globalPointMatches.length === 0) continue;
     const changedPointIndex = outputConnection.pointsToConnect.findIndex(
       (outputPoint, pointIndex) => {
         const inputPoint = inputConnection.pointsToConnect[pointIndex];
@@ -65030,6 +66139,14 @@ function Group_syncFanoutExitsWithGlobalConnections({
     );
     if (changedPointIndex < 0) continue;
     const fanoutExitPoint = outputConnection.pointsToConnect[changedPointIndex];
+    if (globalPointMatches.length === 0) {
+      synchronizedBreakoutPoints.push({
+        sourceTraceId: inputConnection.source_trace_id,
+        routingPcbGroupId,
+        previousPoint: inputConnection.pointsToConnect[changedPointIndex],
+        fanoutExitPoint
+      });
+    }
     for (const {
       globalConnection,
       pointIndex,
@@ -65290,7 +66407,7 @@ function getAccumulatedPcbTracesWithStageOutputReplacements({
 }
 
 // lib/components/primitive-components/Group/get-source-trace-id-for-routed-trace.ts
-import { distance as distance15, pointToSegmentDistance as pointToSegmentDistance3 } from "@tscircuit/math-utils";
+import { distance as distance17, pointToSegmentDistance as pointToSegmentDistance3 } from "@tscircuit/math-utils";
 import { ConnectivityMap as ConnectivityMap5 } from "circuit-json-to-connectivity-map";
 var POINT_EPSILON2 = 1e-6;
 function isPointOnWireSegment({
@@ -65312,7 +66429,7 @@ function isPointInSmtPad({
     return Math.abs(point6.x - pad.x) <= pad.width / 2 + traceWidth / 2 && Math.abs(point6.y - pad.y) <= pad.height / 2 + traceWidth / 2;
   }
   if (pad.shape === "circle") {
-    return distance15(point6, pad) <= pad.radius + traceWidth / 2;
+    return distance17(point6, pad) <= pad.radius + traceWidth / 2;
   }
   return false;
 }
@@ -65321,7 +66438,7 @@ function isPointInPlatedHole({
   hole,
   traceWidth = 0
 }) {
-  return distance15(point6, hole) <= (hole.outer_diameter ?? hole.hole_diameter ?? 0) / 2 + traceWidth / 2;
+  return distance17(point6, hole) <= (hole.outer_diameter ?? hole.hole_diameter ?? 0) / 2 + traceWidth / 2;
 }
 function getEndpointSourcePortIdsFromGeometry(db, trace) {
   const sourcePortIds = /* @__PURE__ */ new Set();
@@ -65334,7 +66451,7 @@ function getEndpointSourcePortIdsFromGeometry(db, trace) {
       if (!pcbPort.source_port_id) continue;
       if (endpoint.layer && pcbPort.layers && !pcbPort.layers.includes(endpoint.layer))
         continue;
-      if (distance15(endpoint, pcbPort) <= 0.01) {
+      if (distance17(endpoint, pcbPort) <= 0.01) {
         sourcePortIds.add(pcbPort.source_port_id);
       }
     }
@@ -66018,8 +67135,8 @@ var Group5 = class extends NormalComponent {
     const groupProps2 = props;
     const hasOutline = groupProps2.outline && groupProps2.outline.length > 0;
     const numericOutline = hasOutline ? groupProps2.outline.map((point6) => ({
-      x: distance16.parse(point6.x),
-      y: distance16.parse(point6.y)
+      x: distance18.parse(point6.x),
+      y: distance18.parse(point6.y)
     })) : void 0;
     const ctx = this.props;
     const anchorPosition = this._getGlobalPcbPositionBeforeLayout();
@@ -66057,8 +67174,8 @@ var Group5 = class extends NormalComponent {
     const hasExplicitPositioning = this._parsedProps.pcbX !== void 0 || this._parsedProps.pcbY !== void 0;
     if (hasOutline) {
       const numericOutline = props.outline.map((point6) => ({
-        x: distance16.parse(point6.x),
-        y: distance16.parse(point6.y)
+        x: distance18.parse(point6.x),
+        y: distance18.parse(point6.y)
       }));
       const outlineBounds = getBoundsFromPoints9(numericOutline);
       if (!outlineBounds) return;
@@ -66459,7 +67576,9 @@ var Group5 = class extends NormalComponent {
       routingPhaseDebugLabels.set(plan, `${label} ${ordinal}`);
     }
     const hasFanoutStage = routingStages.some(
-      ({ autorouterConfig: autorouterConfig2 }) => ["fanout", "single_layer_fanout"].includes(autorouterConfig2.preset ?? "")
+      ({ autorouterConfig: autorouterConfig2 }) => ["fanout", "single_layer_fanout", "dogbone"].includes(
+        autorouterConfig2.preset ?? ""
+      )
     );
     const fanoutPourNetMap = hasFanoutStage ? Group_getFanoutPourNetMap(this, routingPhasePlans) : void 0;
     let { simpleRouteJson: baseSimpleRouteJson } = getSimpleRouteJsonFromCircuitJson({
@@ -66882,6 +68001,11 @@ var Group5 = class extends NormalComponent {
           } else {
             autorouter = localAutorouterStrategy.create({
               simpleRouteJson,
+              onSolverEnded: (event) => this.root?.emit("solver:ended", {
+                ...event,
+                type: "solver:ended",
+                componentName: this.getString()
+              }),
               commonAutorouterOptions,
               busFanoutDirections: routingPhasePlan.busFanoutDirections,
               fanoutBounds: routingPhasePlan.fanoutBounds,
@@ -66937,7 +68061,7 @@ var Group5 = class extends NormalComponent {
           traces = await routingPromise;
         }
         let transformedSimpleRouteJson = precomputedOutputSimpleRouteJson ?? autorouter?.getOutputSimpleRouteJson?.();
-        if (transformedSimpleRouteJson && !usesPreviousStageOutput && ["fanout", "single_layer_fanout"].includes(
+        if (transformedSimpleRouteJson && !usesPreviousStageOutput && ["fanout", "single_layer_fanout", "dogbone"].includes(
           phaseAutorouterConfig.preset ?? ""
         ) && routingPhasePlan.routingPcbGroupId) {
           const synchronizedFanout = Group_syncFanoutExitsWithGlobalConnections(
@@ -66957,10 +68081,14 @@ var Group5 = class extends NormalComponent {
             if (!breakoutPoint) continue;
             db.pcb_breakout_point.update(breakoutPoint.pcb_breakout_point_id, {
               x: synchronizedPoint.fanoutExitPoint.x,
-              y: synchronizedPoint.fanoutExitPoint.y
+              y: synchronizedPoint.fanoutExitPoint.y,
+              layer: synchronizedPoint.fanoutExitPoint.layer
             });
           }
         }
+        if (localAutorouterStrategy.preserveOutputTraces) {
+          for (const trace of traces) fixedTraceIds.add(trace.pcb_trace_id);
+        }
         let stageOutputTraces = traces;
         if (transformedSimpleRouteJson?.traces) {
           stageOutputTraces = transformedSimpleRouteJson.traces;
@@ -66997,7 +68125,7 @@ var Group5 = class extends NormalComponent {
           subcircuit: this,
           input: simpleRouteJson,
           traces,
-          isFanout: ["fanout", "single_layer_fanout"].includes(
+          isFanout: ["fanout", "single_layer_fanout", "dogbone"].includes(
             phaseAutorouterConfig.preset ?? ""
           )
         });
@@ -67930,8 +69058,8 @@ var Led_addPolarityFabricationSymbol = (led) => {
   const a = db.pcb_port.getWhere({ source_port_id: anode.source_port_id });
   const k = db.pcb_port.getWhere({ source_port_id: cathode.source_port_id });
   if (!a || !k) return;
-  const distance23 = Math.hypot(k.x - a.x, k.y - a.y);
-  if (distance23 < 1e-6) return;
+  const distance25 = Math.hypot(k.x - a.x, k.y - a.y);
+  if (distance25 < 1e-6) return;
   const angle = Math.atan2(k.y - a.y, k.x - a.x);
   const frame = compose15(
     translate15((a.x + k.x) / 2, (a.y + k.y) / 2),
@@ -67945,10 +69073,10 @@ var Led_addPolarityFabricationSymbol = (led) => {
   };
   const notes = [];
   generatedNotes.set(led, notes);
-  const halfLength = Math.min(distance23 * 0.2, 0.4);
+  const halfLength = Math.min(distance25 * 0.2, 0.4);
   const halfHeight = halfLength * 0.75;
   const routes = [
-    [point6(-distance23 / 2, 0), point6(-halfLength, 0)],
+    [point6(-distance25 / 2, 0), point6(-halfLength, 0)],
     [
       point6(-halfLength, -halfHeight),
       point6(halfLength, 0),
@@ -67956,7 +69084,7 @@ var Led_addPolarityFabricationSymbol = (led) => {
       point6(-halfLength, -halfHeight)
     ],
     [point6(halfLength, -halfHeight), point6(halfLength, halfHeight)],
-    [point6(halfLength, 0), point6(distance23 / 2, 0)]
+    [point6(halfLength, 0), point6(distance25 / 2, 0)]
   ];
   for (const route of routes) {
     notes.push(
@@ -69890,7 +71018,7 @@ var Board_doInitialPcbPlacementDesignRuleChecks = (board) => {
 
 // lib/components/normal-components/Board/board-castellated-hole.ts
 import {
-  distance as distance17
+  distance as distance19
 } from "circuit-json";
 var CASTELLATED_HOLE_ENDPOINT_TOLERANCE_MM = 1e-6;
 var getConnectionTargets2 = (connectsTo) => {
@@ -69911,8 +71039,8 @@ var BoardCastellatedHole = class _BoardCastellatedHole extends PlatedHole {
   constructor(outlinePoint, outlinePointIndex) {
     const name = `castellated_hole_${outlinePointIndex + 1}`;
     const connectionTargets = getConnectionTargets2(outlinePoint.connectsTo);
-    const holeDiameter = distance17.parse(outlinePoint.holeDiameter);
-    const padDiameter = distance17.parse(outlinePoint.padDiameter);
+    const holeDiameter = distance19.parse(outlinePoint.holeDiameter);
+    const padDiameter = distance19.parse(outlinePoint.padDiameter);
     super({
       shape: "circle",
       holeDiameter,
@@ -70662,11 +71790,11 @@ var MountedBoard = class extends Subcircuit {
 
 // lib/components/normal-components/Panel.ts
 import { panelProps } from "@tscircuit/props";
-import { distance as distance21 } from "circuit-json";
+import { distance as distance23 } from "circuit-json";
 
 // lib/components/normal-components/Subpanel.ts
 import { subpanelProps } from "@tscircuit/props";
-import { distance as distance20 } from "circuit-json";
+import { distance as distance22 } from "circuit-json";
 import { compose as compose17, identity as identity9, translate as translate17 } from "transformation-matrix";
 
 // lib/utils/panels/generate-panel-tabs-and-mouse-bites.ts
@@ -70930,15 +72058,15 @@ function generatePanelOutlineRoutingCutouts(boards, options) {
 }
 
 // lib/utils/panels/pack-into-grid.ts
-import { distance as distance19 } from "circuit-json";
+import { distance as distance21 } from "circuit-json";
 
 // lib/utils/panels/get-board-dimensions-from-props.ts
 import { getBoundsFromPoints as getBoundsFromPoints11 } from "@tscircuit/math-utils";
-import { distance as distance18 } from "circuit-json";
+import { distance as distance20 } from "circuit-json";
 var getBoardDimensionsFromProps = (board) => {
   const props = board._parsedProps;
-  let width = props.width != null ? distance18.parse(props.width) : void 0;
-  let height = props.height != null ? distance18.parse(props.height) : void 0;
+  let width = props.width != null ? distance20.parse(props.width) : void 0;
+  let height = props.height != null ? distance20.parse(props.height) : void 0;
   if ((width === void 0 || height === void 0) && props.outline?.length) {
     const outlineBounds = getBoundsFromPoints11(props.outline);
     if (outlineBounds) {
@@ -70982,8 +72110,8 @@ function packIntoGrid({
   }
   let cols;
   let rows;
-  const minCellWidth = cellWidth ? distance19.parse(cellWidth) : 0;
-  const minCellHeight = cellHeight ? distance19.parse(cellHeight) : 0;
+  const minCellWidth = cellWidth ? distance21.parse(cellWidth) : 0;
+  const minCellHeight = cellHeight ? distance21.parse(cellHeight) : 0;
   if (col !== void 0) {
     cols = col;
     rows = row ?? Math.ceil(itemsWithDims.length / cols);
@@ -71082,8 +72210,8 @@ function getItemDimensions(item, db) {
     const props = subpanel._parsedProps;
     if (props.width !== void 0 && props.height !== void 0) {
       return {
-        width: distance19.parse(props.width),
-        height: distance19.parse(props.height)
+        width: distance21.parse(props.width),
+        height: distance21.parse(props.height)
       };
     }
     const directBoards = subpanel._getDirectBoardChildren();
@@ -71110,7 +72238,7 @@ function getItemDimensions(item, db) {
       return getBoardDimensionsFromProps(directBoards[0]);
     }
     if (subpanel._cachedGridWidth > 0 && subpanel._cachedGridHeight > 0) {
-      const edgePadding = distance19.parse(props.edgePadding ?? 5);
+      const edgePadding = distance21.parse(props.edgePadding ?? 5);
       return {
         width: subpanel._cachedGridWidth + edgePadding * 2,
         height: subpanel._cachedGridHeight + edgePadding * 2
@@ -71268,17 +72396,17 @@ var Subpanel = class _Subpanel extends Group5 {
         edgePaddingTop: edgePaddingTopProp,
         edgePaddingBottom: edgePaddingBottomProp
       } = this._parsedProps;
-      const edgePadding = distance20.parse(edgePaddingProp ?? 5);
-      const edgePaddingLeft = distance20.parse(edgePaddingLeftProp ?? edgePadding);
-      const edgePaddingRight = distance20.parse(
+      const edgePadding = distance22.parse(edgePaddingProp ?? 5);
+      const edgePaddingLeft = distance22.parse(edgePaddingLeftProp ?? edgePadding);
+      const edgePaddingRight = distance22.parse(
         edgePaddingRightProp ?? edgePadding
       );
-      const edgePaddingTop = distance20.parse(edgePaddingTopProp ?? edgePadding);
-      const edgePaddingBottom = distance20.parse(
+      const edgePaddingTop = distance22.parse(edgePaddingTopProp ?? edgePadding);
+      const edgePaddingBottom = distance22.parse(
         edgePaddingBottomProp ?? edgePadding
       );
-      const panelWidth = distance20.parse(this._parsedProps.width);
-      const panelHeight = distance20.parse(this._parsedProps.height);
+      const panelWidth = distance22.parse(this._parsedProps.width);
+      const panelHeight = distance22.parse(this._parsedProps.height);
       availablePanelWidth = panelWidth - edgePaddingLeft - edgePaddingRight;
       availablePanelHeight = panelHeight - edgePaddingTop - edgePaddingBottom;
     }
@@ -71353,8 +72481,8 @@ var Subpanel = class _Subpanel extends Group5 {
     if (!this.pcb_group_id) return;
     if (hasExplicitWidth && hasExplicitHeight) {
       db.pcb_group.update(this.pcb_group_id, {
-        width: distance20.parse(this._parsedProps.width),
-        height: distance20.parse(this._parsedProps.height)
+        width: distance22.parse(this._parsedProps.width),
+        height: distance22.parse(this._parsedProps.height)
       });
     } else if (gridWidth > 0 || gridHeight > 0) {
       const {
@@ -71364,18 +72492,18 @@ var Subpanel = class _Subpanel extends Group5 {
         edgePaddingTop: edgePaddingTopProp,
         edgePaddingBottom: edgePaddingBottomProp
       } = this._parsedProps;
-      const edgePadding = distance20.parse(edgePaddingProp ?? 5);
-      const edgePaddingLeft = distance20.parse(edgePaddingLeftProp ?? edgePadding);
-      const edgePaddingRight = distance20.parse(
+      const edgePadding = distance22.parse(edgePaddingProp ?? 5);
+      const edgePaddingLeft = distance22.parse(edgePaddingLeftProp ?? edgePadding);
+      const edgePaddingRight = distance22.parse(
         edgePaddingRightProp ?? edgePadding
       );
-      const edgePaddingTop = distance20.parse(edgePaddingTopProp ?? edgePadding);
-      const edgePaddingBottom = distance20.parse(
+      const edgePaddingTop = distance22.parse(edgePaddingTopProp ?? edgePadding);
+      const edgePaddingBottom = distance22.parse(
         edgePaddingBottomProp ?? edgePadding
       );
       db.pcb_group.update(this.pcb_group_id, {
-        width: hasExplicitWidth ? distance20.parse(this._parsedProps.width) : gridWidth + edgePaddingLeft + edgePaddingRight,
-        height: hasExplicitHeight ? distance20.parse(this._parsedProps.height) : gridHeight + edgePaddingTop + edgePaddingBottom
+        width: hasExplicitWidth ? distance22.parse(this._parsedProps.width) : gridWidth + edgePaddingLeft + edgePaddingRight,
+        height: hasExplicitHeight ? distance22.parse(this._parsedProps.height) : gridHeight + edgePaddingTop + edgePaddingBottom
       });
     }
   }
@@ -71463,8 +72591,8 @@ var Panel = class extends Subpanel {
     const { db } = this.root;
     const props = this._parsedProps;
     const inserted = db.pcb_panel.insert({
-      width: props.width !== void 0 ? distance21.parse(props.width) : 0,
-      height: props.height !== void 0 ? distance21.parse(props.height) : 0,
+      width: props.width !== void 0 ? distance23.parse(props.width) : 0,
+      height: props.height !== void 0 ? distance23.parse(props.height) : 0,
       thickness: 1.6,
       center: this._getGlobalPcbPositionBeforeLayout(),
       covered_with_solder_mask: !(props.noSolderMask ?? false)
@@ -71483,8 +72611,8 @@ var Panel = class extends Subpanel {
     if (!this.pcb_panel_id) return;
     if (hasExplicitWidth && hasExplicitHeight) {
       db.pcb_panel.update(this.pcb_panel_id, {
-        width: distance21.parse(this._parsedProps.width),
-        height: distance21.parse(this._parsedProps.height)
+        width: distance23.parse(this._parsedProps.width),
+        height: distance23.parse(this._parsedProps.height)
       });
     } else if (gridWidth > 0 || gridHeight > 0) {
       const {
@@ -71494,18 +72622,18 @@ var Panel = class extends Subpanel {
         edgePaddingTop: edgePaddingTopProp,
         edgePaddingBottom: edgePaddingBottomProp
       } = this._parsedProps;
-      const edgePadding = distance21.parse(edgePaddingProp ?? 5);
-      const edgePaddingLeft = distance21.parse(edgePaddingLeftProp ?? edgePadding);
-      const edgePaddingRight = distance21.parse(
+      const edgePadding = distance23.parse(edgePaddingProp ?? 5);
+      const edgePaddingLeft = distance23.parse(edgePaddingLeftProp ?? edgePadding);
+      const edgePaddingRight = distance23.parse(
         edgePaddingRightProp ?? edgePadding
       );
-      const edgePaddingTop = distance21.parse(edgePaddingTopProp ?? edgePadding);
-      const edgePaddingBottom = distance21.parse(
+      const edgePaddingTop = distance23.parse(edgePaddingTopProp ?? edgePadding);
+      const edgePaddingBottom = distance23.parse(
         edgePaddingBottomProp ?? edgePadding
       );
       db.pcb_panel.update(this.pcb_panel_id, {
-        width: hasExplicitWidth ? distance21.parse(this._parsedProps.width) : gridWidth + edgePaddingLeft + edgePaddingRight,
-        height: hasExplicitHeight ? distance21.parse(this._parsedProps.height) : gridHeight + edgePaddingTop + edgePaddingBottom
+        width: hasExplicitWidth ? distance23.parse(this._parsedProps.width) : gridWidth + edgePaddingLeft + edgePaddingRight,
+        height: hasExplicitHeight ? distance23.parse(this._parsedProps.height) : gridHeight + edgePaddingTop + edgePaddingBottom
       });
     }
   }
@@ -71516,8 +72644,8 @@ var Panel = class extends Subpanel {
     const props = this._parsedProps;
     const currentPanel = db.pcb_panel.get(this.pcb_panel_id);
     db.pcb_panel.update(this.pcb_panel_id, {
-      width: props.width !== void 0 ? distance21.parse(props.width) : currentPanel?.width,
-      height: props.height !== void 0 ? distance21.parse(props.height) : currentPanel?.height,
+      width: props.width !== void 0 ? distance23.parse(props.width) : currentPanel?.width,
+      height: props.height !== void 0 ? distance23.parse(props.height) : currentPanel?.height,
       center: this._getGlobalPcbPositionBeforeLayout(),
       covered_with_solder_mask: !(props.noSolderMask ?? false)
     });
@@ -73339,7 +74467,7 @@ var PcbNoteDimension = class extends PrimitiveComponent2 {
 import { breakoutProps } from "@tscircuit/props";
 
 // lib/components/primitive-components/AutoplacedBreakoutPoint.ts
-import { layer_ref as layer_ref3 } from "circuit-json";
+import { layer_ref as layer_ref4 } from "circuit-json";
 var AutoplacedBreakoutPoint = class extends BaseBreakoutPoint {
   get config() {
     return {
@@ -73353,7 +74481,7 @@ var AutoplacedBreakoutPoint = class extends BaseBreakoutPoint {
     position
   }) {
     this.matchedSourceTraceId = sourceTraceId;
-    this._renderPcbBreakoutPoint({ layer: layer_ref3.parse(layer) });
+    this._renderPcbBreakoutPoint({ layer: layer_ref4.parse(layer) });
     this._setPositionFromLayout(position);
   }
 };
@@ -74065,7 +75193,7 @@ var validateWindingBreakoutInput = (input) => {
 };
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/solvers/GatePlacementSolver.ts
-import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver11 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/gate-placement/place-breakout-gates.ts
 var GEOMETRY_EPSILON = 1e-9;
@@ -74595,7 +75723,7 @@ var getSharedGateSlotCount = (points) => new Set(
     (point6) => `${point6.regionId}:${point6.x.toFixed(9)}:${point6.y.toFixed(9)}`
   )
 ).size;
-var GatePlacementSolver = class extends BaseSolver7 {
+var GatePlacementSolver = class extends BaseSolver11 {
   constructor(params) {
     super();
     this.params = params;
@@ -74734,7 +75862,7 @@ var GatePlacementSolver = class extends BaseSolver7 {
 };
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/solvers/ReferenceOrderingSolver.ts
-import { BaseSolver as BaseSolver8 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver12 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/ordering/get-natural-winding-order.ts
 var getNaturalWindingOrder = (region, connections) => connections.map((connection) => {
@@ -74801,7 +75929,7 @@ var getReferenceWindingOrder = (naturalOrder, atomicGroups, buses) => {
 };
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/solvers/ReferenceOrderingSolver.ts
-var ReferenceOrderingSolver = class extends BaseSolver8 {
+var ReferenceOrderingSolver = class extends BaseSolver12 {
   constructor(params) {
     super();
     this.params = params;
@@ -75853,6 +76981,10 @@ var solveImplicitBreakoutPoints = (breakout, solverFn) => {
 
 // lib/components/primitive-components/Breakout/Breakout.ts
 var Breakout = class extends Group5 {
+  get isDogboneFanout() {
+    const autorouter = this._parsedProps.autorouter;
+    return (typeof autorouter === "string" ? autorouter : autorouter?.preset) === "dogbone";
+  }
   get isRoutingDirective() {
     return true;
   }
@@ -75911,7 +77043,7 @@ var Breakout = class extends Group5 {
       for (const port of result.ports) {
         const isInside = breakoutPortSet.has(port);
         const hasOutsidePort = result.ports.some((p) => !breakoutPortSet.has(p));
-        if (!isInside || !hasOutsidePort) continue;
+        if (!isInside || !hasOutsidePort && !this.isDogboneFanout) continue;
         if (manuallyMappedPorts.has(port)) continue;
         if (autoPlacedPorts.has(port)) continue;
         autoPlacedPorts.add(port);
@@ -75924,6 +77056,20 @@ var Breakout = class extends Group5 {
   }
   doInitialPcbAutoplaceBreakoutPoints() {
     if (this.root?.pcbDisabled) return;
+    if (this.isDogboneFanout && this._parsedProps.pcbTracePaths === void 0) {
+      for (const point6 of this.children) {
+        if (!(point6 instanceof AutoplacedBreakoutPoint)) continue;
+        const port = this.root.db.pcb_port.get(
+          point6.matchedPort.pcb_port_id
+        );
+        point6._applySolvedBreakoutPoint({
+          sourceTraceId: point6.matchedSourceTraceId,
+          layer: port.layers[0],
+          position: port
+        });
+      }
+      return;
+    }
     const ownAutorouter = this.props.autorouter;
     const inheritedAutorouter = ownAutorouter === void 0 ? this.parent?.getInheritedProperty("autorouter") : void 0;
     const implicitBreakoutPointSolverFn = typeof ownAutorouter === "object" ? ownAutorouter.implicitBreakoutPointSolverFn : typeof inheritedAutorouter === "object" ? inheritedAutorouter.implicitBreakoutPointSolverFn : void 0;
@@ -76146,7 +77292,7 @@ var SilkscreenGraphic = class extends PrimitiveComponent2 {
 
 // lib/components/primitive-components/Fiducial.ts
 import "zod";
-import { distance as distance22 } from "circuit-json";
+import { distance as distance24 } from "circuit-json";
 import { fiducialProps as fiducialProps2 } from "@tscircuit/props";
 var Fiducial = class extends PrimitiveComponent2 {
   pcb_smtpad_id = null;
@@ -76171,15 +77317,15 @@ var Fiducial = class extends PrimitiveComponent2 {
       shape: "circle",
       x: position.x,
       y: position.y,
-      radius: distance22.parse(props.padDiameter) / 2,
-      soldermask_margin: props.soldermaskPullback ? distance22.parse(props.soldermaskPullback) : distance22.parse(props.padDiameter) / 2,
+      radius: distance24.parse(props.padDiameter) / 2,
+      soldermask_margin: props.soldermaskPullback ? distance24.parse(props.soldermaskPullback) : distance24.parse(props.padDiameter) / 2,
       is_covered_with_solder_mask: true
     });
     this.pcb_smtpad_id = pcb_smtpad.pcb_smtpad_id;
   }
   getPcbSize() {
     const { _parsedProps: props } = this;
-    const d = distance22.parse(props.padDiameter);
+    const d = distance24.parse(props.padDiameter);
     return { width: d, height: d };
   }
   _setPositionFromLayout(newCenter) {
@@ -76223,15 +77369,15 @@ import {
 } from "@tscircuit/copper-pour-solver";
 
 // lib/components/primitive-components/CopperPour/utils/mark-trace-segments-inside-copper-pour.ts
-var EPSILON24 = 1e-9;
+var EPSILON26 = 1e-9;
 var isWireRoutePoint = (routePoint) => routePoint.route_type === "wire";
 var isPointOnSegment2 = (p, a, b) => {
-  const cross4 = (p.y - a.y) * (b.x - a.x) - (p.x - a.x) * (b.y - a.y);
-  if (Math.abs(cross4) > EPSILON24) return false;
+  const cross5 = (p.y - a.y) * (b.x - a.x) - (p.x - a.x) * (b.y - a.y);
+  if (Math.abs(cross5) > EPSILON26) return false;
   const dot = (p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y);
-  if (dot < -EPSILON24) return false;
+  if (dot < -EPSILON26) return false;
   const squaredLength = (b.x - a.x) ** 2 + (b.y - a.y) ** 2;
-  if (dot - squaredLength > EPSILON24) return false;
+  if (dot - squaredLength > EPSILON26) return false;
   return true;
 };
 var isPointInRing2 = (point6, ring) => {
@@ -76255,7 +77401,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 + EPSILON24 && Math.abs(localY) <= height / 2 + EPSILON24;
+  return Math.abs(localX) <= width / 2 + EPSILON26 && Math.abs(localY) <= height / 2 + EPSILON26;
 };
 var isPointInBrepPour = (p, pour) => {
   const outerRing = pour.brep_shape.outer_ring.vertices.map((v) => ({
@@ -76289,7 +77435,7 @@ var isSegmentFullyInsideCopperPour = (start, end, pour) => {
   const dx = end.x - start.x;
   const dy = end.y - start.y;
   const length8 = Math.hypot(dx, dy);
-  if (length8 <= EPSILON24) return false;
+  if (length8 <= EPSILON26) return false;
   const samples = [0, 0.25, 0.5, 0.75, 1];
   return samples.every(
     (t) => isPointInCopperPour(