@jlcpcb/cli 0.2.0 → 0.3.0

package/dist/index.js

@@ -34073,22 +34073,25 @@ var {
 
 // ../core/dist/index.js
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { existsSync } from "fs";
-import { join as join2 } from "path";
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { join as join3 } from "path";
-import { homedir, platform } from "os";
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir2, platform as platform2 } from "os";
 import { readdir, readFile, writeFile, mkdir, access, stat } from "fs/promises";
 import { join, dirname, extname, basename } from "path";
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { join as join2 } from "path";
 import { execSync } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
-import { homedir as homedir2, platform as platform2 } from "os";
-import { join as join4 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile4, readdir as readdir2, unlink } from "fs/promises";
+import { homedir as homedir3, platform as platform3 } from "os";
+import { join as join5 } from "path";
 import { createServer } from "http";
 import { readFileSync } from "fs";
-import { join as join5, dirname as dirname3 } from "path";
+import { join as join6, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 var __defProp2 = Object.defineProperty;
 var __export2 = (target, all) => {
@@ -34117,9 +34120,16 @@ function containsKeyword(text, keyword) {
   return false;
 }
 function getLibraryCategory(prefix, category, description) {
-  const normalizedPrefix = prefix.toUpperCase();
-  if (PREFIX_CATEGORY_MAP[normalizedPrefix]) {
-    return PREFIX_CATEGORY_MAP[normalizedPrefix];
+  const cleanedPrefix = prefix.replace(/[^a-zA-Z0-9]/g, "").toUpperCase();
+  if (cleanedPrefix.length >= 2) {
+    const twoCharPrefix = cleanedPrefix.slice(0, 2);
+    if (PREFIX_CATEGORY_MAP[twoCharPrefix]) {
+      return PREFIX_CATEGORY_MAP[twoCharPrefix];
+    }
+  }
+  const singleCharPrefix = cleanedPrefix.slice(0, 1);
+  if (PREFIX_CATEGORY_MAP[singleCharPrefix]) {
+    return PREFIX_CATEGORY_MAP[singleCharPrefix];
   }
   const searchText = [category || "", description || ""].join(" ");
   if (searchText.trim()) {
@@ -34183,6 +34193,7 @@ var init_category_router = __esm2(() => {
     X: "Crystals",
     J: "Connectors",
     P: "Connectors",
+    RJ: "Connectors",
     K: "Misc",
     F: "Misc"
   };
@@ -34428,6 +34439,48 @@ var init_category_router = __esm2(() => {
         "ceramic resonator"
       ]
     },
+    {
+      category: "Connectors",
+      keywords: [
+        "connector",
+        "header",
+        "socket",
+        "terminal",
+        "terminal block",
+        "jack",
+        "plug",
+        "receptacle",
+        "usb-c",
+        "usb type-c",
+        "micro usb",
+        "mini usb",
+        "usb-a",
+        "usb-b",
+        "hdmi connector",
+        "rj45",
+        "rj11",
+        "barrel jack",
+        "dc jack",
+        "audio jack",
+        "jst",
+        "jst-xh",
+        "jst-ph",
+        "molex",
+        "dupont",
+        "pin header",
+        "female header",
+        "fpc",
+        "ffc",
+        "sim card",
+        "sd card",
+        "microsd",
+        "pogo pin",
+        "spring contact",
+        "test point",
+        "ethernet connector",
+        "modular connector"
+      ]
+    },
     {
       category: "Transistors",
       keywords: [
@@ -34528,46 +34581,6 @@ var init_category_router = __esm2(() => {
         "chip resistor"
       ]
     },
-    {
-      category: "Connectors",
-      keywords: [
-        "connector",
-        "header",
-        "socket",
-        "terminal",
-        "terminal block",
-        "jack",
-        "plug",
-        "receptacle",
-        "usb-c",
-        "usb type-c",
-        "micro usb",
-        "mini usb",
-        "usb-a",
-        "usb-b",
-        "hdmi connector",
-        "rj45",
-        "rj11",
-        "barrel jack",
-        "dc jack",
-        "audio jack",
-        "jst",
-        "jst-xh",
-        "jst-ph",
-        "molex",
-        "dupont",
-        "pin header",
-        "female header",
-        "fpc",
-        "ffc",
-        "sim card",
-        "sd card",
-        "microsd",
-        "pogo pin",
-        "spring contact",
-        "test point"
-      ]
-    },
     {
       category: "ICs",
       keywords: [
@@ -34661,9 +34674,9 @@ function addLibraryToTable(tableContent, libraryName, libraryPath, type, descrip
 `;
 }
 async function ensureSymLibTable(projectDir, symbolLibPath, libraryName = DEFAULT_LIBRARY_NAME, description = DEFAULT_LIBRARY_DESCRIPTION) {
-  const tablePath = join2(projectDir, "sym-lib-table");
+  const tablePath = join3(projectDir, "sym-lib-table");
   const relativePath = symbolLibPath.startsWith(projectDir) ? "${KIPRJMOD}" + symbolLibPath.slice(projectDir.length) : symbolLibPath;
-  if (!existsSync(tablePath)) {
+  if (!existsSync2(tablePath)) {
     const content = generateSymLibTable(relativePath, libraryName, description);
     await writeFile2(tablePath, content, "utf-8");
     return { created: true, modified: false, path: tablePath };
@@ -34677,9 +34690,9 @@ async function ensureSymLibTable(projectDir, symbolLibPath, libraryName = DEFAUL
   return { created: false, modified: true, path: tablePath };
 }
 async function ensureFpLibTable(projectDir, footprintLibPath, libraryName = DEFAULT_LIBRARY_NAME, description = DEFAULT_LIBRARY_DESCRIPTION) {
-  const tablePath = join2(projectDir, "fp-lib-table");
+  const tablePath = join3(projectDir, "fp-lib-table");
   const relativePath = footprintLibPath.startsWith(projectDir) ? "${KIPRJMOD}" + footprintLibPath.slice(projectDir.length) : footprintLibPath;
-  if (!existsSync(tablePath)) {
+  if (!existsSync2(tablePath)) {
     const content = generateFpLibTable(relativePath, libraryName, description);
     await writeFile2(tablePath, content, "utf-8");
     return { created: true, modified: false, path: tablePath };
@@ -34700,37 +34713,37 @@ __export2(exports_global_lib_table, {
   ensureGlobalLibraryTables: () => ensureGlobalLibraryTables,
   ensureGlobalEasyEDALibrary: () => ensureGlobalEasyEDALibrary
 });
-function detectKicadVersion() {
-  const home = homedir();
-  const baseDir = join3(home, "Documents", "KiCad");
+function detectKicadVersion2() {
+  const home = homedir2();
+  const baseDir = join4(home, "Documents", "KiCad");
   for (const version of KICAD_VERSIONS2) {
-    if (existsSync2(join3(baseDir, version))) {
+    if (existsSync3(join4(baseDir, version))) {
       return version;
     }
   }
   return "9.0";
 }
-function getKicadConfigDir(version) {
-  const home = homedir();
-  const plat = platform();
+function getKicadConfigDir2(version) {
+  const home = homedir2();
+  const plat = platform2();
   if (plat === "darwin") {
-    return join3(home, "Library", "Preferences", "kicad", version);
+    return join4(home, "Library", "Preferences", "kicad", version);
   } else if (plat === "win32") {
-    return join3(process.env.APPDATA || join3(home, "AppData", "Roaming"), "kicad", version);
+    return join4(process.env.APPDATA || join4(home, "AppData", "Roaming"), "kicad", version);
   } else {
-    return join3(home, ".config", "kicad", version);
+    return join4(home, ".config", "kicad", version);
   }
 }
 function get3rdPartyBaseDir(version) {
-  const home = homedir();
-  const plat = platform();
+  const home = homedir2();
+  const plat = platform2();
   if (plat === "linux") {
-    return join3(home, ".local", "share", "kicad", version, "3rdparty", LIBRARY_NAMESPACE);
+    return join4(home, ".local", "share", "kicad", version, "3rdparty", LIBRARY_NAMESPACE);
   }
-  return join3(home, "Documents", "KiCad", version, "3rdparty", LIBRARY_NAMESPACE);
+  return join4(home, "Documents", "KiCad", version, "3rdparty", LIBRARY_NAMESPACE);
 }
 function getSymbolLibPath(category, version) {
-  return join3(get3rdPartyBaseDir(version), "symbols", getLibraryFilename(category));
+  return join4(get3rdPartyBaseDir(version), "symbols", getLibraryFilename(category));
 }
 function getSymbolLibUri(category) {
   return `${KICAD_3RD_PARTY_VAR}/${LIBRARY_NAMESPACE}/symbols/${getLibraryFilename(category)}`;
@@ -34771,11 +34784,11 @@ function generateFpLibTable2() {
 `;
 }
 async function ensureGlobalSymLibTable(version) {
-  const configDir = getKicadConfigDir(version);
-  const tablePath = join3(configDir, "sym-lib-table");
+  const configDir = getKicadConfigDir2(version);
+  const tablePath = join4(configDir, "sym-lib-table");
   const categories = getAllCategories();
   await mkdir2(configDir, { recursive: true });
-  if (!existsSync2(tablePath)) {
+  if (!existsSync3(tablePath)) {
     const content2 = generateSymLibTable2();
     await writeFile3(tablePath, content2, "utf-8");
     return {
@@ -34815,11 +34828,11 @@ async function ensureGlobalSymLibTable(version) {
   };
 }
 async function ensureGlobalFpLibTable(version) {
-  const configDir = getKicadConfigDir(version);
-  const tablePath = join3(configDir, "fp-lib-table");
+  const configDir = getKicadConfigDir2(version);
+  const tablePath = join4(configDir, "fp-lib-table");
   const name = LIBRARY_PREFIX2;
   await mkdir2(configDir, { recursive: true });
-  if (!existsSync2(tablePath)) {
+  if (!existsSync3(tablePath)) {
     const content2 = generateFpLibTable2();
     await writeFile3(tablePath, content2, "utf-8");
     return {
@@ -34853,13 +34866,13 @@ async function ensureGlobalFpLibTable(version) {
 }
 async function ensureLibraryStubs(version) {
   const baseDir = get3rdPartyBaseDir(version);
-  const symbolsDir = join3(baseDir, "symbols");
-  const footprintsDir = join3(baseDir, "footprints", getFootprintDirName());
-  const models3dDir = join3(baseDir, "3dmodels", get3DModelsDirName());
+  const symbolsDir = join4(baseDir, "symbols");
+  const footprintsDir = join4(baseDir, "footprints", getFootprintDirName());
+  const models3dDir = join4(baseDir, "3dmodels", get3DModelsDirName());
   const directoriesCreated = [];
   const symbolsCreated = [];
   for (const dir of [symbolsDir, footprintsDir, models3dDir]) {
-    if (!existsSync2(dir)) {
+    if (!existsSync3(dir)) {
       await mkdir2(dir, { recursive: true });
       directoriesCreated.push(dir);
     }
@@ -34868,7 +34881,7 @@ async function ensureLibraryStubs(version) {
   const emptyContent = generateEmptySymbolLibrary();
   for (const category of categories) {
     const filePath = getSymbolLibPath(category, version);
-    if (!existsSync2(filePath)) {
+    if (!existsSync3(filePath)) {
       await writeFile3(filePath, emptyContent, "utf-8");
       symbolsCreated.push(filePath);
     }
@@ -34882,11 +34895,11 @@ function getEasyEDAFootprintLibUri() {
   return `${KICAD_3RD_PARTY_VAR}/${LIBRARY_NAMESPACE}/footprints/${EASYEDA_FOOTPRINT_LIBRARY_NAME}`;
 }
 async function ensureGlobalEasyEDALibrary() {
-  const version = detectKicadVersion();
-  const configDir = getKicadConfigDir(version);
+  const version = detectKicadVersion2();
+  const configDir = getKicadConfigDir2(version);
   await mkdir2(configDir, { recursive: true });
-  const symTablePath = join3(configDir, "sym-lib-table");
-  if (existsSync2(symTablePath)) {
+  const symTablePath = join4(configDir, "sym-lib-table");
+  if (existsSync3(symTablePath)) {
     let content = await readFile3(symTablePath, "utf-8");
     if (!libraryExistsInTable(content, EASYEDA_LIBRARY_NAME)) {
       const uri = getEasyEDASymbolLibUri();
@@ -34902,8 +34915,8 @@ async function ensureGlobalEasyEDALibrary() {
 `;
     await writeFile3(symTablePath, content, "utf-8");
   }
-  const fpTablePath = join3(configDir, "fp-lib-table");
-  if (existsSync2(fpTablePath)) {
+  const fpTablePath = join4(configDir, "fp-lib-table");
+  if (existsSync3(fpTablePath)) {
     let content = await readFile3(fpTablePath, "utf-8");
     if (!libraryExistsInTable(content, EASYEDA_LIBRARY_NAME)) {
       const uri = getEasyEDAFootprintLibUri();
@@ -34922,7 +34935,7 @@ async function ensureGlobalEasyEDALibrary() {
 }
 async function ensureGlobalLibraryTables() {
   const errors2 = [];
-  const version = detectKicadVersion();
+  const version = detectKicadVersion2();
   let symLibTable = {
     path: "",
     created: false,
@@ -38950,6 +38963,9 @@ var coerce = {
 };
 var NEVER = INVALID;
 var LCSCPartNumberSchema = exports_external.string().regex(/^C\d+$/, "Invalid LCSC part number format (expected C followed by digits)");
+var EasyEDAUuidSchema = exports_external.string().regex(/^[a-f0-9]{32}$/i, "Invalid EasyEDA UUID (expected 32-character hex string)").transform((s) => s.toLowerCase());
+var ComponentIdSchema = exports_external.union([LCSCPartNumberSchema, EasyEDAUuidSchema]);
+var SafePathSchema = exports_external.string().min(1, "Path cannot be empty").refine((p) => !p.includes(".."), "Path traversal (..) not allowed").refine((p) => !p.includes("\x00"), "Null bytes not allowed in path");
 var PackageSchema = exports_external.string().min(1, "Package cannot be empty");
 var PriceTierSchema = exports_external.object({
   quantity: exports_external.number().positive(),
@@ -39106,7 +39122,58 @@ var logger = new Logger({ prefix: "ai-eda" });
 function createLogger(packageName) {
   return logger.child(packageName);
 }
+var KICAD_LAYERS = {
+  F_CU: "F.Cu",
+  B_CU: "B.Cu",
+  IN1_CU: "In1.Cu",
+  IN2_CU: "In2.Cu",
+  IN3_CU: "In3.Cu",
+  IN4_CU: "In4.Cu",
+  F_ADHES: "F.Adhes",
+  F_PASTE: "F.Paste",
+  F_SILKS: "F.SilkS",
+  F_MASK: "F.Mask",
+  F_CRTYD: "F.CrtYd",
+  F_FAB: "F.Fab",
+  B_ADHES: "B.Adhes",
+  B_PASTE: "B.Paste",
+  B_SILKS: "B.SilkS",
+  B_MASK: "B.Mask",
+  B_CRTYD: "B.CrtYd",
+  B_FAB: "B.Fab",
+  EDGE_CUTS: "Edge.Cuts",
+  MARGIN: "Margin",
+  DWGS_USER: "Dwgs.User",
+  CMTS_USER: "Cmts.User",
+  ECO1_USER: "Eco1.User",
+  ECO2_USER: "Eco2.User"
+};
+var KICAD_DEFAULTS = {
+  TEXT_SIZE: 1.27,
+  TEXT_THICKNESS: 0.15,
+  WIRE_WIDTH: 0.25,
+  GRID_SCHEMATIC: 2.54,
+  GRID_PCB: 0.25,
+  PIN_LENGTH: 1.27,
+  PIN_NAME_OFFSET: 0
+};
+var KICAD_SYMBOL_VERSION = "20241209";
+var KICAD_FOOTPRINT_VERSION = "20241209";
+var KICAD_VERSIONS = ["9.0", "8.0"];
+function detectKicadVersion() {
+  const home = homedir();
+  const baseDir = join2(home, "Documents", "KiCad");
+  for (const version of KICAD_VERSIONS) {
+    if (existsSync(join2(baseDir, version))) {
+      return version;
+    }
+  }
+  return "9.0";
+}
 var logger3 = createLogger("jlc-api");
+function stripTemperaturePrefix(description) {
+  return description.replace(/^-?\d+℃~[+-]?\d+℃\s*/, "");
+}
 var JLCPCB_SEARCH_API = "https://jlcpcb.com/api/overseas-pcb-order/v1/shoppingCart/smtGood/selectSmtComponentList/v2";
 
 class JLCClient {
@@ -39152,7 +39219,7 @@ class JLCClient {
         package: c.componentSpecificationEn || "",
         price: c.componentPrices?.[0]?.productPrice,
         stock: c.stockCount,
-        description: c.describe,
+        description: stripTemperaturePrefix(c.describe),
         productUrl: c.lcscGoodsUrl,
         datasheetPdf: c.dataManualUrl,
         category: c.componentTypeEn,
@@ -39392,6 +39459,25 @@ function parseSymbolPath(data) {
     return null;
   }
 }
+function parseSymbolText(data) {
+  try {
+    const f = data.split("~");
+    const isPinPart = f[f.length - 1] === "pinpart" || f.some((field) => field === "pinpart");
+    return {
+      x: safeParseFloat(f[2]),
+      y: safeParseFloat(f[3]),
+      rotation: safeParseFloat(f[4]),
+      color: f[5] || "#000000",
+      fontSize: safeParseFloat(f[7], 7),
+      textType: f[11] || "",
+      text: f[12] || "",
+      id: f[15] || f[13] || "",
+      isPinPart
+    };
+  } catch {
+    return null;
+  }
+}
 function parsePad(data) {
   try {
     const f = data.split("~");
@@ -39559,6 +39645,7 @@ function parseSymbolShapes(shapes) {
   const polylines = [];
   const polygons = [];
   const paths = [];
+  const texts = [];
   for (const line of shapes) {
     if (typeof line !== "string")
       continue;
@@ -39612,10 +39699,15 @@ function parseSymbolShapes(shapes) {
           paths.push(path);
         break;
       }
-      case "T":
+      case "T": {
+        const text = parseSymbolText(line);
+        if (text && text.text.trim())
+          texts.push(text);
         break;
+      }
     }
   }
+  associatePinNamesFromTexts(pins, texts);
   return {
     pins,
     rectangles,
@@ -39624,9 +39716,30 @@ function parseSymbolShapes(shapes) {
     arcs,
     polylines,
     polygons,
-    paths
+    paths,
+    texts
   };
 }
+function associatePinNamesFromTexts(pins, texts) {
+  const pinpartTexts = texts.filter((t) => t.isPinPart && t.text.trim());
+  for (const text of pinpartTexts) {
+    const textContent = text.text.trim();
+    const jMatch = textContent.match(/^J(\d+)(?:\/(.+))?$/i);
+    if (jMatch) {
+      const pinNum = jMatch[1];
+      const pinFunction = jMatch[2] || textContent;
+      const pin = pins.find((p) => p.number === pinNum);
+      if (pin && (!pin.name || pin.name === pinNum)) {
+        pin.name = pinFunction || textContent;
+      }
+      continue;
+    }
+    const numMatch = textContent.match(/^(\d+)$/);
+    if (numMatch) {
+      continue;
+    }
+  }
+}
 function parseFootprintShapes(shapes) {
   const pads = [];
   const tracks = [];
@@ -39813,6 +39926,7 @@ class EasyEDAClient {
         polylines: symbolData.polylines,
         polygons: symbolData.polygons,
         paths: symbolData.paths,
+        texts: symbolData.texts,
         origin: symbolOrigin
       },
       footprint: {
@@ -39986,6 +40100,7 @@ class EasyEDACommunityClient {
         polylines: symbolData.polylines,
         polygons: symbolData.polygons,
         paths: symbolData.paths,
+        texts: symbolData.texts,
         origin: symbolOrigin,
         head: dataStr.head || {}
       },
@@ -40012,14 +40127,14 @@ class EasyEDACommunityClient {
   }
 }
 var easyedaCommunityClient = new EasyEDACommunityClient;
-function isLcscId(id) {
+function isLcscId2(id) {
   return /^C\d+$/.test(id);
 }
 function createComponentService() {
   return {
     async search(query, options = {}) {
       const { source = "lcsc", limit = 20, inStock, basicOnly } = options;
-      if (source === "easyeda-community") {
+      if (source === "community" || source === "easyeda-community") {
         const results = await easyedaCommunityClient.search({
           query,
           limit
@@ -40036,7 +40151,7 @@ function createComponentService() {
       return jlcClient.search(query, { limit, inStock, basicOnly });
     },
     async fetch(id) {
-      if (isLcscId(id)) {
+      if (isLcscId2(id)) {
         return easyedaClient.getComponentData(id);
       }
       return null;
@@ -40064,43 +40179,6 @@ function createComponentService() {
     }
   };
 }
-var KICAD_LAYERS = {
-  F_CU: "F.Cu",
-  B_CU: "B.Cu",
-  IN1_CU: "In1.Cu",
-  IN2_CU: "In2.Cu",
-  IN3_CU: "In3.Cu",
-  IN4_CU: "In4.Cu",
-  F_ADHES: "F.Adhes",
-  F_PASTE: "F.Paste",
-  F_SILKS: "F.SilkS",
-  F_MASK: "F.Mask",
-  F_CRTYD: "F.CrtYd",
-  F_FAB: "F.Fab",
-  B_ADHES: "B.Adhes",
-  B_PASTE: "B.Paste",
-  B_SILKS: "B.SilkS",
-  B_MASK: "B.Mask",
-  B_CRTYD: "B.CrtYd",
-  B_FAB: "B.Fab",
-  EDGE_CUTS: "Edge.Cuts",
-  MARGIN: "Margin",
-  DWGS_USER: "Dwgs.User",
-  CMTS_USER: "Cmts.User",
-  ECO1_USER: "Eco1.User",
-  ECO2_USER: "Eco2.User"
-};
-var KICAD_DEFAULTS = {
-  TEXT_SIZE: 1.27,
-  TEXT_THICKNESS: 0.15,
-  WIRE_WIDTH: 0.25,
-  GRID_SCHEMATIC: 2.54,
-  GRID_PCB: 0.25,
-  PIN_LENGTH: 1.27,
-  PIN_NAME_OFFSET: 0
-};
-var KICAD_SYMBOL_VERSION = "20241209";
-var KICAD_FOOTPRINT_VERSION = "20241209";
 var PATTERNS = {
   resistor: /(\d+(?:\.\d+)?)\s*([kKmMgGrR]?)\s*(?:ohm|Ohm|OHM|Ω|R)?/i,
   capacitor: /(\d+(?:\.\d+)?)\s*([pnuμmM]?)[Ff]?\s*(?:[\/\s]*(\d+)\s*[Vv])?/i,
@@ -40510,6 +40588,29 @@ function parseSvgArcPath(path) {
     return null;
   }
 }
+function interpolateArc(params, segmentsPerQuarter = 4) {
+  const center = svgArcToCenter(params);
+  if (!center) {
+    return [{ x: params.x2, y: params.y2 }];
+  }
+  const { cx, cy, rx, ry, startAngle, deltaAngle } = center;
+  const phiRad = params.phi * Math.PI / 180;
+  const cosPhi = Math.cos(phiRad);
+  const sinPhi = Math.sin(phiRad);
+  const arcDegrees = Math.abs(deltaAngle) * (180 / Math.PI);
+  const numSegments = Math.max(2, Math.ceil(arcDegrees / 90 * segmentsPerQuarter));
+  const points = [];
+  for (let i = 1;i <= numSegments; i++) {
+    const t = i / numSegments;
+    const angle = startAngle + deltaAngle * t;
+    const px = rx * Math.cos(angle);
+    const py = ry * Math.sin(angle);
+    const x = cosPhi * px - sinPhi * py + cx;
+    const y = sinPhi * px + cosPhi * py + cy;
+    points.push({ x, y });
+  }
+  return points;
+}
 var CATEGORY_TO_PREFIX = {
   Resistors: "R",
   Capacitors: "C",
@@ -40572,7 +40673,12 @@ class SymbolConverter {
     return output;
   }
   hasRenderableShapes(symbol) {
-    return symbol.rectangles.length > 0 || symbol.circles.length > 0 || symbol.ellipses.length > 0 || symbol.polylines.length > 0 || symbol.polygons.length > 0 || symbol.arcs.length > 0 || symbol.paths.length > 0;
+    const pinNamePattern = /^J\d+(?:\/|$)/i;
+    const hasDecorativeText = (symbol.texts || []).some((t) => {
+      const text = t.text.trim();
+      return text && !pinNamePattern.test(text);
+    });
+    return symbol.rectangles.length > 0 || symbol.circles.length > 0 || symbol.ellipses.length > 0 || symbol.polylines.length > 0 || symbol.polygons.length > 0 || symbol.arcs.length > 0 || symbol.paths.length > 0 || hasDecorativeText;
   }
   generateFromShapes(component, name) {
     const { info, symbol } = component;
@@ -40606,6 +40712,18 @@ class SymbolConverter {
       if (pathOutput)
         output += pathOutput;
     }
+    const pinNamePattern = /^J\d+(?:\/|$)/i;
+    const decorativeTexts = (symbol.texts || []).filter((t) => {
+      const text = t.text.trim();
+      if (!text)
+        return false;
+      return !pinNamePattern.test(text);
+    });
+    for (const text of decorativeTexts) {
+      const textOutput = this.convertText(text, origin);
+      if (textOutput)
+        output += textOutput;
+    }
     output += `		)
 `;
     output += `		(symbol "${name}_1_1"
@@ -40790,6 +40908,24 @@ class SymbolConverter {
 `;
     return output;
   }
+  convertText(text, origin) {
+    if (!text.text || text.text.trim() === "")
+      return null;
+    const x = this.convertX(text.x, origin.x);
+    const y = this.convertY(text.y, origin.y);
+    const fontSize = roundTo(Math.max(text.fontSize * EE_TO_MM * 0.8, 0.5), 3);
+    const rotation = (360 - text.rotation) % 360;
+    const content = text.text.replace(/"/g, "'").replace(/\\/g, "");
+    return `			(text "${content}"
+				(at ${x} ${y} ${rotation})
+				(effects
+					(font
+						(size ${fontSize} ${fontSize})
+					)
+				)
+			)
+`;
+  }
   parseSvgPath(pathStr, origin) {
     const points = [];
     let firstPoint = null;
@@ -41995,7 +42131,7 @@ class FootprintConverter {
       return this.generatePad({ ...pad, shape: "RECT", points: "" }, origin);
     }
     let holeRadius = pad.holeRadius;
-    if (holeRadius === 0 && pad.isPlated && pad.shape === "POLYGON") {
+    if (holeRadius === 0 && pad.layerId === 11 && pad.shape === "POLYGON") {
       holeRadius = this.calculateDrillRadiusFromPolygon(points, pad.centerX, pad.centerY);
     }
     const isSmd = holeRadius === 0;
@@ -42337,12 +42473,26 @@ ${justify ? `			(justify ${justify})
           break;
         case "A":
           if (args.length >= 7) {
+            const arcParams = {
+              x1: currentX,
+              y1: currentY,
+              rx: args[0],
+              ry: args[1],
+              phi: args[2],
+              largeArc: args[3] === 1,
+              sweep: args[4] === 1,
+              x2: args[5],
+              y2: args[6]
+            };
+            const arcPoints = interpolateArc(arcParams, 4);
+            for (const pt of arcPoints) {
+              points.push({
+                x: convertX(pt.x, origin.x),
+                y: convertY(pt.y, origin.y)
+              });
+            }
             currentX = args[5];
             currentY = args[6];
-            points.push({
-              x: convertX(currentX, origin.x),
-              y: convertY(currentY, origin.y)
-            });
           }
           break;
         case "Z":
@@ -42516,7 +42666,6 @@ init_category_router();
 var FOOTPRINT_LIBRARY_NAME = getFootprintDirName();
 var MODELS_3D_NAME = get3DModelsDirName();
 var LIBRARY_NAMESPACE2 = "jlc_mcp";
-var KICAD_VERSIONS3 = ["9.0", "8.0"];
 var EASYEDA_LIBRARY_NAME2 = "EasyEDA";
 var EASYEDA_SYMBOL_LIBRARY_NAME2 = "EasyEDA.kicad_sym";
 var EASYEDA_FOOTPRINT_LIBRARY_NAME2 = "EasyEDA.pretty";
@@ -42525,58 +42674,48 @@ var EASYEDA_LOCAL_LIBRARY_NAME = "EasyEDA-local";
 var EASYEDA_LOCAL_SYMBOL_LIBRARY_NAME = "EasyEDA-local.kicad_sym";
 var EASYEDA_LOCAL_FOOTPRINT_LIBRARY_NAME = "EasyEDA-local.pretty";
 var EASYEDA_LOCAL_LIBRARY_DESCRIPTION = "EasyEDA Community Component Library (Project-local)";
-function detectKicadVersion2() {
-  const home = homedir2();
-  const baseDir = join4(home, "Documents", "KiCad");
-  for (const version of KICAD_VERSIONS3) {
-    if (existsSync3(join4(baseDir, version))) {
-      return version;
-    }
-  }
-  return "9.0";
-}
 function getGlobalLibraryPaths() {
-  const home = homedir2();
-  const version = detectKicadVersion2();
-  const plat = platform2();
+  const home = homedir3();
+  const version = detectKicadVersion();
+  const plat = platform3();
   let base;
   if (plat === "linux") {
-    base = join4(home, ".local", "share", "kicad", version, "3rdparty", LIBRARY_NAMESPACE2);
+    base = join5(home, ".local", "share", "kicad", version, "3rdparty", LIBRARY_NAMESPACE2);
   } else {
-    base = join4(home, "Documents", "KiCad", version, "3rdparty", LIBRARY_NAMESPACE2);
+    base = join5(home, "Documents", "KiCad", version, "3rdparty", LIBRARY_NAMESPACE2);
   }
   return {
     base,
-    symbolsDir: join4(base, "symbols"),
-    footprintsDir: join4(base, "footprints"),
-    models3dDir: join4(base, "3dmodels"),
-    footprintDir: join4(base, "footprints", FOOTPRINT_LIBRARY_NAME),
-    models3dFullDir: join4(base, "3dmodels", MODELS_3D_NAME)
+    symbolsDir: join5(base, "symbols"),
+    footprintsDir: join5(base, "footprints"),
+    models3dDir: join5(base, "3dmodels"),
+    footprintDir: join5(base, "footprints", FOOTPRINT_LIBRARY_NAME),
+    models3dFullDir: join5(base, "3dmodels", MODELS_3D_NAME)
   };
 }
 function getProjectLibraryPaths(projectPath) {
-  const librariesDir = join4(projectPath, "libraries");
+  const librariesDir = join5(projectPath, "libraries");
   return {
     base: librariesDir,
-    symbolsDir: join4(librariesDir, "symbols"),
-    footprintsDir: join4(librariesDir, "footprints"),
-    models3dDir: join4(librariesDir, "3dmodels"),
-    footprintDir: join4(librariesDir, "footprints", FOOTPRINT_LIBRARY_NAME),
-    models3dFullDir: join4(librariesDir, "3dmodels", MODELS_3D_NAME)
+    symbolsDir: join5(librariesDir, "symbols"),
+    footprintsDir: join5(librariesDir, "footprints"),
+    models3dDir: join5(librariesDir, "3dmodels"),
+    footprintDir: join5(librariesDir, "footprints", FOOTPRINT_LIBRARY_NAME),
+    models3dFullDir: join5(librariesDir, "3dmodels", MODELS_3D_NAME)
   };
 }
-function isLcscId2(id) {
+function isLcscId3(id) {
   return /^C\d+$/.test(id);
 }
-function getKicadConfigDir2(version) {
-  const home = homedir2();
-  const plat = platform2();
+function getKicadConfigDir3(version) {
+  const home = homedir3();
+  const plat = platform3();
   if (plat === "darwin") {
-    return join4(home, "Library", "Preferences", "kicad", version);
+    return join5(home, "Library", "Preferences", "kicad", version);
   } else if (plat === "win32") {
-    return join4(process.env.APPDATA || join4(home, "AppData", "Roaming"), "kicad", version);
+    return join5(process.env.APPDATA || join5(home, "AppData", "Roaming"), "kicad", version);
   } else {
-    return join4(home, ".config", "kicad", version);
+    return join5(home, ".config", "kicad", version);
   }
 }
 async function parseSymbolLibrary(filePath, libraryName, category, models3dDir) {
@@ -42602,8 +42741,8 @@ async function parseSymbolLibrary(filePath, libraryName, category, models3dDir)
       const name = nameParts.length > 1 ? nameParts[1] : fullSymbolRef;
       const fpMatch = symbolBlock.match(/\(property\s+"Footprint"\s+"([^"]+)"/);
       const footprintRef = fpMatch ? fpMatch[1] : "";
-      const model3dPath = join4(models3dDir, `${name}.step`);
-      const has3dModel = existsSync3(model3dPath);
+      const model3dPath = join5(models3dDir, `${name}.step`);
+      const has3dModel = existsSync4(model3dPath);
       if (lcscId) {
         components.push({
           lcscId,
@@ -42619,6 +42758,42 @@ async function parseSymbolLibrary(filePath, libraryName, category, models3dDir)
   } catch {}
   return components;
 }
+function removeSymbolFromLibrary(content, symbolName) {
+  const lines = content.split(`
+`);
+  const result = [];
+  let depth = 0;
+  let inTargetSymbol = false;
+  let symbolStartDepth = 0;
+  for (const line of lines) {
+    const openCount = (line.match(/\(/g) || []).length;
+    const closeCount = (line.match(/\)/g) || []).length;
+    const symbolMatch = line.match(/^\s*\(symbol\s+"([^"]+)"/);
+    if (symbolMatch && !inTargetSymbol) {
+      const fullRef = symbolMatch[1];
+      const nameOnly = fullRef.includes(":") ? fullRef.split(":")[1] : fullRef;
+      if (nameOnly === symbolName || nameOnly.startsWith(`${symbolName}_`)) {
+        inTargetSymbol = true;
+        symbolStartDepth = depth;
+        depth += openCount - closeCount;
+        continue;
+      }
+    }
+    if (inTargetSymbol) {
+      depth += openCount - closeCount;
+      if (depth <= symbolStartDepth) {
+        inTargetSymbol = false;
+      }
+      continue;
+    }
+    depth += openCount - closeCount;
+    result.push(line);
+  }
+  return result.join(`
+`).replace(/\n{3,}/g, `
+
+`);
+}
 function adaptCommunityComponent(component) {
   const symbolHead = component.symbol.head;
   const cPara = symbolHead?.c_para || {};
@@ -42641,6 +42816,7 @@ function adaptCommunityComponent(component) {
       polylines: component.symbol.polylines,
       polygons: component.symbol.polygons,
       paths: component.symbol.paths,
+      texts: component.symbol.texts || [],
       origin: component.symbol.origin
     },
     footprint: {
@@ -42664,11 +42840,11 @@ function adaptCommunityComponent(component) {
 function createLibraryService() {
   return {
     async install(id, options = {}) {
-      const isCommunityComponent = !isLcscId2(id);
+      const isCommunityComponent = !isLcscId3(id);
       const isGlobal = !options.projectPath;
       const paths = isGlobal ? getGlobalLibraryPaths() : getProjectLibraryPaths(options.projectPath);
       let component = null;
-      if (isLcscId2(id)) {
+      if (isLcscId3(id)) {
         component = await easyedaClient.getComponentData(id);
       } else {
         const communityComponent = await easyedaCommunityClient.getComponent(id);
@@ -42717,18 +42893,18 @@ function createLibraryService() {
         let easyedaModelsDir;
         if (isGlobal) {
           symbolsDir = paths.symbolsDir;
-          footprintDir = join4(paths.footprintsDir, fpLibDir);
-          easyedaModelsDir = join4(paths.models3dDir, models3dDirName);
+          footprintDir = join5(paths.footprintsDir, fpLibDir);
+          easyedaModelsDir = join5(paths.models3dDir, models3dDirName);
         } else {
-          const librariesDir = join4(options.projectPath, "libraries");
-          symbolsDir = join4(librariesDir, "symbols");
-          footprintDir = join4(librariesDir, "footprints", fpLibDir);
-          easyedaModelsDir = join4(librariesDir, "3dmodels", models3dDirName);
+          const librariesDir = join5(options.projectPath, "libraries");
+          symbolsDir = join5(librariesDir, "symbols");
+          footprintDir = join5(librariesDir, "footprints", fpLibDir);
+          easyedaModelsDir = join5(librariesDir, "3dmodels", models3dDirName);
         }
         models3dDir = easyedaModelsDir;
         await ensureDir(symbolsDir);
         await ensureDir(footprintDir);
-        symbolFile = join4(symbolsDir, symLibFile);
+        symbolFile = join5(symbolsDir, symLibFile);
         symbolName = component.info.name.replace(/[^a-zA-Z0-9_-]/g, "_");
         const include3d = options.include3d ?? true;
         let modelRelativePath;
@@ -42737,7 +42913,7 @@ function createLibraryService() {
           const model = await easyedaCommunityClient.get3DModel(component.model3d.uuid, "step");
           if (model) {
             const modelFilename = `${symbolName}.step`;
-            modelPath = join4(models3dDir, modelFilename);
+            modelPath = join5(models3dDir, modelFilename);
             await writeBinary(modelPath, model);
             if (isGlobal) {
               modelRelativePath = `\${KICAD9_3RD_PARTY}/${LIBRARY_NAMESPACE2}/3dmodels/${models3dDirName}/${modelFilename}`;
@@ -42751,7 +42927,7 @@ function createLibraryService() {
           include3DModel: !!modelRelativePath,
           modelPath: modelRelativePath
         });
-        footprintPath = join4(footprintDir, `${symbolName}.kicad_mod`);
+        footprintPath = join5(footprintDir, `${symbolName}.kicad_mod`);
         footprintRef = `${libName}:${symbolName}`;
         await writeText(footprintPath, footprint);
         component.info.package = footprintRef;
@@ -42766,20 +42942,20 @@ function createLibraryService() {
       } else {
         category = getLibraryCategory(component.info.prefix, component.info.category, component.info.description);
         const symbolLibraryFilename = getLibraryFilename(category);
-        symbolFile = join4(paths.symbolsDir, symbolLibraryFilename);
+        symbolFile = join5(paths.symbolsDir, symbolLibraryFilename);
         footprintDir = paths.footprintDir;
         models3dDir = paths.models3dFullDir;
         await ensureDir(paths.symbolsDir);
         await ensureDir(paths.footprintDir);
         symbolName = symbolConverter.getSymbolName(component);
-        const include3d = options.include3d ?? false;
+        const include3d = options.include3d ?? true;
         let modelRelativePath;
         if (include3d && component.model3d) {
           await ensureDir(models3dDir);
           const model = await easyedaClient.get3DModel(component.model3d.uuid, "step");
           if (model) {
             const modelFilename = `${symbolName}.step`;
-            modelPath = join4(models3dDir, modelFilename);
+            modelPath = join5(models3dDir, modelFilename);
             await writeBinary(modelPath, model);
             modelRelativePath = `\${KICAD9_3RD_PARTY}/${LIBRARY_NAMESPACE2}/3dmodels/${MODELS_3D_NAME}/${modelFilename}`;
           }
@@ -42791,7 +42967,7 @@ function createLibraryService() {
         if (footprintResult.type === "reference") {
           footprintRef = footprintResult.reference;
         } else {
-          footprintPath = join4(footprintDir, `${footprintResult.name}.kicad_mod`);
+          footprintPath = join5(footprintDir, `${footprintResult.name}.kicad_mod`);
           footprintRef = getFootprintReference(footprintResult.name);
           await writeText(footprintPath, footprintResult.content);
         }
@@ -42804,7 +42980,7 @@ function createLibraryService() {
       }
       let symbolContent;
       let symbolAction;
-      if (existsSync3(symbolFile)) {
+      if (existsSync4(symbolFile)) {
         const existingContent = await readFile4(symbolFile, "utf-8");
         if (symbolConverter.symbolExistsInLibrary(existingContent, component.info.name)) {
           if (options.force) {
@@ -42896,9 +43072,9 @@ function createLibraryService() {
         if (options.category && options.category !== category)
           continue;
         const libraryFilename = getLibraryFilename(category);
-        const libraryPath = join4(paths.symbolsDir, libraryFilename);
+        const libraryPath = join5(paths.symbolsDir, libraryFilename);
         const libraryName = `JLC-MCP-${category}`;
-        if (existsSync3(libraryPath)) {
+        if (existsSync4(libraryPath)) {
           const components = await parseSymbolLibrary(libraryPath, libraryName, category, paths.models3dFullDir);
           allComponents.push(...components);
         }
@@ -42913,13 +43089,13 @@ function createLibraryService() {
       await ensureGlobalLibraryTables2();
     },
     async getStatus() {
-      const version = detectKicadVersion2();
+      const version = detectKicadVersion();
       const paths = getGlobalLibraryPaths();
-      const configDir = getKicadConfigDir2(version);
-      const symLibTablePath = join4(configDir, "sym-lib-table");
-      const fpLibTablePath = join4(configDir, "fp-lib-table");
+      const configDir = getKicadConfigDir3(version);
+      const symLibTablePath = join5(configDir, "sym-lib-table");
+      const fpLibTablePath = join5(configDir, "fp-lib-table");
       let installed = false;
-      if (existsSync3(paths.symbolsDir)) {
+      if (existsSync4(paths.symbolsDir)) {
         try {
           const files = await readdir2(paths.symbolsDir);
           installed = files.some((f) => f.endsWith(".kicad_sym"));
@@ -42928,7 +43104,7 @@ function createLibraryService() {
         }
       }
       let linked = false;
-      if (existsSync3(symLibTablePath)) {
+      if (existsSync4(symLibTablePath)) {
         try {
           const content = await readFile4(symLibTablePath, "utf-8");
           linked = content.includes("JLC-MCP");
@@ -42954,8 +43130,8 @@ function createLibraryService() {
     },
     async isEasyEDAInstalled(componentName) {
       const paths = getGlobalLibraryPaths();
-      const easyedaLibPath = join4(paths.symbolsDir, EASYEDA_SYMBOL_LIBRARY_NAME2);
-      if (!existsSync3(easyedaLibPath)) {
+      const easyedaLibPath = join5(paths.symbolsDir, EASYEDA_SYMBOL_LIBRARY_NAME2);
+      if (!existsSync4(easyedaLibPath)) {
         return false;
       }
       try {
@@ -42966,6 +43142,85 @@ function createLibraryService() {
       } catch {
         return false;
       }
+    },
+    async regenerate(options = {}) {
+      const include3d = options.include3d ?? true;
+      const installed = await this.listInstalled({ projectPath: options.projectPath });
+      const results = {
+        total: installed.length,
+        success: 0,
+        failed: 0,
+        components: []
+      };
+      for (let i = 0;i < installed.length; i++) {
+        const component = installed[i];
+        options.onProgress?.(i + 1, installed.length, component, "start");
+        try {
+          await this.install(component.lcscId, {
+            projectPath: options.projectPath,
+            include3d,
+            force: true
+          });
+          results.success++;
+          results.components.push({
+            id: component.lcscId,
+            name: component.name,
+            status: "success"
+          });
+          options.onProgress?.(i + 1, installed.length, component, "success");
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          results.failed++;
+          results.components.push({
+            id: component.lcscId,
+            name: component.name,
+            status: "failed",
+            error: errorMessage
+          });
+          options.onProgress?.(i + 1, installed.length, component, "error", errorMessage);
+        }
+      }
+      return results;
+    },
+    async remove(lcscId, options = {}) {
+      const paths = options.projectPath ? getProjectLibraryPaths(options.projectPath) : getGlobalLibraryPaths();
+      const installed = await this.listInstalled({ projectPath: options.projectPath });
+      const component = installed.find((c) => c.lcscId === lcscId);
+      if (!component) {
+        throw new Error(`Component ${lcscId} not found in library`);
+      }
+      const result = {
+        success: false,
+        lcscId,
+        symbolRemoved: false,
+        footprintRemoved: false,
+        model3dRemoved: false
+      };
+      const libraryFilename = getLibraryFilename(component.category);
+      const symbolLibPath = join5(paths.symbolsDir, libraryFilename);
+      if (existsSync4(symbolLibPath)) {
+        const content = await readFile4(symbolLibPath, "utf-8");
+        const newContent = removeSymbolFromLibrary(content, component.name);
+        await writeText(symbolLibPath, newContent);
+        result.symbolRemoved = true;
+      }
+      if (component.footprintRef?.startsWith("JLC-MCP:")) {
+        const fpName = component.footprintRef.split(":")[1];
+        const footprintPath = join5(paths.footprintDir, `${fpName}.kicad_mod`);
+        if (existsSync4(footprintPath)) {
+          await unlink(footprintPath);
+          result.footprintRemoved = true;
+        }
+      }
+      if (component.has3dModel) {
+        const modelPath = join5(paths.models3dFullDir, `${component.name}.step`);
+        if (existsSync4(modelPath)) {
+          await unlink(modelPath);
+          result.model3dRemoved = true;
+        }
+      }
+      result.success = result.symbolRemoved;
+      return result;
     }
   };
 }
@@ -42981,16 +43236,16 @@ function getHtmlPage() {
     return htmlCache;
   try {
     const possiblePaths = [
-      join5(__dirname2, "assets/search.html"),
-      join5(__dirname2, "../dist/assets/search.html"),
-      join5(__dirname2, "../assets/search.html"),
-      join5(__dirname2, "../assets/search-built.html"),
-      join5(process.cwd(), "dist/assets/search.html"),
-      join5(process.cwd(), "packages/core/dist/assets/search.html"),
-      join5(__dirname2, "../../dist/assets/search.html"),
-      join5(__dirname2, "../../../core/dist/assets/search.html"),
-      join5(__dirname2, "../../../../packages/core/dist/assets/search.html"),
-      join5(__dirname2, "../../node_modules/@jlcpcb/core/dist/assets/search.html")
+      join6(__dirname2, "assets/search.html"),
+      join6(__dirname2, "../dist/assets/search.html"),
+      join6(__dirname2, "../assets/search.html"),
+      join6(__dirname2, "../assets/search-built.html"),
+      join6(process.cwd(), "dist/assets/search.html"),
+      join6(process.cwd(), "packages/core/dist/assets/search.html"),
+      join6(__dirname2, "../../dist/assets/search.html"),
+      join6(__dirname2, "../../../core/dist/assets/search.html"),
+      join6(__dirname2, "../../../../packages/core/dist/assets/search.html"),
+      join6(__dirname2, "../../node_modules/@jlcpcb/core/dist/assets/search.html")
     ];
     for (const path of possiblePaths) {
       try {
@@ -43072,121 +43327,2628 @@ async function handleSearch(url, res) {
         hasNext: page < totalPages,
         hasPrev: page > 1
       }
-    }));
-  } catch (error) {
-    logger7.error("Search error:", error);
-    res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: "Search failed" }));
+    }));
+  } catch (error) {
+    logger7.error("Search error:", error);
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Search failed" }));
+  }
+}
+function communityToComponentData(community) {
+  const cPara = community.symbol.head?.c_para ?? {};
+  const fpCPara = community.footprint.head?.c_para ?? {};
+  return {
+    info: {
+      name: community.title || cPara.name || "Unknown",
+      prefix: cPara.pre || cPara.Prefix || "U",
+      package: fpCPara.package || community.footprint.name,
+      manufacturer: cPara.Manufacturer || cPara.BOM_Manufacturer,
+      description: community.description || cPara.BOM_Manufacturer_Part,
+      category: cPara.package
+    },
+    symbol: community.symbol,
+    footprint: community.footprint,
+    model3d: community.model3d,
+    rawData: community.rawData
+  };
+}
+async function handleComponent(uuid, res) {
+  if (!uuid) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Missing UUID" }));
+    return;
+  }
+  try {
+    const component2 = await easyedaCommunityClient.getComponent(uuid);
+    if (!component2) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Component not found" }));
+      return;
+    }
+    const componentData = communityToComponentData(component2);
+    let symbolSexpr = "";
+    let footprintSexpr = "";
+    try {
+      symbolSexpr = symbolConverter.convertToSymbolEntry(componentData);
+    } catch (e) {
+      logger7.warn("Symbol conversion failed:", e);
+    }
+    try {
+      footprintSexpr = footprintConverter.convert(componentData);
+    } catch (e) {
+      logger7.warn("Footprint conversion failed:", e);
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+      uuid: component2.uuid,
+      title: component2.title,
+      description: component2.description,
+      owner: component2.owner,
+      symbolSexpr,
+      footprintSexpr,
+      model3d: component2.model3d
+    }));
+  } catch (error) {
+    logger7.error("Component fetch error:", error);
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Failed to fetch component" }));
+  }
+}
+var logger8 = createLogger("http-server");
+var DEFAULT_PORT = 3847;
+var serverInstance = null;
+function startHttpServer(options = {}) {
+  if (serverInstance) {
+    logger8.debug("HTTP server already running");
+    const port2 = options.port ?? parseInt(process.env.JLC_MCP_HTTP_PORT || String(DEFAULT_PORT), 10);
+    options.onReady?.(`http://localhost:${port2}`);
+    return port2;
+  }
+  const port = options.port ?? parseInt(process.env.JLC_MCP_HTTP_PORT || String(DEFAULT_PORT), 10);
+  serverInstance = createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    try {
+      await handleRequest(req, res);
+    } catch (error) {
+      logger8.error("Request error:", error);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Internal server error" }));
+    }
+  });
+  serverInstance.listen(port, () => {
+    const url = `http://localhost:${port}`;
+    logger8.info(`HTTP server listening on ${url}`);
+    options.onReady?.(url);
+  });
+  serverInstance.on("error", (error) => {
+    if (error.code === "EADDRINUSE") {
+      logger8.warn(`Port ${port} already in use, HTTP server not started`);
+    } else {
+      logger8.error("HTTP server error:", error);
+    }
+  });
+  return port;
+}
+function stopHttpServer() {
+  if (serverInstance) {
+    serverInstance.close();
+    serverInstance = null;
+    logger8.info("HTTP server stopped");
+  }
+}
+var DEFAULT_COMPARISON_OPTIONS = {
+  positionTolerance: 0.05,
+  sizeTolerance: 0.02,
+  holeTolerance: 0.02,
+  sizeWarningsOnly: false,
+  ignoreExtraPads: false,
+  ignorePinNames: false
+};
+var EE_TO_MM3 = 10 * 0.0254;
+async function fetchReferenceSVG(lcscCode) {
+  const normalizedCode = lcscCode.replace(/^C/i, "");
+  const fullCode = `C${normalizedCode}`;
+  const url = `https://easyeda.com/api/products/${fullCode}/svgs`;
+  const response = await fetch(url, {
+    headers: {
+      Accept: "application/json",
+      "User-Agent": "jlc-cli/1.0"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch SVG for ${fullCode}: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (!data.success || !data.result) {
+    throw new Error(`API error for ${fullCode}: ${JSON.stringify(data)}`);
+  }
+  const symbol = data.result.find((r) => r.docType === 2);
+  const footprint = data.result.find((r) => r.docType === 4);
+  return {
+    lcscCode: fullCode,
+    symbolSvg: symbol?.svg || null,
+    footprintSvg: footprint?.svg || null,
+    componentUuid: footprint?.component_uuid || symbol?.component_uuid || null,
+    bbox: footprint?.bbox || symbol?.bbox
+  };
+}
+var PASSIVES = [
+  {
+    lcsc: "C25076",
+    name: "100nF 0402 Capacitor",
+    features: ["smd"],
+    expectedPadCount: 2,
+    notes: "Standard 0402 - should use KiCad built-in"
+  },
+  {
+    lcsc: "C25111",
+    name: "10K 0603 Resistor",
+    features: ["smd"],
+    expectedPadCount: 2,
+    notes: "Standard 0603 - should use KiCad built-in"
+  },
+  {
+    lcsc: "C1525",
+    name: "10uF 0805 Capacitor",
+    features: ["smd"],
+    expectedPadCount: 2,
+    notes: "Standard 0805 - should use KiCad built-in"
+  }
+];
+var THERMAL_PADS = [
+  {
+    lcsc: "C22467599",
+    name: "MicroSD Socket A-MicroTF-1.85A",
+    features: ["smd", "shield"],
+    notes: "SD card socket with shield tabs"
+  },
+  {
+    lcsc: "C94919",
+    name: "ESP32-WROOM-32E",
+    features: ["thermal", "vias", "castellated", "antenna"],
+    notes: "WiFi module with large ground pad and vias"
+  },
+  {
+    lcsc: "C2040",
+    name: "ATmega328P-MU QFN-32",
+    features: ["qfn", "thermal"],
+    notes: "QFN with exposed thermal pad"
+  }
+];
+var CASTELLATED = [
+  {
+    lcsc: "C3029878",
+    name: "ESP32-C3-MINI-1",
+    features: ["castellated", "antenna"],
+    skip: true,
+    notes: "Compact WiFi/BLE module with castellated edges"
+  },
+  {
+    lcsc: "C82891",
+    name: "ESP-12F",
+    features: ["castellated", "antenna"],
+    notes: "Classic ESP8266 module"
+  },
+  {
+    lcsc: "C2838283",
+    name: "RP2040",
+    features: ["qfn", "thermal"],
+    skip: true,
+    notes: "Raspberry Pi microcontroller - QFN-56"
+  }
+];
+var CONNECTORS = [
+  {
+    lcsc: "C165948",
+    name: "USB-C Receptacle TYPE-C-31-M-12",
+    features: ["smd", "shield", "complex_pads"],
+    notes: "USB Type-C with shield tabs and SMD pads"
+  },
+  {
+    lcsc: "C46398",
+    name: "Micro USB B TYPE-C-31-M-17",
+    features: ["smd", "shield"],
+    notes: "Micro USB with SMD mounting"
+  },
+  {
+    lcsc: "C2939982",
+    name: "RJ45 with Magnetics HR911105A",
+    features: ["tht", "leds", "shield"],
+    skip: true,
+    notes: "Ethernet jack with integrated magnetics"
+  },
+  {
+    lcsc: "C91754",
+    name: "RJ45 Socket",
+    features: ["tht", "shield"],
+    notes: "Standard RJ45 ethernet jack"
+  }
+];
+var THROUGH_HOLE = [
+  {
+    lcsc: "C2062",
+    name: "LM7805 TO-220",
+    features: ["tht", "tab"],
+    skip: true,
+    notes: "Classic TO-220 voltage regulator"
+  },
+  {
+    lcsc: "C88305",
+    name: "Pin Header 2.54mm 1x10",
+    features: ["tht", "high_pin_count"],
+    skip: true,
+    notes: 'Standard 0.1" pin header'
+  },
+  {
+    lcsc: "C2337",
+    name: "Electrolytic Cap 100uF 16V",
+    features: ["tht"],
+    notes: "Radial electrolytic capacitor"
+  }
+];
+var QFN_QFP = [
+  {
+    lcsc: "C14902",
+    name: "STM32F103C8T6 LQFP-48",
+    features: ["qfp", "fine_pitch", "high_pin_count"],
+    skip: true,
+    notes: "Popular STM32 - 0.5mm pitch LQFP"
+  },
+  {
+    lcsc: "C8734",
+    name: "CH340G SOP-16",
+    features: ["smd"],
+    notes: "USB-UART bridge IC"
+  },
+  {
+    lcsc: "C2843335",
+    name: "STM32G071GBU6 UFQFPN-28",
+    features: ["qfn", "thermal", "vias"],
+    notes: "STM32G0 with thermal vias - already tested"
+  }
+];
+var POWER = [
+  {
+    lcsc: "C78244",
+    name: "MP1584 Buck Converter",
+    features: ["smd", "thermal"],
+    skip: true,
+    notes: "DC-DC converter with thermal pad"
+  },
+  {
+    lcsc: "C32767",
+    name: "AMS1117-3.3 SOT-223",
+    features: ["smd", "tab"],
+    skip: true,
+    notes: "LDO with tab pad"
+  },
+  {
+    lcsc: "C155580",
+    name: "IRF540N TO-220",
+    features: ["tht", "tab"],
+    notes: "Power MOSFET - TO-220"
+  }
+];
+var SPECIALTY = [
+  {
+    lcsc: "C88093",
+    name: "WS2812B-V5 LED",
+    features: ["smd"],
+    skip: true,
+    notes: "RGB LED with integrated driver"
+  },
+  {
+    lcsc: "C82942",
+    name: "BME280 Sensor",
+    features: ["smd", "fine_pitch"],
+    notes: "Environmental sensor - tiny LGA"
+  },
+  {
+    lcsc: "C14879",
+    name: "Crystal 8MHz 3215",
+    features: ["smd"],
+    notes: "SMD crystal oscillator"
+  }
+];
+var TEST_CATEGORIES = [
+  {
+    name: "passives",
+    description: "Standard passive components (R, C, L)",
+    components: PASSIVES
+  },
+  {
+    name: "thermal",
+    description: "Components with thermal pads and/or vias",
+    components: THERMAL_PADS
+  },
+  {
+    name: "castellated",
+    description: "Modules with castellated edge pads",
+    components: CASTELLATED
+  },
+  {
+    name: "connectors",
+    description: "USB, SD card, and other connectors",
+    components: CONNECTORS
+  },
+  {
+    name: "throughHole",
+    description: "Through-hole components",
+    components: THROUGH_HOLE
+  },
+  {
+    name: "qfn",
+    description: "QFN, QFP, and fine-pitch ICs",
+    components: QFN_QFP
+  },
+  {
+    name: "power",
+    description: "Power components with thermal features",
+    components: POWER
+  },
+  {
+    name: "specialty",
+    description: "LEDs, sensors, and other specialty parts",
+    components: SPECIALTY
+  }
+];
+function getAllTestComponents() {
+  return TEST_CATEGORIES.flatMap((cat) => cat.components);
+}
+function getTestComponentsByCategory(categoryName) {
+  const category = TEST_CATEGORIES.find((cat) => cat.name === categoryName);
+  return category?.components || [];
+}
+function getCategoryNames() {
+  return TEST_CATEGORIES.map((cat) => cat.name);
+}
+var EE_TO_MM4 = 10 * 0.0254;
+function extractFromReferenceSVG(svg) {
+  const rawPads = [];
+  const rawVias = [];
+  const rawHoles = [];
+  const padRegex = /<g[^>]*c_partid="part_pad"[^>]*>/g;
+  let match;
+  while ((match = padRegex.exec(svg)) !== null) {
+    const groupTag = match[0];
+    const endIndex = findGroupEnd(svg, match.index);
+    const groupContent = svg.slice(match.index, endIndex);
+    const pad = parsePadGroup(groupTag, groupContent);
+    if (pad) {
+      rawPads.push(pad);
+    }
+  }
+  const viaRegex = /<g[^>]*c_partid="part_via"[^>]*>/g;
+  while ((match = viaRegex.exec(svg)) !== null) {
+    const groupTag = match[0];
+    const endIndex = findGroupEnd(svg, match.index);
+    const groupContent = svg.slice(match.index, endIndex);
+    const via = parseViaGroup(groupTag, groupContent);
+    if (via) {
+      rawVias.push(via);
+    }
+  }
+  const holeRegex = /<g[^>]*c_partid="part_hole"[^>]*>/g;
+  while ((match = holeRegex.exec(svg)) !== null) {
+    const groupTag = match[0];
+    const endIndex = findGroupEnd(svg, match.index);
+    const groupContent = svg.slice(match.index, endIndex);
+    const hole = parseHoleGroup(groupTag, groupContent);
+    if (hole) {
+      rawHoles.push(hole);
+    }
+  }
+  const centroid = calculateBoundingBoxCenter(rawPads);
+  const pads = rawPads.map((p) => ({
+    ...p,
+    x: roundTo2(p.x - centroid.x, 4),
+    y: roundTo2(p.y - centroid.y, 4)
+  }));
+  const vias = rawVias.map((v) => ({
+    ...v,
+    x: roundTo2(v.x - centroid.x, 4),
+    y: roundTo2(v.y - centroid.y, 4)
+  }));
+  const holes = rawHoles.map((h) => ({
+    ...h,
+    x: roundTo2(h.x - centroid.x, 4),
+    y: roundTo2(h.y - centroid.y, 4)
+  }));
+  const allPoints = [
+    ...pads.map((p) => ({ x: p.x, y: p.y })),
+    ...vias.map((v) => ({ x: v.x, y: v.y })),
+    ...holes.map((h) => ({ x: h.x, y: h.y }))
+  ];
+  const bounds = calculateBounds(allPoints);
+  return { pads, vias, holes, bounds };
+}
+function calculateBoundingBoxCenter(pads) {
+  if (pads.length === 0) {
+    return { x: 0, y: 0 };
+  }
+  let minX = Infinity, maxX = -Infinity;
+  let minY = Infinity, maxY = -Infinity;
+  for (const pad of pads) {
+    const hw = pad.width / 2;
+    const hh = pad.height / 2;
+    minX = Math.min(minX, pad.x - hw);
+    maxX = Math.max(maxX, pad.x + hw);
+    minY = Math.min(minY, pad.y - hh);
+    maxY = Math.max(maxY, pad.y + hh);
+  }
+  return {
+    x: (minX + maxX) / 2,
+    y: (minY + maxY) / 2
+  };
+}
+function roundTo2(value, decimals) {
+  const factor = Math.pow(10, decimals);
+  return Math.round(value * factor) / factor;
+}
+function findGroupEnd(svg, startIndex) {
+  let depth = 0;
+  let i = startIndex;
+  while (i < svg.length) {
+    if (svg.slice(i, i + 2) === "<g") {
+      depth++;
+      i += 2;
+    } else if (svg.slice(i, i + 4) === "</g>") {
+      depth--;
+      if (depth === 0) {
+        return i + 4;
+      }
+      i += 4;
+    } else {
+      i++;
+    }
+  }
+  return svg.length;
+}
+function parsePadGroup(groupTag, groupContent) {
+  const numberMatch = groupTag.match(/number="([^"]+)"/);
+  const number = numberMatch?.[1] || "";
+  const originMatch = groupTag.match(/c_origin="([^"]+)"/);
+  if (!originMatch)
+    return null;
+  const [xStr, yStr] = originMatch[1].split(",");
+  const x = parseFloat(xStr) * EE_TO_MM4;
+  const y = parseFloat(yStr) * EE_TO_MM4;
+  const layerMatch = groupTag.match(/layerid="(\d+)"/);
+  const layerId = layerMatch ? parseInt(layerMatch[1], 10) : 1;
+  const { shape, width, height, hasHole, holeRadius, rotation } = extractPadShape(groupContent);
+  return {
+    number,
+    x,
+    y,
+    width,
+    height,
+    shape,
+    layerId,
+    hasHole,
+    holeRadius,
+    rotation
+  };
+}
+function extractPadShape(content) {
+  let shape = "rect";
+  let width = 0;
+  let height = 0;
+  let hasHole = false;
+  let holeRadius;
+  let rotation;
+  const groupWidthMatch = content.match(/c_width="([^"]+)"/);
+  const groupHeightMatch = content.match(/c_height="([^"]+)"/);
+  if (groupWidthMatch && groupHeightMatch) {
+    width = parseFloat(groupWidthMatch[1]) * EE_TO_MM4;
+    height = parseFloat(groupHeightMatch[1]) * EE_TO_MM4;
+  }
+  const shapeAttrMatch = content.match(/c_shape="([^"]+)"/);
+  if (shapeAttrMatch) {
+    const shapeAttr = shapeAttrMatch[1].toUpperCase();
+    if (shapeAttr === "RECT")
+      shape = "rect";
+    else if (shapeAttr === "OVAL" || shapeAttr === "ELLIPSE")
+      shape = "oval";
+    else if (shapeAttr === "POLYGON")
+      shape = "polygon";
+    else if (shapeAttr === "CIRCLE")
+      shape = "circle";
+  }
+  const rectMatch = content.match(/<rect[^>]*width="([^"]+)"[^>]*height="([^"]+)"[^>]*>/);
+  if (rectMatch) {
+    width = parseFloat(rectMatch[1]) * EE_TO_MM4;
+    height = parseFloat(rectMatch[2]) * EE_TO_MM4;
+    shape = "rect";
+    if (content.match(/<rect[^>]*rx="[^"]+"/)) {
+      shape = "roundrect";
+    }
+  }
+  const circleMatch = content.match(/<circle[^>]*r="([^"]+)"[^>]*>/);
+  if (circleMatch) {
+    const r = parseFloat(circleMatch[1]) * EE_TO_MM4;
+    width = r * 2;
+    height = r * 2;
+    shape = "circle";
+  }
+  const ellipseMatch = content.match(/<ellipse[^>]*rx="([^"]+)"[^>]*ry="([^"]+)"[^>]*>/);
+  if (ellipseMatch) {
+    width = parseFloat(ellipseMatch[1]) * 2 * EE_TO_MM4;
+    height = parseFloat(ellipseMatch[2]) * 2 * EE_TO_MM4;
+    shape = "oval";
+  }
+  if (content.match(/<polygon[^>]*>/) || content.match(/<path[^>]*d="[^"]*[Cc][^"]*"/)) {
+    shape = "polygon";
+    const polyMatch = content.match(/<polygon[^>]*points="([^"]+)"/);
+    if (polyMatch) {
+      const points = polyMatch[1].split(/[\s,]+/).map(parseFloat);
+      let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+      for (let i = 0;i < points.length; i += 2) {
+        minX = Math.min(minX, points[i]);
+        maxX = Math.max(maxX, points[i]);
+        minY = Math.min(minY, points[i + 1]);
+        maxY = Math.max(maxY, points[i + 1]);
+      }
+      width = (maxX - minX) * EE_TO_MM4;
+      height = (maxY - minY) * EE_TO_MM4;
+    }
+  }
+  const circleHoleMatch = content.match(/<circle[^>]*c_padhole="1"[^>]*r="([^"]+)"[^>]*>/i);
+  if (circleHoleMatch) {
+    const radius = parseFloat(circleHoleMatch[1]);
+    if (radius > 0) {
+      hasHole = true;
+      holeRadius = radius * EE_TO_MM4;
+    }
+  }
+  const polylineHoleMatch = content.match(/<polyline[^>]*c_padhole="1"[^>]*stroke-width="([^"]+)"[^>]*>/i);
+  if (polylineHoleMatch) {
+    const strokeWidth = parseFloat(polylineHoleMatch[1]);
+    if (strokeWidth > 0) {
+      hasHole = true;
+      holeRadius = strokeWidth / 2 * EE_TO_MM4;
+    }
+  }
+  if (!hasHole && content.includes('c_etype="pinhole"')) {
+    hasHole = true;
+    const innerCircle = content.match(/<circle[^>]*fill="[^"]*(?:white|#fff)[^"]*"[^>]*r="([^"]+)"/i);
+    if (innerCircle) {
+      holeRadius = parseFloat(innerCircle[1]) * EE_TO_MM4;
+    }
+  }
+  const transformMatch = content.match(/transform="[^"]*rotate\(([^)]+)\)"/);
+  if (transformMatch) {
+    rotation = parseFloat(transformMatch[1].split(",")[0]);
+  }
+  return { shape, width, height, hasHole, holeRadius, rotation };
+}
+function parseViaGroup(groupTag, groupContent) {
+  const originMatch = groupTag.match(/c_origin="([^"]+)"/);
+  if (!originMatch)
+    return null;
+  const [xStr, yStr] = originMatch[1].split(",");
+  const x = parseFloat(xStr) * EE_TO_MM4;
+  const y = parseFloat(yStr) * EE_TO_MM4;
+  const circles = [...groupContent.matchAll(/<circle[^>]*r="([^"]+)"[^>]*>/g)];
+  if (circles.length === 0)
+    return null;
+  const radii = circles.map((m) => parseFloat(m[1]) * EE_TO_MM4);
+  const outerDiameter = Math.max(...radii) * 2;
+  const holeDiameter = Math.min(...radii) * 2;
+  return { x, y, outerDiameter, holeDiameter };
+}
+function parseHoleGroup(groupTag, groupContent) {
+  const originMatch = groupTag.match(/c_origin="([^"]+)"/);
+  if (!originMatch)
+    return null;
+  const [xStr, yStr] = originMatch[1].split(",");
+  const x = parseFloat(xStr) * EE_TO_MM4;
+  const y = parseFloat(yStr) * EE_TO_MM4;
+  const circleMatch = groupContent.match(/<circle[^>]*r="([^"]+)"[^>]*>/);
+  if (!circleMatch)
+    return null;
+  const diameter = parseFloat(circleMatch[1]) * 2 * EE_TO_MM4;
+  const plated = groupTag.includes('layerid="11"') || groupTag.includes('c_etype="plated"');
+  return { x, y, diameter, plated };
+}
+function extractFromKiCadFootprint(sexp) {
+  const pads = [];
+  const vias = [];
+  const holes = [];
+  const padRegex = /\(pad\s+"([^"]*)"\s+(\w+)\s+(\w+)/g;
+  let match;
+  while ((match = padRegex.exec(sexp)) !== null) {
+    const padStart = match.index;
+    const padEnd = findSexpEnd(sexp, padStart);
+    const padSexp = sexp.slice(padStart, padEnd);
+    const pad = parseKiCadPad(match[1], match[2], match[3], padSexp);
+    if (pad) {
+      if (pad.number === "" && pad.hasHole) {
+        vias.push({
+          x: pad.x,
+          y: pad.y,
+          outerDiameter: pad.width,
+          holeDiameter: pad.holeRadius ? pad.holeRadius * 2 : 0
+        });
+      } else {
+        pads.push(pad);
+      }
+    }
+  }
+  const holeRegex = /\(pad\s+""\s+np_thru_hole/g;
+  while ((match = holeRegex.exec(sexp)) !== null) {
+    const holeStart = match.index;
+    const holeEnd = findSexpEnd(sexp, holeStart);
+    const holeSexp = sexp.slice(holeStart, holeEnd);
+    const hole = parseKiCadHole(holeSexp);
+    if (hole) {
+      holes.push(hole);
+    }
+  }
+  const allPoints = [
+    ...pads.map((p) => ({ x: p.x, y: p.y })),
+    ...vias.map((v) => ({ x: v.x, y: v.y })),
+    ...holes.map((h) => ({ x: h.x, y: h.y }))
+  ];
+  const bounds = calculateBounds(allPoints);
+  return { pads, vias, holes, bounds };
+}
+function findSexpEnd(sexp, startIndex) {
+  let depth = 0;
+  let i = startIndex;
+  while (i < sexp.length) {
+    if (sexp[i] === "(") {
+      depth++;
+    } else if (sexp[i] === ")") {
+      depth--;
+      if (depth === 0) {
+        return i + 1;
+      }
+    }
+    i++;
+  }
+  return sexp.length;
+}
+function parseKiCadPad(number, padType, shape, sexp) {
+  const atMatch = sexp.match(/\(at\s+([\d.-]+)\s+([\d.-]+)(?:\s+([\d.-]+))?\)/);
+  if (!atMatch)
+    return null;
+  const x = parseFloat(atMatch[1]);
+  const y = parseFloat(atMatch[2]);
+  const rotation = atMatch[3] ? parseFloat(atMatch[3]) : 0;
+  const sizeMatch = sexp.match(/\(size\s+([\d.-]+)\s+([\d.-]+)\)/);
+  if (!sizeMatch)
+    return null;
+  const width = parseFloat(sizeMatch[1]);
+  const height = parseFloat(sizeMatch[2]);
+  let layerId = 1;
+  if (sexp.includes("B.Cu")) {
+    layerId = 2;
+  }
+  if (sexp.includes("*.Cu")) {
+    layerId = 11;
+  }
+  const drillMatch = sexp.match(/\(drill\s+([\d.-]+)/);
+  const hasHole = padType === "thru_hole" || padType === "np_thru_hole" || drillMatch !== null;
+  const holeRadius = drillMatch ? parseFloat(drillMatch[1]) / 2 : undefined;
+  const shapeMap = {
+    rect: "rect",
+    circle: "circle",
+    oval: "oval",
+    roundrect: "roundrect",
+    custom: "custom",
+    polygon: "polygon"
+  };
+  return {
+    number,
+    x,
+    y,
+    width,
+    height,
+    shape: shapeMap[shape] || "rect",
+    layerId,
+    hasHole,
+    holeRadius,
+    rotation: rotation !== 0 ? rotation : undefined
+  };
+}
+function parseKiCadHole(sexp) {
+  const atMatch = sexp.match(/\(at\s+([\d.-]+)\s+([\d.-]+)/);
+  const drillMatch = sexp.match(/\(drill\s+([\d.-]+)/);
+  if (!atMatch || !drillMatch)
+    return null;
+  return {
+    x: parseFloat(atMatch[1]),
+    y: parseFloat(atMatch[2]),
+    diameter: parseFloat(drillMatch[1]),
+    plated: !sexp.includes("np_thru_hole")
+  };
+}
+function areShapesEquivalent(shape1, shape2) {
+  if (shape1 === shape2)
+    return true;
+  const rectangularShapes = ["polygon", "rect", "roundrect"];
+  const roundShapes = ["circle", "oval"];
+  if (rectangularShapes.includes(shape1) && rectangularShapes.includes(shape2)) {
+    return true;
+  }
+  if (roundShapes.includes(shape1) && roundShapes.includes(shape2)) {
+    return true;
+  }
+  return false;
+}
+function compareFootprints(reference, generated, options = {}) {
+  const opts = { ...DEFAULT_COMPARISON_OPTIONS, ...options };
+  const diffs = [];
+  const padCountMatch = reference.pads.length === generated.pads.length;
+  const viaCountMatch = reference.vias.length === generated.vias.length;
+  const holeCountMatch = reference.holes.length === generated.holes.length;
+  const usedGenIndices = new Set;
+  for (const refPad of reference.pads) {
+    const match = findMatchingPad(refPad, generated.pads, usedGenIndices, opts.positionTolerance);
+    if (!match) {
+      diffs.push({
+        padNumber: refPad.number,
+        field: "missing",
+        severity: "error",
+        message: `Pad ${refPad.number} missing in generated output`
+      });
+      continue;
+    }
+    const genPad = match.pad;
+    usedGenIndices.add(match.index);
+    const dx = Math.abs(refPad.x - genPad.x);
+    const dy = Math.abs(refPad.y - genPad.y);
+    if (dx > opts.positionTolerance || dy > opts.positionTolerance) {
+      diffs.push({
+        padNumber: refPad.number,
+        field: "position",
+        severity: "error",
+        message: `Position differs: expected (${refPad.x.toFixed(3)}, ${refPad.y.toFixed(3)}), got (${genPad.x.toFixed(3)}, ${genPad.y.toFixed(3)})`,
+        expected: `(${refPad.x.toFixed(3)}, ${refPad.y.toFixed(3)})`,
+        actual: `(${genPad.x.toFixed(3)}, ${genPad.y.toFixed(3)})`
+      });
+    }
+    const dw = Math.abs(refPad.width - genPad.width);
+    const dh = Math.abs(refPad.height - genPad.height);
+    const dwSwapped = Math.abs(refPad.width - genPad.height);
+    const dhSwapped = Math.abs(refPad.height - genPad.width);
+    const sizeMatches = dw <= opts.sizeTolerance && dh <= opts.sizeTolerance || dwSwapped <= opts.sizeTolerance && dhSwapped <= opts.sizeTolerance;
+    if (!sizeMatches) {
+      const posInfo = ` at (${refPad.x.toFixed(2)}, ${refPad.y.toFixed(2)})`;
+      diffs.push({
+        padNumber: refPad.number,
+        field: "size",
+        severity: opts.sizeWarningsOnly ? "warning" : "error",
+        message: `Size differs${posInfo}: expected ${refPad.width.toFixed(3)}x${refPad.height.toFixed(3)}mm, got ${genPad.width.toFixed(3)}x${genPad.height.toFixed(3)}mm`,
+        expected: `${refPad.width.toFixed(3)}x${refPad.height.toFixed(3)}`,
+        actual: `${genPad.width.toFixed(3)}x${genPad.height.toFixed(3)}`
+      });
+    }
+    if (!areShapesEquivalent(refPad.shape, genPad.shape)) {
+      diffs.push({
+        padNumber: refPad.number,
+        field: "shape",
+        severity: "warning",
+        message: `Shape differs: expected ${refPad.shape}, got ${genPad.shape}`,
+        expected: refPad.shape,
+        actual: genPad.shape
+      });
+    }
+    if (refPad.hasHole !== genPad.hasHole) {
+      diffs.push({
+        padNumber: refPad.number,
+        field: "hole",
+        severity: "error",
+        message: `Hole mismatch: expected ${refPad.hasHole ? "THT" : "SMD"}, got ${genPad.hasHole ? "THT" : "SMD"}`
+      });
+    } else if (refPad.hasHole && refPad.holeRadius && genPad.holeRadius) {
+      const drillDiff = Math.abs(refPad.holeRadius - genPad.holeRadius);
+      if (drillDiff > opts.holeTolerance) {
+        diffs.push({
+          padNumber: refPad.number,
+          field: "hole",
+          severity: "warning",
+          message: `Hole size differs: expected ø${(refPad.holeRadius * 2).toFixed(3)}mm, got ø${(genPad.holeRadius * 2).toFixed(3)}mm`,
+          expected: (refPad.holeRadius * 2).toFixed(3),
+          actual: (genPad.holeRadius * 2).toFixed(3)
+        });
+      }
+    }
+  }
+  if (!opts.ignoreExtraPads) {
+    for (let i = 0;i < generated.pads.length; i++) {
+      if (usedGenIndices.has(i))
+        continue;
+      const genPad = generated.pads[i];
+      const matchByPos = reference.pads.find((p) => Math.abs(p.x - genPad.x) < opts.positionTolerance && Math.abs(p.y - genPad.y) < opts.positionTolerance);
+      if (!matchByPos) {
+        diffs.push({
+          padNumber: genPad.number,
+          field: "extra",
+          severity: "warning",
+          message: `Extra pad ${genPad.number} in generated output at (${genPad.x.toFixed(3)}, ${genPad.y.toFixed(3)})`
+        });
+      }
+    }
+  }
+  const errors2 = diffs.filter((d) => d.severity === "error");
+  const warnings = diffs.filter((d) => d.severity === "warning");
+  const passed = errors2.length === 0 && padCountMatch;
+  return {
+    passed,
+    padCountMatch,
+    viaCountMatch,
+    holeCountMatch,
+    referencePadCount: reference.pads.length,
+    generatedPadCount: generated.pads.length,
+    referenceViaCount: reference.vias.length,
+    generatedViaCount: generated.vias.length,
+    diffs,
+    errors: errors2,
+    warnings
+  };
+}
+function findMatchingPad(refPad, generatedPads, usedIndices, tolerance) {
+  const candidates = [];
+  for (let i = 0;i < generatedPads.length; i++) {
+    if (usedIndices.has(i))
+      continue;
+    const p = generatedPads[i];
+    if (p.number === refPad.number) {
+      const distance = Math.sqrt((p.x - refPad.x) ** 2 + (p.y - refPad.y) ** 2);
+      candidates.push({ pad: p, index: i, distance });
+    }
+  }
+  if (candidates.length > 0) {
+    candidates.sort((a, b) => a.distance - b.distance);
+    return { pad: candidates[0].pad, index: candidates[0].index };
+  }
+  for (let i = 0;i < generatedPads.length; i++) {
+    if (usedIndices.has(i))
+      continue;
+    const p = generatedPads[i];
+    if (Math.abs(p.x - refPad.x) < tolerance && Math.abs(p.y - refPad.y) < tolerance) {
+      return { pad: p, index: i };
+    }
+  }
+  return null;
+}
+function calculateBounds(points) {
+  if (points.length === 0) {
+    return { minX: 0, maxX: 0, minY: 0, maxY: 0 };
+  }
+  return {
+    minX: Math.min(...points.map((p) => p.x)),
+    maxX: Math.max(...points.map((p) => p.x)),
+    minY: Math.min(...points.map((p) => p.y)),
+    maxY: Math.max(...points.map((p) => p.y))
+  };
+}
+function formatComparisonResult(result) {
+  const lines = [];
+  const status = result.passed ? "✓ PASS" : "✗ FAIL";
+  lines.push(`Footprint Comparison: ${status}`);
+  lines.push("");
+  lines.push(`  Pad count: ${result.generatedPadCount}/${result.referencePadCount} ${result.padCountMatch ? "✓" : "✗"}`);
+  lines.push(`  Via count: ${result.generatedViaCount}/${result.referenceViaCount} ${result.viaCountMatch ? "✓" : "✗"}`);
+  lines.push("");
+  if (result.errors.length > 0) {
+    lines.push(`  Errors (${result.errors.length}):`);
+    for (const err of result.errors) {
+      lines.push(`    ✗ Pad ${err.padNumber}: ${err.message}`);
+    }
+    lines.push("");
+  }
+  if (result.warnings.length > 0) {
+    lines.push(`  Warnings (${result.warnings.length}):`);
+    for (const warn of result.warnings) {
+      lines.push(`    ⚠ Pad ${warn.padNumber}: ${warn.message}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+var EE_TO_MM5 = 10 * 0.0254;
+var MIL_TO_MM2 = 0.0254;
+function extractFromReferenceSVG2(svg) {
+  const rawPins = [];
+  const pinRegex = /<g[^>]*c_partid="part_pin"[^>]*>/g;
+  let match;
+  while ((match = pinRegex.exec(svg)) !== null) {
+    const groupTag = match[0];
+    const endIndex = findGroupEnd2(svg, match.index);
+    const groupContent = svg.slice(match.index, endIndex);
+    const pin = parsePinGroup(groupTag, groupContent);
+    if (pin) {
+      rawPins.push(pin);
+    }
+  }
+  const centroid = calculateCentroid(rawPins.map((p) => ({ x: p.x, y: p.y })));
+  const pins = rawPins.map((p) => ({
+    ...p,
+    x: roundTo3(p.x - centroid.x, 4),
+    y: roundTo3(p.y - centroid.y, 4)
+  }));
+  const bounds = calculateBounds2(pins.map((p) => ({ x: p.x, y: p.y })));
+  return { pins, bounds };
+}
+function findGroupEnd2(svg, startIndex) {
+  let depth = 0;
+  let i = startIndex;
+  while (i < svg.length) {
+    if (svg.slice(i, i + 2) === "<g") {
+      depth++;
+      i += 2;
+    } else if (svg.slice(i, i + 4) === "</g>") {
+      depth--;
+      if (depth === 0) {
+        return i + 4;
+      }
+      i += 4;
+    } else {
+      i++;
+    }
+  }
+  return svg.length;
+}
+function parsePinGroup(groupTag, groupContent) {
+  const spicepinMatch = groupTag.match(/c_spicepin="([^"]+)"/);
+  const numberMatch = groupTag.match(/number="([^"]+)"/);
+  const number = spicepinMatch?.[1] || numberMatch?.[1] || "";
+  const textMatch = groupContent.match(/<text[^>]*>([^<]*)<\/text>/);
+  const name = textMatch?.[1]?.trim() || number;
+  const originMatch = groupTag.match(/c_origin="([^"]+)"/);
+  if (!originMatch)
+    return null;
+  const [xStr, yStr] = originMatch[1].split(",");
+  const x = parseFloat(xStr) * EE_TO_MM5;
+  const y = -parseFloat(yStr) * EE_TO_MM5;
+  const rotMatch = groupTag.match(/c_rotation="([^"]+)"/);
+  const rotation = rotMatch ? parseFloat(rotMatch[1]) : 0;
+  const etypeMatch = groupTag.match(/c_etype="([^"]+)"/);
+  const electrical = mapElectricalType(etypeMatch?.[1] || "");
+  return {
+    number,
+    name,
+    x,
+    y,
+    rotation,
+    electrical
+  };
+}
+function mapElectricalType(eeType) {
+  const typeMap = {
+    input: "input",
+    output: "output",
+    bi: "bidirectional",
+    tristate: "tri_state",
+    passive: "passive",
+    power: "power_in",
+    power_in: "power_in",
+    power_out: "power_out",
+    open_collector: "open_collector",
+    open_emitter: "open_emitter",
+    unconnected: "no_connect",
+    nc: "no_connect"
+  };
+  return typeMap[eeType.toLowerCase()] || "unspecified";
+}
+function extractFromKiCadSymbol(sexp) {
+  const pins = [];
+  const pinRegex = /\(pin\s+(\w+)\s+(\w+)/g;
+  let match;
+  while ((match = pinRegex.exec(sexp)) !== null) {
+    const pinStart = match.index;
+    const pinEnd = findSexpEnd2(sexp, pinStart);
+    const pinSexp = sexp.slice(pinStart, pinEnd);
+    const pin = parseKiCadPin(match[1], match[2], pinSexp);
+    if (pin) {
+      pins.push(pin);
+    }
+  }
+  const bounds = calculateBounds2(pins.map((p) => ({ x: p.x, y: p.y })));
+  return { pins, bounds };
+}
+function findSexpEnd2(sexp, startIndex) {
+  let depth = 0;
+  let i = startIndex;
+  while (i < sexp.length) {
+    if (sexp[i] === "(") {
+      depth++;
+    } else if (sexp[i] === ")") {
+      depth--;
+      if (depth === 0) {
+        return i + 1;
+      }
+    }
+    i++;
+  }
+  return sexp.length;
+}
+function parseKiCadPin(electricalType, shape, sexp) {
+  const atMatch = sexp.match(/\(at\s+([\d.-]+)\s+([\d.-]+)(?:\s+([\d.-]+))?\)/);
+  if (!atMatch)
+    return null;
+  const x = parseFloat(atMatch[1]) * MIL_TO_MM2;
+  const y = parseFloat(atMatch[2]) * MIL_TO_MM2;
+  const rotation = atMatch[3] ? parseFloat(atMatch[3]) : 0;
+  const nameMatch = sexp.match(/\(name\s+"([^"]*)"/);
+  const name = nameMatch?.[1] || "";
+  const numberMatch = sexp.match(/\(number\s+"([^"]*)"/);
+  const number = numberMatch?.[1] || "";
+  const electrical = mapKiCadElectricalType(electricalType);
+  return {
+    number,
+    name,
+    x,
+    y,
+    rotation,
+    electrical
+  };
+}
+function mapKiCadElectricalType(type) {
+  const typeMap = {
+    input: "input",
+    output: "output",
+    bidirectional: "bidirectional",
+    tri_state: "tri_state",
+    passive: "passive",
+    free: "free",
+    unspecified: "unspecified",
+    power_in: "power_in",
+    power_out: "power_out",
+    open_collector: "open_collector",
+    open_emitter: "open_emitter",
+    no_connect: "no_connect"
+  };
+  return typeMap[type.toLowerCase()] || "unspecified";
+}
+function compareSymbols(reference, generated, options = {}) {
+  const opts = { ...DEFAULT_COMPARISON_OPTIONS, ...options };
+  const diffs = [];
+  const pinCountMatch = reference.pins.length === generated.pins.length;
+  const matchedPins = new Set;
+  for (const refPin of reference.pins) {
+    const genPin = findMatchingPin(refPin, generated.pins, opts.positionTolerance);
+    if (!genPin) {
+      diffs.push({
+        pinNumber: refPin.number,
+        field: "missing",
+        severity: "error",
+        message: `Pin ${refPin.number} (${refPin.name}) missing in generated output`
+      });
+      continue;
+    }
+    matchedPins.add(genPin.number);
+    const dx = Math.abs(refPin.x - genPin.x);
+    const dy = Math.abs(refPin.y - genPin.y);
+    const posTolerance = opts.positionTolerance * 10;
+    if (dx > posTolerance || dy > posTolerance) {
+      diffs.push({
+        pinNumber: refPin.number,
+        field: "position",
+        severity: "warning",
+        message: `Position differs: expected (${refPin.x.toFixed(2)}, ${refPin.y.toFixed(2)}), got (${genPin.x.toFixed(2)}, ${genPin.y.toFixed(2)})`,
+        expected: `(${refPin.x.toFixed(2)}, ${refPin.y.toFixed(2)})`,
+        actual: `(${genPin.x.toFixed(2)}, ${genPin.y.toFixed(2)})`
+      });
+    }
+    if (!opts.ignorePinNames && refPin.name !== genPin.name) {
+      if (refPin.name.toLowerCase() !== genPin.name.toLowerCase()) {
+        diffs.push({
+          pinNumber: refPin.number,
+          field: "name",
+          severity: "warning",
+          message: `Name differs: expected "${refPin.name}", got "${genPin.name}"`,
+          expected: refPin.name,
+          actual: genPin.name
+        });
+      }
+    }
+    const rotDiff = Math.abs(refPin.rotation - genPin.rotation) % 360;
+    if (rotDiff > 1 && rotDiff < 359) {
+      diffs.push({
+        pinNumber: refPin.number,
+        field: "rotation",
+        severity: "info",
+        message: `Rotation differs: expected ${refPin.rotation}°, got ${genPin.rotation}°`,
+        expected: refPin.rotation,
+        actual: genPin.rotation
+      });
+    }
+    if (refPin.electrical && genPin.electrical && refPin.electrical !== genPin.electrical) {
+      diffs.push({
+        pinNumber: refPin.number,
+        field: "electrical",
+        severity: "warning",
+        message: `Electrical type differs: expected ${refPin.electrical}, got ${genPin.electrical}`,
+        expected: refPin.electrical,
+        actual: genPin.electrical
+      });
+    }
+  }
+  for (const genPin of generated.pins) {
+    if (!matchedPins.has(genPin.number)) {
+      const matchByPos = reference.pins.find((p) => Math.abs(p.x - genPin.x) < opts.positionTolerance * 10 && Math.abs(p.y - genPin.y) < opts.positionTolerance * 10);
+      if (!matchByPos) {
+        diffs.push({
+          pinNumber: genPin.number,
+          field: "extra",
+          severity: "warning",
+          message: `Extra pin ${genPin.number} (${genPin.name}) in generated output`
+        });
+      }
+    }
+  }
+  const errors2 = diffs.filter((d) => d.severity === "error");
+  const warnings = diffs.filter((d) => d.severity === "warning");
+  const passed = errors2.length === 0 && pinCountMatch;
+  return {
+    passed,
+    pinCountMatch,
+    referencePinCount: reference.pins.length,
+    generatedPinCount: generated.pins.length,
+    diffs,
+    errors: errors2,
+    warnings
+  };
+}
+function findMatchingPin(refPin, generatedPins, tolerance) {
+  const byNumber = generatedPins.find((p) => p.number === refPin.number);
+  if (byNumber)
+    return byNumber;
+  return generatedPins.find((p) => Math.abs(p.x - refPin.x) < tolerance * 10 && Math.abs(p.y - refPin.y) < tolerance * 10) || null;
+}
+function calculateCentroid(points) {
+  if (points.length === 0) {
+    return { x: 0, y: 0 };
+  }
+  const sum = points.reduce((acc, p) => ({ x: acc.x + p.x, y: acc.y + p.y }), { x: 0, y: 0 });
+  return {
+    x: sum.x / points.length,
+    y: sum.y / points.length
+  };
+}
+function roundTo3(value, decimals) {
+  const factor = Math.pow(10, decimals);
+  return Math.round(value * factor) / factor;
+}
+function calculateBounds2(points) {
+  if (points.length === 0) {
+    return { minX: 0, maxX: 0, minY: 0, maxY: 0 };
+  }
+  return {
+    minX: Math.min(...points.map((p) => p.x)),
+    maxX: Math.max(...points.map((p) => p.x)),
+    minY: Math.min(...points.map((p) => p.y)),
+    maxY: Math.max(...points.map((p) => p.y))
+  };
+}
+function formatSymbolComparisonResult(result) {
+  const lines = [];
+  const status = result.passed ? "✓ PASS" : "✗ FAIL";
+  lines.push(`Symbol Comparison: ${status}`);
+  lines.push("");
+  lines.push(`  Pin count: ${result.generatedPinCount}/${result.referencePinCount} ${result.pinCountMatch ? "✓" : "✗"}`);
+  lines.push("");
+  if (result.errors.length > 0) {
+    lines.push(`  Errors (${result.errors.length}):`);
+    for (const err of result.errors) {
+      lines.push(`    ✗ Pin ${err.pinNumber}: ${err.message}`);
+    }
+    lines.push("");
+  }
+  if (result.warnings.length > 0) {
+    lines.push(`  Warnings (${result.warnings.length}):`);
+    for (const warn of result.warnings) {
+      lines.push(`    ⚠ Pin ${warn.pinNumber}: ${warn.message}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function generateValidationReport(result, svgs) {
+  const statusClass = result.passed ? "pass" : "fail";
+  const statusText = result.passed ? "PASS" : "FAIL";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Validation: ${result.lcscCode} - ${result.componentName}</title>
+  <style>${getStyles()}</style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <h1>${result.componentName}</h1>
+      <div class="meta">
+        <span class="lcsc">LCSC: ${result.lcscCode}</span>
+        <span class="status ${statusClass}">${statusText}</span>
+        <span class="duration">${result.durationMs}ms</span>
+      </div>
+    </header>
+
+    ${result.error ? `<div class="error-banner">${escapeHtml(result.error)}</div>` : ""}
+
+    <div class="main-columns">
+      ${svgs?.footprintRef || svgs?.footprintGen || result.footprint ? `
+      <div class="main-column">
+        <h2 class="column-header">Footprint</h2>
+        ${svgs?.footprintRef || svgs?.footprintGen ? `
+        <div class="svg-comparison">
+          <div class="svg-panel">
+            <h3>Reference (EasyEDA/JLCPCB)</h3>
+            <div class="svg-container">${svgs?.footprintRef || '<div class="no-preview">Not available</div>'}</div>
+          </div>
+          <div class="svg-panel">
+            <h3>Generated (JLC-CLI)</h3>
+            <div class="svg-container">${svgs?.footprintGen || '<div class="no-preview">Not available</div>'}</div>
+          </div>
+        </div>
+        ` : ""}
+        ${result.footprint ? generateFootprintSection(result.footprint) : ""}
+      </div>
+      ` : ""}
+
+      ${svgs?.symbolRef || svgs?.symbolGen || result.symbol ? `
+      <div class="main-column">
+        <h2 class="column-header">Symbol</h2>
+        ${svgs?.symbolRef || svgs?.symbolGen ? `
+        <div class="svg-comparison">
+          <div class="svg-panel">
+            <h3>Reference (EasyEDA/JLCPCB)</h3>
+            <div class="svg-container">${svgs?.symbolRef || '<div class="no-preview">Not available</div>'}</div>
+          </div>
+          <div class="svg-panel">
+            <h3>Generated (JLC-CLI)</h3>
+            <div class="svg-container">${svgs?.symbolGen || '<div class="no-preview">Not available</div>'}</div>
+          </div>
+        </div>
+        ` : ""}
+        ${result.symbol ? generateSymbolSection(result.symbol) : ""}
+      </div>
+      ` : ""}
+    </div>
+
+    <footer>
+      <p>Generated: ${result.timestamp.toISOString()}</p>
+      <p>JLC-CLI Validation Report</p>
+    </footer>
+  </div>
+</body>
+</html>`;
+}
+function generateBatchReport(results, title = "Validation Report") {
+  const passed = results.filter((r) => r.passed).length;
+  const failed = results.filter((r) => !r.passed).length;
+  const errorCount = results.filter((r) => r.error).length;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${title}</title>
+  <style>${getStyles()}</style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <h1>${title}</h1>
+      <div class="summary">
+        <span class="stat pass">${passed} passed</span>
+        <span class="stat fail">${failed} failed</span>
+        <span class="stat error">${errorCount} errors</span>
+        <span class="stat total">${results.length} total</span>
+      </div>
+    </header>
+
+    <section class="results-table">
+      <table>
+        <thead>
+          <tr>
+            <th>LCSC</th>
+            <th>Component</th>
+            <th>Footprint</th>
+            <th>Symbol</th>
+            <th>Status</th>
+            <th>Duration</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${results.map((r) => generateResultRow(r)).join(`
+`)}
+        </tbody>
+      </table>
+    </section>
+
+    ${generateDetailedResults(results)}
+
+    <footer>
+      <p>Generated: ${new Date().toISOString()}</p>
+      <p>JLC-CLI Validation Report</p>
+    </footer>
+  </div>
+</body>
+</html>`;
+}
+function generateFootprintSection(result) {
+  const statusClass = result.passed ? "pass" : "fail";
+  return `
+    <section class="validation-section footprint">
+      <h2>Footprint Validation <span class="${statusClass}">${result.passed ? "✓" : "✗"}</span></h2>
+
+      <div class="stats-grid">
+        <div class="stat-item">
+          <span class="label">Pad Count</span>
+          <span class="value ${result.padCountMatch ? "pass" : "fail"}">
+            ${result.generatedPadCount}/${result.referencePadCount}
+          </span>
+        </div>
+        <div class="stat-item">
+          <span class="label">Via Count</span>
+          <span class="value ${result.viaCountMatch ? "pass" : "fail"}">
+            ${result.generatedViaCount}/${result.referenceViaCount}
+          </span>
+        </div>
+        <div class="stat-item">
+          <span class="label">Errors</span>
+          <span class="value ${result.errors.length > 0 ? "fail" : "pass"}">
+            ${result.errors.length}
+          </span>
+        </div>
+        <div class="stat-item">
+          <span class="label">Warnings</span>
+          <span class="value warn">${result.warnings.length}</span>
+        </div>
+      </div>
+
+      ${result.errors.length > 0 ? `
+      <div class="diff-list errors">
+        <h3>Errors</h3>
+        ${result.errors.map((d) => formatPadDiff(d)).join(`
+`)}
+      </div>
+      ` : ""}
+
+      ${result.warnings.length > 0 ? `
+      <div class="diff-list warnings">
+        <h3>Warnings</h3>
+        ${result.warnings.map((d) => formatPadDiff(d)).join(`
+`)}
+      </div>
+      ` : ""}
+    </section>
+  `;
+}
+function generateSymbolSection(result) {
+  const statusClass = result.passed ? "pass" : "fail";
+  return `
+    <section class="validation-section symbol">
+      <h2>Symbol Validation <span class="${statusClass}">${result.passed ? "✓" : "✗"}</span></h2>
+
+      <div class="stats-grid">
+        <div class="stat-item">
+          <span class="label">Pin Count</span>
+          <span class="value ${result.pinCountMatch ? "pass" : "fail"}">
+            ${result.generatedPinCount}/${result.referencePinCount}
+          </span>
+        </div>
+        <div class="stat-item">
+          <span class="label">Errors</span>
+          <span class="value ${result.errors.length > 0 ? "fail" : "pass"}">
+            ${result.errors.length}
+          </span>
+        </div>
+        <div class="stat-item">
+          <span class="label">Warnings</span>
+          <span class="value warn">${result.warnings.length}</span>
+        </div>
+      </div>
+
+      ${result.errors.length > 0 ? `
+      <div class="diff-list errors">
+        <h3>Errors</h3>
+        ${result.errors.map((d) => formatPinDiff(d)).join(`
+`)}
+      </div>
+      ` : ""}
+
+      ${result.warnings.length > 0 ? `
+      <div class="diff-list warnings">
+        <h3>Warnings</h3>
+        ${result.warnings.map((d) => formatPinDiff(d)).join(`
+`)}
+      </div>
+      ` : ""}
+    </section>
+  `;
+}
+function generateResultRow(result) {
+  const status = result.passed ? "pass" : result.error ? "error" : "fail";
+  const fpStatus = result.footprint ? result.footprint.passed ? "✓" : "✗" : result.error ? "⚠" : "-";
+  const symStatus = result.symbol ? result.symbol.passed ? "✓" : "✗" : result.error ? "⚠" : "-";
+  return `
+    <tr class="${status}">
+      <td><a href="#${result.lcscCode}">${result.lcscCode}</a></td>
+      <td>${escapeHtml(result.componentName)}</td>
+      <td class="center">${fpStatus}</td>
+      <td class="center">${symStatus}</td>
+      <td class="status">${result.passed ? "PASS" : result.error ? "ERROR" : "FAIL"}</td>
+      <td class="right">${result.durationMs}ms</td>
+    </tr>
+  `;
+}
+function generateDetailedResults(results) {
+  const failedResults = results.filter((r) => !r.passed);
+  if (failedResults.length === 0)
+    return "";
+  return `
+    <section class="detailed-results">
+      <h2>Detailed Results</h2>
+      ${failedResults.map((r) => `
+        <div class="result-detail" id="${r.lcscCode}">
+          <h3>${r.lcscCode} - ${escapeHtml(r.componentName)}</h3>
+          ${r.error ? `<div class="error-message">${escapeHtml(r.error)}</div>` : ""}
+          ${r.footprint ? generateFootprintSection(r.footprint) : ""}
+          ${r.symbol ? generateSymbolSection(r.symbol) : ""}
+        </div>
+      `).join(`
+`)}
+    </section>
+  `;
+}
+function formatPadDiff(diff) {
+  const icon = diff.severity === "error" ? "✗" : diff.severity === "warning" ? "⚠" : "ℹ";
+  return `
+    <div class="diff-item ${diff.severity}">
+      <span class="icon">${icon}</span>
+      <span class="pad">Pad ${diff.padNumber}</span>
+      <span class="field">${diff.field}</span>
+      <span class="message">${escapeHtml(diff.message)}</span>
+    </div>
+  `;
+}
+function formatPinDiff(diff) {
+  const icon = diff.severity === "error" ? "✗" : diff.severity === "warning" ? "⚠" : "ℹ";
+  return `
+    <div class="diff-item ${diff.severity}">
+      <span class="icon">${icon}</span>
+      <span class="pin">Pin ${diff.pinNumber}</span>
+      <span class="field">${diff.field}</span>
+      <span class="message">${escapeHtml(diff.message)}</span>
+    </div>
+  `;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function getStyles() {
+  return `
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: #f5f5f5;
+      color: #333;
+      line-height: 1.6;
+    }
+
+    .container {
+      max-width: 1400px;
+      margin: 0 auto;
+      padding: 2rem;
+    }
+
+    header {
+      background: #fff;
+      padding: 1.5rem;
+      border-radius: 8px;
+      margin-bottom: 2rem;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+
+    h1 {
+      font-size: 1.5rem;
+      margin-bottom: 0.5rem;
+    }
+
+    .meta {
+      display: flex;
+      gap: 1rem;
+      align-items: center;
+    }
+
+    .lcsc {
+      font-family: monospace;
+      background: #e8e8e8;
+      padding: 0.25rem 0.5rem;
+      border-radius: 4px;
+    }
+
+    .status {
+      font-weight: bold;
+      padding: 0.25rem 0.75rem;
+      border-radius: 4px;
+    }
+
+    .status.pass, .pass { color: #22c55e; }
+    .status.fail, .fail { color: #ef4444; }
+    .status.error { color: #f59e0b; }
+    .warn { color: #f59e0b; }
+
+    .summary {
+      display: flex;
+      gap: 1rem;
+      margin-top: 1rem;
+    }
+
+    .stat {
+      padding: 0.5rem 1rem;
+      border-radius: 4px;
+      background: #f0f0f0;
+    }
+
+    .stat.pass { background: #dcfce7; }
+    .stat.fail { background: #fee2e2; }
+    .stat.error { background: #fef3c7; }
+
+    .error-banner {
+      background: #fee2e2;
+      color: #b91c1c;
+      padding: 1rem;
+      border-radius: 8px;
+      margin-bottom: 2rem;
+    }
+
+    .comparison {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 2rem;
+      margin-bottom: 2rem;
+    }
+
+    .svg-panel {
+      background: #fff;
+      padding: 1rem;
+      border-radius: 8px;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+
+    .svg-panel h2 {
+      font-size: 1rem;
+      margin-bottom: 1rem;
+      color: #666;
+    }
+
+    .main-columns {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(500px, 1fr));
+      gap: 2rem;
+      margin-bottom: 2rem;
+    }
+
+    .main-column {
+      background: #fff;
+      border-radius: 8px;
+      padding: 1.5rem;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+
+    .column-header {
+      font-size: 1.25rem;
+      margin-bottom: 1.5rem;
+      color: #333;
+      text-align: center;
+      border-bottom: 2px solid #e0e0e0;
+      padding-bottom: 0.75rem;
+    }
+
+    .svg-comparison {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 1rem;
+      margin-bottom: 1.5rem;
+    }
+
+    .svg-panel {
+      background: #f8f8f8;
+      border-radius: 8px;
+      padding: 0.75rem;
+    }
+
+    .svg-panel h3 {
+      font-size: 0.75rem;
+      color: #666;
+      margin-bottom: 0.5rem;
+      text-align: center;
+    }
+
+    .svg-container {
+      background: #1a1a1a;
+      padding: 0.75rem;
+      border-radius: 4px;
+      overflow: hidden;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 220px;
+    }
+
+    .svg-container svg {
+      width: 100%;
+      height: 100%;
+      object-fit: contain;
+    }
+
+    .svg-container .no-preview {
+      color: #888;
+      font-style: italic;
+      font-size: 0.875rem;
+    }
+
+    .validation-section {
+      background: #f8f8f8;
+      padding: 1rem;
+      border-radius: 8px;
+    }
+
+    .validation-section h2 {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      margin-bottom: 1rem;
+      font-size: 1rem;
+    }
+
+    .stats-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+      gap: 1rem;
+      margin-bottom: 1.5rem;
+    }
+
+    .stat-item {
+      background: #f8f8f8;
+      padding: 0.75rem;
+      border-radius: 4px;
+      text-align: center;
+    }
+
+    .stat-item .label {
+      display: block;
+      font-size: 0.75rem;
+      color: #666;
+      margin-bottom: 0.25rem;
+    }
+
+    .stat-item .value {
+      font-size: 1.25rem;
+      font-weight: bold;
+    }
+
+    .diff-list {
+      margin-top: 1rem;
+    }
+
+    .diff-list h3 {
+      font-size: 0.875rem;
+      color: #666;
+      margin-bottom: 0.5rem;
+    }
+
+    .diff-item {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.5rem;
+      background: #f8f8f8;
+      border-radius: 4px;
+      margin-bottom: 0.25rem;
+      font-size: 0.875rem;
+    }
+
+    .diff-item.error { background: #fee2e2; }
+    .diff-item.warning { background: #fef3c7; }
+    .diff-item.info { background: #e0f2fe; }
+
+    .diff-item .icon { width: 1rem; }
+    .diff-item .pad, .diff-item .pin {
+      font-weight: bold;
+      min-width: 4rem;
+    }
+    .diff-item .field {
+      color: #666;
+      min-width: 5rem;
+    }
+    .diff-item .message {
+      flex: 1;
+    }
+
+    .results-table {
+      background: #fff;
+      border-radius: 8px;
+      overflow: hidden;
+      margin-bottom: 2rem;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+
+    table {
+      width: 100%;
+      border-collapse: collapse;
+    }
+
+    th, td {
+      padding: 0.75rem 1rem;
+      text-align: left;
+      border-bottom: 1px solid #eee;
+    }
+
+    th {
+      background: #f8f8f8;
+      font-weight: 600;
+    }
+
+    tr.pass { background: #f0fdf4; }
+    tr.fail { background: #fef2f2; }
+    tr.error { background: #fffbeb; }
+
+    .center { text-align: center; }
+    .right { text-align: right; }
+
+    .detailed-results {
+      margin-top: 2rem;
+    }
+
+    .result-detail {
+      background: #fff;
+      padding: 1.5rem;
+      border-radius: 8px;
+      margin-bottom: 1.5rem;
+      box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+
+    .result-detail h3 {
+      margin-bottom: 1rem;
+    }
+
+    .error-message {
+      background: #fee2e2;
+      color: #b91c1c;
+      padding: 0.75rem;
+      border-radius: 4px;
+      margin-bottom: 1rem;
+    }
+
+    footer {
+      text-align: center;
+      color: #666;
+      font-size: 0.875rem;
+      margin-top: 2rem;
+      padding-top: 2rem;
+      border-top: 1px solid #ddd;
+    }
+
+    @media (max-width: 768px) {
+      .comparison {
+        grid-template-columns: 1fr;
+      }
+    }
+  `;
+}
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    if (/\s/.test(char)) {
+      i++;
+      continue;
+    }
+    if (char === "(" || char === ")") {
+      tokens.push(char);
+      i++;
+      continue;
+    }
+    if (char === '"') {
+      let str = "";
+      i++;
+      while (i < input.length) {
+        if (input[i] === "\\" && i + 1 < input.length) {
+          str += input[i + 1];
+          i += 2;
+        } else if (input[i] === '"') {
+          i++;
+          break;
+        } else {
+          str += input[i];
+          i++;
+        }
+      }
+      tokens.push(`"${str}"`);
+      continue;
+    }
+    let atom = "";
+    while (i < input.length && !/[\s()]/.test(input[i])) {
+      atom += input[i];
+      i++;
+    }
+    if (atom) {
+      tokens.push(atom);
+    }
+  }
+  return tokens;
+}
+function parseTokens(tokens) {
+  if (tokens.length === 0) {
+    return { expr: [], remaining: [] };
+  }
+  const token = tokens[0];
+  if (token === "(") {
+    const list = [];
+    let rest = tokens.slice(1);
+    while (rest.length > 0 && rest[0] !== ")") {
+      const { expr, remaining } = parseTokens(rest);
+      list.push(expr);
+      rest = remaining;
+    }
+    if (rest[0] === ")") {
+      rest = rest.slice(1);
+    }
+    return { expr: list, remaining: rest };
+  }
+  if (token === ")") {
+    return { expr: [], remaining: tokens.slice(1) };
+  }
+  let value = token;
+  if (value.startsWith('"') && value.endsWith('"')) {
+    value = value.slice(1, -1);
+  }
+  return { expr: value, remaining: tokens.slice(1) };
+}
+function parseSExpr(input) {
+  const tokens = tokenize(input);
+  const { expr } = parseTokens(tokens);
+  return expr;
+}
+function isList(expr) {
+  return Array.isArray(expr);
+}
+function isAtom(expr) {
+  return typeof expr === "string";
+}
+function getTag(expr) {
+  if (isList(expr) && expr.length > 0 && isAtom(expr[0])) {
+    return expr[0];
+  }
+  return;
+}
+function findChild(expr, tag) {
+  if (!isList(expr))
+    return;
+  for (const child of expr) {
+    if (isList(child) && getTag(child) === tag) {
+      return child;
+    }
+  }
+  return;
+}
+function findChildren(expr, tag) {
+  if (!isList(expr))
+    return [];
+  const results = [];
+  for (const child of expr) {
+    if (isList(child) && getTag(child) === tag) {
+      results.push(child);
+    }
+  }
+  return results;
+}
+function getAttr(expr, tag) {
+  const child = findChild(expr, tag);
+  if (child && child.length >= 2 && isAtom(child[1])) {
+    return child[1];
+  }
+  return;
+}
+function getNumericAttr(expr, tag) {
+  const value = getAttr(expr, tag);
+  if (value !== undefined) {
+    const num = parseFloat(value);
+    if (!isNaN(num))
+      return num;
+  }
+  return;
+}
+function getPoint(expr, tag) {
+  const child = findChild(expr, tag);
+  if (child && child.length >= 3) {
+    const x = parseFloat(isAtom(child[1]) ? child[1] : "");
+    const y = parseFloat(isAtom(child[2]) ? child[2] : "");
+    if (!isNaN(x) && !isNaN(y)) {
+      return { x, y };
+    }
+  }
+  return;
+}
+function getPointWithRotation(expr, tag) {
+  const child = findChild(expr, tag);
+  if (child && child.length >= 3) {
+    const x = parseFloat(isAtom(child[1]) ? child[1] : "");
+    const y = parseFloat(isAtom(child[2]) ? child[2] : "");
+    if (!isNaN(x) && !isNaN(y)) {
+      const result = { x, y };
+      if (child.length >= 4 && isAtom(child[3])) {
+        const rotation = parseFloat(child[3]);
+        if (!isNaN(rotation)) {
+          result.rotation = rotation;
+        }
+      }
+      return result;
+    }
   }
+  return;
 }
-function communityToComponentData(community) {
-  const cPara = community.symbol.head?.c_para ?? {};
-  const fpCPara = community.footprint.head?.c_para ?? {};
-  return {
-    info: {
-      name: community.title || cPara.name || "Unknown",
-      prefix: cPara.pre || cPara.Prefix || "U",
-      package: fpCPara.package || community.footprint.name,
-      manufacturer: cPara.Manufacturer || cPara.BOM_Manufacturer,
-      description: community.description || cPara.BOM_Manufacturer_Part,
-      category: cPara.package
-    },
-    symbol: community.symbol,
-    footprint: community.footprint,
-    model3d: community.model3d,
-    rawData: community.rawData
-  };
+function getSize(expr) {
+  const child = findChild(expr, "size");
+  if (child && child.length >= 3) {
+    const width = parseFloat(isAtom(child[1]) ? child[1] : "");
+    const height = parseFloat(isAtom(child[2]) ? child[2] : "");
+    if (!isNaN(width) && !isNaN(height)) {
+      return { width, height };
+    }
+  }
+  return;
 }
-async function handleComponent(uuid, res) {
-  if (!uuid) {
-    res.writeHead(400, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: "Missing UUID" }));
+function getStroke(expr) {
+  const stroke = findChild(expr, "stroke");
+  if (!stroke)
+    return;
+  const width = getNumericAttr(stroke, "width") ?? 0.254;
+  const type = getAttr(stroke, "type") ?? "default";
+  return { width, type };
+}
+function getFillType(expr) {
+  const fill = findChild(expr, "fill");
+  if (!fill)
     return;
+  const typeAttr = getAttr(fill, "type");
+  if (typeAttr)
+    return typeAttr;
+  if (fill.length >= 2 && isAtom(fill[1])) {
+    return fill[1];
   }
-  try {
-    const component2 = await easyedaCommunityClient.getComponent(uuid);
-    if (!component2) {
-      res.writeHead(404, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Component not found" }));
-      return;
-    }
-    const componentData = communityToComponentData(component2);
-    let symbolSexpr = "";
-    let footprintSexpr = "";
-    try {
-      symbolSexpr = symbolConverter.convertToSymbolEntry(componentData);
-    } catch (e) {
-      logger7.warn("Symbol conversion failed:", e);
-    }
-    try {
-      footprintSexpr = footprintConverter.convert(componentData);
-    } catch (e) {
-      logger7.warn("Footprint conversion failed:", e);
+  return;
+}
+function getPoints(expr) {
+  const pts = findChild(expr, "pts");
+  if (!pts)
+    return [];
+  const points = [];
+  for (const child of pts) {
+    if (isList(child) && getTag(child) === "xy" && child.length >= 3) {
+      const x = parseFloat(isAtom(child[1]) ? child[1] : "");
+      const y = parseFloat(isAtom(child[2]) ? child[2] : "");
+      if (!isNaN(x) && !isNaN(y)) {
+        points.push({ x, y });
+      }
     }
-    res.writeHead(200, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({
-      uuid: component2.uuid,
-      title: component2.title,
-      description: component2.description,
-      owner: component2.owner,
-      symbolSexpr,
-      footprintSexpr,
-      model3d: component2.model3d
-    }));
+  }
+  return points;
+}
+function getLayers(expr) {
+  const layer = getAttr(expr, "layer");
+  if (layer)
+    return [layer];
+  const layers = findChild(expr, "layers");
+  if (!layers)
+    return [];
+  const result = [];
+  for (let i = 1;i < layers.length; i++) {
+    const item = layers[i];
+    if (isAtom(item)) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+var SYMBOL_COLORS = {
+  background: "#FFFFF8",
+  body: "#840000",
+  bodyFill: "#FFFFC4",
+  pin: "#840000",
+  pinText: "#008484",
+  text: "#000000"
+};
+var FOOTPRINT_COLORS = {
+  background: "#000000",
+  fCu: "#840000",
+  bCu: "#008400",
+  in1Cu: "#C2C200",
+  in2Cu: "#C200C2",
+  fSilkS: "#008484",
+  bSilkS: "#840084",
+  fMask: "#840084",
+  bMask: "#848400",
+  fPaste: "#840000",
+  bPaste: "#00C2C2",
+  fFab: "#848484",
+  bFab: "#000084",
+  fCrtYd: "#C2C2C2",
+  bCrtYd: "#848484",
+  edgeCuts: "#C2C200",
+  dwgsUser: "#C2C2C2",
+  cmtsUser: "#848484",
+  margin: "#C200C2",
+  padFront: "#840000",
+  padBack: "#008400",
+  padThruHole: "#C2C200",
+  drill: "#848484"
+};
+var SYMBOL_SCALE = 10;
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function renderSymbolSvg(sexpr) {
+  if (!sexpr || sexpr.trim() === "") {
+    return createErrorSvg("No symbol data");
+  }
+  try {
+    let parsed = parseSExpr(sexpr);
+    if (isList(parsed) && getTag(parsed) === "kicad_symbol_lib") {
+      const symbols = findChildren(parsed, "symbol");
+      if (symbols.length === 0) {
+        return createErrorSvg("No symbol found in library");
+      }
+      parsed = symbols[0];
+    }
+    if (!isList(parsed) || getTag(parsed) !== "symbol") {
+      return createErrorSvg("Invalid symbol format");
+    }
+    const elements = [];
+    const bounds = { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity };
+    const units = findChildren(parsed, "symbol");
+    for (const unit of units) {
+      for (const rect of findChildren(unit, "rectangle")) {
+        const svg = renderSymbolRectangle(rect, bounds);
+        if (svg)
+          elements.push(svg);
+      }
+      for (const polyline of findChildren(unit, "polyline")) {
+        const svg = renderSymbolPolyline(polyline, bounds);
+        if (svg)
+          elements.push(svg);
+      }
+      for (const circle of findChildren(unit, "circle")) {
+        const svg = renderSymbolCircle(circle, bounds);
+        if (svg)
+          elements.push(svg);
+      }
+      for (const arc of findChildren(unit, "arc")) {
+        const svg = renderSymbolArc(arc, bounds);
+        if (svg)
+          elements.push(svg);
+      }
+      for (const pin of findChildren(unit, "pin")) {
+        const svg = renderSymbolPin(pin, bounds);
+        if (svg)
+          elements.push(svg);
+      }
+    }
+    const padding = 5;
+    if (!isFinite(bounds.minX)) {
+      bounds.minX = -20;
+      bounds.maxX = 20;
+      bounds.minY = -20;
+      bounds.maxY = 20;
+    }
+    const width = (bounds.maxX - bounds.minX + padding * 2) * SYMBOL_SCALE;
+    const height = (bounds.maxY - bounds.minY + padding * 2) * SYMBOL_SCALE;
+    const viewBox = `${(bounds.minX - padding) * SYMBOL_SCALE} ${(-bounds.maxY - padding) * SYMBOL_SCALE} ${width} ${height}`;
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox}" width="100%" height="100%" style="background-color: ${SYMBOL_COLORS.background}">
+  <g transform="scale(${SYMBOL_SCALE}, ${-SYMBOL_SCALE})">
+    ${elements.join(`
+    `)}
+  </g>
+</svg>`;
   } catch (error) {
-    logger7.error("Component fetch error:", error);
-    res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: "Failed to fetch component" }));
+    return createErrorSvg(`Parse error: ${error}`);
   }
 }
-var logger8 = createLogger("http-server");
-var DEFAULT_PORT = 3847;
-var serverInstance = null;
-function startHttpServer(options = {}) {
-  if (serverInstance) {
-    logger8.debug("HTTP server already running");
-    const port2 = options.port ?? parseInt(process.env.JLC_MCP_HTTP_PORT || String(DEFAULT_PORT), 10);
-    options.onReady?.(`http://localhost:${port2}`);
-    return port2;
+function renderSymbolRectangle(rect, bounds) {
+  const start = getPoint(rect, "start");
+  const end = getPoint(rect, "end");
+  if (!start || !end)
+    return "";
+  const stroke = getStroke(rect);
+  const fillType = getFillType(rect);
+  const fill = fillType === "background" ? SYMBOL_COLORS.bodyFill : "none";
+  updateBounds(bounds, start.x, start.y);
+  updateBounds(bounds, end.x, end.y);
+  const x = Math.min(start.x, end.x);
+  const y = Math.min(start.y, end.y);
+  const w = Math.abs(end.x - start.x);
+  const h = Math.abs(end.y - start.y);
+  return `<rect x="${x}" y="${y}" width="${w}" height="${h}" fill="${fill}" stroke="${SYMBOL_COLORS.body}" stroke-width="${stroke?.width ?? 0.254}"/>`;
+}
+function renderSymbolPolyline(polyline, bounds) {
+  const points = getPoints(polyline);
+  if (points.length < 2)
+    return "";
+  const stroke = getStroke(polyline);
+  const fillType = getFillType(polyline);
+  const fill = fillType === "background" ? SYMBOL_COLORS.bodyFill : "none";
+  const pointsStr = points.map((p) => {
+    updateBounds(bounds, p.x, p.y);
+    return `${p.x},${p.y}`;
+  }).join(" ");
+  return `<polyline points="${pointsStr}" fill="${fill}" stroke="${SYMBOL_COLORS.body}" stroke-width="${stroke?.width ?? 0.254}" stroke-linecap="round" stroke-linejoin="round"/>`;
+}
+function renderSymbolCircle(circle, bounds) {
+  const center = getPoint(circle, "center");
+  const radius = getNumericAttr(circle, "radius");
+  if (!center || radius === undefined)
+    return "";
+  const stroke = getStroke(circle);
+  const fillType = getFillType(circle);
+  const fill = fillType === "background" ? SYMBOL_COLORS.bodyFill : "none";
+  updateBounds(bounds, center.x - radius, center.y - radius);
+  updateBounds(bounds, center.x + radius, center.y + radius);
+  return `<circle cx="${center.x}" cy="${center.y}" r="${radius}" fill="${fill}" stroke="${SYMBOL_COLORS.body}" stroke-width="${stroke?.width ?? 0.254}"/>`;
+}
+function renderSymbolArc(arc, bounds) {
+  const start = getPoint(arc, "start");
+  const mid = getPoint(arc, "mid");
+  const end = getPoint(arc, "end");
+  if (!start || !mid || !end)
+    return "";
+  const stroke = getStroke(arc);
+  updateBounds(bounds, start.x, start.y);
+  updateBounds(bounds, mid.x, mid.y);
+  updateBounds(bounds, end.x, end.y);
+  const arcPath = calculateArcPath(start, mid, end);
+  return `<path d="${arcPath}" fill="none" stroke="${SYMBOL_COLORS.body}" stroke-width="${stroke?.width ?? 0.254}" stroke-linecap="round"/>`;
+}
+function calculateArcPath(start, mid, end) {
+  const { x: ax, y: ay } = start;
+  const { x: bx, y: by } = mid;
+  const { x: cx, y: cy } = end;
+  const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+  if (Math.abs(d) < 0.0001) {
+    return `M ${start.x} ${start.y} L ${end.x} ${end.y}`;
+  }
+  const ux = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / d;
+  const uy = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / d;
+  const radius = Math.sqrt((ax - ux) ** 2 + (ay - uy) ** 2);
+  const cross = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+  const sweepFlag = cross > 0 ? 0 : 1;
+  const largeArcFlag = 0;
+  return `M ${start.x} ${start.y} A ${radius} ${radius} 0 ${largeArcFlag} ${sweepFlag} ${end.x} ${end.y}`;
+}
+function renderSymbolPin(pin, bounds) {
+  const at = getPointWithRotation(pin, "at");
+  const length = getNumericAttr(pin, "length") ?? 2.54;
+  if (!at)
+    return "";
+  const nameChild = findChild(pin, "name");
+  const numberChild = findChild(pin, "number");
+  const pinName = nameChild && nameChild.length >= 2 && isAtom(nameChild[1]) ? nameChild[1] : "";
+  const pinNumber = numberChild && numberChild.length >= 2 && isAtom(numberChild[1]) ? numberChild[1] : "";
+  const rotation = at.rotation ?? 0;
+  const radians = rotation * Math.PI / 180;
+  const endX = at.x + length * Math.cos(radians);
+  const endY = at.y + length * Math.sin(radians);
+  updateBounds(bounds, at.x, at.y);
+  updateBounds(bounds, endX, endY);
+  const elements = [];
+  elements.push(`<line x1="${at.x}" y1="${at.y}" x2="${endX}" y2="${endY}" stroke="${SYMBOL_COLORS.pin}" stroke-width="0.254"/>`);
+  elements.push(`<circle cx="${at.x}" cy="${at.y}" r="0.3" fill="${SYMBOL_COLORS.pin}"/>`);
+  if (pinName && pinName !== "~") {
+    const textOffset = 0.5;
+    let textX = endX;
+    let textY = endY;
+    let anchor = "start";
+    let baseline = "middle";
+    if (rotation === 0) {
+      textX = endX + textOffset;
+      anchor = "start";
+    } else if (rotation === 180) {
+      textX = endX - textOffset;
+      anchor = "end";
+    } else if (rotation === 90) {
+      textY = endY + textOffset;
+      baseline = "hanging";
+      anchor = "middle";
+    } else if (rotation === 270) {
+      textY = endY - textOffset;
+      baseline = "alphabetic";
+      anchor = "middle";
+    }
+    elements.push(`<text x="${textX}" y="${textY}" fill="${SYMBOL_COLORS.pinText}" font-size="1" font-family="sans-serif" text-anchor="${anchor}" dominant-baseline="${baseline}" transform="scale(1,-1) translate(0,${-2 * textY})">${escapeXml(pinName)}</text>`);
+  }
+  if (pinNumber) {
+    const midX = (at.x + endX) / 2;
+    const midY = (at.y + endY) / 2;
+    const offsetY = rotation === 0 || rotation === 180 ? 0.8 : 0;
+    elements.push(`<text x="${midX}" y="${midY + offsetY}" fill="${SYMBOL_COLORS.pinText}" font-size="0.8" font-family="sans-serif" text-anchor="middle" dominant-baseline="middle" transform="scale(1,-1) translate(0,${-2 * (midY + offsetY)})">${escapeXml(pinNumber)}</text>`);
+  }
+  return elements.join(`
+`);
+}
+function renderFootprintSvg(sexpr) {
+  if (!sexpr || sexpr.trim() === "") {
+    return createErrorSvg("No footprint data");
   }
-  const port = options.port ?? parseInt(process.env.JLC_MCP_HTTP_PORT || String(DEFAULT_PORT), 10);
-  serverInstance = createServer(async (req, res) => {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-    try {
-      await handleRequest(req, res);
-    } catch (error) {
-      logger8.error("Request error:", error);
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Internal server error" }));
+  try {
+    const parsed = parseSExpr(sexpr);
+    if (!isList(parsed) || getTag(parsed) !== "footprint") {
+      return createErrorSvg("Invalid footprint format");
+    }
+    const elements = [];
+    const bounds = { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity };
+    for (const pad of findChildren(parsed, "pad")) {
+      const svg = renderFootprintPad(pad, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    for (const line of findChildren(parsed, "fp_line")) {
+      const svg = renderFootprintLine(line, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    for (const circle of findChildren(parsed, "fp_circle")) {
+      const svg = renderFootprintCircle(circle, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    for (const arc of findChildren(parsed, "fp_arc")) {
+      const svg = renderFootprintArc(arc, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    for (const rect of findChildren(parsed, "fp_rect")) {
+      const svg = renderFootprintRect(rect, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    for (const poly of findChildren(parsed, "fp_poly")) {
+      const svg = renderFootprintPoly(poly, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    for (const line of findChildren(parsed, "gr_line")) {
+      const svg = renderFootprintLine(line, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    for (const circle of findChildren(parsed, "gr_circle")) {
+      const svg = renderFootprintCircle(circle, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    for (const arc of findChildren(parsed, "gr_arc")) {
+      const svg = renderFootprintArc(arc, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    for (const rect of findChildren(parsed, "gr_rect")) {
+      const svg = renderFootprintRect(rect, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    for (const poly of findChildren(parsed, "gr_poly")) {
+      const svg = renderFootprintPoly(poly, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    for (const text of findChildren(parsed, "fp_text")) {
+      const svg = renderFootprintText(text, bounds);
+      if (svg)
+        elements.push(svg);
+    }
+    const padding = 1;
+    if (!isFinite(bounds.minX)) {
+      bounds.minX = -5;
+      bounds.maxX = 5;
+      bounds.minY = -5;
+      bounds.maxY = 5;
+    }
+    const width = bounds.maxX - bounds.minX + padding * 2;
+    const height = bounds.maxY - bounds.minY + padding * 2;
+    const viewBox = `${bounds.minX - padding} ${bounds.minY - padding} ${width} ${height}`;
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox}" width="100%" height="100%" style="background-color: ${FOOTPRINT_COLORS.background}">
+  <g>
+    ${elements.join(`
+    `)}
+  </g>
+</svg>`;
+  } catch (error) {
+    return createErrorSvg(`Parse error: ${error}`);
+  }
+}
+function getLayerColor(layer) {
+  if (layer.includes("F.Cu"))
+    return FOOTPRINT_COLORS.fCu;
+  if (layer.includes("B.Cu"))
+    return FOOTPRINT_COLORS.bCu;
+  if (/In\d+\.Cu/.test(layer))
+    return FOOTPRINT_COLORS.in1Cu;
+  if (layer.includes("F.SilkS"))
+    return FOOTPRINT_COLORS.fSilkS;
+  if (layer.includes("B.SilkS"))
+    return FOOTPRINT_COLORS.bSilkS;
+  if (layer.includes("F.Mask"))
+    return FOOTPRINT_COLORS.fMask;
+  if (layer.includes("B.Mask"))
+    return FOOTPRINT_COLORS.bMask;
+  if (layer.includes("F.Paste"))
+    return FOOTPRINT_COLORS.fPaste;
+  if (layer.includes("B.Paste"))
+    return FOOTPRINT_COLORS.bPaste;
+  if (layer.includes("F.Fab"))
+    return FOOTPRINT_COLORS.fFab;
+  if (layer.includes("B.Fab"))
+    return FOOTPRINT_COLORS.bFab;
+  if (layer.includes("F.CrtYd"))
+    return FOOTPRINT_COLORS.fCrtYd;
+  if (layer.includes("B.CrtYd"))
+    return FOOTPRINT_COLORS.bCrtYd;
+  if (layer.includes("Edge.Cuts"))
+    return FOOTPRINT_COLORS.edgeCuts;
+  if (layer.includes("Dwgs.User"))
+    return FOOTPRINT_COLORS.dwgsUser;
+  if (layer.includes("Cmts.User"))
+    return FOOTPRINT_COLORS.cmtsUser;
+  if (layer.includes("Margin"))
+    return FOOTPRINT_COLORS.margin;
+  return FOOTPRINT_COLORS.fSilkS;
+}
+function renderFootprintPad(pad, bounds) {
+  if (!isList(pad) || pad.length < 4)
+    return "";
+  const padNumber = isAtom(pad[1]) ? pad[1] : "";
+  const padType = isAtom(pad[2]) ? pad[2] : "";
+  const padShape = isAtom(pad[3]) ? pad[3] : "";
+  const at = getPointWithRotation(pad, "at");
+  const size = getSize(pad);
+  if (!at || !size)
+    return "";
+  updateBounds(bounds, at.x - size.width / 2, at.y - size.height / 2);
+  updateBounds(bounds, at.x + size.width / 2, at.y + size.height / 2);
+  const elements = [];
+  const layers = getLayers(pad);
+  let color;
+  if (padType === "thru_hole" || padType === "np_thru_hole") {
+    color = FOOTPRINT_COLORS.padThruHole;
+  } else if (layers.some((l) => l.includes("B."))) {
+    color = FOOTPRINT_COLORS.padBack;
+  } else {
+    color = FOOTPRINT_COLORS.padFront;
+  }
+  const rotation = at.rotation ?? 0;
+  const transform = rotation !== 0 ? ` transform="rotate(${rotation}, ${at.x}, ${at.y})"` : "";
+  if (padShape === "circle") {
+    const r = Math.min(size.width, size.height) / 2;
+    elements.push(`<circle cx="${at.x}" cy="${at.y}" r="${r}" fill="${color}"${transform}/>`);
+  } else if (padShape === "oval") {
+    const rx = size.width / 2;
+    const ry = size.height / 2;
+    elements.push(`<ellipse cx="${at.x}" cy="${at.y}" rx="${rx}" ry="${ry}" fill="${color}"${transform}/>`);
+  } else if (padShape === "roundrect") {
+    const rratio = getNumericAttr(pad, "roundrect_rratio") ?? 0.25;
+    const rx = Math.min(size.width, size.height) * rratio / 2;
+    const x = at.x - size.width / 2;
+    const y = at.y - size.height / 2;
+    elements.push(`<rect x="${x}" y="${y}" width="${size.width}" height="${size.height}" rx="${rx}" fill="${color}"${transform}/>`);
+  } else if (padShape === "custom") {
+    const primitives = findChild(pad, "primitives");
+    if (primitives) {
+      for (const prim of findChildren(primitives, "gr_poly")) {
+        const points = getPoints(prim);
+        if (points.length >= 3) {
+          const polyStr = points.map((p) => {
+            const absX = at.x + p.x;
+            const absY = at.y + p.y;
+            updateBounds(bounds, absX, absY);
+            return `${absX},${absY}`;
+          }).join(" ");
+          elements.push(`<polygon points="${polyStr}" fill="${color}"${transform}/>`);
+        }
+      }
+    }
+    if (elements.length === 0) {
+      const x = at.x - size.width / 2;
+      const y = at.y - size.height / 2;
+      elements.push(`<rect x="${x}" y="${y}" width="${size.width}" height="${size.height}" fill="${color}"${transform}/>`);
     }
-  });
-  serverInstance.listen(port, () => {
-    const url = `http://localhost:${port}`;
-    logger8.info(`HTTP server listening on ${url}`);
-    options.onReady?.(url);
-  });
-  serverInstance.on("error", (error) => {
-    if (error.code === "EADDRINUSE") {
-      logger8.warn(`Port ${port} already in use, HTTP server not started`);
-    } else {
-      logger8.error("HTTP server error:", error);
+  } else {
+    const x = at.x - size.width / 2;
+    const y = at.y - size.height / 2;
+    elements.push(`<rect x="${x}" y="${y}" width="${size.width}" height="${size.height}" fill="${color}"${transform}/>`);
+  }
+  if (padType === "thru_hole" || padType === "np_thru_hole") {
+    const drill = findChild(pad, "drill");
+    if (drill && drill.length >= 2) {
+      const isOval = isAtom(drill[1]) && drill[1] === "oval";
+      if (isOval && drill.length >= 4) {
+        const dw = parseFloat(isAtom(drill[2]) ? drill[2] : "0");
+        const dh = parseFloat(isAtom(drill[3]) ? drill[3] : "0");
+        elements.push(`<ellipse cx="${at.x}" cy="${at.y}" rx="${dw / 2}" ry="${dh / 2}" fill="${FOOTPRINT_COLORS.drill}"${transform}/>`);
+      } else {
+        const drillSize = parseFloat(isAtom(drill[1]) ? drill[1] : "0");
+        elements.push(`<circle cx="${at.x}" cy="${at.y}" r="${drillSize / 2}" fill="${FOOTPRINT_COLORS.drill}"/>`);
+      }
     }
-  });
-  return port;
+  }
+  if (padNumber) {
+    const fontSize = Math.min(size.width, size.height) * 0.5;
+    elements.push(`<text x="${at.x}" y="${at.y}" fill="#FFFFFF" font-size="${fontSize}" font-family="sans-serif" text-anchor="middle" dominant-baseline="central">${escapeXml(padNumber)}</text>`);
+  }
+  return elements.join(`
+`);
 }
-function stopHttpServer() {
-  if (serverInstance) {
-    serverInstance.close();
-    serverInstance = null;
-    logger8.info("HTTP server stopped");
+function renderFootprintLine(line, bounds) {
+  const start = getPoint(line, "start");
+  const end = getPoint(line, "end");
+  if (!start || !end)
+    return "";
+  const stroke = getStroke(line);
+  const layers = getLayers(line);
+  const layer = layers[0] ?? "F.SilkS";
+  if (layer.includes("CrtYd"))
+    return "";
+  const color = getLayerColor(layer);
+  updateBounds(bounds, start.x, start.y);
+  updateBounds(bounds, end.x, end.y);
+  return `<line x1="${start.x}" y1="${start.y}" x2="${end.x}" y2="${end.y}" stroke="${color}" stroke-width="${stroke?.width ?? 0.15}" stroke-linecap="round"/>`;
+}
+function renderFootprintCircle(circle, bounds) {
+  const center = getPoint(circle, "center");
+  const end = getPoint(circle, "end");
+  if (!center || !end)
+    return "";
+  const radius = Math.sqrt((end.x - center.x) ** 2 + (end.y - center.y) ** 2);
+  const stroke = getStroke(circle);
+  const layers = getLayers(circle);
+  const layer = layers[0] ?? "F.SilkS";
+  if (layer.includes("CrtYd"))
+    return "";
+  const color = getLayerColor(layer);
+  updateBounds(bounds, center.x - radius, center.y - radius);
+  updateBounds(bounds, center.x + radius, center.y + radius);
+  return `<circle cx="${center.x}" cy="${center.y}" r="${radius}" fill="none" stroke="${color}" stroke-width="${stroke?.width ?? 0.15}"/>`;
+}
+function renderFootprintArc(arc, bounds) {
+  const start = getPoint(arc, "start");
+  const mid = getPoint(arc, "mid");
+  const end = getPoint(arc, "end");
+  if (!start || !mid || !end)
+    return "";
+  const stroke = getStroke(arc);
+  const layers = getLayers(arc);
+  const layer = layers[0] ?? "F.SilkS";
+  if (layer.includes("CrtYd"))
+    return "";
+  const color = getLayerColor(layer);
+  updateBounds(bounds, start.x, start.y);
+  updateBounds(bounds, mid.x, mid.y);
+  updateBounds(bounds, end.x, end.y);
+  const arcPath = calculateArcPath(start, mid, end);
+  return `<path d="${arcPath}" fill="none" stroke="${color}" stroke-width="${stroke?.width ?? 0.15}" stroke-linecap="round"/>`;
+}
+function renderFootprintPoly(poly, bounds) {
+  const points = getPoints(poly);
+  if (points.length < 3)
+    return "";
+  const layers = getLayers(poly);
+  const layer = layers[0] ?? "F.Cu";
+  if (layer.includes("CrtYd"))
+    return "";
+  const color = getLayerColor(layer);
+  const stroke = getStroke(poly);
+  const fillType = getFillType(poly);
+  const fill = fillType === "solid" || fillType === "yes" ? color : "none";
+  const pointsStr = points.map((p) => {
+    updateBounds(bounds, p.x, p.y);
+    return `${p.x},${p.y}`;
+  }).join(" ");
+  const strokeWidth = stroke?.width ?? 0;
+  const strokeAttr = strokeWidth > 0 ? ` stroke="${color}" stroke-width="${strokeWidth}"` : "";
+  return `<polygon points="${pointsStr}" fill="${fill}"${strokeAttr}/>`;
+}
+function renderFootprintRect(rect, bounds) {
+  const start = getPoint(rect, "start");
+  const end = getPoint(rect, "end");
+  if (!start || !end)
+    return "";
+  const layers = getLayers(rect);
+  const layer = layers[0] ?? "F.SilkS";
+  if (layer.includes("CrtYd"))
+    return "";
+  const color = getLayerColor(layer);
+  const stroke = getStroke(rect);
+  const fillType = getFillType(rect);
+  const fill = fillType === "solid" ? color : "none";
+  updateBounds(bounds, start.x, start.y);
+  updateBounds(bounds, end.x, end.y);
+  const x = Math.min(start.x, end.x);
+  const y = Math.min(start.y, end.y);
+  const w = Math.abs(end.x - start.x);
+  const h = Math.abs(end.y - start.y);
+  return `<rect x="${x}" y="${y}" width="${w}" height="${h}" fill="${fill}" stroke="${color}" stroke-width="${stroke?.width ?? 0.15}"/>`;
+}
+function renderFootprintText(text, bounds) {
+  if (!isList(text) || text.length < 3)
+    return "";
+  const textType = isAtom(text[1]) ? text[1] : "";
+  const textContent = isAtom(text[2]) ? text[2] : "";
+  if (textType === "reference" || textType === "value")
+    return "";
+  const at = getPointWithRotation(text, "at");
+  if (!at)
+    return "";
+  const layers = getLayers(text);
+  const layer = layers[0] ?? "F.SilkS";
+  const color = getLayerColor(layer);
+  const effects = findChild(text, "effects");
+  let fontSize = 1;
+  let textAnchor = "middle";
+  if (effects) {
+    const font = findChild(effects, "font");
+    if (font) {
+      const size = getSize(font);
+      if (size)
+        fontSize = size.height;
+    }
+    const justify = findChild(effects, "justify");
+    if (justify) {
+      for (let i = 1;i < justify.length; i++) {
+        const val = isAtom(justify[i]) ? justify[i] : "";
+        if (val === "left")
+          textAnchor = "start";
+        else if (val === "right")
+          textAnchor = "end";
+      }
+    }
+  }
+  const textWidth = textContent.length * fontSize * 0.6;
+  const textHeight = fontSize;
+  if (textAnchor === "start") {
+    updateBounds(bounds, at.x, at.y - textHeight / 2);
+    updateBounds(bounds, at.x + textWidth, at.y + textHeight / 2);
+  } else if (textAnchor === "end") {
+    updateBounds(bounds, at.x - textWidth, at.y - textHeight / 2);
+    updateBounds(bounds, at.x, at.y + textHeight / 2);
+  } else {
+    updateBounds(bounds, at.x - textWidth / 2, at.y - textHeight / 2);
+    updateBounds(bounds, at.x + textWidth / 2, at.y + textHeight / 2);
   }
+  const rotation = at.rotation ?? 0;
+  const transform = rotation !== 0 ? ` transform="rotate(${rotation}, ${at.x}, ${at.y})"` : "";
+  return `<text x="${at.x}" y="${at.y}" dy="0.35em" fill="${color}" font-size="${fontSize}" font-family="sans-serif" text-anchor="${textAnchor}"${transform}>${escapeXml(textContent)}</text>`;
+}
+function updateBounds(bounds, x, y) {
+  bounds.minX = Math.min(bounds.minX, x);
+  bounds.maxX = Math.max(bounds.maxX, x);
+  bounds.minY = Math.min(bounds.minY, y);
+  bounds.maxY = Math.max(bounds.maxY, y);
+}
+function createErrorSvg(message) {
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 100" width="100%" height="100%">
+  <rect width="200" height="100" fill="#FFF0F0"/>
+  <text x="100" y="50" fill="#CC0000" font-size="12" font-family="sans-serif" text-anchor="middle" dominant-baseline="central">${escapeXml(message)}</text>
+</svg>`;
 }
 
 // ../../node_modules/ink/build/render.js
@@ -43364,12 +46126,12 @@ var isWebWorker = typeof WorkerGlobalScope !== "undefined" && globalThis instanc
 var isDedicatedWorker = typeof DedicatedWorkerGlobalScope !== "undefined" && globalThis instanceof DedicatedWorkerGlobalScope;
 var isSharedWorker = typeof SharedWorkerGlobalScope !== "undefined" && globalThis instanceof SharedWorkerGlobalScope;
 var isServiceWorker = typeof ServiceWorkerGlobalScope !== "undefined" && globalThis instanceof ServiceWorkerGlobalScope;
-var platform3 = globalThis.navigator?.userAgentData?.platform;
-var isMacOs = platform3 === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
-var isWindows = platform3 === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
-var isLinux = platform3 === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
-var isIos = platform3 === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
-var isAndroid = platform3 === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
+var platform4 = globalThis.navigator?.userAgentData?.platform;
+var isMacOs = platform4 === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
+var isWindows = platform4 === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
+var isLinux = platform4 === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
+var isIos = platform4 === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
+var isAndroid = platform4 === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
 
 // ../../node_modules/ansi-escapes/base.js
 var ESC = "\x1B[";
@@ -45804,7 +48566,7 @@ function parseAnsiCode(string, offset) {
     return string.slice(0, endIndex + 1);
   }
 }
-function tokenize(string, endCharacter = Number.POSITIVE_INFINITY) {
+function tokenize2(string, endCharacter = Number.POSITIVE_INFINITY) {
   const returnValue = [];
   let index = 0;
   let visibleCount = 0;
@@ -45857,7 +48619,7 @@ function undoAnsiCodes(codes) {
   return endCodes.reverse().join("");
 }
 function sliceAnsi(string, start, end) {
-  const tokens = tokenize(string, end);
+  const tokens = tokenize2(string, end);
   let activeCodes = [];
   let position = 0;
   let returnValue = "";
@@ -47644,7 +50406,7 @@ function splitCompoundSGRSequences(code) {
   }
   return ret.map((part) => `\x1B[${part}m`);
 }
-function tokenize2(str, endChar = Number.POSITIVE_INFINITY) {
+function tokenize3(str, endChar = Number.POSITIVE_INFINITY) {
   const ret = [];
   let index = 0;
   let visible = 0;
@@ -47802,7 +50564,7 @@ class Output {
           for (const transformer of transformers) {
             line = transformer(line, index);
           }
-          const characters = styledCharsFromTokens(tokenize2(line));
+          const characters = styledCharsFromTokens(tokenize3(line));
           let offsetX = x;
           for (const character of characters) {
             currentLine[offsetX] = character;
@@ -49145,7 +51907,11 @@ function useNavigation() {
 }
 function useCurrentScreen() {
   const { history, currentIndex } = useNavigation();
-  return history[currentIndex];
+  const entry = history[currentIndex];
+  if (!entry) {
+    throw new Error(`Invalid navigation state: currentIndex=${currentIndex}, history.length=${history.length}`);
+  }
+  return entry;
 }
 
 // src/app/state/AppStateContext.tsx
@@ -49740,7 +52506,7 @@ var is_in_ssh_default = isInSsh;
 var fallbackAttemptSymbol = Symbol("fallbackAttempt");
 var __dirname3 = import.meta.url ? path.dirname(fileURLToPath2(import.meta.url)) : "";
 var localXdgOpenPath = path.join(__dirname3, "xdg-open");
-var { platform: platform5, arch } = process19;
+var { platform: platform6, arch } = process19;
 var tryEachApp = async (apps, opener) => {
   if (apps.length === 0) {
     return;
@@ -49836,7 +52602,7 @@ var baseOpen = async (options) => {
   if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
     shouldUseWindowsInWsl = await canAccessPowerShell();
   }
-  if (platform5 === "darwin") {
+  if (platform6 === "darwin") {
     command = "open";
     if (options.wait) {
       cliArguments.push("--wait-apps");
@@ -49850,7 +52616,7 @@ var baseOpen = async (options) => {
     if (app) {
       cliArguments.push("-a", app);
     }
-  } else if (platform5 === "win32" || shouldUseWindowsInWsl) {
+  } else if (platform6 === "win32" || shouldUseWindowsInWsl) {
     command = await powerShellPath2();
     cliArguments.push(...executePowerShell.argumentsPrefix);
     if (!is_wsl_default) {
@@ -49889,7 +52655,7 @@ var baseOpen = async (options) => {
         await fs6.access(localXdgOpenPath, fsConstants2.X_OK);
         exeLocalXdgOpen = true;
       } catch {}
-      const useSystemXdgOpen = process19.versions.electron ?? (platform5 === "android" || isBundled || !exeLocalXdgOpen);
+      const useSystemXdgOpen = process19.versions.electron ?? (platform6 === "android" || isBundled || !exeLocalXdgOpen);
       command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
     }
     if (appArguments.length > 0) {
@@ -49900,7 +52666,7 @@ var baseOpen = async (options) => {
       childProcessOptions.detached = true;
     }
   }
-  if (platform5 === "darwin" && appArguments.length > 0) {
+  if (platform6 === "darwin" && appArguments.length > 0) {
     cliArguments.push("--args", ...appArguments);
   }
   if (options.target) {
@@ -49963,12 +52729,12 @@ function detectArchBinary(binary) {
   }
   return archBinary;
 }
-function detectPlatformBinary({ [platform5]: platformBinary }, { wsl } = {}) {
+function detectPlatformBinary({ [platform6]: platformBinary }, { wsl } = {}) {
   if (wsl && is_wsl_default) {
     return detectArchBinary(wsl);
   }
   if (!platformBinary) {
-    throw new Error(`${platform5} is not supported`);
+    throw new Error(`${platform6} is not supported`);
   }
   return detectArchBinary(platformBinary);
 }
@@ -50255,7 +53021,7 @@ function DetailView({ component, terminalWidth, isInstalled, installedInfo, stat
       }, undefined, true, undefined, this)
     ]
   }, undefined, true, undefined, this) : null;
-  const footerText = isInstalled ? "S Symbol • F Footprint • M 3D Model • R Regenerate • D Datasheet • Esc Back" : "Enter Install • D Datasheet • Esc Back";
+  const footerText = isInstalled ? "R Regenerate • D Delete • O Datasheet • Esc Back" : "Enter Install • O Datasheet • Esc Back";
   return /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
     flexDirection: "column",
     width: "100%",
@@ -50354,29 +53120,12 @@ function InfoScreen() {
   }, [params.componentId, params.component]);
   const datasheetUrl = component && ("datasheetPdf" in component ? component.datasheetPdf : ("datasheet" in component) ? component.datasheet : undefined);
   const [isRegenerating, setIsRegenerating] = import_react30.useState(false);
+  const [isDeleting, setIsDeleting] = import_react30.useState(false);
   const [regenerateMessage, setRegenerateMessage] = import_react30.useState(null);
   use_input_default((input, key) => {
-    if (isLoading || !component || isCheckingLibrary || isRegenerating)
+    if (isLoading || !component || isCheckingLibrary || isRegenerating || isDeleting)
       return;
     const lowerInput = input.toLowerCase();
-    if (lowerInput === "s" && installedInfo && libraryStatus) {
-      const symbolPath = `${libraryStatus.paths.symbolsDir}/JLC-MCP-${installedInfo.category}.kicad_sym`;
-      open_default(symbolPath);
-      return;
-    }
-    if (lowerInput === "f" && installedInfo && libraryStatus) {
-      if (installedInfo.footprintRef?.startsWith("JLC-MCP:")) {
-        const fpName = installedInfo.footprintRef.split(":")[1];
-        const footprintPath = `${libraryStatus.paths.footprintsDir}/JLC-MCP.pretty/${fpName}.kicad_mod`;
-        open_default(footprintPath);
-      }
-      return;
-    }
-    if (lowerInput === "m" && installedInfo && libraryStatus && installedInfo.has3dModel) {
-      const modelPath = `${libraryStatus.paths.models3dDir}/${installedInfo.name}.step`;
-      open_default(modelPath);
-      return;
-    }
     if (lowerInput === "r" && installedInfo) {
       setIsRegenerating(true);
       setRegenerateMessage("Regenerating symbol and footprint...");
@@ -50389,7 +53138,20 @@ function InfoScreen() {
       }).finally(() => setIsRegenerating(false));
       return;
     }
-    if (lowerInput === "d" && datasheetUrl) {
+    if (lowerInput === "d" && installedInfo) {
+      setIsDeleting(true);
+      setRegenerateMessage("Deleting component...");
+      libraryService.remove(installedInfo.lcscId).then(() => {
+        setRegenerateMessage("✓ Component deleted");
+        setInstalledInfo(null);
+        setTimeout(() => setRegenerateMessage(null), 2000);
+      }).catch((err) => {
+        setRegenerateMessage(`✗ Delete failed: ${err instanceof Error ? err.message : "Unknown error"}`);
+        setTimeout(() => setRegenerateMessage(null), 3000);
+      }).finally(() => setIsDeleting(false));
+      return;
+    }
+    if (lowerInput === "o" && datasheetUrl) {
       open_default(datasheetUrl);
       return;
     }
@@ -51721,11 +54483,12 @@ function App2({ initialScreen, initialParams }) {
     }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
-function renderApp(initialScreen, initialParams) {
-  render_default(/* @__PURE__ */ jsx_dev_runtime15.jsxDEV(App2, {
+async function renderApp(initialScreen, initialParams) {
+  const instance = render_default(/* @__PURE__ */ jsx_dev_runtime15.jsxDEV(App2, {
     initialScreen,
     initialParams
   }, undefined, false, undefined, this));
+  await instance.waitUntilExit();
 }
 
 // src/commands/search.ts
@@ -51748,7 +54511,7 @@ async function searchCommand(query, options) {
       return;
     }
     process.stdout.write("\x1B[1A\x1B[2K");
-    renderApp("search", { query, results });
+    await renderApp("search", { query, results });
   } catch (error) {
     console.error(`Search failed: ${error instanceof Error ? error.message : "Unknown error"}`);
     process.exit(1);
@@ -52112,6 +54875,33 @@ class x {
     }
   }
 }
+var SD = Object.defineProperty;
+var $D = (t, u, F) => (u in t) ? SD(t, u, { enumerable: true, configurable: true, writable: true, value: F }) : t[u] = F;
+var q = (t, u, F) => ($D(t, typeof u != "symbol" ? u + "" : u, F), F);
+
+class jD extends x {
+  constructor(u) {
+    super(u, false), q(this, "options"), q(this, "cursor", 0), this.options = u.options, this.cursor = this.options.findIndex(({ value: F }) => F === u.initialValue), this.cursor === -1 && (this.cursor = 0), this.changeValue(), this.on("cursor", (F) => {
+      switch (F) {
+        case "left":
+        case "up":
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          break;
+        case "down":
+        case "right":
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          break;
+      }
+      this.changeValue();
+    });
+  }
+  get _value() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    this.value = this._value.value;
+  }
+}
 class PD extends x {
   get valueWithCursor() {
     if (this.state === "submit")
@@ -52174,6 +54964,16 @@ var y2 = (s) => {
       return import_picocolors2.default.green(S2);
   }
 };
+var k2 = (s) => {
+  const { cursor: n, options: t, style: i } = s, r2 = s.maxItems ?? Number.POSITIVE_INFINITY, c2 = Math.max(process.stdout.rows - 4, 0), o = Math.min(c2, Math.max(r2, 5));
+  let l2 = 0;
+  n >= l2 + o - 3 ? l2 = Math.max(Math.min(n - o + 3, t.length - o), 0) : n < l2 + 2 && (l2 = Math.max(n - 2, 0));
+  const $2 = o < t.length && l2 > 0, d2 = o < t.length && l2 + o < t.length;
+  return t.slice(l2, l2 + o).map((w2, b2, C) => {
+    const I2 = b2 === 0 && $2, x2 = b2 === C.length - 1 && d2;
+    return I2 || x2 ? import_picocolors2.default.dim("...") : i(w2, b2 + l2 === n);
+  });
+};
 var ue = (s) => new PD({ validate: s.validate, placeholder: s.placeholder, defaultValue: s.defaultValue, initialValue: s.initialValue, render() {
   const n = `${import_picocolors2.default.gray(a)}
 ${y2(this.state)}  ${s.message}
@@ -52195,6 +54995,38 @@ ${import_picocolors2.default.cyan(m2)}
 `;
   }
 } }).prompt();
+var de = (s) => {
+  const n = (t, i) => {
+    const r2 = t.label ?? String(t.value);
+    switch (i) {
+      case "selected":
+        return `${import_picocolors2.default.dim(r2)}`;
+      case "active":
+        return `${import_picocolors2.default.green(j2)} ${r2} ${t.hint ? import_picocolors2.default.dim(`(${t.hint})`) : ""}`;
+      case "cancelled":
+        return `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(r2))}`;
+      default:
+        return `${import_picocolors2.default.dim(R2)} ${import_picocolors2.default.dim(r2)}`;
+    }
+  };
+  return new jD({ options: s.options, initialValue: s.initialValue, render() {
+    const t = `${import_picocolors2.default.gray(a)}
+${y2(this.state)}  ${s.message}
+`;
+    switch (this.state) {
+      case "submit":
+        return `${t}${import_picocolors2.default.gray(a)}  ${n(this.options[this.cursor], "selected")}`;
+      case "cancel":
+        return `${t}${import_picocolors2.default.gray(a)}  ${n(this.options[this.cursor], "cancelled")}
+${import_picocolors2.default.gray(a)}`;
+      default:
+        return `${t}${import_picocolors2.default.cyan(a)}  ${k2({ cursor: this.cursor, options: this.options, maxItems: s.maxItems, style: (i, r2) => n(i, r2 ? "active" : "inactive") }).join(`
+${import_picocolors2.default.cyan(a)}  `)}
+${import_picocolors2.default.cyan(m2)}
+`;
+    }
+  } }).prompt();
+};
 var ve = (s = "") => {
   process.stdout.write(`${import_picocolors2.default.gray(m2)}  ${import_picocolors2.default.red(s)}
 
@@ -52280,24 +55112,24 @@ async function infoCommand(id, options) {
     }
     return;
   }
-  renderApp("info", { componentId: id });
+  await renderApp("info", { componentId: id });
 }
 
 // src/commands/install.ts
 var componentService7 = createComponentService();
 var libraryService6 = createLibraryService();
-function isLcscId3(id) {
+function isLcscId(id) {
   return /^C\d+$/i.test(id);
 }
 async function installCommand(id, options) {
-  if (id && !isLcscId3(id)) {
+  if (id && !isLcscId(id)) {
     v2.error(`"${id}" is not an LCSC part number (e.g., C2040).`);
     v2.info(`For EasyEDA community components, use: ${source_default.cyan(`jlc easyeda install ${id}`)}`);
     process.exit(1);
   }
   if (id && options.force) {
-    const spinner2 = L2();
-    spinner2.start(`Installing component ${id}...`);
+    const spinner = L2();
+    spinner.start(`Installing component ${id}...`);
     try {
       await libraryService6.ensureGlobalTables();
       const result = await libraryService6.install(id, {
@@ -52305,7 +55137,7 @@ async function installCommand(id, options) {
         include3d: options.include3d,
         force: true
       });
-      spinner2.stop(source_default.green("✓ Component installed"));
+      spinner.stop(source_default.green("✓ Component installed"));
       console.log();
       console.log(source_default.cyan("Symbol:    "), result.symbolRef);
       console.log(source_default.cyan("Footprint: "), result.footprintRef);
@@ -52316,22 +55148,20 @@ async function installCommand(id, options) {
       console.log();
       console.log(source_default.dim(`Library: ${result.files.symbolLibrary}`));
     } catch (error) {
-      spinner2.stop(source_default.red("✗ Installation failed"));
+      spinner.stop(source_default.red("✗ Installation failed"));
       v2.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
       process.exit(1);
     }
     return;
   }
   if (id) {
-    const spinner2 = L2();
-    spinner2.start(`Fetching component ${id}...`);
+    console.log(`Fetching component ${id}...`);
     try {
       const details = await componentService7.getDetails(id);
-      spinner2.stop("Component found");
-      renderApp("info", { componentId: id, component: details });
+      process.stdout.write("\x1B[1A\x1B[2K");
+      await renderApp("info", { componentId: id, component: details });
     } catch (error) {
-      spinner2.stop("Failed to fetch component");
-      v2.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+      console.error(`Failed to fetch component: ${error instanceof Error ? error.message : "Unknown error"}`);
       process.exit(1);
     }
     return;
@@ -52349,8 +55179,7 @@ async function installCommand(id, options) {
     ve("Installation cancelled");
     process.exit(0);
   }
-  const spinner = L2();
-  spinner.start(`Searching for "${query}"...`);
+  console.log(`Searching for "${query}"...`);
   const searchOptions = { limit: 20 };
   let results = await componentService7.search(query, searchOptions);
   results = results.sort((a2, b2) => {
@@ -52360,12 +55189,12 @@ async function installCommand(id, options) {
       return 1;
     return 0;
   });
-  spinner.stop(`Found ${results.length} results`);
   if (results.length === 0) {
-    v2.warn("No components found. Try a different search term.");
+    console.log("No components found. Try a different search term.");
     return;
   }
-  renderApp("search", { query, results });
+  process.stdout.write("\x1B[1A\x1B[2K");
+  await renderApp("search", { query, results });
 }
 
 // src/commands/library.ts
@@ -52397,7 +55226,41 @@ async function libraryCommand(options) {
     }
     return;
   }
-  renderApp("library", {});
+  await renderApp("library", {});
+}
+async function regenerateCommand(options) {
+  const include3d = options.include3d ?? true;
+  const components = await libraryService7.listInstalled({ projectPath: options.projectPath });
+  if (components.length === 0) {
+    v2.warn("No installed components found to regenerate.");
+    return;
+  }
+  v2.info(`Found ${source_default.cyan(components.length)} installed components to regenerate.`);
+  console.log();
+  let currentSpinner = null;
+  const result = await libraryService7.regenerate({
+    projectPath: options.projectPath,
+    include3d,
+    onProgress: (current, total, component, status, error) => {
+      if (status === "start") {
+        currentSpinner = L2();
+        currentSpinner.start(`[${current}/${total}] Regenerating ${source_default.cyan(component.name)} (${component.lcscId})...`);
+      } else if (status === "success") {
+        currentSpinner?.stop(source_default.green(`✓ [${current}/${total}] ${component.name} (${component.lcscId})`));
+      } else if (status === "error") {
+        currentSpinner?.stop(source_default.red(`✗ [${current}/${total}] ${component.name} (${component.lcscId}): ${error}`));
+      }
+    }
+  });
+  console.log();
+  v2.success(`Regeneration complete: ${source_default.green(result.success)} succeeded, ${source_default.red(result.failed)} failed`);
+  if (result.failed > 0) {
+    console.log();
+    v2.warn("Failed components:");
+    for (const comp of result.components.filter((c2) => c2.status === "failed")) {
+      console.log(source_default.red(`  • ${comp.name} (${comp.id}): ${comp.error}`));
+    }
+  }
 }
 
 // src/commands/easyeda.ts
@@ -52427,8 +55290,8 @@ Shutting down server...`);
 }
 async function easyedaInstallCommand(uuid, options) {
   if (uuid && options.force) {
-    const spinner2 = L2();
-    spinner2.start(`Installing EasyEDA component ${uuid}...`);
+    const spinner = L2();
+    spinner.start(`Installing EasyEDA component ${uuid}...`);
     try {
       await libraryService8.ensureGlobalTables();
       const result = await libraryService8.install(uuid, {
@@ -52436,7 +55299,7 @@ async function easyedaInstallCommand(uuid, options) {
         include3d: options.include3d,
         force: true
       });
-      spinner2.stop(source_default.green("✓ Component installed"));
+      spinner.stop(source_default.green("✓ Component installed"));
       console.log();
       console.log(source_default.cyan("Symbol:    "), result.symbolRef);
       console.log(source_default.cyan("Footprint: "), result.footprintRef);
@@ -52447,14 +55310,14 @@ async function easyedaInstallCommand(uuid, options) {
       console.log();
       console.log(source_default.dim(`Library: ${result.files.symbolLibrary}`));
     } catch (error) {
-      spinner2.stop(source_default.red("✗ Installation failed"));
+      spinner.stop(source_default.red("✗ Installation failed"));
       v2.error(`Error: ${error instanceof Error ? error.message : "Unknown error"}`);
       process.exit(1);
     }
     return;
   }
   if (uuid) {
-    renderApp("easyeda-info", { uuid });
+    await renderApp("easyeda-info", { uuid });
     return;
   }
   const query = await ue({
@@ -52470,19 +55333,197 @@ async function easyedaInstallCommand(uuid, options) {
     ve("Installation cancelled");
     process.exit(0);
   }
-  const spinner = L2();
-  spinner.start(`Searching EasyEDA community for "${query}"...`);
+  console.log(`Searching EasyEDA community for "${query}"...`);
   const searchOptions = {
     limit: 20,
     source: "easyeda-community"
   };
   const results = await componentService8.search(query, searchOptions);
-  spinner.stop(`Found ${results.length} results`);
   if (results.length === 0) {
-    v2.warn("No components found. Try a different search term.");
+    console.log("No components found. Try a different search term.");
     return;
   }
-  renderApp("search", { query, results });
+  process.stdout.write("\x1B[1A\x1B[2K");
+  await renderApp("search", { query, results });
+}
+
+// src/commands/validate.ts
+import { writeFileSync } from "fs";
+async function validateComponent(lcscCode, options) {
+  const startTime = Date.now();
+  const normalizedCode = lcscCode.replace(/^C/i, "");
+  const fullCode = `C${normalizedCode}`;
+  try {
+    const reference = await fetchReferenceSVG(fullCode);
+    const componentData = await easyedaClient.getComponentData(fullCode);
+    if (!componentData) {
+      return {
+        lcscCode: fullCode,
+        componentName: fullCode,
+        passed: false,
+        footprint: null,
+        symbol: null,
+        timestamp: new Date,
+        durationMs: Date.now() - startTime,
+        error: "Failed to fetch component data from EasyEDA"
+      };
+    }
+    let footprintResult = null;
+    let symbolResult = null;
+    if (options.footprint && reference.footprintSvg) {
+      const kicadContent = footprintConverter.convert(componentData, {});
+      const refData = extractFromReferenceSVG(reference.footprintSvg);
+      const genData = extractFromKiCadFootprint(kicadContent);
+      footprintResult = compareFootprints(refData, genData, {
+        sizeWarningsOnly: true,
+        positionTolerance: 50
+      });
+    }
+    if (options.symbol && reference.symbolSvg) {
+      const kicadContent = symbolConverter.convert(componentData, {
+        symbolName: componentData.info.name
+      });
+      const refData = extractFromReferenceSVG2(reference.symbolSvg);
+      const genData = extractFromKiCadSymbol(kicadContent);
+      symbolResult = compareSymbols(refData, genData, {
+        positionTolerance: 50
+      });
+    }
+    const passed = (!footprintResult || footprintResult.passed) && (!symbolResult || symbolResult.passed);
+    return {
+      lcscCode: fullCode,
+      componentName: componentData.info.name || fullCode,
+      passed,
+      footprint: footprintResult,
+      symbol: symbolResult,
+      timestamp: new Date,
+      durationMs: Date.now() - startTime
+    };
+  } catch (error) {
+    return {
+      lcscCode: fullCode,
+      componentName: fullCode,
+      passed: false,
+      footprint: null,
+      symbol: null,
+      timestamp: new Date,
+      durationMs: Date.now() - startTime,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function validateCommand(id, options) {
+  const validateFootprint = !options.symbolOnly;
+  const validateSymbol = !options.footprintOnly;
+  if (id && !options.category && !options.all) {
+    const spinner = L2();
+    spinner.start(`Validating ${id}...`);
+    const result = await validateComponent(id, {
+      footprint: validateFootprint,
+      symbol: validateSymbol
+    });
+    spinner.stop(result.passed ? source_default.green("✓ Validation passed") : source_default.red("✗ Validation failed"));
+    console.log();
+    console.log(source_default.bold(`${result.componentName} (${result.lcscCode})`));
+    console.log(source_default.dim(`Duration: ${result.durationMs}ms`));
+    console.log();
+    if (result.error) {
+      console.log(source_default.red(`Error: ${result.error}`));
+      process.exit(1);
+    }
+    if (result.footprint) {
+      console.log(formatComparisonResult(result.footprint));
+    }
+    if (result.symbol) {
+      console.log(formatSymbolComparisonResult(result.symbol));
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    }
+    if (options.html) {
+      const reference = await fetchReferenceSVG(id);
+      const componentData = await easyedaClient.getComponentData(id);
+      const svgs = {
+        footprintRef: reference.footprintSvg || undefined,
+        symbolRef: reference.symbolSvg || undefined
+      };
+      if (componentData) {
+        if (validateFootprint) {
+          const kicadFootprint = footprintConverter.convert(componentData, {});
+          svgs.footprintGen = renderFootprintSvg(kicadFootprint);
+        }
+        if (validateSymbol) {
+          const kicadSymbol = symbolConverter.convert(componentData, {
+            symbolName: componentData.info.name
+          });
+          svgs.symbolGen = renderSymbolSvg(kicadSymbol);
+        }
+      }
+      const html = generateValidationReport(result, svgs);
+      writeFileSync(options.html, html);
+      console.log(source_default.dim(`HTML report: ${options.html}`));
+    }
+    process.exit(result.passed ? 0 : 1);
+  }
+  let components = options.all ? getAllTestComponents() : options.category ? getTestComponentsByCategory(options.category) : [];
+  if (components.length === 0 && !id) {
+    const categories = getCategoryNames();
+    const selected = await de({
+      message: "Select a category to validate:",
+      options: [
+        { value: "all", label: "All categories" },
+        ...categories.map((c2) => ({ value: c2, label: c2 }))
+      ]
+    });
+    if (BD(selected)) {
+      ve("Validation cancelled");
+      process.exit(0);
+    }
+    components = selected === "all" ? getAllTestComponents() : getTestComponentsByCategory(selected);
+  }
+  components = components.filter((c2) => !c2.skip);
+  if (components.length === 0) {
+    v2.warn("No components to validate");
+    process.exit(0);
+  }
+  console.log(source_default.bold(`
+Validating ${components.length} components...
+`));
+  const results = [];
+  let passed = 0;
+  let failed = 0;
+  let errors = 0;
+  for (const component of components) {
+    process.stdout.write(`  ${component.lcsc.padEnd(12)} ${component.name.slice(0, 40).padEnd(42)} `);
+    const result = await validateComponent(component.lcsc, {
+      footprint: validateFootprint,
+      symbol: validateSymbol
+    });
+    results.push(result);
+    if (result.error) {
+      errors++;
+      console.log(source_default.yellow("⚠ ERROR"));
+    } else if (result.passed) {
+      passed++;
+      console.log(source_default.green("✓ PASS"));
+    } else {
+      failed++;
+      console.log(source_default.red("✗ FAIL"));
+    }
+  }
+  console.log();
+  console.log(source_default.bold("Summary:"));
+  console.log(`  ${source_default.green(`${passed} passed`)}  ${source_default.red(`${failed} failed`)}  ${source_default.yellow(`${errors} errors`)}`);
+  console.log();
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2));
+  }
+  if (options.html) {
+    const html = generateBatchReport(results, "JLC-CLI Validation Report");
+    writeFileSync(options.html, html);
+    console.log(source_default.dim(`HTML report: ${options.html}`));
+  }
+  process.exit(failed > 0 || errors > 0 ? 1 : 0);
 }
 
 // src/index.ts
@@ -52507,11 +55548,28 @@ program2.command("install [id]").description("Install component to KiCad librari
     force: options.force
   });
 });
-program2.command("library").description("View JLC-MCP library status and installed components").option("--json", "Output as JSON").action(async (options) => {
+var library = program2.command("library").description("JLC-MCP library management");
+library.command("status", { isDefault: true }).description("View library status and installed components").option("--json", "Output as JSON").action(async (options) => {
   await libraryCommand({
     json: options.json
   });
 });
+library.command("regenerate").description("Regenerate all installed components (refetch and reconvert symbols, footprints, 3D models)").option("-p, --project <path>", "Regenerate project-local library").option("--no-3d", "Skip 3D model download").action(async (options) => {
+  await regenerateCommand({
+    projectPath: options.project,
+    include3d: options["3d"]
+  });
+});
+program2.command("validate [id]").description("Validate footprint/symbol generation against JLCPCB reference").option("--footprint-only", "Only validate footprint").option("--symbol-only", "Only validate symbol").option("-c, --category <name>", "Validate all components in category").option("-a, --all", "Validate all test fixtures").option("--html <path>", "Output HTML report to file").option("--json", "Output as JSON").action(async (id, options) => {
+  await validateCommand(id, {
+    footprintOnly: options.footprintOnly,
+    symbolOnly: options.symbolOnly,
+    category: options.category,
+    all: options.all,
+    html: options.html,
+    json: options.json
+  });
+});
 var easyeda = program2.command("easyeda").description("EasyEDA community component browser");
 easyeda.command("search <query...>").description("Open browser-based component search").option("-p, --port <number>", "HTTP server port", "3847").action(async (queryParts, options) => {
   const query = queryParts.join(" ");