circuit-json-to-lbrn 0.0.42 → 0.0.43

package/dist/index.d.ts

@@ -15,6 +15,17 @@ interface ConvertCircuitJsonToLbrnOptions {
     includeLayers?: Array<"top" | "bottom">;
     traceMargin?: number;
     laserSpotSize?: number;
+    /**
+     * Whether to generate copper cut fill layers.
+     * Creates a ring/band around traces and pads that will be laser cut
+     * to remove copper, without cutting into the traces or pads themselves.
+     */
+    includeCopperCutFill?: boolean;
+    /**
+     * Margin to expand the copper outline for the cut fill band (in mm).
+     * This determines how wide the band of copper removal will be around traces/pads.
+     */
+    copperCutFillMargin?: number;
     laserProfile?: {
         copper?: {
             speed?: number;
@@ -30,6 +41,6 @@ interface ConvertCircuitJsonToLbrnOptions {
         };
     };
 }
-declare const convertCircuitJsonToLbrn: (circuitJson: CircuitJson, options?: ConvertCircuitJsonToLbrnOptions) => LightBurnProject;
+declare const convertCircuitJsonToLbrn: (circuitJson: CircuitJson, options?: ConvertCircuitJsonToLbrnOptions) => Promise<LightBurnProject>;
 
 export { type ConvertCircuitJsonToLbrnOptions, convertCircuitJsonToLbrn };

package/dist/index.js

@@ -2481,8 +2481,149 @@ var createTraceClearanceAreasForLayer = ({
   }
 };
 
+// lib/createCopperCutFillForLayer.ts
+import { Polygon as Polygon5, Box as Box4, Point as Point2 } from "@flatten-js/core";
+import { ShapePath as ShapePath28, ShapeGroup } from "lbrnts";
+var manifoldInstance = null;
+var getManifold = async () => {
+  if (!manifoldInstance) {
+    const moduleName = "manifold-3d";
+    const ManifoldModule = (await import(
+      /* @vite-ignore */
+      moduleName
+    )).default;
+    manifoldInstance = await ManifoldModule();
+    manifoldInstance.setup();
+  }
+  return manifoldInstance;
+};
+var polygonToContours = (polygon) => {
+  const contours = [];
+  if (polygon instanceof Box4) {
+    const { xmin, ymin, xmax, ymax } = polygon;
+    contours.push([
+      [xmin, ymin],
+      [xmax, ymin],
+      [xmax, ymax],
+      [xmin, ymax]
+    ]);
+  } else {
+    for (const face of polygon.faces) {
+      const contour = [];
+      for (const edge of face) {
+        contour.push([edge.start.x, edge.start.y]);
+      }
+      if (contour.length >= 3) {
+        contours.push(contour);
+      }
+    }
+  }
+  return contours;
+};
+var contourToPolygon = (contour) => {
+  if (contour.length < 3) return null;
+  const points = contour.map(([x, y]) => new Point2(x, y));
+  try {
+    const polygon = new Polygon5(points);
+    if (polygon.faces.size > 0) {
+      return polygon;
+    }
+  } catch {
+  }
+  return null;
+};
+var createCopperCutFillForLayer = async ({
+  layer,
+  ctx
+}) => {
+  const {
+    project,
+    connMap,
+    topCutNetGeoms,
+    bottomCutNetGeoms,
+    topCopperCutFillCutSetting,
+    bottomCopperCutFillCutSetting,
+    copperCutFillMargin
+  } = ctx;
+  const cutSetting = layer === "top" ? topCopperCutFillCutSetting : bottomCopperCutFillCutSetting;
+  if (!cutSetting) {
+    return;
+  }
+  const netGeomMap = layer === "top" ? topCutNetGeoms : bottomCutNetGeoms;
+  const allGeoms = [];
+  for (const net of Object.keys(connMap.netMap)) {
+    const netGeoms = netGeomMap.get(net);
+    if (netGeoms && netGeoms.length > 0) {
+      allGeoms.push(...netGeoms);
+    }
+  }
+  if (allGeoms.length === 0) {
+    return;
+  }
+  try {
+    const manifold = await getManifold();
+    const { CrossSection } = manifold;
+    const allContours = [];
+    for (const geom of allGeoms) {
+      const contours = polygonToContours(geom);
+      allContours.push(...contours);
+    }
+    if (allContours.length === 0) {
+      return;
+    }
+    const copperInside = new CrossSection(allContours, "Positive");
+    const outerBoundary = copperInside.offset(
+      copperCutFillMargin,
+      "Round",
+      // joinType for smooth corners
+      2,
+      // miterLimit
+      32
+      // circularSegments for round corners
+    );
+    const cutFillArea = outerBoundary.subtract(copperInside);
+    const simplifiedArea = cutFillArea.simplify(1e-3);
+    const resultContours = simplifiedArea.toPolygons();
+    if (resultContours.length === 0) {
+      copperInside.delete();
+      outerBoundary.delete();
+      cutFillArea.delete();
+      simplifiedArea.delete();
+      return;
+    }
+    const shapeGroup = new ShapeGroup();
+    for (const contour of resultContours) {
+      const polygon = contourToPolygon(contour);
+      if (!polygon) continue;
+      for (const island of polygon.splitToIslands()) {
+        const { verts, prims } = polygonToShapePathData(island);
+        if (verts.length > 0) {
+          shapeGroup.children.push(
+            new ShapePath28({
+              cutIndex: cutSetting.index,
+              verts,
+              prims,
+              isClosed: true
+              // Filled shapes should be closed
+            })
+          );
+        }
+      }
+    }
+    if (shapeGroup.children.length > 0) {
+      project.children.push(shapeGroup);
+    }
+    copperInside.delete();
+    outerBoundary.delete();
+    cutFillArea.delete();
+    simplifiedArea.delete();
+  } catch (error) {
+    console.warn(`Failed to create copper cut fill for ${layer} layer:`, error);
+  }
+};
+
 // lib/index.ts
-var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
+var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
   const db = cju2(circuitJson);
   const project = new LightBurnProject({
     appVersion: "1.7.03",
@@ -2496,6 +2637,8 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
   const globalCopperSoldermaskMarginAdjustment = options.globalCopperSoldermaskMarginAdjustment ?? 0;
   const solderMaskMarginPercent = options.solderMaskMarginPercent ?? 0;
   const laserProfile = options.laserProfile;
+  const includeCopperCutFill = options.includeCopperCutFill ?? false;
+  const copperCutFillMargin = options.copperCutFillMargin ?? 0.5;
   const defaultCopperSettings = {
     speed: 300,
     numPasses: 100,
@@ -2553,13 +2696,14 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
     crossHatch: true
   });
   project.children.push(soldermaskCutSetting);
+  let nextCutIndex = 4;
   let topTraceClearanceAreaCutSetting;
   let bottomTraceClearanceAreaCutSetting;
   if (shouldGenerateTraceClearanceZones) {
     if (includeLayers.includes("top")) {
       topTraceClearanceAreaCutSetting = new CutSetting({
         type: "Scan",
-        index: 4,
+        index: nextCutIndex++,
         name: "Clear Top Trace Clearance Areas",
         numPasses: 12,
         speed: 100,
@@ -2573,7 +2717,7 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
     if (includeLayers.includes("bottom")) {
       bottomTraceClearanceAreaCutSetting = new CutSetting({
         type: "Scan",
-        index: 5,
+        index: nextCutIndex++,
         name: "Clear Bottom Trace Clearance Areas",
         numPasses: 12,
         speed: 100,
@@ -2585,6 +2729,38 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
       project.children.push(bottomTraceClearanceAreaCutSetting);
     }
   }
+  let topCopperCutFillCutSetting;
+  let bottomCopperCutFillCutSetting;
+  if (includeCopperCutFill && includeCopper) {
+    if (includeLayers.includes("top")) {
+      topCopperCutFillCutSetting = new CutSetting({
+        type: "Scan",
+        index: nextCutIndex++,
+        name: "Top Copper Cut Fill",
+        numPasses: copperSettings.numPasses,
+        speed: copperSettings.speed,
+        scanOpt: "individual",
+        interval: laserSpotSize,
+        angle: 45,
+        crossHatch: true
+      });
+      project.children.push(topCopperCutFillCutSetting);
+    }
+    if (includeLayers.includes("bottom")) {
+      bottomCopperCutFillCutSetting = new CutSetting({
+        type: "Scan",
+        index: nextCutIndex++,
+        name: "Bottom Copper Cut Fill",
+        numPasses: copperSettings.numPasses,
+        speed: copperSettings.speed,
+        scanOpt: "individual",
+        interval: laserSpotSize,
+        angle: 45,
+        crossHatch: true
+      });
+      project.children.push(bottomCopperCutFillCutSetting);
+    }
+  }
   const connMap = getFullConnectivityMapFromCircuitJson(circuitJson);
   let origin = options.origin;
   if (!origin) {
@@ -2612,7 +2788,10 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
     laserSpotSize,
     topTraceClearanceAreaCutSetting,
     bottomTraceClearanceAreaCutSetting,
-    solderMaskMarginPercent
+    solderMaskMarginPercent,
+    topCopperCutFillCutSetting,
+    bottomCopperCutFillCutSetting,
+    copperCutFillMargin
   };
   for (const net of Object.keys(connMap.netMap)) {
     ctx.topCutNetGeoms.set(net, []);
@@ -2657,6 +2836,14 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
       createTraceClearanceAreasForLayer({ layer: "bottom", ctx });
     }
   }
+  if (includeCopperCutFill && includeCopper) {
+    if (includeLayers.includes("top")) {
+      await createCopperCutFillForLayer({ layer: "top", ctx });
+    }
+    if (includeLayers.includes("bottom")) {
+      await createCopperCutFillForLayer({ layer: "bottom", ctx });
+    }
+  }
   return project;
 };
 export {

package/lib/ConvertContext.ts

@@ -44,6 +44,13 @@ export interface ConvertContext {
   topTraceClearanceAreaCutSetting?: CutSetting
   bottomTraceClearanceAreaCutSetting?: CutSetting
 
+  // Cut settings for copper cut fill layers
+  topCopperCutFillCutSetting?: CutSetting
+  bottomCopperCutFillCutSetting?: CutSetting
+
   // Percent-based solder mask margin (scales with element size)
   solderMaskMarginPercent: number
+
+  // Copper cut fill margin (how far to expand the copper outline for the cut fill band)
+  copperCutFillMargin: number
 }

package/lib/createCopperCutFillForLayer.ts

@@ -0,0 +1,232 @@
+import { Polygon, Box, Point } from "@flatten-js/core"
+import type { ConvertContext } from "./ConvertContext"
+import { polygonToShapePathData } from "./polygon-to-shape-path"
+import { ShapePath, ShapeGroup } from "lbrnts"
+
+// Lazy-load the manifold WASM module
+// Use dynamic import with computed string to prevent bundler from analyzing the import
+// This allows the browser build to succeed - the feature will fail gracefully at runtime
+let manifoldInstance: any = null
+
+const getManifold = async () => {
+  if (!manifoldInstance) {
+    // Use computed module name to prevent bundler from tracing the import
+    const moduleName = "manifold-3d"
+    const ManifoldModule = (await import(/* @vite-ignore */ moduleName)).default
+    manifoldInstance = await ManifoldModule()
+    manifoldInstance.setup() // Initialize the JS-friendly API
+  }
+  return manifoldInstance
+}
+
+type Contour = Array<[number, number]>
+
+/**
+ * Calculates the signed area of a contour.
+ * Positive area = counter-clockwise winding (outer boundary)
+ * Negative area = clockwise winding (hole)
+ */
+const getSignedArea = (contour: Contour): number => {
+  let area = 0
+  const n = contour.length
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n
+    area += contour[i]![0] * contour[j]![1]
+    area -= contour[j]![0] * contour[i]![1]
+  }
+  return area / 2
+}
+
+/**
+ * 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[] => {
+  const contours: Contour[] = []
+
+  if (polygon instanceof Box) {
+    // Convert Box to contour
+    const { xmin, ymin, xmax, ymax } = polygon
+    contours.push([
+      [xmin, ymin],
+      [xmax, ymin],
+      [xmax, ymax],
+      [xmin, ymax],
+    ])
+  } else {
+    // Handle Polygon faces
+    for (const face of polygon.faces) {
+      const contour: Contour = []
+      for (const edge of face) {
+        contour.push([edge.start.x, edge.start.y])
+      }
+      if (contour.length >= 3) {
+        contours.push(contour)
+      }
+    }
+  }
+
+  return contours
+}
+
+/**
+ * Converts a single contour to a flatten-js Polygon
+ */
+const contourToPolygon = (contour: Contour): Polygon | null => {
+  if (contour.length < 3) return null
+
+  const points = contour.map(([x, y]) => new Point(x, y))
+  try {
+    const polygon = new Polygon(points)
+    if (polygon.faces.size > 0) {
+      return polygon
+    }
+  } catch {
+    // Skip invalid polygons
+  }
+  return null
+}
+
+/**
+ * Creates copper cut fill for a given layer using manifold3d CrossSection for offset operations.
+ *
+ * The algorithm:
+ * 1. Collect all copper geometries for the layer (traces, pads, vias, plated holes)
+ * 2. Union all copper geometries into a single CrossSection (the "inside")
+ * 3. Offset (expand) the unified copper outward by copperCutFillMargin (the "outer boundary")
+ * 4. Subtract the inside (original copper) from the outer boundary (expanded copper)
+ * 5. The result is the ring/band area around copper that needs to be lasered to remove more copper
+ *
+ * This creates a laser cut path that removes copper around traces and pads but never
+ * cuts into the traces or pads themselves.
+ */
+export const createCopperCutFillForLayer = async ({
+  layer,
+  ctx,
+}: {
+  layer: "top" | "bottom"
+  ctx: ConvertContext
+}): Promise<void> => {
+  const {
+    project,
+    connMap,
+    topCutNetGeoms,
+    bottomCutNetGeoms,
+    topCopperCutFillCutSetting,
+    bottomCopperCutFillCutSetting,
+    copperCutFillMargin,
+  } = ctx
+
+  // Get the appropriate cut setting for this layer
+  const cutSetting =
+    layer === "top" ? topCopperCutFillCutSetting : bottomCopperCutFillCutSetting
+
+  if (!cutSetting) {
+    return
+  }
+
+  // Get the appropriate geometry map
+  const netGeomMap = layer === "top" ? topCutNetGeoms : bottomCutNetGeoms
+
+  // Collect all geometries for this layer across all nets
+  const allGeoms: Array<Polygon | Box> = []
+  for (const net of Object.keys(connMap.netMap)) {
+    const netGeoms = netGeomMap.get(net)
+    if (netGeoms && netGeoms.length > 0) {
+      allGeoms.push(...netGeoms)
+    }
+  }
+
+  if (allGeoms.length === 0) {
+    return
+  }
+
+  try {
+    // Initialize manifold
+    const manifold = await getManifold()
+    const { CrossSection } = manifold
+
+    // Collect all contours from all geometries
+    const allContours: Contour[] = []
+    for (const geom of allGeoms) {
+      const contours = polygonToContours(geom)
+      allContours.push(...contours)
+    }
+
+    if (allContours.length === 0) {
+      return
+    }
+
+    // Create a unified CrossSection from all copper contours (the "inside")
+    // The constructor performs a boolean union with Positive fill rule
+    const copperInside = new CrossSection(allContours, "Positive")
+
+    // Offset (expand) the copper outward by the margin to get the "outer boundary"
+    // Positive delta expands outward
+    const outerBoundary = copperInside.offset(
+      copperCutFillMargin,
+      "Round", // joinType for smooth corners
+      2.0, // miterLimit
+      32, // circularSegments for round corners
+    )
+
+    // Subtract the inside (original copper) from the outer boundary (expanded copper)
+    // This gives us the ring/band area to laser cut
+    const cutFillArea = outerBoundary.subtract(copperInside)
+
+    // Simplify to clean up any spurious tiny segments
+    const simplifiedArea = cutFillArea.simplify(0.001)
+
+    // Get the resulting contours
+    const resultContours: Contour[] = simplifiedArea.toPolygons()
+
+    if (resultContours.length === 0) {
+      // Clean up WASM memory
+      copperInside.delete()
+      outerBoundary.delete()
+      cutFillArea.delete()
+      simplifiedArea.delete()
+      return
+    }
+
+    // Create a ShapeGroup to hold all contours
+    // LightBurn uses nonzero winding rule: CCW (positive area) = outer boundary, CW (negative area) = hole
+    // By grouping all contours together, LightBurn should properly fill only the ring area
+    const shapeGroup = new ShapeGroup()
+
+    // Convert all contours to ShapePaths and add to the group
+    // Preserve winding order: positive area (CCW) = outer boundary, negative area (CW) = hole
+    for (const contour of resultContours) {
+      const polygon = contourToPolygon(contour)
+      if (!polygon) continue
+
+      for (const island of polygon.splitToIslands()) {
+        const { verts, prims } = polygonToShapePathData(island)
+
+        if (verts.length > 0) {
+          shapeGroup.children.push(
+            new ShapePath({
+              cutIndex: cutSetting.index,
+              verts,
+              prims,
+              isClosed: true, // Filled shapes should be closed
+            }),
+          )
+        }
+      }
+    }
+
+    // Add the group to the project if it has shapes
+    if (shapeGroup.children.length > 0) {
+      project.children.push(shapeGroup)
+    }
+
+    // Clean up WASM memory
+    copperInside.delete()
+    outerBoundary.delete()
+    cutFillArea.delete()
+    simplifiedArea.delete()
+  } catch (error) {
+    console.warn(`Failed to create copper cut fill for ${layer} layer:`, error)
+  }
+}

package/lib/index.ts

@@ -16,6 +16,7 @@ import { addPcbHole } from "./element-handlers/addPcbHole"
 import { addPcbCutout } from "./element-handlers/addPcbCutout"
 import { createCopperShapesForLayer } from "./createCopperShapesForLayer"
 import { createTraceClearanceAreasForLayer } from "./createTraceClearanceAreasForLayer"
+import { createCopperCutFillForLayer } from "./createCopperCutFillForLayer"
 
 export interface ConvertCircuitJsonToLbrnOptions {
   includeSilkscreen?: boolean
@@ -28,6 +29,17 @@ export interface ConvertCircuitJsonToLbrnOptions {
   includeLayers?: Array<"top" | "bottom">
   traceMargin?: number
   laserSpotSize?: number
+  /**
+   * Whether to generate copper cut fill layers.
+   * Creates a ring/band around traces and pads that will be laser cut
+   * to remove copper, without cutting into the traces or pads themselves.
+   */
+  includeCopperCutFill?: boolean
+  /**
+   * Margin to expand the copper outline for the cut fill band (in mm).
+   * This determines how wide the band of copper removal will be around traces/pads.
+   */
+  copperCutFillMargin?: number
   laserProfile?: {
     copper?: {
       speed?: number
@@ -43,10 +55,10 @@ export interface ConvertCircuitJsonToLbrnOptions {
     }
   }
 }
-export const convertCircuitJsonToLbrn = (
+export const convertCircuitJsonToLbrn = async (
   circuitJson: CircuitJson,
   options: ConvertCircuitJsonToLbrnOptions = {},
-): LightBurnProject => {
+): Promise<LightBurnProject> => {
   const db = cju(circuitJson)
   const project = new LightBurnProject({
     appVersion: "1.7.03",
@@ -63,6 +75,8 @@ export const convertCircuitJsonToLbrn = (
     options.globalCopperSoldermaskMarginAdjustment ?? 0
   const solderMaskMarginPercent = options.solderMaskMarginPercent ?? 0
   const laserProfile = options.laserProfile
+  const includeCopperCutFill = options.includeCopperCutFill ?? false
+  const copperCutFillMargin = options.copperCutFillMargin ?? 0.5
 
   // Default laser settings from GitHub issue
   const defaultCopperSettings = {
@@ -134,6 +148,9 @@ export const convertCircuitJsonToLbrn = (
   })
   project.children.push(soldermaskCutSetting)
 
+  // Track the next available cut setting index
+  let nextCutIndex = 4
+
   // Create trace clearance cut settings if needed
   let topTraceClearanceAreaCutSetting: CutSetting | undefined
   let bottomTraceClearanceAreaCutSetting: CutSetting | undefined
@@ -142,7 +159,7 @@ export const convertCircuitJsonToLbrn = (
     if (includeLayers.includes("top")) {
       topTraceClearanceAreaCutSetting = new CutSetting({
         type: "Scan",
-        index: 4,
+        index: nextCutIndex++,
         name: "Clear Top Trace Clearance Areas",
         numPasses: 12,
         speed: 100,
@@ -157,7 +174,7 @@ export const convertCircuitJsonToLbrn = (
     if (includeLayers.includes("bottom")) {
       bottomTraceClearanceAreaCutSetting = new CutSetting({
         type: "Scan",
-        index: 5,
+        index: nextCutIndex++,
         name: "Clear Bottom Trace Clearance Areas",
         numPasses: 12,
         speed: 100,
@@ -170,6 +187,42 @@ export const convertCircuitJsonToLbrn = (
     }
   }
 
+  // Create copper cut fill cut settings if needed
+  let topCopperCutFillCutSetting: CutSetting | undefined
+  let bottomCopperCutFillCutSetting: CutSetting | undefined
+
+  if (includeCopperCutFill && includeCopper) {
+    if (includeLayers.includes("top")) {
+      topCopperCutFillCutSetting = new CutSetting({
+        type: "Scan",
+        index: nextCutIndex++,
+        name: "Top Copper Cut Fill",
+        numPasses: copperSettings.numPasses,
+        speed: copperSettings.speed,
+        scanOpt: "individual",
+        interval: laserSpotSize,
+        angle: 45,
+        crossHatch: true,
+      })
+      project.children.push(topCopperCutFillCutSetting)
+    }
+
+    if (includeLayers.includes("bottom")) {
+      bottomCopperCutFillCutSetting = new CutSetting({
+        type: "Scan",
+        index: nextCutIndex++,
+        name: "Bottom Copper Cut Fill",
+        numPasses: copperSettings.numPasses,
+        speed: copperSettings.speed,
+        scanOpt: "individual",
+        interval: laserSpotSize,
+        angle: 45,
+        crossHatch: true,
+      })
+      project.children.push(bottomCopperCutFillCutSetting)
+    }
+  }
+
   // Build connectivity map and origin
   const connMap = getFullConnectivityMapFromCircuitJson(circuitJson)
   let origin = options.origin
@@ -201,6 +254,9 @@ export const convertCircuitJsonToLbrn = (
     topTraceClearanceAreaCutSetting,
     bottomTraceClearanceAreaCutSetting,
     solderMaskMarginPercent,
+    topCopperCutFillCutSetting,
+    bottomCopperCutFillCutSetting,
+    copperCutFillMargin,
   }
 
   // Initialize net geometry maps
@@ -260,5 +316,15 @@ export const convertCircuitJsonToLbrn = (
     }
   }
 
+  // Create copper cut fill for each layer
+  if (includeCopperCutFill && includeCopper) {
+    if (includeLayers.includes("top")) {
+      await createCopperCutFillForLayer({ layer: "top", ctx })
+    }
+    if (includeLayers.includes("bottom")) {
+      await createCopperCutFillForLayer({ layer: "bottom", ctx })
+    }
+  }
+
   return project
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "circuit-json-to-lbrn",
   "main": "dist/index.js",
-  "version": "0.0.42",
+  "version": "0.0.43",
   "type": "module",
   "scripts": {
     "start": "bun run site/index.html",
@@ -28,6 +28,7 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "lbrnts": "^0.0.12"
+    "lbrnts": "^0.0.13",
+    "manifold-3d": "^3.3.2"
   }
 }