@tscircuit/cli 0.1.1480 → 0.1.1482

package/dist/lib/index.js

@@ -65808,7 +65808,7 @@ var getNodeHandler = (winterSpec, { port, middleware = [] }) => {
   }));
 };
 // package.json
-var version = "0.1.1479";
+var version = "0.1.1481";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -65846,7 +65846,7 @@ var package_default = {
     "circuit-json": "^0.0.425",
     "circuit-json-to-bom-csv": "^0.0.7",
     "circuit-json-to-gerber": "^0.0.51",
-    "circuit-json-to-kicad": "0.0.137",
+    "circuit-json-to-kicad": "0.0.150",
     "circuit-json-to-pnp-csv": "^0.0.7",
     "circuit-json-to-readable-netlist": "^0.0.15",
     "circuit-json-to-spice": "^0.0.10",
@@ -68485,12 +68485,466 @@ import {
 import { KicadPcb as KicadPcb2 } from "kicadts";
 import { cju as cju2 } from "@tscircuit/circuit-json-util";
 import { compose as compose6, translate as translate6, scale as scale4 } from "transformation-matrix";
+
+// node_modules/earcut/src/earcut.js
+function earcut(data, holeIndices, dim = 2) {
+  const hasHoles = holeIndices && holeIndices.length;
+  const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+  let outerNode = linkedList(data, 0, outerLen, dim, true);
+  const triangles = [];
+  if (!outerNode || outerNode.next === outerNode.prev)
+    return triangles;
+  let minX, minY, invSize;
+  if (hasHoles)
+    outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+  if (data.length > 80 * dim) {
+    minX = data[0];
+    minY = data[1];
+    let maxX = minX;
+    let maxY = minY;
+    for (let i = dim;i < outerLen; i += dim) {
+      const x = data[i];
+      const y = data[i + 1];
+      if (x < minX)
+        minX = x;
+      if (y < minY)
+        minY = y;
+      if (x > maxX)
+        maxX = x;
+      if (y > maxY)
+        maxY = y;
+    }
+    invSize = Math.max(maxX - minX, maxY - minY);
+    invSize = invSize !== 0 ? 32767 / invSize : 0;
+  }
+  earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+  return triangles;
+}
+function linkedList(data, start, end, dim, clockwise) {
+  let last;
+  if (clockwise === signedArea(data, start, end, dim) > 0) {
+    for (let i = start;i < end; i += dim)
+      last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+  } else {
+    for (let i = end - dim;i >= start; i -= dim)
+      last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+  }
+  if (last && equals(last, last.next)) {
+    removeNode(last);
+    last = last.next;
+  }
+  return last;
+}
+function filterPoints(start, end) {
+  if (!start)
+    return start;
+  if (!end)
+    end = start;
+  let p = start, again;
+  do {
+    again = false;
+    if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+      removeNode(p);
+      p = end = p.prev;
+      if (p === p.next)
+        break;
+      again = true;
+    } else {
+      p = p.next;
+    }
+  } while (again || p !== end);
+  return end;
+}
+function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+  if (!ear)
+    return;
+  if (!pass && invSize)
+    indexCurve(ear, minX, minY, invSize);
+  let stop = ear;
+  while (ear.prev !== ear.next) {
+    const prev = ear.prev;
+    const next = ear.next;
+    if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+      triangles.push(prev.i, ear.i, next.i);
+      removeNode(ear);
+      ear = next.next;
+      stop = next.next;
+      continue;
+    }
+    ear = next;
+    if (ear === stop) {
+      if (!pass) {
+        earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+      } else if (pass === 1) {
+        ear = cureLocalIntersections(filterPoints(ear), triangles);
+        earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+      } else if (pass === 2) {
+        splitEarcut(ear, triangles, dim, minX, minY, invSize);
+      }
+      break;
+    }
+  }
+}
+function isEar(ear) {
+  const a = ear.prev, b = ear, c = ear.next;
+  if (area(a, b, c) >= 0)
+    return false;
+  const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+  const x0 = Math.min(ax, bx, cx), y0 = Math.min(ay, by, cy), x1 = Math.max(ax, bx, cx), y1 = Math.max(ay, by, cy);
+  let p = c.next;
+  while (p !== a) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      return false;
+    p = p.next;
+  }
+  return true;
+}
+function isEarHashed(ear, minX, minY, invSize) {
+  const a = ear.prev, b = ear, c = ear.next;
+  if (area(a, b, c) >= 0)
+    return false;
+  const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+  const x0 = Math.min(ax, bx, cx), y0 = Math.min(ay, by, cy), x1 = Math.max(ax, bx, cx), y1 = Math.max(ay, by, cy);
+  const minZ = zOrder(x0, y0, minX, minY, invSize), maxZ = zOrder(x1, y1, minX, minY, invSize);
+  let { prevZ: p, nextZ: n } = ear;
+  while (p && p.z >= minZ && n && n.z <= maxZ) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      return false;
+    p = p.prevZ;
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+      return false;
+    n = n.nextZ;
+  }
+  while (p && p.z >= minZ) {
+    if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      return false;
+    p = p.prevZ;
+  }
+  while (n && n.z <= maxZ) {
+    if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+      return false;
+    n = n.nextZ;
+  }
+  return true;
+}
+function cureLocalIntersections(start, triangles) {
+  let p = start;
+  do {
+    const a = p.prev, b = p.next.next;
+    if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+      triangles.push(a.i, p.i, b.i);
+      removeNode(p);
+      removeNode(p.next);
+      p = start = b;
+    }
+    p = p.next;
+  } while (p !== start);
+  return filterPoints(p);
+}
+function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+  let a = start;
+  do {
+    let b = a.next.next;
+    while (b !== a.prev) {
+      if (a.i !== b.i && isValidDiagonal(a, b)) {
+        let c = splitPolygon(a, b);
+        a = filterPoints(a, a.next);
+        c = filterPoints(c, c.next);
+        earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+        earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+        return;
+      }
+      b = b.next;
+    }
+    a = a.next;
+  } while (a !== start);
+}
+function eliminateHoles(data, holeIndices, outerNode, dim) {
+  const queue = [];
+  for (let i = 0, len = holeIndices.length;i < len; i++) {
+    const start = holeIndices[i] * dim;
+    const end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+    const list = linkedList(data, start, end, dim, false);
+    if (list === list.next)
+      list.steiner = true;
+    queue.push(getLeftmost(list));
+  }
+  queue.sort(compareXYSlope);
+  for (let i = 0;i < queue.length; i++) {
+    outerNode = eliminateHole(queue[i], outerNode);
+  }
+  return outerNode;
+}
+function compareXYSlope(a, b) {
+  let result = a.x - b.x;
+  if (result === 0) {
+    result = a.y - b.y;
+    if (result === 0) {
+      const aSlope = (a.next.y - a.y) / (a.next.x - a.x);
+      const bSlope = (b.next.y - b.y) / (b.next.x - b.x);
+      result = aSlope - bSlope;
+    }
+  }
+  return result;
+}
+function eliminateHole(hole, outerNode) {
+  const bridge = findHoleBridge(hole, outerNode);
+  if (!bridge) {
+    return outerNode;
+  }
+  const bridgeReverse = splitPolygon(bridge, hole);
+  filterPoints(bridgeReverse, bridgeReverse.next);
+  return filterPoints(bridge, bridge.next);
+}
+function findHoleBridge(hole, outerNode) {
+  let p = outerNode;
+  const hx = hole.x;
+  const hy = hole.y;
+  let qx = -Infinity;
+  let m;
+  if (equals(hole, p))
+    return p;
+  do {
+    if (equals(hole, p.next))
+      return p.next;
+    else if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+      const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+      if (x <= hx && x > qx) {
+        qx = x;
+        m = p.x < p.next.x ? p : p.next;
+        if (x === hx)
+          return m;
+      }
+    }
+    p = p.next;
+  } while (p !== outerNode);
+  if (!m)
+    return null;
+  const stop = m;
+  const mx = m.x;
+  const my = m.y;
+  let tanMin = Infinity;
+  p = m;
+  do {
+    if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+      const tan = Math.abs(hy - p.y) / (hx - p.x);
+      if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+        m = p;
+        tanMin = tan;
+      }
+    }
+    p = p.next;
+  } while (p !== stop);
+  return m;
+}
+function sectorContainsSector(m, p) {
+  return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+}
+function indexCurve(start, minX, minY, invSize) {
+  let p = start;
+  do {
+    if (p.z === 0)
+      p.z = zOrder(p.x, p.y, minX, minY, invSize);
+    p.prevZ = p.prev;
+    p.nextZ = p.next;
+    p = p.next;
+  } while (p !== start);
+  p.prevZ.nextZ = null;
+  p.prevZ = null;
+  sortLinked(p);
+}
+function sortLinked(list) {
+  let numMerges;
+  let inSize = 1;
+  do {
+    let p = list;
+    let e;
+    list = null;
+    let tail = null;
+    numMerges = 0;
+    while (p) {
+      numMerges++;
+      let q = p;
+      let pSize = 0;
+      for (let i = 0;i < inSize; i++) {
+        pSize++;
+        q = q.nextZ;
+        if (!q)
+          break;
+      }
+      let qSize = inSize;
+      while (pSize > 0 || qSize > 0 && q) {
+        if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+          e = p;
+          p = p.nextZ;
+          pSize--;
+        } else {
+          e = q;
+          q = q.nextZ;
+          qSize--;
+        }
+        if (tail)
+          tail.nextZ = e;
+        else
+          list = e;
+        e.prevZ = tail;
+        tail = e;
+      }
+      p = q;
+    }
+    tail.nextZ = null;
+    inSize *= 2;
+  } while (numMerges > 1);
+  return list;
+}
+function zOrder(x, y, minX, minY, invSize) {
+  x = (x - minX) * invSize | 0;
+  y = (y - minY) * invSize | 0;
+  x = (x | x << 8) & 16711935;
+  x = (x | x << 4) & 252645135;
+  x = (x | x << 2) & 858993459;
+  x = (x | x << 1) & 1431655765;
+  y = (y | y << 8) & 16711935;
+  y = (y | y << 4) & 252645135;
+  y = (y | y << 2) & 858993459;
+  y = (y | y << 1) & 1431655765;
+  return x | y << 1;
+}
+function getLeftmost(start) {
+  let p = start, leftmost = start;
+  do {
+    if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y)
+      leftmost = p;
+    p = p.next;
+  } while (p !== start);
+  return leftmost;
+}
+function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+  return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+}
+function pointInTriangleExceptFirst(ax, ay, bx, by, cx, cy, px, py) {
+  return !(ax === px && ay === py) && pointInTriangle(ax, ay, bx, by, cx, cy, px, py);
+}
+function isValidDiagonal(a, b) {
+  return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (area(a.prev, a, b.prev) || area(a, b.prev, b)) || equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+}
+function area(p, q, r) {
+  return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+}
+function equals(p1, p2) {
+  return p1.x === p2.x && p1.y === p2.y;
+}
+function intersects(p1, q1, p2, q2) {
+  const o1 = sign(area(p1, q1, p2));
+  const o2 = sign(area(p1, q1, q2));
+  const o3 = sign(area(p2, q2, p1));
+  const o4 = sign(area(p2, q2, q1));
+  if (o1 !== o2 && o3 !== o4)
+    return true;
+  if (o1 === 0 && onSegment(p1, p2, q1))
+    return true;
+  if (o2 === 0 && onSegment(p1, q2, q1))
+    return true;
+  if (o3 === 0 && onSegment(p2, p1, q2))
+    return true;
+  if (o4 === 0 && onSegment(p2, q1, q2))
+    return true;
+  return false;
+}
+function onSegment(p, q, r) {
+  return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+}
+function sign(num) {
+  return num > 0 ? 1 : num < 0 ? -1 : 0;
+}
+function intersectsPolygon(a, b) {
+  let p = a;
+  do {
+    if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b))
+      return true;
+    p = p.next;
+  } while (p !== a);
+  return false;
+}
+function locallyInside(a, b) {
+  return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+}
+function middleInside(a, b) {
+  let p = a;
+  let inside = false;
+  const px = (a.x + b.x) / 2;
+  const py = (a.y + b.y) / 2;
+  do {
+    if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+      inside = !inside;
+    p = p.next;
+  } while (p !== a);
+  return inside;
+}
+function splitPolygon(a, b) {
+  const a2 = createNode(a.i, a.x, a.y), b2 = createNode(b.i, b.x, b.y), an = a.next, bp = b.prev;
+  a.next = b;
+  b.prev = a;
+  a2.next = an;
+  an.prev = a2;
+  b2.next = a2;
+  a2.prev = b2;
+  bp.next = b2;
+  b2.prev = bp;
+  return b2;
+}
+function insertNode(i, x, y, last) {
+  const p = createNode(i, x, y);
+  if (!last) {
+    p.prev = p;
+    p.next = p;
+  } else {
+    p.next = last.next;
+    p.prev = last;
+    last.next.prev = p;
+    last.next = p;
+  }
+  return p;
+}
+function removeNode(p) {
+  p.next.prev = p.prev;
+  p.prev.next = p.next;
+  if (p.prevZ)
+    p.prevZ.nextZ = p.nextZ;
+  if (p.nextZ)
+    p.nextZ.prevZ = p.prevZ;
+}
+function createNode(i, x, y) {
+  return {
+    i,
+    x,
+    y,
+    prev: null,
+    next: null,
+    z: 0,
+    prevZ: null,
+    nextZ: null,
+    steiner: false
+  };
+}
+function signedArea(data, start, end, dim) {
+  let sum = 0;
+  for (let i = start, j = end - dim;i < end; i += dim) {
+    sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+    j = i;
+  }
+  return sum;
+}
+
+// node_modules/circuit-json-to-kicad/dist/index.js
 import {
+  Layer,
   Pts as Pts3,
   Xy as Xy3,
   Zone,
   ZoneConnectPads,
   ZoneFill,
+  ZoneFilledPolygon,
   ZoneHatch,
   ZonePolygon
 } from "kicadts";
@@ -68576,7 +69030,7 @@ import { Via, ViaNet } from "kicadts";
 import { applyToPoint as applyToPoint18 } from "transformation-matrix";
 import { Footprint as Footprint4 } from "kicadts";
 import { applyToPoint as applyToPoint19 } from "transformation-matrix";
-import { GrLine } from "kicadts";
+import { GrCircle, GrLine, GrPoly } from "kicadts";
 import {
   At as At2,
   GrText,
@@ -68585,7 +69039,7 @@ import {
   TextEffectsJustify as TextEffectsJustify3
 } from "kicadts";
 import { applyToPoint as applyToPoint20 } from "transformation-matrix";
-import { applyToPoint as applyToPoint22 } from "transformation-matrix";
+import { applyToPoint as applyToPoint22, rotate as rotate9 } from "transformation-matrix";
 import {
   GrText as GrText2,
   TextEffects as TextEffects11,
@@ -68730,8 +69184,9 @@ function getReferencePrefixForComponent(sourceComponent) {
 }
 function getReferenceDesignator(sourceComponent) {
   const name = sourceComponent?.name;
-  if (isReferenceDesignator(name)) {
-    return name.trim();
+  const trimmedName = name?.trim();
+  if (trimmedName) {
+    return trimmedName;
   }
   const prefix = getReferencePrefixForComponent(sourceComponent);
   return `${prefix}?`;
@@ -70329,6 +70784,8 @@ function generateDeterministicUuid(data) {
   const hash = simpleHash(data);
   return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
 }
+var isPcbCopperPour = (element) => element.type === "pcb_copper_pour";
+var getCopperPours = (circuitJson) => circuitJson.filter(isPcbCopperPour);
 var getCopperPourNetInfo = (pour, ctx) => {
   let connectivityKey = pour.source_net_id;
   if (connectivityKey) {
@@ -70339,19 +70796,13 @@ var getCopperPourNetInfo = (pour, ctx) => {
     return;
   return ctx.pcbNetMap?.get(connectivityKey);
 };
-var getRingPoints = (ring, c2kMatPcb) => {
-  return (ring.vertices ?? []).map((point) => {
-    const transformedPoint = applyToPoint8(c2kMatPcb, point);
-    return new Xy3(transformedPoint.x, transformedPoint.y);
-  });
-};
-var getPolygonPoints = (points, c2kMatPcb) => {
+var convertPointsToKicadXy = (points, c2kMatPcb) => {
   return (points ?? []).map((point) => {
     const transformedPoint = applyToPoint8(c2kMatPcb, point);
     return new Xy3(transformedPoint.x, transformedPoint.y);
   });
 };
-var rotatePointsToTopRight = (points) => {
+var rotateRingToStartAtTopRight = (points) => {
   if (points.length < 2)
     return points;
   let startIndex = 0;
@@ -70366,6 +70817,26 @@ var rotatePointsToTopRight = (points) => {
   }
   return [...points.slice(startIndex), ...points.slice(0, startIndex)];
 };
+var removeConsecutiveDuplicatePoints = (points) => {
+  const dedupedPoints = [];
+  for (const point of points) {
+    const lastPoint = dedupedPoints[dedupedPoints.length - 1];
+    if (lastPoint?.x === point.x && lastPoint.y === point.y) {
+      continue;
+    }
+    dedupedPoints.push(point);
+  }
+  return dedupedPoints;
+};
+var removeRepeatedClosingPoint = (points) => {
+  const dedupedPoints = [...points];
+  const firstPoint = dedupedPoints[0];
+  const lastPoint = dedupedPoints[dedupedPoints.length - 1];
+  if (firstPoint && lastPoint && dedupedPoints.length > 1 && firstPoint.x === lastPoint.x && firstPoint.y === lastPoint.y) {
+    dedupedPoints.pop();
+  }
+  return dedupedPoints;
+};
 var getRectRingPoints = (pour, c2kMatPcb) => {
   const ccwRotationDegrees = pour.rotation ?? 0;
   const cornerTransform = compose3(translate3(pour.center.x, pour.center.y), rotate(ccwRotationDegrees * Math.PI / 180));
@@ -70377,17 +70848,87 @@ var getRectRingPoints = (pour, c2kMatPcb) => {
     { x: halfWidth, y: halfHeight },
     { x: -halfWidth, y: halfHeight }
   ].map((corner) => applyToPoint8(cornerTransform, corner));
-  return rotatePointsToTopRight(getPolygonPoints(corners, c2kMatPcb));
+  return convertPointsToKicadXy(corners, c2kMatPcb);
+};
+var getPolygonRingPoints = (pour, c2kMatPcb) => removeRepeatedClosingPoint(removeConsecutiveDuplicatePoints(rotateRingToStartAtTopRight(convertPointsToKicadXy(pour.points, c2kMatPcb))));
+var getBrepZoneRings = (pour, c2kMatPcb) => [
+  removeRepeatedClosingPoint(removeConsecutiveDuplicatePoints(rotateRingToStartAtTopRight(convertPointsToKicadXy(pour.brep_shape.outer_ring.vertices, c2kMatPcb)))),
+  pour.brep_shape.inner_rings.map((ring) => removeRepeatedClosingPoint(removeConsecutiveDuplicatePoints(rotateRingToStartAtTopRight(convertPointsToKicadXy(ring.vertices, c2kMatPcb))))).filter((ringPoints) => ringPoints.length >= 3)
+];
+var getCopperPourZoneRings = (pour, c2kMatPcb) => {
+  switch (pour.shape) {
+    case "rect":
+      return [
+        removeRepeatedClosingPoint(removeConsecutiveDuplicatePoints(rotateRingToStartAtTopRight(getRectRingPoints(pour, c2kMatPcb)))),
+        []
+      ];
+    case "polygon":
+      return [getPolygonRingPoints(pour, c2kMatPcb), []];
+    case "brep":
+      return getBrepZoneRings(pour, c2kMatPcb);
+  }
 };
-var getCopperPourPolygonPoints = (pour, c2kMatPcb) => {
-  if (pour.shape === "rect") {
-    return getRectRingPoints(pour, c2kMatPcb);
+var createZonePolygons = (outerRing, innerRings) => {
+  const polygons = [];
+  if (outerRing.length >= 3) {
+    polygons.push(new ZonePolygon(new Pts3(outerRing)));
   }
-  if (pour.shape === "polygon") {
-    return rotatePointsToTopRight(getPolygonPoints(pour.points, c2kMatPcb));
+  for (const innerRing of innerRings) {
+    if (innerRing.length < 3)
+      continue;
+    polygons.push(new ZonePolygon(new Pts3(innerRing)));
   }
-  const outerRing = pour.brep_shape?.outer_ring;
-  return outerRing ? rotatePointsToTopRight(getRingPoints(outerRing, c2kMatPcb)) : [];
+  return polygons;
+};
+var getTriangleArea = (a, b, c) => Math.abs((a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y)) / 2);
+var createZoneFilledPolygons = (outerRing, innerRings, kicadLayer) => {
+  if (outerRing.length < 3) {
+    return [];
+  }
+  const layer = new Layer([kicadLayer]);
+  if (innerRings.length === 0) {
+    return [
+      new ZoneFilledPolygon({
+        layer,
+        pts: new Pts3(outerRing)
+      })
+    ];
+  }
+  const flattenedPoints = [];
+  const holeIndices = [];
+  let pointIndex = 0;
+  const addRing = (ring) => {
+    for (const point of ring) {
+      flattenedPoints.push(point.x, point.y);
+    }
+    pointIndex += ring.length;
+  };
+  addRing(outerRing);
+  for (const innerRing of innerRings) {
+    holeIndices.push(pointIndex);
+    addRing(innerRing);
+  }
+  const triangleIndices = earcut(flattenedPoints, holeIndices, 2);
+  const filledPolygons = [];
+  for (let i = 0;i < triangleIndices.length; i += 3) {
+    const trianglePoints = [];
+    for (let offset = 0;offset < 3; offset++) {
+      const pointOffset = triangleIndices[i + offset] * 2;
+      const x = flattenedPoints[pointOffset];
+      const y = flattenedPoints[pointOffset + 1];
+      if (x === undefined || y === undefined)
+        continue;
+      trianglePoints.push(new Xy3(x, y));
+    }
+    if (trianglePoints.length !== 3 || getTriangleArea(trianglePoints[0], trianglePoints[1], trianglePoints[2]) === 0) {
+      continue;
+    }
+    filledPolygons.push(new ZoneFilledPolygon({
+      layer,
+      pts: new Pts3(trianglePoints)
+    }));
+  }
+  return filledPolygons;
 };
 var AddCopperPoursStage = class extends ConverterStage {
   _step() {
@@ -70398,19 +70939,18 @@ var AddCopperPoursStage = class extends ConverterStage {
     if (!c2kMatPcb) {
       throw new Error("PCB transformation matrix not initialized in context");
     }
-    const copperPours = this.ctx.db.pcb_copper_pour?.list();
-    for (const pour of copperPours ?? []) {
-      const polygonPoints = getCopperPourPolygonPoints(pour, c2kMatPcb);
-      if (polygonPoints.length < 3)
+    const copperPours = getCopperPours(this.input);
+    for (const pour of copperPours) {
+      const [outerRing, innerRings] = getCopperPourZoneRings(pour, c2kMatPcb);
+      if (outerRing.length < 3)
         continue;
       const netInfo = getCopperPourNetInfo(pour, this.ctx);
       const kicadLayer = getKicadLayer(pour.layer);
-      const polygonPts = new Pts3(polygonPoints);
       const zone = new Zone({
         net: netInfo?.id ?? 0,
         netName: netInfo?.name ?? "",
         layer: kicadLayer,
-        uuid: generateDeterministicUuid(`zone:${pour.pcb_copper_pour_id ?? ""}`),
+        uuid: generateDeterministicUuid(`zone:${pour.pcb_copper_pour_id}`),
         hatch: new ZoneHatch("edge", 0.5),
         connectPads: new ZoneConnectPads({ enabled: true, clearance: 0.15 }),
         minThickness: 0.25,
@@ -70418,9 +70958,11 @@ var AddCopperPoursStage = class extends ConverterStage {
         fill: new ZoneFill({
           filled: true,
           thermalGap: 0.5,
-          thermalBridgeWidth: 0.5
+          thermalBridgeWidth: 0.5,
+          islandRemovalMode: 0
         }),
-        polygons: [new ZonePolygon(polygonPts)]
+        polygons: createZonePolygons(outerRing, innerRings),
+        filledPolygons: createZoneFilledPolygons(outerRing, innerRings, kicadLayer)
       });
       const zones = kicadPcb.zones;
       zones.push(zone);
@@ -71090,7 +71632,8 @@ function convertCourtyardRects(courtyardRects, componentCenter) {
   }
   return fpRects;
 }
-function convertCourtyardOutlines(courtyardOutlines, componentCenter, componentRotation = 0) {
+function convertCourtyardOutlines(params2) {
+  const { courtyardOutlines, componentCenter, componentRotation = 0 } = params2;
   const fpPolys = [];
   const cj2kicadMatrix = compose4(componentRotation !== 0 ? rotate2(componentRotation * Math.PI / 180) : { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 }, scale2(1, -1), translate4(-componentCenter.x, -componentCenter.y));
   for (const outline of courtyardOutlines) {
@@ -71161,7 +71704,13 @@ function createFpTextFromCircuitJson({
     effects: textEffects
   });
 }
-function convertSilkscreenTexts(silkscreenTexts, componentCenter, componentRotation, sourceComponentName) {
+function convertSilkscreenTexts(params2) {
+  const {
+    silkscreenTexts,
+    componentCenter,
+    componentRotation,
+    sourceComponentName
+  } = params2;
   const fpTexts = [];
   for (const textElement of silkscreenTexts) {
     const fpText = createFpTextFromCircuitJson({
@@ -71217,7 +71766,8 @@ function convertSilkscreenPaths(silkscreenPaths, { componentCenter, componentRot
   }
   return fpLines;
 }
-function convertNoteTexts(noteTexts, componentCenter, componentRotation) {
+function convertNoteTexts(params2) {
+  const { noteTexts, componentCenter, componentRotation } = params2;
   const fpTexts = [];
   for (const textElement of noteTexts) {
     const relX = textElement.anchor_position.x - componentCenter.x;
@@ -71247,17 +71797,19 @@ function create3DModelsFromCadComponent(cadComponent, componentCenter, options)
   const model = new FootprintModel3(modelUrl);
   if (cadComponent.position) {
     const boardLayerZOffset = options?.boardLayerZOffset ?? 0;
+    const modelOriginPosition = cadComponent.model_origin_position;
     model.offset = {
-      x: (cadComponent.position.x || 0) - componentCenter.x,
-      y: (cadComponent.position.y || 0) - componentCenter.y,
-      z: (cadComponent.position.z || 0) - boardLayerZOffset
+      x: (cadComponent.position.x || 0) - componentCenter.x - (modelOriginPosition?.x || 0),
+      y: (cadComponent.position.y || 0) - componentCenter.y - (modelOriginPosition?.y || 0),
+      z: (cadComponent.position.z || 0) - boardLayerZOffset - (modelOriginPosition?.z || 0)
     };
   }
   if (cadComponent.rotation) {
+    const footprintRotation = options?.footprintRotation ?? 0;
     model.rotate = {
       x: cadComponent.rotation.x || 0,
       y: cadComponent.rotation.y || 0,
-      z: cadComponent.rotation.z || 0
+      z: (cadComponent.rotation.z || 0) - footprintRotation
     };
   }
   if (cadComponent.model_unit_to_mm_scale_factor) {
@@ -71336,6 +71888,15 @@ function createSmdPadFromCircuitJson({
     }
     padSize = [pcbPad.width, pcbPad.height];
     rotation = pcbPad.ccw_rotation;
+  } else if (pcbPad.shape === "pill") {
+    padShape = "roundrect";
+    padSize = [pcbPad.width, pcbPad.height];
+    roundrect_rratio = pcbPad.radius / Math.min(pcbPad.width, pcbPad.height);
+  } else if (pcbPad.shape === "rotated_pill") {
+    padShape = "roundrect";
+    padSize = [pcbPad.width, pcbPad.height];
+    roundrect_rratio = pcbPad.radius / Math.min(pcbPad.width, pcbPad.height);
+    rotation = pcbPad.ccw_rotation;
   } else if (pcbPad.shape === "rect") {
     const cornerRadius = pcbPad.corner_radius ?? pcbPad.rect_border_radius;
     if (cornerRadius) {
@@ -71359,6 +71920,7 @@ function createSmdPadFromCircuitJson({
       `${padLayer === "F.Cu" ? "F" : "B"}.Mask`
     ],
     solderMaskMargin: pcbPad.soldermask_margin,
+    roundrectRatio: roundrect_rratio,
     uuid: generateDeterministicUuid(padData)
   });
   if (padOptions) {
@@ -71602,7 +72164,8 @@ function createNpthPadFromCircuitJson({
     uuid: crypto.randomUUID()
   });
 }
-function convertNpthHoles(pcbHoles, componentCenter, componentRotation) {
+function convertNpthHoles(params2) {
+  const { pcbHoles, componentCenter, componentRotation } = params2;
   const pads = [];
   for (const pcbHole of pcbHoles) {
     const pad = createNpthPadFromCircuitJson({
@@ -71675,9 +72238,18 @@ var AddFootprintsStage = class extends ConverterStage {
     });
     const fpTexts = footprint.fpTexts;
     const pcbSilkscreenTexts = this.ctx.db.pcb_silkscreen_text?.list().filter((text) => text.pcb_component_id === component.pcb_component_id) || [];
-    fpTexts.push(...convertSilkscreenTexts(pcbSilkscreenTexts, component.center, component.rotation || 0, sourceComponent?.name));
+    fpTexts.push(...convertSilkscreenTexts({
+      silkscreenTexts: pcbSilkscreenTexts,
+      componentCenter: component.center,
+      componentRotation: component.rotation || 0,
+      sourceComponentName: sourceComponent?.name
+    }));
     const pcbNoteTexts = this.ctx.db.pcb_note_text?.list().filter((text) => text.pcb_component_id === component.pcb_component_id) || [];
-    fpTexts.push(...convertNoteTexts(pcbNoteTexts, component.center, component.rotation || 0));
+    fpTexts.push(...convertNoteTexts({
+      noteTexts: pcbNoteTexts,
+      componentCenter: component.center,
+      componentRotation: component.rotation || 0
+    }));
     footprint.fpTexts = fpTexts;
     const pcbSilkscreenPaths = this.ctx.db.pcb_silkscreen_path?.list().filter((path7) => path7.pcb_component_id === component.pcb_component_id) || [];
     const fpLines = footprint.fpLines ?? [];
@@ -71709,7 +72281,11 @@ var AddFootprintsStage = class extends ConverterStage {
     }, this.ctx);
     fpPads.push(...thruHolePads);
     const pcbHoles = this.ctx.db.pcb_hole?.list().filter((hole) => hole.pcb_component_id === component.pcb_component_id) || [];
-    const npthPads = convertNpthHoles(pcbHoles, component.center, component.rotation || 0);
+    const npthPads = convertNpthHoles({
+      pcbHoles,
+      componentCenter: component.center,
+      componentRotation: component.rotation || 0
+    });
     fpPads.push(...npthPads);
     footprint.fpPads = fpPads;
     const pcbSilkscreenCircles = this.ctx.db.pcb_silkscreen_circle?.list().filter((circle) => circle.pcb_component_id === component.pcb_component_id) || [];
@@ -71727,7 +72303,11 @@ var AddFootprintsStage = class extends ConverterStage {
     fpRects.push(...convertCourtyardRects(pcbCourtyardRects, component.center));
     footprint.fpRects = fpRects;
     const pcbCourtyardOutlines = this.ctx.db.pcb_courtyard_outline?.list().filter((outline) => outline.pcb_component_id === component.pcb_component_id) || [];
-    const fpPolys = convertCourtyardOutlines(pcbCourtyardOutlines, component.center, component.rotation || 0);
+    const fpPolys = convertCourtyardOutlines({
+      courtyardOutlines: pcbCourtyardOutlines,
+      componentCenter: component.center,
+      componentRotation: component.rotation || 0
+    });
     if (fpPolys.length > 0) {
       footprint.fpPolys = fpPolys;
     }
@@ -71735,7 +72315,10 @@ var AddFootprintsStage = class extends ConverterStage {
       const pcbBoard = this.ctx.db.pcb_board?.list()[0];
       const boardThickness = pcbBoard?.thickness ?? 0;
       const boardLayerZOffset = component.layer === "bottom" ? -(boardThickness / 2) : boardThickness / 2;
-      const models = create3DModelsFromCadComponent(cadComponent, component.center, { boardLayerZOffset });
+      const models = create3DModelsFromCadComponent(cadComponent, component.center, {
+        boardLayerZOffset,
+        footprintRotation: component.rotation || 0
+      });
       const KICAD_3D_BASE = "${KIPRJMOD}/3dmodels";
       if (models.length > 0) {
         if (this.includeBuiltin3dModels) {
@@ -71789,6 +72372,24 @@ var AddFootprintsStage = class extends ConverterStage {
     return this.ctx.kicadPcb;
   }
 };
+function getRoutePointLayer(point, pointRoleInSegment) {
+  if ("layer" in point) {
+    return point.layer;
+  }
+  if (point.route_type === "through_pad") {
+    if (pointRoleInSegment === "start") {
+      return point.end_layer;
+    }
+    return point.start_layer;
+  }
+  return;
+}
+function getRoutePointWidth(point) {
+  if ("width" in point) {
+    return point.width;
+  }
+  return;
+}
 var AddTracesStage = class extends ConverterStage {
   tracesProcessed = 0;
   pcbTraces = [];
@@ -71796,6 +72397,18 @@ var AddTracesStage = class extends ConverterStage {
     super(input, ctx);
     this.pcbTraces = this.ctx.db.pcb_trace.list();
   }
+  getRoutePointPosition(point, pointRoleInSegment) {
+    if ("x" in point && "y" in point) {
+      return { x: point.x, y: point.y };
+    }
+    if (point.route_type !== "through_pad") {
+      return null;
+    }
+    if (pointRoleInSegment === "start") {
+      return { x: point.end.x, y: point.end.y };
+    }
+    return { x: point.start.x, y: point.start.y };
+  }
   _step() {
     const { kicadPcb, c2kMatPcb, pcbNetMap } = this.ctx;
     if (!kicadPcb) {
@@ -71809,22 +72422,25 @@ var AddTracesStage = class extends ConverterStage {
       return;
     }
     const trace = this.pcbTraces[this.tracesProcessed];
-    if (!trace.route || trace.route.length < 2) {
+    const route = trace.route;
+    if (!route || route.length < 2) {
       this.tracesProcessed++;
       return;
     }
-    let lastKnownLayer = trace.route[0]?.layer;
-    for (let i = 0;i < trace.route.length - 1; i++) {
-      const startPoint = trace.route[i];
-      const endPoint = trace.route[i + 1];
-      const transformedStart = applyToPoint17(c2kMatPcb, {
-        x: startPoint.x,
-        y: startPoint.y
-      });
-      const transformedEnd = applyToPoint17(c2kMatPcb, {
-        x: endPoint.x,
-        y: endPoint.y
-      });
+    let lastKnownLayer = getRoutePointLayer(route[0], "start");
+    for (let i = 0;i < route.length - 1; i++) {
+      const startPoint = route[i];
+      const endPoint = route[i + 1];
+      const startPosition = this.getRoutePointPosition(startPoint, "start");
+      const endPosition = this.getRoutePointPosition(endPoint, "end");
+      if (!startPosition || !endPosition) {
+        throw new Error(`Unable to convert pcb_trace route segment ${trace.pcb_trace_id ?? this.tracesProcessed}:${i} to KiCad segment`);
+      }
+      const transformedStart = applyToPoint17(c2kMatPcb, startPosition);
+      const transformedEnd = applyToPoint17(c2kMatPcb, endPosition);
+      if (transformedStart.x === transformedEnd.x && transformedStart.y === transformedEnd.y) {
+        continue;
+      }
       let netInfo;
       if (pcbNetMap) {
         let connectivityKey = trace.subcircuit_connectivity_map_key;
@@ -71853,25 +72469,27 @@ var AddTracesStage = class extends ConverterStage {
           netInfo = pcbNetMap.get(connectivityKey);
         }
       }
-      const segmentLayerSource = startPoint.layer ?? endPoint.layer ?? lastKnownLayer;
+      const segmentLayerSource = getRoutePointLayer(startPoint, "start") ?? getRoutePointLayer(endPoint, "end") ?? lastKnownLayer;
       const kicadLayer = getKicadLayer(segmentLayerSource);
       const segmentData = `segment:${transformedStart.x},${transformedStart.y}:${transformedEnd.x},${transformedEnd.y}:${kicadLayer}:${netInfo?.id ?? 0}`;
       const segment = new Segment({
         start: { x: transformedStart.x, y: transformedStart.y },
         end: { x: transformedEnd.x, y: transformedEnd.y },
         layer: kicadLayer,
-        width: startPoint.width ?? endPoint.width ?? trace.width ?? 0.25,
+        width: getRoutePointWidth(startPoint) ?? getRoutePointWidth(endPoint) ?? trace.width ?? 0.25,
         net: new SegmentNet(netInfo?.id ?? 0),
         uuid: generateDeterministicUuid(segmentData)
       });
       const segments = kicadPcb.segments;
       segments.push(segment);
       kicadPcb.segments = segments;
-      if (startPoint.layer) {
-        lastKnownLayer = startPoint.layer;
+      const startLayer = getRoutePointLayer(startPoint, "start");
+      const endLayer = getRoutePointLayer(endPoint, "end");
+      if (startLayer) {
+        lastKnownLayer = startLayer;
       }
-      if (endPoint.layer) {
-        lastKnownLayer = endPoint.layer;
+      if (endLayer) {
+        lastKnownLayer = endLayer;
       }
     }
     this.tracesProcessed++;
@@ -72071,7 +72689,11 @@ var AddStandalonePcbElements = class extends ConverterStage {
         uuid: generateDeterministicUuid(footprintSeed)
       });
       const ccwRotationDegrees = 0;
-      const npthPads = convertNpthHoles([hole], { x: hole.x, y: hole.y }, ccwRotationDegrees);
+      const npthPads = convertNpthHoles({
+        pcbHoles: [hole],
+        componentCenter: { x: hole.x, y: hole.y },
+        componentRotation: ccwRotationDegrees
+      });
       if (npthPads.length > 0) {
         footprint.fpPads = npthPads;
         const footprints = kicadPcb.footprints;
@@ -72222,7 +72844,8 @@ function createFabricationNoteTextFromCircuitJson({
   const grText = new GrText({
     text: textElement.text,
     layer: kicadLayer,
-    effects: textEffects
+    effects: textEffects,
+    uuid: generateDeterministicUuid(textElement.pcb_fabrication_note_text_id ?? textElement.text)
   });
   grText.position = position;
   return grText;
@@ -72279,7 +72902,8 @@ function createGrTextFromCircuitJson({
   const grText = new GrText2({
     text: textElement.text,
     layer: kicadLayer,
-    effects: textEffects
+    effects: textEffects,
+    uuid: generateDeterministicUuid(textElement.pcb_silkscreen_text_id ?? textElement.text)
   });
   grText.position = position;
   return grText;
@@ -72298,6 +72922,44 @@ var normalizeOutlineCorners = (corners) => {
   }
   return dedupedCorners;
 };
+var EDGE_CUTS_WIDTH = 0.1;
+var appendGraphicLine = (kicadPcb, grLine) => {
+  const graphicLines = kicadPcb.graphicLines;
+  graphicLines.push(grLine);
+  kicadPcb.graphicLines = graphicLines;
+};
+var appendGraphicCircle = (kicadPcb, grCircle) => {
+  const graphicCircles = kicadPcb.graphicCircles;
+  graphicCircles.push(grCircle);
+  kicadPcb.graphicCircles = graphicCircles;
+};
+var appendGraphicPoly = (kicadPcb, grPoly) => {
+  const graphicPolys = kicadPcb.graphicPolys;
+  graphicPolys.push(grPoly);
+  kicadPcb.graphicPolys = graphicPolys;
+};
+var rotatePointAroundOrigin = (point, rotationDegrees = 0) => {
+  if (!rotationDegrees)
+    return point;
+  return applyToPoint22(rotate9(rotationDegrees * Math.PI / 180), point);
+};
+var getRectCutoutCorners = (cutout) => {
+  const halfWidth = cutout.width / 2;
+  const halfHeight = cutout.height / 2;
+  const localCorners = [
+    { x: -halfWidth, y: -halfHeight },
+    { x: halfWidth, y: -halfHeight },
+    { x: halfWidth, y: halfHeight },
+    { x: -halfWidth, y: halfHeight }
+  ];
+  return localCorners.map((point) => {
+    const rotatedPoint = rotatePointAroundOrigin(point, cutout.rotation);
+    return {
+      x: rotatedPoint.x + cutout.center.x,
+      y: rotatedPoint.y + cutout.center.y
+    };
+  });
+};
 var AddGraphicsStage = class extends ConverterStage {
   _step() {
     const { kicadPcb, c2kMatPcb } = this.ctx;
@@ -72335,9 +72997,7 @@ var AddGraphicsStage = class extends ConverterStage {
           layer: kicadLayer,
           width: path7.stroke_width || 0.15
         });
-        const graphicLines = kicadPcb.graphicLines;
-        graphicLines.push(grLine);
-        kicadPcb.graphicLines = graphicLines;
+        appendGraphicLine(kicadPcb, grLine);
       }
     }
     const standaloneSilkscreenTexts = this.ctx.db.pcb_silkscreen_text?.list().filter((text) => !text.pcb_component_id) || [];
@@ -72400,11 +73060,62 @@ var AddGraphicsStage = class extends ConverterStage {
           start: { x: start.x, y: start.y },
           end: { x: end.x, y: end.y },
           layer: "Edge.Cuts",
-          width: 0.1
+          width: EDGE_CUTS_WIDTH
+        });
+        appendGraphicLine(kicadPcb, edgeLine);
+      }
+    }
+    const pcbCutouts = this.ctx.db.pcb_cutout?.list() || [];
+    for (const cutout of pcbCutouts) {
+      if (cutout.shape === "circle") {
+        const transformedCenter = applyToPoint22(c2kMatPcb, cutout.center);
+        const transformedEnd = applyToPoint22(c2kMatPcb, {
+          x: cutout.center.x + cutout.radius,
+          y: cutout.center.y
         });
-        const graphicLines = kicadPcb.graphicLines;
-        graphicLines.push(edgeLine);
-        kicadPcb.graphicLines = graphicLines;
+        appendGraphicCircle(kicadPcb, new GrCircle({
+          center: transformedCenter,
+          end: transformedEnd,
+          layer: "Edge.Cuts",
+          width: EDGE_CUTS_WIDTH
+        }));
+      } else if (cutout.shape === "polygon") {
+        const corners = normalizeOutlineCorners(cutout.points);
+        if (corners.length < 3)
+          continue;
+        appendGraphicPoly(kicadPcb, new GrPoly({
+          points: corners.map((point) => applyToPoint22(c2kMatPcb, point)),
+          layer: "Edge.Cuts",
+          width: EDGE_CUTS_WIDTH,
+          fill: false
+        }));
+      } else if (cutout.shape === "rect") {
+        const corners = normalizeOutlineCorners(getRectCutoutCorners(cutout));
+        if (corners.length < 3)
+          continue;
+        appendGraphicPoly(kicadPcb, new GrPoly({
+          points: corners.map((point) => applyToPoint22(c2kMatPcb, point)),
+          layer: "Edge.Cuts",
+          width: EDGE_CUTS_WIDTH,
+          fill: false
+        }));
+      } else if (cutout.shape === "path") {
+        if (!cutout.route || cutout.route.length < 2)
+          continue;
+        for (let i = 0;i < cutout.route.length - 1; i++) {
+          const startPoint = cutout.route[i];
+          const endPoint = cutout.route[i + 1];
+          if (!startPoint || !endPoint)
+            continue;
+          const transformedStart = applyToPoint22(c2kMatPcb, startPoint);
+          const transformedEnd = applyToPoint22(c2kMatPcb, endPoint);
+          appendGraphicLine(kicadPcb, new GrLine({
+            start: transformedStart,
+            end: transformedEnd,
+            layer: "Edge.Cuts",
+            width: EDGE_CUTS_WIDTH
+          }));
+        }
       }
     }
     this.finished = true;