circuit-to-canvas 0.0.110 → 0.0.112

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AnyCircuitElement, PcbRenderLayer, NinePointAnchor, PcbPlatedHole, PCBVia, PcbHole, PcbSmtPad, PcbVia, PcbTrace, PcbBoard, PcbPanel, PcbSilkscreenText, PcbSilkscreenRect, PcbSilkscreenCircle, PcbSilkscreenLine, PcbSilkscreenPath, PcbSilkscreenPill, PcbSilkscreenOval, PcbCutout, PCBKeepout, PcbCopperPour, PcbCopperText, PcbFabricationNoteText, PcbFabricationNoteRect, PcbNoteRect, PcbFabricationNotePath, PcbNotePath, PcbNoteText, PcbNoteDimension, PcbFabricationNoteDimension, PcbCourtyardCircle } from 'circuit-json';
+import { LayerRef, AnyCircuitElement, PcbRenderLayer, NinePointAnchor, PcbPlatedHole, PCBVia, PcbHole, PcbSmtPad, PcbVia, PcbCutout, PcbTrace, PcbBoard, PcbPanel, PcbSilkscreenText, PcbSilkscreenRect, PcbSilkscreenCircle, PcbSilkscreenLine, PcbSilkscreenPath, PcbSilkscreenPill, PcbSilkscreenOval, PCBKeepout, PcbCopperPour, PcbCopperText, PcbFabricationNoteText, PcbFabricationNoteRect, PcbNoteRect, PcbFabricationNotePath, PcbNotePath, PcbNoteText, PcbNoteDimension, PcbFabricationNoteDimension, PcbCourtyardCircle } from 'circuit-json';
 import { Matrix } from 'transformation-matrix';
 
 /**
@@ -44,7 +44,7 @@ interface CanvasContext {
     font: string;
     textAlign: "start" | "end" | "left" | "right" | "center";
 }
-type CopperLayerName = "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
+type CopperLayerName = LayerRef;
 type CopperColorMap = Record<CopperLayerName, string> & {
     [layer: string]: string;
 };
@@ -333,7 +333,7 @@ interface DrawPcbPlatedHoleParams {
     colorMap: PcbColorMap;
     soldermaskMargin?: number;
     drawSoldermask?: boolean;
-    layer?: "top" | "bottom";
+    layer?: LayerRef;
 }
 declare function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void;
 
@@ -342,7 +342,7 @@ interface DrawPcbViaParams {
     via: PCBVia;
     realToCanvasMat: Matrix;
     colorMap: PcbColorMap;
-    layer?: "top" | "bottom";
+    layer?: LayerRef;
 }
 declare function drawPcbVia(params: DrawPcbViaParams): void;
 
@@ -364,6 +364,7 @@ interface DrawPcbSmtPadParams {
     holes?: PcbHole[];
     platedHoles?: PcbPlatedHole[];
     vias?: PcbVia[];
+    cutouts?: PcbCutout[];
 }
 declare function drawPcbSmtPad(params: DrawPcbSmtPadParams): void;
 

package/dist/index.js

@@ -1637,22 +1637,24 @@ function drawPadWithDrillCutouts(params) {
   ctx.restore();
 }
 function getPadDrillCutouts(params) {
-  const { pad, holes = [], platedHoles = [], vias = [] } = params;
+  const { pad, holes = [], platedHoles = [], vias = [], cutouts = [] } = params;
   const padBounds = getPadBounds(pad);
   if (!padBounds) return [];
-  const cutouts = [];
-  for (const hole of holes) {
-    const cutout = getHoleDrillCutout(hole);
+  const drillCutouts = [];
+  const addIfOverlapping = (cutout) => {
     if (cutout && boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout);
+      drillCutouts.push(cutout);
     }
+  };
+  for (const cutout of cutouts) {
+    addIfOverlapping(getBoardCutout(cutout));
+  }
+  for (const hole of holes) {
+    addIfOverlapping(getHoleDrillCutout(hole));
   }
   for (const platedHole of platedHoles) {
     if (!layersIncludePadLayer(platedHole.layers, pad.layer)) continue;
-    const cutout = getPlatedHoleDrillCutout(platedHole);
-    if (cutout && boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout);
-    }
+    addIfOverlapping(getPlatedHoleDrillCutout(platedHole));
   }
   for (const via of vias) {
     if (!layersIncludePadLayer(via.layers, pad.layer)) continue;
@@ -1664,11 +1666,9 @@ function getPadDrillCutouts(params) {
       y: via.y,
       radius
     };
-    if (boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout);
-    }
+    addIfOverlapping(cutout);
   }
-  return cutouts;
+  return drillCutouts;
 }
 function appendPadPath(ctx, pad, realToCanvasMat) {
   if (pad.shape === "rect" || pad.shape === "rotated_rect") {
@@ -1741,11 +1741,16 @@ function appendDrillCutoutPath(ctx, drillCutout, realToCanvasMat) {
     });
     return;
   }
+  if (drillCutout.shape === "polygon") {
+    appendPolygonPath(ctx, drillCutout.points, realToCanvasMat);
+    return;
+  }
   appendRectPath(ctx, {
     x: drillCutout.x,
     y: drillCutout.y,
     width: drillCutout.width,
     height: drillCutout.height,
+    radius: drillCutout.radius,
     rotation: drillCutout.rotation,
     realToCanvasMat
   });
@@ -1883,6 +1888,9 @@ function getPadBounds(pad) {
   }
 }
 function getDrillCutoutBounds(cutout) {
+  if (cutout.shape === "polygon") {
+    return getPointBounds(cutout.points);
+  }
   if (cutout.shape === "circle") {
     return boundsAroundCenter(cutout.x, cutout.y, cutout.radius, cutout.radius);
   }
@@ -1906,6 +1914,32 @@ function getDrillCutoutBounds(cutout) {
   }
   return boundsAroundCenter(cutout.x, cutout.y, halfWidth, halfHeight);
 }
+function getBoardCutout(cutout) {
+  if (cutout.shape === "circle") {
+    if (cutout.radius <= 0) return;
+    return {
+      shape: "circle",
+      x: cutout.center.x,
+      y: cutout.center.y,
+      radius: cutout.radius
+    };
+  }
+  if (cutout.shape === "rect") {
+    if (cutout.width <= 0 || cutout.height <= 0) return;
+    return {
+      shape: "rect",
+      x: cutout.center.x,
+      y: cutout.center.y,
+      width: cutout.width,
+      height: cutout.height,
+      radius: cutout.corner_radius,
+      rotation: cutout.rotation
+    };
+  }
+  if (cutout.shape === "polygon" && cutout.points.length >= 3) {
+    return { shape: "polygon", points: cutout.points };
+  }
+}
 function getPointBounds(points) {
   let minX = Infinity;
   let maxX = -Infinity;
@@ -5183,6 +5217,8 @@ var DEFAULT_PCB_COLOR_MAP = {
     inner4: "rgb(64, 224, 208)",
     inner5: "rgb(138, 43, 226)",
     inner6: "rgb(255, 105, 180)",
+    inner7: "rgb(232, 178, 167)",
+    inner8: "rgb(242, 237, 161)",
     bottom: "rgb(77, 127, 196)"
   },
   copperPour: {
@@ -5222,9 +5258,10 @@ var DEFAULT_PCB_COLOR_MAP = {
 // lib/drawer/CircuitToCanvasDrawer.ts
 function getCopperLayer(layers) {
   if (!layers || layers.length === 0) return "top";
-  const hasBottom = layers.some((l) => l.startsWith("bottom"));
-  return hasBottom ? "bottom" : "top";
+  const copperLayer = layers.find((candidate) => candidate.endsWith("_copper"));
+  return copperLayer ? copperLayer.slice(0, -"_copper".length) : "top";
 }
+var isOnCopperLayer = (element, layer) => element.layers?.includes(layer) ?? true;
 var CircuitToCanvasDrawer = class {
   ctx;
   colorMap;
@@ -5310,13 +5347,16 @@ var CircuitToCanvasDrawer = class {
     const renderTopSoldermask = drawSoldermask && (board !== void 0 || panel !== void 0) && (options.drawSoldermaskTop ?? !hasExplicitSoldermaskLayers);
     const renderBottomSoldermask = drawSoldermask && (board !== void 0 || panel !== void 0) && (options.drawSoldermaskBottom ?? false);
     const drawableVias = elements.filter(
-      (el) => shouldDrawElement(el, options) && el.type === "pcb_via"
+      (el) => shouldDrawElement(el, options) && el.type === "pcb_via" && isOnCopperLayer(el, layer)
     );
     const drawableHoles = elements.filter(
       (el) => shouldDrawElement(el, options) && el.type === "pcb_hole"
     );
     const drawablePlatedHoles = elements.filter(
-      (el) => shouldDrawElement(el, options) && el.type === "pcb_plated_hole"
+      (el) => shouldDrawElement(el, options) && el.type === "pcb_plated_hole" && isOnCopperLayer(el, layer)
+    );
+    const drawableCutouts = elements.filter(
+      (el) => shouldDrawElement(el, options) && el.type === "pcb_cutout"
     );
     if (board) {
       drawPcbBoard({
@@ -5349,7 +5389,8 @@ var CircuitToCanvasDrawer = class {
           colorMap: this.colorMap,
           holes: drawableHoles,
           platedHoles: drawablePlatedHoles,
-          vias: drawableVias
+          vias: drawableVias,
+          cutouts: drawableCutouts
         });
       }
       if (element.type === "pcb_copper_text") {
@@ -5387,7 +5428,7 @@ var CircuitToCanvasDrawer = class {
             drawSoldermask: renderTopSoldermask
           });
         }
-        if (element.type === "pcb_plated_hole") {
+        if (element.type === "pcb_plated_hole" && isOnCopperLayer(element, layer)) {
           drawPcbPlatedHole({
             ctx: this.ctx,
             hole: element,
@@ -5398,7 +5439,7 @@ var CircuitToCanvasDrawer = class {
             layer
           });
         }
-        if (element.type === "pcb_via") {
+        if (element.type === "pcb_via" && isOnCopperLayer(element, layer)) {
           drawPcbVia({
             ctx: this.ctx,
             via: element,
@@ -5506,7 +5547,7 @@ var CircuitToCanvasDrawer = class {
     }
     for (const element of elements) {
       if (!shouldDrawElement(element, options)) continue;
-      if (element.type === "pcb_plated_hole" && !renderTopSoldermask) {
+      if (element.type === "pcb_plated_hole" && !renderTopSoldermask && isOnCopperLayer(element, layer)) {
         drawPcbPlatedHole({
           ctx: this.ctx,
           hole: element,
@@ -5517,7 +5558,7 @@ var CircuitToCanvasDrawer = class {
           layer
         });
       }
-      if (element.type === "pcb_via" && !renderTopSoldermask) {
+      if (element.type === "pcb_via" && !renderTopSoldermask && isOnCopperLayer(element, layer)) {
         drawPcbVia({
           ctx: this.ctx,
           via: element,

package/lib/drawer/CircuitToCanvasDrawer.ts

@@ -1,5 +1,6 @@
 import type {
   AnyCircuitElement,
+  LayerRef,
   PCBKeepout,
   PcbBoard,
   PcbCopperPour,
@@ -94,12 +95,17 @@ interface CanvasLike {
   getContext(contextId: "2d"): CanvasContext | null
 }
 
-function getCopperLayer(layers?: PcbRenderLayer[]): "top" | "bottom" {
+function getCopperLayer(layers?: PcbRenderLayer[]): LayerRef {
   if (!layers || layers.length === 0) return "top"
-  const hasBottom = layers.some((l) => l.startsWith("bottom"))
-  return hasBottom ? "bottom" : "top"
+  const copperLayer = layers.find((candidate) => candidate.endsWith("_copper"))
+  return copperLayer
+    ? (copperLayer.slice(0, -"_copper".length) as LayerRef)
+    : "top"
 }
 
+const isOnCopperLayer = (element: PcbVia | PcbPlatedHole, layer: LayerRef) =>
+  element.layers?.includes(layer) ?? true
+
 export class CircuitToCanvasDrawer {
   private ctx: CanvasContext
   private colorMap: PcbColorMap
@@ -233,7 +239,9 @@ export class CircuitToCanvasDrawer {
       (options.drawSoldermaskBottom ?? false)
     const drawableVias = elements.filter(
       (el): el is PcbVia =>
-        shouldDrawElement(el, options) && el.type === "pcb_via",
+        shouldDrawElement(el, options) &&
+        el.type === "pcb_via" &&
+        isOnCopperLayer(el, layer),
     )
     const drawableHoles = elements.filter(
       (el): el is PcbHole =>
@@ -241,7 +249,13 @@ export class CircuitToCanvasDrawer {
     )
     const drawablePlatedHoles = elements.filter(
       (el): el is PcbPlatedHole =>
-        shouldDrawElement(el, options) && el.type === "pcb_plated_hole",
+        shouldDrawElement(el, options) &&
+        el.type === "pcb_plated_hole" &&
+        isOnCopperLayer(el, layer),
+    )
+    const drawableCutouts = elements.filter(
+      (el): el is PcbCutout =>
+        shouldDrawElement(el, options) && el.type === "pcb_cutout",
     )
 
     // Step 2: Draw board outline/material (inner board)
@@ -283,6 +297,7 @@ export class CircuitToCanvasDrawer {
           holes: drawableHoles,
           platedHoles: drawablePlatedHoles,
           vias: drawableVias,
+          cutouts: drawableCutouts,
         })
       }
 
@@ -327,7 +342,10 @@ export class CircuitToCanvasDrawer {
           })
         }
 
-        if (element.type === "pcb_plated_hole") {
+        if (
+          element.type === "pcb_plated_hole" &&
+          isOnCopperLayer(element, layer)
+        ) {
           drawPcbPlatedHole({
             ctx: this.ctx,
             hole: element as PcbPlatedHole,
@@ -339,7 +357,7 @@ export class CircuitToCanvasDrawer {
           })
         }
 
-        if (element.type === "pcb_via") {
+        if (element.type === "pcb_via" && isOnCopperLayer(element, layer)) {
           drawPcbVia({
             ctx: this.ctx,
             via: element as PcbVia,
@@ -469,7 +487,11 @@ export class CircuitToCanvasDrawer {
     for (const element of elements) {
       if (!shouldDrawElement(element, options)) continue
 
-      if (element.type === "pcb_plated_hole" && !renderTopSoldermask) {
+      if (
+        element.type === "pcb_plated_hole" &&
+        !renderTopSoldermask &&
+        isOnCopperLayer(element, layer)
+      ) {
         drawPcbPlatedHole({
           ctx: this.ctx,
           hole: element as PcbPlatedHole,
@@ -483,7 +505,11 @@ export class CircuitToCanvasDrawer {
         })
       }
 
-      if (element.type === "pcb_via" && !renderTopSoldermask) {
+      if (
+        element.type === "pcb_via" &&
+        !renderTopSoldermask &&
+        isOnCopperLayer(element, layer)
+      ) {
         drawPcbVia({
           ctx: this.ctx,
           via: element as PcbVia,

package/lib/drawer/elements/helper-functions/pcb-smtpad-drill-cutouts.ts

@@ -1,4 +1,10 @@
-import type { PcbHole, PcbPlatedHole, PcbSmtPad, PcbVia } from "circuit-json"
+import type {
+  PcbCutout,
+  PcbHole,
+  PcbPlatedHole,
+  PcbSmtPad,
+  PcbVia,
+} from "circuit-json"
 import type { Matrix } from "transformation-matrix"
 import { applyToPoint } from "transformation-matrix"
 import type { CanvasContext } from "../../types"
@@ -34,14 +40,21 @@ interface DrillCutoutRect {
   y: number
   width: number
   height: number
+  radius?: number
   rotation?: number
 }
 
+interface DrillCutoutPolygon {
+  shape: "polygon"
+  points: Array<{ x: number; y: number }>
+}
+
 type DrillCutout =
   | DrillCutoutCircle
   | DrillCutoutOval
   | DrillCutoutPill
   | DrillCutoutRect
+  | DrillCutoutPolygon
 
 interface Bounds {
   minX: number
@@ -55,6 +68,7 @@ export interface PcbSmtPadDrillCutoutParams {
   holes?: PcbHole[]
   platedHoles?: PcbPlatedHole[]
   vias?: PcbVia[]
+  cutouts?: PcbCutout[]
 }
 
 export function drawPadWithDrillCutouts(params: {
@@ -87,26 +101,28 @@ export function drawPadWithDrillCutouts(params: {
 export function getPadDrillCutouts(
   params: PcbSmtPadDrillCutoutParams,
 ): DrillCutout[] {
-  const { pad, holes = [], platedHoles = [], vias = [] } = params
+  const { pad, holes = [], platedHoles = [], vias = [], cutouts = [] } = params
   const padBounds = getPadBounds(pad)
   if (!padBounds) return []
 
-  const cutouts: DrillCutout[] = []
-
-  for (const hole of holes) {
-    const cutout = getHoleDrillCutout(hole)
+  const drillCutouts: DrillCutout[] = []
+  const addIfOverlapping = (cutout: DrillCutout | undefined): void => {
     if (cutout && boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout)
+      drillCutouts.push(cutout)
     }
   }
 
+  for (const cutout of cutouts) {
+    addIfOverlapping(getBoardCutout(cutout))
+  }
+
+  for (const hole of holes) {
+    addIfOverlapping(getHoleDrillCutout(hole))
+  }
+
   for (const platedHole of platedHoles) {
     if (!layersIncludePadLayer(platedHole.layers, pad.layer)) continue
-
-    const cutout = getPlatedHoleDrillCutout(platedHole)
-    if (cutout && boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout)
-    }
+    addIfOverlapping(getPlatedHoleDrillCutout(platedHole))
   }
 
   for (const via of vias) {
@@ -120,12 +136,10 @@ export function getPadDrillCutouts(
       y: via.y,
       radius,
     }
-    if (boundsOverlap(padBounds, getDrillCutoutBounds(cutout))) {
-      cutouts.push(cutout)
-    }
+    addIfOverlapping(cutout)
   }
 
-  return cutouts
+  return drillCutouts
 }
 
 function appendPadPath(
@@ -215,11 +229,17 @@ function appendDrillCutoutPath(
     return
   }
 
+  if (drillCutout.shape === "polygon") {
+    appendPolygonPath(ctx, drillCutout.points, realToCanvasMat)
+    return
+  }
+
   appendRectPath(ctx, {
     x: drillCutout.x,
     y: drillCutout.y,
     width: drillCutout.width,
     height: drillCutout.height,
+    radius: drillCutout.radius,
     rotation: drillCutout.rotation,
     realToCanvasMat,
   })
@@ -429,6 +449,10 @@ function getPadBounds(pad: PcbSmtPad): Bounds | undefined {
 }
 
 function getDrillCutoutBounds(cutout: DrillCutout): Bounds {
+  if (cutout.shape === "polygon") {
+    return getPointBounds(cutout.points)
+  }
+
   if (cutout.shape === "circle") {
     return boundsAroundCenter(cutout.x, cutout.y, cutout.radius, cutout.radius)
   }
@@ -455,6 +479,35 @@ function getDrillCutoutBounds(cutout: DrillCutout): Bounds {
   return boundsAroundCenter(cutout.x, cutout.y, halfWidth, halfHeight)
 }
 
+function getBoardCutout(cutout: PcbCutout): DrillCutout | undefined {
+  if (cutout.shape === "circle") {
+    if (cutout.radius <= 0) return
+    return {
+      shape: "circle",
+      x: cutout.center.x,
+      y: cutout.center.y,
+      radius: cutout.radius,
+    }
+  }
+
+  if (cutout.shape === "rect") {
+    if (cutout.width <= 0 || cutout.height <= 0) return
+    return {
+      shape: "rect",
+      x: cutout.center.x,
+      y: cutout.center.y,
+      width: cutout.width,
+      height: cutout.height,
+      radius: cutout.corner_radius,
+      rotation: cutout.rotation,
+    }
+  }
+
+  if (cutout.shape === "polygon" && cutout.points.length >= 3) {
+    return { shape: "polygon", points: cutout.points }
+  }
+}
+
 function getPointBounds(points: Array<{ x: number; y: number }>): Bounds {
   let minX = Infinity
   let maxX = -Infinity

package/lib/drawer/elements/pcb-plated-hole.ts

@@ -1,4 +1,4 @@
-import type { PcbPlatedHole } from "circuit-json"
+import type { LayerRef, PcbPlatedHole } from "circuit-json"
 import type { Matrix } from "transformation-matrix"
 import { drawCircle } from "../shapes/circle"
 import { drawOval } from "../shapes/oval"
@@ -15,7 +15,7 @@ export interface DrawPcbPlatedHoleParams {
   colorMap: PcbColorMap
   soldermaskMargin?: number
   drawSoldermask?: boolean
-  layer?: "top" | "bottom"
+  layer?: LayerRef
 }
 
 export function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void {

package/lib/drawer/elements/pcb-smtpad.ts

@@ -1,10 +1,16 @@
-import type { PcbHole, PcbPlatedHole, PcbSmtPad, PcbVia } from "circuit-json"
+import type {
+  PcbCutout,
+  PcbHole,
+  PcbPlatedHole,
+  PcbSmtPad,
+  PcbVia,
+} from "circuit-json"
 import type { Matrix } from "transformation-matrix"
-import type { PcbColorMap, CanvasContext } from "../types"
 import { drawCircle } from "../shapes/circle"
-import { drawRect } from "../shapes/rect"
 import { drawPill } from "../shapes/pill"
 import { drawPolygon } from "../shapes/polygon"
+import { drawRect } from "../shapes/rect"
+import type { CanvasContext, PcbColorMap } from "../types"
 import {
   drawPadWithDrillCutouts,
   getPadDrillCutouts,
@@ -18,6 +24,7 @@ export interface DrawPcbSmtPadParams {
   holes?: PcbHole[]
   platedHoles?: PcbPlatedHole[]
   vias?: PcbVia[]
+  cutouts?: PcbCutout[]
 }
 
 function layerToColor(layer: string, colorMap: PcbColorMap): string {

package/lib/drawer/elements/pcb-via.ts

@@ -1,4 +1,4 @@
-import type { PCBVia } from "circuit-json"
+import type { LayerRef, PCBVia } from "circuit-json"
 import type { Matrix } from "transformation-matrix"
 import { drawCircle } from "../shapes/circle"
 import type { CanvasContext, PcbColorMap } from "../types"
@@ -8,7 +8,7 @@ export interface DrawPcbViaParams {
   via: PCBVia
   realToCanvasMat: Matrix
   colorMap: PcbColorMap
-  layer?: "top" | "bottom"
+  layer?: LayerRef
 }
 
 export function drawPcbVia(params: DrawPcbViaParams): void {

package/lib/drawer/types.ts

@@ -1,3 +1,4 @@
+import type { LayerRef } from "circuit-json"
 import type { Matrix } from "transformation-matrix"
 
 /**
@@ -56,15 +57,7 @@ export interface CanvasContext {
   textAlign: "start" | "end" | "left" | "right" | "center"
 }
 
-export type CopperLayerName =
-  | "top"
-  | "bottom"
-  | "inner1"
-  | "inner2"
-  | "inner3"
-  | "inner4"
-  | "inner5"
-  | "inner6"
+export type CopperLayerName = LayerRef
 
 export type CopperColorMap = Record<CopperLayerName, string> & {
   [layer: string]: string
@@ -115,6 +108,8 @@ export const DEFAULT_PCB_COLOR_MAP: PcbColorMap = {
     inner4: "rgb(64, 224, 208)",
     inner5: "rgb(138, 43, 226)",
     inner6: "rgb(255, 105, 180)",
+    inner7: "rgb(232, 178, 167)",
+    inner8: "rgb(242, 237, 161)",
     bottom: "rgb(77, 127, 196)",
   },
   copperPour: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "circuit-to-canvas",
   "main": "dist/index.js",
-  "version": "0.0.110",
+  "version": "0.0.112",
   "type": "module",
   "scripts": {
     "build": "tsup-node ./lib/index.ts --format esm --dts",
@@ -13,13 +13,14 @@
     "@napi-rs/canvas": "^0.1.84",
     "@resvg/resvg-js": "^2.6.2",
     "@tscircuit/alphabet": "^0.0.23",
-    "@tscircuit/circuit-json-util": "^0.0.91",
+    "@tscircuit/circuit-json-util": "^0.0.99",
     "@tscircuit/math-utils": "^0.0.36",
     "@types/bun": "latest",
     "bun-match-svg": "^0.0.14",
-    "circuit-json": "^0.0.433",
+    "circuit-json": "^0.0.450",
     "circuit-json-to-connectivity-map": "^0.0.23",
-    "circuit-to-svg": "^0.0.324",
+    "circuit-to-svg": "^0.0.390",
+    "format-si-unit": "^0.0.7",
     "looks-same": "^10.0.1",
     "schematic-symbols": "^0.0.202",
     "tsup": "^8.5.1"

package/tests/elements/pcb-copper-pour-inner-layers.test.ts

@@ -1,9 +1,12 @@
 import { expect, test } from "bun:test"
 import { createCanvas } from "@napi-rs/canvas"
-import type { AnyCircuitElement } from "circuit-json"
+import type { AnyCircuitElement, LayerRef, PcbRenderLayer } from "circuit-json"
 import { CircuitToCanvasDrawer } from "../../lib/drawer"
 
-function renderCopperPourScene(elements: AnyCircuitElement[]): Buffer {
+function renderCopperPourScene(
+  elements: AnyCircuitElement[],
+  layer: LayerRef,
+): Buffer {
   const canvas = createCanvas(100, 100)
   const ctx = canvas.getContext("2d")
   const drawer = new CircuitToCanvasDrawer(ctx)
@@ -11,7 +14,9 @@ function renderCopperPourScene(elements: AnyCircuitElement[]): Buffer {
   ctx.fillStyle = "#1a1a1a"
   ctx.fillRect(0, 0, 100, 100)
 
-  drawer.drawElements(elements)
+  drawer.drawElements(elements, {
+    layers: [`${layer}_copper` as PcbRenderLayer],
+  })
 
   return canvas.toBuffer("image/png")
 }
@@ -23,6 +28,8 @@ const INNER_LAYERS = [
   "inner4",
   "inner5",
   "inner6",
+  "inner7",
+  "inner8",
 ] as const
 
 function createCopperPourWithTraceScene(
@@ -78,9 +85,10 @@ for (const layer of INNER_LAYERS) {
   test(`draw ${layer} copper pour with trace`, async () => {
     const elements = createCopperPourWithTraceScene(layer)
 
-    const withTrace = renderCopperPourScene(elements)
+    const withTrace = renderCopperPourScene(elements, layer)
     const withoutTrace = renderCopperPourScene(
       elements.filter((element) => element.type !== "pcb_trace"),
+      layer,
     )
 
     expect(Buffer.compare(withTrace, withoutTrace)).not.toBe(0)

package/tests/elements/pcb-smtpad-cutout.test.ts

@@ -0,0 +1,39 @@
+import { expect, test } from "bun:test"
+import { createCanvas } from "@napi-rs/canvas"
+import type { PcbCutout, PcbSmtPad } from "circuit-json"
+import { CircuitToCanvasDrawer } from "../../lib/drawer"
+
+test("cutout removes overlapping SMT pad copper", async () => {
+  const scale = 4
+  const canvas = createCanvas(100 * scale, 100 * scale)
+  const ctx = canvas.getContext("2d")
+  ctx.scale(scale, scale)
+  const drawer = new CircuitToCanvasDrawer(ctx)
+  drawer.configure({
+    colorOverrides: { drill: "rgba(0,0,0,0)" },
+  })
+
+  const pad: PcbSmtPad = {
+    type: "pcb_smtpad",
+    pcb_smtpad_id: "pad1",
+    shape: "rect",
+    layer: "top",
+    x: 50,
+    y: 50,
+    width: 40,
+    height: 20,
+  }
+  const cutout: PcbCutout = {
+    type: "pcb_cutout",
+    pcb_cutout_id: "cutout1",
+    shape: "circle",
+    center: { x: 50, y: 50 },
+    radius: 5,
+  }
+
+  drawer.drawElements([pad, cutout])
+
+  await expect(canvas.toBuffer("image/png")).toMatchPngSnapshot(
+    import.meta.path,
+  )
+})

package/tests/elements/pcb-via-inner-layer.test.ts

@@ -0,0 +1,36 @@
+import { expect, test } from "bun:test"
+import { createCanvas } from "@napi-rs/canvas"
+import type { PcbRenderLayer, PcbVia } from "circuit-json"
+import { CircuitToCanvasDrawer } from "../../lib/drawer"
+
+const renderViaLayer = (via: PcbVia | undefined, layer: PcbRenderLayer) => {
+  const canvas = createCanvas(100, 100)
+  const ctx = canvas.getContext("2d")
+  const drawer = new CircuitToCanvasDrawer(ctx)
+
+  ctx.fillStyle = "#1a1a1a"
+  ctx.fillRect(0, 0, 100, 100)
+  drawer.drawElements(via ? [via] : [], { layers: [layer] })
+
+  return canvas.toBuffer("image/png")
+}
+
+test("draw buried via only on layers in its span", async () => {
+  const via: PcbVia = {
+    type: "pcb_via",
+    pcb_via_id: "via_inner8",
+    x: 50,
+    y: 50,
+    outer_diameter: 40,
+    hole_diameter: 20,
+    layers: ["inner7", "inner8"],
+  }
+
+  const inner8 = renderViaLayer(via, "inner8_copper")
+  const inner6 = renderViaLayer(via, "inner6_copper")
+  const blank = renderViaLayer(undefined, "inner6_copper")
+
+  expect(Buffer.compare(inner8, blank)).not.toBe(0)
+  expect(Buffer.compare(inner6, blank)).toBe(0)
+  await expect(inner8).toMatchPngSnapshot(import.meta.path)
+})