@tscircuit/core 0.0.907 → 0.0.909

package/dist/index.js

@@ -11836,9 +11836,7 @@ import {
   convertPackOutputToPackInput,
   getGraphicsFromPackOutput
 } from "calculate-packing";
-import {
-  length as length4
-} from "circuit-json";
+import { length as length4 } from "circuit-json";
 import Debug8 from "debug";
 
 // lib/components/primitive-components/Group/Group_doInitialPcbLayoutPack/applyComponentConstraintClusters.ts
@@ -12211,83 +12209,6 @@ var applyPackOutput = (group, packOutput, clusterMap) => {
   }
 };
 
-// lib/utils/packing/getObstacleDimensionsFromElement.ts
-function getObstacleDimensionsFromSmtPad(pad) {
-  switch (pad.shape) {
-    case "rect":
-    case "rotated_rect":
-    case "pill":
-    case "rotated_pill":
-      return {
-        width: pad.width,
-        height: pad.height
-      };
-    case "circle":
-      return {
-        width: pad.radius * 2,
-        height: pad.radius * 2
-      };
-    case "polygon":
-      if (!pad.points || pad.points.length === 0) {
-        return null;
-      }
-      const xs = pad.points.map((p) => p.x);
-      const ys = pad.points.map((p) => p.y);
-      const minX = Math.min(...xs);
-      const maxX = Math.max(...xs);
-      const minY = Math.min(...ys);
-      const maxY = Math.max(...ys);
-      return {
-        width: maxX - minX,
-        height: maxY - minY
-      };
-    default:
-      return null;
-  }
-}
-function getObstacleDimensionsFromPlatedHole(hole) {
-  switch (hole.shape) {
-    case "circular_hole_with_rect_pad":
-    case "pill_hole_with_rect_pad":
-    case "rotated_pill_hole_with_rect_pad":
-      return {
-        width: hole.rect_pad_width,
-        height: hole.rect_pad_height
-      };
-    case "circle":
-      return {
-        width: hole.outer_diameter,
-        height: hole.outer_diameter
-      };
-    case "oval":
-      return {
-        width: hole.outer_width,
-        height: hole.outer_height
-      };
-    case "pill":
-      return {
-        width: hole.outer_width,
-        height: hole.outer_height
-      };
-    case "hole_with_polygon_pad":
-      if (!("pad_outline" in hole) || !hole.pad_outline || hole.pad_outline.length === 0) {
-        return null;
-      }
-      const xs = hole.pad_outline.map((p) => p.x);
-      const ys = hole.pad_outline.map((p) => p.y);
-      const minX = Math.min(...xs);
-      const maxX = Math.max(...xs);
-      const minY = Math.min(...ys);
-      const maxY = Math.max(...ys);
-      return {
-        width: maxX - minX,
-        height: maxY - minY
-      };
-    default:
-      return null;
-  }
-}
-
 // lib/components/primitive-components/Group/Group_doInitialPcbLayoutPack/Group_doInitialPcbLayoutPack.ts
 var DEFAULT_MIN_GAP = "1mm";
 var debug6 = Debug8("Group_doInitialPcbLayoutPack");
@@ -12304,7 +12225,7 @@ var Group_doInitialPcbLayoutPack = (group) => {
   const gap = pcbPackGap ?? pcbGap ?? gapProp;
   const gapMm = length4.parse(gap ?? DEFAULT_MIN_GAP);
   const chipMarginsMap = {};
-  const excludedPcbComponentIds = /* @__PURE__ */ new Set();
+  const staticPcbComponentIds = /* @__PURE__ */ new Set();
   const collectMargins = (comp) => {
     if (comp?.pcb_component_id && comp?._parsedProps) {
       const props2 = comp._parsedProps;
@@ -12326,7 +12247,7 @@ var Group_doInitialPcbLayoutPack = (group) => {
     const childIsGroupOrNormalComponent = child;
     if (childIsGroupOrNormalComponent._isNormalComponent && childIsGroupOrNormalComponent.isRelativelyPositioned?.()) {
       if (childIsGroupOrNormalComponent.pcb_component_id) {
-        excludedPcbComponentIds.add(
+        staticPcbComponentIds.add(
           childIsGroupOrNormalComponent.pcb_component_id
         );
       }
@@ -12337,67 +12258,27 @@ var Group_doInitialPcbLayoutPack = (group) => {
       }
     }
   }
-  const filteredCircuitJson = db.toArray().filter((element) => {
-    if (element.type === "pcb_component") {
-      return !excludedPcbComponentIds.has(element.pcb_component_id);
-    }
-    if (element.type === "pcb_group") {
-      return !excludedPcbGroupIds.has(element.pcb_group_id);
-    }
-    return true;
-  });
-  const obstaclesFromRelativelyPositionedComponents = [];
-  for (const pcb_component_id of excludedPcbComponentIds) {
-    const component = db.toArray().find(
-      (el) => el.type === "pcb_component" && el.pcb_component_id === pcb_component_id
-    );
-    if (!component) continue;
-    const componentX = component.center.x;
-    const componentY = component.center.y;
-    const smtpads = db.toArray().filter(
-      (el) => el.type === "pcb_smtpad" && el.pcb_component_id === pcb_component_id
-    );
-    for (const pad of smtpads) {
-      const dimensions = getObstacleDimensionsFromSmtPad(pad);
-      if (!dimensions || dimensions.width === 0 || dimensions.height === 0) {
-        continue;
-      }
-      let centerX;
-      let centerY;
-      if (pad.shape === "polygon") {
-        const xs = pad.points.map((p) => p.x);
-        const ys = pad.points.map((p) => p.y);
-        centerX = componentX + (Math.min(...xs) + Math.max(...xs)) / 2;
-        centerY = componentY + (Math.min(...ys) + Math.max(...ys)) / 2;
-      } else {
-        centerX = componentX + pad.x;
-        centerY = componentY + pad.y;
-      }
-      obstaclesFromRelativelyPositionedComponents.push({
-        obstacleId: pad.pcb_smtpad_id,
-        absoluteCenter: { x: centerX, y: centerY },
-        width: dimensions.width,
-        height: dimensions.height
-      });
-    }
-    const platedHoles = db.toArray().filter(
-      (el) => el.type === "pcb_plated_hole" && el.pcb_component_id === pcb_component_id
-    );
-    for (const hole of platedHoles) {
-      const dimensions = getObstacleDimensionsFromPlatedHole(hole);
-      if (!dimensions || dimensions.width === 0 || dimensions.height === 0) {
-        continue;
+  const isDescendantGroup2 = (db2, groupId, ancestorId) => {
+    if (groupId === ancestorId) return true;
+    const group2 = db2.source_group.get(groupId);
+    if (!group2 || !group2.parent_source_group_id) return false;
+    return isDescendantGroup2(db2, group2.parent_source_group_id, ancestorId);
+  };
+  if (excludedPcbGroupIds.size > 0) {
+    for (const element of db.toArray()) {
+      if (element.type !== "pcb_component") continue;
+      const sourceComponent = db.source_component.get(
+        element.source_component_id
+      );
+      if (!sourceComponent?.source_group_id) continue;
+      for (const groupId of excludedPcbGroupIds) {
+        if (isDescendantGroup2(db, sourceComponent.source_group_id, groupId)) {
+          staticPcbComponentIds.add(element.pcb_component_id);
+        }
       }
-      const centerX = componentX + hole.x;
-      const centerY = componentY + hole.y;
-      obstaclesFromRelativelyPositionedComponents.push({
-        obstacleId: hole.pcb_plated_hole_id,
-        absoluteCenter: { x: centerX, y: centerY },
-        width: dimensions.width,
-        height: dimensions.height
-      });
     }
   }
+  const filteredCircuitJson = db.toArray();
   let bounds;
   if (props.width !== void 0 && props.height !== void 0) {
     const widthMm = length4.parse(props.width);
@@ -12413,15 +12294,15 @@ var Group_doInitialPcbLayoutPack = (group) => {
     ...convertPackOutputToPackInput(
       convertCircuitJsonToPackOutput(filteredCircuitJson, {
         source_group_id: group.source_group_id,
-        shouldAddInnerObstacles: true,
-        chipMarginsMap
+        // shouldAddInnerObstacles: true,
+        chipMarginsMap,
+        staticPcbComponentIds: Array.from(staticPcbComponentIds)
       })
     ),
     // @ts-expect-error we're missing some pack order strategies
     orderStrategy: packOrderStrategy ?? "largest_to_smallest",
     placementStrategy: packPlacementStrategy ?? "minimum_sum_squared_distance_to_network",
     minGap: gapMm,
-    obstacles: obstaclesFromRelativelyPositionedComponents,
     bounds
   };
   const clusterMap = applyComponentConstraintClusters(group, packInput);
@@ -15826,208 +15707,10 @@ import * as Flatten from "@flatten-js/core";
 var DEFAULT_PANEL_MARGIN = 5;
 var DEFAULT_TAB_LENGTH = 5;
 var DEFAULT_TAB_WIDTH = 2;
-function rectanglesOverlap(rect1, rect2) {
-  const r1Left = rect1.center.x - rect1.width / 2;
-  const r1Right = rect1.center.x + rect1.width / 2;
-  const r1Bottom = rect1.center.y - rect1.height / 2;
-  const r1Top = rect1.center.y + rect1.height / 2;
-  const r2Left = rect2.center.x - rect2.width / 2;
-  const r2Right = rect2.center.x + rect2.width / 2;
-  const r2Bottom = rect2.center.y - rect2.height / 2;
-  const r2Top = rect2.center.y + rect2.height / 2;
-  return !(r1Right <= r2Left || r1Left >= r2Right || r1Top <= r2Bottom || r1Bottom >= r2Top);
-}
-function pointOverlapsRectangle(point2, radius, rect) {
-  const rectLeft = rect.center.x - rect.width / 2;
-  const rectRight = rect.center.x + rect.width / 2;
-  const rectBottom = rect.center.y - rect.height / 2;
-  const rectTop = rect.center.y + rect.height / 2;
-  const closestX = Math.max(rectLeft, Math.min(point2.x, rectRight));
-  const closestY = Math.max(rectBottom, Math.min(point2.y, rectTop));
-  const distanceX = point2.x - closestX;
-  const distanceY = point2.y - closestY;
-  return distanceX * distanceX + distanceY * distanceY <= radius * radius;
-}
-function generateTabsForEdge({
-  board,
-  edge,
-  otherBoards,
-  options
-}) {
-  const tabs = [];
-  if (!board.width || !board.height) return tabs;
-  const boardLeft = board.center.x - board.width / 2;
-  const boardRight = board.center.x + board.width / 2;
-  const boardBottom = board.center.y - board.height / 2;
-  const boardTop = board.center.y + board.height / 2;
-  let edgeLength;
-  let isHorizontal;
-  let edgeCenter;
-  if (edge === "top" || edge === "bottom") {
-    edgeLength = board.width;
-    isHorizontal = true;
-    edgeCenter = edge === "top" ? boardTop : boardBottom;
-  } else {
-    edgeLength = board.height;
-    isHorizontal = false;
-    edgeCenter = edge === "right" ? boardRight : boardLeft;
-  }
-  const totalTabWidth = options.tabLength;
-  let fixedSpacing = options.boardGap;
-  if (options.mouseBites) {
-    const mouseBiteDiameter = options.tabWidth * 0.45;
-    const mouseBiteSpacing = mouseBiteDiameter * 0.1;
-    const mouseBitesPerGap = Math.max(2, Math.ceil(options.tabLength / 2));
-    const minSpacingForMouseBites = mouseBitesPerGap * mouseBiteDiameter + (mouseBitesPerGap - 1) * mouseBiteSpacing;
-    fixedSpacing = minSpacingForMouseBites * 1.1;
-  }
-  let numTabs = Math.floor(
-    (edgeLength - fixedSpacing) / (totalTabWidth + fixedSpacing)
-  );
-  if (numTabs < 1 && edgeLength >= totalTabWidth) {
-    numTabs = 1;
-  }
-  if (numTabs === 0) return tabs;
-  const actualSpacing = fixedSpacing;
-  const boardStart = -edgeLength / 2;
-  const boardEnd = edgeLength / 2;
-  for (let i = 0; i < numTabs; i++) {
-    const offsetAlongEdge = boardStart + actualSpacing + i * (totalTabWidth + actualSpacing) + totalTabWidth / 2;
-    const isFirstTab = i === 0;
-    const isLastTab = i === numTabs - 1;
-    const isCornerTab = isFirstTab || isLastTab;
-    let axisStart = offsetAlongEdge - totalTabWidth / 2;
-    let axisEnd = offsetAlongEdge + totalTabWidth / 2;
-    if (isCornerTab) {
-      if (isFirstTab) axisStart = boardStart;
-      if (isLastTab) axisEnd = boardEnd;
-    }
-    axisStart = Math.max(axisStart, boardStart);
-    axisEnd = Math.min(axisEnd, boardEnd);
-    if (isCornerTab) {
-      if (isFirstTab) axisStart -= options.tabWidth;
-      if (isLastTab) axisEnd += options.tabWidth;
-    }
-    if (axisEnd <= axisStart) continue;
-    const axisCenterOffset = (axisStart + axisEnd) / 2;
-    const axisLength = axisEnd - axisStart;
-    const crossAxisOffset = edge === "top" || edge === "right" ? options.tabWidth / 2 : -options.tabWidth / 2;
-    const tabCenter = isHorizontal ? {
-      x: board.center.x + axisCenterOffset,
-      y: edgeCenter + crossAxisOffset
-    } : {
-      x: edgeCenter + crossAxisOffset,
-      y: board.center.y + axisCenterOffset
-    };
-    const tabWidth = isHorizontal ? axisLength : options.tabWidth;
-    const tabHeight = isHorizontal ? options.tabWidth : axisLength;
-    const newTab = {
-      center: tabCenter,
-      width: tabWidth,
-      height: tabHeight,
-      boardId: `${board.center.x}_${board.center.y}`
-    };
-    let overlapsBoard = false;
-    for (const otherBoard of otherBoards) {
-      if (!otherBoard.width || !otherBoard.height) continue;
-      const boardRect = {
-        center: otherBoard.center,
-        width: otherBoard.width,
-        height: otherBoard.height
-      };
-      if (rectanglesOverlap(newTab, boardRect)) {
-        overlapsBoard = true;
-        break;
-      }
-    }
-    if (overlapsBoard && !isCornerTab) continue;
-    tabs.push(newTab);
-  }
-  return tabs;
-}
-function generateMouseBitesForEdge({
-  board,
-  edge,
-  edgeTabs,
-  allBoards,
-  options
-}) {
-  const mouseBites = [];
-  if (edgeTabs.length === 0) return mouseBites;
-  if (!board.width || !board.height) return mouseBites;
-  const boardLeft = board.center.x - board.width / 2;
-  const boardRight = board.center.x + board.width / 2;
-  const boardBottom = board.center.y - board.height / 2;
-  const boardTop = board.center.y + board.height / 2;
-  const isHorizontal = edge === "top" || edge === "bottom";
-  const mouseBiteDiameter = options.tabWidth * 0.45;
-  const mouseBiteSpacing = mouseBiteDiameter * 0.1;
-  const mouseBitesPerGap = Math.max(2, Math.ceil(options.tabLength / 2));
-  let mouseBitePosition;
-  const radius = mouseBiteDiameter / 2;
-  if (edge === "top") {
-    mouseBitePosition = boardTop;
-  } else if (edge === "bottom") {
-    mouseBitePosition = boardBottom;
-  } else if (edge === "right") {
-    mouseBitePosition = boardRight;
-  } else {
-    mouseBitePosition = boardLeft;
-  }
-  const sortedTabs = [...edgeTabs].sort((a, b) => {
-    if (isHorizontal) {
-      return a.center.x - b.center.x;
-    } else {
-      return a.center.y - b.center.y;
-    }
-  });
-  for (let i = 0; i < sortedTabs.length - 1; i++) {
-    const tab1 = sortedTabs[i];
-    const tab2 = sortedTabs[i + 1];
-    let gapStart;
-    let gapEnd;
-    if (isHorizontal) {
-      gapStart = tab1.center.x + tab1.width / 2;
-      gapEnd = tab2.center.x - tab2.width / 2;
-    } else {
-      gapStart = tab1.center.y + tab1.height / 2;
-      gapEnd = tab2.center.y - tab2.height / 2;
-    }
-    const gapLength = gapEnd - gapStart;
-    const totalMouseBiteWidth = mouseBitesPerGap * mouseBiteDiameter;
-    const totalSpacing = (mouseBitesPerGap - 1) * mouseBiteSpacing;
-    if (gapLength < totalMouseBiteWidth + totalSpacing) continue;
-    const gapCenter = (gapStart + gapEnd) / 2;
-    for (let j = 0; j < mouseBitesPerGap; j++) {
-      const posOffset = (j - (mouseBitesPerGap - 1) / 2) * (mouseBiteDiameter + mouseBiteSpacing);
-      const newMouseBite = isHorizontal ? { x: gapCenter + posOffset, y: mouseBitePosition } : { x: mouseBitePosition, y: gapCenter + posOffset };
-      const radius2 = mouseBiteDiameter / 2;
-      let overlapsBoard = false;
-      for (const otherBoard of allBoards) {
-        if (!otherBoard.width || !otherBoard.height) continue;
-        const boardRect = {
-          center: otherBoard.center,
-          width: otherBoard.width,
-          height: otherBoard.height
-        };
-        if (pointOverlapsRectangle(newMouseBite, radius2, boardRect)) {
-          overlapsBoard = true;
-          break;
-        }
-      }
-      if (overlapsBoard) continue;
-      mouseBites.push(newMouseBite);
-    }
-  }
-  return mouseBites;
-}
-var generatePanelTabsAndMouseBitesForOutlines = (outline, otherBoards, options) => {
+var generateCutoutsAndMousebitesForOutline = (outline, options) => {
   const {
-    boardGap,
-    tabLength,
-    // along edge
-    tabWidth,
-    // extrusion
+    gapLength,
+    cutoutWidth,
     mouseBites,
     mouseBiteHoleDiameter,
     mouseBiteHoleSpacing
@@ -16040,181 +15723,142 @@ var generatePanelTabsAndMouseBitesForOutlines = (outline, otherBoards, options)
   const outlinePolygon = new Flatten.Polygon(
     outline.map((p) => Flatten.point(p.x, p.y))
   );
-  const otherBoardGeometries = otherBoards.map(
-    (b) => b.outline ? new Flatten.Polygon(b.outline.map((p) => Flatten.point(p.x, p.y))) : b.width && b.height ? new Flatten.Box(
-      b.center.x - b.width / 2,
-      b.center.y - b.height / 2,
-      b.center.x + b.width / 2,
-      b.center.y + b.height / 2
-    ) : null
-  );
-  for (let i = 0; i < outline.length; i++) {
-    const p1 = outline[i];
-    const p2 = outline[(i + 1) % outline.length];
-    const segmentVector = Flatten.vector(p2.x - p1.x, p2.y - p1.y);
-    const segmentLength = segmentVector.length;
-    const physicalTabLength = boardGap;
-    const cutoutLength = tabLength;
-    if (segmentLength < physicalTabLength) continue;
-    const segmentDirVec = segmentVector.normalize();
-    const isHorizontal = Math.abs(segmentVector.y) < 1e-9;
-    const isVertical = Math.abs(segmentVector.x) < 1e-9;
-    const isAxisAligned = isHorizontal || isVertical;
-    let normalVec = segmentDirVec.rotate(Math.PI / 2);
-    const midPoint = Flatten.point(p1.x, p1.y).translate(
-      segmentDirVec.multiply(segmentLength / 2)
+  let is_ccw;
+  if (outline.length > 2) {
+    const p0 = Flatten.point(outline[0].x, outline[0].y);
+    const p1 = Flatten.point(outline[1].x, outline[1].y);
+    const segmentDir = Flatten.vector(p0, p1).normalize();
+    const normalToLeft = segmentDir.rotate(Math.PI / 2);
+    const midPoint = p0.translate(
+      segmentDir.multiply(Flatten.segment(p0, p1).length / 2)
     );
-    const testPointInward = midPoint.translate(normalVec.multiply(0.01));
-    if (outlinePolygon.contains(testPointInward)) {
+    const testPoint = midPoint.translate(normalToLeft.multiply(0.01));
+    is_ccw = outlinePolygon.contains(testPoint);
+  } else {
+    is_ccw = outlinePolygon.area() > 0;
+  }
+  for (let i = 0; i < outline.length; i++) {
+    const p1_ = outline[i];
+    const p2_ = outline[(i + 1) % outline.length];
+    if (!p1_ || !p2_) continue;
+    const p1 = Flatten.point(p1_.x, p1_.y);
+    const p2 = Flatten.point(p2_.x, p2_.y);
+    const segment2 = Flatten.segment(p1, p2);
+    const segmentLength = segment2.length;
+    if (segmentLength < 1e-6) continue;
+    const segmentVec = Flatten.vector(p1, p2);
+    const segmentDir = segmentVec.normalize();
+    let normalVec = segmentDir.rotate(Math.PI / 2);
+    const midPoint = segment2.middle();
+    const testPoint = midPoint.translate(normalVec.multiply(0.01));
+    if (outlinePolygon.contains(testPoint)) {
       normalVec = normalVec.multiply(-1);
     }
-    const testPointOutward = midPoint.translate(
-      normalVec.multiply((tabWidth + physicalTabLength) / 2)
-    );
-    let isExterior = true;
-    for (const geom of otherBoardGeometries) {
-      if (geom?.contains(testPointOutward)) {
-        isExterior = false;
-        break;
-      }
-    }
-    if (!isExterior) continue;
-    const numTabs = Math.max(
-      1,
-      Math.floor(segmentLength / (physicalTabLength + cutoutLength))
-    );
-    const totalContentLength = numTabs * physicalTabLength;
-    const totalGapLength = segmentLength - totalContentLength;
-    const gapSize = totalGapLength / (numTabs + 1);
-    if (gapSize < 0) continue;
-    const tabsOnSegment = [];
-    for (let j = 0; j < numTabs; j++) {
-      const tabStartDist = gapSize * (j + 1) + physicalTabLength * j;
-      tabsOnSegment.push({
-        start: tabStartDist,
-        end: tabStartDist + physicalTabLength
-      });
-    }
-    const extrusion = normalVec.multiply(tabWidth);
-    for (let j = 0; j <= numTabs; j++) {
-      const gapStartDist = j === 0 ? 0 : tabsOnSegment[j - 1].end;
-      const gapEndDist = j === numTabs ? segmentLength : tabsOnSegment[j].start;
-      const gapLength = gapEndDist - gapStartDist;
-      if (gapLength < 1e-6) continue;
-      if (isAxisAligned) {
-        const width = isHorizontal ? gapLength : tabWidth;
-        const height = isHorizontal ? tabWidth : gapLength;
-        const gapCenterAlongSegment = Flatten.point(p1.x, p1.y).translate(
-          segmentDirVec.multiply(gapStartDist + gapLength / 2)
-        );
-        const center = gapCenterAlongSegment.translate(extrusion.multiply(0.5));
-        tabCutouts.push({
-          type: "pcb_cutout",
-          shape: "rect",
-          center,
-          width,
-          height,
-          corner_radius: Math.min(width, height) / 2
-        });
-      } else {
-        const width = gapLength;
-        const height = tabWidth;
-        const gapCenterAlongSegment = Flatten.point(p1.x, p1.y).translate(
-          segmentDirVec.multiply(gapStartDist + gapLength / 2)
-        );
-        const center = gapCenterAlongSegment.translate(extrusion.multiply(0.5));
-        const rotationDeg = segmentDirVec.slope * 180 / Math.PI;
-        tabCutouts.push({
-          type: "pcb_cutout",
-          shape: "rect",
-          center,
-          width,
-          height,
-          rotation: rotationDeg,
-          corner_radius: Math.min(width, height) / 2
-        });
-      }
+    const numBitesInGap = 2;
+    const totalBitesLength = numBitesInGap * mouseBiteHoleDiameter + (numBitesInGap - 1) * mouseBiteHoleSpacing;
+    let effectiveGapLength;
+    if (mouseBites) {
+      effectiveGapLength = totalBitesLength;
+    } else {
+      effectiveGapLength = gapLength;
     }
+    effectiveGapLength = Math.min(effectiveGapLength, segmentLength * 0.9);
+    const gapStartDist = (segmentLength - effectiveGapLength) / 2;
+    const gapEndDist = gapStartDist + effectiveGapLength;
     if (mouseBites) {
-      const holeSpacing = mouseBiteHoleDiameter + mouseBiteHoleSpacing;
-      for (const tab of tabsOnSegment) {
-        const tabLength2 = tab.end - tab.start;
-        if (tabLength2 < holeSpacing) continue;
-        const numBitesInTab = Math.floor(tabLength2 / holeSpacing);
-        if (numBitesInTab <= 0) continue;
-        const biteStartOffset = tab.start + (tabLength2 - (numBitesInTab - 1) * holeSpacing) / 2;
-        for (let k = 0; k < numBitesInTab; k++) {
-          const biteDist = biteStartOffset + k * holeSpacing;
-          const pos = Flatten.point(p1.x, p1.y).translate(
-            segmentDirVec.multiply(biteDist)
-          );
-          mouseBiteHoles.push({
-            x: pos.x,
-            y: pos.y
-          });
+      const holeAndSpacing = mouseBiteHoleDiameter + mouseBiteHoleSpacing;
+      if (effectiveGapLength >= totalBitesLength && holeAndSpacing > 0) {
+        const firstBiteCenterOffsetInGap = (effectiveGapLength - totalBitesLength) / 2 + mouseBiteHoleDiameter / 2;
+        const firstBiteDistFromP1 = gapStartDist + firstBiteCenterOffsetInGap;
+        for (let k = 0; k < numBitesInGap; k++) {
+          const biteDist = firstBiteDistFromP1 + k * holeAndSpacing;
+          const pos = p1.translate(segmentDir.multiply(biteDist));
+          mouseBiteHoles.push({ x: pos.x, y: pos.y });
         }
       }
     }
+    const p_prev_ = outline[(i - 1 + outline.length) % outline.length];
+    const p_next_ = outline[(i + 2) % outline.length];
+    let start_ext = 0;
+    let end_ext = 0;
+    if (p_prev_ && p_next_) {
+      const vec_in_p1 = Flatten.vector(Flatten.point(p_prev_.x, p_prev_.y), p1);
+      const p1_cross = vec_in_p1.cross(segmentVec);
+      const is_p1_convex = is_ccw ? p1_cross > 1e-9 : p1_cross < -1e-9;
+      const vec_out_p2 = Flatten.vector(p2, Flatten.point(p_next_.x, p_next_.y));
+      const p2_cross = segmentVec.cross(vec_out_p2);
+      const is_p2_convex = is_ccw ? p2_cross > 1e-9 : p2_cross < -1e-9;
+      start_ext = is_p1_convex ? cutoutWidth : 0;
+      end_ext = is_p2_convex ? cutoutWidth : 0;
+    }
+    const cutoutParts = [
+      { start: 0 - start_ext, end: gapStartDist },
+      { start: gapEndDist, end: segmentLength + end_ext }
+    ];
+    const extrusion = normalVec.multiply(cutoutWidth);
+    for (const part of cutoutParts) {
+      const partLength = part.end - part.start;
+      if (partLength < 1e-6) continue;
+      const partCenterAlongSegment = p1.translate(
+        segmentDir.multiply(part.start + partLength / 2)
+      );
+      const center = partCenterAlongSegment.translate(extrusion.multiply(0.5));
+      const width = partLength;
+      const height = cutoutWidth;
+      const rotationDeg = segmentDir.slope * 180 / Math.PI;
+      tabCutouts.push({
+        type: "pcb_cutout",
+        shape: "rect",
+        center: { x: center.x, y: center.y },
+        width,
+        height,
+        rotation: rotationDeg,
+        corner_radius: cutoutWidth / 2
+      });
+    }
   }
   return { tabCutouts, mouseBiteHoles };
 };
 function generatePanelTabsAndMouseBites(boards, options) {
   const finalTabCutouts = [];
   const allMouseBites = [];
-  for (let boardIndex = 0; boardIndex < boards.length; boardIndex++) {
-    const board = boards[boardIndex];
-    const otherBoards = boards.filter((_, i) => i !== boardIndex);
+  const { tabWidth, tabLength, mouseBites: useMouseBites } = options;
+  const processedBoards = boards.map((board) => {
+    if ((!board.outline || board.outline.length === 0) && board.width && board.height) {
+      const w2 = board.width / 2;
+      const h2 = board.height / 2;
+      return {
+        ...board,
+        outline: [
+          { x: board.center.x - w2, y: board.center.y - h2 },
+          { x: board.center.x + w2, y: board.center.y - h2 },
+          { x: board.center.x + w2, y: board.center.y + h2 },
+          { x: board.center.x - w2, y: board.center.y + h2 }
+        ]
+      };
+    }
+    return board;
+  });
+  for (const board of processedBoards) {
     if (board.outline && board.outline.length > 0) {
-      const mouseBiteDiameter2 = options.tabWidth * 0.45;
+      const mouseBiteDiameter2 = tabWidth * 0.45;
       const mouseBiteSpacing = mouseBiteDiameter2 * 0.1;
-      const generated = generatePanelTabsAndMouseBitesForOutlines(
-        board.outline,
-        otherBoards,
-        {
-          ...options,
-          mouseBiteHoleDiameter: mouseBiteDiameter2,
-          mouseBiteHoleSpacing: mouseBiteSpacing
-        }
-      );
+      const generated = generateCutoutsAndMousebitesForOutline(board.outline, {
+        gapLength: tabLength,
+        cutoutWidth: tabWidth,
+        mouseBites: useMouseBites,
+        mouseBiteHoleDiameter: mouseBiteDiameter2,
+        mouseBiteHoleSpacing: mouseBiteSpacing
+      });
       finalTabCutouts.push(...generated.tabCutouts);
       allMouseBites.push(...generated.mouseBiteHoles);
-    } else {
-      for (const edge of ["top", "bottom", "left", "right"]) {
-        const edgeTabs = generateTabsForEdge({
-          board,
-          edge,
-          otherBoards,
-          options
-        });
-        for (const tab of edgeTabs) {
-          const tabWidthDimension = Math.min(tab.width, tab.height);
-          finalTabCutouts.push({
-            type: "pcb_cutout",
-            shape: "rect",
-            center: tab.center,
-            width: tab.width,
-            height: tab.height,
-            corner_radius: tabWidthDimension / 2
-          });
-        }
-        if (options.mouseBites) {
-          const edgeMouseBites = generateMouseBitesForEdge({
-            board,
-            edge,
-            edgeTabs,
-            allBoards: otherBoards,
-            options
-          });
-          allMouseBites.push(...edgeMouseBites);
-        }
-      }
     }
   }
   const tabCutouts = finalTabCutouts.map((tab, index) => ({
     ...tab,
     pcb_cutout_id: `panel_tab_${index}`
   }));
-  const mouseBiteDiameter = options.tabWidth * 0.45;
+  const mouseBiteDiameter = tabWidth * 0.45;
   const mouseBiteHoles = allMouseBites.map((bite, index) => ({
     type: "pcb_hole",
     pcb_hole_id: `panel_mouse_bite_${index}`,
@@ -16562,10 +16206,10 @@ var Jumper = class extends NormalComponent3 {
     };
     for (const trace of traces) {
       if (!trace.route) continue;
-      for (const segment of trace.route) {
-        if (segment.route_type !== "wire") continue;
-        segment.start_pcb_port_id = updatePortId(segment.start_pcb_port_id);
-        segment.end_pcb_port_id = updatePortId(segment.end_pcb_port_id);
+      for (const segment2 of trace.route) {
+        if (segment2.route_type !== "wire") continue;
+        segment2.start_pcb_port_id = updatePortId(segment2.start_pcb_port_id);
+        segment2.end_pcb_port_id = updatePortId(segment2.end_pcb_port_id);
       }
     }
   }
@@ -16752,10 +16396,10 @@ var SolderJumper = class extends NormalComponent3 {
     };
     for (const trace of traces) {
       if (!trace.route) continue;
-      for (const segment of trace.route) {
-        if (segment.route_type !== "wire") continue;
-        segment.start_pcb_port_id = updatePortId(segment.start_pcb_port_id);
-        segment.end_pcb_port_id = updatePortId(segment.end_pcb_port_id);
+      for (const segment2 of trace.route) {
+        if (segment2.route_type !== "wire") continue;
+        segment2.start_pcb_port_id = updatePortId(segment2.start_pcb_port_id);
+        segment2.end_pcb_port_id = updatePortId(segment2.end_pcb_port_id);
       }
     }
   }
@@ -19418,7 +19062,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.906",
+  version: "0.0.908",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -19523,7 +19167,7 @@ var package_default = {
   dependencies: {
     "@flatten-js/core": "^1.6.2",
     "@lume/kiwi": "^0.4.3",
-    "calculate-packing": "0.0.65",
+    "calculate-packing": "0.0.66",
     "css-select": "5.1.0",
     "format-si-unit": "^0.0.3",
     nanoid: "^5.0.7",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.907",
+  "version": "0.0.909",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -106,7 +106,7 @@
   "dependencies": {
     "@flatten-js/core": "^1.6.2",
     "@lume/kiwi": "^0.4.3",
-    "calculate-packing": "0.0.65",
+    "calculate-packing": "0.0.66",
     "css-select": "5.1.0",
     "format-si-unit": "^0.0.3",
     "nanoid": "^5.0.7",