@tscircuit/core 0.0.1914 → 0.0.1916

package/dist/index.js

@@ -6119,11 +6119,11 @@ function Trace_doInitialPcbTraceRender(trace) {
       const closestNetBPort = getClosest(netAPort, netBPorts);
       const netAPortPosition = netAPort._getGlobalPcbPositionBeforeLayout();
       const netBPortPosition = closestNetBPort._getGlobalPcbPositionBeforeLayout();
-      const distance22 = Math.sqrt(
+      const distance23 = Math.sqrt(
         (netAPortPosition.x - netBPortPosition.x) ** 2 + (netAPortPosition.y - netBPortPosition.y) ** 2
       );
-      if (distance22 < closestDistance) {
-        closestDistance = distance22;
+      if (distance23 < closestDistance) {
+        closestDistance = distance23;
         closestPortPair = [netAPort, closestNetBPort];
       }
     }
@@ -7283,7 +7283,7 @@ var getMaxLengthFromConnectedComponents = (ports, { db }) => {
       return sourceComponent.max_decoupling_trace_length;
     }
     return null;
-  }).filter((length7) => typeof length7 === "number");
+  }).filter((length8) => typeof length8 === "number");
   if (componentMaxLengths.length === 0) return void 0;
   return Math.min(...componentMaxLengths);
 };
@@ -10130,11 +10130,11 @@ import { schematicPathProps } from "@tscircuit/props";
 import SVGPathCommander from "svg-path-commander";
 function sampleCurveSegment(segmentPath, samplesPerUnit) {
   const commander = new SVGPathCommander(segmentPath);
-  const length7 = commander.getTotalLength();
-  const numSamples = Math.max(2, Math.ceil(length7 * samplesPerUnit));
+  const length8 = commander.getTotalLength();
+  const numSamples = Math.max(2, Math.ceil(length8 * samplesPerUnit));
   const points = [];
   for (let i = 1; i <= numSamples; i++) {
-    const t = i / numSamples * length7;
+    const t = i / numSamples * length8;
     const point6 = commander.getPointAtLength(t);
     points.push({ x: point6.x, y: point6.y });
   }
@@ -12303,7 +12303,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 distance22 = elm.distance_from_component_edge;
+        const distance23 = elm.distance_from_component_edge;
         const facingDirection = getFacingDirectionFromSide(
           elm.side_of_component
         );
@@ -12311,8 +12311,8 @@ var createComponentsFromCircuitJson = ({
         const directionVector = getUnitVectorFromDirection2(facingDirection);
         const stemDirection = elm.facing_direction === facingDirection ? 1 : -1;
         const portCenter = {
-          x: elm.center.x + directionVector.x * distance22 * stemDirection,
-          y: elm.center.y + directionVector.y * distance22 * stemDirection
+          x: elm.center.x + directionVector.x * distance23 * stemDirection,
+          y: elm.center.y + directionVector.y * distance23 * stemDirection
         };
         const sourcePort = sourcePortsByImportedId.get(elm.source_port_id);
         const aliases = Array.from(
@@ -13543,9 +13543,9 @@ var getLabelPlacementAlongRoute = (route) => {
   for (let pointIndex = 1; pointIndex < route.length; pointIndex++) {
     const from = route[pointIndex - 1];
     const to = route[pointIndex];
-    const length7 = Math.hypot(to.x - from.x, to.y - from.y);
-    if (length7 > longestSegment.length) {
-      longestSegment = { from, to, length: length7 };
+    const length8 = Math.hypot(to.x - from.x, to.y - from.y);
+    if (length8 > longestSegment.length) {
+      longestSegment = { from, to, length: length8 };
     }
   }
   const deltaX = longestSegment.to.x - longestSegment.from.x;
@@ -16770,15 +16770,15 @@ var Capacitor_addPolarityFabricationSymbols = (capacitor) => {
     source_port_id: negatives[0].source_port_id
   });
   if (!positive || !negative) return;
-  const distance22 = Math.hypot(negative.x - positive.x, negative.y - positive.y);
-  if (distance22 < 1e-6) return;
+  const distance23 = Math.hypot(negative.x - positive.x, negative.y - positive.y);
+  if (distance23 < 1e-6) return;
   const frame = compose6(
     translate4((positive.x + negative.x) / 2, (positive.y + negative.y) / 2),
     rotate3(Math.atan2(negative.y - positive.y, negative.x - positive.x))
   );
   const point6 = (x, y) => applyToPoint25(frame, { x, y });
-  const offset = distance22 / 4;
-  const halfSize = Math.min(distance22 * 0.12, 0.3);
+  const offset = distance23 / 4;
+  const halfSize = Math.min(distance23 * 0.12, 0.3);
   const routes = [
     [point6(-offset - halfSize, 0), point6(-offset + halfSize, 0)],
     [point6(-offset, -halfSize), point6(-offset, halfSize)],
@@ -18270,7 +18270,7 @@ import {
   groupProps
 } from "@tscircuit/props";
 import {
-  distance as distance15
+  distance as distance16
 } from "circuit-json";
 import Debug15 from "debug";
 
@@ -18977,7 +18977,7 @@ function validateOriginalEndpointConnectivity(params) {
         representativeConnection.name
       )
     ).map((obstacle) => ({ type: "obstacle", obstacle }));
-    const routeCopper = (routedSrj.traces ?? []).filter(
+    const routeCopper2 = (routedSrj.traces ?? []).filter(
       (trace) => traceBelongsToNet(inputSrj, trace, representativeConnection)
     ).flatMap((trace) => extractTraceCopper(trace, layerNames));
     const planeCopper = [
@@ -18994,7 +18994,7 @@ function validateOriginalEndpointConnectivity(params) {
     const copper = [
       ...endpointCopper,
       ...obstacleCopper,
-      ...routeCopper,
+      ...routeCopper2,
       ...planeCopper
     ];
     const connectedCopper = new DisjointSet(copper.length);
@@ -19469,8 +19469,8 @@ function getTerminalDirections(params) {
     x: plan.targetPoint.x - plan.sourcePoint.x,
     y: plan.targetPoint.y - plan.sourcePoint.y
   };
-  const length7 = Math.hypot(rawOutward.x, rawOutward.y);
-  const outward = length7 > EPSILON4 ? { x: rawOutward.x / length7, y: rawOutward.y / length7 } : { x: 1, y: 0 };
+  const length8 = Math.hypot(rawOutward.x, rawOutward.y);
+  const outward = length8 > EPSILON4 ? { x: rawOutward.x / length8, y: rawOutward.y / length8 } : { x: 1, y: 0 };
   return {
     outward,
     perpendicular: { x: -outward.y, y: outward.x }
@@ -19759,7 +19759,7 @@ function runLocalCompletionPass(params) {
   };
 }
 function traceLength(trace) {
-  let length7 = 0;
+  let length8 = 0;
   let previousWire;
   for (const point6 of trace.route) {
     if (point6.route_type !== "wire") {
@@ -19767,10 +19767,10 @@ function traceLength(trace) {
       continue;
     }
     if (previousWire?.layer === point6.layer)
-      length7 += distance9(previousWire, point6);
+      length8 += distance9(previousWire, point6);
     previousWire = point6;
   }
-  return length7;
+  return length8;
 }
 function trimCompletedFanoutTails(params) {
   const { fanoutSrj, completionTraces } = params;
@@ -20480,8 +20480,8 @@ function* getMultiSegmentTuningWindows(params) {
   for (const [index, segment2] of plan.segments.entries()) {
     if (segment2.layer !== plan.targetLayer || index < (plan.sourceEscapeSegmentCount ?? 1))
       continue;
-    const length7 = distance9(segment2.start, segment2.end);
-    const steps = Math.max(1, Math.ceil(length7 / (segment2.width / 2)));
+    const length8 = distance9(segment2.start, segment2.end);
+    const steps = Math.max(1, Math.ceil(length8 / (segment2.width / 2)));
     for (let step = 0; step <= steps; step++) {
       consumeWork();
       const fraction = step / steps;
@@ -26416,7 +26416,7 @@ function hasValidTurns(segments) {
     const segment2 = segments[i];
     const dx = segment2.end.x - segment2.start.x;
     const dy = segment2.end.y - segment2.start.y;
-    const length7 = Math.hypot(dx, dy);
+    const length8 = Math.hypot(dx, dy);
     if (Math.min(
       Math.abs(dx),
       Math.abs(dy),
@@ -26425,12 +26425,12 @@ function hasValidTurns(segments) {
       return false;
     const next = segments[i + 1];
     if (next && distance9(segment2.end, next.start) > EPSILON8) return false;
-    if (!next || next.layer !== segment2.layer || length7 < EPSILON8) continue;
+    if (!next || next.layer !== segment2.layer || length8 < EPSILON8) continue;
     const nx = next.end.x - next.start.x;
     const ny = next.end.y - next.start.y;
     const nextLength = Math.hypot(nx, ny);
     if (nextLength < EPSILON8) continue;
-    if ((dx * nx + dy * ny) / (length7 * nextLength) < Math.SQRT1_2 - EPSILON8)
+    if ((dx * nx + dy * ny) / (length8 * nextLength) < Math.SQRT1_2 - EPSILON8)
       return false;
   }
   return true;
@@ -26751,7 +26751,7 @@ function normalizeFanoutPlanCorners(params) {
         0
       )
     );
-    if (lengths.some((length7) => !Number.isFinite(length7)) || Math.abs(lengths[0] - lengths[1]) > pair.lengthTolerance + EPSILON8)
+    if (lengths.some((length8) => !Number.isFinite(length8)) || Math.abs(lengths[0] - lengths[1]) > pair.lengthTolerance + EPSILON8)
       return null;
   }
   if (params.inputSrj.traces?.length && plans.length) {
@@ -26990,7 +26990,7 @@ function rebuildTraceRoute(plan, segments) {
 function createPlanWithSegments(plan, segments, updateSourceEscapeCount = false) {
   const route = rebuildTraceRoute(plan, segments);
   if (!route) return null;
-  const length7 = [...segments, ...plan.planeEndpointSegments ?? []].reduce(
+  const length8 = [...segments, ...plan.planeEndpointSegments ?? []].reduce(
     (total, segment2) => total + distance9(segment2.start, segment2.end),
     0
   );
@@ -27002,7 +27002,7 @@ function createPlanWithSegments(plan, segments, updateSourceEscapeCount = false)
     ...updateSourceEscapeCount && plan.sourceEscapeSegmentCount !== void 0 && sourceEscapeSegmentCount >= 0 ? { sourceEscapeSegmentCount } : {},
     trace: { ...plan.trace, route },
     segments,
-    length: length7
+    length: length8
   };
 }
 function addedTuningViasAreSelfClear(plan, addedVias, clearance) {
@@ -27532,11 +27532,11 @@ function* createExtendedFoldCandidates(params) {
         continue;
     } else if (start.layer !== plan.targetLayer && (!params.allowTransitLayerMatching || !(bus.allowedLayers ?? [plan.targetLayer]).includes(start.layer) || !(bus.routableEscapeLayers ?? bus.allowedLayers ?? [plan.targetLayer]).includes(start.layer)))
       continue;
-    const length7 = distance9(start.start, start.end);
-    if (length7 <= EPSILON9) continue;
+    const length8 = distance9(start.start, start.end);
+    if (length8 <= EPSILON9) continue;
     const direction = {
-      x: (start.end.x - start.start.x) / length7,
-      y: (start.end.y - start.start.y) / length7
+      x: (start.end.x - start.start.x) / length8,
+      y: (start.end.y - start.start.y) / length8
     };
     for (let last = first + 2; last < Math.min(plan.segments.length, first + 16); last++) {
       const span = plan.segments.slice(first, last + 1);
@@ -27613,19 +27613,19 @@ function* createSpreadLaneCandidates(plan, clearance, workBudget) {
   for (const { segment: segment2, index } of plan.segments.map((segment3, index2) => ({ segment: segment3, index: index2 })).filter(({ segment: segment3 }) => segment3.layer === plan.targetLayer).toSorted(
     (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 <= EPSILON9) continue;
+    const length8 = distance9(segment2.start, segment2.end);
+    if (length8 <= EPSILON9) continue;
     const dx = Math.abs(segment2.end.x - segment2.start.x);
     const dy = Math.abs(segment2.end.y - segment2.start.y);
     if (dx > EPSILON9 && dy > EPSILON9 && Math.abs(dx - dy) > EPSILON9) continue;
     const tangent = {
-      x: (segment2.end.x - segment2.start.x) / length7,
-      y: (segment2.end.y - segment2.start.y) / length7
+      x: (segment2.end.x - segment2.start.x) / length8,
+      y: (segment2.end.y - segment2.start.y) / length8
     };
     const pitch = segment2.width + clearance;
     for (const multiple of [2, 3, 4, 6]) {
       const offset = pitch * multiple;
-      if (length7 < 2 * offset + pitch) continue;
+      if (length8 < 2 * offset + pitch) continue;
       for (const sign of [1, -1]) {
         consumeMatchingWork(workBudget);
         const normal = { x: -tangent.y * sign, y: tangent.x * sign };
@@ -28395,15 +28395,15 @@ function sourceOriginRouteIsSelfClear(params) {
     const radius = (viaDiameter + traceWidth) / 2 + clearance;
     const incident = /* @__PURE__ */ new Set();
     for (const direction of [-1, 1]) {
-      let point6 = via.center, length7 = 0;
+      let point6 = via.center, length8 = 0;
       const z18 = direction === -1 ? via.fromZ : via.toZ;
       for (let edge = via.edge + direction; edge >= 0 && edge + 1 < points.length; edge += direction) {
         const a = points[edge], b = points[edge + 1];
         const near = direction === -1 ? b : a, far = direction === -1 ? a : b;
-        if (a.z !== z18 || b.z !== z18 || distance9(point6, near) > 1e-7 || length7 > radius + 1e-7)
+        if (a.z !== z18 || b.z !== z18 || distance9(point6, near) > 1e-7 || length8 > radius + 1e-7)
           break;
         incident.add(edge);
-        length7 += distance9(near, far);
+        length8 += distance9(near, far);
         point6 = far;
       }
     }
@@ -28466,10 +28466,10 @@ function shortcutSection(points, width, clear) {
       const lowerBound = Math.max(dx, dy) + (Math.SQRT2 - 1) * Math.min(dx, dy);
       if (cost[i] + lowerBound >= cost[j] - EPSILON10) continue;
       for (const path of connectorVariants(a, b)) {
-        const length7 = path.slice(1).reduce((sum, p, index) => sum + distance9(path[index], p), 0);
-        if (cost[i] + length7 >= cost[j] - EPSILON10 || !path.slice(1).every((p, index) => clear(path[index], p)))
+        const length8 = path.slice(1).reduce((sum, p, index) => sum + distance9(path[index], p), 0);
+        if (cost[i] + length8 >= cost[j] - EPSILON10 || !path.slice(1).every((p, index) => clear(path[index], p)))
           continue;
-        cost[j] = cost[i] + length7;
+        cost[j] = cost[i] + length8;
         edges[j] = { previous: i, points: path };
       }
     }
@@ -28814,14 +28814,14 @@ var intersectsRegion = (regions, a, b = a) => regions.some(
 );
 function terminalSuffixAt(segments, point6, layer) {
   const positions = [];
-  let length7 = 0;
+  let length8 = 0;
   for (const [index2, segment2] of segments.entries()) {
     if (segment2.layer === layer && distancePointToSegment(point6, segment2.start, segment2.end) < 1e-8) {
-      const offset = length7 + distance9(segment2.start, point6);
+      const offset = length8 + distance9(segment2.start, point6);
       if (!positions.some((p) => Math.abs(p.offset - offset) < 1e-8))
         positions.push({ index: index2, offset });
     }
-    length7 += distance9(segment2.start, segment2.end);
+    length8 += distance9(segment2.start, segment2.end);
   }
   if (positions.length !== 1) return null;
   let index = positions[0].index;
@@ -28884,12 +28884,12 @@ function boundaryTerminalPlanIsSelfClear(params) {
       if (Math.abs(ux * vy - uy * vx) >= 1e-10 || ux * vx + uy * vy < 0) break;
       runStart = previous.start;
     }
-    const length7 = distance9(runStart, cut);
-    if (length7 < 1e-10) return false;
-    const trim = Math.min(maximumJoinLength, length7 / 3);
+    const length8 = distance9(runStart, cut);
+    if (length8 < 1e-10) return false;
+    const trim = Math.min(maximumJoinLength, length8 / 3);
     cut = {
-      x: cut.x + (runStart.x - cut.x) * trim / length7,
-      y: cut.y + (runStart.y - cut.y) * trim / length7
+      x: cut.x + (runStart.x - cut.x) * trim / length8,
+      y: cut.y + (runStart.y - cut.y) * trim / length8
     };
   }
   const suffix = terminalSuffixAt(plan.segments, cut, start.layer);
@@ -33562,13 +33562,13 @@ function* sourcePrefixFoldShortcuts(plan, clearance) {
   if (first < 0) return;
   const pitch = prefix[first].width + clearance;
   for (let start = first; start >= Math.max(0, first - 3); start--) {
-    let length7 = 0;
+    let length8 = 0;
     for (let end = start; end < Math.min(prefix.length, first + 8); end++) {
       const segment2 = prefix[end];
       if (segment2.layer !== plan.sourceLayer || end > start && distance9(prefix[end - 1].end, segment2.start) > 1e-7)
         break;
-      length7 += distance9(segment2.start, segment2.end);
-      if (length7 > 4 * pitch + 1e-7) break;
+      length8 += distance9(segment2.start, segment2.end);
+      if (length8 > 4 * pitch + 1e-7) break;
       if (end <= first) continue;
       const a = prefix[start].start, b = segment2.end, dx = b.x - a.x, dy = b.y - a.y, diagonal = Math.min(Math.abs(dx), Math.abs(dy));
       for (const bend of [
@@ -33581,7 +33581,7 @@ function* sourcePrefixFoldShortcuts(plan, clearance) {
           y: b.y - Math.sign(dy) * diagonal
         }
       ]) {
-        if (distance9(a, bend) + distance9(bend, b) >= length7 - 1e-7) continue;
+        if (distance9(a, bend) + distance9(bend, b) >= length8 - 1e-7) continue;
         yield [
           prefix[0].start,
           ...prefix.slice(0, start).map((s) => s.end),
@@ -33711,8 +33711,8 @@ function repairSourcePadReentries(params) {
           const key = JSON.stringify([anchor, points]);
           if (seen.has(key)) continue;
           seen.add(key);
-          const length7 = points.slice(1).reduce((sum, p, i) => sum + distance9(points[i], p), 0) + prefix.slice(anchor).reduce((sum, s) => sum + distance9(s.start, s.end), 0);
-          proposals.push({ anchor, points, length: length7 });
+          const length8 = points.slice(1).reduce((sum, p, i) => sum + distance9(points[i], p), 0) + prefix.slice(anchor).reduce((sum, s) => sum + distance9(s.start, s.end), 0);
+          proposals.push({ anchor, points, length: length8 });
         }
       }
     }
@@ -37514,9 +37514,9 @@ function getFreeBoundaryTracks(params) {
   for (const via of vias) {
     if (!via.spanLayers.includes(targetLayer2)) continue;
     const radius = via.diameter / 2 + traceWidth / 2 + clearance;
-    const distance22 = Math.abs(via.center[across] - edge);
-    if (distance22 >= radius) continue;
-    const extent = Math.sqrt(radius * radius - distance22 * distance22);
+    const distance23 = Math.abs(via.center[across] - edge);
+    if (distance23 >= radius) continue;
+    const extent = Math.sqrt(radius * radius - distance23 * distance23);
     blocked.push([via.center[along] - extent, via.center[along] + extent]);
   }
   const gaps = [];
@@ -38731,8 +38731,8 @@ var LayerRoutingAttempts = class {
 
 // node_modules/@tscircuit/fanout-solver/lib/get-boundary-approach-reservations.ts
 function getBoundaryApproachReservations(params) {
-  const length7 = params.traceWidth + params.clearance;
-  if (!Number.isFinite(length7) || !(params.traceWidth > 0) || params.clearance < 0)
+  const length8 = params.traceWidth + params.clearance;
+  if (!Number.isFinite(length8) || !(params.traceWidth > 0) || params.clearance < 0)
     throw new Error("Boundary approach reservations require valid trace rules");
   return params.buses.filter(
     (bus) => bus.termination.type === "boundary" && !params.excludedBusIds.has(bus.busId)
@@ -38749,10 +38749,10 @@ function getBoundaryApproachReservations(params) {
           `Missing boundary approach target for ${connection.connectionIndex}`
         );
       const start = { ...end };
-      if (bus.exitEdge === "bottom") start.y += length7;
-      else if (bus.exitEdge === "top") start.y -= length7;
-      else if (bus.exitEdge === "left") start.x += length7;
-      else start.x -= length7;
+      if (bus.exitEdge === "bottom") start.y += length8;
+      else if (bus.exitEdge === "top") start.y -= length8;
+      else if (bus.exitEdge === "left") start.x += length8;
+      else start.x -= length8;
       return {
         type: "pcb_trace",
         pcb_trace_id: `fanout-approach-reservation:${connection.connectionIndex}`,
@@ -43010,7 +43010,7 @@ function validateDifferentialPairs(inputSrj, plansByConnection, issues) {
         0
       )
     );
-    if (lengths.some((length7) => !Number.isFinite(length7))) {
+    if (lengths.some((length8) => !Number.isFinite(length8))) {
       addIssue2(
         issues,
         "invalid-differential-pair",
@@ -49205,6 +49205,8 @@ function getPresetAutoroutingConfig(autorouterConfig, platformConfig) {
         groupMode: "subcircuit",
         preset: "single_layer_fanout"
       };
+    case "bus-lanes":
+      return { local: true, groupMode: "subcircuit", preset: "bus_lanes" };
     case "fanout":
       return {
         local: true,
@@ -49267,6 +49269,1153 @@ function getPresetAutoroutingConfig(autorouterConfig, platformConfig) {
   }
 }
 
+// node_modules/@tscircuit/bus-lanes-solver/lib/bus-lanes-solver.ts
+import { BaseSolver as BaseSolver4 } 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);
+function pointSegmentDistance(p, edge) {
+  const [a, b] = edge, dx = b.x - a.x, dy = b.y - a.y, t = Math.max(
+    0,
+    Math.min(
+      1,
+      ((p.x - a.x) * dx + (p.y - a.y) * dy) / (dx * dx + dy * dy || 1)
+    )
+  );
+  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);
+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)
+    return 0;
+  return Math.min(
+    pointSegmentDistance(a, cd),
+    pointSegmentDistance(b, cd),
+    pointSegmentDistance(c, ab),
+    pointSegmentDistance(d, ab)
+  );
+}
+var length = (path) => path.slice(1).reduce((sum, p, i) => sum + distance12(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
+  );
+}
+
+// node_modules/@tscircuit/bus-lanes-solver/lib/vector-scene.ts
+function fixedCopper(input) {
+  const result = [];
+  for (const o of input.obstacles)
+    for (const layer of o.layers)
+      result.push({
+        a: o.center,
+        b: o.center,
+        radius: 0,
+        layer,
+        owners: o.connectedTo,
+        rect: {
+          minX: o.center.x - o.width / 2,
+          maxX: o.center.x + o.width / 2,
+          minY: o.center.y - o.height / 2,
+          maxY: o.center.y + o.height / 2
+        }
+      });
+  const layers = Array.from(
+    { length: input.layerCount },
+    (_, i) => i === 0 ? "top" : i === input.layerCount - 1 ? "bottom" : `inner${i}`
+  );
+  for (const t of input.traces ?? [])
+    for (let i = 0; i < t.route.length; i++) {
+      const p = t.route[i], q = t.route[i + 1], owners = [t.connection_name ?? "", t.source_trace_id ?? ""];
+      if (p.route_type === "via") {
+        const a = layers.indexOf(p.from_layer), b = layers.indexOf(p.to_layer);
+        for (const layer of p.layers ?? layers.slice(Math.min(a, b), Math.max(a, b) + 1))
+          result.push({
+            a: p,
+            b: p,
+            radius: (p.via_diameter ?? 0.3) / 2,
+            layer,
+            owners
+          });
+      } else if (q?.route_type === "wire") {
+        if (p.layer !== q.layer)
+          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) {
+        const wire = p.route_type === "wire" ? p : q;
+        result.push({
+          a: p,
+          b: q,
+          radius: wire.width / 2,
+          layer: wire.layer,
+          owners
+        });
+      }
+    }
+  return result;
+}
+function routeCopper(t) {
+  return t.route.slice(1).map((p, i) => ({
+    a: t.route[i],
+    b: p,
+    radius: p.width / 2,
+    layer: p.layer,
+    owners: [t.connection_name ?? ""]
+  }));
+}
+var intersectsRect = (a, b, r) => {
+  let t0 = 0, t1 = 1;
+  for (const [origin, delta, min, max] of [
+    [a.x, b.x - a.x, r.minX, r.maxX],
+    [a.y, b.y - a.y, r.minY, r.maxY]
+  ]) {
+    if (Math.abs(delta) < 1e-12) {
+      if (origin < min || origin > max) return false;
+      continue;
+    }
+    let lo = (min - origin) / delta, hi = (max - origin) / delta;
+    if (lo > hi) [lo, hi] = [hi, lo];
+    t0 = Math.max(t0, lo);
+    t1 = Math.min(t1, hi);
+    if (t0 > t1) return false;
+  }
+  return true;
+};
+function clearanceToCopper(a, b, c) {
+  if (!c.rect) return segmentDistance([a, b], [c.a, c.b]) - c.radius;
+  const r = c.rect;
+  if (intersectsRect(a, b, r)) return 0;
+  const corners = [
+    { x: r.minX, y: r.minY },
+    { x: r.maxX, y: r.minY },
+    { x: r.maxX, y: r.maxY },
+    { x: r.minX, y: r.maxY }
+  ];
+  return Math.min(
+    ...corners.map(
+      (p, i) => segmentDistance([a, b], [p, corners[(i + 1) % 4]])
+    )
+  );
+}
+var VectorScene = class {
+  constructor(input, connection, width, all) {
+    this.input = input;
+    this.connection = connection;
+    this.width = width;
+    this.owners = new Set(
+      [
+        connection.name,
+        connection.source_trace_id,
+        ...connection.pointsToConnect.flatMap((p) => [
+          p.pointId,
+          p.pcb_port_id
+        ])
+      ].filter((s) => !!s)
+    );
+    this.copper = all.filter(
+      (c) => c.layer === connection.pointsToConnect[0].layer && !c.owners.some((n) => this.owners.has(n))
+    );
+    this.margin = width / 2 + (input.minTraceToPadEdgeClearance ?? input.defaultObstacleMargin ?? 0.075);
+  }
+  input;
+  connection;
+  width;
+  copper;
+  owners;
+  margin;
+  visible(a, b) {
+    const m = this.width / 2 + (this.input.minBoardEdgeClearance ?? 0), r = this.input.bounds;
+    if ([a, b].some(
+      (p) => p.x < r.minX + m - 1e-9 || p.x > r.maxX - m + 1e-9 || p.y < r.minY + m - 1e-9 || p.y > r.maxY - m + 1e-9
+    ))
+      return false;
+    const minX = Math.min(a.x, b.x) - this.margin, maxX = Math.max(a.x, b.x) + this.margin, minY = Math.min(a.y, b.y) - this.margin, maxY = Math.max(a.y, b.y) + this.margin;
+    for (const c of this.copper) {
+      const r2 = c.rect ?? {
+        minX: Math.min(c.a.x, c.b.x) - c.radius,
+        maxX: Math.max(c.a.x, c.b.x) + c.radius,
+        minY: Math.min(c.a.y, c.b.y) - c.radius,
+        maxY: Math.max(c.a.y, c.b.y) + c.radius
+      };
+      if (r2.minX > maxX || r2.maxX < minX || r2.minY > maxY || r2.maxY < minY)
+        continue;
+      if (clearanceToCopper(a, b, c) < this.margin - 1e-8) return false;
+    }
+    return true;
+  }
+  pathVisible(path) {
+    return path.slice(1).every((b, i) => this.visible(path[i], b));
+  }
+  /** Vertices of circumscribed octagonal Minkowski offsets. Their edges are
+   * horizontal, vertical or 45 degrees, including circular vias and trace caps. */
+  vertices() {
+    const result = [], k = Math.SQRT2 - 1, epsilon = 1e-5;
+    for (const c of this.copper) {
+      if (c.rect) {
+        const r = c.rect, m = this.margin + epsilon;
+        result.push(
+          { x: r.minX - m, y: r.minY - m },
+          { x: r.minX - m, y: r.maxY + m },
+          { x: r.maxX + m, y: r.minY - m },
+          { x: r.maxX + m, y: r.maxY + m }
+        );
+      } 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 [x, y] of [
+            [1, k],
+            [k, 1],
+            [-k, 1],
+            [-1, k],
+            [-1, -k],
+            [-k, -1],
+            [k, -1],
+            [1, -k]
+          ])
+            result.push({ x: p.x + x * r, y: p.y + y * r });
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    return result.filter((p) => {
+      const key = `${p.x.toFixed(9)},${p.y.toFixed(9)}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return this.visible(p, p);
+    });
+  }
+};
+
+// node_modules/@tscircuit/bus-lanes-solver/lib/min-heap.ts
+var MinHeap2 = class {
+  entries = [];
+  sequence = 0;
+  get length() {
+    return this.entries.length;
+  }
+  values() {
+    return this.entries.map((e) => e.value);
+  }
+  before(a, b) {
+    return a.value.f < b.value.f || a.value.f === b.value.f && a.sequence < b.sequence;
+  }
+  push(value) {
+    const entry = { value, sequence: this.sequence++ };
+    let i = this.entries.length;
+    this.entries.push(entry);
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (!this.before(entry, this.entries[parent])) break;
+      this.entries[i] = this.entries[parent];
+      i = parent;
+    }
+    this.entries[i] = entry;
+  }
+  pop() {
+    const first = this.entries[0], last = this.entries.pop();
+    if (this.entries.length) {
+      let i = 0;
+      while (i * 2 + 1 < this.entries.length) {
+        let child = i * 2 + 1;
+        if (child + 1 < this.entries.length && this.before(this.entries[child + 1], this.entries[child]))
+          child++;
+        if (!this.before(this.entries[child], last)) break;
+        this.entries[i] = this.entries[child];
+        i = child;
+      }
+      this.entries[i] = last;
+    }
+    return first.value;
+  }
+};
+
+// node_modules/@tscircuit/bus-lanes-solver/lib/vector-visibility.ts
+function connectors(a, b) {
+  const dx = b.x - a.x, dy = b.y - a.y, sx = Math.sign(dx), sy = Math.sign(dy), d = Math.min(Math.abs(dx), Math.abs(dy));
+  if (Math.min(Math.abs(dx), Math.abs(dy)) < 1e-10 || Math.abs(Math.abs(dx) - Math.abs(dy)) < 1e-10)
+    return [[a, b]];
+  const lead = (Math.max(Math.abs(dx), Math.abs(dy)) - d) / 2;
+  const centered = Math.abs(dx) > Math.abs(dy) ? [a, { x: a.x + sx * lead, y: a.y }, { x: b.x - sx * lead, y: b.y }, b] : [a, { x: a.x, y: a.y + sy * lead }, { x: b.x, y: b.y - sy * lead }, b];
+  return [
+    centered,
+    [a, { x: a.x + sx * d, y: a.y + sy * d }, b],
+    [a, { x: b.x - sx * d, y: b.y - sy * d }, b],
+    [a, { x: a.x, y: b.y }, b],
+    [a, { x: b.x, y: a.y }, b]
+  ];
+}
+var VectorVisibilitySearch = class {
+  constructor(scene, start, end) {
+    this.scene = scene;
+    this.start = start;
+    this.end = end;
+    this.vertices = [start, end];
+    this.open.push({ id: 0, g: 0, f: distance12(start, end) });
+    this.best.set(0, 0);
+  }
+  scene;
+  start;
+  end;
+  vertices;
+  open = new MinHeap2();
+  best = /* @__PURE__ */ new Map();
+  expanded = 0;
+  failed = false;
+  solved = false;
+  result = [];
+  geometryLoaded = false;
+  current;
+  visibleEdges = [];
+  step() {
+    if (!this.geometryLoaded) {
+      this.geometryLoaded = true;
+      const lowerBound = Math.max(
+        Math.abs(this.end.x - this.start.x),
+        Math.abs(this.end.y - this.start.y)
+      ) + (Math.SQRT2 - 1) * Math.min(
+        Math.abs(this.end.x - this.start.x),
+        Math.abs(this.end.y - this.start.y)
+      );
+      for (const path of connectors(this.start, this.end)) {
+        if (length(path) > lowerBound + 1e-9 || !this.scene.pathVisible(path))
+          continue;
+        this.visibleEdges = [path];
+        this.result = simplify(path);
+        this.solved = true;
+        this.expanded = 1;
+        return;
+      }
+      this.vertices.push(...this.scene.vertices());
+    }
+    if (!this.open.length) {
+      this.failed = true;
+      return;
+    }
+    const cur = this.open.pop();
+    if (cur.g > (this.best.get(cur.id) ?? Infinity) + 1e-9) return;
+    this.current = cur;
+    this.expanded++;
+    this.visibleEdges = [];
+    if (cur.id === 1) {
+      const edges = [];
+      for (let c = cur; c?.parent; c = c.parent)
+        edges.push(c.edge);
+      this.result = simplify([
+        this.start,
+        ...edges.reverse().flatMap((p) => p.slice(1))
+      ]);
+      this.solved = true;
+      return;
+    }
+    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);
+      if (lower >= (this.best.get(id) ?? Infinity) - 1e-9) continue;
+      const candidates = connectors(from, to).sort(
+        (a, b) => length(a) - length(b)
+      );
+      for (const path of candidates) {
+        const g = cur.g + length(path);
+        if (g >= (this.best.get(id) ?? Infinity) - 1e-9) continue;
+        if (!this.scene.pathVisible(path)) continue;
+        this.best.set(id, g);
+        this.open.push({
+          id,
+          g,
+          f: g + distance12(to, this.end),
+          parent: cur,
+          edge: path
+        });
+        if (this.visibleEdges.length < 100) this.visibleEdges.push(path);
+        break;
+      }
+    }
+  }
+  currentPath() {
+    const edges = [];
+    for (let c = this.current; c?.parent; c = c.parent) edges.push(c.edge);
+    return [this.start, ...edges.reverse().flatMap((e) => e.slice(1))];
+  }
+};
+
+// node_modules/@tscircuit/bus-lanes-solver/lib/winding-orders.ts
+function windingOrders(connections) {
+  const orders = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (order) => {
+    const key = order.map((c) => c.name).join("\0");
+    if (!seen.has(key)) {
+      seen.add(key);
+      orders.push(order);
+    }
+  };
+  const direction = connections.reduce(
+    (v, c) => ({
+      x: v.x + c.pointsToConnect[1].x - c.pointsToConnect[0].x,
+      y: v.y + c.pointsToConnect[1].y - c.pointsToConnect[0].y
+    }),
+    { x: 0, y: 0 }
+  );
+  const transverse = (c) => -direction.y * c.pointsToConnect[0].x + direction.x * c.pointsToConnect[0].y;
+  const sweep = [...connections].sort(
+    (a, b) => a.pointsToConnect[0].layer.localeCompare(b.pointsToConnect[0].layer) || transverse(a) - transverse(b) || a.name.localeCompare(b.name)
+  );
+  const span = (endpoint, axis) => Math.max(...connections.map((c) => c.pointsToConnect[endpoint][axis])) - Math.min(...connections.map((c) => c.pointsToConnect[endpoint][axis]));
+  const transverseAxis = span(0, "x") < 1e-7 && span(1, "x") < 1e-7 ? "y" : span(0, "y") < 1e-7 && span(1, "y") < 1e-7 ? "x" : void 0;
+  if (transverseAxis) {
+    const drift = connections.reduce(
+      (s, c) => s + c.pointsToConnect[1][transverseAxis] - c.pointsToConnect[0][transverseAxis],
+      0
+    );
+    if (Math.abs(drift) > 1e-7)
+      add(
+        [...connections].sort(
+          (a, b) => a.pointsToConnect[0].layer.localeCompare(
+            b.pointsToConnect[0].layer
+          ) || -Math.sign(drift) * (a.pointsToConnect[0][transverseAxis] - b.pointsToConnect[0][transverseAxis]) || a.name.localeCompare(b.name)
+        )
+      );
+  }
+  add(sweep);
+  add([...sweep].reverse());
+  add(connections);
+  for (const endpoint of [1, 0]) {
+    const center = connections.reduce(
+      (p, c) => ({
+        x: p.x + c.pointsToConnect[endpoint].x / connections.length,
+        y: p.y + c.pointsToConnect[endpoint].y / connections.length
+      }),
+      { x: 0, y: 0 }
+    );
+    const angle = (c) => Math.atan2(
+      c.pointsToConnect[endpoint].y - center.y,
+      c.pointsToConnect[endpoint].x - center.x
+    );
+    const angular = [...connections].sort(
+      (a, b) => angle(a) - angle(b) || a.name.localeCompare(b.name)
+    );
+    add(angular);
+    add([...angular].reverse());
+    for (const axis of ["x", "y"]) {
+      const other = axis === "x" ? "y" : "x";
+      const sorted = [...connections].sort(
+        (a, b) => a.pointsToConnect[endpoint][axis] - b.pointsToConnect[endpoint][axis] || a.pointsToConnect[endpoint][other] - b.pointsToConnect[endpoint][other]
+      );
+      add(sorted);
+      add([...sorted].reverse());
+    }
+    for (let i = 1; i < angular.length; i++) {
+      const rotated = [...angular.slice(i), ...angular.slice(0, i)];
+      add(rotated);
+      add([...rotated].reverse());
+    }
+  }
+  return orders;
+}
+
+// node_modules/@tscircuit/bus-lanes-solver/lib/route-lengths.ts
+function fixedRouteLength(input, name) {
+  const connection = input.connections.find((c) => c.name === name);
+  return (input.traces ?? []).filter(
+    (t) => t.connection_name === name || t.source_trace_id === (connection?.source_trace_id ?? name)
+  ).reduce((sum, t) => sum + length(t.route), 0);
+}
+function busLengthReports(input, traces) {
+  return (input.buses ?? []).map((bus) => {
+    const lengths = bus.connectionNames.map((name) => {
+      const route = traces.find((t) => t.connection_name === name);
+      return {
+        name,
+        carrierLengthMm: route ? length(route.route) : null,
+        fixedLengthMm: fixedRouteLength(input, name),
+        totalLengthMm: route ? length(route.route) + fixedRouteLength(input, name) : null
+      };
+    });
+    const complete = lengths.every((l) => l.totalLengthMm !== null);
+    const values = lengths.map((l) => l.totalLengthMm ?? 0);
+    const skewMm = complete && values.length ? Math.max(...values) - Math.min(...values) : null;
+    return {
+      busId: bus.busId,
+      toleranceMm: bus.maxLengthSkew ?? null,
+      skewMm,
+      matched: bus.maxLengthSkew !== void 0 && skewMm !== null && skewMm <= bus.maxLengthSkew + 1e-7,
+      lengths
+    };
+  });
+}
+function lengthConstraints(input) {
+  return [
+    ...(input.buses ?? []).filter((b) => b.maxLengthSkew !== void 0).map((b) => ({
+      names: b.connectionNames,
+      tolerance: b.maxLengthSkew
+    })),
+    ...(input.differentialPairs ?? []).map((p) => ({
+      names: p.connectionNames,
+      tolerance: p.lengthTolerance
+    }))
+  ];
+}
+function minimumLengthTargets(input, traces) {
+  const targets = new Map(
+    traces.map((t) => [
+      t.connection_name,
+      length(t.route) + fixedRouteLength(input, t.connection_name)
+    ])
+  );
+  const constraints = lengthConstraints(input);
+  for (let pass = 0; pass < targets.size; pass++) {
+    let changed = false;
+    for (const { names, tolerance } of constraints) {
+      const floor = Math.max(...names.map((n) => targets.get(n))) - tolerance;
+      for (const name of names)
+        if (targets.get(name) < floor - 1e-9) {
+          targets.set(name, floor);
+          changed = true;
+        }
+    }
+    if (!changed) break;
+  }
+  return targets;
+}
+function pairLengthReports(input, traces) {
+  return busLengthReports(
+    {
+      ...input,
+      buses: (input.differentialPairs ?? []).map((p, i) => ({
+        busId: `pair_${i}`,
+        connectionNames: p.connectionNames,
+        maxLengthSkew: p.lengthTolerance
+      }))
+    },
+    traces
+  );
+}
+
+// node_modules/@tscircuit/bus-lanes-solver/lib/spread-tuning-lanes.ts
+function spreadTuningLanes(input, traces, pitch) {
+  const dx = traces.reduce((s, t) => s + t.route.at(-1).x - t.route[0].x, 0);
+  const dy = traces.reduce((s, t) => s + t.route.at(-1).y - t.route[0].y, 0);
+  const angle = Math.round(Math.atan2(dy, dx) / (Math.PI / 4)) * Math.PI / 4, ux = Math.cos(angle), uy = Math.sin(angle);
+  const uv = (p) => ({ u: p.x * ux + p.y * uy, v: -p.x * uy + p.y * ux });
+  const xy = (u, v) => ({
+    x: u * ux - v * uy,
+    y: u * uy + v * ux
+  });
+  const result = [];
+  for (const layer of new Set(traces.map((t) => t.route[0].layer))) {
+    const group = traces.filter((t) => t.route[0].layer === layer).sort((a, b) => uv(a.route[0]).v - uv(b.route[0]).v);
+    const center = group.reduce(
+      (s, t) => s + (uv(t.route[0]).v + uv(t.route.at(-1)).v) / 2,
+      0
+    ) / group.length;
+    for (const [index, t] of group.entries()) {
+      const a = uv(t.route[0]), b = uv(t.route.at(-1)), v = center + (index - (group.length - 1) / 2) * pitch;
+      const da = Math.abs(v - a.v), db = Math.abs(v - b.v), space = b.u - a.u - da - db;
+      if (space < 1) return null;
+      const lead = space * 0.15;
+      const points = simplify([
+        xy(a.u, a.v),
+        xy(a.u + lead, a.v),
+        xy(a.u + lead + da, v),
+        xy(b.u - lead - db, v),
+        xy(b.u - lead, b.v),
+        xy(b.u, b.v)
+      ]);
+      result.push({
+        ...t,
+        route: points.map((p) => ({
+          ...p,
+          route_type: "wire",
+          layer,
+          width: t.route[0].width
+        }))
+      });
+    }
+  }
+  const copper = [...fixedCopper(input), ...result.flatMap(routeCopper)];
+  for (const t of result) {
+    const c = input.connections.find((c2) => c2.name === t.connection_name);
+    if (!new VectorScene(
+      input,
+      c,
+      t.route[0].width,
+      copper
+    ).pathVisible(t.route))
+      return null;
+  }
+  return traces.map(
+    (t) => result.find((r) => r.connection_name === t.connection_name)
+  );
+}
+
+// node_modules/@tscircuit/bus-lanes-solver/lib/length-tuning.ts
+function tuneLengths(input, traces, targets) {
+  const fixed = fixedCopper(input);
+  function* candidates(t, scene) {
+    const connection = input.connections.find(
+      (c) => c.name === t.connection_name
+    );
+    const width = t.route[0].width;
+    const delta = targets.get(connection.name) - length(t.route) - fixedRouteLength(input, connection.name);
+    if (delta < 1e-8) {
+      yield t;
+      return;
+    }
+    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);
+    for (const { i } of segments) {
+      const a = t.route[i], b = t.route[i + 1], span = distance12(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);
+      const preferredTeeth = Math.min(
+        maximumTeeth,
+        Math.max(2, Math.ceil(delta / (12 * width)))
+      );
+      const counts = Array.from({ length: maximumTeeth }, (_, i2) => i2 + 1).sort(
+        (a2, b2) => Math.abs(a2 - preferredTeeth) - Math.abs(b2 - preferredTeeth) || b2 - a2
+      );
+      for (const teeth of counts) {
+        for (const fraction of [0.9, 0.65, 0.4]) {
+          const w = span * fraction / teeth;
+          if (w < pitch) continue;
+          const c = Math.min(
+            delta / (2 * teeth),
+            w / 10,
+            (w / 2 - returnSpacing) / 2
+          );
+          const h = delta / (2 * teeth) + 2 * c * (2 - Math.SQRT2);
+          for (const phase of [0.5, 0, 1])
+            for (const side of [1, -1]) {
+              const at = (x, y) => ({
+                x: a.x + ux * x - uy * y * side,
+                y: a.y + uy * x + ux * y * side
+              });
+              const bump = [at(0, 0)];
+              for (let tooth = 0; tooth < teeth; tooth++) {
+                const offset = span * (1 - fraction) * (0.05 + 0.9 * phase) + tooth * w, gap = w * 0.5;
+                bump.push(
+                  ...[
+                    [offset, 0],
+                    [offset + c, c],
+                    [offset + c, h - c],
+                    [offset + 2 * c, h],
+                    [offset + gap - 2 * c, h],
+                    [offset + gap - c, h - c],
+                    [offset + gap - c, c],
+                    [offset + gap, 0]
+                  ].map(([x, y]) => at(x, y))
+                );
+              }
+              bump.push(at(span, 0));
+              if (!scene.pathVisible(bump)) continue;
+              const next = simplify([
+                ...t.route.slice(0, i),
+                ...bump,
+                ...t.route.slice(i + 2)
+              ]);
+              if (Math.abs(
+                length(next) + fixedRouteLength(input, connection.name) - targets.get(connection.name)
+              ) > 1e-6)
+                continue;
+              if (!tuningPathIsSelfClear(next, returnSpacing)) continue;
+              yield {
+                ...t,
+                route: next.map((p) => ({
+                  ...p,
+                  route_type: "wire",
+                  layer: connection.pointsToConnect[0].layer,
+                  width
+                }))
+              };
+            }
+        }
+      }
+    }
+  }
+  const result = [...traces];
+  const pending = new Set(traces.map((_, i) => i));
+  let changed = true;
+  while (pending.size && changed) {
+    changed = false;
+    for (const index of pending) {
+      const connection = input.connections.find(
+        (c) => c.name === traces[index].connection_name
+      );
+      const scene = new VectorScene(
+        input,
+        connection,
+        traces[index].route[0].width,
+        [...fixed, ...result.flatMap(routeCopper)]
+      );
+      const next = candidates(traces[index], scene).next().value;
+      if (!next) continue;
+      result[index] = next;
+      pending.delete(index);
+      changed = true;
+    }
+  }
+  if (pending.size)
+    throw Error(
+      `Insufficient tuning clearance for ${[...pending].map((i) => traces[i].connection_name).join(", ")}`
+    );
+  return result;
+}
+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]));
+  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;
+      const a = path[i], b = path[i + 1], c = path[j], d = path[j + 1];
+      if (Math.max(a.x, b.x) + required < Math.min(c.x, d.x) || Math.max(c.x, d.x) + required < Math.min(a.x, b.x) || Math.max(a.y, b.y) + required < Math.min(c.y, d.y) || Math.max(c.y, d.y) + required < Math.min(a.y, b.y))
+        continue;
+      if (segmentDistance([a, b], [c, d]) >= required - 1e-8) continue;
+      let sx = 0, sy = 0;
+      for (let k = i; k <= j; k++) {
+        const dx = path[k + 1].x - path[k].x, dy = path[k + 1].y - path[k].y;
+        if (Math.abs(dx) > 1e-8) {
+          if (sx && sx !== Math.sign(dx)) return false;
+          sx = Math.sign(dx);
+        }
+        if (Math.abs(dy) > 1e-8) {
+          if (sy && sy !== Math.sign(dy)) return false;
+          sy = Math.sign(dy);
+        }
+      }
+    }
+  return true;
+}
+
+// node_modules/@tscircuit/bus-lanes-solver/lib/layer-colors.ts
+var layerColors = {
+  top: "#dc2626",
+  inner1: "#ca8a04",
+  inner2: "#16a34a",
+  inner3: "#0891b2",
+  inner4: "#9333ea",
+  inner5: "#ea580c",
+  inner6: "#db2777",
+  bottom: "#2563eb"
+};
+var layerColor = (layer) => layerColors[layer] ?? "#64748b";
+
+// node_modules/@tscircuit/bus-lanes-solver/lib/bus-lanes-solver.ts
+var BusLanesSolver = class extends BaseSolver4 {
+  input;
+  options;
+  phase = "validate";
+  failureCode = null;
+  traces = [];
+  widths = /* @__PURE__ */ new Map();
+  fixed = [];
+  orders = [];
+  attempt = 0;
+  lane = 0;
+  search;
+  bestPartial = [];
+  constructor(input, options = {}) {
+    super();
+    this.input = structuredClone(input);
+    this.options = options;
+    this.MAX_ITERATIONS = options.maxSearchIterations ?? 2e5;
+  }
+  getConstructorParams() {
+    return [this.input, this.options];
+  }
+  getOutput() {
+    if (!this.solved) throw Error(this.error ?? "Bus lanes are not solved");
+    return {
+      ...this.input,
+      traces: [...this.input.traces ?? [], ...this.traces]
+    };
+  }
+  fail(code, message) {
+    this.failureCode = code;
+    this.error = message;
+    this.failed = true;
+    this.phase = "failed";
+  }
+  tryFinalAcceptance() {
+    if (!this.solved)
+      this.fail(
+        "search_budget_exhausted",
+        "Vector visibility search budget exhausted"
+      );
+  }
+  initialize() {
+    const input = this.input;
+    if (input.outline?.length) {
+      this.fail("unsupported_outline", "Custom board outlines are unsupported");
+      return;
+    }
+    if (input.differentialPairs?.some(
+      (p) => p.traceGap !== void 0 || p.maxUncoupledLength !== void 0
+    )) {
+      this.fail(
+        "unsupported_coupling",
+        "Coupled differential geometry is not supported"
+      );
+      return;
+    }
+    const names = /* @__PURE__ */ new Set();
+    for (const c of input.connections) {
+      if (names.has(c.name)) throw Error(`Duplicate connection ${c.name}`);
+      names.add(c.name);
+      if (c.pointsToConnect.length !== 2) {
+        this.fail(
+          "invalid_terminals",
+          `${c.name}: exactly two terminals required`
+        );
+        return;
+      }
+      const [a, b] = c.pointsToConnect;
+      if (a.layers || b.layers || a.layer !== b.layer) {
+        this.fail(
+          "layer_change_required",
+          `${c.name}: ${a.layer} \u2192 ${b.layer}; a common fixed layer is required; fanout handoff layers must agree`
+        );
+        return;
+      }
+      if (![a.x, a.y, b.x, b.y].every(Number.isFinite))
+        throw Error("Nonfinite terminal");
+      this.widths.set(
+        c.name,
+        c.nominalTraceWidth ?? c.width ?? input.minTraceWidth
+      );
+    }
+    for (const b of input.buses ?? [])
+      if (b.maxLengthSkew !== void 0 && (!Number.isFinite(b.maxLengthSkew) || b.maxLengthSkew < 0))
+        throw Error("Invalid maximum length skew");
+    for (const { names: members, tolerance } of lengthConstraints(input)) {
+      if (!Number.isFinite(tolerance) || tolerance < 0)
+        throw Error("Invalid maximum length skew");
+      if (members.length < 1 || new Set(members).size !== members.length || members.some((n) => !names.has(n)))
+        throw Error("Invalid length matching members");
+    }
+    const claimed = /* @__PURE__ */ new Set();
+    for (const b of input.buses ?? [])
+      for (const name of b.connectionNames) {
+        const c = input.connections.find((c2) => c2.name === name);
+        if (!c || claimed.has(name))
+          throw Error(`Missing or duplicated bus member ${name}`);
+        claimed.add(name);
+        const layer = c.pointsToConnect[0].layer;
+        if (b.allowedLayers && !b.allowedLayers.includes(layer))
+          throw Error(`${b.busId}: forbidden layer ${layer}`);
+        const width = b.traceWidth;
+        if (width !== void 0) this.widths.set(name, width);
+      }
+    for (const width of this.widths.values())
+      if (!Number.isFinite(width) || width <= 0 || width < input.minTraceWidth)
+        throw Error("Invalid trace width");
+    this.fixed = fixedCopper(input);
+    for (const c of input.connections)
+      for (const p of c.pointsToConnect)
+        this.fixed.push({
+          a: p,
+          b: p,
+          layer: p.layer,
+          radius: this.widths.get(c.name) / 2,
+          owners: [c.name]
+        });
+    this.orders = windingOrders(input.connections);
+    if (!input.connections.length) {
+      this.solved = true;
+      this.phase = "solved";
+      return;
+    }
+    this.phase = "route";
+    this.startLane();
+  }
+  scene(c) {
+    return new VectorScene(this.input, c, this.widths.get(c.name), [
+      ...this.fixed,
+      ...this.traces.flatMap(routeCopper)
+    ]);
+  }
+  startLane() {
+    if (this.lane === this.input.connections.length) {
+      this.phase = "match";
+      return;
+    }
+    const c = this.orders[this.attempt][this.lane], [a, b] = c.pointsToConnect;
+    this.search = new VectorVisibilitySearch(this.scene(c), a, b);
+  }
+  retry() {
+    if (this.traces.length > this.bestPartial.length)
+      this.bestPartial = structuredClone(this.traces);
+    this.attempt++;
+    if (this.attempt >= this.orders.length) {
+      this.traces = this.bestPartial;
+      this.fail(
+        "no_planar_route",
+        "No collision-free routing found in the vector visibility graph"
+      );
+      return;
+    }
+    this.traces = [];
+    this.lane = 0;
+    this.startLane();
+  }
+  route() {
+    const s = this.search;
+    s.step();
+    if (s.solved) {
+      const c = this.orders[this.attempt][this.lane];
+      this.traces.push({
+        type: "pcb_trace",
+        pcb_trace_id: `bus_lane_${c.name}`,
+        connection_name: c.name,
+        source_trace_id: c.source_trace_id ?? c.name,
+        route: s.result.map((p) => ({
+          route_type: "wire",
+          x: p.x,
+          y: p.y,
+          layer: c.pointsToConnect[0].layer,
+          width: this.widths.get(c.name)
+        }))
+      });
+      this.lane++;
+      this.startLane();
+    } else if (s.failed || s.expanded >= (this.options.maxLaneIterations ?? 4e3))
+      this.retry();
+  }
+  match() {
+    const original = this.traces;
+    const input = this.input;
+    function* candidates() {
+      yield original;
+      const width = Math.max(...original.map((t) => t.route[0].width));
+      for (const multiplier of [16, 24, 28, 32]) {
+        const spread = spreadTuningLanes(input, original, width * multiplier);
+        if (spread) yield spread;
+      }
+    }
+    let error;
+    for (const candidate of candidates()) {
+      const targets = minimumLengthTargets(input, candidate);
+      try {
+        this.traces = tuneLengths(input, candidate, targets);
+        this.phase = "validate_output";
+        return;
+      } catch (e) {
+        error = e;
+      }
+    }
+    this.fail("length_matching_failed", String(error));
+    return;
+  }
+  validateOutput() {
+    for (const c of this.input.connections) {
+      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)
+        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);
+        if (a.route_type !== "wire" || b.route_type !== "wire" || a.layer !== b.layer)
+          throw Error("Forbidden layer transition");
+        if (Math.min(dx, dy) > 1e-8 && Math.abs(dx - dy) > 1e-8)
+          throw Error("Non-octilinear segment");
+        if (!scene.visible(a, b))
+          throw Error("Final copper clearance violation");
+      }
+    }
+    if ([
+      ...busLengthReports(this.input, this.traces),
+      ...pairLengthReports(this.input, this.traces)
+    ].some((b) => b.toleranceMm !== null && !b.matched))
+      throw Error("Final bus length skew violation");
+    this.phase = "solved";
+    this.solved = true;
+  }
+  _step() {
+    try {
+      if (this.phase === "validate") this.initialize();
+      else if (this.phase === "route") this.route();
+      else if (this.phase === "match") this.match();
+      else if (this.phase === "validate_output") this.validateOutput();
+    } catch (e) {
+      this.fail("constraint_error", String(e));
+    }
+    this.progress = this.lane / Math.max(1, this.input.connections.length);
+    this.stats = {
+      busLengths: busLengthReports(this.input, this.traces),
+      pairLengths: pairLengthReports(this.input, this.traces),
+      phase: this.phase,
+      algorithm: "octilinear_visibility",
+      attempt: this.attempt,
+      lane: this.lane,
+      totalLanes: this.input.connections.length,
+      vertices: this.search?.vertices.length ?? 0,
+      expandedVertices: this.search?.expanded ?? 0,
+      frontier: this.search?.open.length ?? 0,
+      failureCode: this.failureCode,
+      traceLengthsMm: this.traces.map((t) => ({
+        name: t.connection_name,
+        length: length(t.route)
+      }))
+    };
+  }
+  visualize() {
+    const lines = [], points = [], rects = [], circles = [];
+    for (const c of fixedCopper(this.input)) {
+      if (c.rect) {
+        rects.push({
+          center: {
+            x: (c.rect.minX + c.rect.maxX) / 2,
+            y: (c.rect.minY + c.rect.maxY) / 2
+          },
+          width: c.rect.maxX - c.rect.minX,
+          height: c.rect.maxY - c.rect.minY,
+          layer: c.layer,
+          fill: `${layerColor(c.layer)}30`,
+          stroke: layerColor(c.layer)
+        });
+        continue;
+      }
+      if (distance12(c.a, c.b) < 1e-9)
+        circles.push({
+          center: c.a,
+          radius: c.radius,
+          layer: c.layer,
+          fill: "transparent",
+          stroke: layerColor(c.layer)
+        });
+      else
+        lines.push({
+          points: [
+            { x: c.a.x, y: c.a.y },
+            { x: c.b.x, y: c.b.y }
+          ],
+          strokeWidth: c.radius * 2,
+          strokeColor: layerColor(c.layer),
+          layer: c.layer,
+          label: `Fixed fanout [${c.layer}]`
+        });
+    }
+    for (const t of this.traces)
+      lines.push({
+        points: t.route.map(({ x, y }) => ({ x, y })),
+        strokeWidth: t.route[0].width,
+        strokeColor: layerColor(t.route[0].layer),
+        layer: t.route[0].layer,
+        label: t.connection_name
+      });
+    for (const c of this.input.connections)
+      for (const [i, p] of c.pointsToConnect.entries())
+        points.push({
+          ...p,
+          color: i ? "#d97706" : "#2563eb",
+          label: `${c.name} ${i ? "target" : "source"} [${p.layer}]`
+        });
+    if (this.search && this.phase === "route") {
+      const layer = this.orders[this.attempt][this.lane]?.pointsToConnect[0].layer;
+      for (const edge of this.search.visibleEdges)
+        lines.push({
+          points: edge,
+          strokeWidth: 0.02,
+          strokeColor: "#67e8f980",
+          layer
+        });
+      for (const n of this.search.open.values().slice(0, 80))
+        points.push({ ...this.search.vertices[n.id], color: "#06b6d4", layer });
+      lines.push({
+        points: this.search.currentPath(),
+        strokeColor: "#f43f5e",
+        strokeWidth: 0.09,
+        layer
+      });
+    }
+    return {
+      title: `Vector bus lanes \xB7 ${this.phase}`,
+      lines,
+      points,
+      rects,
+      circles
+    };
+  }
+};
+
+// lib/utils/autorouting/BusLanesAutorouter.ts
+var BusLanesAutorouter = class {
+  constructor(input) {
+    this.input = input;
+    this.solver = new BusLanesSolver(input);
+  }
+  input;
+  isRouting = false;
+  solver;
+  timer;
+  listeners = [];
+  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;
+    const tick = () => {
+      if (!this.isRouting) return;
+      try {
+        for (let i = 0; i < 200 && !this.solver.solved && !this.solver.failed; i++)
+          this.solver.step();
+        if (this.solver.failed) {
+          this.isRouting = false;
+          this.emit({
+            type: "error",
+            error: new Error(this.solver.error ?? "Bus lanes routing failed")
+          });
+          return;
+        }
+        if (this.solver.solved) {
+          this.isRouting = false;
+          this.emit({ type: "complete", traces: this.solver.traces });
+          return;
+        }
+        this.emit({
+          type: "progress",
+          steps: this.solver.iterations,
+          progress: this.solver.progress,
+          phase: this.solver.phase,
+          debugGraphics: this.solver.visualize()
+        });
+        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 ?? "Bus lanes routing failed");
+    return this.solver.traces;
+  }
+};
+
 // lib/utils/autorouting/CapacityMeshAutorouter.ts
 import {
   AutoroutingPipelineSolver9_Networked as AutoroutingPipelineSolver9_Networked2
@@ -49293,7 +50442,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 BaseSolver4,
+  BaseSolver as BaseSolver5,
   definePipelineStep
 } from "@tscircuit/solver-utils";
 
@@ -49311,7 +50460,7 @@ import { applyToPoint as applyToPoint27, compose as compose9, scale as scale2, t
 // node_modules/@tscircuit/implicit-copper-pour-solver/lib/geometry.ts
 import {
   clamp,
-  distance as distance12,
+  distance as distance13,
   doBoundsOverlap as doBoundsOverlap2,
   getBoundsFromPoints as getBoundsFromPoints3,
   getUnitVectorFromPointAToB as getUnitVectorFromPointAToB2,
@@ -49360,7 +50509,7 @@ var distanceToPolygon = (point6, polygon) => {
 var distanceToPrimitive = (primitive, px, py) => {
   const point6 = { x: px, y: py };
   if (primitive.kind === "circle") {
-    return Math.max(distance12(point6, primitive) - primitive.radius, 0);
+    return Math.max(distance13(point6, primitive) - primitive.radius, 0);
   }
   if (primitive.kind === "segment") {
     return Math.max(
@@ -49411,7 +50560,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 = distance12(point6, candidate);
+      const candidateDistance = distance13(point6, candidate);
       if (candidateDistance < bestDistance) {
         bestDistance = candidateDistance;
         closestPoint = candidate;
@@ -50467,7 +51616,7 @@ var prepareCircuitJson = (input) => {
 
 // node_modules/@tscircuit/implicit-copper-pour-solver/lib/simplify-polygon-edges.ts
 import {
-  distance as distance13,
+  distance as distance14,
   doSegmentsIntersect,
   onSegment,
   pointToSegmentDistance as pointToSegmentDistance2
@@ -50486,13 +51635,13 @@ var simplifyRdpPath = (points, tolerance) => {
     let furthestIndex = -1;
     let furthestDistance = tolerance;
     for (let index = firstIndex + 1; index < lastIndex; index++) {
-      const segmentDistance = pointToSegmentDistance2(
+      const segmentDistance2 = pointToSegmentDistance2(
         points[index],
         first,
         last
       );
-      if (segmentDistance > furthestDistance) {
-        furthestDistance = segmentDistance;
+      if (segmentDistance2 > furthestDistance) {
+        furthestDistance = segmentDistance2;
         furthestIndex = index;
       }
     }
@@ -50530,8 +51679,8 @@ var simplifyOpenPath = (points, tolerance) => {
     const point6 = points[index];
     const next = points[index + 1];
     const shortestLeg = Math.min(
-      distance13(point6, previous),
-      distance13(next, point6)
+      distance14(point6, previous),
+      distance14(next, point6)
     );
     if (repeatsTurnDirection || shortestLeg > tolerance) {
       anchorIndices.push(index);
@@ -50580,8 +51729,8 @@ var normalizePolygon = (polygon) => {
 };
 var isPointStrictlyInsideSegment = (point6, start, end) => {
   if (pointsEqual(point6, start) || pointsEqual(point6, end)) return false;
-  const cross3 = crossProduct(start, end, point6);
-  if (Math.abs(cross3) > 1e-9) return false;
+  const cross4 = crossProduct(start, end, point6);
+  if (Math.abs(cross4) > 1e-9) return false;
   return onSegment(start, point6, end);
 };
 var splitEdgesAtVertices = (polygon, allVertices) => {
@@ -50933,7 +52082,7 @@ var mergeSolverGraphics = (source, overlay) => {
 };
 
 // node_modules/@tscircuit/implicit-copper-pour-solver/lib/implicit-copper-pour-pipeline-solver.ts
-var PrepareCircuitJsonSolver = class extends BaseSolver4 {
+var PrepareCircuitJsonSolver = class extends BaseSolver5 {
   constructor(input) {
     super();
     this.input = input;
@@ -50949,7 +52098,7 @@ var PrepareCircuitJsonSolver = class extends BaseSolver4 {
     return this.output;
   }
 };
-var AssignGridCellsSolver = class extends BaseSolver4 {
+var AssignGridCellsSolver = class extends BaseSolver5 {
   constructor(input) {
     super();
     this.input = input;
@@ -50972,7 +52121,7 @@ var AssignGridCellsSolver = class extends BaseSolver4 {
     return this.output;
   }
 };
-var TracePowerPolygonsSolver = class extends BaseSolver4 {
+var TracePowerPolygonsSolver = class extends BaseSolver5 {
   constructor(input) {
     super();
     this.input = input;
@@ -51008,7 +52157,7 @@ var TracePowerPolygonsSolver = class extends BaseSolver4 {
     };
   }
 };
-var SimplifyPolygonEdgesSolver = class extends BaseSolver4 {
+var SimplifyPolygonEdgesSolver = class extends BaseSolver5 {
   constructor(input) {
     super();
     this.input = input;
@@ -51146,13 +52295,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 BaseSolver5 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver6 } 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 cross3 = (point6.y - start.y) * (end.x - start.x) - (point6.x - start.x) * (end.y - start.y);
-  if (Math.abs(cross3) > POINT_EPSILON) return false;
+  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 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;
@@ -51473,7 +52622,7 @@ var getGridCoordinates = ({
   }
   return coordinates;
 };
-var ViaStitchSolver = class extends BaseSolver5 {
+var ViaStitchSolver = class extends BaseSolver6 {
   constructor(input) {
     super();
     this.input = input;
@@ -51620,6 +52769,7 @@ var ViaStitchSolver = class extends BaseSolver5 {
 // lib/solvers.ts
 import { PackSolver2 } from "calculate-packing";
 var SOLVERS = {
+  BusLanesSolver,
   PackSolver2,
   LayoutPipelineSolver,
   AutoroutingPipelineSolver,
@@ -52082,6 +53232,22 @@ var localAutorouterStrategies = /* @__PURE__ */ new Map([
     createFanoutAutorouterStrategy("single_layer_fanout")
   ],
   ["fanout", createFanoutAutorouterStrategy("fanout")],
+  [
+    "bus_lanes",
+    {
+      name: "bus_lanes",
+      cacheable: false,
+      getSolverName: () => "BusLanesSolver",
+      create: ({ simpleRouteJson, onSolverStarted }) => {
+        onSolverStarted?.({
+          solverName: "BusLanesSolver",
+          solverParams: simpleRouteJson,
+          solverConstructorArgs: [simpleRouteJson]
+        });
+        return new BusLanesAutorouter(simpleRouteJson);
+      }
+    }
+  ],
   ["simplify", simplificationLocalAutorouterStrategy]
 ]);
 var getLocalAutorouterStrategy = (preset) => localAutorouterStrategies.get(preset ?? "") ?? defaultLocalAutorouterStrategy;
@@ -54640,7 +55806,7 @@ function Group_doInitialPcbComponentAnchorAlignment(group) {
 // lib/components/primitive-components/Group/Group_doInitialPcbLayoutFlex.ts
 import { getMinimumFlexContainer } from "@tscircuit/circuit-json-util";
 import { RootFlexBox } from "@tscircuit/miniflex";
-import { length } from "circuit-json";
+import { length as length2 } from "circuit-json";
 var Group_doInitialPcbLayoutFlex = (group) => {
   const { db } = group.root;
   const { _parsedProps: props } = group;
@@ -54692,8 +55858,8 @@ var Group_doInitialPcbLayoutFlex = (group) => {
     rowGap = rawGap;
     columnGap = rawGap;
   } else if (typeof rawGap === "string") {
-    rowGap = length.parse(rawGap);
-    columnGap = length.parse(rawGap);
+    rowGap = length2.parse(rawGap);
+    columnGap = length2.parse(rawGap);
   }
   let minFlexContainer;
   let width = props.width ?? props.pcbWidth ?? void 0;
@@ -54773,7 +55939,7 @@ import {
   repositionPcbComponentTo as repositionPcbComponentTo2,
   repositionPcbGroupTo as repositionPcbGroupTo2
 } from "@tscircuit/circuit-json-util";
-import { length as length2 } from "circuit-json";
+import { length as length3 } from "circuit-json";
 import { CssGrid } from "minicssgrid";
 var MIN_GAP = 1;
 function Group_doInitialPcbLayoutGrid(group) {
@@ -54835,7 +56001,7 @@ function parseGridConfiguration(props) {
   const templateRows = props.pcbGridTemplateRows;
   const parseGap = (gapValue) => {
     if (gapValue === void 0) return MIN_GAP;
-    return typeof gapValue === "number" ? gapValue : length2.parse(gapValue);
+    return typeof gapValue === "number" ? gapValue : length3.parse(gapValue);
   };
   const gridGapOption = props.pcbGridGap ?? props.gridGap ?? props.pcbLayout?.gridGap;
   const rowGapOption = props.pcbGridRowGap ?? props.gridRowGap ?? props.pcbLayout?.gridRowGap;
@@ -54986,7 +56152,7 @@ import {
   convertPackOutputToPackInput,
   getGraphicsFromPackOutput
 } from "calculate-packing";
-import { length as length3 } from "circuit-json";
+import { length as length4 } from "circuit-json";
 import Debug6 from "debug";
 
 // lib/utils/packing/solvePackSolverWithTimeout.ts
@@ -55495,16 +56661,16 @@ var Group_doInitialPcbLayoutPack = (group) => {
     pcbPackGap
   } = props;
   const gap = pcbPackGap ?? pcbGap ?? gapProp;
-  const gapMm = length3.parse(gap ?? DEFAULT_MIN_GAP);
+  const gapMm = length4.parse(gap ?? DEFAULT_MIN_GAP);
   const chipMarginsMap = {};
   const staticPcbComponentIds = /* @__PURE__ */ new Set();
   const collectMargins = (comp) => {
     if (comp?.pcb_component_id && comp?._parsedProps) {
       const props2 = comp._parsedProps;
-      const left = length3.parse(props2.pcbMarginLeft ?? props2.pcbMarginX ?? 0);
-      const right = length3.parse(props2.pcbMarginRight ?? props2.pcbMarginX ?? 0);
-      const top = length3.parse(props2.pcbMarginTop ?? props2.pcbMarginY ?? 0);
-      const bottom = length3.parse(
+      const left = length4.parse(props2.pcbMarginLeft ?? props2.pcbMarginX ?? 0);
+      const right = length4.parse(props2.pcbMarginRight ?? props2.pcbMarginX ?? 0);
+      const top = length4.parse(props2.pcbMarginTop ?? props2.pcbMarginY ?? 0);
+      const bottom = length4.parse(
         props2.pcbMarginBottom ?? props2.pcbMarginY ?? 0
       );
       if (left || right || top || bottom) {
@@ -55553,8 +56719,8 @@ var Group_doInitialPcbLayoutPack = (group) => {
   const filteredCircuitJson = db.toArray();
   let bounds;
   if (props.width !== void 0 && props.height !== void 0) {
-    const widthMm = length3.parse(props.width);
-    const heightMm = length3.parse(props.height);
+    const widthMm = length4.parse(props.width);
+    const heightMm = length4.parse(props.height);
     bounds = {
       minX: -widthMm / 2,
       maxX: widthMm / 2,
@@ -55859,7 +57025,7 @@ import {
   repositionSchematicGroupTo
 } from "@tscircuit/circuit-json-util";
 import { RootFlexBox as RootFlexBox2 } from "@tscircuit/miniflex";
-import { length as length4 } from "circuit-json";
+import { length as length5 } from "circuit-json";
 var getSizeOfTreeNodeChild = (db, child) => {
   const { sourceComponent, sourceGroup } = child;
   if (child.nodeType === "component") {
@@ -55952,8 +57118,8 @@ var Group_doInitialSchematicLayoutFlex = (group) => {
     rowGap = rawGap;
     columnGap = rawGap;
   } else if (typeof rawGap === "string") {
-    rowGap = length4.parse(rawGap);
-    columnGap = length4.parse(rawGap);
+    rowGap = length5.parse(rawGap);
+    columnGap = length5.parse(rawGap);
   }
   let minFlexContainer;
   let width = props.width ?? props.schWidth ?? void 0;
@@ -56047,7 +57213,7 @@ var Group_doInitialSchematicLayoutFlex = (group) => {
 };
 
 // lib/components/primitive-components/Group/Group_doInitialSchematicLayoutGrid.ts
-import { length as length5 } from "circuit-json";
+import { length as length6 } from "circuit-json";
 
 // lib/components/primitive-components/Group/utils/updateSchematicPrimitivesForLayoutShift.ts
 function updateSchematicPrimitivesForLayoutShift({
@@ -56151,7 +57317,7 @@ function Group_doInitialSchematicLayoutGrid(group) {
   let gridGapY;
   const parseGap = (val) => {
     if (val === void 0) return void 0;
-    return typeof val === "number" ? val : length5.parse(val);
+    return typeof val === "number" ? val : length6.parse(val);
   };
   if (gridRowGapOption !== void 0 || gridColumnGapOption !== void 0) {
     const fallbackX = typeof gridGapOption === "object" && gridGapOption !== null ? gridGapOption.x : gridGapOption;
@@ -56162,14 +57328,14 @@ function Group_doInitialSchematicLayoutGrid(group) {
     gridGapX = gridGapOption;
     gridGapY = gridGapOption;
   } else if (typeof gridGapOption === "string") {
-    const parsed = length5.parse(gridGapOption);
+    const parsed = length6.parse(gridGapOption);
     gridGapX = parsed;
     gridGapY = parsed;
   } else if (typeof gridGapOption === "object" && gridGapOption !== null) {
     const xRaw = gridGapOption.x;
     const yRaw = gridGapOption.y;
-    gridGapX = typeof xRaw === "number" ? xRaw : length5.parse(xRaw ?? "0mm");
-    gridGapY = typeof yRaw === "number" ? yRaw : length5.parse(yRaw ?? "0mm");
+    gridGapX = typeof xRaw === "number" ? xRaw : length6.parse(xRaw ?? "0mm");
+    gridGapY = typeof yRaw === "number" ? yRaw : length6.parse(yRaw ?? "0mm");
   } else {
     gridGapX = 1;
     gridGapY = 1;
@@ -58402,19 +59568,19 @@ import Debug12 from "debug";
 import { isValidElement as isValidElement2 } from "react";
 
 // lib/components/primitive-components/Group/Group_doInitialSchematicTraceRender/segment-intersection.ts
-var cross2 = (ax, ay, bx, by) => {
+var cross3 = (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 = cross2(r.x, r.y, s.x, s.y);
+  const rxs = cross3(r.x, r.y, s.x, s.y);
   const q_p = { x: q1.x - p1.x, y: q1.y - p1.y };
-  const q_pxr = cross2(q_p.x, q_p.y, r.x, r.y);
+  const q_pxr = cross3(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 = cross2(q_p.x, q_p.y, s.x, s.y) / rxs;
-  const u = cross2(q_p.x, q_p.y, r.x, r.y) / rxs;
+  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;
   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 };
 }
@@ -58426,14 +59592,14 @@ function isHorizontalEdge(edge) {
   const dy = Math.abs(edge.to.y - edge.from.y);
   return dx >= dy;
 }
-function length6(a, b) {
+function length7(a, b) {
   return Math.hypot(b.x - a.x, b.y - a.y);
 }
 function pointAt(a, b, t) {
   return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
 }
 function paramAlong(a, b, p) {
-  const L = length6(a, b);
+  const L = length7(a, b);
   if (L < TOL) return 0;
   const t = ((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / ((b.x - a.x) * (b.x - a.x) + (b.y - a.y) * (b.y - a.y));
   return Math.max(0, Math.min(1, t)) * L;
@@ -58456,7 +59622,7 @@ function mergeIntervals(intervals, tol = TOL) {
   return merged;
 }
 function splitEdgeByCrossings(edge, crossingDistances, crossLen) {
-  const L = length6(edge.from, edge.to);
+  const L = length7(edge.from, edge.to);
   if (L < TOL || crossingDistances.length === 0) return [edge];
   const half = crossLen / 2;
   const rawIntervals = crossingDistances.map((d) => ({
@@ -58508,8 +59674,8 @@ function computeCrossings(traces, opts = {}) {
           }
           const P = segmentIntersection(eA.from, eA.to, eB.from, eB.to, tol);
           if (!P) continue;
-          const LA = length6(eA.from, eA.to);
-          const LB = length6(eB.from, eB.to);
+          const LA = length7(eA.from, eA.to);
+          const LB = length7(eB.from, eB.to);
           if (LA < tol || LB < tol) continue;
           const dA = paramAlong(eA.from, eA.to, P);
           const dB = paramAlong(eB.from, eB.to, P);
@@ -58607,8 +59773,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 cross3 = v1.x * v2.y - v1.y * v2.x;
-  return Math.abs(cross3) <= tol * L1 * L2;
+  const cross4 = v1.x * v2.y - v1.y * v2.x;
+  return Math.abs(cross4) <= tol * L1 * L2;
 }
 function incidentEdgesAtPoint(trace, p, tol = TOL2) {
   return trace.edges.filter(
@@ -58758,7 +59924,7 @@ function isCollinear(a, b, tol = TOL3) {
 function splitEdgeAroundIntervals(edge, intervals) {
   const merged = mergeIntervals(intervals);
   if (merged.length === 0) return [edge];
-  const edgeLength = length6(edge.from, edge.to);
+  const edgeLength = length7(edge.from, edge.to);
   if (edgeLength <= TOL3) return [edge];
   const result = [];
   let cursor = 0;
@@ -58792,7 +59958,7 @@ function removeOverlappingSameNetCrossingSegments(traces) {
     const crossingTrace = traces[crossingTraceIndex];
     if (!crossingTrace.connectivity_key) continue;
     for (const crossingEdge of crossingTrace.edges) {
-      if (!crossingEdge.is_crossing || length6(crossingEdge.from, crossingEdge.to) <= TOL3)
+      if (!crossingEdge.is_crossing || length7(crossingEdge.from, crossingEdge.to) <= TOL3)
         continue;
       for (let traceIndex = 0; traceIndex < traces.length; traceIndex++) {
         const candidateTrace = traces[traceIndex];
@@ -58801,7 +59967,7 @@ function removeOverlappingSameNetCrossingSegments(traces) {
         }
         for (let edgeIndex = 0; edgeIndex < candidateTrace.edges.length; edgeIndex++) {
           const candidateEdge = candidateTrace.edges[edgeIndex];
-          const candidateLength = length6(candidateEdge.from, candidateEdge.to);
+          const candidateLength = length7(candidateEdge.from, candidateEdge.to);
           if (candidateEdge.is_crossing || candidateLength <= TOL3) continue;
           if (!isCollinear(candidateEdge, crossingEdge)) continue;
           const start = Math.max(
@@ -61976,6 +63142,7 @@ function Group_getRoutingPhasePlans(group) {
   for (const plan of plans) {
     plan.autorouter = autoroutersByPhaseIndex.get(plan.routingPhaseIndex);
     const phaseProps = phasePropsByPhaseIndex.get(plan.routingPhaseIndex);
+    plan.isImplicitRemainingPhase = plan.routingPhaseIndex === null && phaseProps === void 0;
     plan.phaseName = phaseProps?.name;
     plan.reroute = phaseProps?.reroute;
     plan.region = phaseProps?.region;
@@ -62101,6 +63268,7 @@ function Group_getRoutingPhasePlans(group) {
       ...breakoutPlans,
       {
         routingPhaseIndex: null,
+        isImplicitRemainingPhase: true,
         nets: [...reroutePlan.nets],
         traces: [...reroutePlan.traces]
       },
@@ -62114,7 +63282,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1913",
+  version: "0.0.1915",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -62148,6 +63316,7 @@ var package_default = {
     "@tsci/tscircuit.ti": "github:tscircuit/ti#57e314be4b2b06bc546d4def7453e619604d1157",
     "@tscircuit/alphabet": "0.0.25",
     "@tscircuit/bga-fanout-solver": "github:tscircuit/bga-fanout-solver#247c835cb8d69b65e53891dcf869731079415b39",
+    "@tscircuit/bus-lanes-solver": "github:tscircuit/bus-lanes-solver#0bc8d071241b18a3e7465a878881abe4998f6384",
     "@tscircuit/capacity-autorouter": "^0.0.900",
     "@tscircuit/checks": "^0.0.192",
     "@tscircuit/circuit-json-util": "^0.0.113",
@@ -62846,7 +64015,7 @@ function getAccumulatedPcbTracesWithStageOutputReplacements({
 }
 
 // lib/components/primitive-components/Group/get-source-trace-id-for-routed-trace.ts
-import { distance as distance14, pointToSegmentDistance as pointToSegmentDistance3 } from "@tscircuit/math-utils";
+import { distance as distance15, pointToSegmentDistance as pointToSegmentDistance3 } from "@tscircuit/math-utils";
 import { ConnectivityMap as ConnectivityMap5 } from "circuit-json-to-connectivity-map";
 var POINT_EPSILON2 = 1e-6;
 function isPointOnWireSegment({
@@ -62868,7 +64037,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 distance14(point6, pad) <= pad.radius + traceWidth / 2;
+    return distance15(point6, pad) <= pad.radius + traceWidth / 2;
   }
   return false;
 }
@@ -62877,7 +64046,7 @@ function isPointInPlatedHole({
   hole,
   traceWidth = 0
 }) {
-  return distance14(point6, hole) <= (hole.outer_diameter ?? hole.hole_diameter ?? 0) / 2 + traceWidth / 2;
+  return distance15(point6, hole) <= (hole.outer_diameter ?? hole.hole_diameter ?? 0) / 2 + traceWidth / 2;
 }
 function getEndpointSourcePortIdsFromGeometry(db, trace) {
   const sourcePortIds = /* @__PURE__ */ new Set();
@@ -62890,7 +64059,7 @@ function getEndpointSourcePortIdsFromGeometry(db, trace) {
       if (!pcbPort.source_port_id) continue;
       if (endpoint.layer && pcbPort.layers && !pcbPort.layers.includes(endpoint.layer))
         continue;
-      if (distance14(endpoint, pcbPort) <= 0.01) {
+      if (distance15(endpoint, pcbPort) <= 0.01) {
         sourcePortIds.add(pcbPort.source_port_id);
       }
     }
@@ -63574,8 +64743,8 @@ var Group5 = class extends NormalComponent3 {
     const groupProps2 = props;
     const hasOutline = groupProps2.outline && groupProps2.outline.length > 0;
     const numericOutline = hasOutline ? groupProps2.outline.map((point6) => ({
-      x: distance15.parse(point6.x),
-      y: distance15.parse(point6.y)
+      x: distance16.parse(point6.x),
+      y: distance16.parse(point6.y)
     })) : void 0;
     const ctx = this.props;
     const anchorPosition = this._getGlobalPcbPositionBeforeLayout();
@@ -63613,8 +64782,8 @@ var Group5 = class extends NormalComponent3 {
     const hasExplicitPositioning = this._parsedProps.pcbX !== void 0 || this._parsedProps.pcbY !== void 0;
     if (hasOutline) {
       const numericOutline = props.outline.map((point6) => ({
-        x: distance15.parse(point6.x),
-        y: distance15.parse(point6.y)
+        x: distance16.parse(point6.x),
+        y: distance16.parse(point6.y)
       }));
       const outlineBounds = getBoundsFromPoints9(numericOutline);
       if (!outlineBounds) return;
@@ -64136,6 +65305,7 @@ var Group5 = class extends NormalComponent3 {
     };
     const fixedFanoutTraceIds = /* @__PURE__ */ new Set();
     let previousStageOutputSimpleRouteJson;
+    const skippedRemainingPhases = /* @__PURE__ */ new Set();
     for (const [
       routingStageIndex,
       {
@@ -64147,6 +65317,7 @@ var Group5 = class extends NormalComponent3 {
         phaseStageCount
       }
     ] of routingStages.entries()) {
+      if (skippedRemainingPhases.has(routingPhasePlan)) continue;
       if (!usesPreviousStageOutput) {
         previousStageOutputSimpleRouteJson = void 0;
       }
@@ -64238,16 +65409,31 @@ var Group5 = class extends NormalComponent3 {
           })
         };
       }
-      simpleRouteJson = withFixedFanoutTraces(
-        simpleRouteJson,
-        fixedFanoutTraceIds
-      );
+      if (phaseAutorouterConfig.preset !== "bus_lanes") {
+        simpleRouteJson = withFixedFanoutTraces(
+          simpleRouteJson,
+          fixedFanoutTraceIds
+        );
+      }
       simpleRouteJson = Group_applyDrcTolerancesToSimpleRouteJson(
         simpleRouteJson,
         routingPhasePlan.drcTolerances
       );
       simpleRouteJson.allowViaInPad = phaseAutorouterConfig.allowViaInPad;
       const getPrecomputedRoutingResult = usesPreviousStageOutput ? void 0 : routingPhasePlan.getPrecomputedRoutingResult;
+      const preflightRoutingCheckPolicy = this.getInheritedProperty(
+        "preflightRoutingCheckPolicy"
+      );
+      if (routingPhasePlan.isImplicitRemainingPhase && phaseStageIndex === 0 && this.getInheritedProperty("routeRemaining") === void 0 && (preflightRoutingCheckPolicy === "basic" || preflightRoutingCheckPolicy === "conservative") && simpleRouteJson.connections.length > 50) {
+        skippedRemainingPhases.add(routingPhasePlan);
+        db.pcb_autorouting_error.insert({
+          pcb_error_id: `pcb_autorouting_error_remaining_routes_${this.subcircuit_id}`,
+          subcircuit_id: this.subcircuit_id ?? void 0,
+          error_type: "pcb_autorouting_error",
+          message: `Remaining routes left unrouted (over 50 traces remaining and preflightRoutingCheckPolicy="${preflightRoutingCheckPolicy}"). Set <board routeRemaining={true} /> or create <autoroutingphase /> elements for specific connections in the order you'd like to route them. The autorouter may hang unless you create autorouting phases incrementally.`
+        });
+        continue;
+      }
       const simplificationHasNoTraceInput = Boolean(
         isTraceSimplificationPhase && simpleRouteJson.traces?.length === 0
       );
@@ -65413,8 +66599,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 distance22 = Math.hypot(k.x - a.x, k.y - a.y);
-  if (distance22 < 1e-6) return;
+  const distance23 = Math.hypot(k.x - a.x, k.y - a.y);
+  if (distance23 < 1e-6) return;
   const angle = Math.atan2(k.y - a.y, k.x - a.x);
   const frame = compose14(
     translate14((a.x + k.x) / 2, (a.y + k.y) / 2),
@@ -65428,10 +66614,10 @@ var Led_addPolarityFabricationSymbol = (led) => {
   };
   const notes = [];
   generatedNotes.set(led, notes);
-  const halfLength = Math.min(distance22 * 0.2, 0.4);
+  const halfLength = Math.min(distance23 * 0.2, 0.4);
   const halfHeight = halfLength * 0.75;
   const routes = [
-    [point6(-distance22 / 2, 0), point6(-halfLength, 0)],
+    [point6(-distance23 / 2, 0), point6(-halfLength, 0)],
     [
       point6(-halfLength, -halfHeight),
       point6(halfLength, 0),
@@ -65439,7 +66625,7 @@ var Led_addPolarityFabricationSymbol = (led) => {
       point6(-halfLength, -halfHeight)
     ],
     [point6(halfLength, -halfHeight), point6(halfLength, halfHeight)],
-    [point6(halfLength, 0), point6(distance22 / 2, 0)]
+    [point6(halfLength, 0), point6(distance23 / 2, 0)]
   ];
   for (const route of routes) {
     notes.push(
@@ -67163,8 +68349,8 @@ import {
 var EPSILON24 = 1e-9;
 var isWireRoutePoint = (routePoint) => routePoint.route_type === "wire";
 var isPointOnSegment2 = (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) > EPSILON24) return false;
+  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 dot = (p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y);
   if (dot < -EPSILON24) return false;
   const squaredLength = (b.x - a.x) ** 2 + (b.y - a.y) ** 2;
@@ -67225,8 +68411,8 @@ var isTraceConnectedToSourceNet = (trace, sourceNetId, sourceTraceById) => {
 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 <= EPSILON24) return false;
+  const length8 = Math.hypot(dx, dy);
+  if (length8 <= EPSILON24) return false;
   const samples = [0, 0.25, 0.5, 0.75, 1];
   return samples.every(
     (t) => isPointInCopperPour(
@@ -67694,13 +68880,13 @@ var getPlatedHolePolygon = (pad, componentRotation = 0) => {
   );
 };
 var getTraceSegmentPolygon = (start, end, startWidth, endWidth = startWidth) => {
-  const length7 = Math.hypot(end.x - start.x, end.y - start.y);
+  const length8 = Math.hypot(end.x - start.x, end.y - start.y);
   const r1 = startWidth / 2;
   const r2 = endWidth / 2;
-  if (length7 <= Math.abs(r2 - r1))
+  if (length8 <= Math.abs(r2 - r1))
     return circlePolygon(r1 >= r2 ? start : end, Math.max(r1, r2));
   const angle = Math.atan2(end.y - start.y, end.x - start.x);
-  const tangent = Math.acos((r1 - r2) / length7);
+  const tangent = Math.acos((r1 - r2) / length8);
   const first = new Arc(
     new Point(start.x, start.y),
     r1,
@@ -68005,7 +69191,7 @@ var Board_doInitialPcbPlacementDesignRuleChecks = (board) => {
 
 // lib/components/normal-components/board-castellated-hole.ts
 import {
-  distance as distance16
+  distance as distance17
 } from "circuit-json";
 var CASTELLATED_HOLE_ENDPOINT_TOLERANCE_MM = 1e-6;
 var getConnectionTargets2 = (connectsTo) => {
@@ -68026,8 +69212,8 @@ var BoardCastellatedHole = class _BoardCastellatedHole extends PlatedHole {
   constructor(outlinePoint, outlinePointIndex) {
     const name = `castellated_hole_${outlinePointIndex + 1}`;
     const connectionTargets = getConnectionTargets2(outlinePoint.connectsTo);
-    const holeDiameter = distance16.parse(outlinePoint.holeDiameter);
-    const padDiameter = distance16.parse(outlinePoint.padDiameter);
+    const holeDiameter = distance17.parse(outlinePoint.holeDiameter);
+    const padDiameter = distance17.parse(outlinePoint.padDiameter);
     super({
       shape: "circle",
       holeDiameter,
@@ -68871,11 +70057,11 @@ var MountedBoard = class extends Subcircuit {
 
 // lib/components/normal-components/Panel.ts
 import { panelProps } from "@tscircuit/props";
-import { distance as distance20 } from "circuit-json";
+import { distance as distance21 } from "circuit-json";
 
 // lib/components/normal-components/Subpanel.ts
 import { subpanelProps } from "@tscircuit/props";
-import { distance as distance19 } from "circuit-json";
+import { distance as distance20 } from "circuit-json";
 import { compose as compose17, identity as identity8, translate as translate17 } from "transformation-matrix";
 
 // lib/utils/panels/generate-panel-tabs-and-mouse-bites.ts
@@ -69139,15 +70325,15 @@ function generatePanelOutlineRoutingCutouts(boards, options) {
 }
 
 // lib/utils/panels/pack-into-grid.ts
-import { distance as distance18 } from "circuit-json";
+import { distance as distance19 } from "circuit-json";
 
 // lib/utils/panels/get-board-dimensions-from-props.ts
 import { getBoundsFromPoints as getBoundsFromPoints11 } from "@tscircuit/math-utils";
-import { distance as distance17 } from "circuit-json";
+import { distance as distance18 } from "circuit-json";
 var getBoardDimensionsFromProps = (board) => {
   const props = board._parsedProps;
-  let width = props.width != null ? distance17.parse(props.width) : void 0;
-  let height = props.height != null ? distance17.parse(props.height) : void 0;
+  let width = props.width != null ? distance18.parse(props.width) : void 0;
+  let height = props.height != null ? distance18.parse(props.height) : void 0;
   if ((width === void 0 || height === void 0) && props.outline?.length) {
     const outlineBounds = getBoundsFromPoints11(props.outline);
     if (outlineBounds) {
@@ -69191,8 +70377,8 @@ function packIntoGrid({
   }
   let cols;
   let rows;
-  const minCellWidth = cellWidth ? distance18.parse(cellWidth) : 0;
-  const minCellHeight = cellHeight ? distance18.parse(cellHeight) : 0;
+  const minCellWidth = cellWidth ? distance19.parse(cellWidth) : 0;
+  const minCellHeight = cellHeight ? distance19.parse(cellHeight) : 0;
   if (col !== void 0) {
     cols = col;
     rows = row ?? Math.ceil(itemsWithDims.length / cols);
@@ -69291,8 +70477,8 @@ function getItemDimensions(item, db) {
     const props = subpanel._parsedProps;
     if (props.width !== void 0 && props.height !== void 0) {
       return {
-        width: distance18.parse(props.width),
-        height: distance18.parse(props.height)
+        width: distance19.parse(props.width),
+        height: distance19.parse(props.height)
       };
     }
     const directBoards = subpanel._getDirectBoardChildren();
@@ -69319,7 +70505,7 @@ function getItemDimensions(item, db) {
       return getBoardDimensionsFromProps(directBoards[0]);
     }
     if (subpanel._cachedGridWidth > 0 && subpanel._cachedGridHeight > 0) {
-      const edgePadding = distance18.parse(props.edgePadding ?? 5);
+      const edgePadding = distance19.parse(props.edgePadding ?? 5);
       return {
         width: subpanel._cachedGridWidth + edgePadding * 2,
         height: subpanel._cachedGridHeight + edgePadding * 2
@@ -69477,17 +70663,17 @@ var Subpanel = class _Subpanel extends Group5 {
         edgePaddingTop: edgePaddingTopProp,
         edgePaddingBottom: edgePaddingBottomProp
       } = this._parsedProps;
-      const edgePadding = distance19.parse(edgePaddingProp ?? 5);
-      const edgePaddingLeft = distance19.parse(edgePaddingLeftProp ?? edgePadding);
-      const edgePaddingRight = distance19.parse(
+      const edgePadding = distance20.parse(edgePaddingProp ?? 5);
+      const edgePaddingLeft = distance20.parse(edgePaddingLeftProp ?? edgePadding);
+      const edgePaddingRight = distance20.parse(
         edgePaddingRightProp ?? edgePadding
       );
-      const edgePaddingTop = distance19.parse(edgePaddingTopProp ?? edgePadding);
-      const edgePaddingBottom = distance19.parse(
+      const edgePaddingTop = distance20.parse(edgePaddingTopProp ?? edgePadding);
+      const edgePaddingBottom = distance20.parse(
         edgePaddingBottomProp ?? edgePadding
       );
-      const panelWidth = distance19.parse(this._parsedProps.width);
-      const panelHeight = distance19.parse(this._parsedProps.height);
+      const panelWidth = distance20.parse(this._parsedProps.width);
+      const panelHeight = distance20.parse(this._parsedProps.height);
       availablePanelWidth = panelWidth - edgePaddingLeft - edgePaddingRight;
       availablePanelHeight = panelHeight - edgePaddingTop - edgePaddingBottom;
     }
@@ -69562,8 +70748,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: distance19.parse(this._parsedProps.width),
-        height: distance19.parse(this._parsedProps.height)
+        width: distance20.parse(this._parsedProps.width),
+        height: distance20.parse(this._parsedProps.height)
       });
     } else if (gridWidth > 0 || gridHeight > 0) {
       const {
@@ -69573,18 +70759,18 @@ var Subpanel = class _Subpanel extends Group5 {
         edgePaddingTop: edgePaddingTopProp,
         edgePaddingBottom: edgePaddingBottomProp
       } = this._parsedProps;
-      const edgePadding = distance19.parse(edgePaddingProp ?? 5);
-      const edgePaddingLeft = distance19.parse(edgePaddingLeftProp ?? edgePadding);
-      const edgePaddingRight = distance19.parse(
+      const edgePadding = distance20.parse(edgePaddingProp ?? 5);
+      const edgePaddingLeft = distance20.parse(edgePaddingLeftProp ?? edgePadding);
+      const edgePaddingRight = distance20.parse(
         edgePaddingRightProp ?? edgePadding
       );
-      const edgePaddingTop = distance19.parse(edgePaddingTopProp ?? edgePadding);
-      const edgePaddingBottom = distance19.parse(
+      const edgePaddingTop = distance20.parse(edgePaddingTopProp ?? edgePadding);
+      const edgePaddingBottom = distance20.parse(
         edgePaddingBottomProp ?? edgePadding
       );
       db.pcb_group.update(this.pcb_group_id, {
-        width: hasExplicitWidth ? distance19.parse(this._parsedProps.width) : gridWidth + edgePaddingLeft + edgePaddingRight,
-        height: hasExplicitHeight ? distance19.parse(this._parsedProps.height) : gridHeight + edgePaddingTop + edgePaddingBottom
+        width: hasExplicitWidth ? distance20.parse(this._parsedProps.width) : gridWidth + edgePaddingLeft + edgePaddingRight,
+        height: hasExplicitHeight ? distance20.parse(this._parsedProps.height) : gridHeight + edgePaddingTop + edgePaddingBottom
       });
     }
   }
@@ -69672,8 +70858,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 ? distance20.parse(props.width) : 0,
-      height: props.height !== void 0 ? distance20.parse(props.height) : 0,
+      width: props.width !== void 0 ? distance21.parse(props.width) : 0,
+      height: props.height !== void 0 ? distance21.parse(props.height) : 0,
       thickness: 1.6,
       center: this._getGlobalPcbPositionBeforeLayout(),
       covered_with_solder_mask: !(props.noSolderMask ?? false)
@@ -69692,8 +70878,8 @@ var Panel = class extends Subpanel {
     if (!this.pcb_panel_id) return;
     if (hasExplicitWidth && hasExplicitHeight) {
       db.pcb_panel.update(this.pcb_panel_id, {
-        width: distance20.parse(this._parsedProps.width),
-        height: distance20.parse(this._parsedProps.height)
+        width: distance21.parse(this._parsedProps.width),
+        height: distance21.parse(this._parsedProps.height)
       });
     } else if (gridWidth > 0 || gridHeight > 0) {
       const {
@@ -69703,18 +70889,18 @@ var Panel = class extends Subpanel {
         edgePaddingTop: edgePaddingTopProp,
         edgePaddingBottom: edgePaddingBottomProp
       } = this._parsedProps;
-      const edgePadding = distance20.parse(edgePaddingProp ?? 5);
-      const edgePaddingLeft = distance20.parse(edgePaddingLeftProp ?? edgePadding);
-      const edgePaddingRight = distance20.parse(
+      const edgePadding = distance21.parse(edgePaddingProp ?? 5);
+      const edgePaddingLeft = distance21.parse(edgePaddingLeftProp ?? edgePadding);
+      const edgePaddingRight = distance21.parse(
         edgePaddingRightProp ?? edgePadding
       );
-      const edgePaddingTop = distance20.parse(edgePaddingTopProp ?? edgePadding);
-      const edgePaddingBottom = distance20.parse(
+      const edgePaddingTop = distance21.parse(edgePaddingTopProp ?? edgePadding);
+      const edgePaddingBottom = distance21.parse(
         edgePaddingBottomProp ?? edgePadding
       );
       db.pcb_panel.update(this.pcb_panel_id, {
-        width: hasExplicitWidth ? distance20.parse(this._parsedProps.width) : gridWidth + edgePaddingLeft + edgePaddingRight,
-        height: hasExplicitHeight ? distance20.parse(this._parsedProps.height) : gridHeight + edgePaddingTop + edgePaddingBottom
+        width: hasExplicitWidth ? distance21.parse(this._parsedProps.width) : gridWidth + edgePaddingLeft + edgePaddingRight,
+        height: hasExplicitHeight ? distance21.parse(this._parsedProps.height) : gridHeight + edgePaddingTop + edgePaddingBottom
       });
     }
   }
@@ -69725,8 +70911,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 ? distance20.parse(props.width) : currentPanel?.width,
-      height: props.height !== void 0 ? distance20.parse(props.height) : currentPanel?.height,
+      width: props.width !== void 0 ? distance21.parse(props.width) : currentPanel?.width,
+      height: props.height !== void 0 ? distance21.parse(props.height) : currentPanel?.height,
       center: this._getGlobalPcbPositionBeforeLayout(),
       covered_with_solder_mask: !(props.noSolderMask ?? false)
     });
@@ -72032,7 +73218,7 @@ var validateWindingBreakoutInput = (input) => {
 };
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/solvers/GatePlacementSolver.ts
-import { BaseSolver as BaseSolver6 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/gate-placement/place-breakout-gates.ts
 var GEOMETRY_EPSILON = 1e-9;
@@ -72562,7 +73748,7 @@ var getSharedGateSlotCount = (points) => new Set(
     (point6) => `${point6.regionId}:${point6.x.toFixed(9)}:${point6.y.toFixed(9)}`
   )
 ).size;
-var GatePlacementSolver = class extends BaseSolver6 {
+var GatePlacementSolver = class extends BaseSolver7 {
   constructor(params) {
     super();
     this.params = params;
@@ -72701,7 +73887,7 @@ var GatePlacementSolver = class extends BaseSolver6 {
 };
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/solvers/ReferenceOrderingSolver.ts
-import { BaseSolver as BaseSolver7 } from "@tscircuit/solver-utils";
+import { BaseSolver as BaseSolver8 } 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) => {
@@ -72768,7 +73954,7 @@ var getReferenceWindingOrder = (naturalOrder, atomicGroups, buses) => {
 };
 
 // node_modules/@tscircuit/winding-breakout-point-solver/lib/solvers/ReferenceOrderingSolver.ts
-var ReferenceOrderingSolver = class extends BaseSolver7 {
+var ReferenceOrderingSolver = class extends BaseSolver8 {
   constructor(params) {
     super();
     this.params = params;
@@ -74113,7 +75299,7 @@ var SilkscreenGraphic = class extends PrimitiveComponent2 {
 
 // lib/components/primitive-components/Fiducial.ts
 import "zod";
-import { distance as distance21 } from "circuit-json";
+import { distance as distance22 } from "circuit-json";
 import { fiducialProps as fiducialProps2 } from "@tscircuit/props";
 var Fiducial = class extends PrimitiveComponent2 {
   pcb_smtpad_id = null;
@@ -74138,15 +75324,15 @@ var Fiducial = class extends PrimitiveComponent2 {
       shape: "circle",
       x: position.x,
       y: position.y,
-      radius: distance21.parse(props.padDiameter) / 2,
-      soldermask_margin: props.soldermaskPullback ? distance21.parse(props.soldermaskPullback) : distance21.parse(props.padDiameter) / 2,
+      radius: distance22.parse(props.padDiameter) / 2,
+      soldermask_margin: props.soldermaskPullback ? distance22.parse(props.soldermaskPullback) : distance22.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 = distance21.parse(props.padDiameter);
+    const d = distance22.parse(props.padDiameter);
     return { width: d, height: d };
   }
   _setPositionFromLayout(newCenter) {