@tscircuit/checks 0.0.196 → 0.0.197

package/dist/index.js

@@ -1,3 +1,711 @@
+// lib/check-copper-pour-shorts.ts
+import Flatbush from "flatbush";
+import "@flatten-js/core";
+import { getReadableNameForElement } from "@tscircuit/circuit-json-util";
+
+// node_modules/@tscircuit/circuit-json-to-flattenjs/dist/index.js
+import * as F from "@flatten-js/core";
+import { Vector as Vector2 } from "@flatten-js/core";
+import { BooleanOperations } from "@flatten-js/core";
+import { Arc as Arc2 } from "@flatten-js/core";
+var EPS = 1e-9;
+var point = (p) => new F.Point(p.x, p.y);
+function positive(value, name) {
+  if (!Number.isFinite(value) || value <= 0)
+    throw new Error(`${name} must be finite and positive`);
+  return value;
+}
+function circle(center, radius) {
+  positive(radius, "radius");
+  return new F.Polygon(new F.Circle(point(center), radius));
+}
+function ring(vertices) {
+  const clean = vertices.filter(
+    (p, i) => i === 0 || point(p).distanceTo(point(vertices[i - 1]))[0] > EPS
+  );
+  if (clean.length > 1 && point(clean[0]).distanceTo(point(clean.at(-1)))[0] <= EPS)
+    clean.pop();
+  if (clean.length < 2)
+    throw new Error("A ring needs at least two distinct vertices");
+  const edges = clean.map((a, i) => {
+    const b = clean[(i + 1) % clean.length];
+    if (![a.x, a.y, a.bulge ?? 0].every(Number.isFinite))
+      throw new Error("Non-finite ring vertex");
+    const bulge = a.bulge ?? 0;
+    if (Math.abs(bulge) <= EPS) return new F.Segment(point(a), point(b));
+    const dx = b.x - a.x, dy = b.y - a.y;
+    const length = Math.hypot(dx, dy);
+    const offset = length * (1 - bulge * bulge) / (4 * bulge);
+    const center = new F.Point(
+      (a.x + b.x) / 2 - dy / length * offset,
+      (a.y + b.y) / 2 + dx / length * offset
+    );
+    return new F.Arc(
+      center,
+      length * (1 + bulge * bulge) / (4 * Math.abs(bulge)),
+      Math.atan2(a.y - center.y, a.x - center.x),
+      Math.atan2(b.y - center.y, b.x - center.x),
+      bulge > 0
+    );
+  });
+  const polygon = new F.Polygon();
+  polygon.addFace(edges);
+  if (polygon.area() <= EPS)
+    throw new Error("A ring must enclose a non-zero area");
+  return polygon;
+}
+function rectangle(center, width, height, rotation = 0, radius = 0) {
+  positive(width, "width");
+  positive(height, "height");
+  if (!Number.isFinite(rotation) || !Number.isFinite(radius) || radius < 0)
+    throw new Error("Invalid rectangle rotation or corner radius");
+  const r = Math.min(radius, width / 2, height / 2);
+  const x = width / 2, y = height / 2;
+  let polygon;
+  if (r <= EPS)
+    polygon = ring([
+      { x: -x, y: -y },
+      { x, y: -y },
+      { x, y },
+      { x: -x, y }
+    ]);
+  else {
+    const corners = [
+      new F.Point(x - r, -y + r),
+      new F.Point(x - r, y - r),
+      new F.Point(-x + r, y - r),
+      new F.Point(-x + r, -y + r)
+    ];
+    const edges = [];
+    for (let i = 0; i < 4; i++) {
+      const angle = -Math.PI / 2 + i * Math.PI / 2;
+      const arc = new F.Arc(corners[i], r, angle, angle + Math.PI / 2, true);
+      const next = corners[(i + 1) % 4];
+      const nextStart = new F.Point(
+        next.x + r * Math.cos(angle + Math.PI / 2),
+        next.y + r * Math.sin(angle + Math.PI / 2)
+      );
+      edges.push(arc);
+      if (arc.end.distanceTo(nextStart)[0] > EPS)
+        edges.push(new F.Segment(arc.end, nextStart));
+    }
+    polygon = new F.Polygon();
+    polygon.addFace(edges);
+  }
+  return polygon.rotate(rotation * Math.PI / 180).translate(new F.Vector(center.x, center.y));
+}
+function stroke(a, b, widthA, widthB = widthA) {
+  const r1 = positive(widthA, "trace width") / 2, r2 = positive(widthB, "trace width") / 2;
+  const d = point(a).distanceTo(point(b))[0];
+  if (d <= Math.abs(r1 - r2) + EPS)
+    return circle(r1 >= r2 ? a : b, Math.max(r1, r2));
+  const theta = Math.atan2(b.y - a.y, b.x - a.x);
+  const alpha = Math.acos((r1 - r2) / d);
+  const low = theta - alpha, high = theta + alpha;
+  const p = (c, r, angle) => new F.Point(c.x + r * Math.cos(angle), c.y + r * Math.sin(angle));
+  const polygon = new F.Polygon();
+  polygon.addFace([
+    new F.Segment(p(a, r1, low), p(b, r2, low)),
+    new F.Arc(point(b), r2, low, high, true),
+    new F.Segment(p(b, r2, high), p(a, r1, high)),
+    new F.Arc(point(a), r1, high, low, true)
+  ]);
+  return polygon;
+}
+function withHoles(outer, holes) {
+  const result = outer.clone();
+  const orientation = [...result.faces][0].orientation();
+  for (const hole of holes) {
+    const copy = hole.clone();
+    if ([...copy.faces][0].orientation() === orientation) copy.reverse();
+    for (const face of copy.faces) result.addFace(face.shapes);
+  }
+  return result;
+}
+function ellipse(center, width, height, rotation = 0, tolerance = 1e-3) {
+  positive(width, "ellipse width");
+  positive(height, "ellipse height");
+  positive(tolerance, "curveTolerance");
+  if (Math.abs(width - height) < EPS) return circle(center, width / 2);
+  const radius = Math.max(width, height) / 2;
+  const count = Math.max(
+    16,
+    Math.ceil(Math.PI / Math.acos(Math.max(-1, 1 - tolerance / radius)))
+  );
+  if (count > 1e5)
+    throw new Error("curveTolerance requires more than 100000 ellipse segments");
+  return ring(
+    Array.from({ length: count }, (_, i) => ({
+      x: width / 2 * Math.cos(i * 2 * Math.PI / count),
+      y: height / 2 * Math.sin(i * 2 * Math.PI / count)
+    }))
+  ).rotate(rotation * Math.PI / 180).translate(new F.Vector(center.x, center.y));
+}
+function getCopperLayers(json, options) {
+  if (options.copperLayers) {
+    if (!options.copperLayers.length || new Set(options.copperLayers).size !== options.copperLayers.length)
+      throw new Error(
+        "copperLayers must be a non-empty list without duplicates"
+      );
+    return [...options.copperLayers];
+  }
+  const board = json.find((e) => e.type === "pcb_board");
+  let count = board?.num_layers ?? 2;
+  for (const element of json) {
+    const layers = "layers" in element ? element.layers : "layer" in element ? [element.layer] : [];
+    if (Array.isArray(layers))
+      for (const layer of layers) {
+        const match = typeof layer === "string" && /^inner(\d+)$/.exec(layer);
+        if (match) count = Math.max(count, Number(match[1]) + 2);
+      }
+    if (element.type === "pcb_trace")
+      for (const p of element.route) {
+        for (const layer of p.route_type === "wire" ? [p.layer] : p.route_type === "via" ? [p.from_layer, p.to_layer] : [p.start_layer, p.end_layer]) {
+          const match = /^inner(\d+)$/.exec(layer);
+          if (match) count = Math.max(count, Number(match[1]) + 2);
+        }
+      }
+  }
+  if (!Number.isInteger(count) || count < 1 || count > 10)
+    throw new Error("Supported copper layer count is 1\u201310");
+  return count === 1 ? ["top"] : [
+    "top",
+    ...Array.from(
+      { length: count - 2 },
+      (_, i) => `inner${i + 1}`
+    ),
+    "bottom"
+  ];
+}
+function spanLayers(layers, stack) {
+  if (!layers.length) return [];
+  const indices = layers.map((layer) => stack.indexOf(layer));
+  if (indices.some((i) => i < 0))
+    throw new Error(`Layer is missing from copperLayers: ${layers.join(", ")}`);
+  return stack.slice(Math.min(...indices), Math.max(...indices) + 1);
+}
+function smtPad(pad) {
+  switch (pad.shape) {
+    case "circle":
+      return circle(pad, pad.radius);
+    case "polygon":
+      return ring(pad.points);
+    case "rect":
+    case "rotated_rect":
+      return rectangle(
+        pad,
+        pad.width,
+        pad.height,
+        "ccw_rotation" in pad ? pad.ccw_rotation : 0,
+        pad.rect_border_radius ?? pad.corner_radius ?? 0
+      );
+    case "pill":
+    case "rotated_pill":
+      return rectangle(
+        pad,
+        pad.width,
+        pad.height,
+        "ccw_rotation" in pad ? pad.ccw_rotation : 0,
+        pad.radius
+      );
+  }
+}
+function nonPlatedHole(hole, tolerance) {
+  switch (hole.hole_shape) {
+    case "circle":
+      return circle(hole, hole.hole_diameter / 2);
+    case "square":
+      return rectangle(hole, hole.hole_diameter, hole.hole_diameter);
+    case "rect":
+      return rectangle(hole, hole.hole_width, hole.hole_height);
+    case "oval":
+      return ellipse(hole, hole.hole_width, hole.hole_height, 0, tolerance);
+    case "pill":
+    case "rotated_pill":
+      return rectangle(
+        hole,
+        hole.hole_width,
+        hole.hole_height,
+        "ccw_rotation" in hole ? hole.ccw_rotation : 0,
+        Math.min(hole.hole_width, hole.hole_height) / 2
+      );
+  }
+}
+function platedHole(hole, componentRotation, includeDrill, tolerance) {
+  let outer;
+  let drill;
+  const drillCenter = {
+    x: hole.x + ("hole_offset_x" in hole ? hole.hole_offset_x ?? 0 : 0),
+    y: hole.y + ("hole_offset_y" in hole ? hole.hole_offset_y ?? 0 : 0)
+  };
+  switch (hole.shape) {
+    case "circle":
+      outer = circle(hole, hole.outer_diameter / 2);
+      drill = circle(hole, hole.hole_diameter / 2);
+      break;
+    case "oval":
+      outer = ellipse(
+        hole,
+        hole.outer_width,
+        hole.outer_height,
+        hole.ccw_rotation,
+        tolerance
+      );
+      drill = ellipse(
+        hole,
+        hole.hole_width,
+        hole.hole_height,
+        hole.ccw_rotation,
+        tolerance
+      );
+      break;
+    case "pill":
+      outer = rectangle(
+        hole,
+        hole.outer_width,
+        hole.outer_height,
+        hole.ccw_rotation,
+        Math.min(hole.outer_width, hole.outer_height) / 2
+      );
+      drill = rectangle(
+        hole,
+        hole.hole_width,
+        hole.hole_height,
+        hole.ccw_rotation,
+        Math.min(hole.hole_width, hole.hole_height) / 2
+      );
+      break;
+    case "circular_hole_with_rect_pad":
+    case "pill_hole_with_rect_pad":
+    case "rotated_pill_hole_with_rect_pad":
+      outer = rectangle(
+        hole,
+        hole.rect_pad_width,
+        hole.rect_pad_height,
+        "rect_ccw_rotation" in hole ? hole.rect_ccw_rotation : 0,
+        hole.rect_border_radius ?? 0
+      );
+      drill = hole.shape === "circular_hole_with_rect_pad" ? circle(drillCenter, hole.hole_diameter / 2) : rectangle(
+        drillCenter,
+        hole.hole_width,
+        hole.hole_height,
+        "hole_ccw_rotation" in hole ? hole.hole_ccw_rotation : 0,
+        Math.min(hole.hole_width, hole.hole_height) / 2
+      );
+      break;
+    case "hole_with_polygon_pad": {
+      const rotation = hole.ccw_rotation ?? componentRotation;
+      outer = ring(hole.pad_outline).rotate(rotation * Math.PI / 180).translate(new Vector2(hole.x, hole.y));
+      drill = hole.hole_shape === "circle" ? circle(drillCenter, hole.hole_diameter / 2) : hole.hole_shape === "oval" ? ellipse(
+        drillCenter,
+        hole.hole_width,
+        hole.hole_height,
+        rotation,
+        tolerance
+      ) : rectangle(
+        drillCenter,
+        hole.hole_width,
+        hole.hole_height,
+        rotation,
+        Math.min(hole.hole_width, hole.hole_height) / 2
+      );
+      break;
+    }
+  }
+  return includeDrill ? withHoles(outer, [drill]) : outer;
+}
+var samePoint = (a, b) => a.x === b.x && a.y === b.y;
+var unit = (x, y) => {
+  const length = Math.hypot(x, y);
+  return length ? { x: x / length, y: y / length } : { x: 1, y: 0 };
+};
+function interpolatedPolygon(segments) {
+  const points = [
+    { ...segments[0].start, width: segments[0].startWidth },
+    ...segments.map((s) => ({ ...s.end, width: s.endWidth }))
+  ];
+  const directions = segments.map(
+    (s) => unit(s.end.x - s.start.x, s.end.y - s.start.y)
+  );
+  const left = [], right = [];
+  for (let i = 0; i < points.length; i++) {
+    const p = points[i];
+    positive(p.width, "interpolated trace width");
+    const before = directions[Math.max(0, i - 1)], after = directions[Math.min(i, directions.length - 1)];
+    const d = unit(before.x + after.x, before.y + after.y);
+    const nx = -d.y * p.width / 2, ny = d.x * p.width / 2;
+    left.push({ x: p.x + nx, y: p.y + ny });
+    right.push({ x: p.x - nx, y: p.y - ny });
+  }
+  return ring([...left, ...right.reverse()]);
+}
+function traceGeometry(trace, stack, includeDrill) {
+  const result = /* @__PURE__ */ new Map();
+  const drills = /* @__PURE__ */ new Map();
+  const segments = [];
+  const add = (layer, shape) => result.set(layer, [...result.get(layer) ?? [], shape]);
+  for (const p of trace.route) {
+    if (p.route_type === "via") {
+      const legacy = p;
+      const outerDiameter = p.outer_diameter ?? legacy.via_diameter;
+      if (outerDiameter === void 0) continue;
+      const holeDiameter = p.hole_diameter ?? legacy.via_hole_diameter;
+      const shape = circle(p, outerDiameter / 2);
+      const drill = includeDrill && holeDiameter ? circle(p, holeDiameter / 2) : void 0;
+      for (const layer of spanLayers([p.from_layer, p.to_layer], stack)) {
+        add(layer, drill ? withHoles(shape, [drill]) : shape);
+        if (drill) drills.set(layer, [...drills.get(layer) ?? [], drill]);
+      }
+    }
+    if (p.route_type === "through_pad") {
+      for (const layer of /* @__PURE__ */ new Set([p.start_layer, p.end_layer]))
+        add(layer, stroke(p.start, p.end, p.width));
+    }
+  }
+  for (let i = 0; i < trace.route.length - 1; i++) {
+    const a = trace.route[i], b = trace.route[i + 1];
+    const start = a.route_type === "through_pad" ? a.end : a;
+    const end = b.route_type === "through_pad" ? b.start : b;
+    if (samePoint(start, end)) continue;
+    const startLayers = a.route_type === "wire" ? [a.layer] : a.route_type === "via" ? spanLayers([a.from_layer, a.to_layer], stack) : [a.end_layer];
+    const endLayers = b.route_type === "wire" ? [b.layer] : b.route_type === "via" ? spanLayers([b.from_layer, b.to_layer], stack) : [b.start_layer];
+    const sharedLayers = startLayers.filter(
+      (layer) => endLayers.includes(layer)
+    );
+    if (sharedLayers.length !== 1)
+      throw new Error(
+        `Cannot determine one wire layer between route points ${i} and ${i + 1}`
+      );
+    const startLayer = sharedLayers[0];
+    const width = "width" in a ? a.width : "width" in b ? b.width : void 0;
+    if (width === void 0 || samePoint(start, end)) continue;
+    segments.push({
+      start,
+      end,
+      layer: startLayer,
+      startWidth: width,
+      endWidth: "width" in b ? b.width : width
+    });
+  }
+  if (trace.route_thickness_mode === "interpolated") {
+    let group = [];
+    const flush = () => {
+      if (group.length) {
+        add(group[0].layer, interpolatedPolygon(group));
+        group = [];
+      }
+    };
+    for (const segment of segments) {
+      const last = group.at(-1);
+      if (last && (last.layer !== segment.layer || !samePoint(last.end, segment.start) || last.endWidth !== segment.startWidth))
+        flush();
+      group.push(segment);
+    }
+    flush();
+  } else
+    for (const s of segments) add(s.layer, stroke(s.start, s.end, s.startWidth));
+  for (const [layer, holes] of drills) {
+    result.set(
+      layer,
+      result.get(layer).map(
+        (shape) => holes.reduce(
+          (shape2, hole) => BooleanOperations.subtract(shape2, hole),
+          shape
+        )
+      ).filter((shape) => shape.faces.size > 0)
+    );
+  }
+  return result;
+}
+var supportedElementTypes = [
+  "pcb_board",
+  "pcb_smtpad",
+  "pcb_plated_hole",
+  "pcb_hole",
+  "pcb_via",
+  "pcb_trace",
+  "pcb_copper_pour",
+  "pcb_cutout",
+  "pcb_keepout",
+  "pcb_courtyard_rect",
+  "pcb_courtyard_circle",
+  "pcb_courtyard_pill",
+  "pcb_courtyard_polygon",
+  "pcb_courtyard_outline"
+];
+function cutoutGeometry(cutout) {
+  switch (cutout.shape) {
+    case "circle":
+      return [circle(cutout.center, cutout.radius)];
+    case "rect":
+      return [
+        rectangle(
+          cutout.center,
+          cutout.width,
+          cutout.height,
+          cutout.rotation,
+          cutout.corner_radius
+        )
+      ];
+    case "polygon":
+      return [ring(cutout.points)];
+    case "path": {
+      if (cutout.slot_length !== void 0 || cutout.space_between_slots !== void 0 || cutout.slot_corner_radius !== void 0) {
+        throw new Error(
+          "Patterned/custom-corner path cutouts are not supported; use explicit rect/polygon cutouts"
+        );
+      }
+      return cutout.route.slice(1).map((p, i) => stroke(cutout.route[i], p, cutout.slot_width));
+    }
+  }
+}
+function convertCircuitJsonToFlattenJs(json, options = {}) {
+  if (options.layer && options.layers)
+    throw new Error("Specify layer or layers, not both");
+  const selectedLayers = options.layer ? [options.layer] : options.layers;
+  const stack = getCopperLayers(json, options);
+  const result = {
+    elements: [],
+    warnings: [],
+    bounds: void 0,
+    copperLayers: stack
+  };
+  const rotations = new Map(
+    json.filter((e) => e.type === "pcb_component").map((e) => [e.pcb_component_id, e.rotation])
+  );
+  const tolerance = options.curveTolerance ?? 1e-3;
+  if (!Number.isFinite(tolerance) || tolerance <= 0)
+    throw new Error("curveTolerance must be finite and positive");
+  const includeDrill = options.includeDrillHoles !== false;
+  for (const element of json) {
+    if (!supportedElementTypes.includes(element.type))
+      continue;
+    const elementId = element[`${element.type}_id`];
+    if (options.elementTypes && !options.elementTypes.includes(element.type))
+      continue;
+    if (options.elementIds && !options.elementIds.includes(elementId)) continue;
+    let role = "copper";
+    let layers = [null];
+    let shapes = [];
+    let byLayer;
+    try {
+      switch (element.type) {
+        case "pcb_smtpad":
+          layers = [element.layer];
+          shapes = [smtPad(element)];
+          break;
+        case "pcb_plated_hole":
+          layers = spanLayers(element.layers, stack);
+          shapes = [
+            platedHole(
+              element,
+              rotations.get(element.pcb_component_id ?? "") ?? 0,
+              includeDrill,
+              tolerance
+            )
+          ];
+          break;
+        case "pcb_via": {
+          layers = spanLayers(element.layers, stack);
+          const outer = circle(element, element.outer_diameter / 2);
+          shapes = [
+            includeDrill ? withHoles(outer, [circle(element, element.hole_diameter / 2)]) : outer
+          ];
+          break;
+        }
+        case "pcb_trace":
+          byLayer = traceGeometry(element, stack, includeDrill);
+          layers = [...byLayer.keys()];
+          break;
+        case "pcb_copper_pour":
+          layers = [element.layer];
+          shapes = [
+            element.shape === "rect" ? rectangle(
+              element.center,
+              element.width,
+              element.height,
+              element.rotation
+            ) : element.shape === "polygon" ? ring(element.points) : withHoles(
+              ring(element.brep_shape.outer_ring.vertices),
+              element.brep_shape.inner_rings.map(
+                (h) => ring(h.vertices)
+              )
+            )
+          ];
+          break;
+        case "pcb_board":
+          role = "board";
+          shapes = [
+            element.outline?.length ? ring(element.outline) : rectangle(element.center, element.width, element.height)
+          ];
+          break;
+        case "pcb_hole":
+          role = "drill";
+          shapes = [nonPlatedHole(element, tolerance)];
+          break;
+        case "pcb_cutout":
+          role = "cutout";
+          shapes = cutoutGeometry(element);
+          break;
+        case "pcb_keepout":
+          role = "keepout";
+          layers = element.layers;
+          shapes = [
+            element.shape === "circle" ? circle(element.center, element.radius) : element.shape === "rect" ? rectangle(element.center, element.width, element.height) : ring(element.outline)
+          ];
+          break;
+        case "pcb_courtyard_rect":
+          role = "courtyard";
+          layers = [element.layer];
+          shapes = [
+            rectangle(
+              element.center,
+              element.width,
+              element.height,
+              element.ccw_rotation
+            )
+          ];
+          break;
+        case "pcb_courtyard_circle":
+          role = "courtyard";
+          layers = [element.layer];
+          shapes = [circle(element.center, element.radius)];
+          break;
+        case "pcb_courtyard_pill":
+          role = "courtyard";
+          layers = [element.layer];
+          shapes = [
+            rectangle(
+              element.center,
+              element.width,
+              element.height,
+              0,
+              element.radius
+            )
+          ];
+          break;
+        case "pcb_courtyard_polygon":
+          role = "courtyard";
+          layers = [element.layer];
+          shapes = [ring(element.points)];
+          break;
+        case "pcb_courtyard_outline":
+          role = "courtyard";
+          layers = [element.layer];
+          shapes = [ring(element.outline)];
+          break;
+      }
+      if (options.roles && !options.roles.includes(role)) continue;
+      const convertedElements = [];
+      for (const layer of new Set(layers)) {
+        if (layer === null ? options.includeLayerless === false : selectedLayers && !selectedLayers.includes(layer))
+          continue;
+        const layerShapes = byLayer?.get(layer) ?? shapes;
+        if (!layerShapes.length) continue;
+        const bounds = layerShapes.reduce(
+          (box, shape) => box.merge(shape.box),
+          layerShapes[0].box
+        );
+        if (![bounds.xmin, bounds.ymin, bounds.xmax, bounds.ymax].every(
+          Number.isFinite
+        ))
+          throw new Error("Non-finite geometry bounds");
+        const converted = {
+          elementId,
+          elementType: element.type,
+          sourceElement: element,
+          role,
+          layer,
+          shapes: layerShapes,
+          bounds
+        };
+        convertedElements.push(converted);
+      }
+      for (const converted of convertedElements) {
+        result.elements.push(converted);
+        result.bounds = result.bounds ? result.bounds.merge(converted.bounds) : converted.bounds;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (options.strict) throw new Error(`${elementId}: ${message}`);
+      result.warnings.push({ elementId, elementType: element.type, message });
+    }
+  }
+  return result;
+}
+
+// lib/check-copper-pour-shorts.ts
+import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectivity-map";
+function touchesPour(pour, geometry) {
+  if (!pour.box.intersect(geometry.box)) return false;
+  return pour.intersect(geometry).length > 0 || [...geometry.faces].some((face) => pour.contains(face.first.start)) || [...pour.faces].some((face) => geometry.contains(face.first.start));
+}
+function checkCopperPourShorts(circuitJson) {
+  if (!circuitJson.some((e) => e.type === "pcb_copper_pour")) return [];
+  const connMap = getFullConnectivityMapFromCircuitJson(circuitJson);
+  const { elements: copper } = convertCircuitJsonToFlattenJs(circuitJson, {
+    elementTypes: [
+      "pcb_smtpad",
+      "pcb_plated_hole",
+      "pcb_via",
+      "pcb_trace",
+      "pcb_copper_pour"
+    ],
+    strict: true
+  });
+  const layers = /* @__PURE__ */ new Map();
+  for (const element of copper) {
+    const entries = layers.get(element.layer) ?? [];
+    for (const shape of element.shapes) entries.push({ element, shape });
+    layers.set(element.layer, entries);
+  }
+  const indexes = new Map(
+    [...layers].map(([layer, entries]) => {
+      const index = new Flatbush(entries.length);
+      for (const { shape } of entries) {
+        const b = shape.box;
+        index.add(b.xmin, b.ymin, b.xmax, b.ymax);
+      }
+      index.finish();
+      return [layer, { index, entries }];
+    })
+  );
+  const netNames = new Map(
+    circuitJson.filter((e) => e.type === "source_net").map((e) => [e.source_net_id, e.name])
+  );
+  const errors = /* @__PURE__ */ new Map();
+  for (const pour of copper) {
+    const element = pour.sourceElement;
+    if (element.type !== "pcb_copper_pour") continue;
+    const netId = element.source_net_id;
+    const { index, entries } = indexes.get(pour.layer);
+    const candidates = /* @__PURE__ */ new Set();
+    for (const shape of pour.shapes) {
+      const b = shape.box;
+      for (const i of index.search(b.xmin, b.ymin, b.xmax, b.ymax))
+        candidates.add(i);
+    }
+    for (const i of [...candidates].sort((a, b) => a - b)) {
+      const { element: other, shape: otherShape } = entries[i];
+      if (pour.elementId === other.elementId) continue;
+      const otherNetId = other.sourceElement.type === "pcb_copper_pour" ? other.sourceElement.source_net_id : other.elementId;
+      if (netId && otherNetId && (netId === otherNetId || connMap.areIdsConnected(netId, otherNetId)))
+        continue;
+      const id = `copper_pour_short_${[pour.elementId, other.elementId].sort().join("_")}`;
+      if (errors.has(id) || !pour.shapes.some((shape) => touchesPour(shape, otherShape)))
+        continue;
+      errors.set(id, {
+        type: "pcb_placement_error",
+        pcb_placement_error_id: id,
+        error_type: "pcb_placement_error",
+        message: `Copper pour ${pour.elementId} (${netNames.get(netId) ?? netId ?? "unassigned net"}) shorts to ${getReadableNameForElement(circuitJson, other.elementId)} (${other.elementId}) on ${pour.layer} (accidental copper contact)`,
+        subcircuit_id: element.subcircuit_id
+      });
+    }
+  }
+  return [...errors.values()];
+}
+
 // lib/check-traces-are-contiguous/is-point-in-pad.ts
 import { pointToSegmentDistance } from "@tscircuit/math-utils";
 
@@ -9,11 +717,11 @@ import {
   pointToSegmentClosestPoint,
   segmentToSegmentMinDistance
 } from "@tscircuit/math-utils";
-var rotatePoint = (point, angleDegrees) => {
+var rotatePoint = (point2, angleDegrees) => {
   const angle = angleDegrees * Math.PI / 180;
   return {
-    x: point.x * Math.cos(angle) - point.y * Math.sin(angle),
-    y: point.x * Math.sin(angle) + point.y * Math.cos(angle)
+    x: point2.x * Math.cos(angle) - point2.y * Math.sin(angle),
+    y: point2.x * Math.sin(angle) + point2.y * Math.cos(angle)
   };
 };
 var getRotatedRectPoints = ({
@@ -30,8 +738,8 @@ var getRotatedRectPoints = ({
     { x: halfWidth, y: -halfHeight },
     { x: halfWidth, y: halfHeight },
     { x: -halfWidth, y: halfHeight }
-  ].map((point) => {
-    const rotated = rotatePoint(point, ccwRotation);
+  ].map((point2) => {
+    const rotated = rotatePoint(point2, ccwRotation);
     return { x: x + rotated.x, y: y + rotated.y };
   });
 };
@@ -76,7 +784,7 @@ var getPolygonPointsForPad = (pad) => {
   );
 };
 var getPolygonEdges = (points) => points.map(
-  (point, index) => [point, points[(index + 1) % points.length]]
+  (point2, index) => [point2, points[(index + 1) % points.length]]
 );
 var getClosestPointsBetweenSegments = (a1, a2, b1, b2) => {
   const intersection = getSegmentIntersection(a1, a2, b1, b2);
@@ -127,7 +835,7 @@ var getSegmentToPolygonClearanceFromPoints = (start, end, polygon) => {
   }
   const intersections = getPolygonEdges(polygon).map(
     ([edgeStart, edgeEnd]) => getSegmentIntersection(start, end, edgeStart, edgeEnd)
-  ).filter((point) => point !== null);
+  ).filter((point2) => point2 !== null);
   if (intersections.length > 0) {
     const dx = end.x - start.x;
     const dy = end.y - start.y;
@@ -179,17 +887,17 @@ var getSegmentToPolygonClearanceFromPoints = (start, end, polygon) => {
   };
 };
 var getSegmentToPillClearance = (segment, pad) => {
-  const pill2 = getPillCenterLineForPad(pad);
+  const pill = getPillCenterLineForPad(pad);
   const closest = getClosestPointsBetweenSegments(
     { x: segment.x1, y: segment.y1 },
     { x: segment.x2, y: segment.y2 },
-    pill2.start,
-    pill2.end
+    pill.start,
+    pill.end
   );
   return {
     distance: closest.distance,
     center: closest.center,
-    radius: pill2.radius,
+    radius: pill.radius,
     tracePoint: closest.pointOnA,
     obstaclePoint: closest.pointOnB
   };
@@ -201,73 +909,73 @@ function getDistanceBetweenPoints(pointA, pointB) {
 }
 var POINT_ON_SEGMENT_TOLERANCE_MM = 1e-9;
 var POINT_IN_PAD_TOLERANCE_MM = 1e-9;
-function isPointOnSegment(point, segment) {
-  const crossProduct = (point.y - segment.start.y) * (segment.end.x - segment.start.x) - (point.x - segment.start.x) * (segment.end.y - segment.start.y);
+function isPointOnSegment(point2, segment) {
+  const crossProduct = (point2.y - segment.start.y) * (segment.end.x - segment.start.x) - (point2.x - segment.start.x) * (segment.end.y - segment.start.y);
   if (Math.abs(crossProduct) > POINT_ON_SEGMENT_TOLERANCE_MM) return false;
-  const dotProduct = (point.x - segment.start.x) * (segment.end.x - segment.start.x) + (point.y - segment.start.y) * (segment.end.y - segment.start.y);
+  const dotProduct = (point2.x - segment.start.x) * (segment.end.x - segment.start.x) + (point2.y - segment.start.y) * (segment.end.y - segment.start.y);
   if (dotProduct < -POINT_ON_SEGMENT_TOLERANCE_MM) return false;
   const squaredLength = (segment.end.x - segment.start.x) ** 2 + (segment.end.y - segment.start.y) ** 2;
   return dotProduct <= squaredLength + POINT_ON_SEGMENT_TOLERANCE_MM;
 }
-function isPointInPolygon(point, polygon) {
+function isPointInPolygon(point2, polygon) {
   let inside = false;
   for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
     const pi = polygon[i];
     const pj = polygon[j];
-    if (isPointOnSegment(point, { start: pi, end: pj })) return true;
-    const intersects = pi.y > point.y !== pj.y > point.y && point.x < (pj.x - pi.x) * (point.y - pi.y) / (pj.y - pi.y) + pi.x;
+    if (isPointOnSegment(point2, { start: pi, end: pj })) return true;
+    const intersects = pi.y > point2.y !== pj.y > point2.y && point2.x < (pj.x - pi.x) * (point2.y - pi.y) / (pj.y - pi.y) + pi.x;
     if (intersects) inside = !inside;
   }
   return inside;
 }
-function isPointInPad(point, pad) {
+function isPointInPad(point2, pad) {
   if (pad.type === "pcb_smtpad") {
     if (pad.shape === "circle") {
-      return getDistanceBetweenPoints(point, pad) <= pad.radius + POINT_IN_PAD_TOLERANCE_MM;
+      return getDistanceBetweenPoints(point2, pad) <= pad.radius + POINT_IN_PAD_TOLERANCE_MM;
     }
     if (pad.shape === "rect") {
       const halfWidth = pad.width / 2;
       const halfHeight = pad.height / 2;
-      return Math.abs(point.x - pad.x) <= halfWidth + POINT_IN_PAD_TOLERANCE_MM && Math.abs(point.y - pad.y) <= halfHeight + POINT_IN_PAD_TOLERANCE_MM;
+      return Math.abs(point2.x - pad.x) <= halfWidth + POINT_IN_PAD_TOLERANCE_MM && Math.abs(point2.y - pad.y) <= halfHeight + POINT_IN_PAD_TOLERANCE_MM;
     }
     if (pad.shape === "rotated_rect") {
-      return isPointInPolygon(point, getPolygonPointsForPad(pad));
+      return isPointInPolygon(point2, getPolygonPointsForPad(pad));
     }
     if (pad.shape === "pill" || pad.shape === "rotated_pill") {
       if (pad.shape === "rotated_pill") {
-        const pill2 = getPillCenterLineForPad(pad);
-        return pointToSegmentDistance(point, pill2.start, pill2.end) <= pill2.radius + POINT_IN_PAD_TOLERANCE_MM;
+        const pill = getPillCenterLineForPad(pad);
+        return pointToSegmentDistance(point2, pill.start, pill.end) <= pill.radius + POINT_IN_PAD_TOLERANCE_MM;
       }
       const halfWidth = pad.width / 2;
       const halfHeight = pad.height / 2;
       const radius = pad.radius;
-      if (Math.abs(point.x - pad.x) <= halfWidth - radius + POINT_IN_PAD_TOLERANCE_MM && Math.abs(point.y - pad.y) <= halfHeight + POINT_IN_PAD_TOLERANCE_MM) {
+      if (Math.abs(point2.x - pad.x) <= halfWidth - radius + POINT_IN_PAD_TOLERANCE_MM && Math.abs(point2.y - pad.y) <= halfHeight + POINT_IN_PAD_TOLERANCE_MM) {
         return true;
       }
       const cornerX = Math.max(
-        Math.abs(point.x - pad.x) - (halfWidth - radius),
+        Math.abs(point2.x - pad.x) - (halfWidth - radius),
         0
       );
       const cornerY = Math.max(
-        Math.abs(point.y - pad.y) - (halfHeight - radius),
+        Math.abs(point2.y - pad.y) - (halfHeight - radius),
         0
       );
       const radiusWithTolerance = radius + POINT_IN_PAD_TOLERANCE_MM;
       return cornerX * cornerX + cornerY * cornerY <= radiusWithTolerance * radiusWithTolerance;
     }
     if (pad.shape === "polygon") {
-      return isPointInPolygon(point, pad.points);
+      return isPointInPolygon(point2, pad.points);
     }
   }
   if (pad.type === "pcb_plated_hole") {
     if (pad.shape === "circle") {
-      return getDistanceBetweenPoints(point, pad) <= pad.outer_diameter / 2 + POINT_IN_PAD_TOLERANCE_MM;
+      return getDistanceBetweenPoints(point2, pad) <= pad.outer_diameter / 2 + POINT_IN_PAD_TOLERANCE_MM;
     }
     if ("rect_pad_width" in pad && "rect_pad_height" in pad) {
-      return isPointInPolygon(point, getPolygonPointsForPad(pad));
+      return isPointInPolygon(point2, getPolygonPointsForPad(pad));
     }
     if (pad.shape === "oval" || pad.shape === "pill") {
-      return Math.abs(point.x - pad.x) <= pad.outer_width / 2 + POINT_IN_PAD_TOLERANCE_MM && Math.abs(point.y - pad.y) <= pad.outer_height / 2 + POINT_IN_PAD_TOLERANCE_MM;
+      return Math.abs(point2.x - pad.x) <= pad.outer_width / 2 + POINT_IN_PAD_TOLERANCE_MM && Math.abs(point2.y - pad.y) <= pad.outer_height / 2 + POINT_IN_PAD_TOLERANCE_MM;
     }
   }
   return false;
@@ -283,23 +991,23 @@ var addStartAndEndPortIdsIfMissing = (soup) => {
     (item) => item.type === "pcb_smtpad"
   );
   const pcbTraces = soup.filter((item) => item.type === "pcb_trace");
-  function findPortIdOverlappingPoint(point, options = {}) {
+  function findPortIdOverlappingPoint(point2, options = {}) {
     const traceWidth = options.traceWidth || 0;
     const directPort = pcbPorts.find(
-      (port) => distance(port.x, port.y, point.x, point.y) < 0.01
+      (port) => distance(port.x, port.y, point2.x, point2.y) < 0.01
     );
     if (directPort) return directPort.pcb_port_id;
     if (options.isFirstOrLastPoint) {
-      const smtPad = pcbSmtPads.find((pad) => {
+      const smtPad2 = pcbSmtPads.find((pad) => {
         if (pad.shape === "rect") {
-          return Math.abs(point.x - pad.x) < pad.width / 2 + traceWidth / 2 && Math.abs(point.y - pad.y) < pad.height / 2 + traceWidth / 2;
+          return Math.abs(point2.x - pad.x) < pad.width / 2 + traceWidth / 2 && Math.abs(point2.y - pad.y) < pad.height / 2 + traceWidth / 2;
         } else if (pad.shape === "circle") {
-          return distance(point.x, point.y, pad.x, pad.y) < pad.radius;
+          return distance(point2.x, point2.y, pad.x, pad.y) < pad.radius;
         } else if (pad.shape === "pill" || pad.shape === "rotated_pill") {
-          return isPointInPad(point, pad);
+          return isPointInPad(point2, pad);
         }
       });
-      if (smtPad) return smtPad.pcb_port_id ?? null;
+      if (smtPad2) return smtPad2.pcb_port_id ?? null;
     }
     return null;
   }
@@ -333,13 +1041,13 @@ var addStartAndEndPortIdsIfMissing = (soup) => {
 
 // lib/check-each-pcb-port-connected-to-pcb-trace.ts
 import {
-  getFullConnectivityMapFromCircuitJson,
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2,
   PcbConnectivityMap
 } from "circuit-json-to-connectivity-map";
 
 // lib/util/get-readable-names.ts
 import {
-  getReadableNameForElement,
+  getReadableNameForElement as getReadableNameForElement2,
   getReadableNameForPcbPort,
   getBoundsOfPcbElements
 } from "@tscircuit/circuit-json-util";
@@ -358,7 +1066,7 @@ var firstReadableName = (candidates, id) => {
   return "";
 };
 var getReadableNameForComponent = (circuitJson, pcbComponentId) => sanitizeReadableName(
-  getReadableNameForElement(circuitJson, pcbComponentId),
+  getReadableNameForElement2(circuitJson, pcbComponentId),
   pcbComponentId,
   "component"
 );
@@ -395,7 +1103,7 @@ var getReadableNameForPort = (circuitJson, pcbPortId) => {
     }
   }
   return sanitizeReadableName(
-    getReadableNameForPcbPort(circuitJson, pcbPortId) ?? getReadableNameForElement(circuitJson, pcbPortId),
+    getReadableNameForPcbPort(circuitJson, pcbPortId) ?? getReadableNameForElement2(circuitJson, pcbPortId),
     pcbPortId,
     "port"
   );
@@ -448,7 +1156,7 @@ var getReadableNameForSourceTrace = (circuitJson, sourceTrace) => {
   return `trace ${sourceTrace.source_trace_id}`;
 };
 var getReadableNameForElementId = (circuitJson, elementId) => sanitizeReadableName(
-  getReadableNameForElement(circuitJson, elementId),
+  getReadableNameForElement2(circuitJson, elementId),
   elementId,
   "element"
 );
@@ -640,7 +1348,7 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
     (item) => item.type === "source_net"
   );
   const errors = [];
-  const connectivityMap = getFullConnectivityMapFromCircuitJson(circuitJson);
+  const connectivityMap = getFullConnectivityMapFromCircuitJson2(circuitJson);
   const pcbConnectivityMap = new PcbConnectivityMap(circuitJson);
   let pourConnectivity;
   const getPourConnectivity = () => pourConnectivity ??= getCopperPourConnectivity(
@@ -727,7 +1435,7 @@ function checkEachPcbPortConnectedToPcbTraces(circuitJson) {
 }
 
 // lib/check-each-pcb-trace-non-overlapping/check-each-pcb-trace-non-overlapping.ts
-import { cju as cju2, getReadableNameForElement as getReadableNameForElement2 } from "@tscircuit/circuit-json-util";
+import { cju as cju2, getReadableNameForElement as getReadableNameForElement3 } from "@tscircuit/circuit-json-util";
 import { getPrimaryId as getPrimaryId2 } from "@tscircuit/circuit-json-util";
 import {
   segmentToBoundsMinDistance,
@@ -735,7 +1443,7 @@ import {
 } from "@tscircuit/math-utils";
 import { segmentToSegmentMinDistance as segmentToSegmentMinDistance3 } from "@tscircuit/math-utils";
 import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson2
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson3
 } from "circuit-json-to-connectivity-map";
 
 // lib/check-pad-clearance/common.ts
@@ -782,10 +1490,10 @@ var getPadBounds = (pad) => {
   if (pad.type === "pcb_keepout") {
     if (pad.shape === "outline") {
       return {
-        minX: Math.min(...pad.outline.map((point) => point.x)),
-        minY: Math.min(...pad.outline.map((point) => point.y)),
-        maxX: Math.max(...pad.outline.map((point) => point.x)),
-        maxY: Math.max(...pad.outline.map((point) => point.y))
+        minX: Math.min(...pad.outline.map((point2) => point2.x)),
+        minY: Math.min(...pad.outline.map((point2) => point2.y)),
+        maxX: Math.max(...pad.outline.map((point2) => point2.x)),
+        maxY: Math.max(...pad.outline.map((point2) => point2.y))
       };
     }
     if (pad.shape === "circle") {
@@ -897,28 +1605,28 @@ var getPadToPadGap = (padA, padB) => {
     ) - pillA.radius - pillB.radius;
   }
   if (isPillPad(padA) && isCircularPad(padB)) {
-    const pill2 = getPillCenterLineForPad(padA);
-    return segmentToCircleMinDistance(pill2.start, pill2.end, getCircleShape(padB)) - pill2.radius;
+    const pill = getPillCenterLineForPad(padA);
+    return segmentToCircleMinDistance(pill.start, pill.end, getCircleShape(padB)) - pill.radius;
   }
   if (isCircularPad(padA) && isPillPad(padB)) {
-    const pill2 = getPillCenterLineForPad(padB);
-    return segmentToCircleMinDistance(pill2.start, pill2.end, getCircleShape(padA)) - pill2.radius;
+    const pill = getPillCenterLineForPad(padB);
+    return segmentToCircleMinDistance(pill.start, pill.end, getCircleShape(padA)) - pill.radius;
   }
   if (isPillPad(padA)) {
-    const pill2 = getPillCenterLineForPad(padA);
+    const pill = getPillCenterLineForPad(padA);
     return getSegmentToPolygonClearanceFromPoints(
-      pill2.start,
-      pill2.end,
+      pill.start,
+      pill.end,
       getPolygonShape(padB).points
-    ).distance - pill2.radius;
+    ).distance - pill.radius;
   }
   if (isPillPad(padB)) {
-    const pill2 = getPillCenterLineForPad(padB);
+    const pill = getPillCenterLineForPad(padB);
     return getSegmentToPolygonClearanceFromPoints(
-      pill2.start,
-      pill2.end,
+      pill.start,
+      pill.end,
       getPolygonShape(padA).points
-    ).distance - pill2.radius;
+    ).distance - pill.radius;
   }
   if (isCircularPad(padA) && isCircularPad(padB)) {
     return distanceBetweenCircleAndCircle(
@@ -1008,19 +1716,19 @@ var getTraceObstacleClearance = (segment, obstacle) => {
   const end = { x: segment.x2, y: segment.y2 };
   const traceRadius = segment.thickness / 2;
   if (obstacle.type === "pcb_via" || isCircularPad(obstacle)) {
-    const circle = obstacle.type === "pcb_via" ? {
+    const circle2 = obstacle.type === "pcb_via" ? {
       x: obstacle.x,
       y: obstacle.y,
       radius: obstacle.outer_diameter / 2
     } : getCircleShape(obstacle);
-    const closestPoint = pointToSegmentClosestPoint2(circle, start, end);
+    const closestPoint = pointToSegmentClosestPoint2(circle2, start, end);
     return {
-      gap: segmentToCircleMinDistance(start, end, circle) - traceRadius,
+      gap: segmentToCircleMinDistance(start, end, circle2) - traceRadius,
       center: getCenterBetweenCopperEdges({
         tracePoint: closestPoint,
-        obstaclePoint: circle,
+        obstaclePoint: circle2,
         traceRadius,
-        obstacleRadius: circle.radius
+        obstacleRadius: circle2.radius
       })
     };
   }
@@ -1440,19 +2148,19 @@ var getCollidableBounds = (collidable) => {
     if (isPolygon) {
       const polygonPoints = getPolygonPointsForPad(collidable);
       return {
-        minX: Math.min(...polygonPoints.map((point) => point.x)),
-        minY: Math.min(...polygonPoints.map((point) => point.y)),
-        maxX: Math.max(...polygonPoints.map((point) => point.x)),
-        maxY: Math.max(...polygonPoints.map((point) => point.y))
+        minX: Math.min(...polygonPoints.map((point2) => point2.x)),
+        minY: Math.min(...polygonPoints.map((point2) => point2.y)),
+        maxX: Math.max(...polygonPoints.map((point2) => point2.x)),
+        maxY: Math.max(...polygonPoints.map((point2) => point2.y))
       };
     }
     if (collidable.type === "pcb_smtpad" && collidable.shape === "rotated_pill") {
-      const pill2 = getPillCenterLineForPad(collidable);
+      const pill = getPillCenterLineForPad(collidable);
       return {
-        minX: Math.min(pill2.start.x, pill2.end.x) - pill2.radius,
-        minY: Math.min(pill2.start.y, pill2.end.y) - pill2.radius,
-        maxX: Math.max(pill2.start.x, pill2.end.x) + pill2.radius,
-        maxY: Math.max(pill2.start.y, pill2.end.y) + pill2.radius
+        minX: Math.min(pill.start.x, pill.end.x) - pill.radius,
+        minY: Math.min(pill.start.y, pill.end.y) - pill.radius,
+        maxX: Math.max(pill.start.x, pill.end.x) + pill.radius,
+        maxY: Math.max(pill.start.y, pill.end.y) + pill.radius
       };
     }
   }
@@ -1516,7 +2224,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
 } = {}) {
   const errors = [];
   addStartAndEndPortIdsIfMissing(circuitJson);
-  connMap ??= getFullConnectivityMapFromCircuitJson2(circuitJson);
+  connMap ??= getFullConnectivityMapFromCircuitJson3(circuitJson);
   const board = getPcbBoard(circuitJson);
   minClearance ??= getBoardDrcValue(board, "min_trace_to_pad_edge_clearance") ?? DEFAULT_TRACE_MARGIN;
   const pcbTraces = cju2(circuitJson).pcb_trace.list();
@@ -1578,7 +2286,7 @@ function checkEachPcbTraceNonOverlapping(circuitJson, {
     objects: allObjects,
     getBounds: getCollidableBounds
   });
-  const getReadableName = (id) => getReadableNameForElement2(circuitJson, id);
+  const getReadableName = (id) => getReadableNameForElement3(circuitJson, id);
   const constructErrorMessage = (traceName, otherName, gap) => {
     if (isTraceObstacleOverlap(gap)) {
       return `PCB trace ${traceName} overlaps with ${otherName} (accidental contact)`;
@@ -1792,400 +2500,60 @@ var NetManager = class {
 };
 
 // lib/check-pcb-components-out-of-board/checkViasOffBoard.ts
-import { getReadableNameForElement as getReadableNameForElement3 } from "@tscircuit/circuit-json-util";
+import { getReadableNameForElement as getReadableNameForElement4 } from "@tscircuit/circuit-json-util";
 
 // lib/check-copper-to-board-edge-clearance.ts
-import * as Flatten from "@flatten-js/core";
-import { applyToPoint, rotateDEG } from "transformation-matrix";
-var toPcbComponentId = (id) => id;
 var GEOMETRY_EPSILON = 1e-9;
-var pointsToPolygon = (points) => {
-  if (points.length < 3) return null;
-  return new Flatten.Polygon(points.map(({ x, y }) => new Flatten.Point(x, y)));
-};
-var brepRingToPolygon = (vertices) => {
-  const ring = vertices.filter((vertex, index) => {
-    const previous = vertices[index - 1];
-    return !previous || Math.abs(previous.x - vertex.x) > GEOMETRY_EPSILON || Math.abs(previous.y - vertex.y) > GEOMETRY_EPSILON;
-  });
-  if (ring.length > 1 && Math.abs(ring[0].x - ring.at(-1).x) <= GEOMETRY_EPSILON && Math.abs(ring[0].y - ring.at(-1).y) <= GEOMETRY_EPSILON) {
-    ring.pop();
-  }
-  if (ring.length < 3) return null;
-  const edges = [];
-  for (let index = 0; index < ring.length; index++) {
-    const start = ring[index];
-    const end = ring[(index + 1) % ring.length];
-    const startPoint = new Flatten.Point(start.x, start.y);
-    const endPoint = new Flatten.Point(end.x, end.y);
-    const bulge = start.bulge ?? 0;
-    if (Math.abs(bulge) <= GEOMETRY_EPSILON) {
-      edges.push(new Flatten.Segment(startPoint, endPoint));
-      continue;
-    }
-    const chordLength = startPoint.distanceTo(endPoint)[0];
-    if (chordLength <= GEOMETRY_EPSILON) continue;
-    const midpoint2 = {
-      x: (start.x + end.x) / 2,
-      y: (start.y + end.y) / 2
-    };
-    const leftNormal = {
-      x: -(end.y - start.y) / chordLength,
-      y: (end.x - start.x) / chordLength
-    };
-    const centerOffset = chordLength * (1 - bulge * bulge) / (4 * bulge);
-    const center = new Flatten.Point(
-      midpoint2.x + leftNormal.x * centerOffset,
-      midpoint2.y + leftNormal.y * centerOffset
-    );
-    const radius = chordLength * (1 + bulge * bulge) / (4 * Math.abs(bulge));
-    edges.push(
-      new Flatten.Arc(
-        center,
-        radius,
-        Math.atan2(start.y - center.y, start.x - center.x),
-        Math.atan2(end.y - center.y, end.x - center.x),
-        bulge > 0
-      )
-    );
-  }
-  if (edges.length < 3) return null;
-  const polygon = new Flatten.Polygon();
-  polygon.addFace(edges);
-  return polygon;
-};
-var boardToPolygon = (board) => {
-  if (board.outline && board.outline.length >= 3) {
-    return pointsToPolygon(board.outline);
-  }
-  if (!board.center || typeof board.width !== "number" || typeof board.height !== "number") {
-    return null;
-  }
-  const halfWidth = board.width / 2;
-  const halfHeight = board.height / 2;
-  return pointsToPolygon([
-    { x: board.center.x - halfWidth, y: board.center.y - halfHeight },
-    { x: board.center.x + halfWidth, y: board.center.y - halfHeight },
-    { x: board.center.x + halfWidth, y: board.center.y + halfHeight },
-    { x: board.center.x - halfWidth, y: board.center.y + halfHeight }
-  ]);
-};
-var getRectanglePolygon = ({
-  x,
-  y,
-  width,
-  height,
-  ccwRotationDegrees = 0
-}) => {
-  const halfWidth = width / 2;
-  const halfHeight = height / 2;
-  const rotationMatrix = rotateDEG(ccwRotationDegrees, x, y);
-  return pointsToPolygon(
-    [
-      { x: x - halfWidth, y: y - halfHeight },
-      { x: x + halfWidth, y: y - halfHeight },
-      { x: x + halfWidth, y: y + halfHeight },
-      { x: x - halfWidth, y: y + halfHeight }
-    ].map((point) => applyToPoint(rotationMatrix, point))
-  );
-};
-var roundedRect = ({
-  x,
-  y,
-  width,
-  height,
-  cornerRadius,
-  ccwRotationDegrees = 0
-}) => {
-  const radius = Math.max(0, Math.min(cornerRadius, width / 2, height / 2));
-  if (radius <= GEOMETRY_EPSILON) {
-    const polygon = getRectanglePolygon({
-      x,
-      y,
-      width,
-      height,
-      ccwRotationDegrees
-    });
-    return polygon ? { kind: "shapes", shapes: [polygon] } : null;
-  }
-  const shapes = [];
-  const innerWidth = width - 2 * radius;
-  const innerHeight = height - 2 * radius;
-  if (innerWidth > GEOMETRY_EPSILON) {
-    const verticalBand = getRectanglePolygon({
-      x,
-      y,
-      width: innerWidth,
-      height,
-      ccwRotationDegrees
-    });
-    if (verticalBand) shapes.push(verticalBand);
-  }
-  if (innerHeight > GEOMETRY_EPSILON) {
-    const horizontalBand = getRectanglePolygon({
-      x,
-      y,
-      width,
-      height: innerHeight,
-      ccwRotationDegrees
-    });
-    if (horizontalBand) shapes.push(horizontalBand);
-  }
-  const halfInnerWidth = innerWidth / 2;
-  const halfInnerHeight = innerHeight / 2;
-  const rotationMatrix = rotateDEG(ccwRotationDegrees, x, y);
-  const cornerCenters = [
-    { x: x - halfInnerWidth, y: y - halfInnerHeight },
-    { x: x + halfInnerWidth, y: y - halfInnerHeight },
-    { x: x + halfInnerWidth, y: y + halfInnerHeight },
-    { x: x - halfInnerWidth, y: y + halfInnerHeight }
-  ].map((point) => applyToPoint(rotationMatrix, point)).filter(
-    (point, index, points) => points.findIndex(
-      (candidate) => Math.abs(candidate.x - point.x) <= GEOMETRY_EPSILON && Math.abs(candidate.y - point.y) <= GEOMETRY_EPSILON
-    ) === index
-  );
-  shapes.push(
-    ...cornerCenters.map(
-      (center) => new Flatten.Circle(new Flatten.Point(center.x, center.y), radius)
-    )
-  );
-  return shapes.length > 0 ? { kind: "shapes", shapes } : null;
-};
-var pill = ({
-  x,
-  y,
-  width,
-  height,
-  radius,
-  ccwRotationDegrees = 0
-}) => {
-  const halfLineLength = Math.max(Math.max(width, height) / 2 - radius, 0);
-  const localAxis = width >= height ? { x: halfLineLength, y: 0 } : { x: 0, y: halfLineLength };
-  const axis = applyToPoint(rotateDEG(ccwRotationDegrees), localAxis);
-  if (halfLineLength <= GEOMETRY_EPSILON) {
-    return {
-      kind: "shapes",
-      shapes: [new Flatten.Circle(new Flatten.Point(x, y), radius)]
-    };
-  }
-  return {
-    kind: "pill",
-    centerLine: new Flatten.Segment(
-      new Flatten.Point(x - axis.x, y - axis.y),
-      new Flatten.Point(x + axis.x, y + axis.y)
-    ),
-    radius
-  };
-};
-var getSmtPadGeometry = (pad) => {
-  switch (pad.shape) {
-    case "circle":
-      return {
-        kind: "shapes",
-        shapes: [
-          new Flatten.Circle(new Flatten.Point(pad.x, pad.y), pad.radius)
-        ]
-      };
-    case "rect":
-      return roundedRect({
-        x: pad.x,
-        y: pad.y,
-        width: pad.width,
-        height: pad.height,
-        cornerRadius: pad.rect_border_radius ?? pad.corner_radius ?? 0
-      });
-    case "rotated_rect":
-      return roundedRect({
-        x: pad.x,
-        y: pad.y,
-        width: pad.width,
-        height: pad.height,
-        cornerRadius: pad.rect_border_radius ?? pad.corner_radius ?? 0,
-        ccwRotationDegrees: pad.ccw_rotation
-      });
-    case "pill":
-      return pill({
-        x: pad.x,
-        y: pad.y,
-        width: pad.width,
-        height: pad.height,
-        radius: pad.radius
-      });
-    case "rotated_pill":
-      return pill({
-        x: pad.x,
-        y: pad.y,
-        width: pad.width,
-        height: pad.height,
-        radius: pad.radius,
-        ccwRotationDegrees: pad.ccw_rotation
-      });
-    case "polygon": {
-      const polygon = pointsToPolygon(pad.points);
-      return polygon ? { kind: "shapes", shapes: [polygon] } : null;
-    }
-  }
-};
-var getPlatedHoleGeometry = (platedHole, componentCcwRotationDegrees) => {
-  switch (platedHole.shape) {
-    case "circle":
-      return {
-        kind: "shapes",
-        shapes: [
-          new Flatten.Circle(
-            new Flatten.Point(platedHole.x, platedHole.y),
-            platedHole.outer_diameter / 2
-          )
-        ]
-      };
-    case "oval":
-    case "pill":
-      return pill({
-        x: platedHole.x,
-        y: platedHole.y,
-        width: platedHole.outer_width,
-        height: platedHole.outer_height,
-        radius: Math.min(
-          platedHole.outer_width / 2,
-          platedHole.outer_height / 2
-        ),
-        ccwRotationDegrees: platedHole.ccw_rotation
-      });
-    case "circular_hole_with_rect_pad":
-    case "pill_hole_with_rect_pad":
-    case "rotated_pill_hole_with_rect_pad":
-      return roundedRect({
-        x: platedHole.x,
-        y: platedHole.y,
-        width: platedHole.rect_pad_width,
-        height: platedHole.rect_pad_height,
-        cornerRadius: platedHole.rect_border_radius ?? 0,
-        ccwRotationDegrees: "rect_ccw_rotation" in platedHole ? platedHole.rect_ccw_rotation ?? 0 : 0
-      });
-    case "hole_with_polygon_pad": {
-      const ccwRotationDegrees = platedHole.ccw_rotation ?? componentCcwRotationDegrees;
-      const rotationMatrix = rotateDEG(ccwRotationDegrees);
-      const polygon = pointsToPolygon(
-        platedHole.pad_outline.map((point) => {
-          const rotatedPoint = applyToPoint(rotationMatrix, point);
-          return {
-            x: platedHole.x + rotatedPoint.x,
-            y: platedHole.y + rotatedPoint.y
-          };
-        })
-      );
-      return polygon ? { kind: "shapes", shapes: [polygon] } : null;
-    }
-  }
-};
-var getCopperGeometry = (element, componentCcwRotationsById) => {
-  if (element.type === "pcb_via") {
-    return {
-      kind: "shapes",
-      shapes: [
-        new Flatten.Circle(
-          new Flatten.Point(element.x, element.y),
-          element.outer_diameter / 2
-        )
-      ]
-    };
-  }
-  if (element.type === "pcb_smtpad") return getSmtPadGeometry(element);
-  if (element.type === "pcb_plated_hole") {
-    return getPlatedHoleGeometry(
-      element,
-      element.pcb_component_id ? componentCcwRotationsById.get(
-        toPcbComponentId(element.pcb_component_id)
-      ) ?? 0 : 0
-    );
-  }
-  let polygon;
-  switch (element.shape) {
-    case "rect":
-      polygon = getRectanglePolygon({
-        x: element.center.x,
-        y: element.center.y,
-        width: element.width,
-        height: element.height,
-        ccwRotationDegrees: element.rotation ?? 0
-      });
-      break;
-    case "polygon":
-      polygon = pointsToPolygon(element.points);
-      break;
-    case "brep":
-      polygon = brepRingToPolygon(element.brep_shape.outer_ring.vertices);
-      break;
-  }
-  return polygon ? { kind: "shapes", shapes: [polygon] } : null;
-};
-var getCopperElementId = (element) => {
-  if (element.type === "pcb_via") return element.pcb_via_id;
-  if (element.type === "pcb_smtpad") return element.pcb_smtpad_id;
-  if (element.type === "pcb_plated_hole") return element.pcb_plated_hole_id;
-  return element.pcb_copper_pour_id;
-};
 var getCopperElementLabel = (element) => {
   if (element.type === "pcb_via") return "Via";
   if (element.type === "pcb_smtpad") return "SMT pad";
   if (element.type === "pcb_plated_hole") return "Plated hole";
   return "Copper pour";
 };
-var measureClearance = (board, geometry) => {
-  if (geometry.kind === "shapes") {
-    const isInside2 = geometry.shapes.every((shape) => board.contains(shape));
-    return {
-      isInside: isInside2,
-      clearance: isInside2 ? Math.min(
-        ...geometry.shapes.map((shape) => board.distanceTo(shape)[0])
-      ) : 0
-    };
-  }
-  const centerLineClearance = board.distanceTo(geometry.centerLine)[0];
-  const clearance = centerLineClearance - geometry.radius;
-  const isInside = board.contains(geometry.centerLine) && clearance >= -GEOMETRY_EPSILON;
-  return {
-    isInside,
-    clearance: isInside ? Math.max(0, clearance) : 0
-  };
-};
 function checkCopperToBoardEdgeClearance(circuitJson) {
   const board = getPcbBoard(circuitJson);
   if (!board) return [];
-  const boardPolygon = boardToPolygon(board);
+  const boardPolygon = convertCircuitJsonToFlattenJs([board], { strict: true }).elements[0]?.shapes[0];
   if (!boardPolygon) return [];
   const requiredClearance = getBoardDrcValue(board, "min_board_edge_clearance") ?? jlcMinTolerances.min_board_edge_clearance;
   if (requiredClearance === void 0) return [];
   const allowedOffBoardComponentIds = new Set(
     circuitJson.filter(
       (element) => element.type === "pcb_component"
-    ).filter((component) => component.is_allowed_to_be_off_board).map((component) => toPcbComponentId(component.pcb_component_id))
-  );
-  const copperElements = circuitJson.filter(
-    (element) => element.type === "pcb_via" || element.type === "pcb_smtpad" || element.type === "pcb_plated_hole" || element.type === "pcb_copper_pour"
+    ).filter((component) => component.is_allowed_to_be_off_board).map((component) => component.pcb_component_id)
   );
-  const componentCcwRotationsById = new Map(
-    circuitJson.filter(
-      (element) => element.type === "pcb_component"
-    ).map((component) => [
-      toPcbComponentId(component.pcb_component_id),
-      component.rotation
-    ])
+  const { elements: copperElements } = convertCircuitJsonToFlattenJs(
+    circuitJson,
+    {
+      elementTypes: [
+        "pcb_via",
+        "pcb_smtpad",
+        "pcb_plated_hole",
+        "pcb_copper_pour"
+      ],
+      includeDrillHoles: false,
+      strict: true
+    }
   );
   const errors = [];
-  for (const element of copperElements) {
-    if ((element.type === "pcb_smtpad" || element.type === "pcb_plated_hole") && element.pcb_component_id && allowedOffBoardComponentIds.has(
-      toPcbComponentId(element.pcb_component_id)
-    )) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const geometry of copperElements) {
+    if (seen.has(geometry.elementId)) continue;
+    seen.add(geometry.elementId);
+    const element = geometry.sourceElement;
+    if ((element.type === "pcb_smtpad" || element.type === "pcb_plated_hole") && element.pcb_component_id && allowedOffBoardComponentIds.has(element.pcb_component_id)) {
       continue;
     }
-    const geometry = getCopperGeometry(element, componentCcwRotationsById);
-    if (!geometry) continue;
-    const { isInside, clearance } = measureClearance(boardPolygon, geometry);
+    const isInside = geometry.shapes.every(
+      (shape) => boardPolygon.contains(shape)
+    );
+    const clearance = isInside ? Math.min(
+      ...geometry.shapes.map((shape) => boardPolygon.distanceTo(shape)[0])
+    ) : 0;
     if (isInside && clearance + GEOMETRY_EPSILON >= requiredClearance) {
       continue;
     }
-    const id = getCopperElementId(element);
+    const id = geometry.elementId;
     const label = getCopperElementLabel(element);
     errors.push({
       type: "pcb_placement_error",
@@ -2216,7 +2584,7 @@ function checkViasOffBoard(circuitJson) {
   return vias.flatMap((via) => {
     const violation = violationsById.get(via.pcb_via_id);
     if (!violation) return [];
-    const viaName = getReadableNameForElement3(circuitJson, via.pcb_via_id);
+    const viaName = getReadableNameForElement4(circuitJson, via.pcb_via_id);
     return [
       {
         ...violation,
@@ -2229,7 +2597,7 @@ function checkViasOffBoard(circuitJson) {
 
 // lib/check-pcb-components-out-of-board/checkPcbComponentsOutOfBoard.ts
 import * as Flatten2 from "@flatten-js/core";
-import { rotateDEG as rotateDEG2, applyToPoint as applyToPoint2 } from "transformation-matrix";
+import { rotateDEG, applyToPoint } from "transformation-matrix";
 function isPolygonCCW(poly) {
   return poly.area() >= 0;
 }
@@ -2250,9 +2618,9 @@ function rectanglePolygon({
   ];
   let poly = new Flatten2.Polygon(corners);
   if (rotationDeg) {
-    const matrix = rotateDEG2(rotationDeg, cx, cy);
+    const matrix = rotateDEG(rotationDeg, cx, cy);
     const rotatedCorners = corners.map((pt) => {
-      const p = applyToPoint2(matrix, { x: pt.x, y: pt.y });
+      const p = applyToPoint(matrix, { x: pt.x, y: pt.y });
       return new Flatten2.Point(p.x, p.y);
     });
     poly = new Flatten2.Polygon(rotatedCorners);
@@ -2260,7 +2628,7 @@ function rectanglePolygon({
   if (!isPolygonCCW(poly)) poly.reverse();
   return poly;
 }
-function boardToPolygon2({
+function boardToPolygon({
   board
 }) {
   if (board.outline && board.outline.length > 0) {
@@ -2316,9 +2684,9 @@ function computeOverlapDistance(compPoly, boardPoly, componentCenter, componentW
       y: (corners[i].y + corners[next].y) / 2
     });
   }
-  const matrix = rotateDEG2(rotationDeg, componentCenter.x, componentCenter.y);
+  const matrix = rotateDEG(rotationDeg, componentCenter.x, componentCenter.y);
   const rotatePoint2 = (pt) => {
-    const p = applyToPoint2(matrix, pt);
+    const p = applyToPoint(matrix, pt);
     return new Flatten2.Point(p.x, p.y);
   };
   const rotatedPoints = corners.concat(midpoints).map(rotatePoint2);
@@ -2404,7 +2772,7 @@ function checkPcbComponentsOutOfBoard(circuitJson) {
     (el) => el.type === "pcb_board"
   );
   if (!board) return [];
-  const boardPoly = boardToPolygon2({ board });
+  const boardPoly = boardToPolygon({ board });
   if (!boardPoly) return [];
   const components = circuitJson.filter(
     (el) => el.type === "pcb_component"
@@ -2462,7 +2830,7 @@ function checkPcbComponentsOutOfBoard(circuitJson) {
 // lib/check-pcb-component-over-cutout.ts
 import { doBoundsOverlap } from "@tscircuit/math-utils";
 import * as Flatten3 from "@flatten-js/core";
-import { applyToPoint as applyToPoint3, rotateDEG as rotateDEG3 } from "transformation-matrix";
+import { applyToPoint as applyToPoint2, rotateDEG as rotateDEG2 } from "transformation-matrix";
 var CUTOUT_CIRCLE_SEGMENTS = 32;
 function rectanglePolygon2({
   center,
@@ -2478,10 +2846,10 @@ function rectanglePolygon2({
     { x: center.x + halfWidth, y: center.y + halfHeight },
     { x: center.x - halfWidth, y: center.y + halfHeight }
   ];
-  const matrix = rotateDEG3(rotation, center.x, center.y);
+  const matrix = rotateDEG2(rotation, center.x, center.y);
   return new Flatten3.Polygon(
     corners.map((corner) => {
-      const rotated = rotation ? applyToPoint3(matrix, corner) : corner;
+      const rotated = rotation ? applyToPoint2(matrix, corner) : corner;
       return new Flatten3.Point(rotated.x, rotated.y);
     })
   );
@@ -2514,7 +2882,7 @@ function cutoutToPolygon(cutout) {
   }
   if (cutout.shape === "polygon") {
     return new Flatten3.Polygon(
-      cutout.points.map((point) => new Flatten3.Point(point.x, point.y))
+      cutout.points.map((point2) => new Flatten3.Point(point2.x, point2.y))
     );
   }
   return null;
@@ -2643,9 +3011,9 @@ function checkPcbCopperOverKeepout(circuitJson) {
 }
 
 // lib/check-same-net-via-spacing.ts
-import { getReadableNameForElement as getReadableNameForElement4 } from "@tscircuit/circuit-json-util";
+import { getReadableNameForElement as getReadableNameForElement5 } from "@tscircuit/circuit-json-util";
 import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson3
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson4
 } from "circuit-json-to-connectivity-map";
 
 // lib/util/distance.ts
@@ -2667,7 +3035,7 @@ function checkSameNetViaSpacing(circuitJson, {
   if (vias.length < 2) return [];
   const board = getPcbBoard(circuitJson);
   minClearance ??= getBoardDrcValue(board, "min_via_hole_edge_to_via_hole_edge_clearance") ?? jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
-  connMap ??= getFullConnectivityMapFromCircuitJson3(circuitJson);
+  connMap ??= getFullConnectivityMapFromCircuitJson4(circuitJson);
   const errors = [];
   const reported = /* @__PURE__ */ new Set();
   for (let i = 0; i < vias.length; i++) {
@@ -2684,10 +3052,10 @@ function checkSameNetViaSpacing(circuitJson, {
       errors.push({
         type: "pcb_via_clearance_error",
         pcb_error_id: `same_net_vias_close_${pairId}`,
-        message: `Vias ${getReadableNameForElement4(
+        message: `Vias ${getReadableNameForElement5(
           circuitJson,
           viaA.pcb_via_id
-        )} and ${getReadableNameForElement4(
+        )} and ${getReadableNameForElement5(
           circuitJson,
           viaB.pcb_via_id
         )} are too close together (gap: ${gap.toFixed(3)}mm)`,
@@ -2706,9 +3074,9 @@ function checkSameNetViaSpacing(circuitJson, {
 }
 
 // lib/check-different-net-via-spacing.ts
-import { getReadableNameForElement as getReadableNameForElement5 } from "@tscircuit/circuit-json-util";
+import { getReadableNameForElement as getReadableNameForElement6 } from "@tscircuit/circuit-json-util";
 import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson4
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson5
 } from "circuit-json-to-connectivity-map";
 function checkDifferentNetViaSpacing(circuitJson, {
   connMap,
@@ -2718,7 +3086,7 @@ function checkDifferentNetViaSpacing(circuitJson, {
   if (vias.length < 2) return [];
   const board = getPcbBoard(circuitJson);
   minClearance ??= getBoardDrcValue(board, "min_via_hole_edge_to_via_hole_edge_clearance") ?? jlcMinTolerances.min_via_hole_edge_to_via_hole_edge_clearance;
-  connMap ??= getFullConnectivityMapFromCircuitJson4(circuitJson);
+  connMap ??= getFullConnectivityMapFromCircuitJson5(circuitJson);
   const errors = [];
   const reported = /* @__PURE__ */ new Set();
   for (let i = 0; i < vias.length; i++) {
@@ -2735,10 +3103,10 @@ function checkDifferentNetViaSpacing(circuitJson, {
       errors.push({
         type: "pcb_via_clearance_error",
         pcb_error_id: `different_net_vias_close_${pairId}`,
-        message: `Vias ${getReadableNameForElement5(
+        message: `Vias ${getReadableNameForElement6(
           circuitJson,
           viaA.pcb_via_id
-        )} and ${getReadableNameForElement5(
+        )} and ${getReadableNameForElement6(
           circuitJson,
           viaB.pcb_via_id
         )} from different nets are too close together (gap: ${gap.toFixed(
@@ -2760,14 +3128,14 @@ function checkDifferentNetViaSpacing(circuitJson, {
 
 // lib/check-source-traces-match-pcb-trace-thickness.ts
 import { cju as cju4 } from "@tscircuit/circuit-json-util";
-import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson5 } from "circuit-json-to-connectivity-map";
+import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson6 } from "circuit-json-to-connectivity-map";
 function checkSourceTracesMatchPcbTraceThickness(circuitJson) {
   const warnings = [];
   const db = cju4(circuitJson);
   const sourceTraces = db.source_trace.list();
   const pcbTraces = db.pcb_trace.list();
   const pcbPorts = db.pcb_port.list();
-  const connectivityMap = getFullConnectivityMapFromCircuitJson5(circuitJson);
+  const connectivityMap = getFullConnectivityMapFromCircuitJson6(circuitJson);
   for (const sourceTrace of sourceTraces) {
     const requestedThickness = sourceTrace.min_trace_thickness;
     if (requestedThickness === void 0) continue;
@@ -2785,7 +3153,7 @@ function checkSourceTracesMatchPcbTraceThickness(circuitJson) {
     );
     if (relatedPcbTraces.length === 0) continue;
     const actualWireWidths = relatedPcbTraces.flatMap(
-      (pcbTrace) => pcbTrace.route.filter((point) => point.route_type === "wire").map((point) => point.width)
+      (pcbTrace) => pcbTrace.route.filter((point2) => point2.route_type === "wire").map((point2) => point2.width)
     );
     if (actualWireWidths.length === 0) continue;
     const actualThickness = Math.min(...actualWireWidths);
@@ -2793,18 +3161,18 @@ function checkSourceTracesMatchPcbTraceThickness(circuitJson) {
     let undersizedSegment;
     for (const relatedPcbTrace of relatedPcbTraces) {
       for (let i = 0; i < relatedPcbTrace.route.length - 1; i++) {
-        const point = relatedPcbTrace.route[i];
+        const point2 = relatedPcbTrace.route[i];
         const nextPoint = relatedPcbTrace.route[i + 1];
-        if (!point || !nextPoint) continue;
-        if (point.route_type !== "wire" || nextPoint.route_type !== "wire") {
+        if (!point2 || !nextPoint) continue;
+        if (point2.route_type !== "wire" || nextPoint.route_type !== "wire") {
           continue;
         }
-        if (point.width !== actualThickness) continue;
+        if (point2.width !== actualThickness) continue;
         undersizedSegment = {
           pcb_trace_id: relatedPcbTrace.pcb_trace_id,
           center: {
-            x: (point.x + nextPoint.x) / 2,
-            y: (point.y + nextPoint.y) / 2
+            x: (point2.x + nextPoint.x) / 2,
+            y: (point2.y + nextPoint.y) / 2
           }
         };
         break;
@@ -2832,7 +3200,7 @@ function checkSourceTracesMatchPcbTraceThickness(circuitJson) {
 }
 
 // lib/check-source-traces-have-pcb-traces.ts
-import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson6 } from "circuit-json-to-connectivity-map";
+import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson7 } from "circuit-json-to-connectivity-map";
 function checkSourceTracesHavePcbTraces(circuitJson) {
   const errors = [];
   const sourceTraces = circuitJson.filter(
@@ -2847,7 +3215,7 @@ function checkSourceTracesHavePcbTraces(circuitJson) {
   const sourcePortToPcbPort = new Map(
     pcbPorts.map((pcbPort) => [pcbPort.source_port_id, pcbPort])
   );
-  const connectivityMap = getFullConnectivityMapFromCircuitJson6(circuitJson);
+  const connectivityMap = getFullConnectivityMapFromCircuitJson7(circuitJson);
   let pourConnectivity;
   const getPourConnectivity = () => pourConnectivity ??= getCopperPourConnectivity(
     circuitJson,
@@ -2895,7 +3263,7 @@ import {
   getReadableNameForPcbTrace
 } from "@tscircuit/circuit-json-util";
 import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson7,
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson8,
   PcbConnectivityMap as PcbConnectivityMap2
 } from "circuit-json-to-connectivity-map";
 
@@ -2977,27 +3345,27 @@ function getViaContactIndex(circuitJson, connectivity) {
   }
   for (const trace of circuitJson) {
     if (trace.type !== "pcb_trace") continue;
-    for (const point of trace.route) {
-      if (point.route_type !== "via") continue;
+    for (const point2 of trace.route) {
+      if (point2.route_type !== "via") continue;
       if (vias.some(
-        (via) => Math.hypot(via.x - point.x, via.y - point.y) <= CONTACT_EPSILON && (via.pcb_trace_id === trace.pcb_trace_id || !via.pcb_trace_id && connectivity.areIdsConnected(
+        (via) => Math.hypot(via.x - point2.x, via.y - point2.y) <= CONTACT_EPSILON && (via.pcb_trace_id === trace.pcb_trace_id || !via.pcb_trace_id && connectivity.areIdsConnected(
           via.pcb_via_id,
           trace.pcb_trace_id
         ))
       ))
         continue;
-      const from = stack.indexOf(point.from_layer);
-      const to = stack.indexOf(point.to_layer);
+      const from = stack.indexOf(point2.from_layer);
+      const to = stack.indexOf(point2.to_layer);
       if (from < 0 || to < 0) continue;
-      const diameter = point.outer_diameter;
+      const diameter = point2.outer_diameter;
       if (diameter !== void 0 && (!Number.isFinite(diameter) || diameter <= 0))
         continue;
       add(
         trace.pcb_trace_id,
         stack.slice(Math.min(from, to), Math.max(from, to) + 1),
         {
-          x: point.x,
-          y: point.y,
+          x: point2.x,
+          y: point2.y,
           ownerTraceId: trace.pcb_trace_id,
           radius: diameter === void 0 ? void 0 : diameter / 2
         }
@@ -3007,30 +3375,30 @@ function getViaContactIndex(circuitJson, connectivity) {
   return index;
 }
 function endpointTouchesVia({
-  point,
+  point: point2,
   width,
   ownerTrace,
   index,
   connectivity
 }) {
-  if (point.route_type !== "wire" || !Number.isFinite(width) || width <= 0)
+  if (point2.route_type !== "wire" || !Number.isFinite(width) || width <= 0)
     return false;
   const net = connectivity.getNetConnectedToId(ownerTrace.pcb_trace_id);
   if (!net) return false;
-  return (index.get(net)?.get(point.layer) ?? []).some((via) => {
+  return (index.get(net)?.get(point2.layer) ?? []).some((via) => {
     if (via.ownerTraceId === ownerTrace.pcb_trace_id) return false;
     if (!via.touchesPad && ![...via.touchingTraceIds].some((id) => id !== ownerTrace.pcb_trace_id))
       return false;
     const contactDistance = via.radius === void 0 ? 0 : via.radius + width / 2;
-    return Math.hypot(point.x - via.x, point.y - via.y) <= contactDistance + CONTACT_EPSILON;
+    return Math.hypot(point2.x - via.x, point2.y - via.y) <= contactDistance + CONTACT_EPSILON;
   });
 }
 
 // lib/check-traces-are-contiguous/check-traces-are-contiguous.ts
 var ENDPOINT_CONTACT_EPSILON = 1e-9;
 var TRACE_SEGMENT_GEOMETRY_EPSILON = 1e-9;
-function routePointTouchesPad(point, pad) {
-  return point.route_type === "wire" && getLayersOfPcbElement(pad).includes(point.layer) && isPointInPad(point, pad);
+function routePointTouchesPad(point2, pad) {
+  return point2.route_type === "wire" && getLayersOfPcbElement(pad).includes(point2.layer) && isPointInPad(point2, pad);
 }
 function getTraceWireSegmentsByNetAndLayer(pcbTraces, fullConnectivityMap) {
   const segmentsByNetAndLayer = /* @__PURE__ */ new Map();
@@ -3073,43 +3441,43 @@ function getEndpointTraceCopperWidth(trace, endpoint) {
   return void 0;
 }
 function routePointTouchesLogicallyConnectedTraceCopper({
-  point,
+  point: point2,
   endpointTraceCopperWidth,
   ownerTrace,
   traceWireSegmentsByNetAndLayer,
   fullConnectivityMap
 }) {
-  if (point.route_type !== "wire") return false;
+  if (point2.route_type !== "wire") return false;
   const ownerNetId = fullConnectivityMap.getNetConnectedToId(
     ownerTrace.pcb_trace_id
   );
   if (!ownerNetId) return false;
-  const candidateSegments = traceWireSegmentsByNetAndLayer.get(ownerNetId)?.get(point.layer) ?? [];
+  const candidateSegments = traceWireSegmentsByNetAndLayer.get(ownerNetId)?.get(point2.layer) ?? [];
   for (const segment of candidateSegments) {
     if (segment.trace.pcb_trace_id === ownerTrace.pcb_trace_id) continue;
     const maximumContactDistance = endpointTraceCopperWidth / 2 + segment.start.width / 2 + ENDPOINT_CONTACT_EPSILON;
-    if (pointToSegmentDistance3(point, segment.start, segment.end) <= maximumContactDistance) {
+    if (pointToSegmentDistance3(point2, segment.start, segment.end) <= maximumContactDistance) {
       return true;
     }
   }
   return false;
 }
-function getRoutePointCenter(point) {
-  if (point.route_type === "through_pad") {
+function getRoutePointCenter(point2) {
+  if (point2.route_type === "through_pad") {
     return {
-      x: (point.start.x + point.end.x) / 2,
-      y: (point.start.y + point.end.y) / 2
+      x: (point2.start.x + point2.end.x) / 2,
+      y: (point2.start.y + point2.end.y) / 2
     };
   }
-  return { x: point.x, y: point.y };
+  return { x: point2.x, y: point2.y };
 }
-function routePointConnectsToAnotherExpectedPort(point, expectedPorts, missingPcbPortId, padMap) {
+function routePointConnectsToAnotherExpectedPort(point2, expectedPorts, missingPcbPortId, padMap) {
   return expectedPorts.some((expectedPort) => {
     if (!expectedPort.pcb_port_id || expectedPort.pcb_port_id === missingPcbPortId) {
       return false;
     }
     const expectedPads = padMap.get(expectedPort.pcb_port_id);
-    return expectedPads?.some((pad) => routePointTouchesPad(point, pad)) ?? false;
+    return expectedPads?.some((pad) => routePointTouchesPad(point2, pad)) ?? false;
   });
 }
 function getMissingConnectionErrorCenter({
@@ -3182,7 +3550,7 @@ function checkTracesAreContiguous(circuitJson) {
   let fullConnectivityMap;
   let traceWireSegmentsByNetAndLayer;
   const getFullConnectivityMap = () => {
-    fullConnectivityMap ??= getFullConnectivityMapFromCircuitJson7(circuitJson);
+    fullConnectivityMap ??= getFullConnectivityMapFromCircuitJson8(circuitJson);
     return fullConnectivityMap;
   };
   const getTraceWireSegmentIndex = () => {
@@ -3220,10 +3588,10 @@ function checkTracesAreContiguous(circuitJson) {
     const touchedPortIds = /* @__PURE__ */ new Set();
     const firstPoint = trace.route[0];
     const lastPoint = trace.route.at(-1);
-    for (const point of [firstPoint, lastPoint]) {
-      if (!point) continue;
+    for (const point2 of [firstPoint, lastPoint]) {
+      if (!point2) continue;
       for (const [pcbPortId, pads] of padMap) {
-        if (pads.some((pad) => routePointTouchesPad(point, pad))) {
+        if (pads.some((pad) => routePointTouchesPad(point2, pad))) {
           touchedPortIds.add(pcbPortId);
         }
       }
@@ -3521,7 +3889,7 @@ import {
   getPrimaryId as getPrimaryId5
 } from "@tscircuit/circuit-json-util";
 import { doBoundsOverlap as doBoundsOverlap3 } from "@tscircuit/math-utils";
-import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson8 } from "circuit-json-to-connectivity-map";
+import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson9 } from "circuit-json-to-connectivity-map";
 
 // lib/check-pcb-components-overlap/doPcbElementsOverlap.ts
 import { getBoundsOfPcbElements as getBoundsOfPcbElements4 } from "@tscircuit/circuit-json-util";
@@ -3608,7 +3976,7 @@ var formatOverlapElementDescription = (circuitJson, element) => {
 };
 function checkPcbComponentOverlap(circuitJson) {
   const errors = [];
-  const connMap = getFullConnectivityMapFromCircuitJson8(circuitJson);
+  const connMap = getFullConnectivityMapFromCircuitJson9(circuitJson);
   const smtPads = cju6(circuitJson).pcb_smtpad.list();
   const platedHoles = cju6(circuitJson).pcb_plated_hole.list();
   const holes = cju6(circuitJson).pcb_hole.list();
@@ -3933,11 +4301,11 @@ var checkPcbTraceViaCounts = (circuitJson) => {
 // lib/check-pad-pad-clearance.ts
 import {
   getPrimaryId as getPrimaryId6,
-  getReadableNameForElement as getReadableNameForElement6
+  getReadableNameForElement as getReadableNameForElement7
 } from "@tscircuit/circuit-json-util";
 import { formatMm } from "format-si-unit";
 import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson9
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson10
 } from "circuit-json-to-connectivity-map";
 function checkPadPadClearance(circuitJson, {
   connMap,
@@ -3947,7 +4315,7 @@ function checkPadPadClearance(circuitJson, {
   if (pads.length < 2) return [];
   const board = getPcbBoard(circuitJson);
   minClearance ??= getBoardDrcValue(board, "min_pad_edge_to_pad_edge_clearance") ?? jlcMinTolerances.min_pad_edge_to_pad_edge_clearance;
-  connMap ??= getFullConnectivityMapFromCircuitJson9(circuitJson);
+  connMap ??= getFullConnectivityMapFromCircuitJson10(circuitJson);
   const spatialIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
@@ -3978,7 +4346,7 @@ function checkPadPadClearance(circuitJson, {
         type: "pcb_pad_pad_clearance_error",
         pcb_pad_pad_clearance_error_id: `pad_pad_clearance_${pairId}`,
         error_type: "pcb_pad_pad_clearance_error",
-        message: `Pads ${getReadableNameForElement6(circuitJson, padAId)} and ${getReadableNameForElement6(circuitJson, padBId)} are too close (clearance: ${formatMm(gap)}, minimum: ${formatMm(minClearance)})`,
+        message: `Pads ${getReadableNameForElement7(circuitJson, padAId)} and ${getReadableNameForElement7(circuitJson, padBId)} are too close (clearance: ${formatMm(gap)}, minimum: ${formatMm(minClearance)})`,
         pcb_pad_ids: [padAId, padBId],
         minimum_clearance: minClearance,
         actual_clearance: gap,
@@ -3998,11 +4366,11 @@ function checkPadPadClearance(circuitJson, {
 // lib/check-pad-trace-clearance.ts
 import {
   getPrimaryId as getPrimaryId7,
-  getReadableNameForElement as getReadableNameForElement7
+  getReadableNameForElement as getReadableNameForElement8
 } from "@tscircuit/circuit-json-util";
 import { formatMm as formatMm2 } from "format-si-unit";
 import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson10
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson11
 } from "circuit-json-to-connectivity-map";
 function checkPadTraceClearance(circuitJson, {
   connMap,
@@ -4013,7 +4381,7 @@ function checkPadTraceClearance(circuitJson, {
   if (pads.length === 0 || segments.length === 0) return [];
   const board = getPcbBoard(circuitJson);
   minClearance ??= getBoardDrcValue(board, "min_trace_to_pad_edge_clearance") ?? jlcMinTolerances.min_trace_to_pad_edge_clearance;
-  connMap ??= getFullConnectivityMapFromCircuitJson10(circuitJson);
+  connMap ??= getFullConnectivityMapFromCircuitJson11(circuitJson);
   const spatialIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
@@ -4043,7 +4411,7 @@ function checkPadTraceClearance(circuitJson, {
         type: "pcb_pad_trace_clearance_error",
         pcb_pad_trace_clearance_error_id: `pad_trace_clearance_${pairId}`,
         error_type: "pcb_pad_trace_clearance_error",
-        message: `Pad ${getReadableNameForElement7(circuitJson, padId)} and trace ${getReadableNameForElement7(circuitJson, segment.pcb_trace_id)} are too close (clearance: ${formatMm2(gap)}, minimum: ${formatMm2(minClearance)})`,
+        message: `Pad ${getReadableNameForElement8(circuitJson, padId)} and trace ${getReadableNameForElement8(circuitJson, segment.pcb_trace_id)} are too close (clearance: ${formatMm2(gap)}, minimum: ${formatMm2(minClearance)})`,
         pcb_pad_id: padId,
         pcb_trace_id: segment.pcb_trace_id,
         minimum_clearance: minClearance,
@@ -4060,10 +4428,10 @@ function checkPadTraceClearance(circuitJson, {
 }
 
 // lib/check-via-trace-clearance.ts
-import { getReadableNameForElement as getReadableNameForElement8 } from "@tscircuit/circuit-json-util";
+import { getReadableNameForElement as getReadableNameForElement9 } from "@tscircuit/circuit-json-util";
 import { formatMm as formatMm3 } from "format-si-unit";
 import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson11
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson12
 } from "circuit-json-to-connectivity-map";
 function checkViaTraceClearance(circuitJson, {
   connMap,
@@ -4074,7 +4442,7 @@ function checkViaTraceClearance(circuitJson, {
   if (vias.length === 0 || segments.length === 0) return [];
   const board = getPcbBoard(circuitJson);
   minClearance ??= getBoardDrcValue(board, "min_trace_to_pad_edge_clearance") ?? jlcMinTolerances.min_trace_to_pad_edge_clearance;
-  connMap ??= getFullConnectivityMapFromCircuitJson11(circuitJson);
+  connMap ??= getFullConnectivityMapFromCircuitJson12(circuitJson);
   const errors = /* @__PURE__ */ new Map();
   const overlappingPairIds = /* @__PURE__ */ new Set();
   for (const via of vias) {
@@ -4095,7 +4463,7 @@ function checkViaTraceClearance(circuitJson, {
         type: "pcb_via_trace_clearance_error",
         pcb_via_trace_clearance_error_id: `via_trace_clearance_${pairId}`,
         error_type: "pcb_via_trace_clearance_error",
-        message: `Via ${getReadableNameForElement8(circuitJson, via.pcb_via_id)} and trace ${getReadableNameForElement8(circuitJson, segment.pcb_trace_id)} are too close (clearance: ${formatMm3(gap)}, minimum: ${formatMm3(minClearance)})`,
+        message: `Via ${getReadableNameForElement9(circuitJson, via.pcb_via_id)} and trace ${getReadableNameForElement9(circuitJson, segment.pcb_trace_id)} are too close (clearance: ${formatMm3(gap)}, minimum: ${formatMm3(minClearance)})`,
         pcb_via_id: via.pcb_via_id,
         pcb_trace_id: segment.pcb_trace_id,
         minimum_clearance: minClearance,
@@ -4114,11 +4482,11 @@ function checkViaTraceClearance(circuitJson, {
 // lib/check-via-pad-clearance.ts
 import {
   getPrimaryId as getPrimaryId8,
-  getReadableNameForElement as getReadableNameForElement9
+  getReadableNameForElement as getReadableNameForElement10
 } from "@tscircuit/circuit-json-util";
 import { formatMm as formatMm4 } from "format-si-unit";
 import {
-  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson12
+  getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson13
 } from "circuit-json-to-connectivity-map";
 function checkViaPadClearance(circuitJson, {
   connMap,
@@ -4131,7 +4499,7 @@ function checkViaPadClearance(circuitJson, {
   if (vias.length === 0 || pads.length === 0) return [];
   const board = getPcbBoard(circuitJson);
   const requiredClearance = minClearance ?? getBoardDrcValue(board, "min_pad_edge_to_pad_edge_clearance") ?? jlcMinTolerances.min_pad_edge_to_pad_edge_clearance;
-  connMap ??= getFullConnectivityMapFromCircuitJson12(circuitJson);
+  connMap ??= getFullConnectivityMapFromCircuitJson13(circuitJson);
   const padIndex = new SpatialObjectIndex({
     objects: pads,
     getBounds: getPadBounds,
@@ -4157,7 +4525,7 @@ function checkViaPadClearance(circuitJson, {
         type: "pcb_pad_pad_clearance_error",
         pcb_pad_pad_clearance_error_id: `via_pad_clearance_${via.pcb_via_id}_${padId}`,
         error_type: "pcb_pad_pad_clearance_error",
-        message: `Via ${getReadableNameForElement9(circuitJson, via.pcb_via_id)} and pad ${getReadableNameForElement9(circuitJson, padId)} are too close (clearance: ${formatMm4(gap)}, minimum: ${formatMm4(requiredClearance)})`,
+        message: `Via ${getReadableNameForElement10(circuitJson, via.pcb_via_id)} and pad ${getReadableNameForElement10(circuitJson, padId)} are too close (clearance: ${formatMm4(gap)}, minimum: ${formatMm4(requiredClearance)})`,
         pcb_pad_ids: [via.pcb_via_id, padId],
         minimum_clearance: requiredClearance,
         actual_clearance: gap,
@@ -4170,7 +4538,7 @@ function checkViaPadClearance(circuitJson, {
 
 // lib/check-vias-in-pads.ts
 import { getPrimaryId as getPrimaryId9 } from "@tscircuit/circuit-json-util";
-import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson13 } from "circuit-json-to-connectivity-map";
+import { getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson14 } from "circuit-json-to-connectivity-map";
 function checkViasInPads(circuitJson) {
   const board = getPcbBoard(circuitJson);
   if (board && "is_via_in_pad_allowed" in board && board.is_via_in_pad_allowed === true) {
@@ -4181,7 +4549,7 @@ function checkViasInPads(circuitJson) {
   );
   const pads = getPads(circuitJson);
   if (vias.length === 0 || pads.length === 0) return [];
-  const connMap = getFullConnectivityMapFromCircuitJson13(circuitJson);
+  const connMap = getFullConnectivityMapFromCircuitJson14(circuitJson);
   const padOrdinals = new Map(
     pads.map((pad, index) => [getPrimaryId9(pad), index])
   );
@@ -5119,22 +5487,22 @@ function checkCourtyardOverlap(circuitJson) {
 // lib/check-testpoint-accessibility.ts
 import { isPointInsidePolygon as isPointInsidePolygon3 } from "@tscircuit/math-utils";
 var isCourtyardElement3 = (element) => element.type === "pcb_courtyard_circle" || element.type === "pcb_courtyard_outline" || element.type === "pcb_courtyard_polygon" || element.type === "pcb_courtyard_rect";
-var isPointInsideCourtyard = (point, courtyard) => {
+var isPointInsideCourtyard = (point2, courtyard) => {
   if (courtyard.type === "pcb_courtyard_circle") {
-    const dx = point.x - courtyard.center.x;
-    const dy = point.y - courtyard.center.y;
+    const dx = point2.x - courtyard.center.x;
+    const dy = point2.y - courtyard.center.y;
     return dx * dx + dy * dy <= courtyard.radius * courtyard.radius;
   }
   if (courtyard.type === "pcb_courtyard_rect") {
     const angle = -1 * (courtyard.ccw_rotation ?? 0) * Math.PI / 180;
-    const dx = point.x - courtyard.center.x;
-    const dy = point.y - courtyard.center.y;
+    const dx = point2.x - courtyard.center.x;
+    const dy = point2.y - courtyard.center.y;
     const localX = dx * Math.cos(angle) - dy * Math.sin(angle);
     const localY = dx * Math.sin(angle) + dy * Math.cos(angle);
     return Math.abs(localX) <= courtyard.width / 2 && Math.abs(localY) <= courtyard.height / 2;
   }
   const polygon = courtyard.type === "pcb_courtyard_polygon" ? courtyard.points : courtyard.outline;
-  return isPointInsidePolygon3(point, polygon);
+  return isPointInsidePolygon3(point2, polygon);
 };
 var getPcbComponentName = (circuitJson, pcbComponentId) => {
   const pcbComponent = circuitJson.find(
@@ -5234,6 +5602,7 @@ async function runAllRoutingChecks(circuitJson) {
     ...checkPcbTraceLengths(circuitJson),
     ...checkPcbTraceViaCounts(circuitJson),
     ...checkEachPcbTraceNonOverlapping(circuitJson),
+    ...checkCopperPourShorts(circuitJson),
     ...checkPadTraceClearance(circuitJson),
     ...checkViaTraceClearance(circuitJson),
     ...checkViaPadClearance(circuitJson),
@@ -5256,6 +5625,7 @@ export {
   NetManager,
   checkAllPinsInComponentAreUnderspecified,
   checkConnectorAccessibleOrientation,
+  checkCopperPourShorts,
   checkCopperToBoardEdgeClearance,
   checkDifferentNetViaSpacing,
   checkEachPcbPortConnectedToPcbTraces,