circuit-json-to-lbrn 0.0.6 → 0.0.8

package/dist/index.js

@@ -1,10 +1,576 @@
 // lib/index.ts
-import { LightBurnProject, CutSetting, ShapePath as ShapePath3 } from "lbrnts";
+import { LightBurnProject, CutSetting, ShapePath as ShapePath10 } from "lbrnts";
 import { cju as cju2 } from "@tscircuit/circuit-json-util";
 
 // lib/element-handlers/addPlatedHole/addCirclePlatedHole.ts
 import { ShapePath } from "lbrnts";
 
+// lib/helpers/circleShape.ts
+var createCirclePath = (centerX, centerY, radius, segments = 64) => {
+  const verts = [];
+  const prims = [];
+  for (let i = 0; i < segments; i++) {
+    const angle = i / segments * Math.PI * 2;
+    const x = centerX + radius * Math.cos(angle);
+    const y = centerY + radius * Math.sin(angle);
+    verts.push({ x, y });
+    prims.push({ type: 0 });
+  }
+  if (verts.length > 0) {
+    const firstVert = verts[0];
+    if (firstVert) {
+      verts.push({ ...firstVert });
+      prims.push({ type: 0 });
+    }
+  }
+  return { verts, prims };
+};
+
+// lib/element-handlers/addPlatedHole/addCirclePlatedHole.ts
+var addCirclePlatedHole = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  if (platedHole.outer_diameter > 0) {
+    const outerRadius = platedHole.outer_diameter / 2;
+    const outer = createCirclePath(centerX, centerY, outerRadius);
+    project.children.push(
+      new ShapePath({
+        cutIndex: copperCutSetting.index,
+        verts: outer.verts,
+        prims: outer.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (platedHole.hole_diameter > 0) {
+    const innerRadius = platedHole.hole_diameter / 2;
+    const inner = createCirclePath(centerX, centerY, innerRadius);
+    project.children.push(
+      new ShapePath({
+        cutIndex: throughBoardCutSetting.index,
+        verts: inner.verts,
+        prims: inner.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addOvalPlatedHole.ts
+import { ShapePath as ShapePath2 } from "lbrnts";
+
+// lib/helpers/ovalShape.ts
+var createOvalPath = (centerX, centerY, width, height, rotation = 0, segments = 64) => {
+  const verts = [];
+  const prims = [];
+  const radiusX = width / 2;
+  const radiusY = height / 2;
+  const cosTheta = Math.cos(rotation);
+  const sinTheta = Math.sin(rotation);
+  for (let i = 0; i < segments; i++) {
+    const angle = i / segments * Math.PI * 2;
+    const localX = radiusX * Math.cos(angle);
+    const localY = radiusY * Math.sin(angle);
+    const rotatedX = centerX + localX * cosTheta - localY * sinTheta;
+    const rotatedY = centerY + localX * sinTheta + localY * cosTheta;
+    verts.push({ x: rotatedX, y: rotatedY });
+    prims.push({ type: 0 });
+  }
+  if (verts.length > 0) {
+    const firstVert = verts[0];
+    if (firstVert) {
+      verts.push({ ...firstVert });
+      prims.push({ type: 0 });
+    }
+  }
+  return { verts, prims };
+};
+
+// lib/element-handlers/addPlatedHole/addOvalPlatedHole.ts
+var addOvalPlatedHole = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  if (platedHole.outer_width <= 0 || platedHole.outer_height <= 0) {
+    return;
+  }
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  const rotation = (platedHole.ccw_rotation ?? 0) * (Math.PI / 180);
+  if (platedHole.outer_width > 0 && platedHole.outer_height > 0) {
+    const outer = createOvalPath(
+      centerX,
+      centerY,
+      platedHole.outer_width,
+      platedHole.outer_height,
+      rotation
+    );
+    project.children.push(
+      new ShapePath2({
+        cutIndex: copperCutSetting.index,
+        verts: outer.verts,
+        prims: outer.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (platedHole.hole_width > 0 && platedHole.hole_height > 0) {
+    const inner = createOvalPath(
+      centerX,
+      centerY,
+      platedHole.hole_width,
+      platedHole.hole_height,
+      rotation
+    );
+    project.children.push(
+      new ShapePath2({
+        cutIndex: throughBoardCutSetting.index,
+        verts: inner.verts,
+        prims: inner.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addCircularHoleWithRectPad.ts
+import { ShapePath as ShapePath3 } from "lbrnts";
+
+// lib/helpers/roundedRectShape.ts
+var createRoundedRectPath = (centerX, centerY, width, height, borderRadius = 0, segments = 4, rotation = 0) => {
+  const verts = [];
+  const prims = [];
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  const rotatePoint = (x, y) => {
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    return {
+      x: x * cos - y * sin,
+      y: x * sin + y * cos
+    };
+  };
+  const addPoint = (x, y) => {
+    const rotated = rotation ? rotatePoint(x, y) : { x, y };
+    verts.push({ x: centerX + rotated.x, y: centerY + rotated.y });
+    prims.push({ type: 0 });
+  };
+  addPoint(-halfWidth + borderRadius, -halfHeight);
+  addPoint(halfWidth - borderRadius, -halfHeight);
+  if (borderRadius > 0) {
+    for (let i = 0; i <= segments; i++) {
+      const angle = Math.PI * 1.5 + i * Math.PI * 0.5 / segments;
+      addPoint(
+        halfWidth - borderRadius + Math.cos(angle) * borderRadius,
+        -halfHeight + borderRadius + Math.sin(angle) * borderRadius
+      );
+    }
+  } else {
+    addPoint(halfWidth, -halfHeight);
+  }
+  addPoint(halfWidth, -halfHeight + borderRadius);
+  addPoint(halfWidth, halfHeight - borderRadius);
+  if (borderRadius > 0) {
+    for (let i = 0; i <= segments; i++) {
+      const angle = i * Math.PI * 0.5 / segments;
+      addPoint(
+        halfWidth - borderRadius + Math.cos(angle) * borderRadius,
+        halfHeight - borderRadius + Math.sin(angle) * borderRadius
+      );
+    }
+  } else {
+    addPoint(halfWidth, halfHeight);
+  }
+  addPoint(halfWidth - borderRadius, halfHeight);
+  addPoint(-halfWidth + borderRadius, halfHeight);
+  if (borderRadius > 0) {
+    for (let i = 0; i <= segments; i++) {
+      const angle = Math.PI * 0.5 + i * Math.PI * 0.5 / segments;
+      addPoint(
+        -halfWidth + borderRadius + Math.cos(angle) * borderRadius,
+        halfHeight - borderRadius + Math.sin(angle) * borderRadius
+      );
+    }
+  } else {
+    addPoint(-halfWidth, halfHeight);
+  }
+  addPoint(-halfWidth, halfHeight - borderRadius);
+  addPoint(-halfWidth, -halfHeight + borderRadius);
+  if (borderRadius > 0) {
+    for (let i = 0; i <= segments; i++) {
+      const angle = Math.PI + i * Math.PI * 0.5 / segments;
+      addPoint(
+        -halfWidth + borderRadius + Math.cos(angle) * borderRadius,
+        -halfHeight + borderRadius + Math.sin(angle) * borderRadius
+      );
+    }
+  } else {
+    addPoint(-halfWidth, -halfHeight);
+  }
+  if (verts.length > 0) {
+    const firstVert = verts[0];
+    if (firstVert) {
+      verts.push({ ...firstVert });
+      prims.push({ type: 0 });
+    }
+  }
+  return { verts, prims };
+};
+
+// lib/element-handlers/addPlatedHole/addCircularHoleWithRectPad.ts
+var addCircularHoleWithRectPad = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  const holeRadius = platedHole.hole_diameter / 2;
+  const padWidth = platedHole.rect_pad_width;
+  const padHeight = platedHole.rect_pad_height;
+  const borderRadius = platedHole.rect_border_radius ?? 0;
+  const padPath = createRoundedRectPath(
+    centerX,
+    centerY,
+    padWidth,
+    padHeight,
+    borderRadius
+  );
+  project.children.push(
+    new ShapePath3({
+      cutIndex: copperCutSetting.index,
+      verts: padPath.verts,
+      prims: padPath.prims,
+      isClosed: true
+    })
+  );
+  if (holeRadius > 0) {
+    const holeCenterX = centerX + platedHole.hole_offset_x;
+    const holeCenterY = centerY + platedHole.hole_offset_y;
+    const holePath = createCirclePath(holeCenterX, holeCenterY, holeRadius, 32);
+    project.children.push(
+      new ShapePath3({
+        cutIndex: throughBoardCutSetting.index,
+        verts: holePath.verts,
+        prims: holePath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addPillHoleWithRectPad.ts
+import { ShapePath as ShapePath4 } from "lbrnts";
+
+// lib/helpers/pathPointUtils.ts
+var createPointAdder = (verts, prims, options = {}) => {
+  const { rotation = 0, rotationCenter, translation } = options;
+  const cos = Math.cos(rotation);
+  const sin = Math.sin(rotation);
+  const effectiveCenter = rotationCenter ?? translation ?? { x: 0, y: 0 };
+  return (x, y) => {
+    let px = x;
+    let py = y;
+    if (rotation) {
+      const cx = effectiveCenter.x;
+      const cy = effectiveCenter.y;
+      const dx = px - cx;
+      const dy = py - cy;
+      px = cx + dx * cos - dy * sin;
+      py = cy + dx * sin + dy * cos;
+    }
+    const tx = translation?.x ?? 0;
+    const ty = translation?.y ?? 0;
+    verts.push({ x: px + tx, y: py + ty });
+    prims.push({ type: 0 });
+  };
+};
+
+// lib/helpers/pillShape.ts
+var createPillPath = (centerX, centerY, width, height, rotation = 0, segments = 32) => {
+  const verts = [];
+  const prims = [];
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  const radius = Math.min(halfWidth, halfHeight);
+  const isVertical = height > width;
+  const addPoint = createPointAdder(verts, prims, {
+    rotation,
+    rotationCenter: { x: centerX, y: centerY }
+  });
+  if (isVertical) {
+    const capOffset = halfHeight - radius;
+    for (let i = 0; i <= segments; i++) {
+      const angle = Math.PI + i / segments * Math.PI;
+      const x = centerX + radius * Math.cos(angle);
+      const y = centerY - capOffset + radius * Math.sin(angle);
+      addPoint(x, y);
+    }
+    addPoint(centerX + radius, centerY + capOffset);
+    for (let i = 0; i <= segments; i++) {
+      const angle = i / segments * Math.PI;
+      const x = centerX + radius * Math.cos(angle);
+      const y = centerY + capOffset + radius * Math.sin(angle);
+      addPoint(x, y);
+    }
+    addPoint(centerX - radius, centerY - capOffset);
+  } else {
+    const capOffset = halfWidth - radius;
+    for (let i = 0; i <= segments; i++) {
+      const angle = -Math.PI / 2 + i / segments * Math.PI;
+      const x = centerX + capOffset + radius * Math.cos(angle);
+      const y = centerY + radius * Math.sin(angle);
+      addPoint(x, y);
+    }
+    addPoint(centerX - capOffset, centerY + radius);
+    for (let i = 0; i <= segments; i++) {
+      const angle = Math.PI / 2 + i / segments * Math.PI;
+      const x = centerX - capOffset + radius * Math.cos(angle);
+      const y = centerY + radius * Math.sin(angle);
+      addPoint(x, y);
+    }
+    addPoint(centerX + capOffset, centerY - radius);
+  }
+  if (verts.length > 0) {
+    const firstVert = verts[0];
+    if (firstVert) {
+      verts.push({ ...firstVert });
+      prims.push({ type: 0 });
+    }
+  }
+  return { verts, prims };
+};
+
+// lib/element-handlers/addPlatedHole/addPillHoleWithRectPad.ts
+var addPillHoleWithRectPad = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  const padWidth = platedHole.rect_pad_width;
+  const padHeight = platedHole.rect_pad_height;
+  const borderRadius = platedHole.rect_border_radius ?? 0;
+  if (padWidth > 0 && padHeight > 0) {
+    const padPath = createRoundedRectPath(
+      centerX,
+      centerY,
+      padWidth,
+      padHeight,
+      borderRadius
+    );
+    project.children.push(
+      new ShapePath4({
+        cutIndex: copperCutSetting.index,
+        verts: padPath.verts,
+        prims: padPath.prims,
+        isClosed: true
+      })
+    );
+  }
+  const holeWidth = platedHole.hole_width;
+  const holeHeight = platedHole.hole_height;
+  if (holeWidth > 0 && holeHeight > 0) {
+    const holeCenterX = centerX + platedHole.hole_offset_x;
+    const holeCenterY = centerY + platedHole.hole_offset_y;
+    const holePath = createPillPath(
+      holeCenterX,
+      holeCenterY,
+      holeWidth,
+      holeHeight
+    );
+    project.children.push(
+      new ShapePath4({
+        cutIndex: throughBoardCutSetting.index,
+        verts: holePath.verts,
+        prims: holePath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addRotatedPillHoleWithRectPad.ts
+import { ShapePath as ShapePath5 } from "lbrnts";
+var addRotatedPillHoleWithRectPad = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  const padWidth = platedHole.rect_pad_width;
+  const padHeight = platedHole.rect_pad_height;
+  const borderRadius = platedHole.rect_border_radius ?? 0;
+  const padRotation = (platedHole.rect_ccw_rotation ?? 0) * (Math.PI / 180);
+  if (padWidth > 0 && padHeight > 0) {
+    const padPath = createRoundedRectPath(
+      centerX,
+      centerY,
+      padWidth,
+      padHeight,
+      borderRadius,
+      4,
+      padRotation
+    );
+    project.children.push(
+      new ShapePath5({
+        cutIndex: copperCutSetting.index,
+        verts: padPath.verts,
+        prims: padPath.prims,
+        isClosed: true
+      })
+    );
+  }
+  const holeWidth = platedHole.hole_width;
+  const holeHeight = platedHole.hole_height;
+  const holeRotation = (platedHole.hole_ccw_rotation ?? 0) * (Math.PI / 180);
+  if (holeWidth > 0 && holeHeight > 0) {
+    const holeCenterX = centerX + platedHole.hole_offset_x;
+    const holeCenterY = centerY + platedHole.hole_offset_y;
+    const holePath = createPillPath(
+      holeCenterX,
+      holeCenterY,
+      holeWidth,
+      holeHeight,
+      holeRotation
+    );
+    project.children.push(
+      new ShapePath5({
+        cutIndex: throughBoardCutSetting.index,
+        verts: holePath.verts,
+        prims: holePath.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addHoleWithPolygonPad.ts
+import { ShapePath as ShapePath6 } from "lbrnts";
+
+// lib/helpers/polygonShape.ts
+var createPolygonPathFromOutline = (outline, offsetX, offsetY) => {
+  const verts = [];
+  for (const point2 of outline) {
+    const x = (point2.x ?? 0) + offsetX;
+    const y = (point2.y ?? 0) + offsetY;
+    verts.push({ x, y });
+  }
+  if (verts.length === 0) {
+    return { verts, prims: [] };
+  }
+  const first = verts[0];
+  verts.push({ x: first.x, y: first.y });
+  const prims = new Array(verts.length).fill({ type: 0 });
+  return { verts, prims };
+};
+
+// lib/element-handlers/addPlatedHole/addHoleWithPolygonPad.ts
+var addHoleWithPolygonPad = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  if (platedHole.pad_outline.length >= 3) {
+    const pad = createPolygonPathFromOutline(
+      platedHole.pad_outline,
+      platedHole.x + origin.x,
+      platedHole.y + origin.y
+    );
+    project.children.push(
+      new ShapePath6({
+        cutIndex: copperCutSetting.index,
+        verts: pad.verts,
+        prims: pad.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (platedHole.hole_shape === "circle" && platedHole.hole_diameter) {
+    const centerX = platedHole.x + platedHole.hole_offset_x + origin.x;
+    const centerY = platedHole.y + platedHole.hole_offset_y + origin.y;
+    const radius = platedHole.hole_diameter / 2;
+    const hole = createCirclePath(centerX, centerY, radius, 64);
+    project.children.push(
+      new ShapePath6({
+        cutIndex: throughBoardCutSetting.index,
+        verts: hole.verts,
+        prims: hole.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (platedHole.hole_shape === "pill" && platedHole.hole_diameter) {
+    const centerX = platedHole.x + platedHole.hole_offset_x + origin.x;
+    const centerY = platedHole.y + platedHole.hole_offset_y + origin.y;
+    const radius = platedHole.hole_diameter / 2;
+    const hole = createCirclePath(centerX, centerY, radius, 64);
+    project.children.push(
+      new ShapePath6({
+        cutIndex: throughBoardCutSetting.index,
+        verts: hole.verts,
+        prims: hole.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/addPillPlatedHole.ts
+import { ShapePath as ShapePath7 } from "lbrnts";
+var addPcbPlatedHolePill = (platedHole, ctx) => {
+  const { project, copperCutSetting, throughBoardCutSetting, origin } = ctx;
+  const centerX = platedHole.x + origin.x;
+  const centerY = platedHole.y + origin.y;
+  const rotation = (platedHole.ccw_rotation || 0) * (Math.PI / 180);
+  if (platedHole.outer_width > 0 && platedHole.outer_height > 0) {
+    const outer = createPillPath(
+      centerX,
+      centerY,
+      platedHole.outer_width,
+      platedHole.outer_height,
+      rotation
+    );
+    project.children.push(
+      new ShapePath7({
+        cutIndex: copperCutSetting.index,
+        verts: outer.verts,
+        prims: outer.prims,
+        isClosed: true
+      })
+    );
+  }
+  if (platedHole.hole_width > 0 && platedHole.hole_height > 0) {
+    const inner = createPillPath(
+      centerX,
+      centerY,
+      platedHole.hole_width,
+      platedHole.hole_height,
+      rotation
+    );
+    project.children.push(
+      new ShapePath7({
+        cutIndex: throughBoardCutSetting.index,
+        verts: inner.verts,
+        prims: inner.prims,
+        isClosed: true
+      })
+    );
+  }
+};
+
+// lib/element-handlers/addPlatedHole/index.ts
+var addPlatedHole = (platedHole, ctx) => {
+  switch (platedHole.shape) {
+    case "circle":
+      return addCirclePlatedHole(platedHole, ctx);
+    case "oval":
+      return addOvalPlatedHole(platedHole, ctx);
+    case "pill":
+      return addPcbPlatedHolePill(platedHole, ctx);
+    case "circular_hole_with_rect_pad":
+      return addCircularHoleWithRectPad(platedHole, ctx);
+    case "pill_hole_with_rect_pad":
+      return addPillHoleWithRectPad(platedHole, ctx);
+    case "rotated_pill_hole_with_rect_pad":
+      return addRotatedPillHoleWithRectPad(platedHole, ctx);
+    case "hole_with_polygon_pad":
+      return addHoleWithPolygonPad(platedHole, ctx);
+    default:
+      const _exhaustive = platedHole;
+      console.warn(`Unknown plated hole shape: ${platedHole.shape}`);
+  }
+};
+
 // lib/element-handlers/addSmtPad/addRectSmtPad.ts
 import { Box } from "@flatten-js/core";
 import "lbrnts";
@@ -69,7 +635,7 @@ var addPcbTrace = (trace, ctx) => {
     return;
   }
   const { route } = trace;
-  const traceWidth = route.find((point) => point.route_type === "wire")?.width ?? 0.15;
+  const traceWidth = route.find((point2) => point2.route_type === "wire")?.width ?? 0.15;
   const polygons = [];
   for (const routePoint of route) {
     const circle = new Flatten2.Circle(
@@ -117,9 +683,9 @@ var addPcbTrace = (trace, ctx) => {
   netGeoms.get(netId)?.push(tracePolygon);
 };
 
-// lib/index.ts
-import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
-import { Polygon, Box as Box2, BooleanOperations as BooleanOperations2 } from "@flatten-js/core";
+// lib/element-handlers/addPcbBoard/index.ts
+import { Polygon, point } from "@flatten-js/core";
+import { ShapePath as ShapePath9 } from "lbrnts";
 
 // lib/polygon-to-shape-path.ts
 function polygonToShapePathData(polygon) {
@@ -148,6 +714,46 @@ function polygonToShapePathData(polygon) {
   return { verts, prims };
 }
 
+// lib/element-handlers/addPcbBoard/index.ts
+var addPcbBoard = (board, ctx) => {
+  const { origin, project, throughBoardCutSetting } = ctx;
+  let polygon = null;
+  if (board.outline?.length) {
+    polygon = new Polygon(
+      board.outline.map(
+        (outlinePoint) => point(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;
+    polygon = new Polygon([
+      point(minX, minY),
+      point(maxX, minY),
+      point(maxX, maxY),
+      point(minX, maxY)
+    ]);
+  }
+  if (!polygon) return;
+  const { verts, prims } = polygonToShapePathData(polygon);
+  project.children.push(
+    new ShapePath9({
+      cutIndex: throughBoardCutSetting.index,
+      verts,
+      prims,
+      isClosed: true
+    })
+  );
+};
+
+// lib/index.ts
+import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
+import { Polygon as Polygon2, Box as Box2, BooleanOperations as BooleanOperations2 } from "@flatten-js/core";
+
 // lib/calculateBounds.ts
 import { cju } from "@tscircuit/circuit-json-util";
 var calculateCircuitBounds = (circuitJson) => {
@@ -173,14 +779,14 @@ var calculateCircuitBounds = (circuitJson) => {
     }
   }
   for (const trace of db.pcb_trace.list()) {
-    const isWidthPoint = (point) => "width" in point && typeof point.width === "number";
+    const isWidthPoint = (point2) => "width" in point2 && typeof point2.width === "number";
     const halfWidth = trace.route_thickness_mode === "interpolated" ? 0 : (trace.route.find(isWidthPoint)?.width ?? 0) / 2;
-    for (const point of trace.route) {
-      const pointWidth = trace.route_thickness_mode === "interpolated" ? isWidthPoint(point) ? point.width / 2 : 0 : halfWidth;
-      minX = Math.min(minX, point.x - pointWidth);
-      minY = Math.min(minY, point.y - pointWidth);
-      maxX = Math.max(maxX, point.x + pointWidth);
-      maxY = Math.max(maxY, point.y + pointWidth);
+    for (const point2 of trace.route) {
+      const pointWidth = trace.route_thickness_mode === "interpolated" ? isWidthPoint(point2) ? point2.width / 2 : 0 : halfWidth;
+      minX = Math.min(minX, point2.x - pointWidth);
+      minY = Math.min(minY, point2.y - pointWidth);
+      maxX = Math.max(maxX, point2.x + pointWidth);
+      maxY = Math.max(maxY, point2.y + pointWidth);
     }
   }
   for (const hole of db.pcb_plated_hole.list()) {
@@ -218,6 +824,13 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
     speed: 100
   });
   project.children.push(copperCutSetting);
+  const throughBoardCutSetting = new CutSetting({
+    index: 1,
+    name: "Cut Through Board",
+    numPasses: 3,
+    speed: 50
+  });
+  project.children.push(throughBoardCutSetting);
   const connMap = getFullConnectivityMapFromCircuitJson(circuitJson);
   let origin = options.origin;
   if (!origin) {
@@ -228,6 +841,7 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
     db,
     project,
     copperCutSetting,
+    throughBoardCutSetting,
     connMap,
     netGeoms: /* @__PURE__ */ new Map(),
     origin
@@ -238,9 +852,15 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
   for (const smtpad of db.pcb_smtpad.list()) {
     addSmtPad(smtpad, ctx);
   }
+  for (const platedHole of db.pcb_plated_hole.list()) {
+    addPlatedHole(platedHole, ctx);
+  }
   for (const trace of db.pcb_trace.list()) {
     addPcbTrace(trace, ctx);
   }
+  for (const board of db.pcb_board.list()) {
+    addPcbBoard(board, ctx);
+  }
   for (const net of Object.keys(connMap.netMap)) {
     const netGeoms = ctx.netGeoms.get(net);
     if (netGeoms.length === 0) {
@@ -248,19 +868,19 @@ var convertCircuitJsonToLbrn = (circuitJson, options = {}) => {
     }
     let union = netGeoms[0];
     if (union instanceof Box2) {
-      union = new Polygon(union);
+      union = new Polygon2(union);
     }
     for (const geom of netGeoms.slice(1)) {
-      if (geom instanceof Polygon) {
+      if (geom instanceof Polygon2) {
         union = BooleanOperations2.unify(union, geom);
       } else if (geom instanceof Box2) {
-        union = BooleanOperations2.unify(union, new Polygon(geom));
+        union = BooleanOperations2.unify(union, new Polygon2(geom));
       }
     }
     for (const island of union.splitToIslands()) {
       const { verts, prims } = polygonToShapePathData(island);
       project.children.push(
-        new ShapePath3({
+        new ShapePath10({
           cutIndex: copperCutSetting.index,
           verts,
           prims,