circuit-json-to-tscircuit 0.0.57 → 0.0.59

package/dist/{chunk-U24G34W6.js → chunk-QMIS5SJZ.js}

@@ -1,16 +1,224 @@
 // lib/get-board-using-template.ts
 import { mmStr as mmStr8 } from "@tscircuit/mm";
-import { su as su14 } from "@tscircuit/soup-util";
+import { su as su16 } from "@tscircuit/soup-util";
 
-// lib/generate-footprint-tsx/convert-copper-text.ts
+// lib/generate-copper-pours-tsx.ts
 import { su } from "@tscircuit/soup-util";
 
+// lib/get-bulge-arc.ts
+var getBulgeArc = ({
+  end,
+  start
+}) => {
+  const bulge = start.bulge ?? 0;
+  const deltaX = end.x - start.x;
+  const deltaY = end.y - start.y;
+  const chordLength = Math.hypot(deltaX, deltaY);
+  if (Math.abs(bulge) < 1e-12 || chordLength < 1e-12) return null;
+  const centerOffset = chordLength * (1 - bulge * bulge) / (4 * bulge);
+  const midpoint = {
+    x: (start.x + end.x) / 2,
+    y: (start.y + end.y) / 2
+  };
+  return {
+    center: {
+      x: midpoint.x - deltaY / chordLength * centerOffset,
+      y: midpoint.y + deltaX / chordLength * centerOffset
+    },
+    radius: Math.abs(chordLength * (1 + bulge * bulge) / (4 * bulge)),
+    sweepAngle: 4 * Math.atan(bulge)
+  };
+};
+
+// lib/flatten-brep-ring.ts
+var MAX_ANGLE_STEP = Math.PI / 18;
+var flattenBrepRing = (vertices) => {
+  if (vertices.length < 2) return vertices.map(toPoint);
+  const points = [toPoint(vertices[0])];
+  for (let index = 0; index < vertices.length; index++) {
+    const start = vertices[index];
+    const end = vertices[(index + 1) % vertices.length];
+    const isClosingSegment = index === vertices.length - 1;
+    const arc = getBulgeArc({ end, start });
+    if (!arc) {
+      if (!isClosingSegment) points.push(toPoint(end));
+      continue;
+    }
+    const startAngle = Math.atan2(
+      start.y - arc.center.y,
+      start.x - arc.center.x
+    );
+    const stepCount = Math.max(
+      2,
+      Math.ceil(Math.abs(arc.sweepAngle) / MAX_ANGLE_STEP)
+    );
+    for (let step = 1; step <= stepCount; step++) {
+      if (isClosingSegment && step === stepCount) continue;
+      if (step === stepCount) {
+        points.push(toPoint(end));
+        continue;
+      }
+      const angle = startAngle + arc.sweepAngle * step / stepCount;
+      points.push({
+        x: arc.center.x + arc.radius * Math.cos(angle),
+        y: arc.center.y + arc.radius * Math.sin(angle)
+      });
+    }
+  }
+  return points;
+};
+var toPoint = ({ x, y }) => ({ x, y });
+
+// lib/get-brep-copper-pour-outline.ts
+var getBrepCopperPourOutline = (brepShape) => {
+  let outline = withWinding(
+    flattenBrepRing(brepShape.outer_ring.vertices),
+    "ccw"
+  );
+  const holes = (brepShape.inner_rings ?? []).map((ring) => withWinding(flattenBrepRing(ring.vertices), "cw")).filter((ring) => ring.length >= 3).sort((first, second) => getLeftmostX(first) - getLeftmostX(second));
+  for (const hole of holes) {
+    const bridgedOutline = bridgeHoleIntoOutline({ hole, outline });
+    if (!bridgedOutline) return void 0;
+    outline = bridgedOutline;
+  }
+  return outline;
+};
+var bridgeHoleIntoOutline = ({
+  hole,
+  outline
+}) => {
+  const holeStartIndex = getLeftmostPointIndex(hole);
+  const holeStart = hole[holeStartIndex];
+  const bridge = findLeftwardBridge({ holeStart, outline });
+  if (!bridge) return void 0;
+  const outlineWithBridge = [...outline];
+  let bridgeIndex = bridge.edgeStartIndex;
+  const edgeEndIndex = (bridge.edgeStartIndex + 1) % outline.length;
+  if (pointsEqual(bridge.point, outline[edgeEndIndex])) {
+    bridgeIndex = edgeEndIndex;
+  } else if (!pointsEqual(bridge.point, outline[bridge.edgeStartIndex])) {
+    bridgeIndex = bridge.edgeStartIndex + 1;
+    outlineWithBridge.splice(bridgeIndex, 0, bridge.point);
+  }
+  const orderedHole = [
+    ...hole.slice(holeStartIndex),
+    ...hole.slice(0, holeStartIndex)
+  ];
+  return [
+    ...outlineWithBridge.slice(0, bridgeIndex + 1),
+    ...orderedHole,
+    holeStart,
+    bridge.point,
+    ...outlineWithBridge.slice(bridgeIndex + 1)
+  ];
+};
+var findLeftwardBridge = ({
+  holeStart,
+  outline
+}) => {
+  let closestBridge;
+  for (let index = 0; index < outline.length; index++) {
+    const start = outline[index];
+    const end = outline[(index + 1) % outline.length];
+    if (start.y > holeStart.y === end.y > holeStart.y) continue;
+    const x = start.x + (holeStart.y - start.y) * (end.x - start.x) / (end.y - start.y);
+    if (x > holeStart.x) continue;
+    if (closestBridge && x <= closestBridge.point.x) continue;
+    closestBridge = {
+      edgeStartIndex: index,
+      point: { x, y: holeStart.y }
+    };
+  }
+  return closestBridge;
+};
+var withWinding = (ring, winding) => {
+  const isCounterclockwise = getSignedArea(ring) > 0;
+  const shouldReverse = winding === "ccw" && !isCounterclockwise || winding === "cw" && isCounterclockwise;
+  return shouldReverse ? [...ring].reverse() : [...ring];
+};
+var getSignedArea = (ring) => ring.reduce((area, point, index) => {
+  const nextPoint = ring[(index + 1) % ring.length];
+  return area + point.x * nextPoint.y - nextPoint.x * point.y;
+}, 0) / 2;
+var getLeftmostPointIndex = (ring) => ring.reduce(
+  (leftmostIndex, point, index) => point.x < ring[leftmostIndex].x ? index : leftmostIndex,
+  0
+);
+var getLeftmostX = (ring) => ring[getLeftmostPointIndex(ring)].x;
+var pointsEqual = (first, second) => first.x === second.x && first.y === second.y;
+
+// lib/get-copper-pour-outline.ts
+function getCopperPourOutline(pour) {
+  if (pour.shape === "polygon") return pour.points;
+  if (pour.shape === "brep") {
+    return getBrepCopperPourOutline(pour.brep_shape);
+  }
+  const halfWidth = pour.width / 2;
+  const halfHeight = pour.height / 2;
+  const ccwRotationRadians = (pour.rotation ?? 0) * Math.PI / 180;
+  const cosine = Math.cos(ccwRotationRadians);
+  const sine = Math.sin(ccwRotationRadians);
+  return [
+    { x: -halfWidth, y: -halfHeight },
+    { x: halfWidth, y: -halfHeight },
+    { x: halfWidth, y: halfHeight },
+    { x: -halfWidth, y: halfHeight }
+  ].map(({ x, y }) => ({
+    x: pour.center.x + x * cosine - y * sine,
+    y: pour.center.y + x * sine + y * cosine
+  }));
+}
+
+// lib/generate-copper-pours-tsx.ts
+function generateCopperPoursTsx(circuitJson) {
+  const sourceNetNameById = new Map(
+    su(circuitJson).source_net.list().map((sourceNet) => [sourceNet.source_net_id, sourceNet.name])
+  );
+  const reservedNetNames = new Set(sourceNetNameById.values());
+  const usedNetNames = /* @__PURE__ */ new Set();
+  const copperPours = su(circuitJson).pcb_copper_pour.list().flatMap((pour) => {
+    const resolvedSourceNetName = pour.source_net_id ? sourceNetNameById.get(pour.source_net_id) : void 0;
+    const sourceNetName = resolvedSourceNetName ?? getUnassignedCopperPourNetName({
+      pcbCopperPourId: pour.pcb_copper_pour_id,
+      reservedNetNames
+    });
+    const outline = getCopperPourOutline(pour);
+    if (!outline || outline.length < 3) return [];
+    usedNetNames.add(sourceNetName);
+    const netSelector = `net[name=${JSON.stringify(sourceNetName)}]`;
+    return [
+      `<copperpour layer={${JSON.stringify(pour.layer)}} connectsTo={${JSON.stringify(netSelector)}} outline={${JSON.stringify(outline)}} padMargin={0} traceMargin={0} clearance={0} boardEdgeMargin={0} cutoutMargin={0} useThermalReliefs={false} coveredWithSolderMask={${pour.covered_with_solder_mask ?? true}} />`
+    ];
+  });
+  const nets = [...usedNetNames].map(
+    (sourceNetName) => `<net name={${JSON.stringify(sourceNetName)}} />`
+  );
+  return [...nets, ...copperPours];
+}
+var getUnassignedCopperPourNetName = ({
+  pcbCopperPourId,
+  reservedNetNames
+}) => {
+  const baseName = `__circuit_json_unassigned_${pcbCopperPourId}`;
+  let name = baseName;
+  let suffix = 2;
+  while (reservedNetNames.has(name)) {
+    name = `${baseName}_${suffix}`;
+    suffix += 1;
+  }
+  reservedNetNames.add(name);
+  return name;
+};
+
+// lib/generate-footprint-tsx/convert-copper-text.ts
+import { su as su2 } from "@tscircuit/soup-util";
+
 // lib/generate-footprint-tsx/footprint-tsx-attribute-formatters/escape-jsx-text.ts
 var escapeJsxText = (value) => String(value ?? "").replace(/"/g, '\\"');
 
 // lib/generate-footprint-tsx/convert-copper-text.ts
 var convertCopperText = (circuitJson) => {
-  const copperTexts = su(circuitJson).pcb_copper_text.list();
+  const copperTexts = su2(circuitJson).pcb_copper_text.list();
   const elementStrings = [];
   for (const copperText of copperTexts) {
     const anchorPosition = copperText.anchor_position ?? { x: 0, y: 0 };
@@ -44,7 +252,7 @@ var convertCopperText = (circuitJson) => {
 };
 
 // lib/generate-footprint-tsx/convert-courtyard.ts
-import { su as su2 } from "@tscircuit/soup-util";
+import { su as su3 } from "@tscircuit/soup-util";
 
 // lib/generate-footprint-tsx/footprint-tsx-attribute-formatters/format-pcb-rotation-attr.ts
 var formatPcbRotationAttr = (rotation, attrName = "pcbRotation") => {
@@ -55,9 +263,9 @@ var formatPcbRotationAttr = (rotation, attrName = "pcbRotation") => {
 
 // lib/generate-footprint-tsx/convert-courtyard.ts
 var convertCourtyard = (circuitJson) => {
-  const courtyardOutlines = su2(circuitJson).pcb_courtyard_outline.list();
-  const courtyardRects = su2(circuitJson).pcb_courtyard_rect.list();
-  const courtyardCircles = su2(circuitJson).pcb_courtyard_circle.list();
+  const courtyardOutlines = su3(circuitJson).pcb_courtyard_outline.list();
+  const courtyardRects = su3(circuitJson).pcb_courtyard_rect.list();
+  const courtyardCircles = su3(circuitJson).pcb_courtyard_circle.list();
   const elementStrings = [];
   for (const courtyardOutline of courtyardOutlines) {
     const attrs = [
@@ -98,7 +306,7 @@ var convertCourtyard = (circuitJson) => {
 };
 
 // lib/generate-footprint-tsx/convert-cutouts.ts
-import { su as su3 } from "@tscircuit/soup-util";
+import { su as su4 } from "@tscircuit/soup-util";
 
 // lib/generate-footprint-tsx/footprint-tsx-attribute-formatters/format-mm.ts
 import { mmStr } from "@tscircuit/mm";
@@ -106,7 +314,7 @@ var formatMm = (value) => mmStr(value ?? 0);
 
 // lib/generate-footprint-tsx/convert-cutouts.ts
 var convertCutouts = (circuitJson) => {
-  const pcbCutouts = su3(circuitJson).pcb_cutout.list();
+  const pcbCutouts = su4(circuitJson).pcb_cutout.list();
   const elementStrings = [];
   for (const cutout of pcbCutouts) {
     if (cutout.shape === "rect") {
@@ -130,12 +338,12 @@ var convertCutouts = (circuitJson) => {
 };
 
 // lib/generate-footprint-tsx/convert-fabrication.ts
-import { su as su4 } from "@tscircuit/soup-util";
+import { su as su5 } from "@tscircuit/soup-util";
 var convertFabrication = (circuitJson) => {
-  const fabricationNotePaths = su4(circuitJson).pcb_fabrication_note_path.list();
-  const fabricationNoteTexts = su4(circuitJson).pcb_fabrication_note_text.list();
-  const fabricationNoteRects = su4(circuitJson).pcb_fabrication_note_rect.list();
-  const fabricationNoteDimensions = su4(circuitJson).pcb_fabrication_note_dimension.list();
+  const fabricationNotePaths = su5(circuitJson).pcb_fabrication_note_path.list();
+  const fabricationNoteTexts = su5(circuitJson).pcb_fabrication_note_text.list();
+  const fabricationNoteRects = su5(circuitJson).pcb_fabrication_note_rect.list();
+  const fabricationNoteDimensions = su5(circuitJson).pcb_fabrication_note_dimension.list();
   const elementStrings = [];
   for (const fabPath of fabricationNotePaths) {
     const attrs = [`route={${JSON.stringify(fabPath.route)}}`];
@@ -207,10 +415,10 @@ var convertFabrication = (circuitJson) => {
   }
   for (const fabDimension of fabricationNoteDimensions) {
     const fromPoint = fabDimension.from ?? { x: 0, y: 0 };
-    const toPoint = fabDimension.to ?? { x: 0, y: 0 };
+    const toPoint2 = fabDimension.to ?? { x: 0, y: 0 };
     const attrs = [
       `from={{ x: ${fromPoint.x}, y: ${fromPoint.y} }}`,
-      `to={{ x: ${toPoint.x}, y: ${toPoint.y} }}`
+      `to={{ x: ${toPoint2.x}, y: ${toPoint2.y} }}`
     ];
     if (fabDimension.text !== void 0) {
       attrs.push(`text="${escapeJsxText(fabDimension.text)}"`);
@@ -241,10 +449,10 @@ var convertFabrication = (circuitJson) => {
 };
 
 // lib/generate-footprint-tsx/convert-holes.ts
-import { su as su5 } from "@tscircuit/soup-util";
+import { su as su6 } from "@tscircuit/soup-util";
 import { mmStr as mmStr2 } from "@tscircuit/mm";
 var convertHoles = (circuitJson) => {
-  const holes = su5(circuitJson).pcb_hole.list();
+  const holes = su6(circuitJson).pcb_hole.list();
   const elementStrings = [];
   for (const hole of holes) {
     if (hole.hole_shape === "circle") {
@@ -269,9 +477,9 @@ var convertHoles = (circuitJson) => {
 };
 
 // lib/generate-footprint-tsx/convert-keepouts.ts
-import { su as su6 } from "@tscircuit/soup-util";
+import { su as su7 } from "@tscircuit/soup-util";
 var convertKeepouts = (circuitJson) => {
-  const pcbKeepouts = su6(circuitJson).pcb_keepout.list();
+  const pcbKeepouts = su7(circuitJson).pcb_keepout.list();
   const elementStrings = [];
   for (const keepout of pcbKeepouts) {
     if (keepout.shape === "rect") {
@@ -290,13 +498,13 @@ var convertKeepouts = (circuitJson) => {
 };
 
 // lib/generate-footprint-tsx/convert-notes.ts
-import { su as su7 } from "@tscircuit/soup-util";
+import { su as su8 } from "@tscircuit/soup-util";
 var convertNotes = (circuitJson) => {
-  const noteTexts = su7(circuitJson).pcb_note_text.list();
-  const noteRects = su7(circuitJson).pcb_note_rect.list();
-  const notePaths = su7(circuitJson).pcb_note_path.list();
-  const noteLines = su7(circuitJson).pcb_note_line.list();
-  const noteDimensions = su7(circuitJson).pcb_note_dimension.list();
+  const noteTexts = su8(circuitJson).pcb_note_text.list();
+  const noteRects = su8(circuitJson).pcb_note_rect.list();
+  const notePaths = su8(circuitJson).pcb_note_path.list();
+  const noteLines = su8(circuitJson).pcb_note_line.list();
+  const noteDimensions = su8(circuitJson).pcb_note_dimension.list();
   const elementStrings = [];
   for (const noteText of noteTexts) {
     const anchorPosition = noteText.anchor_position ?? { x: 0, y: 0 };
@@ -358,10 +566,10 @@ var convertNotes = (circuitJson) => {
   }
   for (const noteDimension of noteDimensions) {
     const fromPoint = noteDimension.from ?? { x: 0, y: 0 };
-    const toPoint = noteDimension.to ?? { x: 0, y: 0 };
+    const toPoint2 = noteDimension.to ?? { x: 0, y: 0 };
     const attrs = [
       `from={{ x: ${fromPoint.x}, y: ${fromPoint.y} }}`,
-      `to={{ x: ${toPoint.x}, y: ${toPoint.y} }}`,
+      `to={{ x: ${toPoint2.x}, y: ${toPoint2.y} }}`,
       `font="${noteDimension.font ?? "tscircuit2024"}"`,
       `fontSize={${noteDimension.font_size ?? 0}}`
     ];
@@ -386,11 +594,11 @@ var convertNotes = (circuitJson) => {
 };
 
 // lib/generate-footprint-tsx/convert-pcb-traces.ts
-import { su as su8 } from "@tscircuit/soup-util";
-var convertPcbTraces = (circuitJson) => su8(circuitJson).pcb_trace.list().map((trace) => `<pcbtrace route={${JSON.stringify(trace.route)}} />`);
+import { su as su9 } from "@tscircuit/soup-util";
+var convertPcbTraces = (circuitJson) => su9(circuitJson).pcb_trace.list().map((trace) => `<pcbtrace route={${JSON.stringify(trace.route)}} />`);
 
 // lib/generate-footprint-tsx/convert-plated-holes.ts
-import { su as su9 } from "@tscircuit/soup-util";
+import { su as su10 } from "@tscircuit/soup-util";
 import { mmStr as mmStr4 } from "@tscircuit/mm";
 
 // lib/generate-footprint-tsx/footprint-tsx-attribute-formatters/format-optional-mm-attr.ts
@@ -411,7 +619,7 @@ var formatSolderMaskAttrs = (platedHole) => {
 
 // lib/generate-footprint-tsx/convert-plated-holes.ts
 var convertPlatedHoles = (circuitJson) => {
-  const platedHoles = su9(circuitJson).pcb_plated_hole.list();
+  const platedHoles = su10(circuitJson).pcb_plated_hole.list();
   const elementStrings = [];
   for (const platedHole of platedHoles) {
     if (platedHole.shape === "oval" || platedHole.shape === "pill") {
@@ -443,12 +651,12 @@ var convertPlatedHoles = (circuitJson) => {
 };
 
 // lib/generate-footprint-tsx/convert-silkscreen.ts
-import { su as su10 } from "@tscircuit/soup-util";
+import { su as su11 } from "@tscircuit/soup-util";
 var convertSilkscreen = (circuitJson) => {
-  const silkscreenLines = su10(circuitJson).pcb_silkscreen_line.list();
-  const silkscreenPaths = su10(circuitJson).pcb_silkscreen_path.list();
-  const silkscreenRects = su10(circuitJson).pcb_silkscreen_rect.list();
-  const silkscreenCircles = su10(circuitJson).pcb_silkscreen_circle.list();
+  const silkscreenLines = su11(circuitJson).pcb_silkscreen_line.list();
+  const silkscreenPaths = su11(circuitJson).pcb_silkscreen_path.list();
+  const silkscreenRects = su11(circuitJson).pcb_silkscreen_rect.list();
+  const silkscreenCircles = su11(circuitJson).pcb_silkscreen_circle.list();
   const elementStrings = [];
   for (const silkscreenPath of silkscreenPaths) {
     const attrs = [`route={${JSON.stringify(silkscreenPath.route)}}`];
@@ -518,11 +726,131 @@ var convertSilkscreen = (circuitJson) => {
   return elementStrings;
 };
 
+// lib/generate-footprint-tsx/convert-silkscreen-graphics.ts
+import { su as su12 } from "@tscircuit/soup-util";
+
+// lib/generate-footprint-tsx/get-brep-rings-bounds.ts
+var getBrepRingsBounds = (rings) => {
+  const boundaryPoints = rings.flatMap(getRingBoundaryPoints);
+  if (boundaryPoints.length === 0) return null;
+  const xs = boundaryPoints.map((point) => point.x);
+  const ys = boundaryPoints.map((point) => point.y);
+  return {
+    maxX: Math.max(...xs),
+    maxY: Math.max(...ys),
+    minX: Math.min(...xs),
+    minY: Math.min(...ys)
+  };
+};
+var getRingBoundaryPoints = (ring) => {
+  const boundaryPoints = [...ring.vertices];
+  for (let index = 0; index < ring.vertices.length; index++) {
+    const start = ring.vertices[index];
+    const end = ring.vertices[(index + 1) % ring.vertices.length];
+    const arc = getBulgeArc({ end, start });
+    if (!arc) continue;
+    const startAngle = Math.atan2(
+      start.y - arc.center.y,
+      start.x - arc.center.x
+    );
+    for (const angle of [0, Math.PI / 2, Math.PI, 3 * Math.PI / 2]) {
+      if (!isAngleOnArc({ angle, startAngle, sweepAngle: arc.sweepAngle })) {
+        continue;
+      }
+      boundaryPoints.push({
+        x: arc.center.x + arc.radius * Math.cos(angle),
+        y: arc.center.y + arc.radius * Math.sin(angle)
+      });
+    }
+  }
+  return boundaryPoints;
+};
+var isAngleOnArc = ({
+  angle,
+  startAngle,
+  sweepAngle
+}) => {
+  const angularDistance = sweepAngle >= 0 ? normalizeAngle(angle - startAngle) : normalizeAngle(startAngle - angle);
+  return angularDistance <= Math.abs(sweepAngle) + 1e-12;
+};
+var normalizeAngle = (angle) => {
+  const fullTurn = 2 * Math.PI;
+  return (angle % fullTurn + fullTurn) % fullTurn;
+};
+
+// lib/generate-footprint-tsx/create-silkscreen-graphic-image.ts
+var createSilkscreenGraphicImage = (graphic) => {
+  const rings = [
+    graphic.brep_shape.outer_ring,
+    ...(graphic.brep_shape.inner_rings ?? []).filter(isRenderableRing)
+  ];
+  if (!isRenderableRing(graphic.brep_shape.outer_ring)) return null;
+  const bounds = getBrepRingsBounds(rings);
+  if (!bounds) return null;
+  const { maxX, maxY, minX, minY } = bounds;
+  const width = maxX - minX;
+  const height = maxY - minY;
+  if (width <= 0 || height <= 0) return null;
+  const pathData = rings.map((ring) => createRingPath({ maxY, minX, ring })).join(" ");
+  const svg = [
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}">`,
+    `<path d="${pathData}" fill="black" fill-rule="evenodd"/>`,
+    "</svg>"
+  ].join("");
+  return {
+    center: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 },
+    dataUrl: `data:image/svg+xml;base64,${btoa(svg)}`,
+    height,
+    width
+  };
+};
+var createRingPath = ({
+  maxY,
+  minX,
+  ring
+}) => {
+  const firstVertex = ring.vertices[0];
+  const commands = [
+    `M${formatCoordinate(firstVertex.x - minX)} ${formatCoordinate(maxY - firstVertex.y)}`
+  ];
+  for (let index = 0; index < ring.vertices.length; index++) {
+    const start = ring.vertices[index];
+    const end = ring.vertices[(index + 1) % ring.vertices.length];
+    const arc = getBulgeArc({ end, start });
+    const x = formatCoordinate(end.x - minX);
+    const y = formatCoordinate(maxY - end.y);
+    if (arc) {
+      const radius = formatCoordinate(arc.radius);
+      const largeArcFlag = Math.abs(start.bulge ?? 0) > 1 ? 1 : 0;
+      const sweepFlag = (start.bulge ?? 0) < 0 ? 1 : 0;
+      commands.push(
+        `A${radius} ${radius} 0 ${largeArcFlag} ${sweepFlag} ${x} ${y}`
+      );
+    } else if (index < ring.vertices.length - 1) {
+      commands.push(`L${x} ${y}`);
+    }
+  }
+  return commands.concat("Z").join(" ");
+};
+var isRenderableRing = (ring) => ring.vertices.length >= 3 || ring.vertices.length >= 2 && ring.vertices.some((vertex) => Math.abs(vertex.bulge ?? 0) > 1e-12);
+var formatCoordinate = (value) => Number(value.toFixed(6)).toString();
+
+// lib/generate-footprint-tsx/convert-silkscreen-graphics.ts
+var convertSilkscreenGraphics = (circuitJson) => {
+  return su12(circuitJson).pcb_silkscreen_graphic.list().flatMap((graphic) => {
+    const image = createSilkscreenGraphicImage(graphic);
+    if (!image) return [];
+    return [
+      `<silkscreengraphic imageUrl=${JSON.stringify(image.dataUrl)} pcbX={${image.center.x}} pcbY={${image.center.y}} width={${image.width}} height={${image.height}} layer=${JSON.stringify(graphic.layer)} />`
+    ];
+  });
+};
+
 // lib/generate-footprint-tsx/convert-silkscreen-text.ts
-import { su as su11 } from "@tscircuit/soup-util";
+import { su as su13 } from "@tscircuit/soup-util";
 import { mmStr as mmStr5 } from "@tscircuit/mm";
 var convertSilkscreenText = (circuitJson) => {
-  const silkscreenTexts = su11(circuitJson).pcb_silkscreen_text.list();
+  const silkscreenTexts = su13(circuitJson).pcb_silkscreen_text.list();
   const elementStrings = [];
   for (const silkscreenText of silkscreenTexts) {
     const pcbX = silkscreenText.anchor_position?.x ?? 0;
@@ -537,10 +865,10 @@ var convertSilkscreenText = (circuitJson) => {
 };
 
 // lib/generate-footprint-tsx/convert-smt-pads.ts
-import { su as su12 } from "@tscircuit/soup-util";
+import { su as su14 } from "@tscircuit/soup-util";
 import { mmStr as mmStr6 } from "@tscircuit/mm";
 var convertSmtPads = (circuitJson) => {
-  const smtPads = su12(circuitJson).pcb_smtpad.list();
+  const smtPads = su14(circuitJson).pcb_smtpad.list();
   const elementStrings = [];
   for (const smtPad of smtPads) {
     const commonAttrs = [];
@@ -589,9 +917,9 @@ var convertSmtPads = (circuitJson) => {
 
 // lib/generate-footprint-tsx/convert-vias.ts
 import { mmStr as mmStr7 } from "@tscircuit/mm";
-import { su as su13 } from "@tscircuit/soup-util";
+import { su as su15 } from "@tscircuit/soup-util";
 var convertVias = (circuitJson) => {
-  return su13(circuitJson).pcb_via.list().map((via) => {
+  return su15(circuitJson).pcb_via.list().map((via) => {
     const fromLayer = via.from_layer ?? via.layers[0];
     const toLayer = via.to_layer ?? via.layers[via.layers.length - 1];
     if (!fromLayer || !toLayer) {
@@ -615,6 +943,7 @@ var generateFootprintTsx = (circuitJson) => {
     convertSmtPads,
     convertPcbTraces,
     convertSilkscreen,
+    convertSilkscreenGraphics,
     convertFabrication,
     convertSilkscreenText,
     convertCopperText,
@@ -639,7 +968,7 @@ var getBoardUsingTemplate = ({
   circuitJson,
   componentName
 }) => {
-  const pcbBoard = su14(circuitJson).pcb_board.list()[0];
+  const pcbBoard = su16(circuitJson).pcb_board.list()[0];
   const boardProps = [];
   if (pcbBoard) {
     if (pcbBoard.width !== void 0) {
@@ -679,7 +1008,11 @@ var getBoardUsingTemplate = ({
   }
   const boardPropsStr = boardProps.join(" ");
   const footprintTsx = generateFootprintTsx(circuitJson);
-  const children = footprintTsx ? `<chip footprint={${footprintTsx}} />` : "";
+  const copperPoursTsx = generateCopperPoursTsx(circuitJson);
+  const children = [
+    footprintTsx ? `<chip footprint={${footprintTsx}} />` : "",
+    ...copperPoursTsx
+  ].filter(Boolean).join("\n");
   return `
 ${componentName ? `export const ${componentName} =` : "export default"} () => (
   <board${boardPropsStr ? ` ${boardPropsStr}` : ""}>
@@ -691,18 +1024,18 @@ ${componentName ? `export default ${componentName}` : ""}
 };
 
 // lib/generate-symbol-tsx.ts
-import { su as su15 } from "@tscircuit/soup-util";
+import { su as su17 } from "@tscircuit/soup-util";
 var escapeJsxText2 = (text) => text.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 var generateSymbolTsx = (circuitJson) => {
-  const schematicArcs = su15(circuitJson).schematic_arc.list();
-  const schematicLines = su15(circuitJson).schematic_line.list();
-  const schematicPaths = su15(circuitJson).schematic_path.list();
-  const schematicTexts = su15(circuitJson).schematic_text.list();
-  const schematicCircles = su15(circuitJson).schematic_circle.list();
-  const schematicBoxes = su15(circuitJson).schematic_box.list();
-  const schematicRects = su15(circuitJson).schematic_rect.list();
-  const schematicTables = su15(circuitJson).schematic_table.list();
-  const schematicTableCells = su15(circuitJson).schematic_table_cell.list();
+  const schematicArcs = su17(circuitJson).schematic_arc.list();
+  const schematicLines = su17(circuitJson).schematic_line.list();
+  const schematicPaths = su17(circuitJson).schematic_path.list();
+  const schematicTexts = su17(circuitJson).schematic_text.list();
+  const schematicCircles = su17(circuitJson).schematic_circle.list();
+  const schematicBoxes = su17(circuitJson).schematic_box.list();
+  const schematicRects = su17(circuitJson).schematic_rect.list();
+  const schematicTables = su17(circuitJson).schematic_table.list();
+  const schematicTableCells = su17(circuitJson).schematic_table_cell.list();
   const elementStrings = [];
   for (const arc of schematicArcs) {
     const center = arc.center ?? { x: 0, y: 0 };

package/dist/cli/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   convertCircuitJsonToTscircuit
-} from "../chunk-U24G34W6.js";
+} from "../chunk-QMIS5SJZ.js";
 
 // cli/main.ts
 import { Command } from "commander";
@@ -16,7 +16,7 @@ var package_default = {
     "./cli": "./dist/cli/main.js"
   },
   type: "module",
-  version: "0.0.56",
+  version: "0.0.58",
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/circuit-json-to-tscircuit.git"

package/dist/lib/index.js

@@ -1,6 +1,6 @@
 import {
   convertCircuitJsonToTscircuit
-} from "../chunk-U24G34W6.js";
+} from "../chunk-QMIS5SJZ.js";
 export {
   convertCircuitJsonToTscircuit
 };

package/lib/flatten-brep-ring.ts

@@ -0,0 +1,46 @@
+import type { Point } from "circuit-json"
+import { getBulgeArc, type BulgePoint } from "./get-bulge-arc"
+
+const MAX_ANGLE_STEP = Math.PI / 18
+
+export const flattenBrepRing = (vertices: BulgePoint[]): Point[] => {
+  if (vertices.length < 2) return vertices.map(toPoint)
+
+  const points: Point[] = [toPoint(vertices[0]!)]
+  for (let index = 0; index < vertices.length; index++) {
+    const start = vertices[index]!
+    const end = vertices[(index + 1) % vertices.length]!
+    const isClosingSegment = index === vertices.length - 1
+    const arc = getBulgeArc({ end, start })
+
+    if (!arc) {
+      if (!isClosingSegment) points.push(toPoint(end))
+      continue
+    }
+
+    const startAngle = Math.atan2(
+      start.y - arc.center.y,
+      start.x - arc.center.x,
+    )
+    const stepCount = Math.max(
+      2,
+      Math.ceil(Math.abs(arc.sweepAngle) / MAX_ANGLE_STEP),
+    )
+    for (let step = 1; step <= stepCount; step++) {
+      if (isClosingSegment && step === stepCount) continue
+      if (step === stepCount) {
+        points.push(toPoint(end))
+        continue
+      }
+      const angle = startAngle + (arc.sweepAngle * step) / stepCount
+      points.push({
+        x: arc.center.x + arc.radius * Math.cos(angle),
+        y: arc.center.y + arc.radius * Math.sin(angle),
+      })
+    }
+  }
+
+  return points
+}
+
+const toPoint = ({ x, y }: BulgePoint): Point => ({ x, y })