@tscircuit/cli 0.1.1739 → 0.1.1740

package/dist/cli/main.js

@@ -39814,7 +39814,7 @@ var init_chunk_4ISXDEM5 = __esm(() => {
 var exports_dist_3YR26ALR = {};
 __export2(exports_dist_3YR26ALR, {
   isSimulationVoltageProbe: () => isSimulationVoltageProbe,
-  isSimulationTransientVoltageGraph: () => isSimulationTransientVoltageGraph2,
+  isSimulationTransientVoltageGraph: () => isSimulationTransientVoltageGraph,
   isSimulationExperiment: () => isSimulationExperiment2,
   getSoftwareUsedString: () => getSoftwareUsedString,
   createSvgObjectsForSchComponentPortHovers: () => createSvgObjectsForSchComponentPortHovers,
@@ -49688,7 +49688,7 @@ function convertCircuitJsonToSchematicSvg3(circuitJson, options) {
   };
   return stringify(svgObject);
 }
-function isSimulationTransientVoltageGraph2(value) {
+function isSimulationTransientVoltageGraph(value) {
   return value?.type === "simulation_transient_voltage_graph";
 }
 function isSimulationExperiment2(value) {
@@ -49707,7 +49707,7 @@ function convertCircuitJsonToSimulationGraphSvg2({
 }) {
   const selectedIds = simulation_transient_voltage_graph_ids ? new Set(simulation_transient_voltage_graph_ids) : null;
   const experiment = circuitJson.find((element) => isSimulationExperiment2(element) && element.simulation_experiment_id === simulation_experiment_id);
-  const graphs = circuitJson.filter((element) => isSimulationTransientVoltageGraph2(element) && element.simulation_experiment_id === simulation_experiment_id && (!selectedIds || selectedIds.has(element.simulation_transient_voltage_graph_id)));
+  const graphs = circuitJson.filter((element) => isSimulationTransientVoltageGraph(element) && element.simulation_experiment_id === simulation_experiment_id && (!selectedIds || selectedIds.has(element.simulation_transient_voltage_graph_id)));
   if (graphs.length === 0) {
     throw new Error(`No simulation_transient_voltage_graph elements found for simulation_experiment_id "${simulation_experiment_id}"`);
   }
@@ -50249,7 +50249,7 @@ function convertCircuitJsonToSchematicSimulationSvg2({
   graphAboveSchematic = false,
   showErrorsInTextOverlay
 }) {
-  const schematicElements = circuitJson.filter((element) => !isSimulationExperiment2(element) && !isSimulationTransientVoltageGraph2(element));
+  const schematicElements = circuitJson.filter((element) => !isSimulationExperiment2(element) && !isSimulationTransientVoltageGraph(element));
   const clampedRatio = clamp01(schematicHeightRatio);
   const rawSchematicHeight = Math.max(1, height * clampedRatio);
   const rawSimulationHeight = Math.max(1, height - rawSchematicHeight);
@@ -118506,7 +118506,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1738";
+var version = "0.1.1739";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -118529,7 +118529,7 @@ var package_default = {
     "@tscircuit/image-utils": "^0.0.8",
     "@tscircuit/krt-wasm": "^0.1.6",
     "@tscircuit/math-utils": "0.0.36",
-    "@tscircuit/props": "^0.0.580",
+    "@tscircuit/props": "^0.0.592",
     "@tscircuit/runframe": "^0.0.2274",
     "@tscircuit/schematic-match-adapt": "^0.0.22",
     "@tscircuit/solver-utils": "0.0.16",
@@ -118543,21 +118543,21 @@ var package_default = {
     "@types/semver": "^7.5.8",
     "bun-match-svg": "^0.0.12",
     chokidar: "4.0.1",
-    "circuit-json": "^0.0.446",
+    "circuit-json": "^0.0.455",
     "circuit-json-to-3d-png": "^0.0.6",
     "circuit-json-to-bom-csv": "^0.0.7",
     "circuit-json-to-connectivity-map": "^0.0.25",
-    "circuit-json-to-footprinter": "^0.0.1",
+    "circuit-json-to-footprinter": "^0.0.15",
     "circuit-json-to-gerber": "^0.0.83",
     "circuit-json-to-kicad": "0.0.157",
     "circuit-json-to-pnp-csv": "^0.0.7",
     "circuit-json-to-readable-netlist": "^0.0.15",
-    "circuit-json-to-spice": "^0.0.40",
+    "circuit-json-to-spice": "^0.0.45",
     "circuit-json-to-step": "^0.0.38",
     "circuit-json-to-tscircuit": "^0.0.42",
     "circuit-json-trace-length-analysis": "github:tscircuit/circuit-json-trace-length-analysis#2b44792a40df0ca83b6bfb6ac95ed5e35e7168b8",
     "circuit-to-canvas": "^0.0.111",
-    "circuit-to-svg": "^0.0.378",
+    "circuit-to-svg": "^0.0.393",
     commander: "^14.0.0",
     conf: "^13.1.0",
     configstore: "^7.0.0",
@@ -118586,9 +118586,10 @@ var package_default = {
     prompts: "^2.4.2",
     redaxios: "^0.5.1",
     semver: "^7.6.3",
+    spicets: "^0.0.4",
     stepts: "^0.0.3",
     tempy: "^3.1.0",
-    tscircuit: "0.0.2099-libonly",
+    tscircuit: "0.0.2142-libonly",
     tsx: "^4.7.1",
     "typed-ky": "^0.0.4",
     zod: "^3.23.8"
@@ -133667,20 +133668,26 @@ async function loadLocalStepModelFsMap(circuitJson) {
 import {
   convertCircuitJsonToSchematicSimulationSvg,
   convertCircuitJsonToSimulationGraphSvg,
-  isSimulationExperiment,
-  isSimulationTransientVoltageGraph
+  isSimulationExperiment
 } from "circuit-to-svg";
-var isSimulationTransientCurrentGraph = (element) => element.type === "simulation_transient_current_graph";
+var SIMULATION_ANALYSIS_RESULT_TYPES = new Set([
+  "simulation_transient_voltage_graph",
+  "simulation_transient_current_graph",
+  "simulation_dc_operating_point_voltage",
+  "simulation_dc_operating_point_current",
+  "simulation_dc_sweep_voltage_graph",
+  "simulation_dc_sweep_current_graph",
+  "simulation_ac_sweep_voltage_graph",
+  "simulation_ac_sweep_current_graph"
+]);
+var isSimulationAnalysisResult = (element) => SIMULATION_ANALYSIS_RESULT_TYPES.has(element.type);
 var getSimulationSvgInputs = (circuitJson, simulationExperimentId) => {
-  const simulationTransientCurrentGraphIds = circuitJson.filter((element) => isSimulationTransientCurrentGraph(element) && element.simulation_experiment_id === simulationExperimentId).map((element) => element.simulation_transient_current_graph_id);
-  const simulationTransientVoltageGraphIds = circuitJson.filter((element) => isSimulationTransientVoltageGraph(element) && element.simulation_experiment_id === simulationExperimentId).map((element) => element.simulation_transient_voltage_graph_id);
-  if (simulationTransientCurrentGraphIds.length === 0 && simulationTransientVoltageGraphIds.length === 0) {
+  const hasAnalysisResult = circuitJson.some((element) => isSimulationAnalysisResult(element) && element.simulation_experiment_id === simulationExperimentId);
+  if (!hasAnalysisResult) {
     return;
   }
   return {
-    simulation_experiment_id: simulationExperimentId,
-    simulation_transient_current_graph_ids: simulationTransientCurrentGraphIds,
-    simulation_transient_voltage_graph_ids: simulationTransientVoltageGraphIds
+    simulation_experiment_id: simulationExperimentId
   };
 };
 var toFileNameSuffix = (value) => value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -286063,140 +286070,69 @@ var convertKicadFootprintToTsx = async ({
   console.log(kleur_default.green(`Converted ${outputPath}`));
 };
 
-// node_modules/circuit-json-to-footprinter/dist/index.js
-import { fp as fp3 } from "@tscircuit/footprinter";
-import { getFootprintNames as getFootprintNames2, getFootprintSizes } from "@tscircuit/footprinter";
-var toNumber4 = (value, fallback = 0) => {
-  if (typeof value === "number" && Number.isFinite(value))
-    return value;
-  if (typeof value === "string") {
-    const parsed = Number.parseFloat(value);
-    if (Number.isFinite(parsed))
-      return parsed;
+// node_modules/circuit-json-to-footprinter/dist/chunk-HCIYAG7H.js
+import {
+  getBoundsFromPoints as getBoundsFromPoints4
+} from "@tscircuit/math-utils";
+import { getBoundsCenter, isPointInsidePolygon as isPointInsidePolygon3 } from "@tscircuit/math-utils";
+var toRadians2 = (degrees) => degrees * Math.PI / 180;
+var rotatePoint4 = (x4, y4, radians) => ({
+  x: x4 * Math.cos(radians) - y4 * Math.sin(radians),
+  y: x4 * Math.sin(radians) + y4 * Math.cos(radians)
+});
+var getSizedBounds = (points) => {
+  const bounds = getBoundsFromPoints4([...points]);
+  if (!bounds) {
+    throw new Error("Cannot calculate bounds for an empty point list");
   }
-  return fallback;
-};
-var normalizePortHint = (hint) => {
-  const trimmed = hint.trim();
-  const pinMatch = trimmed.match(/^pin(\d+)$/i);
-  if (pinMatch)
-    return `pin${pinMatch[1]}`;
-  const numericMatch = trimmed.match(/^(\d+)$/);
-  return numericMatch ? `pin${numericMatch[1]}` : trimmed;
+  return {
+    ...bounds,
+    height: bounds.maxY - bounds.minY,
+    width: bounds.maxX - bounds.minX
+  };
 };
-var normalizeShape = (shape, width, height) => {
-  const normalized = typeof shape === "string" ? shape.toLowerCase() : "rect";
-  if (normalized === "circle" || normalized === "ellipse")
-    return "circle";
-  if (normalized === "pill" || normalized === "oval")
-    return "pill";
-  if (Math.abs(width - height) < 0.00001 && normalized === "round") {
-    return "circle";
+var getPolygonArea = (points) => {
+  let doubledArea = 0;
+  for (let index = 0;index < points.length; index += 1) {
+    const current2 = points[index];
+    const next = points[(index + 1) % points.length];
+    doubledArea += current2.x * next.y - next.x * current2.y;
   }
-  return "rect";
-};
-var getCornerRadius = (element, width, height) => {
-  const radius = toNumber4(element.corner_radius ?? element.cornerRadius ?? element.rect_border_radius);
-  return radius > 0 ? Math.min(radius, width / 2, height / 2) : undefined;
+  return Math.abs(doubledArea) / 2;
 };
-var circuitJsonToPreview = (circuitJson, options = {}) => {
-  const pads = circuitJson.flatMap((rawElement, index) => {
-    const element = rawElement;
-    if (element.type === "pcb_smtpad") {
-      const width = toNumber4(element.width);
-      const height = toNumber4(element.height);
-      return [
-        {
-          cornerRadius: getCornerRadius(element, width, height),
-          height,
-          id: String(element.pcb_smtpad_id ?? `pcb_smtpad_${index + 1}`),
-          kind: "smt",
-          layer: String(element.layer ?? "top"),
-          portHints: Array.isArray(element.port_hints) ? element.port_hints.map((hint) => normalizePortHint(String(hint))) : [],
-          rotation: toNumber4(element.rotation),
-          shape: normalizeShape(element.shape, width, height),
-          width,
-          x: toNumber4(element.x),
-          y: toNumber4(element.y)
-        }
-      ];
-    }
-    if (element.type === "pcb_plated_hole") {
-      const width = toNumber4(element.width ?? element.outer_diameter ?? element.outerDiameter, 0.6);
-      const height = toNumber4(element.height, width);
-      return [
-        {
-          cornerRadius: getCornerRadius(element, width, height),
-          height,
-          id: String(element.pcb_plated_hole_id ?? `pcb_plated_hole_${index + 1}`),
-          kind: "plated-hole",
-          layer: Array.isArray(element.layers) ? String(element.layers[0] ?? "top") : "top",
-          portHints: Array.isArray(element.port_hints) ? element.port_hints.map((hint) => normalizePortHint(String(hint))) : [],
-          rotation: toNumber4(element.rotation),
-          shape: normalizeShape(element.shape ?? "circle", width, height),
-          width,
-          x: toNumber4(element.x),
-          y: toNumber4(element.y)
-        }
-      ];
-    }
-    return [];
-  });
-  if (pads.length === 0) {
-    throw new Error("Circuit JSON must contain at least one PCB SMT pad or plated hole");
+var getPolygonWorldPoints = (shape) => {
+  if (shape.shape !== "polygon" || !shape.points) {
+    throw new Error("Polygon preview shapes require points");
   }
-  return {
-    pads,
-    sourceHints: options.sourceHints,
-    subtitle: options.subtitle ?? "Circuit JSON footprint",
-    title: options.title ?? "Circuit JSON"
-  };
-};
-var footprinterStringToPreview = (footprinterString) => {
-  const normalized = footprinterString.trim();
-  if (!normalized)
-    throw new Error("Footprinter string is required");
-  return circuitJsonToPreview(fp3.string(normalized).circuitJson(), {
-    subtitle: "Generated by @tscircuit/footprinter",
-    title: normalized
+  const radians = toRadians2(shape.rotation);
+  return shape.points.map((point9) => {
+    const rotated = rotatePoint4(point9.x, point9.y, radians);
+    return { x: rotated.x + shape.x, y: rotated.y + shape.y };
   });
 };
-var DEFAULT_GRID_SIZE = 320;
-var toRadians2 = (degrees) => degrees * Math.PI / 180;
-var rotatePoint4 = (x4, y4, radians) => ({
-  x: x4 * Math.cos(radians) - y4 * Math.sin(radians),
-  y: x4 * Math.sin(radians) + y4 * Math.cos(radians)
-});
-var getPadBounds3 = (pad2) => {
-  const halfWidth = pad2.width / 2;
-  const halfHeight = pad2.height / 2;
-  const radians = toRadians2(pad2.rotation);
+var getShapeBounds = (shape) => {
+  if (shape.shape === "polygon") {
+    if (!shape.points || shape.points.length < 3) {
+      throw new Error("Polygon preview shapes require at least three points");
+    }
+    return getSizedBounds(getPolygonWorldPoints(shape));
+  }
+  const halfWidth = shape.width / 2;
+  const halfHeight = shape.height / 2;
+  const radians = toRadians2(shape.rotation);
   const corners = [
     rotatePoint4(-halfWidth, -halfHeight, radians),
     rotatePoint4(halfWidth, -halfHeight, radians),
     rotatePoint4(halfWidth, halfHeight, radians),
     rotatePoint4(-halfWidth, halfHeight, radians)
   ].map((corner) => ({
-    x: corner.x + pad2.x,
-    y: corner.y + pad2.y
+    x: corner.x + shape.x,
+    y: corner.y + shape.y
   }));
-  const xs3 = corners.map((corner) => corner.x);
-  const ys3 = corners.map((corner) => corner.y);
-  const minX = Math.min(...xs3);
-  const maxX = Math.max(...xs3);
-  const minY = Math.min(...ys3);
-  const maxY = Math.max(...ys3);
-  return {
-    height: maxY - minY,
-    maxX,
-    maxY,
-    minX,
-    minY,
-    width: maxX - minX
-  };
+  return getSizedBounds(corners);
 };
-var getFootprintBounds = (pads) => {
-  if (!pads.length) {
+var getFootprintBounds = (shapes) => {
+  if (shapes.length === 0) {
     return {
       height: 1,
       maxX: 0.5,
@@ -286206,20 +286142,13 @@ var getFootprintBounds = (pads) => {
       width: 1
     };
   }
-  const bounds = pads.map(getPadBounds3);
-  const minX = Math.min(...bounds.map((bound) => bound.minX));
-  const minY = Math.min(...bounds.map((bound) => bound.minY));
-  const maxX = Math.max(...bounds.map((bound) => bound.maxX));
-  const maxY = Math.max(...bounds.map((bound) => bound.maxY));
-  return {
-    height: maxY - minY,
-    maxX,
-    maxY,
-    minX,
-    minY,
-    width: maxX - minX
-  };
+  const bounds = shapes.map(getShapeBounds);
+  return getSizedBounds(bounds.flatMap((bound) => [
+    { x: bound.minX, y: bound.minY },
+    { x: bound.maxX, y: bound.maxY }
+  ]));
 };
+var DEFAULT_GRID_SIZE = 320;
 var addPadding = (bounds) => {
   const padX = Math.max(bounds.width * 0.18, 0.65);
   const padY = Math.max(bounds.height * 0.18, 0.65);
@@ -286242,21 +286171,40 @@ var translateFootprint = (footprint, deltaX, deltaY) => ({
 });
 var centerFootprint = (footprint) => {
   const bounds = getFootprintBounds(footprint.pads);
-  const centerX = (bounds.minX + bounds.maxX) / 2;
-  const centerY = (bounds.minY + bounds.maxY) / 2;
-  return translateFootprint(footprint, -centerX, -centerY);
-};
-var pointInPad = (x4, y4, pad2) => {
-  const dx3 = x4 - pad2.x;
-  const dy3 = y4 - pad2.y;
-  const local = rotatePoint4(dx3, dy3, -toRadians2(pad2.rotation));
-  const halfWidth = pad2.width / 2;
-  const halfHeight = pad2.height / 2;
-  if (pad2.shape === "circle") {
+  const center2 = getBoundsCenter(bounds);
+  return translateFootprint(footprint, -center2.x, -center2.y);
+};
+var getHoleShapes = (pads) => pads.flatMap((pad2) => {
+  if (!pad2.hole)
+    return [];
+  return [
+    {
+      height: pad2.hole.height,
+      rotation: pad2.hole.rotation,
+      shape: pad2.hole.shape,
+      width: pad2.hole.width,
+      x: pad2.x + pad2.hole.offsetX,
+      y: pad2.y + pad2.hole.offsetY
+    }
+  ];
+});
+var pointInShape = (x4, y4, shape) => {
+  const dx3 = x4 - shape.x;
+  const dy3 = y4 - shape.y;
+  const local = rotatePoint4(dx3, dy3, -toRadians2(shape.rotation));
+  const halfWidth = shape.width / 2;
+  const halfHeight = shape.height / 2;
+  if (shape.shape === "polygon") {
+    if (!shape.points || shape.points.length < 3) {
+      throw new Error("Polygon preview shapes require at least three points");
+    }
+    return isPointInsidePolygon3(local, shape.points);
+  }
+  if (shape.shape === "circle") {
     return Math.hypot(local.x, local.y) <= Math.min(halfWidth, halfHeight);
   }
-  if (pad2.shape === "rect") {
-    const cornerRadius = Math.max(0, Math.min(pad2.cornerRadius ?? 0, halfWidth, halfHeight));
+  if (shape.shape === "rect") {
+    const cornerRadius = Math.max(0, Math.min(shape.cornerRadius ?? 0, halfWidth, halfHeight));
     if (cornerRadius === 0) {
       return Math.abs(local.x) <= halfWidth && Math.abs(local.y) <= halfHeight;
     }
@@ -286272,7 +286220,7 @@ var pointInPad = (x4, y4, pad2) => {
     const cornerDy = absY - innerHalfHeight;
     return cornerDx >= 0 && cornerDy >= 0 && cornerDx * cornerDx + cornerDy * cornerDy <= cornerRadius * cornerRadius;
   }
-  if (pad2.width >= pad2.height) {
+  if (shape.width >= shape.height) {
     const capsuleLength2 = halfWidth - halfHeight;
     if (Math.abs(local.x) <= capsuleLength2 && Math.abs(local.y) <= halfHeight) {
       return true;
@@ -286299,12 +286247,18 @@ var mergeBounds3 = (left, right) => {
     width: maxX - minX
   };
 };
-var summarizeCopperComparison = (left, right, gridSize = DEFAULT_GRID_SIZE) => {
-  const normalizedLeft = centerFootprint(left);
-  const normalizedRight = centerFootprint(right);
-  const bounds = addPadding(mergeBounds3(getFootprintBounds(normalizedLeft.pads), getFootprintBounds(normalizedRight.pads)));
+var getComparisonBounds = (left, right) => {
+  if (!left.length)
+    return addPadding(getFootprintBounds(right));
+  if (!right.length)
+    return addPadding(getFootprintBounds(left));
+  return addPadding(mergeBounds3(getFootprintBounds(left), getFootprintBounds(right)));
+};
+var rasterizeShapes = (left, right, gridSize, includeOccupancy) => {
+  const bounds = getComparisonBounds(left, right);
   const cellWidth = bounds.width / gridSize;
   const cellHeight = bounds.height / gridSize;
+  const occupancy = includeOccupancy ? new Uint8Array(gridSize * gridSize) : undefined;
   let leftCount = 0;
   let rightCount = 0;
   let overlapCount = 0;
@@ -286312,24 +286266,230 @@ var summarizeCopperComparison = (left, right, gridSize = DEFAULT_GRID_SIZE) => {
     const sampleY = bounds.maxY - (row + 0.5) * cellHeight;
     for (let column = 0;column < gridSize; column += 1) {
       const sampleX = bounds.minX + (column + 0.5) * cellWidth;
-      const inLeft = normalizedLeft.pads.some((pad2) => pointInPad(sampleX, sampleY, pad2));
-      const inRight = normalizedRight.pads.some((pad2) => pointInPad(sampleX, sampleY, pad2));
+      const inLeft = left.some((shape) => pointInShape(sampleX, sampleY, shape));
+      const inRight = right.some((shape) => pointInShape(sampleX, sampleY, shape));
       if (inLeft)
         leftCount += 1;
       if (inRight)
         rightCount += 1;
       if (inLeft && inRight)
         overlapCount += 1;
+      if (occupancy) {
+        const index = row * gridSize + column;
+        occupancy[index] = inLeft && inRight ? 3 : inLeft ? 1 : inRight ? 2 : 0;
+      }
     }
   }
   const unionCount = leftCount + rightCount - overlapCount;
-  const cellArea = cellWidth * cellHeight;
-  const intersectionArea2 = overlapCount * cellArea;
-  const unionArea = unionCount * cellArea;
   return {
-    copperIntersectionOverUnion: unionArea === 0 ? 0 : intersectionArea2 / unionArea
+    coverageLeft: leftCount === 0 ? 0 : overlapCount / leftCount,
+    coverageRight: rightCount === 0 ? 0 : overlapCount / rightCount,
+    iou: unionCount === 0 ? 0 : overlapCount / unionCount,
+    leftOnlyRatio: unionCount === 0 ? 0 : Math.max(leftCount - overlapCount, 0) / unionCount,
+    occupancy,
+    rightOnlyRatio: unionCount === 0 ? 0 : Math.max(rightCount - overlapCount, 0) / unionCount
+  };
+};
+var compareNormalizedFootprints = (left, right, gridSize, includeOccupancy) => {
+  const normalizedLeft = centerFootprint(left);
+  const normalizedRight = centerFootprint(right);
+  const comparison = rasterizeShapes(normalizedLeft.pads, normalizedRight.pads, gridSize, includeOccupancy);
+  return { comparison, normalizedLeft, normalizedRight };
+};
+var summarizeCopperComparison = (left, right, gridSize = DEFAULT_GRID_SIZE) => {
+  const { comparison, normalizedLeft, normalizedRight } = compareNormalizedFootprints(left, right, gridSize, false);
+  const leftHoles = getHoleShapes(normalizedLeft.pads);
+  const rightHoles = getHoleShapes(normalizedRight.pads);
+  const holeIntersectionOverUnion = leftHoles.length === 0 && rightHoles.length === 0 ? 1 : rasterizeShapes(leftHoles, rightHoles, gridSize, false).iou;
+  return {
+    copperIntersectionOverUnion: comparison.iou,
+    holeIntersectionOverUnion
+  };
+};
+
+// node_modules/circuit-json-to-footprinter/dist/index.js
+import { fp as fp3 } from "@tscircuit/footprinter";
+import {
+  getBoundsCenter as getBoundsCenter2,
+  getBoundsFromPoints as getBoundsFromPoints5
+} from "@tscircuit/math-utils";
+import { getFootprintNames as getFootprintNames2, getFootprintSizes } from "@tscircuit/footprinter";
+var toNumber4 = (value, fallback = 0) => {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return fallback;
+};
+var normalizePortHint = (hint) => {
+  const trimmed = hint.trim();
+  const pinMatch = trimmed.match(/^pin(\d+)$/i);
+  if (pinMatch)
+    return `pin${pinMatch[1]}`;
+  const numericMatch = trimmed.match(/^(\d+)$/);
+  return numericMatch ? `pin${numericMatch[1]}` : trimmed;
+};
+var normalizeShape = (shape, width, height) => {
+  const normalized = typeof shape === "string" ? shape.toLowerCase() : "rect";
+  if (normalized === "circle" || normalized === "ellipse")
+    return "circle";
+  if (normalized === "pill" || normalized === "oval" || normalized === "rotated_pill") {
+    return "pill";
+  }
+  if (Math.abs(width - height) < 0.00001 && normalized === "round") {
+    return "circle";
+  }
+  return "rect";
+};
+var getCornerRadius = (element, width, height) => {
+  const radius = toNumber4(element.corner_radius ?? element.cornerRadius ?? element.rect_border_radius);
+  return radius > 0 ? Math.min(radius, width / 2, height / 2) : undefined;
+};
+var getPlatedHolePadGeometry = (element) => {
+  const elementShape = String(element.shape ?? "circle").toLowerCase();
+  const hasRectPad = element.pad_shape === "rect" || elementShape.includes("with_rect_pad");
+  const outerDiameter = toNumber4(element.outer_diameter ?? element.outerDiameter, 0.6);
+  const width = hasRectPad ? toNumber4(element.rect_pad_width ?? element.outer_width ?? element.width, outerDiameter) : toNumber4(element.outer_width ?? element.width, outerDiameter);
+  const height = hasRectPad ? toNumber4(element.rect_pad_height ?? element.outer_height ?? element.height, width) : toNumber4(element.outer_height ?? element.height, width);
+  const shape = hasRectPad ? normalizeShape(element.pad_shape ?? "rect", width, height) : normalizeShape(elementShape, width, height);
+  const rotation11 = hasRectPad ? toNumber4(element.rect_ccw_rotation ?? element.ccw_rotation ?? element.rotation) : toNumber4(element.ccw_rotation ?? element.rotation);
+  return { height, rotation: rotation11, shape, width };
+};
+var getPlatedHoleGeometry = (element) => {
+  const elementShape = String(element.shape ?? "circle").toLowerCase();
+  const rawHoleShape = String(element.hole_shape ?? (elementShape === "circle" || elementShape === "oval" || elementShape === "pill" ? elementShape : "circle")).toLowerCase();
+  const holeDiameter = toNumber4(element.hole_diameter);
+  const width = toNumber4(element.hole_width, holeDiameter);
+  const height = toNumber4(element.hole_height, width);
+  if (width <= 0 || height <= 0)
+    return;
+  return {
+    height,
+    offsetX: toNumber4(element.hole_offset_x),
+    offsetY: toNumber4(element.hole_offset_y),
+    rotation: toNumber4(element.hole_ccw_rotation ?? (elementShape === "oval" || elementShape === "pill" ? element.ccw_rotation : undefined) ?? element.rotation),
+    shape: normalizeShape(rawHoleShape, width, height),
+    width
+  };
+};
+var parsePolygonPoints = (value, elementName) => {
+  if (!Array.isArray(value) || value.length < 3) {
+    throw new Error(`${elementName} must contain at least three points`);
+  }
+  const points = value.map((rawPoint) => {
+    if (!rawPoint || typeof rawPoint !== "object") {
+      throw new Error(`${elementName} points must contain finite x/y values`);
+    }
+    const point9 = rawPoint;
+    const x4 = toNumber4(point9.x, Number.NaN);
+    const y4 = toNumber4(point9.y, Number.NaN);
+    if (!Number.isFinite(x4) || !Number.isFinite(y4)) {
+      throw new Error(`${elementName} points must contain finite x/y values`);
+    }
+    return { x: x4, y: y4 };
+  });
+  if (getPolygonArea(points) <= 0.000000000001) {
+    throw new Error(`${elementName} must enclose a non-zero area`);
+  }
+  return points;
+};
+var getPolygonSmtPadGeometry = (element) => {
+  const absolutePoints = parsePolygonPoints(element.points, "Polygon PCB SMT pads");
+  const bounds = getBoundsFromPoints5(absolutePoints);
+  if (!bounds) {
+    throw new Error("Polygon PCB SMT pads must contain at least three points");
+  }
+  const { x: x4, y: y4 } = getBoundsCenter2(bounds);
+  return {
+    height: bounds.maxY - bounds.minY,
+    points: absolutePoints.map((point9) => ({
+      x: point9.x - x4,
+      y: point9.y - y4
+    })),
+    width: bounds.maxX - bounds.minX,
+    x: x4,
+    y: y4
+  };
+};
+var getSmtPadMetadata = (element, index) => ({
+  id: String(element.pcb_smtpad_id ?? `pcb_smtpad_${index + 1}`),
+  kind: "smt",
+  layer: String(element.layer ?? "top"),
+  portHints: Array.isArray(element.port_hints) ? element.port_hints.map((hint) => normalizePortHint(String(hint))) : []
+});
+var parseSmtPad = (element, index) => {
+  const metadata = getSmtPadMetadata(element, index);
+  if (element.shape === "polygon") {
+    return {
+      ...metadata,
+      ...getPolygonSmtPadGeometry(element),
+      rotation: 0,
+      shape: "polygon"
+    };
+  }
+  const diameter = toNumber4(element.radius) * 2;
+  const width = toNumber4(element.width, diameter);
+  const height = toNumber4(element.height, width);
+  return {
+    ...metadata,
+    cornerRadius: getCornerRadius(element, width, height),
+    height,
+    rotation: toNumber4(element.ccw_rotation ?? element.rotation),
+    shape: normalizeShape(element.shape, width, height),
+    width,
+    x: toNumber4(element.x),
+    y: toNumber4(element.y)
+  };
+};
+var circuitJsonToPreview = (circuitJson, options = {}) => {
+  const pads = circuitJson.flatMap((rawElement, index) => {
+    const element = rawElement;
+    if (element.type === "pcb_smtpad") {
+      return [parseSmtPad(element, index)];
+    }
+    if (element.type === "pcb_plated_hole") {
+      const { height, rotation: rotation11, shape, width } = getPlatedHolePadGeometry(element);
+      return [
+        {
+          cornerRadius: getCornerRadius(element, width, height),
+          height,
+          hole: getPlatedHoleGeometry(element),
+          id: String(element.pcb_plated_hole_id ?? `pcb_plated_hole_${index + 1}`),
+          kind: "plated-hole",
+          layer: Array.isArray(element.layers) ? String(element.layers[0] ?? "top") : "top",
+          portHints: Array.isArray(element.port_hints) ? element.port_hints.map((hint) => normalizePortHint(String(hint))) : [],
+          rotation: rotation11,
+          shape,
+          width,
+          x: toNumber4(element.x),
+          y: toNumber4(element.y)
+        }
+      ];
+    }
+    return [];
+  });
+  if (pads.length === 0) {
+    throw new Error("Circuit JSON must contain at least one PCB SMT pad or plated hole");
+  }
+  return {
+    pads,
+    sourceHints: options.sourceHints,
+    subtitle: options.subtitle ?? "Circuit JSON footprint",
+    title: options.title ?? "Circuit JSON"
   };
 };
+var footprinterStringToPreview = (footprinterString) => {
+  const normalized = footprinterString.trim();
+  if (!normalized)
+    throw new Error("Footprinter string is required");
+  return circuitJsonToPreview(fp3.string(normalized).circuitJson(), {
+    subtitle: "Generated by @tscircuit/footprinter",
+    title: normalized
+  });
+};
 var SEARCH_GRID_SIZE = 112;
 var MAX_OPTIMIZED_SEEDS = 10;
 var OPTIMIZATION_STEPS = 16;
@@ -286345,6 +286505,34 @@ var NUMERIC_PARAMETERS = [
   "od",
   "id"
 ];
+var FOOTPRINT_ROTATIONS = [0, 90, 180, 270];
+var PIN1_LOCATIONS = [
+  ["leftside", "top"],
+  ["leftside", "bottom"],
+  ["rightside", "top"],
+  ["rightside", "bottom"],
+  ["topside", "left"],
+  ["topside", "right"],
+  ["bottomside", "left"],
+  ["bottomside", "right"]
+];
+var getOrientedHeuristics = (seed, analysis) => {
+  const heuristics = seed.family === "lga" ? {
+    ...analysis.heuristics,
+    h: analysis.bounds.height,
+    pl: analysis.lgaPadLength,
+    pw: analysis.lgaPadWidth,
+    w: analysis.bounds.width
+  } : analysis.heuristics;
+  if (seed.searchRotation !== 90 && seed.searchRotation !== 270) {
+    return heuristics;
+  }
+  return {
+    ...heuristics,
+    h: heuristics.w,
+    w: heuristics.h
+  };
+};
 var clamp5 = (value, min, max2) => Math.min(Math.max(value, min), max2);
 var median = (values) => {
   if (!values.length)
@@ -286353,36 +286541,8 @@ var median = (values) => {
   const middle = Math.floor(sorted.length / 2);
   return sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle];
 };
-var getPadBounds22 = (pad2) => {
-  const radians = pad2.rotation * Math.PI / 180;
-  const cosine = Math.abs(Math.cos(radians));
-  const sine = Math.abs(Math.sin(radians));
-  const width = pad2.width * cosine + pad2.height * sine;
-  const height = pad2.width * sine + pad2.height * cosine;
-  return {
-    height,
-    maxX: pad2.x + width / 2,
-    maxY: pad2.y + height / 2,
-    minX: pad2.x - width / 2,
-    minY: pad2.y - height / 2,
-    width
-  };
-};
-var getBounds3 = (pads) => {
-  const padBounds = pads.map(getPadBounds22);
-  const minX = Math.min(...padBounds.map((bound) => bound.minX));
-  const minY = Math.min(...padBounds.map((bound) => bound.minY));
-  const maxX = Math.max(...padBounds.map((bound) => bound.maxX));
-  const maxY = Math.max(...padBounds.map((bound) => bound.maxY));
-  return {
-    height: maxY - minY,
-    maxX,
-    maxY,
-    minX,
-    minY,
-    width: maxX - minX
-  };
-};
+var getPadBounds3 = (pad2) => getFootprintBounds([pad2]);
+var getBounds3 = (pads) => getFootprintBounds(pads);
 var clusterCoordinates = (values, tolerance) => {
   const sorted = [...values].sort((left, right) => left - right);
   const clusters = [];
@@ -286412,39 +286572,59 @@ var getPitchEstimate = (pads, tolerance) => {
   }
   if (!differences.length)
     return Math.max(tolerance * 2, 1);
-  return median(differences);
+  const sortedDifferences = differences.toSorted((left, right) => left - right);
+  return sortedDifferences[Math.floor((sortedDifferences.length - 1) * 0.25)];
 };
 var analyzeTarget = (target) => {
   const bounds = getBounds3(target.pads);
-  const padBounds = target.pads.map(getPadBounds22);
+  const padBounds = target.pads.map(getPadBounds3);
   const medianPadWidth = median(padBounds.map((bound) => bound.width));
   const medianPadHeight = median(padBounds.map((bound) => bound.height));
   const tolerance = Math.max(Math.min(medianPadWidth, medianPadHeight) * 0.22, 0.015);
-  const xCoordinates = clusterCoordinates(target.pads.map((pad2) => pad2.x), tolerance);
-  const yCoordinates = clusterCoordinates(target.pads.map((pad2) => pad2.y), tolerance);
   const centerX = (bounds.minX + bounds.maxX) / 2;
   const centerY = (bounds.minY + bounds.maxY) / 2;
-  const edgeToleranceX = Math.max(medianPadWidth * 0.75, bounds.width * 0.08);
-  const edgeToleranceY = Math.max(medianPadHeight * 0.75, bounds.height * 0.08);
-  const sidePads = target.pads.filter((pad2) => Math.abs(pad2.x - (bounds.minX + medianPadWidth / 2)) <= edgeToleranceX || Math.abs(pad2.x - (bounds.maxX - medianPadWidth / 2)) <= edgeToleranceX || Math.abs(pad2.y - (bounds.minY + medianPadHeight / 2)) <= edgeToleranceY || Math.abs(pad2.y - (bounds.maxY - medianPadHeight / 2)) <= edgeToleranceY);
   const medianPadArea = median(padBounds.map((bound) => bound.width * bound.height));
-  const thermalPad = target.pads.map((pad2) => ({ bound: getPadBounds22(pad2), pad: pad2 })).filter(({ bound, pad: pad2 }) => Math.abs(pad2.x - centerX) <= medianPadWidth && Math.abs(pad2.y - centerY) <= medianPadHeight && bound.width * bound.height > medianPadArea * 2.5).sort((left, right) => right.bound.width * right.bound.height - left.bound.width * left.bound.height)[0]?.bound;
-  const gridOccupancy = target.pads.length / Math.max(xCoordinates.length * yCoordinates.length, 1);
-  const hasPadsOnFourSides = sidePads.filter((pad2) => Math.abs(pad2.x - centerX) > bounds.width * 0.3).length >= 4 && sidePads.filter((pad2) => Math.abs(pad2.y - centerY) > bounds.height * 0.3).length >= 4;
+  const thermalPadEntry = target.pads.map((pad2) => ({ bound: getPadBounds3(pad2), pad: pad2 })).filter(({ bound, pad: pad2 }) => Math.abs(pad2.x - centerX) <= medianPadWidth && Math.abs(pad2.y - centerY) <= medianPadHeight && bound.width * bound.height > medianPadArea * 2.5).sort((left, right) => right.bound.width * right.bound.height - left.bound.width * left.bound.height)[0];
+  const topologyPads = thermalPadEntry ? target.pads.filter((pad2) => pad2 !== thermalPadEntry.pad) : target.pads;
+  const topologyBounds = getBounds3(topologyPads);
+  const topologyCenterX = (topologyBounds.minX + topologyBounds.maxX) / 2;
+  const topologyCenterY = (topologyBounds.minY + topologyBounds.maxY) / 2;
+  const xCoordinates = clusterCoordinates(topologyPads.map((pad2) => pad2.x), tolerance);
+  const yCoordinates = clusterCoordinates(topologyPads.map((pad2) => pad2.y), tolerance);
+  const edgeToleranceX = Math.max(medianPadWidth * 0.75, topologyBounds.width * 0.08);
+  const edgeToleranceY = Math.max(medianPadHeight * 0.75, topologyBounds.height * 0.08);
+  const sidePads = topologyPads.filter((pad2) => Math.abs(pad2.x - (topologyBounds.minX + medianPadWidth / 2)) <= edgeToleranceX || Math.abs(pad2.x - (topologyBounds.maxX - medianPadWidth / 2)) <= edgeToleranceX || Math.abs(pad2.y - (topologyBounds.minY + medianPadHeight / 2)) <= edgeToleranceY || Math.abs(pad2.y - (topologyBounds.maxY - medianPadHeight / 2)) <= edgeToleranceY);
+  const minPadCenterX = Math.min(...topologyPads.map((pad2) => pad2.x));
+  const maxPadCenterX = Math.max(...topologyPads.map((pad2) => pad2.x));
+  const minPadCenterY = Math.min(...topologyPads.map((pad2) => pad2.y));
+  const maxPadCenterY = Math.max(...topologyPads.map((pad2) => pad2.y));
+  const topologyPadEntries = topologyPads.map((pad2) => ({
+    bounds: getPadBounds3(pad2),
+    pad: pad2
+  }));
+  const leftRightEdgePads = topologyPadEntries.filter(({ pad: pad2 }) => Math.abs(pad2.x - minPadCenterX) <= tolerance || Math.abs(pad2.x - maxPadCenterX) <= tolerance);
+  const topBottomEdgePads = topologyPadEntries.filter(({ pad: pad2 }) => Math.abs(pad2.y - minPadCenterY) <= tolerance || Math.abs(pad2.y - maxPadCenterY) <= tolerance);
+  const leftSidePadCount = topologyPadEntries.filter(({ bounds: bound, pad: pad2 }) => Math.abs(pad2.x - minPadCenterX) <= edgeToleranceX && bound.width >= bound.height * 0.95).length;
+  const rightSidePadCount = topologyPadEntries.filter(({ bounds: bound, pad: pad2 }) => Math.abs(pad2.x - maxPadCenterX) <= edgeToleranceX && bound.width >= bound.height * 0.95).length;
+  const bottomSidePadCount = topologyPadEntries.filter(({ bounds: bound, pad: pad2 }) => Math.abs(pad2.y - minPadCenterY) <= edgeToleranceY && bound.height >= bound.width * 0.95).length;
+  const topSidePadCount = topologyPadEntries.filter(({ bounds: bound, pad: pad2 }) => Math.abs(pad2.y - maxPadCenterY) <= edgeToleranceY && bound.height >= bound.width * 0.95).length;
+  const gridOccupancy = topologyPads.length / Math.max(xCoordinates.length * yCoordinates.length, 1);
+  const hasPadsOnFourSides = sidePads.filter((pad2) => Math.abs(pad2.x - topologyCenterX) > topologyBounds.width * 0.3).length >= 4 && sidePads.filter((pad2) => Math.abs(pad2.y - topologyCenterY) > topologyBounds.height * 0.3).length >= 4;
   let topology = "irregular";
   if (xCoordinates.length === 1 || yCoordinates.length === 1) {
     topology = "linear";
   } else if (xCoordinates.length <= 2 || yCoordinates.length <= 2) {
     topology = "two-sided";
-  } else if (target.pads.length >= 4 && xCoordinates.length >= 2 && yCoordinates.length >= 2 && gridOccupancy >= 0.68) {
+  } else if (topologyPads.length >= 4 && xCoordinates.length >= 2 && yCoordinates.length >= 2 && gridOccupancy >= 0.68) {
     topology = "grid";
-  } else if (hasPadsOnFourSides && target.pads.length >= 8) {
+  } else if (hasPadsOnFourSides && topologyPads.length >= 8) {
     topology = "four-sided";
   }
   const pitch = getPitchEstimate(target.pads, tolerance);
   const medianPadLongSide = median(padBounds.map((bound) => Math.max(bound.width, bound.height)));
   const medianPadShortSide = median(padBounds.map((bound) => Math.min(bound.width, bound.height)));
   const medianPadDiameter = median(padBounds.map((bound) => Math.sqrt(bound.width * bound.height)));
+  const medianHoleDiameter = median(target.pads.flatMap((pad2) => pad2.hole ? [Math.sqrt(pad2.hole.width * pad2.hole.height)] : []));
   const platedHoleCount = target.pads.filter((pad2) => pad2.kind === "plated-hole").length;
   const insetQuadAdjustment = topology === "four-sided" ? 0.2 : 0;
   return {
@@ -286454,7 +286634,7 @@ var analyzeTarget = (target) => {
     heuristics: {
       ball: medianPadDiameter,
       h: bounds.height + insetQuadAdjustment,
-      id: medianPadDiameter * 0.6,
+      id: medianHoleDiameter || medianPadDiameter * 0.6,
       od: medianPadDiameter,
       p: pitch,
       pad: medianPadDiameter,
@@ -286463,10 +286643,17 @@ var analyzeTarget = (target) => {
       pw: medianPadShortSide,
       w: bounds.width + insetQuadAdjustment
     },
+    horizontalSidePadCount: Math.max(leftSidePadCount, rightSidePadCount),
+    lgaPadLength: leftRightEdgePads.length ? median(leftRightEdgePads.map(({ bounds: bound }) => bound.width)) : median(topBottomEdgePads.map(({ bounds: bound }) => bound.height)),
+    lgaPadWidth: leftRightEdgePads.length ? median(leftRightEdgePads.map(({ bounds: bound }) => bound.height)) : median(topBottomEdgePads.map(({ bounds: bound }) => bound.width)),
     perimeterPadCount: sidePads.length,
     platedHoleCount,
-    thermalPad: thermalPad ? { height: thermalPad.height, width: thermalPad.width } : undefined,
-    topology
+    thermalPad: thermalPadEntry ? {
+      height: thermalPadEntry.bound.height,
+      width: thermalPadEntry.bound.width
+    } : undefined,
+    topology,
+    verticalSidePadCount: Math.max(bottomSidePadCount, topSidePadCount)
   };
 };
 var normalizePads = (pads) => {
@@ -286479,8 +286666,28 @@ var normalizePads = (pads) => {
     y: pad2.y - centerY
   }));
 };
+var rotateFootprint = (footprint, rotation11) => {
+  if (rotation11 === 0)
+    return footprint;
+  const radians = rotation11 * Math.PI / 180;
+  return {
+    ...footprint,
+    pads: footprint.pads.map((pad2) => ({
+      ...pad2,
+      hole: pad2.hole ? {
+        ...pad2.hole,
+        offsetX: pad2.hole.offsetX * Math.cos(radians) - pad2.hole.offsetY * Math.sin(radians),
+        offsetY: pad2.hole.offsetX * Math.sin(radians) + pad2.hole.offsetY * Math.cos(radians),
+        rotation: (pad2.hole.rotation + rotation11) % 360
+      } : undefined,
+      rotation: (pad2.rotation + rotation11) % 360,
+      x: pad2.x * Math.cos(radians) - pad2.y * Math.sin(radians),
+      y: pad2.x * Math.sin(radians) + pad2.y * Math.cos(radians)
+    }))
+  };
+};
 var getOrientedPadSize = (pad2) => {
-  const bounds = getPadBounds22({ ...pad2, x: 0, y: 0 });
+  const bounds = getPadBounds3({ ...pad2, x: 0, y: 0 });
   return { height: bounds.height, width: bounds.width };
 };
 var matchPadsByPosition = (left, right) => {
@@ -286521,6 +286728,22 @@ var getGeometryLoss = (candidate, target) => {
       loss += 4;
     if (candidatePad.shape !== targetPad.shape)
       loss += 0.08;
+    if (Boolean(candidatePad.hole) !== Boolean(targetPad.hole)) {
+      loss += 4;
+    } else if (candidatePad.hole && targetPad.hole) {
+      const holeWidthScale = Math.max(targetPad.hole.width, 0.05);
+      const holeHeightScale = Math.max(targetPad.hole.height, 0.05);
+      const holeWidthDifference = (candidatePad.hole.width - targetPad.hole.width) / holeWidthScale;
+      const holeHeightDifference = (candidatePad.hole.height - targetPad.hole.height) / holeHeightScale;
+      const holeOffsetXDifference = (candidatePad.hole.offsetX - targetPad.hole.offsetX) / positionScale;
+      const holeOffsetYDifference = (candidatePad.hole.offsetY - targetPad.hole.offsetY) / positionScale;
+      loss += holeWidthDifference * holeWidthDifference + holeHeightDifference * holeHeightDifference + holeOffsetXDifference * holeOffsetXDifference * 4 + holeOffsetYDifference * holeOffsetYDifference * 4;
+      if (candidatePad.hole.shape !== targetPad.hole.shape)
+        loss += 0.08;
+    }
+    if (targetPad.portHints.length > 0 && !candidatePad.portHints.some((hint) => targetPad.portHints.includes(hint))) {
+      loss += 0.04;
+    }
   }
   return loss / pairs4.length;
 };
@@ -286530,11 +286753,13 @@ var getDomainScore = (target, family) => {
   const aliases2 = {
     cap: ["capacitor", "cap"],
     dfn: ["dfn"],
+    lga: ["lga"],
     qfn: ["qfn"],
     res: ["resistor", "res"],
     soic: ["soic", "so-"],
     ssop: ["ssop"],
-    tssop: ["tssop"]
+    tssop: ["tssop"],
+    usbcmidmount: ["usb-c", "usb c", "type-c", "type c", "usbc"]
   };
   const terms = aliases2[family] ?? [family];
   return terms.some((term) => description.includes(term)) ? 1 : 0;
@@ -286559,7 +286784,71 @@ var buildParameterizedString = (seed, parameters) => {
   }).join("_");
   return suffix ? `${seed}_${suffix}` : seed;
 };
-var geometrySignature = (preview) => preview.pads.map((pad2) => [pad2.kind, pad2.shape, pad2.x, pad2.y, pad2.width, pad2.height, pad2.rotation].map(String).join(":")).join("|");
+var geometrySignature = (preview) => preview.pads.map((pad2) => {
+  const holeSignature = pad2.hole ? [
+    pad2.hole.shape,
+    pad2.hole.offsetX,
+    pad2.hole.offsetY,
+    pad2.hole.width,
+    pad2.hole.height,
+    pad2.hole.rotation
+  ].join(":") : "no-hole";
+  const pointSignature = pad2.shape === "polygon" ? pad2.points?.map((point9) => `${point9.x}:${point9.y}`).join(",") : "no-points";
+  return [
+    pad2.kind,
+    pad2.shape,
+    pad2.x,
+    pad2.y,
+    pad2.width,
+    pad2.height,
+    pad2.rotation,
+    pointSignature,
+    holeSignature
+  ].map(String).join(":");
+}).join("|");
+var padShapeSignature = (preview) => preview.pads.map((pad2) => `${pad2.kind}:${pad2.shape}`).toSorted().join("|");
+var areClose = (left, right) => Math.abs(left - right) <= 0.00001;
+var areSamePoint = (left, right) => areClose(left.x, right.x) && areClose(left.y, right.y);
+var haveSamePolygon = (left, right) => {
+  if (left.shape !== "polygon" && right.shape !== "polygon")
+    return true;
+  if (left.shape !== "polygon" || right.shape !== "polygon")
+    return false;
+  const leftPoints = getPolygonWorldPoints(left);
+  const rightPoints = getPolygonWorldPoints(right);
+  if (leftPoints.length !== rightPoints.length)
+    return false;
+  const matchesFrom = (startIndex, direction2) => leftPoints.every((leftPoint, index) => {
+    const rightIndex = (startIndex + direction2 * index + rightPoints.length) % rightPoints.length;
+    return areSamePoint(leftPoint, rightPoints[rightIndex]);
+  });
+  return rightPoints.some((rightPoint, startIndex) => areSamePoint(leftPoints[0], rightPoint) && (matchesFrom(startIndex, 1) || matchesFrom(startIndex, -1)));
+};
+var haveSameOrientedPads = (left, right) => {
+  if (left.pads.length !== right.pads.length)
+    return false;
+  return left.pads.every((leftPad, index) => {
+    const rightPad = right.pads[index];
+    if (!rightPad)
+      return false;
+    const leftSize = getOrientedPadSize(leftPad);
+    const rightSize = getOrientedPadSize(rightPad);
+    const holesMatch = !leftPad.hole && !rightPad.hole ? true : Boolean(leftPad.hole && rightPad.hole) && leftPad.hole?.shape === rightPad.hole?.shape && areClose(leftPad.hole?.offsetX ?? 0, rightPad.hole?.offsetX ?? 0) && areClose(leftPad.hole?.offsetY ?? 0, rightPad.hole?.offsetY ?? 0) && areClose(leftPad.hole?.width ?? 0, rightPad.hole?.width ?? 0) && areClose(leftPad.hole?.height ?? 0, rightPad.hole?.height ?? 0) && areClose(leftPad.hole?.rotation ?? 0, rightPad.hole?.rotation ?? 0);
+    return leftPad.kind === rightPad.kind && leftPad.shape === rightPad.shape && leftPad.portHints.join("|") === rightPad.portHints.join("|") && areClose(leftPad.x, rightPad.x) && areClose(leftPad.y, rightPad.y) && areClose(leftSize.width, rightSize.width) && areClose(leftSize.height, rightSize.height) && haveSamePolygon(leftPad, rightPad) && holesMatch;
+  });
+};
+var encodeOrientationInFootprinterString = (footprinterString, searchRotation, orientedPreview) => {
+  if (searchRotation === 0)
+    return footprinterString;
+  for (const [side, alignment] of PIN1_LOCATIONS) {
+    const orientedString = `${footprinterString}_pin1location(${side},${alignment})`;
+    const preview = tryBuild(orientedString);
+    if (preview && haveSameOrientedPads(preview, orientedPreview)) {
+      return orientedString;
+    }
+  }
+  return null;
+};
 var getPreferredFamilies = (analysis) => {
   if (analysis.platedHoleCount > analysis.perimeterPadCount / 2) {
     return /* @__PURE__ */ new Set([
@@ -286569,16 +286858,18 @@ var getPreferredFamilies = (analysis) => {
       "pinrow",
       "radial",
       "to220",
-      "to92"
+      "to92",
+      "usbcmidmount"
     ]);
   }
   if (analysis.topology === "grid")
     return /* @__PURE__ */ new Set(["bga"]);
   if (analysis.topology === "four-sided") {
-    return /* @__PURE__ */ new Set(["lqfp", "mlp", "qfn", "qfp", "quad", "tqfp"]);
+    return /* @__PURE__ */ new Set(["lga", "lqfp", "mlp", "qfn", "qfp", "quad", "tqfp"]);
   }
   if (analysis.topology === "two-sided") {
     return /* @__PURE__ */ new Set([
+      "lga",
       "soic",
       "tssop",
       "ssop",
@@ -286599,20 +286890,43 @@ var generateSeeds = (target, analysis) => {
   const seeds = /* @__PURE__ */ new Set;
   for (const family of getFootprintNames2()) {
     seeds.add(`${family}${padCount}`);
-    seeds.add(family);
+    if (family !== "usbcmidmount")
+      seeds.add(family);
   }
   if (analysis.thermalPad && analysis.perimeterPadCount > 0) {
-    const thermalPadDimensions = `${formatMillimeters(analysis.thermalPad.width)}x${formatMillimeters(analysis.thermalPad.height)}`;
-    for (const family of ["mlp", "qfn", "quad"]) {
+    const thermalPadDimensionOptions = /* @__PURE__ */ new Set([
+      `${formatMillimeters(analysis.thermalPad.width)}x${formatMillimeters(analysis.thermalPad.height)}`,
+      `${formatMillimeters(analysis.thermalPad.height)}x${formatMillimeters(analysis.thermalPad.width)}`
+    ]);
+    const thermalPadFamilies = analysis.topology === "two-sided" ? ["dfn", "msop", "soic", "ssop", "tssop", "vssop"] : ["mlp", "qfn", "quad"];
+    for (const family of thermalPadFamilies) {
       seeds.add(`${family}${analysis.perimeterPadCount}_thermalpad`);
-      seeds.add(`${family}${analysis.perimeterPadCount}_thermalpad${thermalPadDimensions}`);
+      for (const thermalPadDimensions of thermalPadDimensionOptions) {
+        seeds.add(`${family}${analysis.perimeterPadCount}_thermalpad${thermalPadDimensions}`);
+      }
     }
   }
   if (analysis.topology === "grid") {
     seeds.add(`bga${padCount}_grid${analysis.gridColumns}x${analysis.gridRows}`);
   }
+  if (analysis.topology === "four-sided" && 2 * (analysis.horizontalSidePadCount + analysis.verticalSidePadCount) === analysis.perimeterPadCount) {
+    seeds.add(`lga${analysis.perimeterPadCount}_grid${analysis.horizontalSidePadCount}x${analysis.verticalSidePadCount}`);
+  }
+  const hasLgaHint = target.sourceHints?.some((hint) => hint.toLowerCase().includes("lga"));
+  if (analysis.topology === "two-sided" && hasLgaHint) {
+    const padsPerSide = analysis.perimeterPadCount / 2;
+    if (Number.isInteger(padsPerSide)) {
+      const grid = analysis.gridColumns <= 2 ? `${padsPerSide}x0` : `0x${padsPerSide}`;
+      seeds.add(`lga${analysis.perimeterPadCount}_grid${grid}`);
+    }
+  }
+  if (analysis.topology === "two-sided" && padCount % 2 === 1) {
+    for (let missingPosition = 1;missingPosition <= padCount + 1; missingPosition += 1) {
+      seeds.add(`dfn${padCount + 1}_missing(${missingPosition})`);
+    }
+  }
   if (padCount === 2 && analysis.platedHoleCount === 0) {
-    const padBounds = target.pads.map(getPadBounds22);
+    const padBounds = target.pads.map(getPadBounds3);
     const passiveDimensions = `p${formatMillimeters(analysis.heuristics.p)}_pw${formatMillimeters(median(padBounds.map((bound) => bound.width)))}_ph${formatMillimeters(median(padBounds.map((bound) => bound.height)))}`;
     seeds.add(`res_${passiveDimensions}`);
     seeds.add(`cap_${passiveDimensions}`);
@@ -286622,18 +286936,49 @@ var generateSeeds = (target, analysis) => {
       seeds.add(`res${size.imperial}`);
     }
   }
+  if (target.pads.some((pad2) => pad2.shape === "pill")) {
+    for (const seed of [...seeds]) {
+      const pillPadSeed = `${seed}_pillpads`;
+      const preview = tryBuild(pillPadSeed);
+      if (preview?.pads.length === padCount && preview.pads.some((pad2) => pad2.shape === "pill")) {
+        seeds.add(pillPadSeed);
+      }
+    }
+  }
   return [...seeds];
 };
-var selectSeedsToOptimize = (candidates, analysis) => {
+var selectSeedsToOptimize = (candidates, analysis, target) => {
   const selected = /* @__PURE__ */ new Map;
+  const targetPadShapeSignature = padShapeSignature(target);
+  const selectedShapeFamilies = /* @__PURE__ */ new Set;
+  if (analysis.topology === "four-sided" || analysis.topology === "two-sided") {
+    const lgaGridCandidate = candidates.find((candidate) => candidate.family === "lga" && candidate.footprinterString.includes("_grid") && candidate.searchRotation === 0);
+    if (lgaGridCandidate) {
+      selected.set(`${lgaGridCandidate.footprinterString}:${lgaGridCandidate.searchRotation}`, lgaGridCandidate);
+    }
+  }
+  if (target.pads.some((pad2) => pad2.shape === "pill")) {
+    for (const candidate of candidates) {
+      if (padShapeSignature(candidate.preview) !== targetPadShapeSignature) {
+        continue;
+      }
+      if (selectedShapeFamilies.has(candidate.family))
+        continue;
+      selectedShapeFamilies.add(candidate.family);
+      selected.set(`${candidate.footprinterString}:${candidate.searchRotation}`, candidate);
+      if (selected.size >= 4)
+        break;
+    }
+  }
   for (const candidate of candidates.slice(0, 4)) {
-    selected.set(candidate.footprinterString, candidate);
+    selected.set(`${candidate.footprinterString}:${candidate.searchRotation}`, candidate);
   }
   const preferredFamilies = getPreferredFamilies(analysis);
   for (const family of preferredFamilies) {
-    const candidate = candidates.find((entry) => entry.family === family && entry.footprinterString === family) ?? candidates.find((entry) => entry.family === family);
-    if (candidate)
-      selected.set(candidate.footprinterString, candidate);
+    const candidate = (analysis.thermalPad ? candidates.find((entry) => entry.family === family && entry.footprinterString.includes("_thermalpad")) : undefined) ?? (family === "dfn" ? candidates.find((entry) => entry.family === family && entry.footprinterString.includes("_missing(")) : undefined) ?? (family === "lga" ? candidates.find((entry) => entry.family === family && entry.footprinterString.includes("_grid")) : undefined) ?? candidates.find((entry) => entry.family === family && entry.footprinterString === family) ?? candidates.find((entry) => entry.family === family);
+    if (candidate) {
+      selected.set(`${candidate.footprinterString}:${candidate.searchRotation}`, candidate);
+    }
     if (selected.size >= MAX_OPTIMIZED_SEEDS)
       break;
   }
@@ -286642,12 +286987,14 @@ var selectSeedsToOptimize = (candidates, analysis) => {
 var findActiveParameters = (seed, analysis) => {
   const active = [];
   const baseSignature = geometrySignature(seed.preview);
+  const heuristics = getOrientedHeuristics(seed, analysis);
   for (const parameter of NUMERIC_PARAMETERS) {
-    const heuristic = Math.max(analysis.heuristics[parameter], 0.05);
+    const heuristic = Math.max(heuristics[parameter], 0.05);
     const preview = tryBuild(buildParameterizedString(seed.footprinterString, {
       [parameter]: heuristic
     }));
-    if (preview && preview.pads.length === seed.preview.pads.length && geometrySignature(preview) !== baseSignature) {
+    const orientedPreview = preview ? rotateFootprint(preview, seed.searchRotation) : null;
+    if (orientedPreview && orientedPreview.pads.length === seed.preview.pads.length && geometrySignature(orientedPreview) !== baseSignature) {
       active.push(parameter);
     }
   }
@@ -286662,13 +287009,17 @@ var optimizeSeed = (seed, target, analysis) => {
     };
   }
   const values = {};
+  const heuristics = getOrientedHeuristics(seed, analysis);
   for (const parameter of activeParameters) {
-    values[parameter] = Math.max(analysis.heuristics[parameter], 0.05);
+    values[parameter] = Math.max(heuristics[parameter], 0.05);
   }
   const evaluate = (parameters) => {
     const footprinterString = buildParameterizedString(seed.footprinterString, parameters);
-    const preview = tryBuild(footprinterString);
-    if (!preview || preview.pads.length !== target.pads.length) {
+    const unrotatedPreview = tryBuild(footprinterString);
+    if (!unrotatedPreview)
+      return null;
+    const preview = rotateFootprint(unrotatedPreview, seed.searchRotation);
+    if (preview.pads.length !== target.pads.length) {
       return null;
     }
     return {
@@ -286710,9 +287061,9 @@ var optimizeSeed = (seed, target, analysis) => {
       secondMoments[parameter] = secondMoment;
       const correctedFirstMoment = firstMoment / (1 - 0.9 ** iteration);
       const correctedSecondMoment = secondMoment / (1 - 0.999 ** iteration);
-      const stepScale = Math.max(analysis.heuristics[parameter] * 0.075, 0.025);
+      const stepScale = Math.max(heuristics[parameter] * 0.075, 0.025);
       const currentValue = values[parameter] ?? 0.05;
-      const upperBound2 = Math.max(analysis.bounds.width, analysis.bounds.height, analysis.heuristics[parameter]) * 3;
+      const upperBound2 = Math.max(analysis.bounds.width, analysis.bounds.height, heuristics[parameter]) * 3;
       values[parameter] = clamp5(currentValue - stepScale * correctedFirstMoment / (Math.sqrt(correctedSecondMoment) + 0.00000001), 0.025, Math.max(upperBound2, 0.1));
     }
     current2 = evaluate(values);
@@ -286734,17 +287085,20 @@ var optimizeSeed = (seed, target, analysis) => {
     const withoutParameter = { ...simplifiedParameters };
     delete withoutParameter[parameter];
     const simplifiedPreview2 = tryBuild(buildParameterizedString(seed.footprinterString, withoutParameter));
-    if (simplifiedPreview2 && geometrySignature(simplifiedPreview2) === bestSignature) {
+    const orientedSimplifiedPreview = simplifiedPreview2 ? rotateFootprint(simplifiedPreview2, seed.searchRotation) : null;
+    if (orientedSimplifiedPreview && geometrySignature(orientedSimplifiedPreview) === bestSignature) {
       delete simplifiedParameters[parameter];
     }
   }
   const simplifiedString = buildParameterizedString(seed.footprinterString, simplifiedParameters);
-  const simplifiedPreview = tryBuild(simplifiedString) ?? best.preview;
+  const unrotatedSimplifiedPreview = tryBuild(simplifiedString);
+  const simplifiedPreview = unrotatedSimplifiedPreview ? rotateFootprint(unrotatedSimplifiedPreview, seed.searchRotation) : best.preview;
   return {
     family: seed.family,
     footprinterString: simplifiedString,
     geometryScore: 1 / (1 + best.loss),
     optimizedParameters: simplifiedParameters,
+    searchRotation: seed.searchRotation,
     preview: simplifiedPreview
   };
 };
@@ -286752,44 +287106,63 @@ var discoverFootprinterString = (target, maxCandidates = 5) => {
   const analysis = analyzeTarget(target);
   const rawSeeds = generateSeeds(target, analysis);
   const seedCandidates = rawSeeds.flatMap((footprinterString) => {
-    const preview = tryBuild(footprinterString);
-    if (!preview || preview.pads.length !== target.pads.length)
+    const unrotatedPreview = tryBuild(footprinterString);
+    if (!unrotatedPreview || unrotatedPreview.pads.length !== target.pads.length) {
       return [];
-    const platedHoleCount = preview.pads.filter((pad2) => pad2.kind === "plated-hole").length;
-    if (platedHoleCount !== analysis.platedHoleCount)
-      return [];
-    return [
-      {
-        family: getFamily(footprinterString),
-        footprinterString,
-        geometryScore: getGeometryScore(preview, target),
-        preview
-      }
-    ];
+    }
+    return FOOTPRINT_ROTATIONS.flatMap((searchRotation) => {
+      const preview = rotateFootprint(unrotatedPreview, searchRotation);
+      const platedHoleCount = preview.pads.filter((pad2) => pad2.kind === "plated-hole").length;
+      if (platedHoleCount !== analysis.platedHoleCount)
+        return [];
+      return [
+        {
+          family: getFamily(footprinterString),
+          footprinterString,
+          geometryScore: getGeometryScore(preview, target),
+          preview,
+          searchRotation
+        }
+      ];
+    });
   });
-  seedCandidates.sort((left, right) => right.geometryScore - left.geometryScore);
-  const selectedSeeds = selectSeedsToOptimize(seedCandidates, analysis);
+  seedCandidates.sort((left, right) => right.geometryScore - left.geometryScore || left.searchRotation - right.searchRotation);
+  const selectedSeeds = selectSeedsToOptimize(seedCandidates, analysis, target);
   const optimized = selectedSeeds.map((seed) => optimizeSeed(seed, target, analysis));
+  const targetPadShapeSignature = padShapeSignature(target);
   const allCandidates = [...optimized, ...seedCandidates].map((candidate) => {
-    const copperIntersectionOverUnion = summarizeCopperComparison(candidate.preview, target, SEARCH_GRID_SIZE).copperIntersectionOverUnion;
+    const { copperIntersectionOverUnion, holeIntersectionOverUnion } = summarizeCopperComparison(candidate.preview, target, SEARCH_GRID_SIZE);
     const domainScore = getDomainScore(target, candidate.family);
+    const shapesMatch = padShapeSignature(candidate.preview) === targetPadShapeSignature;
     return {
       copperIntersectionOverUnion,
       domainScore,
       family: candidate.family,
       footprinterString: candidate.footprinterString,
       geometryScore: candidate.geometryScore,
+      holeIntersectionOverUnion,
       optimizedParameters: "optimizedParameters" in candidate ? candidate.optimizedParameters : {},
-      rankingScore: copperIntersectionOverUnion + domainScore * 0.08
+      preview: candidate.preview,
+      rankingScore: copperIntersectionOverUnion + (holeIntersectionOverUnion - 1) * 0.12 + domainScore * (shapesMatch ? 0.08 : 0.01),
+      searchRotation: candidate.searchRotation
     };
-  }).sort((left, right) => right.rankingScore - left.rankingScore || right.copperIntersectionOverUnion - left.copperIntersectionOverUnion || right.domainScore - left.domainScore || right.geometryScore - left.geometryScore || left.footprinterString.length - right.footprinterString.length);
+  }).sort((left, right) => right.rankingScore - left.rankingScore || right.copperIntersectionOverUnion - left.copperIntersectionOverUnion || right.holeIntersectionOverUnion - left.holeIntersectionOverUnion || right.domainScore - left.domainScore || right.geometryScore - left.geometryScore || left.searchRotation - right.searchRotation || left.footprinterString.length - right.footprinterString.length);
   const uniqueCandidates = [];
   const seenStrings = /* @__PURE__ */ new Set;
   for (const candidate of allCandidates) {
-    if (seenStrings.has(candidate.footprinterString))
+    const orientedString = encodeOrientationInFootprinterString(candidate.footprinterString, candidate.searchRotation, candidate.preview);
+    if (!orientedString || seenStrings.has(orientedString))
       continue;
-    seenStrings.add(candidate.footprinterString);
-    uniqueCandidates.push(candidate);
+    seenStrings.add(orientedString);
+    const {
+      preview: _preview,
+      searchRotation: _searchRotation,
+      ...publicData
+    } = candidate;
+    uniqueCandidates.push({
+      ...publicData,
+      footprinterString: orientedString
+    });
     if (uniqueCandidates.length >= clamp5(maxCandidates, 1, 10))
       break;
   }
@@ -286810,6 +287183,9 @@ var circuitJsonToFootprinter = (circuitJson, options = {}) => {
   return discoverFootprinterString(target, options.maxCandidates);
 };
 
+// lib/shared/circuit-json-to-footprinter.ts
+var circuitJsonToFootprinter2 = circuitJsonToFootprinter;
+
 // cli/convert/discover-footprinter-from-file.ts
 import fs51 from "node:fs/promises";
 import path56 from "node:path";
@@ -286853,7 +287229,7 @@ var discoverFootprinterFromFile = async ({
 }) => {
   const circuitJson = await loadCircuitJsonForFootprinter(inputPath);
   const inputText = await fs51.readFile(inputPath, "utf-8");
-  const result = circuitJsonToFootprinter(circuitJson, {
+  const result = circuitJsonToFootprinter2(circuitJson, {
     sourceHints: [path56.basename(inputPath), inputText.slice(0, 20000)]
   });
   if (!result.best) {
@@ -291789,7 +292165,7 @@ import {
 
 // node_modules/dsn-converter/dist/index.js
 import { su as su14 } from "@tscircuit/soup-util";
-import { getBoundsFromPoints as getBoundsFromPoints4 } from "@tscircuit/math-utils";
+import { getBoundsFromPoints as getBoundsFromPoints6 } from "@tscircuit/math-utils";
 import { applyToPoint as applyToPoint31, scale as scale8 } from "transformation-matrix";
 import { su as su24 } from "@tscircuit/soup-util";
 import { su as su34 } from "@tscircuit/soup-util";
@@ -292033,9 +292409,9 @@ function getPolygonCentroid2(points) {
     y: centroidY / areaFactor
   };
 }
-function getPolygonSmtPadGeometry(pad2) {
+function getPolygonSmtPadGeometry2(pad2) {
   const points = getNormalizedPoints(pad2.points);
-  const bounds = getBoundsFromPoints4(points);
+  const bounds = getBoundsFromPoints6(points);
   if (!bounds) {
     return {
       center: { x: 0, y: 0 },
@@ -292071,7 +292447,7 @@ function createAndAddPadstackFromPcbSmtPad({
 }) {
   const isCircle = pad2.shape === "circle";
   const isPolygon = pad2.shape === "polygon";
-  const polygonPadGeometry = isPolygon ? getPolygonSmtPadGeometry(pad2) : undefined;
+  const polygonPadGeometry = isPolygon ? getPolygonSmtPadGeometry2(pad2) : undefined;
   let shape = "rect";
   let outerDiameter;
   let holeDiameter;
@@ -292128,7 +292504,7 @@ function createPinForImage({
     return;
   const isCircle = pad2.shape === "circle";
   const isPolygon = pad2.shape === "polygon";
-  const polygonPadGeometry = isPolygon ? getPolygonSmtPadGeometry(pad2) : undefined;
+  const polygonPadGeometry = isPolygon ? getPolygonSmtPadGeometry2(pad2) : undefined;
   let shape = "rect";
   let outerDiameter;
   let holeDiameter;
@@ -304038,11 +304414,11 @@ function generateArcFromSweep(startX, startY, endX, endY, radius, largeArcFlag,
   return path71;
 }
 var mil10ToMm = (value) => value * 10 * 0.0254;
-var getBoundsCenter = (bounds) => ({
+var getBoundsCenter3 = (bounds) => ({
   x: (bounds.minX + bounds.maxX) / 2,
   y: (bounds.minY + bounds.maxY) / 2
 });
-var getBoundsFromPoints5 = (points) => {
+var getBoundsFromPoints7 = (points) => {
   if (points.length === 0) {
     return null;
   }
@@ -304108,8 +304484,8 @@ var getEasyEdaModelOriginOnBoardMm = ({
   }
   let modelOriginMm = null;
   if (points.length > 0) {
-    const bounds = getBoundsFromPoints5(points);
-    modelOriginMm = bounds ? getBoundsCenter(bounds) : null;
+    const bounds = getBoundsFromPoints7(points);
+    modelOriginMm = bounds ? getBoundsCenter3(bounds) : null;
   } else {
     const [originX, originY] = String(svgNode.svgData.attrs?.c_origin ?? "0,0").split(",").map((value) => Number(value.trim()));
     if (Number.isFinite(originX) && Number.isFinite(originY)) {
@@ -304142,7 +304518,7 @@ var getCadModelOffsetMmFromBounds = (easyEdaJson, bounds, {
   const rotationDeg = (rotationZRaw % 360 + 360) % 360;
   if (![0, 90, 180, 270].includes(rotationDeg))
     return null;
-  const modelCenter = getBoundsCenter(getXyBoundsFromModelBounds(bounds));
+  const modelCenter = getBoundsCenter3(getXyBoundsFromModelBounds(bounds));
   const footprintCenter = easyEdaJson.packageDetail.dataStr.head;
   const footprintCenterMm = footprintBoundsCenterMm ?? {
     x: mil10ToMm(footprintCenter.x),
@@ -311791,11 +312167,11 @@ function generateArcFromSweep2(startX, startY, endX, endY, radius, largeArcFlag,
   return path71;
 }
 var mil10ToMm2 = (value) => value * 10 * 0.0254;
-var getBoundsCenter2 = (bounds) => ({
+var getBoundsCenter4 = (bounds) => ({
   x: (bounds.minX + bounds.maxX) / 2,
   y: (bounds.minY + bounds.maxY) / 2
 });
-var getBoundsFromPoints6 = (points) => {
+var getBoundsFromPoints8 = (points) => {
   if (points.length === 0) {
     return null;
   }
@@ -311861,8 +312237,8 @@ var getEasyEdaModelOriginOnBoardMm2 = ({
   }
   let modelOriginMm = null;
   if (points.length > 0) {
-    const bounds = getBoundsFromPoints6(points);
-    modelOriginMm = bounds ? getBoundsCenter2(bounds) : null;
+    const bounds = getBoundsFromPoints8(points);
+    modelOriginMm = bounds ? getBoundsCenter4(bounds) : null;
   } else {
     const [originX, originY] = String(svgNode.svgData.attrs?.c_origin ?? "0,0").split(",").map((value) => Number(value.trim()));
     if (Number.isFinite(originX) && Number.isFinite(originY)) {
@@ -311891,7 +312267,7 @@ var getCadModelOffsetMmFromBounds2 = (easyEdaJson, bounds, {
   const rotationDeg = (rotationZRaw % 360 + 360) % 360;
   if (![0, 90, 180, 270].includes(rotationDeg))
     return null;
-  const modelCenter = getBoundsCenter2(getXyBoundsFromModelBounds2(bounds));
+  const modelCenter = getBoundsCenter4(getXyBoundsFromModelBounds2(bounds));
   const footprintCenter = easyEdaJson.packageDetail.dataStr.head;
   const footprintCenterMm = footprintBoundsCenterMm ?? {
     x: mil10ToMm2(footprintCenter.x),
@@ -313452,7 +313828,7 @@ var convertImportedFootprintToFootprinter = ({
   tsx
 }) => {
   try {
-    const discovery = circuitJsonToFootprinter(circuitJson, {
+    const discovery = circuitJsonToFootprinter2(circuitJson, {
       maxCandidates: 5,
       sourceHints
     });