circuit-json-to-lbrn 0.0.43 → 0.0.45

package/dist/index.js

@@ -1728,6 +1728,9 @@ var createCirclePolygon = (center, radius, numPoints = 16) => {
   }
   return new Flatten4.Polygon(points);
 };
+var positionKey = (x, y) => {
+  return `${x.toFixed(6)},${y.toFixed(6)}`;
+};
 var addPcbTrace = (trace, ctx) => {
   const {
     topCutNetGeoms,
@@ -1738,7 +1741,9 @@ var addPcbTrace = (trace, ctx) => {
     origin,
     includeCopper,
     includeLayers,
-    traceMargin
+    traceMargin,
+    topTraceEndpoints,
+    bottomTraceEndpoints
   } = ctx;
   if (!includeCopper) {
     return;
@@ -1779,22 +1784,32 @@ var addPcbTrace = (trace, ctx) => {
       cutNetGeoms.get(netId)?.push(result);
     }
     const segments = layerSegments.get(layer);
+    const endpointSet = layer === "top" ? topTraceEndpoints : bottomTraceEndpoints;
     if (segments) {
       for (const segment of segments) {
         if (segment.length >= 2) {
           const firstPoint = segment[0];
           const lastPoint = segment[segment.length - 1];
           const radius = traceWidth / 2 * 1.1;
-          const startCircle = createCirclePolygon(
-            { x: firstPoint.x + origin.x, y: firstPoint.y + origin.y },
-            radius
-          );
-          cutNetGeoms.get(netId)?.push(startCircle);
-          const endCircle = createCirclePolygon(
-            { x: lastPoint.x + origin.x, y: lastPoint.y + origin.y },
-            radius
-          );
-          cutNetGeoms.get(netId)?.push(endCircle);
+          const startX = firstPoint.x + origin.x;
+          const startY = firstPoint.y + origin.y;
+          const startKey = positionKey(startX, startY);
+          if (!endpointSet.has(startKey)) {
+            endpointSet.add(startKey);
+            const startCircle = createCirclePolygon(
+              { x: startX, y: startY },
+              radius
+            );
+            cutNetGeoms.get(netId)?.push(startCircle);
+          }
+          const endX = lastPoint.x + origin.x;
+          const endY = lastPoint.y + origin.y;
+          const endKey = positionKey(endX, endY);
+          if (!endpointSet.has(endKey)) {
+            endpointSet.add(endKey);
+            const endCircle = createCirclePolygon({ x: endX, y: endY }, radius);
+            cutNetGeoms.get(netId)?.push(endCircle);
+          }
         }
       }
     }
@@ -2484,19 +2499,38 @@ 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";
+
+// lib/getManifold.ts
 var manifoldInstance = null;
 var getManifold = async () => {
   if (!manifoldInstance) {
-    const moduleName = "manifold-3d";
-    const ManifoldModule = (await import(
-      /* @vite-ignore */
-      moduleName
-    )).default;
+    let ManifoldModule;
+    try {
+      const moduleName = "manifold-3d";
+      ManifoldModule = (await import(
+        /* @vite-ignore */
+        moduleName
+      )).default;
+    } catch {
+      try {
+        const cdnUrl = "https://cdn.jsdelivr.net/npm/manifold-3d@3.0.0/manifold.js";
+        ManifoldModule = (await import(
+          /* @vite-ignore */
+          cdnUrl
+        )).default;
+      } catch (cdnError) {
+        throw new Error(
+          `Failed to load manifold-3d: not available in Node.js or via CDN. ${cdnError}`
+        );
+      }
+    }
     manifoldInstance = await ManifoldModule();
     manifoldInstance.setup();
   }
   return manifoldInstance;
 };
+
+// lib/createCopperCutFillForLayer.ts
 var polygonToContours = (polygon) => {
   const contours = [];
   if (polygon instanceof Box4) {
@@ -2543,7 +2577,8 @@ var createCopperCutFillForLayer = async ({
     bottomCutNetGeoms,
     topCopperCutFillCutSetting,
     bottomCopperCutFillCutSetting,
-    copperCutFillMargin
+    copperCutFillMargin,
+    boardOutlineContour
   } = ctx;
   const cutSetting = layer === "top" ? topCopperCutFillCutSetting : bottomCopperCutFillCutSetting;
   if (!cutSetting) {
@@ -2581,7 +2616,14 @@ var createCopperCutFillForLayer = async ({
       32
       // circularSegments for round corners
     );
-    const cutFillArea = outerBoundary.subtract(copperInside);
+    let cutFillArea = outerBoundary.subtract(copperInside);
+    if (boardOutlineContour && boardOutlineContour.length >= 3) {
+      const boardOutline = new CrossSection([boardOutlineContour], "Positive");
+      const clippedArea = cutFillArea.intersect(boardOutline);
+      cutFillArea.delete();
+      cutFillArea = clippedArea;
+      boardOutline.delete();
+    }
     const simplifiedArea = cutFillArea.simplify(1e-3);
     const resultContours = simplifiedArea.toPolygons();
     if (resultContours.length === 0) {
@@ -2791,7 +2833,9 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
     solderMaskMarginPercent,
     topCopperCutFillCutSetting,
     bottomCopperCutFillCutSetting,
-    copperCutFillMargin
+    copperCutFillMargin,
+    topTraceEndpoints: /* @__PURE__ */ new Set(),
+    bottomTraceEndpoints: /* @__PURE__ */ new Set()
   };
   for (const net of Object.keys(connMap.netMap)) {
     ctx.topCutNetGeoms.set(net, []);
@@ -2799,6 +2843,28 @@ var convertCircuitJsonToLbrn = async (circuitJson, options = {}) => {
     ctx.topScanNetGeoms.set(net, []);
     ctx.bottomScanNetGeoms.set(net, []);
   }
+  for (const board of db.pcb_board.list()) {
+    if (board.outline?.length) {
+      ctx.boardOutlineContour = board.outline.map((outlinePoint) => [
+        outlinePoint.x + origin.x,
+        outlinePoint.y + origin.y
+      ]);
+    } else if (typeof board.width === "number" && typeof board.height === "number" && board.center) {
+      const halfWidth = board.width / 2;
+      const halfHeight = board.height / 2;
+      const minX = board.center.x - halfWidth + origin.x;
+      const minY = board.center.y - halfHeight + origin.y;
+      const maxX = board.center.x + halfWidth + origin.x;
+      const maxY = board.center.y + halfHeight + origin.y;
+      ctx.boardOutlineContour = [
+        [minX, minY],
+        [maxX, minY],
+        [maxX, maxY],
+        [minX, maxY]
+      ];
+    }
+    break;
+  }
   for (const smtpad of db.pcb_smtpad.list()) {
     addSmtPad(smtpad, ctx);
   }

package/lib/ConvertContext.ts

@@ -3,6 +3,8 @@ import type { CutSetting, LightBurnProject } from "lbrnts"
 import type { Box, Polygon } from "@flatten-js/core"
 import type { ConnectivityMap } from "circuit-json-to-connectivity-map"
 
+type Contour = Array<[number, number]>
+
 export type ConnectivityMapKey = string
 
 export interface ConvertContext {
@@ -53,4 +55,12 @@ export interface ConvertContext {
 
   // Copper cut fill margin (how far to expand the copper outline for the cut fill band)
   copperCutFillMargin: number
+
+  // Track trace endpoint positions to avoid duplicate circles
+  // Key is "x,y" rounded to 6 decimal places
+  topTraceEndpoints: Set<string>
+  bottomTraceEndpoints: Set<string>
+
+  // Board outline as a contour for clipping copper cut fill
+  boardOutlineContour?: Contour
 }

package/lib/createCopperCutFillForLayer.ts

@@ -2,22 +2,7 @@ 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
-}
+import { getManifold } from "./getManifold"
 
 type Contour = Array<[number, number]>
 
@@ -115,6 +100,7 @@ export const createCopperCutFillForLayer = async ({
     topCopperCutFillCutSetting,
     bottomCopperCutFillCutSetting,
     copperCutFillMargin,
+    boardOutlineContour,
   } = ctx
 
   // Get the appropriate cut setting for this layer
@@ -172,7 +158,16 @@ export const createCopperCutFillForLayer = async ({
 
     // 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)
+    let cutFillArea = outerBoundary.subtract(copperInside)
+
+    // Clip to board outline if available
+    if (boardOutlineContour && boardOutlineContour.length >= 3) {
+      const boardOutline = new CrossSection([boardOutlineContour], "Positive")
+      const clippedArea = cutFillArea.intersect(boardOutline)
+      cutFillArea.delete()
+      cutFillArea = clippedArea
+      boardOutline.delete()
+    }
 
     // Simplify to clean up any spurious tiny segments
     const simplifiedArea = cutFillArea.simplify(0.001)

package/lib/element-handlers/addPcbTrace/index.ts

@@ -27,6 +27,14 @@ const createCirclePolygon = (
   return new Flatten.Polygon(points)
 }
 
+/**
+ * Creates a position key for deduplication.
+ * Rounds to 6 decimal places to handle floating point precision.
+ */
+const positionKey = (x: number, y: number): string => {
+  return `${x.toFixed(6)},${y.toFixed(6)}`
+}
+
 export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
   const {
     topCutNetGeoms,
@@ -38,6 +46,8 @@ export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
     includeCopper,
     includeLayers,
     traceMargin,
+    topTraceEndpoints,
+    bottomTraceEndpoints,
   } = ctx
 
   // Only include traces when including copper
@@ -95,7 +105,10 @@ export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
     // Add circular pads at trace endpoints to ensure overlap at junctions
     // This is crucial for boolean union to properly merge traces that share endpoints
     // Use a slightly larger radius (1.1x) to ensure proper overlap despite floating point issues
+    // Deduplicate endpoints to avoid identical polygons that cause boolean operation failures
     const segments = layerSegments.get(layer)
+    const endpointSet =
+      layer === "top" ? topTraceEndpoints : bottomTraceEndpoints
     if (segments) {
       for (const segment of segments) {
         if (segment.length >= 2) {
@@ -103,19 +116,28 @@ export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
           const lastPoint = segment[segment.length - 1]!
           const radius = (traceWidth / 2) * 1.1 // Slightly larger for reliable overlap
 
-          // Add circle at start point (translated by origin)
-          const startCircle = createCirclePolygon(
-            { x: firstPoint.x + origin.x, y: firstPoint.y + origin.y },
-            radius,
-          )
-          cutNetGeoms.get(netId)?.push(startCircle)
-
-          // Add circle at end point (translated by origin)
-          const endCircle = createCirclePolygon(
-            { x: lastPoint.x + origin.x, y: lastPoint.y + origin.y },
-            radius,
-          )
-          cutNetGeoms.get(netId)?.push(endCircle)
+          // Add circle at start point (translated by origin) if not already added
+          const startX = firstPoint.x + origin.x
+          const startY = firstPoint.y + origin.y
+          const startKey = positionKey(startX, startY)
+          if (!endpointSet.has(startKey)) {
+            endpointSet.add(startKey)
+            const startCircle = createCirclePolygon(
+              { x: startX, y: startY },
+              radius,
+            )
+            cutNetGeoms.get(netId)?.push(startCircle)
+          }
+
+          // Add circle at end point (translated by origin) if not already added
+          const endX = lastPoint.x + origin.x
+          const endY = lastPoint.y + origin.y
+          const endKey = positionKey(endX, endY)
+          if (!endpointSet.has(endKey)) {
+            endpointSet.add(endKey)
+            const endCircle = createCirclePolygon({ x: endX, y: endY }, radius)
+            cutNetGeoms.get(netId)?.push(endCircle)
+          }
         }
       }
     }

package/lib/getManifold.ts

@@ -0,0 +1,31 @@
+// Lazy-load the manifold WASM module
+// Supports both Node.js and browser environments with CDN fallback
+
+let manifoldInstance: any = null
+
+export const getManifold = async () => {
+  if (!manifoldInstance) {
+    let ManifoldModule: any
+
+    // Try Node.js import first (for CLI/tests)
+    try {
+      const moduleName = "manifold-3d"
+      ManifoldModule = (await import(/* @vite-ignore */ moduleName)).default
+    } catch {
+      // Fallback to CDN for browser environments
+      try {
+        const cdnUrl =
+          "https://cdn.jsdelivr.net/npm/manifold-3d@3.0.0/manifold.js"
+        ManifoldModule = (await import(/* @vite-ignore */ cdnUrl)).default
+      } catch (cdnError) {
+        throw new Error(
+          `Failed to load manifold-3d: not available in Node.js or via CDN. ${cdnError}`,
+        )
+      }
+    }
+
+    manifoldInstance = await ManifoldModule()
+    manifoldInstance.setup() // Initialize the JS-friendly API
+  }
+  return manifoldInstance
+}

package/lib/index.ts

@@ -257,6 +257,8 @@ export const convertCircuitJsonToLbrn = async (
     topCopperCutFillCutSetting,
     bottomCopperCutFillCutSetting,
     copperCutFillMargin,
+    topTraceEndpoints: new Set(),
+    bottomTraceEndpoints: new Set(),
   }
 
   // Initialize net geometry maps
@@ -267,6 +269,34 @@ export const convertCircuitJsonToLbrn = async (
     ctx.bottomScanNetGeoms.set(net, [])
   }
 
+  // Extract board outline for clipping copper cut fill
+  for (const board of db.pcb_board.list()) {
+    if (board.outline?.length) {
+      ctx.boardOutlineContour = board.outline.map((outlinePoint) => [
+        outlinePoint.x + origin.x,
+        outlinePoint.y + origin.y,
+      ])
+    } else if (
+      typeof board.width === "number" &&
+      typeof board.height === "number" &&
+      board.center
+    ) {
+      const halfWidth = board.width / 2
+      const halfHeight = board.height / 2
+      const minX = board.center.x - halfWidth + origin.x
+      const minY = board.center.y - halfHeight + origin.y
+      const maxX = board.center.x + halfWidth + origin.x
+      const maxY = board.center.y + halfHeight + origin.y
+      ctx.boardOutlineContour = [
+        [minX, minY],
+        [maxX, minY],
+        [maxX, maxY],
+        [minX, maxY],
+      ]
+    }
+    break // Only use the first board
+  }
+
   // Process all PCB elements
   for (const smtpad of db.pcb_smtpad.list()) {
     addSmtPad(smtpad, ctx)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "circuit-json-to-lbrn",
   "main": "dist/index.js",
-  "version": "0.0.43",
+  "version": "0.0.45",
   "type": "module",
   "scripts": {
     "start": "bun run site/index.html",