@tscircuit/pcb-viewer 1.11.282 → 1.11.283

package/dist/index.js

@@ -10468,7 +10468,6 @@ var createBoxFromPoints = (points) => {
   }
   return { minX, maxX, minY, maxY };
 };
-var getBoundsFromPoints = createBoxFromPoints;
 var mergeBoundingBoxesInternal = (a, b) => ({
   minX: Math.min(a.minX, b.minX),
   maxX: Math.max(a.maxX, b.maxX),
@@ -10605,7 +10604,7 @@ function calculateDiagonalLabel(params) {
   } = params;
   const deltaX = dimensionEnd.x - dimensionStart.x;
   const deltaY = dimensionEnd.y - dimensionStart.y;
-  const distance5 = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+  const distance4 = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
   const screenDeltaX = screenDimensionEnd.x - screenDimensionStart.x;
   const screenDeltaY = screenDimensionEnd.y - screenDimensionStart.y;
   const screenDistance = Math.sqrt(
@@ -10647,11 +10646,11 @@ function calculateDiagonalLabel(params) {
   const x = midX + offsetX;
   const y = midY + offsetY;
   return {
-    distance: distance5,
+    distance: distance4,
     screenDistance,
     x,
     y,
-    show: distance5 > 0.01 && screenDistance > 30 && isDiagonal
+    show: distance4 > 0.01 && screenDistance > 30 && isDiagonal
   };
 }
 
@@ -10945,11 +10944,11 @@ var DimensionOverlay = ({
       for (const snap of snappingPointsWithScreen) {
         const dx = snap.screenPoint.x - screenPoint.x;
         const dy = snap.screenPoint.y - screenPoint.y;
-        const distance5 = Math.hypot(dx, dy);
-        if (distance5 > SNAP_THRESHOLD_PX) continue;
-        if (!bestMatch || distance5 < bestMatch.distance) {
+        const distance4 = Math.hypot(dx, dy);
+        if (distance4 > SNAP_THRESHOLD_PX) continue;
+        if (!bestMatch || distance4 < bestMatch.distance) {
           bestMatch = {
-            distance: distance5,
+            distance: distance4,
             id: snap.id,
             point: snap.point
           };
@@ -11548,10 +11547,10 @@ var isInsideOfSmtpad = (elm, point, padding = 0) => {
 };
 var isInsideOfPlatedHole = (hole, point, padding = 0) => {
   if (hole.shape === "circle") {
-    const distance5 = Math.sqrt(
+    const distance4 = Math.sqrt(
       (point.x - hole.x) ** 2 + (point.y - hole.y) ** 2
     );
-    return distance5 <= hole.outer_diameter / 2 + padding;
+    return distance4 <= hole.outer_diameter / 2 + padding;
   } else if (hole.shape === "circular_hole_with_rect_pad") {
     const dx = Math.abs(point.x - hole.x);
     const dy = Math.abs(point.y - hole.y);
@@ -12379,7 +12378,7 @@ var ErrorOverlay = ({
 
 // src/components/MouseElementTracker.tsx
 import { pointToSegmentDistance } from "@tscircuit/math-utils";
-import { distance as distance4 } from "circuit-json";
+import { distance as distance3 } from "circuit-json";
 
 // src/lib/util/if-sets-match-exactly.ts
 function ifSetsMatchExactly(set1, set2) {
@@ -12709,6 +12708,7 @@ var BoardAnchorOffsetOverlay = ({
   const components = elements.filter(
     (el) => isPcbComponent(el)
   );
+  const groups = elements.filter((el) => isPcbGroup(el));
   const hoveredComponentIds = highlightedPrimitives.map((primitive) => {
     if (isPcbComponent(primitive._parent_pcb_component)) {
       return primitive._parent_pcb_component.pcb_component_id;
@@ -12718,20 +12718,36 @@ var BoardAnchorOffsetOverlay = ({
     }
     return null;
   }).filter((id) => Boolean(id));
+  const hoveredGroupIds = /* @__PURE__ */ new Set();
+  hoveredComponentIds.forEach((componentId) => {
+    const component = components.find((c) => c.pcb_component_id === componentId);
+    if (component?.pcb_group_id) {
+      hoveredGroupIds.add(component.pcb_group_id);
+    }
+  });
   const isShowingAnchorOffsets = useGlobalStore(
     (state) => state.is_showing_group_anchor_offsets
   );
   if (!isShowingAnchorOffsets && hoveredComponentIds.length === 0) {
     return null;
   }
-  const targets = components.map((component) => {
+  const componentTargets = components.map((component) => {
     const boardId = component.positioned_relative_to_pcb_board_id;
     if (!boardId) return null;
     const board = boards.find((b) => b.pcb_board_id === boardId);
-    return board ? { component, board } : null;
+    return board ? { component, board, type: "component" } : null;
   }).filter(
     (target) => Boolean(target)
   );
+  const groupTargets = groups.map((group) => {
+    const boardId = group.positioned_relative_to_pcb_board_id;
+    if (!boardId || !group.center) return null;
+    const board = boards.find((b) => b.pcb_board_id === boardId);
+    return board ? { group, board, type: "group" } : null;
+  }).filter(
+    (target) => Boolean(target)
+  );
+  const targets = [...componentTargets, ...groupTargets];
   if (targets.length === 0) return null;
   const shouldShowAllTargets = hoveredComponentIds.length === 0;
   const labelStyle = {
@@ -12742,9 +12758,13 @@ var BoardAnchorOffsetOverlay = ({
     fontFamily: "monospace",
     fontWeight: "bold"
   };
-  const targetEntries = targets.filter(
-    ({ component }) => shouldShowAllTargets || hoveredComponentIds.includes(component.pcb_component_id)
-  );
+  const targetEntries = targets.filter((target) => {
+    if (target.type === "component") {
+      return shouldShowAllTargets || hoveredComponentIds.includes(target.component.pcb_component_id);
+    } else {
+      return shouldShowAllTargets || hoveredGroupIds.has(target.group.pcb_group_id);
+    }
+  });
   if (targetEntries.length === 0) return null;
   const boardAnchorScreens = /* @__PURE__ */ new Map();
   return /* @__PURE__ */ jsx12(
@@ -12772,35 +12792,53 @@ var BoardAnchorOffsetOverlay = ({
           width: containerWidth,
           height: containerHeight,
           children: [
-            targetEntries.map(({ component, board }) => {
-              const anchorPosition = board.center;
-              const componentCenter = component.center;
-              const anchorKey = board.pcb_board_id;
+            targetEntries.map((target) => {
+              const anchorPosition = target.board.center;
+              const anchorKey = target.board.pcb_board_id;
+              let targetCenter;
+              let targetId;
+              let displayOffsetX;
+              let displayOffsetY;
+              if (target.type === "component") {
+                targetCenter = target.component.center;
+                targetId = target.component.pcb_component_id;
+                displayOffsetX = target.component.display_offset_x;
+                displayOffsetY = target.component.display_offset_y;
+              } else {
+                if (!target.group.center) return null;
+                targetCenter = {
+                  x: target.group.center.x,
+                  y: target.group.center.y
+                };
+                targetId = target.group.pcb_group_id;
+                displayOffsetX = target.group.display_offset_x;
+                displayOffsetY = target.group.display_offset_y;
+              }
               if (!boardAnchorScreens.has(anchorKey)) {
                 const screenPoint = applyToPoint12(transform, anchorPosition);
                 boardAnchorScreens.set(anchorKey, screenPoint);
               }
               const anchorMarkerScreen = boardAnchorScreens.get(anchorKey);
-              const componentScreen = applyToPoint12(transform, componentCenter);
-              const offsetX = componentCenter.x - anchorPosition.x;
-              const offsetY = componentCenter.y - anchorPosition.y;
-              const xLineLength = Math.abs(componentScreen.x - anchorMarkerScreen.x);
-              const yLineLength = Math.abs(componentScreen.y - anchorMarkerScreen.y);
-              const isComponentAboveAnchor = componentScreen.y < anchorMarkerScreen.y;
-              const isComponentRightOfAnchor = componentScreen.x > anchorMarkerScreen.x;
-              const xLabelOffset = isComponentAboveAnchor ? VISUAL_CONFIG.LABEL_OFFSET_ABOVE : VISUAL_CONFIG.LABEL_OFFSET_BELOW;
-              const yLabelOffset = isComponentRightOfAnchor ? VISUAL_CONFIG.LABEL_OFFSET_RIGHT : VISUAL_CONFIG.LABEL_OFFSET_LEFT;
+              const targetScreen = applyToPoint12(transform, targetCenter);
+              const offsetX = targetCenter.x - anchorPosition.x;
+              const offsetY = targetCenter.y - anchorPosition.y;
+              const xLineLength = Math.abs(targetScreen.x - anchorMarkerScreen.x);
+              const yLineLength = Math.abs(targetScreen.y - anchorMarkerScreen.y);
+              const isTargetAboveAnchor = targetScreen.y < anchorMarkerScreen.y;
+              const isTargetRightOfAnchor = targetScreen.x > anchorMarkerScreen.x;
+              const xLabelOffset = isTargetAboveAnchor ? VISUAL_CONFIG.LABEL_OFFSET_ABOVE : VISUAL_CONFIG.LABEL_OFFSET_BELOW;
+              const yLabelOffset = isTargetRightOfAnchor ? VISUAL_CONFIG.LABEL_OFFSET_RIGHT : VISUAL_CONFIG.LABEL_OFFSET_LEFT;
               const shouldShowXLabel = xLineLength > VISUAL_CONFIG.MIN_LINE_LENGTH_FOR_LABEL;
               const shouldShowYLabel = yLineLength > VISUAL_CONFIG.MIN_LINE_LENGTH_FOR_LABEL;
-              const xLabelText = component.display_offset_x ?? `Board \u0394x: ${offsetX.toFixed(2)}mm`;
-              const yLabelText = component.display_offset_y ?? `Board \u0394y: ${offsetY.toFixed(2)}mm`;
+              const xLabelText = displayOffsetX ?? `Board \u0394x: ${offsetX.toFixed(2)}mm`;
+              const yLabelText = displayOffsetY ?? `Board \u0394y: ${offsetY.toFixed(2)}mm`;
               return /* @__PURE__ */ jsxs9("g", { children: [
                 /* @__PURE__ */ jsx12(
                   "line",
                   {
                     x1: anchorMarkerScreen.x,
                     y1: anchorMarkerScreen.y,
-                    x2: componentScreen.x,
+                    x2: targetScreen.x,
                     y2: anchorMarkerScreen.y,
                     stroke: COLORS.OFFSET_LINE,
                     strokeWidth: VISUAL_CONFIG.LINE_STROKE_WIDTH,
@@ -12810,10 +12848,10 @@ var BoardAnchorOffsetOverlay = ({
                 /* @__PURE__ */ jsx12(
                   "line",
                   {
-                    x1: componentScreen.x,
+                    x1: targetScreen.x,
                     y1: anchorMarkerScreen.y,
-                    x2: componentScreen.x,
-                    y2: componentScreen.y,
+                    x2: targetScreen.x,
+                    y2: targetScreen.y,
                     stroke: COLORS.OFFSET_LINE,
                     strokeWidth: VISUAL_CONFIG.LINE_STROKE_WIDTH,
                     strokeDasharray: VISUAL_CONFIG.LINE_DASH_PATTERN
@@ -12822,8 +12860,8 @@ var BoardAnchorOffsetOverlay = ({
                 /* @__PURE__ */ jsx12(
                   "circle",
                   {
-                    cx: componentScreen.x,
-                    cy: componentScreen.y,
+                    cx: targetScreen.x,
+                    cy: targetScreen.y,
                     r: VISUAL_CONFIG.COMPONENT_MARKER_RADIUS,
                     fill: COLORS.COMPONENT_MARKER_FILL,
                     stroke: COLORS.COMPONENT_MARKER_STROKE,
@@ -12833,9 +12871,9 @@ var BoardAnchorOffsetOverlay = ({
                 shouldShowXLabel && /* @__PURE__ */ jsx12(
                   "foreignObject",
                   {
-                    x: Math.min(anchorMarkerScreen.x, componentScreen.x),
+                    x: Math.min(anchorMarkerScreen.x, targetScreen.x),
                     y: anchorMarkerScreen.y + xLabelOffset,
-                    width: Math.abs(componentScreen.x - anchorMarkerScreen.x),
+                    width: Math.abs(targetScreen.x - anchorMarkerScreen.x),
                     height: 20,
                     style: { overflow: "visible" },
                     children: /* @__PURE__ */ jsx12("div", { style: { ...labelStyle, textAlign: "center" }, children: xLabelText })
@@ -12844,10 +12882,10 @@ var BoardAnchorOffsetOverlay = ({
                 shouldShowYLabel && /* @__PURE__ */ jsx12(
                   "foreignObject",
                   {
-                    x: componentScreen.x + yLabelOffset,
-                    y: Math.min(anchorMarkerScreen.y, componentScreen.y),
+                    x: targetScreen.x + yLabelOffset,
+                    y: Math.min(anchorMarkerScreen.y, targetScreen.y),
                     width: 20,
-                    height: Math.abs(componentScreen.y - anchorMarkerScreen.y),
+                    height: Math.abs(targetScreen.y - anchorMarkerScreen.y),
                     style: { overflow: "visible" },
                     children: /* @__PURE__ */ jsx12(
                       "div",
@@ -12863,7 +12901,7 @@ var BoardAnchorOffsetOverlay = ({
                     )
                   }
                 )
-              ] }, `${board.pcb_board_id}-${component.pcb_component_id}`);
+              ] }, `${target.board.pcb_board_id}-${targetId}-${target.type}`);
             }),
             Array.from(boardAnchorScreens.entries()).map(
               ([boardId, anchorScreen]) => /* @__PURE__ */ jsxs9("g", { children: [
@@ -12900,26 +12938,6 @@ var BoardAnchorOffsetOverlay = ({
 
 // src/components/AnchorOffsetOverlay/Group/index.tsx
 import { applyToPoint as applyToPoint13 } from "transformation-matrix";
-
-// src/components/AnchorOffsetOverlay/Group/calculateGroupBoundingBox.ts
-import { distance as distance3 } from "circuit-json";
-var calculateGroupBoundingBox = (groupComponents) => {
-  const points = [];
-  for (const comp of groupComponents) {
-    if (!comp.center) {
-      continue;
-    }
-    const width = typeof comp.width === "number" ? comp.width : distance3.parse(comp.width);
-    const height = typeof comp.height === "number" ? comp.height : distance3.parse(comp.height);
-    const halfWidth = width / 2;
-    const halfHeight = height / 2;
-    points.push({ x: comp.center.x - halfWidth, y: comp.center.y - halfHeight });
-    points.push({ x: comp.center.x + halfWidth, y: comp.center.y + halfHeight });
-  }
-  return getBoundsFromPoints(points);
-};
-
-// src/components/AnchorOffsetOverlay/Group/index.tsx
 import { jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
 var GroupAnchorOffsetOverlay = ({
   elements,
@@ -12941,29 +12959,53 @@ var GroupAnchorOffsetOverlay = ({
     }
     return null;
   }).filter((id) => Boolean(id));
+  const hoveredGroupIds = /* @__PURE__ */ new Set();
+  hoveredComponentIds.forEach((componentId) => {
+    const component = components.find((c) => c.pcb_component_id === componentId);
+    if (component?.pcb_group_id) {
+      hoveredGroupIds.add(component.pcb_group_id);
+    }
+    if (component?.position_mode === "relative_to_group_anchor" && component.positioned_relative_to_pcb_group_id) {
+      hoveredGroupIds.add(component.positioned_relative_to_pcb_group_id);
+    }
+  });
   const isShowingAnchorOffsets = useGlobalStore(
     (s) => s.is_showing_group_anchor_offsets
   );
   if (!isShowingAnchorOffsets && hoveredComponentIds.length === 0) {
     return null;
   }
-  const targets = components.map((component) => {
+  const componentTargets = components.map((component) => {
     if (component.position_mode === "relative_to_group_anchor" && component.positioned_relative_to_pcb_group_id) {
       const parentGroup = groups.find(
         (group) => group.pcb_group_id === component.positioned_relative_to_pcb_group_id
       );
-      return parentGroup && parentGroup.anchor_position ? { component, parentGroup } : null;
+      return parentGroup && parentGroup.anchor_position ? { component, parentGroup, type: "component" } : null;
     }
     if (component.pcb_group_id) {
       const parentGroup = groups.find(
         (group) => group.pcb_group_id === component.pcb_group_id
       );
-      return parentGroup && parentGroup.anchor_position ? { component, parentGroup } : null;
+      return parentGroup && parentGroup.anchor_position ? { component, parentGroup, type: "component" } : null;
     }
     return null;
   }).filter(
     (target) => Boolean(target)
   );
+  const groupTargets = groups.map((group) => {
+    if (group.position_mode === "relative_to_group_anchor" && group.positioned_relative_to_pcb_group_id) {
+      const parentGroup = groups.find(
+        (g) => g.pcb_group_id === group.positioned_relative_to_pcb_group_id
+      );
+      if (parentGroup && parentGroup.anchor_position && group.center) {
+        return { group, parentGroup, type: "group" };
+      }
+    }
+    return null;
+  }).filter(
+    (target) => Boolean(target)
+  );
+  const targets = [...componentTargets, ...groupTargets];
   if (targets.length === 0) return null;
   const shouldShowAllTargets = hoveredComponentIds.length === 0;
   const labelStyle = {
@@ -12974,15 +13016,22 @@ var GroupAnchorOffsetOverlay = ({
     fontFamily: "monospace",
     fontWeight: "bold"
   };
-  const targetEntries = targets.filter(
-    ({ component }) => shouldShowAllTargets || hoveredComponentIds.includes(component.pcb_component_id)
-  );
+  const targetEntries = targets.filter((target) => {
+    if (target.type === "component") {
+      return shouldShowAllTargets || hoveredComponentIds.includes(target.component.pcb_component_id);
+    } else {
+      return shouldShowAllTargets || hoveredGroupIds.has(target.group.pcb_group_id) || hoveredGroupIds.has(target.parentGroup.pcb_group_id);
+    }
+  });
   if (targetEntries.length === 0) return null;
   const groupAnchorScreens = /* @__PURE__ */ new Map();
-  targetEntries.forEach(({ parentGroup }) => {
-    if (!parentGroup.anchor_position) return;
-    const anchorScreen = applyToPoint13(transform, parentGroup.anchor_position);
-    groupAnchorScreens.set(parentGroup.pcb_group_id, anchorScreen);
+  targetEntries.forEach((target) => {
+    if (!target.parentGroup.anchor_position) return;
+    const anchorScreen = applyToPoint13(
+      transform,
+      target.parentGroup.anchor_position
+    );
+    groupAnchorScreens.set(target.parentGroup.pcb_group_id, anchorScreen);
   });
   return /* @__PURE__ */ jsx13(
     "div",
@@ -13009,34 +13058,48 @@ var GroupAnchorOffsetOverlay = ({
           width: containerWidth,
           height: containerHeight,
           children: [
-            targetEntries.map(({ component, parentGroup }) => {
-              const anchor = parentGroup.anchor_position;
-              const center = component.center;
-              if (!anchor || !center) return null;
+            targetEntries.map((target) => {
+              const anchor = target.parentGroup.anchor_position;
+              if (!anchor) return null;
               const anchorMarkerPosition = { x: anchor.x, y: anchor.y };
-              const targetCenter = { x: center.x, y: center.y };
-              const groupComponents = components.filter(
-                (comp) => comp.pcb_group_id === parentGroup.pcb_group_id
-              );
-              const boundingBox = calculateGroupBoundingBox(groupComponents);
-              if (!boundingBox) return null;
+              let targetCenter = null;
+              let targetId;
+              let displayOffsetX;
+              let displayOffsetY;
+              if (target.type === "component") {
+                const center = target.component.center;
+                if (!center) return null;
+                targetCenter = { x: center.x, y: center.y };
+                targetId = target.component.pcb_component_id;
+                displayOffsetX = target.component.display_offset_x;
+                displayOffsetY = target.component.display_offset_y;
+              } else {
+                if (!target.group.center) return null;
+                targetCenter = {
+                  x: target.group.center.x,
+                  y: target.group.center.y
+                };
+                targetId = target.group.pcb_group_id;
+                displayOffsetX = target.group.display_offset_x;
+                displayOffsetY = target.group.display_offset_y;
+              }
               const offsetX = targetCenter.x - anchorMarkerPosition.x;
               const offsetY = targetCenter.y - anchorMarkerPosition.y;
               const anchorMarkerScreen = applyToPoint13(
                 transform,
                 anchorMarkerPosition
               );
-              const componentScreen = applyToPoint13(transform, targetCenter);
-              const xLineLength = Math.abs(componentScreen.x - anchorMarkerScreen.x);
-              const yLineLength = Math.abs(componentScreen.y - anchorMarkerScreen.y);
-              const isComponentAboveAnchor = componentScreen.y < anchorMarkerScreen.y;
-              const isComponentRightOfAnchor = componentScreen.x > anchorMarkerScreen.x;
-              const xLabelOffset = isComponentAboveAnchor ? VISUAL_CONFIG.LABEL_OFFSET_ABOVE : VISUAL_CONFIG.LABEL_OFFSET_BELOW;
-              const yLabelOffset = isComponentRightOfAnchor ? VISUAL_CONFIG.LABEL_OFFSET_RIGHT : VISUAL_CONFIG.LABEL_OFFSET_LEFT;
+              const targetScreen = applyToPoint13(transform, targetCenter);
+              const xLineLength = Math.abs(targetScreen.x - anchorMarkerScreen.x);
+              const yLineLength = Math.abs(targetScreen.y - anchorMarkerScreen.y);
+              const isTargetAboveAnchor = targetScreen.y < anchorMarkerScreen.y;
+              const isTargetRightOfAnchor = targetScreen.x > anchorMarkerScreen.x;
+              const xLabelOffset = isTargetAboveAnchor ? VISUAL_CONFIG.LABEL_OFFSET_ABOVE : VISUAL_CONFIG.LABEL_OFFSET_BELOW;
+              const yLabelOffset = isTargetRightOfAnchor ? VISUAL_CONFIG.LABEL_OFFSET_RIGHT : VISUAL_CONFIG.LABEL_OFFSET_LEFT;
               const shouldShowXLabel = xLineLength > VISUAL_CONFIG.MIN_LINE_LENGTH_FOR_LABEL;
               const shouldShowYLabel = yLineLength > VISUAL_CONFIG.MIN_LINE_LENGTH_FOR_LABEL;
-              const xLabelText = component.display_offset_x ?? `\u0394x: ${offsetX.toFixed(2)}mm`;
-              const yLabelText = component.display_offset_y ?? `\u0394y: ${offsetY.toFixed(2)}mm`;
+              const xLabelText = displayOffsetX ?? `\u0394x: ${offsetX.toFixed(2)}mm`;
+              const yLabelText = displayOffsetY ?? `\u0394y: ${offsetY.toFixed(2)}mm`;
               return /* @__PURE__ */ jsxs10(
                 "g",
                 {
@@ -13046,7 +13109,7 @@ var GroupAnchorOffsetOverlay = ({
                       {
                         x1: anchorMarkerScreen.x,
                         y1: anchorMarkerScreen.y,
-                        x2: componentScreen.x,
+                        x2: targetScreen.x,
                         y2: anchorMarkerScreen.y,
                         stroke: COLORS.OFFSET_LINE,
                         strokeWidth: VISUAL_CONFIG.LINE_STROKE_WIDTH,
@@ -13056,10 +13119,10 @@ var GroupAnchorOffsetOverlay = ({
                     /* @__PURE__ */ jsx13(
                       "line",
                       {
-                        x1: componentScreen.x,
+                        x1: targetScreen.x,
                         y1: anchorMarkerScreen.y,
-                        x2: componentScreen.x,
-                        y2: componentScreen.y,
+                        x2: targetScreen.x,
+                        y2: targetScreen.y,
                         stroke: COLORS.OFFSET_LINE,
                         strokeWidth: VISUAL_CONFIG.LINE_STROKE_WIDTH,
                         strokeDasharray: VISUAL_CONFIG.LINE_DASH_PATTERN
@@ -13068,8 +13131,8 @@ var GroupAnchorOffsetOverlay = ({
                     /* @__PURE__ */ jsx13(
                       "circle",
                       {
-                        cx: componentScreen.x,
-                        cy: componentScreen.y,
+                        cx: targetScreen.x,
+                        cy: targetScreen.y,
                         r: VISUAL_CONFIG.COMPONENT_MARKER_RADIUS,
                         fill: COLORS.COMPONENT_MARKER_FILL,
                         stroke: COLORS.COMPONENT_MARKER_STROKE,
@@ -13079,9 +13142,9 @@ var GroupAnchorOffsetOverlay = ({
                     shouldShowXLabel && /* @__PURE__ */ jsx13(
                       "foreignObject",
                       {
-                        x: Math.min(anchorMarkerScreen.x, componentScreen.x),
+                        x: Math.min(anchorMarkerScreen.x, targetScreen.x),
                         y: anchorMarkerScreen.y + xLabelOffset,
-                        width: Math.abs(componentScreen.x - anchorMarkerScreen.x),
+                        width: Math.abs(targetScreen.x - anchorMarkerScreen.x),
                         height: 20,
                         style: { overflow: "visible" },
                         children: /* @__PURE__ */ jsx13("div", { style: { ...labelStyle, textAlign: "center" }, children: xLabelText })
@@ -13090,10 +13153,10 @@ var GroupAnchorOffsetOverlay = ({
                     shouldShowYLabel && /* @__PURE__ */ jsx13(
                       "foreignObject",
                       {
-                        x: componentScreen.x + yLabelOffset,
-                        y: Math.min(anchorMarkerScreen.y, componentScreen.y),
+                        x: targetScreen.x + yLabelOffset,
+                        y: Math.min(anchorMarkerScreen.y, targetScreen.y),
                         width: 20,
-                        height: Math.abs(componentScreen.y - anchorMarkerScreen.y),
+                        height: Math.abs(targetScreen.y - anchorMarkerScreen.y),
                         style: { overflow: "visible" },
                         children: /* @__PURE__ */ jsx13(
                           "div",
@@ -13111,7 +13174,7 @@ var GroupAnchorOffsetOverlay = ({
                     )
                   ]
                 },
-                `${parentGroup.pcb_group_id}-${component.pcb_component_id}`
+                `${target.parentGroup.pcb_group_id}-${targetId}-${target.type}`
               );
             }),
             Array.from(groupAnchorScreens.entries()).map(
@@ -13190,22 +13253,22 @@ var getPrimitivesUnderPoint = (primitives, rwPoint, transform) => {
   for (const primitive of primitives) {
     if (!primitive._element) continue;
     if ("x1" in primitive && primitive._element?.type === "pcb_trace") {
-      const distance5 = pointToSegmentDistance(
+      const distance4 = pointToSegmentDistance(
         { x: rwPoint.x, y: rwPoint.y },
         { x: primitive.x1, y: primitive.y1 },
         { x: primitive.x2, y: primitive.y2 }
       );
       const lineWidth = primitive.width || 0.5;
       const detectionThreshold = Math.max(lineWidth * 25, 2) / transform.a;
-      if (distance5 < detectionThreshold) {
+      if (distance4 < detectionThreshold) {
         newMousedPrimitives.push(primitive);
       }
       continue;
     }
     if (primitive.pcb_drawing_type === "polygon") {
       const points = primitive.points.map((point) => ({
-        x: distance4.parse(point.x),
-        y: distance4.parse(point.y)
+        x: distance3.parse(point.x),
+        y: distance3.parse(point.y)
       }));
       const boundingBox = getPolygonBoundingBox(points);
       if (!boundingBox) continue;
@@ -13219,8 +13282,8 @@ var getPrimitivesUnderPoint = (primitives, rwPoint, transform) => {
     }
     if (primitive.pcb_drawing_type === "polygon_with_arcs") {
       const points = primitive.brep_shape.outer_ring.vertices.map((v) => ({
-        x: distance4.parse(v.x),
-        y: distance4.parse(v.y)
+        x: distance3.parse(v.x),
+        y: distance3.parse(v.y)
       }));
       const boundingBox = getPolygonBoundingBox(points);
       if (!boundingBox) continue;
@@ -13668,11 +13731,11 @@ var RatsNestOverlay = ({ transform, soup, children }) => {
       connectedIds.forEach((id) => {
         const pos = getElementPosition(id);
         if (pos) {
-          const distance5 = Math.sqrt(
+          const distance4 = Math.sqrt(
             (sourcePoint.x - pos.x) ** 2 + (sourcePoint.y - pos.y) ** 2
           );
-          if (distance5 < minDistance && distance5 > 0) {
-            minDistance = distance5;
+          if (distance4 < minDistance && distance4 > 0) {
+            minDistance = distance4;
             nearestPoint = pos;
           }
         }
@@ -13752,7 +13815,7 @@ import { css as css3 } from "@emotion/css";
 // package.json
 var package_default = {
   name: "@tscircuit/pcb-viewer",
-  version: "1.11.281",
+  version: "1.11.282",
   main: "dist/index.js",
   type: "module",
   repository: "tscircuit/pcb-viewer",