circuit-json-to-gerber 0.0.81 → 0.0.83

package/dist/{chunk-LJRHQISL.js → chunk-46NSLLUV.js}

@@ -292,6 +292,8 @@ var ExcellonDrillBuilder = class {
 var excellonDrill = () => new ExcellonDrillBuilder();
 
 // src/excellon-drill/convert-soup-to-excellon-drill-commands.ts
+import polygonClipping from "polygon-clipping";
+import { getBoundFromCenteredRect } from "@tscircuit/math-utils";
 var getLayerCount = (circuitJson) => {
   const board = circuitJson.find((element) => element.type === "pcb_board");
   if (!board || typeof board.num_layers !== "number") {
@@ -426,6 +428,149 @@ var getDrillableElements = (circuitJson) => [
   ...circuitJson,
   ...getTraceRouteViaElements(circuitJson)
 ];
+var circleCutoutPolygonSegmentCount = 64;
+var getBoardOutlinePolygons = (circuitJson) => {
+  return circuitJson.flatMap((element) => {
+    if (element.type !== "pcb_board") {
+      return [];
+    }
+    if (element.outline && element.outline.length > 2) {
+      return [[element.outline.map((point) => [point.x, point.y])]];
+    }
+    const bounds = getBoundFromCenteredRect({
+      center: element.center,
+      width: element.width,
+      height: element.height
+    });
+    return [
+      [
+        [
+          [bounds.minX, bounds.minY],
+          [bounds.maxX, bounds.minY],
+          [bounds.maxX, bounds.maxY],
+          [bounds.minX, bounds.maxY]
+        ]
+      ]
+    ];
+  });
+};
+var getCircleCutoutPolygon = (cutout) => {
+  const points = [];
+  for (let i = 0; i < circleCutoutPolygonSegmentCount; i++) {
+    const angle = i / circleCutoutPolygonSegmentCount * Math.PI * 2;
+    points.push([
+      cutout.center.x + cutout.radius * Math.cos(angle),
+      cutout.center.y + cutout.radius * Math.sin(angle)
+    ]);
+  }
+  return [points];
+};
+var isInternalCircularCutout = ({
+  cutout,
+  boardOutlinePolygons
+}) => {
+  const cutoutPolygon = getCircleCutoutPolygon(cutout);
+  return boardOutlinePolygons.some((boardOutlinePolygon) => {
+    const overlapsBoard = polygonClipping.intersection(boardOutlinePolygon, cutoutPolygon).length > 0;
+    const extendsOutsideBoard = polygonClipping.difference(cutoutPolygon, boardOutlinePolygon).length > 0;
+    return overlapsBoard && !extendsOutsideBoard;
+  });
+};
+var getInternalCircularCutoutDrills = (circuitJson) => {
+  const boardOutlinePolygons = getBoardOutlinePolygons(circuitJson);
+  return circuitJson.filter(
+    (element) => {
+      if (element.type !== "pcb_cutout") {
+        return false;
+      }
+      if (element.shape !== "circle") {
+        return false;
+      }
+      return isInternalCircularCutout({
+        cutout: element,
+        boardOutlinePolygons
+      });
+    }
+  );
+};
+var getDrillElements = ({
+  circuitJson,
+  is_plated
+}) => {
+  const drillableElements = getDrillableElements(circuitJson).filter(
+    (element) => element.type !== "pcb_cutout"
+  );
+  if (is_plated) {
+    return drillableElements;
+  }
+  const internalCircularCutoutDrills = getInternalCircularCutoutDrills(circuitJson);
+  return [...drillableElements, ...internalCircularCutoutDrills];
+};
+var getHoleDiameter = (element) => {
+  if ("hole_diameter" in element && typeof element.hole_diameter === "number") {
+    return element.hole_diameter;
+  }
+  if (element.type === "pcb_cutout") {
+    return element.radius * 2;
+  }
+  if ("hole_width" in element && typeof element.hole_width === "number" && "hole_height" in element && typeof element.hole_height === "number") {
+    return Math.min(element.hole_width, element.hole_height);
+  }
+  return void 0;
+};
+var getDrillCenter = (element) => {
+  if (element.type === "pcb_cutout") {
+    return element.center;
+  }
+  let x = 0;
+  let y = 0;
+  let holeOffsetX = 0;
+  let holeOffsetY = 0;
+  if ("x" in element && typeof element.x === "number") {
+    x = element.x;
+  }
+  if ("y" in element && typeof element.y === "number") {
+    y = element.y;
+  }
+  if ("hole_offset_x" in element && typeof element.hole_offset_x === "number") {
+    holeOffsetX = element.hole_offset_x;
+  }
+  if ("hole_offset_y" in element && typeof element.hole_offset_y === "number") {
+    holeOffsetY = element.hole_offset_y;
+  }
+  return {
+    x: x + holeOffsetX,
+    y: y + holeOffsetY
+  };
+};
+var getYMultiplier = (flip_y_axis) => {
+  if (flip_y_axis) {
+    return -1;
+  }
+  return 1;
+};
+var getSlotEndpoints = ({
+  holeWidth,
+  holeHeight,
+  slotHalfLength
+}) => {
+  let startRelative = { x: 0, y: -slotHalfLength };
+  let endRelative = { x: 0, y: slotHalfLength };
+  if (holeWidth >= holeHeight) {
+    startRelative = { x: -slotHalfLength, y: 0 };
+    endRelative = { x: slotHalfLength, y: 0 };
+  }
+  return { startRelative, endRelative };
+};
+var getHoleRotationDegrees = (element) => {
+  if ("hole_ccw_rotation" in element && typeof element.hole_ccw_rotation === "number") {
+    return element.hole_ccw_rotation;
+  }
+  if ("ccw_rotation" in element && typeof element.ccw_rotation === "number") {
+    return element.ccw_rotation;
+  }
+  return 0;
+};
 var convertSoupToExcellonDrillCommands = ({
   circuitJson,
   is_plated,
@@ -434,7 +579,10 @@ var convertSoupToExcellonDrillCommands = ({
 }) => {
   const builder = excellonDrill();
   const layerCount = getLayerCount(circuitJson);
-  const drillableElements = getDrillableElements(circuitJson);
+  const drillElements = getDrillElements({
+    circuitJson,
+    is_plated
+  });
   builder.add("M48", {});
   const date_str = (/* @__PURE__ */ new Date()).toISOString();
   builder.add("header_comment", {
@@ -457,8 +605,8 @@ var convertSoupToExcellonDrillCommands = ({
   }).add("FMAT", { format: 2 }).add("unit_format", { unit: "METRIC", lz: null });
   let tool_counter = 10;
   const diameterToToolNumber = {};
-  for (const element of drillableElements) {
-    if (!shouldIncludeElement({
+  for (const element of drillElements) {
+    if (element.type !== "pcb_cutout" && !shouldIncludeElement({
       element,
       is_plated,
       layer_span,
@@ -469,7 +617,7 @@ var convertSoupToExcellonDrillCommands = ({
     if (is_plated && element.type === "pcb_hole") {
       continue;
     }
-    const holeDiameter = "hole_diameter" in element && typeof element.hole_diameter === "number" ? element.hole_diameter : "hole_width" in element && typeof element.hole_width === "number" && "hole_height" in element && typeof element.hole_height === "number" ? Math.min(element.hole_width, element.hole_height) : void 0;
+    const holeDiameter = getHoleDiameter(element);
     if (!holeDiameter) continue;
     if (!diameterToToolNumber[holeDiameter]) {
       builder.add("aper_function_header", {
@@ -488,9 +636,9 @@ var convertSoupToExcellonDrillCommands = ({
   builder.add("G05", {});
   for (let i = 10; i < tool_counter; i++) {
     builder.add("use_tool", { tool_number: i });
-    for (const element of drillableElements) {
-      if (element.type === "pcb_plated_hole" || element.type === "pcb_hole" || element.type === "pcb_via") {
-        if (!shouldIncludeElement({
+    for (const element of drillElements) {
+      if (element.type === "pcb_plated_hole" || element.type === "pcb_hole" || element.type === "pcb_via" || element.type === "pcb_cutout") {
+        if (element.type !== "pcb_cutout" && !shouldIncludeElement({
           element,
           is_plated,
           layer_span,
@@ -501,17 +649,14 @@ var convertSoupToExcellonDrillCommands = ({
         if (is_plated && element.type === "pcb_hole") {
           continue;
         }
-        const holeDiameter = "hole_diameter" in element && typeof element.hole_diameter === "number" ? element.hole_diameter : "hole_width" in element && typeof element.hole_width === "number" && "hole_height" in element && typeof element.hole_height === "number" ? Math.min(element.hole_width, element.hole_height) : void 0;
+        const holeDiameter = getHoleDiameter(element);
         if (!holeDiameter || diameterToToolNumber[holeDiameter] !== i) {
           continue;
         }
-        const elementX = "x" in element && typeof element.x === "number" ? element.x : 0;
-        const elementY = "y" in element && typeof element.y === "number" ? element.y : 0;
-        const offsetX = "hole_offset_x" in element && typeof element.hole_offset_x === "number" ? element.hole_offset_x : 0;
-        const offsetY = "hole_offset_y" in element && typeof element.hole_offset_y === "number" ? element.hole_offset_y : 0;
-        const centerX = elementX + offsetX;
-        const centerY = elementY + offsetY;
-        const yMultiplier = flip_y_axis ? -1 : 1;
+        const drillCenter = getDrillCenter(element);
+        const centerX = drillCenter.x;
+        const centerY = drillCenter.y;
+        const yMultiplier = getYMultiplier(flip_y_axis);
         if ("hole_width" in element && typeof element.hole_width === "number" && "hole_height" in element && typeof element.hole_height === "number") {
           const holeWidth = element.hole_width;
           const holeHeight = element.hole_height;
@@ -524,14 +669,16 @@ var convertSoupToExcellonDrillCommands = ({
             });
             continue;
           }
-          const rotationDegrees = "hole_ccw_rotation" in element && typeof element.hole_ccw_rotation === "number" ? element.hole_ccw_rotation : "ccw_rotation" in element && typeof element.ccw_rotation === "number" ? element.ccw_rotation : 0;
+          const rotationDegrees = getHoleRotationDegrees(element);
           const rotationRadians = rotationDegrees * Math.PI / 180;
           const cosTheta = Math.cos(rotationRadians);
           const sinTheta = Math.sin(rotationRadians);
-          const isWidthMajor = holeWidth >= holeHeight;
           const slotHalfLength = (maxDim - minDim) / 2;
-          const startRelative = isWidthMajor ? { x: -slotHalfLength, y: 0 } : { x: 0, y: -slotHalfLength };
-          const endRelative = isWidthMajor ? { x: slotHalfLength, y: 0 } : { x: 0, y: slotHalfLength };
+          const { startRelative, endRelative } = getSlotEndpoints({
+            holeWidth,
+            holeHeight,
+            slotHalfLength
+          });
           const rotatePoint = ({ x, y }) => ({
             x: x * cosTheta - y * sinTheta,
             y: x * sinTheta + y * cosTheta
@@ -600,12 +747,10 @@ var convertSoupToExcellonDrillCommandLayers = ({
     ])
   );
   const hasNonPlatedDrill = circuitJson.some((element) => {
-    if (element.type !== "pcb_hole") {
-      return false;
-    }
-    return hasDrillGeometry(element);
+    return element.type === "pcb_hole" && hasDrillGeometry(element);
   });
-  if (!hasNonPlatedDrill) {
+  const hasInternalCircularCutoutDrill = getInternalCircularCutoutDrills(circuitJson).length > 0;
+  if (!hasNonPlatedDrill && !hasInternalCircularCutoutDrill) {
     return platedDrillLayers;
   }
   return {
@@ -1329,6 +1474,136 @@ var defineCommonMacros = (glayer) => {
   );
 };
 
+// src/gerber/convert-soup-to-gerber-commands/getSilkscreenShapeStroke.ts
+import {
+  applyToPoint,
+  compose,
+  identity,
+  rotate,
+  translate
+} from "transformation-matrix";
+import { getBoundFromCenteredRect as getBoundFromCenteredRect2 } from "@tscircuit/math-utils";
+var SILKSCREEN_SHAPE_TYPES = [
+  "pcb_silkscreen_line",
+  "pcb_silkscreen_rect",
+  "pcb_silkscreen_circle",
+  "pcb_silkscreen_oval",
+  "pcb_silkscreen_pill"
+];
+var isSilkscreenShape = (element) => SILKSCREEN_SHAPE_TYPES.includes(element.type);
+var DEFAULT_STROKE_WIDTH = 0.1;
+var ELLIPSE_SEGMENTS = 48;
+var CORNER_SEGMENTS = 12;
+var rotationAboutCenter = (center, ccwDegrees) => ccwDegrees ? compose(
+  translate(center.x, center.y),
+  rotate(ccwDegrees * Math.PI / 180),
+  translate(-center.x, -center.y)
+) : identity();
+var ellipseRoute = (center, radiusX, radiusY, ccwDegrees = 0) => {
+  const matrix = rotationAboutCenter(center, ccwDegrees);
+  return Array.from({ length: ELLIPSE_SEGMENTS + 1 }, (_, i) => {
+    const angle = i / ELLIPSE_SEGMENTS * Math.PI * 2;
+    return applyToPoint(matrix, {
+      x: center.x + radiusX * Math.cos(angle),
+      y: center.y + radiusY * Math.sin(angle)
+    });
+  });
+};
+var rectangleRoute = (center, width, height, cornerRadius, ccwDegrees = 0) => {
+  const halfW = width / 2;
+  const halfH = height / 2;
+  const route = [];
+  if (cornerRadius <= 0) {
+    const bounds = getBoundFromCenteredRect2({ center, width, height });
+    route.push(
+      { x: bounds.minX, y: bounds.minY },
+      { x: bounds.maxX, y: bounds.minY },
+      { x: bounds.maxX, y: bounds.maxY },
+      { x: bounds.minX, y: bounds.maxY }
+    );
+  } else {
+    const insetW = halfW - cornerRadius;
+    const insetH = halfH - cornerRadius;
+    const corners = [
+      { x: center.x + insetW, y: center.y + insetH, start: 0 },
+      { x: center.x - insetW, y: center.y + insetH, start: Math.PI / 2 },
+      { x: center.x - insetW, y: center.y - insetH, start: Math.PI },
+      { x: center.x + insetW, y: center.y - insetH, start: 3 * Math.PI / 2 }
+    ];
+    for (const corner of corners) {
+      for (let i = 0; i <= CORNER_SEGMENTS; i++) {
+        const angle = corner.start + i / CORNER_SEGMENTS * (Math.PI / 2);
+        route.push({
+          x: corner.x + cornerRadius * Math.cos(angle),
+          y: corner.y + cornerRadius * Math.sin(angle)
+        });
+      }
+    }
+  }
+  route.push(route[0]);
+  const matrix = rotationAboutCenter(center, ccwDegrees);
+  return route.map((point) => applyToPoint(matrix, point));
+};
+var clampCornerRadius = (width, height, cornerRadius) => {
+  if (typeof cornerRadius !== "number" || cornerRadius <= 0) return 0;
+  return Math.min(cornerRadius, width / 2, height / 2);
+};
+var getSilkscreenShapeStroke = (element) => {
+  const strokeWidth = element.stroke_width ?? DEFAULT_STROKE_WIDTH;
+  switch (element.type) {
+    case "pcb_silkscreen_line":
+      return {
+        route: [
+          { x: element.x1, y: element.y1 },
+          { x: element.x2, y: element.y2 }
+        ],
+        strokeWidth
+      };
+    case "pcb_silkscreen_rect":
+      return {
+        route: rectangleRoute(
+          element.center,
+          element.width,
+          element.height,
+          clampCornerRadius(
+            element.width,
+            element.height,
+            element.corner_radius
+          ),
+          element.ccw_rotation ?? 0
+        ),
+        strokeWidth
+      };
+    case "pcb_silkscreen_circle":
+      return {
+        route: ellipseRoute(element.center, element.radius, element.radius),
+        strokeWidth
+      };
+    case "pcb_silkscreen_oval":
+      return {
+        route: ellipseRoute(
+          element.center,
+          element.radius_x,
+          element.radius_y,
+          element.ccw_rotation ?? 0
+        ),
+        strokeWidth
+      };
+    case "pcb_silkscreen_pill":
+      return {
+        route: rectangleRoute(
+          element.center,
+          element.width,
+          element.height,
+          Math.min(element.width, element.height) / 2
+        ),
+        strokeWidth
+      };
+    default:
+      return null;
+  }
+};
+
 // src/gerber/convert-soup-to-gerber-commands/defineAperturesForLayer.ts
 import stableStringify from "fast-json-stable-stringify";
 
@@ -1878,6 +2153,20 @@ function getAllApertureTemplateConfigsForLayer({
     } else if (elm.type === "pcb_silkscreen_path") {
       if (!isFabricationLayer)
         addConfigIfNew(getApertureConfigFromPcbSilkscreenPath(elm));
+    } else if (isSilkscreenShape(elm)) {
+      if (!isFabricationLayer) {
+        addConfigIfNew({
+          standard_template_code: "C",
+          diameter: elm.stroke_width ?? 0.1
+        });
+        if (elm.is_filled === true) {
+          addConfigIfNew(REGION_APERTURE_CONFIG);
+        }
+      }
+    } else if (elm.type === "pcb_silkscreen_graphic") {
+      if (glayer_name.endsWith("_SilkScreen")) {
+        addConfigIfNew(REGION_APERTURE_CONFIG);
+      }
     } else if (elm.type === "pcb_silkscreen_text") {
       if (!isFabricationLayer)
         addConfigIfNew(getApertureConfigFromPcbSilkscreenText(elm));
@@ -1953,7 +2242,7 @@ var findApertureNumber = (glayer, search_params) => {
 // package.json
 var package_default = {
   name: "circuit-json-to-gerber",
-  version: "0.0.80",
+  version: "0.0.82",
   main: "dist/index.js",
   type: "module",
   scripts: {
@@ -1984,6 +2273,7 @@ var package_default = {
     gerberts: "^0.0.3",
     jszip: "^3.10.1",
     "pcb-stackup": "^4.2.8",
+    "polygon-clipping": "^0.15.7",
     react: "^19.2.1",
     "react-dom": "^19.2.1",
     tscircuit: "^0.0.1776",
@@ -2164,11 +2454,11 @@ var offsetPolygonOutline = (points, offset) => {
 // src/gerber/convert-soup-to-gerber-commands/index.ts
 import { lineAlphabet } from "@tscircuit/alphabet";
 import {
-  applyToPoint,
-  compose,
-  identity,
-  rotate,
-  translate
+  applyToPoint as applyToPoint4,
+  compose as compose4,
+  identity as identity3,
+  rotate as rotate4,
+  translate as translate4
 } from "transformation-matrix";
 
 // src/gerber/convert-soup-to-gerber-commands/fabricationLayerRefs.ts
@@ -2182,15 +2472,18 @@ var getFabricationLayerRefs = (circuitJson) => outerLayerRefs.filter(
 );
 
 // src/gerber/convert-soup-to-gerber-commands/getFabRectPoints.ts
+import { getBoundFromCenteredRect as getBoundFromCenteredRect3 } from "@tscircuit/math-utils";
 var getFabRectPoints = (element) => {
-  const halfWidth = element.width / 2;
-  const halfHeight = element.height / 2;
-  const { x, y } = element.center;
+  const bounds = getBoundFromCenteredRect3({
+    center: element.center,
+    width: element.width,
+    height: element.height
+  });
   return [
-    { x: x - halfWidth, y: y - halfHeight },
-    { x: x + halfWidth, y: y - halfHeight },
-    { x: x + halfWidth, y: y + halfHeight },
-    { x: x - halfWidth, y: y + halfHeight }
+    { x: bounds.minX, y: bounds.minY },
+    { x: bounds.maxX, y: bounds.minY },
+    { x: bounds.maxX, y: bounds.maxY },
+    { x: bounds.minX, y: bounds.maxY }
   ];
 };
 
@@ -2340,6 +2633,353 @@ var renderFabricationDimension = ({
 };
 
 // src/gerber/convert-soup-to-gerber-commands/index.ts
+import polygonClipping3 from "polygon-clipping";
+
+// src/gerber/utils/boardCutoutGeometry.ts
+import polygonClipping2 from "polygon-clipping";
+import { applyToPoint as applyToPoint2, compose as compose2, rotate as rotate2, translate as translate2 } from "transformation-matrix";
+import { getBoundFromCenteredRect as getBoundFromCenteredRect4 } from "@tscircuit/math-utils";
+var roundedRectCornerArcSegmentCount = 8;
+var circleCutoutPolygonSegmentCount2 = 64;
+var getBoardOutlinePolygon = (board) => {
+  if (board.outline && board.outline.length > 2) {
+    return [board.outline.map((point) => [point.x, point.y])];
+  }
+  const bounds = getBoundFromCenteredRect4({
+    center: board.center,
+    width: board.width,
+    height: board.height
+  });
+  return [
+    [
+      [bounds.minX, bounds.minY],
+      [bounds.maxX, bounds.minY],
+      [bounds.maxX, bounds.maxY],
+      [bounds.minX, bounds.maxY]
+    ]
+  ];
+};
+var getBoardOutlinePolygons2 = (circuitJson) => circuitJson.filter((element) => element.type === "pcb_board").map(getBoardOutlinePolygon);
+var getRectCutoutOutlinePoints = (cutout) => {
+  const { center, width, height, rotation, corner_radius } = cutout;
+  const w = width / 2;
+  const h = height / 2;
+  const r = Math.max(0, Math.min(corner_radius ?? 0, Math.abs(w), Math.abs(h)));
+  let transformMatrix = translate2(center.x, center.y);
+  if (rotation) {
+    transformMatrix = compose2(
+      transformMatrix,
+      rotate2(rotation * Math.PI / 180)
+    );
+  }
+  if (r === 0) {
+    return [
+      { x: -w, y: h },
+      { x: w, y: h },
+      { x: w, y: -h },
+      { x: -w, y: -h }
+    ].map((point) => applyToPoint2(transformMatrix, point));
+  }
+  const points = [];
+  const corners = [
+    { center: { x: w - r, y: h - r }, start: Math.PI / 2, end: 0 },
+    { center: { x: w - r, y: -h + r }, start: 0, end: -Math.PI / 2 },
+    { center: { x: -w + r, y: -h + r }, start: -Math.PI / 2, end: -Math.PI },
+    { center: { x: -w + r, y: h - r }, start: Math.PI, end: Math.PI / 2 }
+  ];
+  for (const corner of corners) {
+    for (let i = 0; i <= roundedRectCornerArcSegmentCount; i++) {
+      const t = i / roundedRectCornerArcSegmentCount;
+      const angle = corner.start + (corner.end - corner.start) * t;
+      points.push({
+        x: corner.center.x + r * Math.cos(angle),
+        y: corner.center.y + r * Math.sin(angle)
+      });
+    }
+  }
+  return points.map((point) => applyToPoint2(transformMatrix, point));
+};
+var getCircleCutoutOutlinePolygon = (cutout) => {
+  const points = [];
+  for (let i = 0; i < circleCutoutPolygonSegmentCount2; i++) {
+    const angle = i / circleCutoutPolygonSegmentCount2 * Math.PI * 2;
+    points.push([
+      cutout.center.x + cutout.radius * Math.cos(angle),
+      cutout.center.y + cutout.radius * Math.sin(angle)
+    ]);
+  }
+  return [points];
+};
+var getSolidCutoutOutlinePolygon = (cutout) => {
+  if (cutout.shape === "rect") {
+    return [
+      getRectCutoutOutlinePoints(cutout).map((point) => [point.x, point.y])
+    ];
+  }
+  if (cutout.shape === "circle") {
+    return getCircleCutoutOutlinePolygon(cutout);
+  }
+  if (cutout.shape === "polygon") {
+    return [cutout.points.map((point) => [point.x, point.y])];
+  }
+  return null;
+};
+var doesSolidCutoutOverlapBoardEdge = ({
+  cutout,
+  boardOutlinePolygons
+}) => {
+  const cutoutOutlinePolygon = getSolidCutoutOutlinePolygon(cutout);
+  if (!cutoutOutlinePolygon) return false;
+  return boardOutlinePolygons.some((boardOutlinePolygon) => {
+    const overlapsBoard = polygonClipping2.intersection(boardOutlinePolygon, cutoutOutlinePolygon).length > 0;
+    const extendsOutsideBoard = polygonClipping2.difference(cutoutOutlinePolygon, boardOutlinePolygon).length > 0;
+    return overlapsBoard && extendsOutsideBoard;
+  });
+};
+var isCutoutFullyInternal = ({
+  cutout,
+  boardOutlinePolygons
+}) => {
+  const cutoutOutlinePolygon = getSolidCutoutOutlinePolygon(cutout);
+  if (!cutoutOutlinePolygon) return false;
+  return boardOutlinePolygons.some(
+    (boardOutlinePolygon) => (
+      // Has overlap with the board interior …
+      polygonClipping2.intersection(boardOutlinePolygon, cutoutOutlinePolygon).length > 0 && // … but does not extend outside it at all.
+      polygonClipping2.difference(cutoutOutlinePolygon, boardOutlinePolygon).length === 0
+    )
+  );
+};
+
+// src/gerber/utils/emitCutoutEdgeCuts.ts
+import {
+  applyToPoint as applyToPoint3,
+  compose as compose3,
+  identity as identity2,
+  rotate as rotate3,
+  translate as translate3
+} from "transformation-matrix";
+var emitCutoutEdgeCuts = ({
+  cutout,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  if (cutout.shape === "circle") {
+    emitCircle({ cutout, builder, mfy, drawCw });
+  } else if (cutout.shape === "rect") {
+    emitRect({ cutout, builder, mfy, drawCw });
+  } else if (cutout.shape === "polygon") {
+    emitPolygon({ cutout, builder, mfy, drawCw });
+  }
+};
+var emitCircle = ({
+  cutout,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  const { center, radius } = cutout;
+  const p1 = { x: center.x + radius, y: center.y };
+  const p2 = { x: center.x - radius, y: center.y };
+  const isYFlipped = mfy(1) < 0;
+  let isClockwise = drawCw;
+  if (isYFlipped) {
+    isClockwise = !isClockwise;
+  }
+  let arcMode = "set_movement_mode_to_counterclockwise_circular";
+  if (isClockwise) {
+    arcMode = "set_movement_mode_to_clockwise_circular";
+  }
+  builder.add("move_operation", { x: p1.x, y: mfy(p1.y) }).add(arcMode, {}).add("plot_operation", { x: p2.x, y: mfy(p2.y), i: -radius, j: 0 }).add("plot_operation", { x: p1.x, y: mfy(p1.y), i: radius, j: 0 }).add("set_movement_mode_to_linear", {});
+};
+var emitRect = ({
+  cutout,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  const { center, width, height, rotation, corner_radius } = cutout;
+  const w = width / 2;
+  const h = height / 2;
+  let cr = 0;
+  if (corner_radius !== void 0) {
+    cr = corner_radius;
+  }
+  const r = Math.max(0, Math.min(cr, Math.abs(w), Math.abs(h)));
+  let rotationTransform = identity2();
+  if (rotation) {
+    rotationTransform = rotate3(rotation * Math.PI / 180);
+  }
+  const transformMatrix = compose3(
+    translate3(center.x, center.y),
+    rotationTransform
+  );
+  if (r > 0) {
+    emitRoundedRect({ w, h, r, transformMatrix, builder, mfy, drawCw });
+  } else {
+    emitSharpRect({ w, h, transformMatrix, builder, mfy, drawCw });
+  }
+};
+var emitSharpRect = ({
+  w,
+  h,
+  transformMatrix,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  const cwPoints = [
+    { x: -w, y: h },
+    { x: w, y: h },
+    { x: w, y: -h },
+    { x: -w, y: -h }
+  ];
+  const isYFlipped = mfy(1) < 0;
+  let shouldReverse = !drawCw;
+  if (isYFlipped) {
+    shouldReverse = !shouldReverse;
+  }
+  let pts = cwPoints;
+  if (shouldReverse) {
+    pts = [...cwPoints].reverse();
+  }
+  const tpts = pts.map((p) => applyToPoint3(transformMatrix, p));
+  builder.add("move_operation", { x: tpts[0].x, y: mfy(tpts[0].y) });
+  for (let i = 1; i < tpts.length; i++) {
+    builder.add("plot_operation", { x: tpts[i].x, y: mfy(tpts[i].y) });
+  }
+  builder.add("plot_operation", { x: tpts[0].x, y: mfy(tpts[0].y) });
+};
+var emitRoundedRect = ({
+  w,
+  h,
+  r,
+  transformMatrix,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  const isYFlipped = mfy(1) < 0;
+  let isClockwise = drawCw;
+  if (isYFlipped) {
+    isClockwise = !isClockwise;
+  }
+  let arcMode = "set_movement_mode_to_counterclockwise_circular";
+  if (isClockwise) {
+    arcMode = "set_movement_mode_to_clockwise_circular";
+  }
+  let currentPoint;
+  const addLine = (pt) => {
+    const tpt = applyToPoint3(transformMatrix, pt);
+    builder.add("plot_operation", { x: tpt.x, y: mfy(tpt.y) });
+    currentPoint = tpt;
+  };
+  const addArc = (endPt, centerPt) => {
+    const tEnd = applyToPoint3(transformMatrix, endPt);
+    const tCenter = applyToPoint3(transformMatrix, centerPt);
+    builder.add(arcMode, {}).add("plot_operation", {
+      x: tEnd.x,
+      y: mfy(tEnd.y),
+      i: tCenter.x - currentPoint.x,
+      j: mfy(tCenter.y) - mfy(currentPoint.y)
+    }).add("set_movement_mode_to_linear", {});
+    currentPoint = tEnd;
+  };
+  if (isClockwise) {
+    const cwSegments = [
+      {
+        lineTo: { x: w - r, y: h },
+        arcEnd: { x: w, y: h - r },
+        arcCenter: { x: w - r, y: h - r }
+      },
+      {
+        lineTo: { x: w, y: -h + r },
+        arcEnd: { x: w - r, y: -h },
+        arcCenter: { x: w - r, y: -h + r }
+      },
+      {
+        lineTo: { x: -w + r, y: -h },
+        arcEnd: { x: -w, y: -h + r },
+        arcCenter: { x: -w + r, y: -h + r }
+      },
+      {
+        lineTo: { x: -w, y: h - r },
+        arcEnd: { x: -w + r, y: h },
+        arcCenter: { x: -w + r, y: h - r }
+      }
+    ];
+    const startPt = { x: -w + r, y: h };
+    const tStart = applyToPoint3(transformMatrix, startPt);
+    builder.add("move_operation", { x: tStart.x, y: mfy(tStart.y) });
+    currentPoint = tStart;
+    for (const seg of cwSegments) {
+      addLine(seg.lineTo);
+      addArc(seg.arcEnd, seg.arcCenter);
+    }
+  } else {
+    const startPt = { x: w - r, y: h };
+    const tStart = applyToPoint3(transformMatrix, startPt);
+    builder.add("move_operation", { x: tStart.x, y: mfy(tStart.y) });
+    currentPoint = tStart;
+    addLine({ x: -w + r, y: h });
+    addArc({ x: -w, y: h - r }, { x: -w + r, y: h - r });
+    addLine({ x: -w, y: -h + r });
+    addArc({ x: -w + r, y: -h }, { x: -w + r, y: -h + r });
+    addLine({ x: w - r, y: -h });
+    addArc({ x: w, y: -h + r }, { x: w - r, y: -h + r });
+    addLine({ x: w, y: h - r });
+    addArc({ x: w - r, y: h }, { x: w - r, y: h - r });
+  }
+};
+var emitPolygon = ({
+  cutout,
+  builder,
+  mfy,
+  drawCw
+}) => {
+  const points = cutout.points;
+  if (points.length === 0) return;
+  const isYFlipped = mfy(1) < 0;
+  let shouldReverse = !drawCw;
+  if (isYFlipped) {
+    shouldReverse = !shouldReverse;
+  }
+  let ordered = points;
+  if (shouldReverse) {
+    ordered = [...points].reverse();
+  }
+  builder.add("move_operation", { x: ordered[0].x, y: mfy(ordered[0].y) });
+  for (let i = 1; i < ordered.length; i++) {
+    builder.add("plot_operation", { x: ordered[i].x, y: mfy(ordered[i].y) });
+  }
+  builder.add("plot_operation", { x: ordered[0].x, y: mfy(ordered[0].y) });
+};
+
+// src/gerber/convert-soup-to-gerber-commands/index.ts
+var closeRing = (ring) => {
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+  if (!first || !last) return ring;
+  if (first[0] === last[0] && first[1] === last[1]) return ring;
+  return [...ring, first];
+};
+var emitEdgeCutRing = (gerberBuild, ring, mfy) => {
+  const closedRing = closeRing(ring);
+  const firstPoint = closedRing[0];
+  if (!firstPoint || closedRing.length < 4) return;
+  gerberBuild.add("move_operation", {
+    x: firstPoint[0],
+    y: mfy(firstPoint[1])
+  });
+  for (let i = 1; i < closedRing.length; i++) {
+    const point = closedRing[i];
+    gerberBuild.add("plot_operation", {
+      x: point[0],
+      y: mfy(point[1])
+    });
+  }
+};
 var getLayerCount2 = (circuitJson) => {
   const board = circuitJson.find((element) => element.type === "pcb_board");
   const numLayers = board?.num_layers ?? 2;
@@ -2355,6 +2995,7 @@ var getGerberInnerLayerName = (layerRef) => {
 var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
   opts.flip_y_axis ??= false;
   const hasPanel = circuitJson.some((e) => e.type === "pcb_panel");
+  const hasBoard = circuitJson.some((e) => e.type === "pcb_board");
   const layerCount = getLayerCount2(circuitJson);
   const innerLayerRefs = getInnerLayerRefs(layerCount);
   const copperLayerRefs = ["top", ...innerLayerRefs, "bottom"];
@@ -2444,7 +3085,16 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
       //mm
     }).build()
   );
-  const mfy = (y) => opts.flip_y_axis ? -y : y;
+  const mfy = (y) => {
+    if (opts.flip_y_axis) {
+      return -y;
+    }
+    return y;
+  };
+  const boardOutlinePolygons = getBoardOutlinePolygons2(circuitJson);
+  const solidCutoutPolygons = circuitJson.filter((element) => element.type === "pcb_cutout").filter(
+    (cutout) => doesSolidCutoutOverlapBoardEdge({ cutout, boardOutlinePolygons })
+  ).map(getSolidCutoutOutlinePolygon).filter((polygon) => polygon !== null);
   const renderPillFlash = ({
     glayer,
     x,
@@ -2597,18 +3247,18 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
     const shouldMirror = element.is_mirrored !== void 0 ? element.is_mirrored : element.layer === "bottom";
     if (shouldMirror) {
       transforms.push(
-        translate(cx, cy),
+        translate4(cx, cy),
         { a: -1, b: 0, c: 0, d: 1, e: 0, f: 0 },
-        translate(-cx, -cy)
+        translate4(-cx, -cy)
       );
       rotation = -rotation;
     }
     if (rotation) {
       const rad = rotation * Math.PI / 180;
-      transforms.push(translate(cx, cy), rotate(rad), translate(-cx, -cy));
+      transforms.push(translate4(cx, cy), rotate4(rad), translate4(-cx, -cy));
     }
-    const transformMatrix = transforms.length > 0 ? compose(...transforms) : void 0;
-    const applyTransform = (point) => transformMatrix ? applyToPoint(transformMatrix, point) : point;
+    const transformMatrix = transforms.length > 0 ? compose4(...transforms) : void 0;
+    const applyTransform = (point) => transformMatrix ? applyToPoint4(transformMatrix, point) : point;
     if (element.is_knockout) {
       const padding = element.knockout_padding ?? {
         left: 0.2,
@@ -2797,17 +3447,17 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
             { x: -w, y: -h }
             // Bottom-left
           ];
-          let transformMatrix = identity();
+          let transformMatrix = identity3();
           if (rotation) {
             const angle_rad = rotation * Math.PI / 180;
-            transformMatrix = rotate(angle_rad);
+            transformMatrix = rotate4(angle_rad);
           }
-          transformMatrix = compose(
-            translate(center.x, center.y),
+          transformMatrix = compose4(
+            translate4(center.x, center.y),
             transformMatrix
           );
           const transformedPoints = points.map(
-            (p) => applyToPoint(transformMatrix, p)
+            (p) => applyToPoint4(transformMatrix, p)
           );
           const regionApertureNumber = getRegionApertureNumber(copper_glayer);
           const rect_builder = gerberBuilder().add("select_aperture", { aperture_number: regionApertureNumber }).add("start_region_statement", {});
@@ -2931,6 +3581,69 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           }
           glayer.push(...gerber.build());
         }
+      } else if (isSilkscreenShape(element) && isOuterLayerRef(layer)) {
+        if (element.layer === layer) {
+          const stroke = getSilkscreenShapeStroke(element);
+          if (stroke) {
+            const glayer = glayers[getGerberLayerName(layer, "silkscreen")];
+            const isFilled = element.is_filled === true;
+            const isStroked = element.has_stroke !== false;
+            if (isFilled) {
+              addClosedRegionFromPoints({
+                target: glayer,
+                apertureSource: glayer,
+                points: stroke.route
+              });
+            }
+            if (isStroked) {
+              renderOpenPath({
+                element: {
+                  type: element.type,
+                  stroke_width: stroke.strokeWidth,
+                  is_stroke_dashed: element.is_stroke_dashed
+                },
+                glayer,
+                apertureConfig: {
+                  standard_template_code: "C",
+                  diameter: stroke.strokeWidth
+                },
+                route: stroke.route,
+                mapY: mfy
+              });
+            }
+          }
+        }
+      } else if (
+        // pcb_silkscreen_graphic is newer than this repo's pinned circuit-json,
+        // so it isn't in the AnyCircuitElement union yet — match it structurally.
+        element.type === "pcb_silkscreen_graphic" && isOuterLayerRef(layer)
+      ) {
+        const graphic = element;
+        if (graphic.layer === layer && graphic.brep_shape) {
+          const glayer = glayers[getGerberLayerName(layer, "silkscreen")];
+          const { outer_ring, inner_rings } = graphic.brep_shape;
+          const regionApertureNumber = getRegionApertureNumber(glayer);
+          const outerBuilder = gerberBuilder().add("select_aperture", { aperture_number: regionApertureNumber }).add("start_region_statement", {});
+          drawRingToBuilder(outerBuilder, reverseRing(outer_ring));
+          outerBuilder.add("end_region_statement", {});
+          glayer.push(...outerBuilder.build());
+          if (inner_rings && inner_rings.length > 0) {
+            glayer.push(
+              ...gerberBuilder().add("set_layer_polarity", { polarity: "C" }).build()
+            );
+            for (const inner_ring of inner_rings) {
+              const innerBuilder = gerberBuilder().add("select_aperture", {
+                aperture_number: regionApertureNumber
+              }).add("start_region_statement", {});
+              drawRingToBuilder(innerBuilder, inner_ring);
+              innerBuilder.add("end_region_statement", {});
+              glayer.push(...innerBuilder.build());
+            }
+            glayer.push(
+              ...gerberBuilder().add("set_layer_polarity", { polarity: "D" }).build()
+            );
+          }
+        }
       } else if (element.type === "pcb_silkscreen_text" && isOuterLayerRef(layer)) {
         renderVectorText(
           element,
@@ -3300,36 +4013,42 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
           aperture_number: 10
         });
         if (outline && outline.length > 2) {
-          const outlinePoints = outline.map((point) => ({
-            x: point.x,
-            y: mfy(point.y)
-          }));
-          const firstPoint = outlinePoints[0];
-          gerberBuild.add("move_operation", firstPoint);
-          for (let i = 1; i < outlinePoints.length; i++) {
-            gerberBuild.add("plot_operation", outlinePoints[i]);
+          const boardPolygon = [
+            outline.map((point) => [point.x, point.y])
+          ];
+          let boardGeometry = [boardPolygon];
+          if (solidCutoutPolygons.length > 0) {
+            boardGeometry = polygonClipping3.difference(
+              boardPolygon,
+              ...solidCutoutPolygons
+            );
           }
-          const lastPoint = outlinePoints[outlinePoints.length - 1];
-          if (lastPoint.x !== firstPoint.x || lastPoint.y !== firstPoint.y) {
-            gerberBuild.add("plot_operation", firstPoint);
+          for (const polygon of boardGeometry) {
+            for (const ring of polygon) {
+              emitEdgeCutRing(gerberBuild, ring, mfy);
+            }
           }
         } else {
-          gerberBuild.add("move_operation", {
-            x: center.x - width / 2,
-            y: mfy(center.y - height / 2)
-          }).add("plot_operation", {
-            x: center.x + width / 2,
-            y: mfy(center.y - height / 2)
-          }).add("plot_operation", {
-            x: center.x + width / 2,
-            y: mfy(center.y + height / 2)
-          }).add("plot_operation", {
-            x: center.x - width / 2,
-            y: mfy(center.y + height / 2)
-          }).add("plot_operation", {
-            x: center.x - width / 2,
-            y: mfy(center.y - height / 2)
-          });
+          const boardPolygon = [
+            [
+              [center.x - width / 2, center.y - height / 2],
+              [center.x + width / 2, center.y - height / 2],
+              [center.x + width / 2, center.y + height / 2],
+              [center.x - width / 2, center.y + height / 2]
+            ]
+          ];
+          let boardGeometry = [boardPolygon];
+          if (solidCutoutPolygons.length > 0) {
+            boardGeometry = polygonClipping3.difference(
+              boardPolygon,
+              ...solidCutoutPolygons
+            );
+          }
+          for (const polygon of boardGeometry) {
+            for (const ring of polygon) {
+              emitEdgeCutRing(gerberBuild, ring, mfy);
+            }
+          }
         }
         glayer.push(...gerberBuild.build());
       } else if (element.type === "pcb_panel" && layer === "edgecut") {
@@ -3357,146 +4076,26 @@ var convertSoupToGerberCommands = (circuitJson, opts = {}) => {
         glayer.push(...gerberBuild.build());
       } else if (element.type === "pcb_cutout") {
         if (layer === "edgecut") {
+          if (hasBoard && !hasPanel && doesSolidCutoutOverlapBoardEdge({
+            cutout: element,
+            boardOutlinePolygons
+          })) {
+            continue;
+          }
           const ec_layer = glayers.Edge_Cuts;
           const cutout_builder = gerberBuilder().add("select_aperture", {
             aperture_number: 10
           });
-          const el = element;
-          if (el.shape === "rect") {
-            const { center, width, height, rotation, corner_radius } = el;
-            const w = width / 2;
-            const h = height / 2;
-            const r = Math.max(
-              0,
-              Math.min(corner_radius ?? 0, Math.abs(w), Math.abs(h))
-            );
-            const makeTransformMatrix = () => {
-              let transformMatrix2 = identity();
-              if (rotation) {
-                const angle_rad = rotation * Math.PI / 180;
-                transformMatrix2 = rotate(angle_rad);
-              }
-              return compose(translate(center.x, center.y), transformMatrix2);
-            };
-            const transformMatrix = makeTransformMatrix();
-            if (r > 0) {
-              const startPoint = { x: -w + r, y: h };
-              let currentPoint = applyToPoint(transformMatrix, startPoint);
-              cutout_builder.add("move_operation", {
-                x: currentPoint.x,
-                y: mfy(currentPoint.y)
-              });
-              const addLine = (point) => {
-                const transformedPoint = applyToPoint(transformMatrix, point);
-                cutout_builder.add("plot_operation", {
-                  x: transformedPoint.x,
-                  y: mfy(transformedPoint.y)
-                });
-                currentPoint = transformedPoint;
-              };
-              const addArc = (options) => {
-                const transformedPoint = applyToPoint(
-                  transformMatrix,
-                  options.point
-                );
-                const transformedCenter = applyToPoint(
-                  transformMatrix,
-                  options.center
-                );
-                cutout_builder.add("set_movement_mode_to_clockwise_circular", {}).add("plot_operation", {
-                  x: transformedPoint.x,
-                  y: mfy(transformedPoint.y),
-                  i: transformedCenter.x - currentPoint.x,
-                  j: mfy(transformedCenter.y) - mfy(currentPoint.y)
-                }).add("set_movement_mode_to_linear", {});
-                currentPoint = transformedPoint;
-              };
-              addLine({ x: w - r, y: h });
-              addArc({
-                point: { x: w, y: h - r },
-                center: { x: w - r, y: h - r }
-              });
-              addLine({ x: w, y: -h + r });
-              addArc({
-                point: { x: w - r, y: -h },
-                center: { x: w - r, y: -h + r }
-              });
-              addLine({ x: -w + r, y: -h });
-              addArc({
-                point: { x: -w, y: -h + r },
-                center: { x: -w + r, y: -h + r }
-              });
-              addLine({ x: -w, y: h - r });
-              addArc({
-                point: { x: -w + r, y: h },
-                center: { x: -w + r, y: h - r }
-              });
-            } else {
-              const points = [
-                { x: -w, y: h },
-                // Top-left
-                { x: w, y: h },
-                // Top-right
-                { x: w, y: -h },
-                // Bottom-right
-                { x: -w, y: -h }
-                // Bottom-left
-              ];
-              const transformedPoints = points.map(
-                (p) => applyToPoint(transformMatrix, p)
-              );
-              cutout_builder.add("move_operation", {
-                x: transformedPoints[0].x,
-                y: mfy(transformedPoints[0].y)
-              });
-              for (let i = 1; i < transformedPoints.length; i++) {
-                cutout_builder.add("plot_operation", {
-                  x: transformedPoints[i].x,
-                  y: mfy(transformedPoints[i].y)
-                });
-              }
-              cutout_builder.add("plot_operation", {
-                x: transformedPoints[0].x,
-                y: mfy(transformedPoints[0].y)
-              });
-            }
-          } else if (el.shape === "circle") {
-            const { center, radius } = el;
-            const p1 = { x: center.x + radius, y: center.y };
-            const p2 = { x: center.x - radius, y: center.y };
-            cutout_builder.add("move_operation", {
-              x: p1.x,
-              y: mfy(p1.y)
-            }).add("set_movement_mode_to_counterclockwise_circular", {}).add("plot_operation", {
-              x: p2.x,
-              y: mfy(p2.y),
-              i: -radius,
-              j: 0
-            }).add("plot_operation", {
-              x: p1.x,
-              y: mfy(p1.y),
-              i: radius,
-              j: 0
-            }).add("set_movement_mode_to_linear", {});
-          } else if (el.shape === "polygon") {
-            const { points } = el;
-            if (points.length > 0) {
-              cutout_builder.add("move_operation", {
-                x: points[0].x,
-                y: mfy(points[0].y)
-              });
-              for (let i = 1; i < points.length; i++) {
-                cutout_builder.add("plot_operation", {
-                  x: points[i].x,
-                  y: mfy(points[i].y)
-                });
-              }
-              cutout_builder.add("plot_operation", {
-                x: points[0].x,
-                y: mfy(points[0].y)
-              });
-            }
-          }
+          const drawCw = hasBoard && !hasPanel && isCutoutFullyInternal({
+            cutout: element,
+            boardOutlinePolygons
+          });
+          emitCutoutEdgeCuts({
+            cutout: element,
+            builder: cutout_builder,
+            mfy,
+            drawCw
+          });
           ec_layer.push(...cutout_builder.build());
         }
       }
@@ -3521,4 +4120,4 @@ export {
   stringifyGerberCommands,
   convertSoupToGerberCommands
 };
-//# sourceMappingURL=chunk-LJRHQISL.js.map
+//# sourceMappingURL=chunk-46NSLLUV.js.map