circuit-json-to-lbrn 0.0.20 → 0.0.22

package/lib/ConvertContext.ts

@@ -9,19 +9,23 @@ export interface ConvertContext {
   db: CircuitJsonUtilObjects
   project: LightBurnProject
 
-  copperCutSetting: CutSetting
+  topCopperCutSetting: CutSetting
+  bottomCopperCutSetting: CutSetting
   throughBoardCutSetting: CutSetting
   soldermaskCutSetting: CutSetting
 
   connMap: ConnectivityMap
 
-  netGeoms: Map<ConnectivityMapKey, Array<Polygon | Box>>
+  // Separate net geometries for top and bottom layers
+  topNetGeoms: Map<ConnectivityMapKey, Array<Polygon | Box>>
+  bottomNetGeoms: Map<ConnectivityMapKey, Array<Polygon | Box>>
 
   origin: { x: number; y: number }
 
   // Include flags
   includeCopper: boolean
   includeSoldermask: boolean
+  includeLayers: Array<"top" | "bottom">
 
   // Soldermask margin (can be negative)
   soldermaskMargin: number

package/lib/element-handlers/addPcbCutout/addCirclePcbCutout.ts

@@ -25,7 +25,11 @@ export const addCirclePcbCutout = (
 
   // Add the cutout - cut through the board
   if (cutout.radius > 0 && includeCopper) {
-    const circlePath = createCirclePath(centerX, centerY, cutout.radius)
+    const circlePath = createCirclePath({
+      centerX,
+      centerY,
+      radius: cutout.radius,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: throughBoardCutSetting.index,
@@ -39,7 +43,11 @@ export const addCirclePcbCutout = (
   // Add soldermask opening if drawing soldermask
   if (cutout.radius > 0 && includeSoldermask) {
     const smRadius = cutout.radius + soldermaskMargin
-    const outer = createCirclePath(centerX, centerY, smRadius)
+    const outer = createCirclePath({
+      centerX,
+      centerY,
+      radius: smRadius,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: soldermaskCutSetting.index,

package/lib/element-handlers/addPcbCutout/addPolygonPcbCutout.ts

@@ -23,11 +23,11 @@ export const addPolygonPcbCutout = (
 
   // Add the cutout - cut through the board
   if (cutout.points.length >= 3 && includeCopper) {
-    const polygonPath = createPolygonPathFromOutline(
-      cutout.points,
-      origin.x,
-      origin.y,
-    )
+    const polygonPath = createPolygonPathFromOutline({
+      outline: cutout.points,
+      offsetX: origin.x,
+      offsetY: origin.y,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: throughBoardCutSetting.index,
@@ -55,7 +55,11 @@ export const addPolygonPcbCutout = (
           }))
         : cutout.points
 
-    const polygonPath = createPolygonPathFromOutline(points, origin.x, origin.y)
+    const polygonPath = createPolygonPathFromOutline({
+      outline: points,
+      offsetX: origin.x,
+      offsetY: origin.y,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: soldermaskCutSetting.index,

package/lib/element-handlers/addPcbCutout/addRectPcbCutout.ts

@@ -26,15 +26,15 @@ export const addRectPcbCutout = (
   // Add the cutout - cut through the board
   if (cutout.width > 0 && cutout.height > 0 && includeCopper) {
     const rotation = (cutout.rotation ?? 0) * (Math.PI / 180) // Convert degrees to radians
-    const rectPath = createRoundedRectPath(
+    const rectPath = createRoundedRectPath({
       centerX,
       centerY,
-      cutout.width,
-      cutout.height,
-      0, // no border radius for cutouts
-      4, // segments
+      width: cutout.width,
+      height: cutout.height,
+      borderRadius: 0, // no border radius for cutouts
+      segments: 4, // segments
       rotation,
-    )
+    })
     project.children.push(
       new ShapePath({
         cutIndex: throughBoardCutSetting.index,
@@ -50,15 +50,15 @@ export const addRectPcbCutout = (
     const rotation = (cutout.rotation ?? 0) * (Math.PI / 180) // Convert degrees to radians
     const smWidth = cutout.width + 2 * soldermaskMargin
     const smHeight = cutout.height + 2 * soldermaskMargin
-    const rectPath = createRoundedRectPath(
+    const rectPath = createRoundedRectPath({
       centerX,
       centerY,
-      smWidth,
-      smHeight,
-      0, // no border radius for cutouts
-      4, // segments
+      width: smWidth,
+      height: smHeight,
+      borderRadius: 0, // no border radius for cutouts
+      segments: 4, // segments
       rotation,
-    )
+    })
     project.children.push(
       new ShapePath({
         cutIndex: soldermaskCutSetting.index,

package/lib/element-handlers/addPcbHole/addCirclePcbHole.ts

@@ -25,7 +25,11 @@ export const addCirclePcbHole = (
   // Add soldermask opening if drawing soldermask
   if (hole.hole_diameter > 0 && includeSoldermask) {
     const smRadius = hole.hole_diameter / 2 + soldermaskMargin
-    const soldermaskPath = createCirclePath(centerX, centerY, smRadius)
+    const soldermaskPath = createCirclePath({
+      centerX,
+      centerY,
+      radius: smRadius,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: soldermaskCutSetting.index,
@@ -39,7 +43,11 @@ export const addCirclePcbHole = (
   // Add the hole - cut through the board
   if (hole.hole_diameter > 0 && includeCopper) {
     const radius = hole.hole_diameter / 2
-    const circlePath = createCirclePath(centerX, centerY, radius)
+    const circlePath = createCirclePath({
+      centerX,
+      centerY,
+      radius,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: throughBoardCutSetting.index,

package/lib/element-handlers/addPcbHole/addOvalPcbHole.ts

@@ -24,12 +24,12 @@ export const addOvalPcbHole = (
 
   // Add soldermask opening if drawing soldermask
   if (hole.hole_width > 0 && hole.hole_height > 0 && includeSoldermask) {
-    const soldermaskPath = createOvalPath(
+    const soldermaskPath = createOvalPath({
       centerX,
       centerY,
-      hole.hole_width + soldermaskMargin * 2,
-      hole.hole_height + soldermaskMargin * 2,
-    )
+      width: hole.hole_width + soldermaskMargin * 2,
+      height: hole.hole_height + soldermaskMargin * 2,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: soldermaskCutSetting.index,
@@ -42,12 +42,12 @@ export const addOvalPcbHole = (
 
   // Add the hole - cut through the board
   if (hole.hole_width > 0 && hole.hole_height > 0 && includeCopper) {
-    const ovalPath = createOvalPath(
+    const ovalPath = createOvalPath({
       centerX,
       centerY,
-      hole.hole_width,
-      hole.hole_height,
-    )
+      width: hole.hole_width,
+      height: hole.hole_height,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: throughBoardCutSetting.index,

package/lib/element-handlers/addPcbHole/addPillPcbHole.ts

@@ -24,12 +24,12 @@ export const addPillPcbHole = (
 
   // Add soldermask opening if drawing soldermask
   if (hole.hole_width > 0 && hole.hole_height > 0 && includeSoldermask) {
-    const soldermaskPath = createPillPath(
+    const soldermaskPath = createPillPath({
       centerX,
       centerY,
-      hole.hole_width + soldermaskMargin * 2,
-      hole.hole_height + soldermaskMargin * 2,
-    )
+      width: hole.hole_width + soldermaskMargin * 2,
+      height: hole.hole_height + soldermaskMargin * 2,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: soldermaskCutSetting.index,
@@ -42,12 +42,12 @@ export const addPillPcbHole = (
 
   // Add the hole - cut through the board
   if (hole.hole_width > 0 && hole.hole_height > 0 && includeCopper) {
-    const pillPath = createPillPath(
+    const pillPath = createPillPath({
       centerX,
       centerY,
-      hole.hole_width,
-      hole.hole_height,
-    )
+      width: hole.hole_width,
+      height: hole.hole_height,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: throughBoardCutSetting.index,

package/lib/element-handlers/addPcbHole/addRectPcbHole.ts

@@ -24,13 +24,13 @@ export const addRectPcbHole = (
 
   // Add soldermask opening if drawing soldermask
   if (hole.hole_width > 0 && hole.hole_height > 0 && includeSoldermask) {
-    const soldermaskPath = createRoundedRectPath(
+    const soldermaskPath = createRoundedRectPath({
       centerX,
       centerY,
-      hole.hole_width + soldermaskMargin * 2,
-      hole.hole_height + soldermaskMargin * 2,
-      0, // no border radius for rect holes
-    )
+      width: hole.hole_width + soldermaskMargin * 2,
+      height: hole.hole_height + soldermaskMargin * 2,
+      borderRadius: 0, // no border radius for rect holes
+    })
     project.children.push(
       new ShapePath({
         cutIndex: soldermaskCutSetting.index,
@@ -43,13 +43,13 @@ export const addRectPcbHole = (
 
   // Add the hole - cut through the board
   if (hole.hole_width > 0 && hole.hole_height > 0 && includeCopper) {
-    const rectPath = createRoundedRectPath(
+    const rectPath = createRoundedRectPath({
       centerX,
       centerY,
-      hole.hole_width,
-      hole.hole_height,
-      0, // no border radius for rect holes
-    )
+      width: hole.hole_width,
+      height: hole.hole_height,
+      borderRadius: 0, // no border radius for rect holes
+    })
     project.children.push(
       new ShapePath({
         cutIndex: throughBoardCutSetting.index,

package/lib/element-handlers/addPcbHole/addRotatedPillPcbHole.ts

@@ -25,13 +25,13 @@ export const addRotatedPillPcbHole = (
 
   // Add soldermask opening if drawing soldermask
   if (hole.hole_width > 0 && hole.hole_height > 0 && includeSoldermask) {
-    const soldermaskPath = createPillPath(
+    const soldermaskPath = createPillPath({
       centerX,
       centerY,
-      hole.hole_width + soldermaskMargin * 2,
-      hole.hole_height + soldermaskMargin * 2,
+      width: hole.hole_width + soldermaskMargin * 2,
+      height: hole.hole_height + soldermaskMargin * 2,
       rotation,
-    )
+    })
     project.children.push(
       new ShapePath({
         cutIndex: soldermaskCutSetting.index,
@@ -44,13 +44,13 @@ export const addRotatedPillPcbHole = (
 
   // Add the hole - cut through the board
   if (hole.hole_width > 0 && hole.hole_height > 0 && includeCopper) {
-    const pillPath = createPillPath(
+    const pillPath = createPillPath({
       centerX,
       centerY,
-      hole.hole_width,
-      hole.hole_height,
+      width: hole.hole_width,
+      height: hole.hole_height,
       rotation,
-    )
+    })
     project.children.push(
       new ShapePath({
         cutIndex: throughBoardCutSetting.index,

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

@@ -1,10 +1,17 @@
-import type { PcbTrace } from "circuit-json"
+import type { PcbTrace, PcbTraceRoutePoint } from "circuit-json"
 import type { ConvertContext } from "../../ConvertContext"
 import Flatten, { BooleanOperations } from "@flatten-js/core"
 import { circleToPolygon } from "./circle-to-polygon"
 
 export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
-  const { netGeoms, connMap, origin, includeCopper, includeSoldermask } = ctx
+  const {
+    topNetGeoms,
+    bottomNetGeoms,
+    connMap,
+    origin,
+    includeCopper,
+    includeLayers,
+  } = ctx
 
   // Only include traces when including copper
   // Traces are NOT included in soldermask-only mode to prevent accidental bridging
@@ -14,83 +21,160 @@ export const addPcbTrace = (trace: PcbTrace, ctx: ConvertContext) => {
 
   const netId = connMap.getNetConnectedToId(
     trace.source_trace_id ?? trace.pcb_trace_id,
-  )!
+  )
 
   if (!netId) {
-    console.warn(`Trace ${trace.pcb_trace_id} is not connected to any net`)
+    // Skip traces that are not connected to any net
+    // This can happen for traces without a source_trace_id
     return
   }
 
   if (!trace.route || trace.route.length < 2) {
-    console.warn(`Trace ${trace.pcb_trace_id} has insufficient route points`)
     return
   }
 
   const { route } = trace
+  const wirePoint = route.find((point) => {
+    if (!("route_type" in point)) return true
+    return point.route_type === "wire"
+  })
+  const traceWidth = (wirePoint as any)?.width ?? 0.15
+
+  // Group consecutive wire segments by layer
+  // When we hit a via, we start a new segment on the new layer
+  const layerSegments = new Map<
+    "top" | "bottom",
+    Array<Array<{ x: number; y: number }>>
+  >()
+
+  let currentSegment: Array<{ x: number; y: number }> = []
+  let currentLayer: "top" | "bottom" | null = null
+
+  for (const point of route) {
+    if ("route_type" in point && point.route_type === "via") {
+      // Via marks end of current segment - save it
+      if (currentLayer && currentSegment.length > 0) {
+        if (!layerSegments.has(currentLayer)) {
+          layerSegments.set(currentLayer, [])
+        }
+        layerSegments.get(currentLayer)!.push(currentSegment)
+      }
+      // Reset for next segment
+      currentSegment = []
+      currentLayer = null
+      continue
+    }
 
-  const traceWidth =
-    route.find((point) => point.route_type === "wire")?.width ?? 0.15
-
-  const polygons: Flatten.Polygon[] = []
-
-  // Add circles for each vertex
-  for (const routePoint of route) {
-    const circle = new Flatten.Circle(
-      new Flatten.Point(routePoint.x + origin.x, routePoint.y + origin.y),
-      traceWidth / 2,
-    )
-    polygons.push(circleToPolygon(circle))
+    // Treat points without route_type as wire points (default behavior)
+    const isWirePoint = !("route_type" in point) || point.route_type === "wire"
+    if (isWirePoint && "layer" in point && point.layer) {
+      const pointLayer = point.layer as "top" | "bottom" | string
+      if (pointLayer !== "top" && pointLayer !== "bottom") {
+        continue // Skip inner layers
+      }
+
+      // If layer changed (shouldn't happen without via, but handle it)
+      if (currentLayer !== null && currentLayer !== pointLayer) {
+        // Save current segment
+        if (currentSegment.length > 0) {
+          if (!layerSegments.has(currentLayer)) {
+            layerSegments.set(currentLayer, [])
+          }
+          layerSegments.get(currentLayer)!.push(currentSegment)
+        }
+        // Start new segment
+        currentSegment = []
+      }
+
+      currentLayer = pointLayer
+      currentSegment.push({ x: point.x, y: point.y })
+    }
   }
 
-  // Add rectangles for each segment
-  for (let i = 0; i < route.length - 1; i++) {
-    const p1 = route[i]
-    const p2 = route[i + 1]
-
-    if (!p1 || !p2) continue
-
-    const segmentLength = Math.hypot(p1.x - p2.x, p1.y - p2.y)
-    if (segmentLength === 0) continue
-
-    const centerX = (p1.x + p2.x) / 2 + origin.x
-    const centerY = (p1.y + p2.y) / 2 + origin.y
-    const rotationDeg = (Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180) / Math.PI
-
-    const w2 = segmentLength / 2
-    const h2 = traceWidth / 2
-
-    const angleRad = (rotationDeg * Math.PI) / 180
-    const cosAngle = Math.cos(angleRad)
-    const sinAngle = Math.sin(angleRad)
-
-    const corners = [
-      { x: -w2, y: -h2 },
-      { x: w2, y: -h2 },
-      { x: w2, y: h2 },
-      { x: -w2, y: h2 },
-    ]
+  // Save final segment
+  if (currentLayer && currentSegment.length > 0) {
+    if (!layerSegments.has(currentLayer)) {
+      layerSegments.set(currentLayer, [])
+    }
+    layerSegments.get(currentLayer)!.push(currentSegment)
+  }
 
-    const rotatedCorners = corners.map((p) => ({
-      x: centerX + p.x * cosAngle - p.y * sinAngle,
-      y: centerY + p.x * sinAngle + p.y * cosAngle,
-    }))
+  // Process each layer
+  for (const [layer, segments] of layerSegments.entries()) {
+    if (!includeLayers.includes(layer)) {
+      continue
+    }
 
-    polygons.push(
-      new Flatten.Polygon(rotatedCorners.map((p) => Flatten.point(p.x, p.y))),
-    )
-  }
+    // Combine all segments for this layer into one set of polygons
+    const polygons: Flatten.Polygon[] = []
+
+    for (const points of segments) {
+      if (points.length < 2) continue
+
+      // Add circles for each vertex in this segment
+      for (const routePoint of points) {
+        const circle = new Flatten.Circle(
+          new Flatten.Point(routePoint.x + origin.x, routePoint.y + origin.y),
+          traceWidth / 2,
+        )
+        polygons.push(circleToPolygon(circle))
+      }
+
+      // Add rectangles for each line segment
+      for (let i = 0; i < points.length - 1; i++) {
+        const p1 = points[i]
+        const p2 = points[i + 1]
+
+        if (!p1 || !p2) continue
+
+        const segmentLength = Math.hypot(p1.x - p2.x, p1.y - p2.y)
+        if (segmentLength === 0) continue
+
+        const centerX = (p1.x + p2.x) / 2 + origin.x
+        const centerY = (p1.y + p2.y) / 2 + origin.y
+        const rotationDeg =
+          (Math.atan2(p2.y - p1.y, p2.x - p1.x) * 180) / Math.PI
+
+        const w2 = segmentLength / 2
+        const h2 = traceWidth / 2
+
+        const angleRad = (rotationDeg * Math.PI) / 180
+        const cosAngle = Math.cos(angleRad)
+        const sinAngle = Math.sin(angleRad)
+
+        const corners = [
+          { x: -w2, y: -h2 },
+          { x: w2, y: -h2 },
+          { x: w2, y: h2 },
+          { x: -w2, y: h2 },
+        ]
+
+        const rotatedCorners = corners.map((p) => ({
+          x: centerX + p.x * cosAngle - p.y * sinAngle,
+          y: centerY + p.x * sinAngle + p.y * cosAngle,
+        }))
+
+        polygons.push(
+          new Flatten.Polygon(
+            rotatedCorners.map((p) => Flatten.point(p.x, p.y)),
+          ),
+        )
+      }
+    }
 
-  // Union all polygons together to create the final trace polygon
-  if (polygons.length === 0) return
+    // Union all polygons together to create the final trace polygon for this layer
+    if (polygons.length === 0) continue
 
-  let tracePolygon = polygons[0]!
+    let tracePolygon = polygons[0]!
 
-  for (let i = 1; i < polygons.length; i++) {
-    const poly = polygons[i]
-    if (poly) {
-      tracePolygon = BooleanOperations.unify(tracePolygon, poly)
+    for (let i = 1; i < polygons.length; i++) {
+      const poly = polygons[i]
+      if (poly) {
+        tracePolygon = BooleanOperations.unify(tracePolygon, poly)
+      }
     }
-  }
 
-  netGeoms.get(netId)?.push(tracePolygon)
+    const netGeoms = layer === "top" ? topNetGeoms : bottomNetGeoms
+    netGeoms.get(netId)?.push(tracePolygon)
+  }
 }

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

@@ -9,19 +9,24 @@ export const addPcbVia = (via: PcbVia, ctx: ConvertContext): void => {
   const {
     db,
     project,
-    copperCutSetting,
+    topCopperCutSetting,
+    bottomCopperCutSetting,
     soldermaskCutSetting,
     throughBoardCutSetting,
+    topNetGeoms,
+    bottomNetGeoms,
     origin,
     includeCopper,
     includeSoldermask,
     connMap,
     soldermaskMargin,
+    includeLayers,
   } = ctx
   const centerX = via.x + origin.x
   const centerY = via.y + origin.y
 
   // Add outer circle (copper annulus) if drawing copper - add to netGeoms for merging
+  // Vias go through all layers, so add to both top and bottom
   if (via.outer_diameter > 0 && includeCopper) {
     // Find the pcb_port associated with this via (vias don't have pcb_port_id property)
     // We need to find a port at the same location as the via
@@ -38,26 +43,51 @@ export const addPcbVia = (via: PcbVia, ctx: ConvertContext): void => {
     const polygon = circleToPolygon(circle)
 
     if (netId) {
-      // Add to netGeoms to be merged with other elements on the same net
-      ctx.netGeoms.get(netId)?.push(polygon)
+      // Add to both top and bottom netGeoms since vias go through the board
+      if (includeLayers.includes("top")) {
+        topNetGeoms.get(netId)?.push(polygon.clone())
+      }
+      if (includeLayers.includes("bottom")) {
+        bottomNetGeoms.get(netId)?.push(polygon.clone())
+      }
     } else {
-      // No net connection - draw directly
-      const outer = createCirclePath(centerX, centerY, outerRadius)
-      project.children.push(
-        new ShapePath({
-          cutIndex: copperCutSetting.index,
-          verts: outer.verts,
-          prims: outer.prims,
-          isClosed: true,
-        }),
-      )
+      // No net connection - draw directly for each included layer
+      const outer = createCirclePath({
+        centerX,
+        centerY,
+        radius: outerRadius,
+      })
+      if (includeLayers.includes("top")) {
+        project.children.push(
+          new ShapePath({
+            cutIndex: topCopperCutSetting.index,
+            verts: outer.verts,
+            prims: outer.prims,
+            isClosed: true,
+          }),
+        )
+      }
+      if (includeLayers.includes("bottom")) {
+        project.children.push(
+          new ShapePath({
+            cutIndex: bottomCopperCutSetting.index,
+            verts: outer.verts,
+            prims: outer.prims,
+            isClosed: true,
+          }),
+        )
+      }
     }
   }
 
   // Add soldermask opening if drawing soldermask
   if (via.outer_diameter > 0 && includeSoldermask) {
     const smRadius = via.outer_diameter / 2 + soldermaskMargin
-    const outer = createCirclePath(centerX, centerY, smRadius)
+    const outer = createCirclePath({
+      centerX,
+      centerY,
+      radius: smRadius,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: soldermaskCutSetting.index,
@@ -71,7 +101,11 @@ export const addPcbVia = (via: PcbVia, ctx: ConvertContext): void => {
   // Add inner circle (hole) - always cut through the board regardless of mode
   if (via.hole_diameter > 0 && includeCopper) {
     const innerRadius = via.hole_diameter / 2
-    const inner = createCirclePath(centerX, centerY, innerRadius)
+    const inner = createCirclePath({
+      centerX,
+      centerY,
+      radius: innerRadius,
+    })
     project.children.push(
       new ShapePath({
         cutIndex: throughBoardCutSetting.index,