circuit-to-canvas 0.0.49 → 0.0.50

package/dist/index.d.ts

@@ -327,7 +327,12 @@ declare function drawPcbSmtPad(params: DrawPcbSmtPadParams): void;
 declare function drawSoldermaskRingForRect(ctx: CanvasContext, center: {
     x: number;
     y: number;
-}, width: number, height: number, margin: number, borderRadius: number, rotation: number, realToCanvasMat: Matrix, soldermaskColor: string, padColor: string): void;
+}, width: number, height: number, margin: number, borderRadius: number, rotation: number, realToCanvasMat: Matrix, soldermaskColor: string, padColor: string, asymmetricMargins?: {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}): void;
 /**
  * Draws a soldermask ring for circular shapes with negative margin
  * (soldermask appears inside the pad boundary)

package/dist/index.js

@@ -253,12 +253,19 @@ function drawPolygon(params) {
 
 // lib/drawer/elements/soldermask-margin.ts
 import { applyToPoint as applyToPoint6 } from "transformation-matrix";
-function drawSoldermaskRingForRect(ctx, center, width, height, margin, borderRadius, rotation, realToCanvasMat, soldermaskColor, padColor) {
+function drawSoldermaskRingForRect(ctx, center, width, height, margin, borderRadius, rotation, realToCanvasMat, soldermaskColor, padColor, asymmetricMargins) {
   const [cx, cy] = applyToPoint6(realToCanvasMat, [center.x, center.y]);
   const scaledWidth = width * Math.abs(realToCanvasMat.a);
   const scaledHeight = height * Math.abs(realToCanvasMat.a);
-  const scaledMargin = Math.abs(margin) * Math.abs(realToCanvasMat.a);
   const scaledRadius = borderRadius * Math.abs(realToCanvasMat.a);
+  const ml = asymmetricMargins?.left ?? margin;
+  const mr = asymmetricMargins?.right ?? margin;
+  const mt = asymmetricMargins?.top ?? margin;
+  const mb = asymmetricMargins?.bottom ?? margin;
+  const scaledThicknessL = Math.max(0, -ml) * Math.abs(realToCanvasMat.a);
+  const scaledThicknessR = Math.max(0, -mr) * Math.abs(realToCanvasMat.a);
+  const scaledThicknessT = Math.max(0, -mt) * Math.abs(realToCanvasMat.a);
+  const scaledThicknessB = Math.max(0, -mb) * Math.abs(realToCanvasMat.a);
   ctx.save();
   ctx.translate(cx, cy);
   if (rotation !== 0) {
@@ -299,14 +306,23 @@ function drawSoldermaskRingForRect(ctx, center, width, height, margin, borderRad
   if (ctx.globalCompositeOperation !== void 0) {
     ctx.globalCompositeOperation = prevCompositeOp || "source-over";
   }
-  const innerWidth = scaledWidth - scaledMargin * 2;
-  const innerHeight = scaledHeight - scaledMargin * 2;
-  const innerRadius = Math.max(0, scaledRadius - scaledMargin);
+  const innerWidth = Math.max(
+    0,
+    scaledWidth - (scaledThicknessL + scaledThicknessR)
+  );
+  const innerHeight = Math.max(
+    0,
+    scaledHeight - (scaledThicknessT + scaledThicknessB)
+  );
+  const innerRadius = Math.max(
+    0,
+    scaledRadius - (scaledThicknessL + scaledThicknessR + scaledThicknessT + scaledThicknessB) / 4
+  );
   if (innerWidth > 0 && innerHeight > 0) {
     ctx.beginPath();
+    const x = -scaledWidth / 2 + scaledThicknessL;
+    const y = -scaledHeight / 2 + scaledThicknessT;
     if (innerRadius > 0) {
-      const x = -innerWidth / 2;
-      const y = -innerHeight / 2;
       const r = Math.min(innerRadius, innerWidth / 2, innerHeight / 2);
       ctx.moveTo(x + r, y);
       ctx.lineTo(x + innerWidth - r, y);
@@ -324,7 +340,7 @@ function drawSoldermaskRingForRect(ctx, center, width, height, margin, borderRad
       ctx.lineTo(x, y + r);
       ctx.arcTo(x, y, x + r, y, r);
     } else {
-      ctx.rect(-innerWidth / 2, -innerHeight / 2, innerWidth, innerHeight);
+      ctx.rect(x, y, innerWidth, innerHeight);
     }
     ctx.fillStyle = padColor;
     ctx.fill();
@@ -1324,24 +1340,40 @@ function getSoldermaskColor2(layer, colorMap) {
   return colorMap.soldermaskOverCopper[layer] ?? colorMap.soldermaskOverCopper.top;
 }
 function getBorderRadius(pad, margin = 0) {
-  return (pad.corner_radius ?? pad.rect_border_radius ?? 0) + margin;
+  let r = 0;
+  if (pad.shape === "rect" || pad.shape === "rotated_rect") {
+    r = pad.corner_radius ?? pad.rect_border_radius ?? 0;
+  }
+  return r + margin;
 }
 function drawPcbSmtPad(params) {
   const { ctx, pad, realToCanvasMat, colorMap } = params;
   const color = layerToColor(pad.layer, colorMap);
   const isCoveredWithSoldermask = pad.is_covered_with_solder_mask === true;
   const margin = isCoveredWithSoldermask ? 0 : pad.soldermask_margin ?? 0;
-  const hasSoldermask = !isCoveredWithSoldermask && pad.soldermask_margin !== void 0 && pad.soldermask_margin !== 0;
   const soldermaskRingColor = getSoldermaskColor2(pad.layer, colorMap);
   const positiveMarginColor = colorMap.substrate;
   const soldermaskOverlayColor = getSoldermaskColor2(pad.layer, colorMap);
+  const hasSoldermask = !isCoveredWithSoldermask && margin !== 0;
+  let ml = margin;
+  let mr = margin;
+  let mt = margin;
+  let mb = margin;
+  let hasAnySoldermask = hasSoldermask;
+  if (!isCoveredWithSoldermask && (pad.shape === "rect" || pad.shape === "rotated_rect")) {
+    ml = pad.soldermask_margin_left ?? pad.soldermask_margin ?? 0;
+    mr = pad.soldermask_margin_right ?? pad.soldermask_margin ?? 0;
+    mt = pad.soldermask_margin_top ?? pad.soldermask_margin ?? 0;
+    mb = pad.soldermask_margin_bottom ?? pad.soldermask_margin ?? 0;
+    hasAnySoldermask = ml !== 0 || mr !== 0 || mt !== 0 || mb !== 0;
+  }
   if (pad.shape === "rect") {
-    if (hasSoldermask && margin > 0) {
+    if (hasAnySoldermask && (ml > 0 || mr > 0 || mt > 0 || mb > 0)) {
       drawRect({
         ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width + margin * 2,
-        height: pad.height + margin * 2,
+        center: { x: pad.x + (mr - ml) / 2, y: pad.y + (mt - mb) / 2 },
+        width: pad.width + ml + mr,
+        height: pad.height + mt + mb,
         fill: positiveMarginColor,
         realToCanvasMat,
         borderRadius: getBorderRadius(pad)
@@ -1356,21 +1388,22 @@ function drawPcbSmtPad(params) {
       realToCanvasMat,
       borderRadius: getBorderRadius(pad)
     });
-    if (hasSoldermask && margin < 0) {
+    if (hasAnySoldermask && (ml < 0 || mr < 0 || mt < 0 || mb < 0)) {
       drawSoldermaskRingForRect(
         ctx,
         { x: pad.x, y: pad.y },
         pad.width,
         pad.height,
-        margin,
+        pad.soldermask_margin ?? 0,
         getBorderRadius(pad),
         0,
         realToCanvasMat,
         soldermaskRingColor,
-        color
+        color,
+        { left: ml, right: mr, top: mt, bottom: mb }
       );
     }
-    if (isCoveredWithSoldermask && margin === 0) {
+    if (isCoveredWithSoldermask) {
       drawRect({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -1384,12 +1417,17 @@ function drawPcbSmtPad(params) {
     return;
   }
   if (pad.shape === "rotated_rect") {
-    if (hasSoldermask && margin > 0) {
+    const radians = (pad.ccw_rotation ?? 0) * Math.PI / 180;
+    const dxLocal = (mr - ml) / 2;
+    const dyLocal = (mt - mb) / 2;
+    const dxGlobal = dxLocal * Math.cos(radians) - dyLocal * Math.sin(radians);
+    const dyGlobal = dxLocal * Math.sin(radians) + dyLocal * Math.cos(radians);
+    if (hasAnySoldermask && (ml > 0 || mr > 0 || mt > 0 || mb > 0)) {
       drawRect({
         ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width + margin * 2,
-        height: pad.height + margin * 2,
+        center: { x: pad.x + dxGlobal, y: pad.y + dyGlobal },
+        width: pad.width + ml + mr,
+        height: pad.height + mt + mb,
         fill: positiveMarginColor,
         realToCanvasMat,
         borderRadius: getBorderRadius(pad),
@@ -1406,21 +1444,22 @@ function drawPcbSmtPad(params) {
       borderRadius: getBorderRadius(pad),
       rotation: pad.ccw_rotation ?? 0
     });
-    if (hasSoldermask && margin < 0) {
+    if (hasAnySoldermask && (ml < 0 || mr < 0 || mt < 0 || mb < 0)) {
       drawSoldermaskRingForRect(
         ctx,
         { x: pad.x, y: pad.y },
         pad.width,
         pad.height,
-        margin,
+        pad.soldermask_margin ?? 0,
         getBorderRadius(pad),
         pad.ccw_rotation ?? 0,
         realToCanvasMat,
         soldermaskRingColor,
-        color
+        color,
+        { left: ml, right: mr, top: mt, bottom: mb }
       );
     }
-    if (isCoveredWithSoldermask && margin === 0) {
+    if (isCoveredWithSoldermask) {
       drawRect({
         ctx,
         center: { x: pad.x, y: pad.y },

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

@@ -36,11 +36,11 @@ function getSoldermaskColor(layer: string, colorMap: PcbColorMap): string {
 }
 
 function getBorderRadius(pad: PcbSmtPad, margin = 0): number {
-  return (
-    ((pad as { corner_radius?: number }).corner_radius ??
-      (pad as { rect_border_radius?: number }).rect_border_radius ??
-      0) + margin
-  )
+  let r = 0
+  if (pad.shape === "rect" || pad.shape === "rotated_rect") {
+    r = pad.corner_radius ?? pad.rect_border_radius ?? 0
+  }
+  return r + margin
 }
 
 export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
@@ -48,25 +48,40 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
 
   const color = layerToColor(pad.layer, colorMap)
   const isCoveredWithSoldermask = pad.is_covered_with_solder_mask === true
-  // If covered with soldermask, fully covered with no margin; otherwise use soldermask_margin if set
   const margin = isCoveredWithSoldermask ? 0 : (pad.soldermask_margin ?? 0)
-  const hasSoldermask =
-    !isCoveredWithSoldermask &&
-    pad.soldermask_margin !== undefined &&
-    pad.soldermask_margin !== 0
+
   const soldermaskRingColor = getSoldermaskColor(pad.layer, colorMap)
   const positiveMarginColor = colorMap.substrate
   const soldermaskOverlayColor = getSoldermaskColor(pad.layer, colorMap)
 
+  const hasSoldermask = !isCoveredWithSoldermask && margin !== 0
+
+  let ml = margin
+  let mr = margin
+  let mt = margin
+  let mb = margin
+  let hasAnySoldermask = hasSoldermask
+
+  if (
+    !isCoveredWithSoldermask &&
+    (pad.shape === "rect" || pad.shape === "rotated_rect")
+  ) {
+    ml = pad.soldermask_margin_left ?? pad.soldermask_margin ?? 0
+    mr = pad.soldermask_margin_right ?? pad.soldermask_margin ?? 0
+    mt = pad.soldermask_margin_top ?? pad.soldermask_margin ?? 0
+    mb = pad.soldermask_margin_bottom ?? pad.soldermask_margin ?? 0
+    hasAnySoldermask = ml !== 0 || mr !== 0 || mt !== 0 || mb !== 0
+  }
+
   // Draw the copper pad
   if (pad.shape === "rect") {
     // For positive margins, draw extended mask area first
-    if (hasSoldermask && margin > 0) {
+    if (hasAnySoldermask && (ml > 0 || mr > 0 || mt > 0 || mb > 0)) {
       drawRect({
         ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width + margin * 2,
-        height: pad.height + margin * 2,
+        center: { x: pad.x + (mr - ml) / 2, y: pad.y + (mt - mb) / 2 },
+        width: pad.width + ml + mr,
+        height: pad.height + mt + mb,
         fill: positiveMarginColor,
         realToCanvasMat,
         borderRadius: getBorderRadius(pad),
@@ -85,23 +100,24 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
     })
 
     // For negative margins, draw soldermask ring on top of the pad
-    if (hasSoldermask && margin < 0) {
+    if (hasAnySoldermask && (ml < 0 || mr < 0 || mt < 0 || mb < 0)) {
       drawSoldermaskRingForRect(
         ctx,
         { x: pad.x, y: pad.y },
         pad.width,
         pad.height,
-        margin,
+        pad.soldermask_margin ?? 0,
         getBorderRadius(pad),
         0,
         realToCanvasMat,
         soldermaskRingColor,
         color,
+        { left: ml, right: mr, top: mt, bottom: mb },
       )
     }
 
-    // If covered with soldermask and margin == 0 (treat as 0 positive margin), draw soldermaskOverCopper overlay
-    if (isCoveredWithSoldermask && margin === 0) {
+    // If covered with soldermask, draw soldermaskOverCopper overlay
+    if (isCoveredWithSoldermask) {
       drawRect({
         ctx,
         center: { x: pad.x, y: pad.y },
@@ -116,13 +132,19 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
   }
 
   if (pad.shape === "rotated_rect") {
+    const radians = ((pad.ccw_rotation ?? 0) * Math.PI) / 180
+    const dxLocal = (mr - ml) / 2
+    const dyLocal = (mt - mb) / 2
+    const dxGlobal = dxLocal * Math.cos(radians) - dyLocal * Math.sin(radians)
+    const dyGlobal = dxLocal * Math.sin(radians) + dyLocal * Math.cos(radians)
+
     // For positive margins, draw extended mask area first
-    if (hasSoldermask && margin > 0) {
+    if (hasAnySoldermask && (ml > 0 || mr > 0 || mt > 0 || mb > 0)) {
       drawRect({
         ctx,
-        center: { x: pad.x, y: pad.y },
-        width: pad.width + margin * 2,
-        height: pad.height + margin * 2,
+        center: { x: pad.x + dxGlobal, y: pad.y + dyGlobal },
+        width: pad.width + ml + mr,
+        height: pad.height + mt + mb,
         fill: positiveMarginColor,
         realToCanvasMat,
         borderRadius: getBorderRadius(pad),
@@ -143,23 +165,24 @@ export function drawPcbSmtPad(params: DrawPcbSmtPadParams): void {
     })
 
     // For negative margins, draw soldermask ring on top of the pad
-    if (hasSoldermask && margin < 0) {
+    if (hasAnySoldermask && (ml < 0 || mr < 0 || mt < 0 || mb < 0)) {
       drawSoldermaskRingForRect(
         ctx,
         { x: pad.x, y: pad.y },
         pad.width,
         pad.height,
-        margin,
+        pad.soldermask_margin ?? 0,
         getBorderRadius(pad),
         pad.ccw_rotation ?? 0,
         realToCanvasMat,
         soldermaskRingColor,
         color,
+        { left: ml, right: mr, top: mt, bottom: mb },
       )
     }
 
-    // If covered with soldermask and margin == 0 (treat as 0 positive margin), draw soldermaskOverCopper overlay
-    if (isCoveredWithSoldermask && margin === 0) {
+    // If covered with soldermask, draw soldermaskOverCopper overlay
+    if (isCoveredWithSoldermask) {
       drawRect({
         ctx,
         center: { x: pad.x, y: pad.y },

package/lib/drawer/elements/soldermask-margin.ts

@@ -17,13 +17,29 @@ export function drawSoldermaskRingForRect(
   realToCanvasMat: Matrix,
   soldermaskColor: string,
   padColor: string,
+  asymmetricMargins?: {
+    left: number
+    right: number
+    top: number
+    bottom: number
+  },
 ): void {
   const [cx, cy] = applyToPoint(realToCanvasMat, [center.x, center.y])
   const scaledWidth = width * Math.abs(realToCanvasMat.a)
   const scaledHeight = height * Math.abs(realToCanvasMat.a)
-  const scaledMargin = Math.abs(margin) * Math.abs(realToCanvasMat.a)
   const scaledRadius = borderRadius * Math.abs(realToCanvasMat.a)
 
+  const ml = asymmetricMargins?.left ?? margin
+  const mr = asymmetricMargins?.right ?? margin
+  const mt = asymmetricMargins?.top ?? margin
+  const mb = asymmetricMargins?.bottom ?? margin
+
+  // Thickness of the soldermask ring (only if negative margin)
+  const scaledThicknessL = Math.max(0, -ml) * Math.abs(realToCanvasMat.a)
+  const scaledThicknessR = Math.max(0, -mr) * Math.abs(realToCanvasMat.a)
+  const scaledThicknessT = Math.max(0, -mt) * Math.abs(realToCanvasMat.a)
+  const scaledThicknessB = Math.max(0, -mb) * Math.abs(realToCanvasMat.a)
+
   ctx.save()
   ctx.translate(cx, cy)
 
@@ -76,16 +92,31 @@ export function drawSoldermaskRingForRect(
     ctx.globalCompositeOperation = prevCompositeOp || "source-over"
   }
 
-  // Restore pad color in inner rectangle (reduced by margin)
-  const innerWidth = scaledWidth - scaledMargin * 2
-  const innerHeight = scaledHeight - scaledMargin * 2
-  const innerRadius = Math.max(0, scaledRadius - scaledMargin)
+  // Restore pad color in inner rectangle (reduced by margins)
+  const innerWidth = Math.max(
+    0,
+    scaledWidth - (scaledThicknessL + scaledThicknessR),
+  )
+  const innerHeight = Math.max(
+    0,
+    scaledHeight - (scaledThicknessT + scaledThicknessB),
+  )
+  const innerRadius = Math.max(
+    0,
+    scaledRadius -
+      (scaledThicknessL +
+        scaledThicknessR +
+        scaledThicknessT +
+        scaledThicknessB) /
+        4,
+  )
 
   if (innerWidth > 0 && innerHeight > 0) {
     ctx.beginPath()
+    const x = -scaledWidth / 2 + scaledThicknessL
+    const y = -scaledHeight / 2 + scaledThicknessT
+
     if (innerRadius > 0) {
-      const x = -innerWidth / 2
-      const y = -innerHeight / 2
       const r = Math.min(innerRadius, innerWidth / 2, innerHeight / 2)
 
       ctx.moveTo(x + r, y)
@@ -104,7 +135,7 @@ export function drawSoldermaskRingForRect(
       ctx.lineTo(x, y + r)
       ctx.arcTo(x, y, x + r, y, r)
     } else {
-      ctx.rect(-innerWidth / 2, -innerHeight / 2, innerWidth, innerHeight)
+      ctx.rect(x, y, innerWidth, innerHeight)
     }
 
     ctx.fillStyle = padColor

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "circuit-to-canvas",
   "main": "dist/index.js",
-  "version": "0.0.49",
+  "version": "0.0.50",
   "type": "module",
   "scripts": {
     "build": "tsup-node ./lib/index.ts --format esm --dts",
@@ -17,7 +17,7 @@
     "@tscircuit/math-utils": "^0.0.29",
     "@types/bun": "latest",
     "bun-match-svg": "^0.0.14",
-    "circuit-json": "^0.0.348",
+    "circuit-json": "^0.0.356",
     "circuit-json-to-connectivity-map": "^0.0.23",
     "circuit-to-svg": "^0.0.303",
     "looks-same": "^10.0.1",

package/tests/elements/pcb-smtpad-asymmetric-soldermask-margin.test.ts

@@ -0,0 +1,140 @@
+import { expect, test } from "bun:test"
+import { createCanvas } from "@napi-rs/canvas"
+import type { AnyCircuitElement } from "circuit-json"
+import { CircuitToCanvasDrawer } from "../../lib/drawer"
+
+test("draw smt pads with asymmetric soldermask margins", async () => {
+  const canvas = createCanvas(800, 600)
+  const ctx = canvas.getContext("2d")
+  const drawer = new CircuitToCanvasDrawer(ctx)
+
+  ctx.fillStyle = "#1a1a1a"
+  ctx.fillRect(0, 0, 800, 600)
+
+  const circuit: AnyCircuitElement[] = [
+    {
+      type: "pcb_board",
+      pcb_board_id: "board0",
+      center: { x: 0, y: 0 },
+      width: 14,
+      height: 10,
+      thickness: 1.6,
+      num_layers: 2,
+      material: "fr4",
+    },
+    // Rectangle with asymmetric positive margins
+    {
+      type: "pcb_smtpad",
+      pcb_smtpad_id: "pad_rect_pos_asym",
+      shape: "rect",
+      layer: "top",
+      x: -4,
+      y: 2,
+      width: 2,
+      height: 1,
+      soldermask_margin_left: 0.5,
+      soldermask_margin_right: 0.1,
+      soldermask_margin_top: 0.2,
+      soldermask_margin_bottom: 0.8,
+    },
+    // Rectangle with asymmetric negative margins
+    {
+      type: "pcb_smtpad",
+      pcb_smtpad_id: "pad_rect_neg_asym",
+      shape: "rect",
+      layer: "top",
+      x: -4,
+      y: -2,
+      width: 2,
+      height: 1.5,
+      soldermask_margin_left: -0.2,
+      soldermask_margin_right: -0.6,
+      soldermask_margin_top: -0.1,
+      soldermask_margin_bottom: -0.4,
+    },
+    // Rotated rectangle with asymmetric positive margins
+    {
+      type: "pcb_smtpad",
+      pcb_smtpad_id: "pad_rot_rect_pos_asym",
+      shape: "rotated_rect",
+      layer: "top",
+      x: 4,
+      y: 2,
+      width: 2,
+      height: 1,
+      ccw_rotation: 45,
+      soldermask_margin_left: 0.8,
+      soldermask_margin_right: 0.2,
+      soldermask_margin_top: 0.1,
+      soldermask_margin_bottom: 0.5,
+    },
+    // Rotated rectangle with asymmetric negative margins
+    {
+      type: "pcb_smtpad",
+      pcb_smtpad_id: "pad_rot_rect_neg_asym",
+      shape: "rotated_rect",
+      layer: "top",
+      x: 4,
+      y: -2,
+      width: 2,
+      height: 1.5,
+      ccw_rotation: 30,
+      soldermask_margin_left: -0.5,
+      soldermask_margin_right: -0.1,
+      soldermask_margin_top: -0.4,
+      soldermask_margin_bottom: -0.2,
+    },
+    // Labels
+    {
+      type: "pcb_silkscreen_text",
+      pcb_silkscreen_text_id: "text1",
+      pcb_component_id: "comp1",
+      layer: "top",
+      anchor_position: { x: -4, y: 3.5 },
+      anchor_alignment: "center",
+      text: "Rect Pos Asym",
+      font_size: 0.4,
+      font: "tscircuit2024",
+    },
+    {
+      type: "pcb_silkscreen_text",
+      pcb_silkscreen_text_id: "text2",
+      pcb_component_id: "comp1",
+      layer: "top",
+      anchor_position: { x: -4, y: -3.8 },
+      anchor_alignment: "center",
+      text: "Rect Neg Asym",
+      font_size: 0.4,
+      font: "tscircuit2024",
+    },
+    {
+      type: "pcb_silkscreen_text",
+      pcb_silkscreen_text_id: "text3",
+      pcb_component_id: "comp1",
+      layer: "top",
+      anchor_position: { x: 4, y: 3.8 },
+      anchor_alignment: "center",
+      text: "Rot Rect Pos Asym",
+      font_size: 0.4,
+      font: "tscircuit2024",
+    },
+    {
+      type: "pcb_silkscreen_text",
+      pcb_silkscreen_text_id: "text4",
+      pcb_component_id: "comp1",
+      layer: "top",
+      anchor_position: { x: 4, y: -3.8 },
+      anchor_alignment: "center",
+      text: "Rot Rect Neg Asym",
+      font_size: 0.4,
+      font: "tscircuit2024",
+    },
+  ]
+
+  drawer.setCameraBounds({ minX: -7, maxX: 7, minY: -5, maxY: 5 })
+  drawer.drawElements(circuit)
+
+  await expect(canvas.toBuffer("image/png")).toMatchPngSnapshot(
+    import.meta.path,
+  )
+})

package/tests/elements/pcb-smtpad-soldermask-margin.test.ts

@@ -1,5 +1,6 @@
 import { expect, test } from "bun:test"
 import { createCanvas } from "@napi-rs/canvas"
+import type { AnyCircuitElement } from "circuit-json"
 import { CircuitToCanvasDrawer } from "../../lib/drawer"
 
 test("draw smt pads with positive and negative soldermask margins", async () => {
@@ -10,13 +11,16 @@ test("draw smt pads with positive and negative soldermask margins", async () =>
   ctx.fillStyle = "#1a1a1a"
   ctx.fillRect(0, 0, 800, 600)
 
-  const circuit: any = [
+  const circuit: AnyCircuitElement[] = [
     {
       type: "pcb_board",
       pcb_board_id: "board0",
       center: { x: 0, y: 0 },
       width: 14,
       height: 10,
+      thickness: 1.6,
+      num_layers: 2,
+      material: "fr4",
     },
     // Rectangle with positive margin (mask extends beyond pad)
     {
@@ -94,57 +98,69 @@ test("draw smt pads with positive and negative soldermask margins", async () =>
     {
       type: "pcb_silkscreen_text",
       pcb_silkscreen_text_id: "text_rect_pos",
+      pcb_component_id: "comp1",
       layer: "top",
       anchor_position: { x: -4, y: 3.2 },
       anchor_alignment: "center",
       text: "+0.2mm",
       font_size: 0.4,
+      font: "tscircuit2024",
     },
     {
       type: "pcb_silkscreen_text",
       pcb_silkscreen_text_id: "text_circle_pos",
+      pcb_component_id: "comp1",
       layer: "top",
       anchor_position: { x: 0, y: 3.2 },
       anchor_alignment: "center",
       text: "+0.15mm",
       font_size: 0.4,
+      font: "tscircuit2024",
     },
     {
       type: "pcb_silkscreen_text",
       pcb_silkscreen_text_id: "text_pill_pos",
+      pcb_component_id: "comp1",
       layer: "top",
       anchor_position: { x: 4, y: 3.2 },
       anchor_alignment: "center",
       text: "+0.1mm",
       font_size: 0.4,
+      font: "tscircuit2024",
     },
     // Silkscreen labels for negative margin pads (bottom row)
     {
       type: "pcb_silkscreen_text",
       pcb_silkscreen_text_id: "text_rect_neg",
+      pcb_component_id: "comp1",
       layer: "top",
       anchor_position: { x: -4, y: -3.2 },
       anchor_alignment: "center",
       text: "-0.15mm",
       font_size: 0.4,
+      font: "tscircuit2024",
     },
     {
       type: "pcb_silkscreen_text",
       pcb_silkscreen_text_id: "text_circle_neg",
+      pcb_component_id: "comp1",
       layer: "top",
       anchor_position: { x: 0, y: -3.2 },
       anchor_alignment: "center",
       text: "-0.2mm",
       font_size: 0.4,
+      font: "tscircuit2024",
     },
     {
       type: "pcb_silkscreen_text",
       pcb_silkscreen_text_id: "text_pill_neg",
+      pcb_component_id: "comp1",
       layer: "top",
       anchor_position: { x: 4, y: -3.2 },
       anchor_alignment: "center",
       text: "-0.12mm",
       font_size: 0.4,
+      font: "tscircuit2024",
     },
   ]