circuit-json-to-lbrn 0.0.84 → 0.0.85

package/README.md

@@ -43,6 +43,8 @@ const defaultLbrn = convertCircuitJsonToLbrn(circuitJson)
 - `includeLayers?: Array<"top" | "bottom">` - Specify which layers to include (default: `["top", "bottom"]`)
 - `mirrorBottomLayer?: boolean` - Mirror bottom layer across the board X-center for flipped-board cutting (default: `false`)
 - `includeHolePunch?: boolean` - Include "Hole Punch Top" / "Hole Punch Bottom" layers that mark hole centers for drilling (default: `true`)
+- `includeSoldermaskAblation?: boolean` - Include a top-layer scan outline around all copper for soldermask ablation (default: `false`)
+- `soldermaskAblationClearance?: number` - Clearance from copper to the soldermask ablation outline in mm (default: `1`)
 - `toolingLayerIncludeRefs?: string[]` - Copy the PCB copper lands for component selectors such as `".U1"` or `".TP1"` to LightBurn's native, non-output T1 tooling layer (default: `[]`)
 
 ## Soldermask Support

package/dist/index.d.ts

@@ -11,6 +11,10 @@ interface ConvertCircuitJsonToLbrnOptions {
     includeCopper?: boolean;
     includeSoldermask?: boolean;
     includeSoldermaskCure?: boolean;
+    /** Generate a top-layer outer contour around copper for soldermask ablation. */
+    includeSoldermaskAblation?: boolean;
+    /** Clearance between copper and the soldermask ablation outline, in mm. Defaults to 1. */
+    soldermaskAblationClearance?: number;
     globalCopperSoldermaskMarginAdjustment?: number;
     solderMaskMarginPercent?: number;
     includeLayers?: Array<"top" | "bottom">;

package/dist/index.js

@@ -26,6 +26,7 @@ var LAYER_INDEXES = {
   reflectedBottomBoardCut: 13,
   topHolePunch: 14,
   bottomHolePunch: 15,
+  topSoldermaskAblation: 16,
   // Native LightBurn non-output tool layers
   tool1: 30
 };
@@ -116,6 +117,9 @@ var calculateOriginFromBounds = (bounds, margin) => {
   return { x: originX, y: originY };
 };
 
+// lib/create-soldermask-ablation-outline.ts
+import { ShapeGroup as ShapeGroup2 } from "lbrnts";
+
 // lib/createCopperCutFillForLayer.ts
 import { Box, Point, Polygon } from "@flatten-js/core";
 import { ShapeGroup } from "lbrnts";
@@ -338,6 +342,76 @@ var createCopperCutFillForLayer = async ({
   }
 };
 
+// lib/create-soldermask-ablation-outline.ts
+var createSoldermaskAblationOutline = async (ctx) => {
+  const {
+    boardOutlineContour,
+    clipCopperCutFillToBoardOutline,
+    project,
+    soldermaskAblationClearance,
+    topCutNetGeoms,
+    topSoldermaskAblationCutSetting
+  } = ctx;
+  if (!topSoldermaskAblationCutSetting) return;
+  const copperContours = [];
+  for (const netGeometries of topCutNetGeoms.values()) {
+    for (const geometry of netGeometries) {
+      copperContours.push(
+        ...polygonToContours(geometry).map(normalizeContourToCcw)
+      );
+    }
+  }
+  if (copperContours.length === 0) return;
+  try {
+    const { CrossSection } = await getManifold();
+    const copperArea = new CrossSection(copperContours, "NonZero");
+    const expandedCopperArea = copperArea.offset(
+      soldermaskAblationClearance,
+      "Round",
+      2,
+      32
+    );
+    let outlineArea = expandedCopperArea;
+    if (clipCopperCutFillToBoardOutline && boardOutlineContour && boardOutlineContour.length >= 3) {
+      const boardArea = new CrossSection(
+        [normalizeContourToCcw(boardOutlineContour)],
+        "NonZero"
+      );
+      outlineArea = expandedCopperArea.intersect(boardArea);
+      expandedCopperArea.delete();
+      boardArea.delete();
+    }
+    const simplifiedOutline = outlineArea.simplify(1e-3);
+    const outerContours = simplifiedOutline.toPolygons().filter((contour) => signedArea(contour) > 0);
+    const outlineGroup = new ShapeGroup2();
+    for (const contour of outerContours) {
+      const polygon = contourToPolygon(contour);
+      if (!polygon) continue;
+      for (const island of polygon.splitToIslands()) {
+        const pathData = polygonToShapePathData(island);
+        if (pathData.verts.length === 0) continue;
+        outlineGroup.children.push(
+          createLayerShapePath({
+            cutIndex: topSoldermaskAblationCutSetting.index,
+            pathData,
+            layer: "top",
+            isClosed: true,
+            ctx
+          })
+        );
+      }
+    }
+    if (outlineGroup.children.length > 0) {
+      project.children.push(outlineGroup);
+    }
+    copperArea.delete();
+    outlineArea.delete();
+    simplifiedOutline.delete();
+  } catch (error) {
+    console.warn("Failed to create top soldermask ablation outline:", error);
+  }
+};
+
 // lib/createCopperShapesForLayer.ts
 import { Box as Box2, Point as Point2, Polygon as Polygon2 } from "@flatten-js/core";
 var signedArea2 = (contour) => {
@@ -708,7 +782,7 @@ var createOxidationCleaningLayerForLayer = async ({
 
 // lib/createSoldermaskCureLayer.ts
 import { Point as Point3, Polygon as Polygon3 } from "@flatten-js/core";
-import { ShapeGroup as ShapeGroup2, ShapePath as ShapePath3 } from "lbrnts";
+import { ShapeGroup as ShapeGroup3, ShapePath as ShapePath3 } from "lbrnts";
 var contourToPolygon3 = (contour) => {
   if (contour.length < 3) return null;
   const points = contour.map(([x, y]) => new Point3(x, y));
@@ -748,7 +822,7 @@ var collectSoldermaskContours = (project, soldermaskCutIndex) => {
       }
       continue;
     }
-    if (child instanceof ShapeGroup2) {
+    if (child instanceof ShapeGroup3) {
       for (const groupChild of child.children) {
         if (groupChild instanceof ShapePath3) {
           if (groupChild.cutIndex !== soldermaskCutIndex) {
@@ -800,7 +874,7 @@ var createSoldermaskCureLayerForLayer = async ({
       simplifiedArea.delete();
       return;
     }
-    const shapeGroup = new ShapeGroup2();
+    const shapeGroup = new ShapeGroup3();
     for (const contour of resultContours) {
       const polygon = contourToPolygon3(contour);
       if (!polygon) continue;
@@ -3306,6 +3380,8 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
   const includeCopper = options.includeCopper ?? true;
   const includeSoldermask = options.includeSoldermask ?? false;
   const includeSoldermaskCure = options.includeSoldermaskCure ?? false;
+  const includeSoldermaskAblation = options.includeSoldermaskAblation ?? false;
+  const soldermaskAblationClearance = options.soldermaskAblationClearance ?? 1;
   const includeHolePunch = options.includeHolePunch ?? true;
   const shouldIncludeSoldermaskCure = includeSoldermask && includeSoldermaskCure;
   const globalCopperSoldermaskMarginAdjustment = options.globalCopperSoldermaskMarginAdjustment ?? 0;
@@ -3342,6 +3418,9 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
   if (traceMargin > 0 && !includeCopper) {
     throw new Error("traceMargin requires includeCopper to be true");
   }
+  if (soldermaskAblationClearance < 0) {
+    throw new Error("soldermaskAblationClearance must not be negative");
+  }
   const topCopperCutSetting = new CutSetting2({
     index: LAYER_INDEXES.topCopper,
     name: "Cut Top Copper",
@@ -3552,6 +3631,24 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
       project.children.push(bottomCopperCutFillCutSetting);
     }
   }
+  let topSoldermaskAblationCutSetting;
+  if (includeSoldermaskAblation && includeCopper && includeLayers.includes("top")) {
+    topSoldermaskAblationCutSetting = new CutSetting2({
+      type: "Scan",
+      index: LAYER_INDEXES.topSoldermaskAblation,
+      name: "Top Soldermask Ablation",
+      numPasses: 5,
+      speed: 7e3,
+      frequency: 4e4,
+      scanOpt: "mergeAll",
+      interval: 0.1,
+      qPulseWidth: 1,
+      crossHatch: true,
+      wobbleEnable: true,
+      anglePerPass: 1
+    });
+    project.children.push(topSoldermaskAblationCutSetting);
+  }
   let topOxidationCleaningCutSetting;
   let bottomOxidationCleaningCutSetting;
   if (includeOxidationCleaningLayer) {
@@ -3600,6 +3697,7 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
     topSoldermaskCureCutSetting,
     bottomSoldermaskCureCutSetting,
     reflectedBottomBoardCutSetting,
+    topSoldermaskAblationCutSetting,
     tool1CutSetting,
     connMap,
     topCutNetGeoms: /* @__PURE__ */ new Map(),
@@ -3621,6 +3719,7 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
     bottomCopperCutFillCutSetting,
     copperCutFillMargin,
     clipCopperCutFillToBoardOutline,
+    soldermaskAblationClearance,
     topOxidationCleaningCutSetting,
     bottomOxidationCleaningCutSetting,
     topTraceEndpoints: /* @__PURE__ */ new Set(),
@@ -3728,6 +3827,9 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
       await createCopperCutFillForLayer({ layer: "bottom", ctx });
     }
   }
+  if (includeSoldermaskAblation && includeCopper && includeLayers.includes("top")) {
+    await createSoldermaskAblationOutline(ctx);
+  }
   if (includeOxidationCleaningLayer) {
     if (includeLayers.includes("top")) {
       await createOxidationCleaningLayerForLayer({ layer: "top", ctx });

package/lib/ConvertContext.ts

@@ -24,6 +24,7 @@ export interface ConvertContext {
   topSoldermaskCureCutSetting?: CutSetting
   bottomSoldermaskCureCutSetting?: CutSetting
   reflectedBottomBoardCutSetting?: CutSetting
+  topSoldermaskAblationCutSetting?: CutSetting
   tool1CutSetting?: CutSetting
 
   connMap: ConnectivityMap
@@ -73,6 +74,7 @@ export interface ConvertContext {
   // Copper cut fill margin (how far to expand the copper outline for the cut fill band)
   copperCutFillMargin: number
   clipCopperCutFillToBoardOutline: boolean
+  soldermaskAblationClearance: number
 
   // Track trace endpoint positions to avoid duplicate circles
   // Key is "x,y" rounded to 6 decimal places

package/lib/create-soldermask-ablation-outline.ts

@@ -0,0 +1,99 @@
+import { ShapeGroup } from "lbrnts"
+import type { ConvertContext } from "./ConvertContext"
+import {
+  type Contour,
+  contourToPolygon,
+  normalizeContourToCcw,
+  polygonToContours,
+  signedArea,
+} from "./createCopperCutFillForLayer"
+import { getManifold } from "./getManifold"
+import { createLayerShapePath } from "./helpers/createLayerShapePath"
+import { polygonToShapePathData } from "./polygon-to-shape-path"
+
+export const createSoldermaskAblationOutline = async (
+  ctx: ConvertContext,
+): Promise<void> => {
+  const {
+    boardOutlineContour,
+    clipCopperCutFillToBoardOutline,
+    project,
+    soldermaskAblationClearance,
+    topCutNetGeoms,
+    topSoldermaskAblationCutSetting,
+  } = ctx
+
+  if (!topSoldermaskAblationCutSetting) return
+
+  const copperContours: Contour[] = []
+  for (const netGeometries of topCutNetGeoms.values()) {
+    for (const geometry of netGeometries) {
+      copperContours.push(
+        ...polygonToContours(geometry).map(normalizeContourToCcw),
+      )
+    }
+  }
+  if (copperContours.length === 0) return
+
+  try {
+    const { CrossSection } = await getManifold()
+    const copperArea = new CrossSection(copperContours, "NonZero")
+    const expandedCopperArea = copperArea.offset(
+      soldermaskAblationClearance,
+      "Round",
+      2,
+      32,
+    )
+    let outlineArea = expandedCopperArea
+
+    if (
+      clipCopperCutFillToBoardOutline &&
+      boardOutlineContour &&
+      boardOutlineContour.length >= 3
+    ) {
+      const boardArea = new CrossSection(
+        [normalizeContourToCcw(boardOutlineContour)],
+        "NonZero",
+      )
+      outlineArea = expandedCopperArea.intersect(boardArea)
+      expandedCopperArea.delete()
+      boardArea.delete()
+    }
+
+    const simplifiedOutline = outlineArea.simplify(0.001)
+    const outerContours = simplifiedOutline
+      .toPolygons()
+      .filter((contour: Contour) => signedArea(contour) > 0)
+    const outlineGroup = new ShapeGroup()
+
+    for (const contour of outerContours) {
+      const polygon = contourToPolygon(contour)
+      if (!polygon) continue
+
+      for (const island of polygon.splitToIslands()) {
+        const pathData = polygonToShapePathData(island)
+        if (pathData.verts.length === 0) continue
+
+        outlineGroup.children.push(
+          createLayerShapePath({
+            cutIndex: topSoldermaskAblationCutSetting.index,
+            pathData,
+            layer: "top",
+            isClosed: true,
+            ctx,
+          }),
+        )
+      }
+    }
+
+    if (outlineGroup.children.length > 0) {
+      project.children.push(outlineGroup)
+    }
+
+    copperArea.delete()
+    outlineArea.delete()
+    simplifiedOutline.delete()
+  } catch (error) {
+    console.warn("Failed to create top soldermask ablation outline:", error)
+  }
+}

package/lib/createCopperCutFillForLayer.ts

@@ -5,9 +5,9 @@ import { getManifold } from "./getManifold"
 import { createLayerShapePath } from "./helpers/createLayerShapePath"
 import { polygonToShapePathData } from "./polygon-to-shape-path"
 
-type Contour = Array<[number, number]>
+export type Contour = Array<[number, number]>
 
-const signedArea = (contour: Contour): number => {
+export const signedArea = (contour: Contour): number => {
   let area = 0
   for (let i = 0; i < contour.length; i++) {
     const [x1, y1] = contour[i]!
@@ -17,7 +17,7 @@ const signedArea = (contour: Contour): number => {
   return area / 2
 }
 
-const normalizeContourToCcw = (contour: Contour): Contour =>
+export const normalizeContourToCcw = (contour: Contour): Contour =>
   contour.length >= 3 && signedArea(contour) < 0
     ? [...contour].reverse()
     : contour
@@ -26,7 +26,7 @@ const normalizeContourToCcw = (contour: Contour): Contour =>
  * Converts a flatten-js Polygon to an array of contours for manifold CrossSection
  * Each contour is an array of [x, y] coordinates
  */
-const polygonToContours = (polygon: Polygon | Box): Contour[] => {
+export const polygonToContours = (polygon: Polygon | Box): Contour[] => {
   const contours: Contour[] = []
 
   if (polygon instanceof Box) {
@@ -57,7 +57,7 @@ const polygonToContours = (polygon: Polygon | Box): Contour[] => {
 /**
  * Converts a single contour to a flatten-js Polygon
  */
-const contourToPolygon = (contour: Contour): Polygon | null => {
+export const contourToPolygon = (contour: Contour): Polygon | null => {
   if (contour.length < 3) return null
 
   const points = contour.map(([x, y]) => new Point(x, y))

package/lib/index.ts

@@ -8,6 +8,7 @@ import {
   calculateCircuitBounds,
   calculateOriginFromBounds,
 } from "./calculateBounds"
+import { createSoldermaskAblationOutline } from "./create-soldermask-ablation-outline"
 import { createCopperCutFillForLayer } from "./createCopperCutFillForLayer"
 import { createCopperShapesForLayer } from "./createCopperShapesForLayer"
 import { createHolePunchLayers } from "./createHolePunchLayers"
@@ -34,6 +35,10 @@ export interface ConvertCircuitJsonToLbrnOptions {
   includeCopper?: boolean
   includeSoldermask?: boolean
   includeSoldermaskCure?: boolean
+  /** Generate a top-layer outer contour around copper for soldermask ablation. */
+  includeSoldermaskAblation?: boolean
+  /** Clearance between copper and the soldermask ablation outline, in mm. Defaults to 1. */
+  soldermaskAblationClearance?: number
   globalCopperSoldermaskMarginAdjustment?: number
   solderMaskMarginPercent?: number
   includeLayers?: Array<"top" | "bottom">
@@ -102,6 +107,8 @@ export const convertCircuitJsonToLbrn = async (
   const includeCopper = options.includeCopper ?? true
   const includeSoldermask = options.includeSoldermask ?? false
   const includeSoldermaskCure = options.includeSoldermaskCure ?? false
+  const includeSoldermaskAblation = options.includeSoldermaskAblation ?? false
+  const soldermaskAblationClearance = options.soldermaskAblationClearance ?? 1
   const includeHolePunch = options.includeHolePunch ?? true
   const shouldIncludeSoldermaskCure = includeSoldermask && includeSoldermaskCure
   const globalCopperSoldermaskMarginAdjustment =
@@ -153,6 +160,9 @@ export const convertCircuitJsonToLbrn = async (
   if (traceMargin > 0 && !includeCopper) {
     throw new Error("traceMargin requires includeCopper to be true")
   }
+  if (soldermaskAblationClearance < 0) {
+    throw new Error("soldermaskAblationClearance must not be negative")
+  }
 
   // Create cut settings
   const topCopperCutSetting = new CutSetting({
@@ -385,6 +395,29 @@ export const convertCircuitJsonToLbrn = async (
     }
   }
 
+  let topSoldermaskAblationCutSetting: CutSetting | undefined
+  if (
+    includeSoldermaskAblation &&
+    includeCopper &&
+    includeLayers.includes("top")
+  ) {
+    topSoldermaskAblationCutSetting = new CutSetting({
+      type: "Scan",
+      index: LAYER_INDEXES.topSoldermaskAblation,
+      name: "Top Soldermask Ablation",
+      numPasses: 5,
+      speed: 7000,
+      frequency: 40000,
+      scanOpt: "mergeAll",
+      interval: 0.1,
+      qPulseWidth: 1,
+      crossHatch: true,
+      wobbleEnable: true,
+      anglePerPass: 1,
+    })
+    project.children.push(topSoldermaskAblationCutSetting)
+  }
+
   // Create oxidation cleaning layer cut settings if needed
   let topOxidationCleaningCutSetting: CutSetting | undefined
   let bottomOxidationCleaningCutSetting: CutSetting | undefined
@@ -441,6 +474,7 @@ export const convertCircuitJsonToLbrn = async (
     topSoldermaskCureCutSetting,
     bottomSoldermaskCureCutSetting,
     reflectedBottomBoardCutSetting,
+    topSoldermaskAblationCutSetting,
     tool1CutSetting,
     connMap,
     topCutNetGeoms: new Map(),
@@ -462,6 +496,7 @@ export const convertCircuitJsonToLbrn = async (
     bottomCopperCutFillCutSetting,
     copperCutFillMargin,
     clipCopperCutFillToBoardOutline,
+    soldermaskAblationClearance,
     topOxidationCleaningCutSetting,
     bottomOxidationCleaningCutSetting,
     topTraceEndpoints: new Set(),
@@ -605,6 +640,14 @@ export const convertCircuitJsonToLbrn = async (
     }
   }
 
+  if (
+    includeSoldermaskAblation &&
+    includeCopper &&
+    includeLayers.includes("top")
+  ) {
+    await createSoldermaskAblationOutline(ctx)
+  }
+
   // Create oxidation cleaning layer for each layer
   if (includeOxidationCleaningLayer) {
     if (includeLayers.includes("top")) {

package/lib/layer-indexes.ts

@@ -23,6 +23,7 @@ export const LAYER_INDEXES = {
   reflectedBottomBoardCut: 13,
   topHolePunch: 14,
   bottomHolePunch: 15,
+  topSoldermaskAblation: 16,
 
   // Native LightBurn non-output tool layers
   tool1: 30,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "circuit-json-to-lbrn",
   "main": "dist/index.js",
-  "version": "0.0.84",
+  "version": "0.0.85",
   "type": "module",
   "scripts": {
     "start": "bun run site/index.html",
@@ -30,7 +30,7 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "lbrnts": "^0.0.19",
+    "lbrnts": "^0.0.22",
     "manifold-3d": "^3.3.2"
   }
 }

package/tests/basics/soldermask-ablation.test.ts

@@ -0,0 +1,111 @@
+import { expect, test } from "bun:test"
+import type { CircuitJson } from "circuit-json"
+import { CutSetting } from "lbrnts"
+import { convertCircuitJsonToLbrn } from "../../lib"
+import { LAYER_INDEXES } from "../../lib/layer-indexes"
+import circuitJson from "../examples/example05/example05.circuit.json" with {
+  type: "json",
+}
+
+type ProjectNode = {
+  children?: ProjectNode[]
+  cutIndex?: number
+  index?: number
+  name?: string
+  type?: string
+  verts?: Array<{ x: number; y: number }>
+}
+
+const flattenProject = (nodes: ProjectNode[]): ProjectNode[] =>
+  nodes.flatMap((node) => [node, ...flattenProject(node.children ?? [])])
+
+const getBounds = (nodes: ProjectNode[]) => {
+  const vertices = nodes.flatMap((node) => node.verts ?? [])
+  return {
+    minX: Math.min(...vertices.map((vertex) => vertex.x)),
+    maxX: Math.max(...vertices.map((vertex) => vertex.x)),
+    minY: Math.min(...vertices.map((vertex) => vertex.y)),
+    maxY: Math.max(...vertices.map((vertex) => vertex.y)),
+  }
+}
+
+test("creates a 1mm top soldermask ablation outer outline", async () => {
+  const project = await convertCircuitJsonToLbrn(circuitJson as CircuitJson, {
+    includeLayers: ["top"],
+    includeCopper: true,
+    includeSoldermaskAblation: true,
+    soldermaskAblationClearance: 1,
+    origin: { x: 0, y: 0 },
+  })
+  const projectNodes = flattenProject(project.children as ProjectNode[])
+
+  expect(
+    projectNodes.find(
+      (node) => node.index === LAYER_INDEXES.topSoldermaskAblation,
+    ),
+  ).toMatchObject({
+    name: "Top Soldermask Ablation",
+    type: "Scan",
+  })
+
+  const copperShapes = projectNodes.filter(
+    (node) => node.cutIndex === LAYER_INDEXES.topCopper,
+  )
+  const ablationOutlineShapes = projectNodes.filter(
+    (node) => node.cutIndex === LAYER_INDEXES.topSoldermaskAblation,
+  )
+
+  expect(ablationOutlineShapes).toHaveLength(1)
+
+  const copperBounds = getBounds(copperShapes)
+  const outlineBounds = getBounds(ablationOutlineShapes)
+  expect(copperBounds.minX - outlineBounds.minX).toBeCloseTo(1, 1)
+  expect(outlineBounds.maxX - copperBounds.maxX).toBeCloseTo(1, 1)
+  expect(copperBounds.minY - outlineBounds.minY).toBeCloseTo(1, 1)
+  expect(outlineBounds.maxY - copperBounds.maxY).toBeCloseTo(1, 1)
+})
+
+test("uses the production soldermask ablation scan settings", async () => {
+  const project = await convertCircuitJsonToLbrn(circuitJson as CircuitJson, {
+    includeLayers: ["top"],
+    includeCopper: true,
+    includeSoldermaskAblation: true,
+  })
+  const soldermaskAblation = project.children.find(
+    (child): child is CutSetting =>
+      child instanceof CutSetting &&
+      child.index === LAYER_INDEXES.topSoldermaskAblation,
+  )
+
+  expect(soldermaskAblation).toMatchObject({
+    type: "Scan",
+    speed: 7000,
+    frequency: 40000,
+    qPulseWidth: 1,
+    interval: 0.1,
+    numPasses: 5,
+    scanOpt: "mergeAll",
+    crossHatch: true,
+    wobbleEnable: true,
+    anglePerPass: 1,
+  })
+
+  const xml = project.getString()
+  const soldermaskAblationXml = xml.match(
+    /<CutSetting type="Scan">\s*<index Value="16"\/>[\s\S]*?<\/CutSetting>/,
+  )?.[0]
+
+  expect(soldermaskAblationXml).toContain('<scanOpt Value="mergeAll"/>')
+  expect(soldermaskAblationXml).toContain('<crossHatch Value="1"/>')
+  expect(soldermaskAblationXml).toContain('<wobbleEnable Value="1"/>')
+  expect(soldermaskAblationXml).toContain('<anglePerPass Value="1"/>')
+})
+
+test("rejects a negative soldermask ablation clearance", async () => {
+  await expect(
+    convertCircuitJsonToLbrn(circuitJson as CircuitJson, {
+      includeSoldermaskAblation: true,
+      soldermaskAblationClearance: -1,
+    }),
+  ).rejects.toThrow("soldermaskAblationClearance must not be negative")
+})