@tscircuit/cli 0.1.769 → 0.1.771

package/dist/main.js

@@ -73252,6 +73252,7 @@ var projectConfigSchema = z.object({
   build: z.object({
     circuitJson: z.boolean().optional(),
     kicadLibrary: z.boolean().optional(),
+    kicadPcm: z.boolean().optional(),
     previewImages: z.boolean().optional(),
     typescriptLibrary: z.boolean().optional()
   }).optional()
@@ -74127,7 +74128,7 @@ var getGlobalDepsInstallCommand = (packageManager, deps) => {
 import { execSync as execSync2 } from "node:child_process";
 var import_semver2 = __toESM2(require_semver2(), 1);
 // package.json
-var version = "0.1.768";
+var version = "0.1.770";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -172424,8 +172425,8 @@ var registerRemove = (program3) => {
 };
 
 // cli/build/register.ts
-import path45 from "node:path";
-import fs45 from "node:fs";
+import path47 from "node:path";
+import fs47 from "node:fs";
 
 // cli/build/build-file.ts
 import path35 from "node:path";
@@ -172711,7 +172712,8 @@ var applyCiBuildOptions = async ({
       site: options?.site ?? true,
       useCdnJavascript: options?.useCdnJavascript ?? true,
       ignoreErrors: options?.ignoreErrors ?? true,
-      kicadFootprintLibrary: options?.kicadFootprintLibrary ?? projectConfig2?.build?.kicadLibrary ?? false
+      kicadFootprintLibrary: options?.kicadFootprintLibrary ?? projectConfig2?.build?.kicadLibrary ?? false,
+      kicadPcm: options?.kicadPcm ?? projectConfig2?.build?.kicadPcm ?? false
     },
     handled: false
   };
@@ -173145,9 +173147,204 @@ var generateKicadProject = async ({
   };
 };
 
-// cli/build/transpile/index.ts
+// cli/build/build-kicad-pcm.ts
 import path43 from "node:path";
 import fs43 from "node:fs";
+
+// lib/shared/generate-pcm-assets.ts
+var import_jszip3 = __toESM2(require_lib4(), 1);
+import fs42 from "node:fs";
+import path42 from "node:path";
+import crypto3 from "node:crypto";
+async function generatePcmAssets(options) {
+  const {
+    packageName,
+    version: version2,
+    author,
+    description = `${packageName} - tscircuit component`,
+    descriptionFull = `A tscircuit component exported for use in KiCad. Visit https://tscircuit.com/${author}/${packageName} for more information.`,
+    license = "MIT",
+    kicadLibraryPath,
+    outputDir,
+    baseUrl
+  } = options;
+  const identifier = `com.tscircuit.${author}.${packageName}`.toLowerCase().replace(/[^a-z0-9.-]/g, "-").slice(0, 50);
+  fs42.mkdirSync(outputDir, { recursive: true });
+  const metadata = {
+    $schema: "https://go.kicad.org/pcm/schemas/v1",
+    name: `tscircuit ${packageName}`,
+    description: description.slice(0, 500),
+    description_full: descriptionFull.slice(0, 5000),
+    identifier,
+    type: "library",
+    author: {
+      name: author,
+      contact: {
+        web: `https://tscircuit.com/${author}`
+      }
+    },
+    license,
+    resources: {},
+    versions: [
+      {
+        version: version2,
+        status: "stable",
+        kicad_version: "7.0"
+      }
+    ]
+  };
+  const zipFileName = `${identifier}-${version2}.zip`;
+  const zipFilePath = path42.join(outputDir, zipFileName);
+  await createPcmZip({
+    kicadLibraryPath,
+    metadata,
+    outputPath: zipFilePath
+  });
+  const zipBuffer = fs42.readFileSync(zipFilePath);
+  const sha256 = crypto3.createHash("sha256").update(zipBuffer).digest("hex");
+  const zipSize = zipBuffer.length;
+  const downloadUrl = baseUrl ? `${baseUrl}/pcm/${zipFileName}` : `./${zipFileName}`;
+  const packagesJson = {
+    packages: [
+      {
+        identifier,
+        name: `tscircuit ${packageName}`,
+        description: description.slice(0, 500),
+        description_full: descriptionFull.slice(0, 5000),
+        type: "library",
+        author: {
+          name: author,
+          contact: {
+            web: `https://tscircuit.com/${author}`
+          }
+        },
+        license,
+        resources: {},
+        versions: [
+          {
+            version: version2,
+            status: "stable",
+            kicad_version: "7.0",
+            download_url: downloadUrl,
+            download_sha256: sha256,
+            download_size: zipSize,
+            install_size: zipSize * 2
+          }
+        ]
+      }
+    ]
+  };
+  const packagesJsonPath = path42.join(outputDir, "packages.json");
+  fs42.writeFileSync(packagesJsonPath, JSON.stringify(packagesJson, null, 2));
+  const packagesJsonBuffer = fs42.readFileSync(packagesJsonPath);
+  const packagesJsonSha256 = crypto3.createHash("sha256").update(packagesJsonBuffer).digest("hex");
+  const packagesJsonUrl = baseUrl ? `${baseUrl}/pcm/packages.json` : "./packages.json";
+  const repositoryJson = {
+    $schema: "https://go.kicad.org/pcm/schemas/v1",
+    name: `tscircuit ${author}/${packageName}`,
+    maintainer: {
+      name: author,
+      contact: {
+        web: `https://tscircuit.com/${author}`
+      }
+    },
+    packages: {
+      url: packagesJsonUrl,
+      sha256: packagesJsonSha256,
+      update_timestamp: Math.floor(Date.now() / 1000)
+    }
+  };
+  const repositoryJsonPath = path42.join(outputDir, "repository.json");
+  fs42.writeFileSync(repositoryJsonPath, JSON.stringify(repositoryJson, null, 2));
+  return {
+    outputDir,
+    repositoryJsonPath,
+    packagesJsonPath,
+    packageZipPath: zipFilePath,
+    packageZipSha256: sha256,
+    packageZipSize: zipSize
+  };
+}
+function addDirectoryToZip(opts) {
+  const { zip, dirPath, zipPath } = opts;
+  const entries = fs42.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path42.join(dirPath, entry.name);
+    const entryZipPath = zipPath ? `${zipPath}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      addDirectoryToZip({ zip, dirPath: fullPath, zipPath: entryZipPath });
+    } else {
+      const content = fs42.readFileSync(fullPath);
+      zip.file(entryZipPath, content);
+    }
+  }
+}
+async function createPcmZip(options) {
+  const { kicadLibraryPath, metadata, outputPath } = options;
+  const zip = new import_jszip3.default;
+  zip.file("metadata.json", JSON.stringify(metadata, null, 2));
+  const footprintsDir = path42.join(kicadLibraryPath, "footprints");
+  if (fs42.existsSync(footprintsDir)) {
+    addDirectoryToZip({ zip, dirPath: footprintsDir, zipPath: "footprints" });
+  }
+  const symbolsDir = path42.join(kicadLibraryPath, "symbols");
+  if (fs42.existsSync(symbolsDir)) {
+    addDirectoryToZip({ zip, dirPath: symbolsDir, zipPath: "symbols" });
+  }
+  const modelsDir = path42.join(kicadLibraryPath, "3dmodels");
+  if (fs42.existsSync(modelsDir)) {
+    addDirectoryToZip({ zip, dirPath: modelsDir, zipPath: "3dmodels" });
+  }
+  const zipBuffer = await zip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 9 }
+  });
+  fs42.writeFileSync(outputPath, zipBuffer);
+}
+
+// cli/build/build-kicad-pcm.ts
+async function buildKicadPcm({
+  entryFile,
+  projectDir,
+  distDir
+}) {
+  const packageJsonPath = path43.join(projectDir, "package.json");
+  if (!fs43.existsSync(packageJsonPath)) {
+    throw new Error("No package.json found for KiCad PCM generation");
+  }
+  const packageJson = JSON.parse(fs43.readFileSync(packageJsonPath, "utf-8"));
+  const packageName = packageJson.name?.split("/").pop()?.split(".").pop() || path43.basename(projectDir);
+  const version2 = packageJson.version || "1.0.0";
+  const author = getPackageAuthor(packageJson.name || "") || "tscircuit";
+  const description = packageJson.description || "";
+  const libraryName = path43.basename(projectDir);
+  const kicadLibOutputDir = path43.join(distDir, "kicad-library");
+  if (!fs43.existsSync(kicadLibOutputDir)) {
+    await convertToKicadLibrary({
+      filePath: entryFile,
+      libraryName,
+      outputDir: kicadLibOutputDir
+    });
+  }
+  const pcmOutputDir = path43.join(distDir, "pcm");
+  const baseUrl = `https://${author}--${packageName}.tscircuit.app`;
+  await generatePcmAssets({
+    packageName,
+    version: version2,
+    author,
+    description,
+    kicadLibraryPath: kicadLibOutputDir,
+    outputDir: pcmOutputDir,
+    baseUrl
+  });
+  console.log(`  KiCad PCM assets generated at ${kleur_default.dim(path43.relative(process.cwd(), pcmOutputDir))}`);
+  console.log(`  Repository URL: ${kleur_default.cyan(`${baseUrl}/pcm/repository.json`)}`);
+}
+
+// cli/build/transpile/index.ts
+import path45 from "node:path";
+import fs45 from "node:fs";
 import { rollup } from "rollup";
 import typescript from "@rollup/plugin-typescript";
 import resolve11 from "@rollup/plugin-node-resolve";
@@ -173156,11 +173353,11 @@ import json from "@rollup/plugin-json";
 import dts from "rollup-plugin-dts";
 
 // cli/build/transpile/static-asset-plugin.ts
-import fs42 from "node:fs";
-import path42 from "node:path";
+import fs44 from "node:fs";
+import path44 from "node:path";
 import { createHash } from "node:crypto";
 function normalizePathSeparators(filePath) {
-  return filePath.split(path42.sep).join("/");
+  return filePath.split(path44.sep).join("/");
 }
 var STATIC_ASSET_EXTENSIONS = new Set([
   ".glb",
@@ -173191,24 +173388,24 @@ var createStaticAssetPlugin = ({
   return {
     name: "tsci-static-assets",
     resolveId(source, importer) {
-      const ext = path42.extname(source).toLowerCase();
+      const ext = path44.extname(source).toLowerCase();
       if (!STATIC_ASSET_EXTENSIONS.has(ext))
         return null;
-      if (path42.isAbsolute(source)) {
-        return fs42.existsSync(source) ? { id: normalizePathSeparators(source), external: true } : null;
+      if (path44.isAbsolute(source)) {
+        return fs44.existsSync(source) ? { id: normalizePathSeparators(source), external: true } : null;
       }
       if (importer) {
-        const importerNative = importer.split("/").join(path42.sep);
-        const resolvedFromImporter = path42.resolve(path42.dirname(importerNative), source);
-        if (fs42.existsSync(resolvedFromImporter)) {
+        const importerNative = importer.split("/").join(path44.sep);
+        const resolvedFromImporter = path44.resolve(path44.dirname(importerNative), source);
+        if (fs44.existsSync(resolvedFromImporter)) {
           return {
             id: normalizePathSeparators(resolvedFromImporter),
             external: true
           };
         }
       }
-      const resolvedFromProject = path42.resolve(resolvedBaseUrl, source);
-      if (fs42.existsSync(resolvedFromProject)) {
+      const resolvedFromProject = path44.resolve(resolvedBaseUrl, source);
+      if (fs44.existsSync(resolvedFromProject)) {
         return {
           id: normalizePathSeparators(resolvedFromProject),
           external: true
@@ -173221,8 +173418,8 @@ var createStaticAssetPlugin = ({
           const wildcard = isWildcard ? source.slice(patternPrefix.length) : "";
           for (const target of targets) {
             const targetPath = isWildcard ? target.replace("*", wildcard) : target;
-            const resolvedTarget = path42.resolve(resolvedBaseUrl, targetPath);
-            if (fs42.existsSync(resolvedTarget)) {
+            const resolvedTarget = path44.resolve(resolvedBaseUrl, targetPath);
+            if (fs44.existsSync(resolvedTarget)) {
               return {
                 id: normalizePathSeparators(resolvedTarget),
                 external: true
@@ -173248,18 +173445,18 @@ var createStaticAssetPlugin = ({
         if (chunk.type !== "chunk")
           continue;
         for (const importedId of chunk.imports) {
-          const ext = path42.extname(importedId).toLowerCase();
+          const ext = path44.extname(importedId).toLowerCase();
           if (!STATIC_ASSET_EXTENSIONS.has(ext))
             continue;
           if (!copiedAssets.has(importedId)) {
-            const assetDir = path42.join(outputDir, "assets");
-            fs42.mkdirSync(assetDir, { recursive: true });
-            const nativePath = importedId.split("/").join(path42.sep);
-            const fileBuffer = fs42.readFileSync(nativePath);
+            const assetDir = path44.join(outputDir, "assets");
+            fs44.mkdirSync(assetDir, { recursive: true });
+            const nativePath = importedId.split("/").join(path44.sep);
+            const fileBuffer = fs44.readFileSync(nativePath);
             const hash = createHash("sha1").update(fileBuffer).digest("hex").slice(0, 8);
-            const fileName = `${path42.basename(importedId, ext)}-${hash}${ext}`;
-            const outputFilePath = path42.join(assetDir, fileName);
-            fs42.writeFileSync(outputFilePath, fileBuffer);
+            const fileName = `${path44.basename(importedId, ext)}-${hash}${ext}`;
+            const outputFilePath = path44.join(assetDir, fileName);
+            fs44.writeFileSync(outputFilePath, fileBuffer);
             copiedAssets.set(importedId, `./assets/${fileName}`);
             assetIdToOutputPath.set(importedId, `./assets/${fileName}`);
           }
@@ -173281,17 +173478,17 @@ function escapeRegExp(string) {
 
 // cli/build/transpile/index.ts
 var createExternalFunction = (projectDir, tsconfigPath) => (id) => {
-  if (id.startsWith(".") || id.startsWith("/") || path43.isAbsolute(id)) {
+  if (id.startsWith(".") || id.startsWith("/") || path45.isAbsolute(id)) {
     return false;
   }
   let baseUrl = projectDir;
   let pathMappings = {};
-  if (tsconfigPath && fs43.existsSync(tsconfigPath)) {
+  if (tsconfigPath && fs45.existsSync(tsconfigPath)) {
     try {
-      const tsconfigContent = fs43.readFileSync(tsconfigPath, "utf-8");
+      const tsconfigContent = fs45.readFileSync(tsconfigPath, "utf-8");
       const tsconfig = JSON.parse(tsconfigContent);
       if (tsconfig.compilerOptions?.baseUrl) {
-        baseUrl = path43.resolve(path43.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
+        baseUrl = path45.resolve(path45.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
       }
       if (tsconfig.compilerOptions?.paths) {
         pathMappings = tsconfig.compilerOptions.paths;
@@ -173305,17 +173502,17 @@ var createExternalFunction = (projectDir, tsconfigPath) => (id) => {
     }
   }
   const potentialPaths = [
-    path43.join(baseUrl, id),
-    path43.join(baseUrl, `${id}.ts`),
-    path43.join(baseUrl, `${id}.tsx`),
-    path43.join(baseUrl, `${id}.js`),
-    path43.join(baseUrl, `${id}.jsx`),
-    path43.join(baseUrl, id, "index.ts"),
-    path43.join(baseUrl, id, "index.tsx"),
-    path43.join(baseUrl, id, "index.js"),
-    path43.join(baseUrl, id, "index.jsx")
+    path45.join(baseUrl, id),
+    path45.join(baseUrl, `${id}.ts`),
+    path45.join(baseUrl, `${id}.tsx`),
+    path45.join(baseUrl, `${id}.js`),
+    path45.join(baseUrl, `${id}.jsx`),
+    path45.join(baseUrl, id, "index.ts"),
+    path45.join(baseUrl, id, "index.tsx"),
+    path45.join(baseUrl, id, "index.js"),
+    path45.join(baseUrl, id, "index.jsx")
   ];
-  if (potentialPaths.some((p4) => fs43.existsSync(p4))) {
+  if (potentialPaths.some((p4) => fs45.existsSync(p4))) {
     return false;
   }
   return true;
@@ -173326,17 +173523,17 @@ var transpileFile = async ({
   projectDir
 }) => {
   try {
-    fs43.mkdirSync(outputDir, { recursive: true });
-    const tsconfigPath = path43.join(projectDir, "tsconfig.json");
-    const hasTsConfig = fs43.existsSync(tsconfigPath);
+    fs45.mkdirSync(outputDir, { recursive: true });
+    const tsconfigPath = path45.join(projectDir, "tsconfig.json");
+    const hasTsConfig = fs45.existsSync(tsconfigPath);
     let tsconfigBaseUrl = projectDir;
     let tsconfigPathMappings;
     if (hasTsConfig) {
       try {
-        const tsconfigContent = fs43.readFileSync(tsconfigPath, "utf-8");
+        const tsconfigContent = fs45.readFileSync(tsconfigPath, "utf-8");
         const tsconfig = JSON.parse(tsconfigContent);
         if (tsconfig.compilerOptions?.baseUrl) {
-          tsconfigBaseUrl = path43.resolve(path43.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
+          tsconfigBaseUrl = path45.resolve(path45.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
         }
         if (tsconfig.compilerOptions?.paths) {
           tsconfigPathMappings = tsconfig.compilerOptions.paths;
@@ -173391,27 +173588,27 @@ var transpileFile = async ({
       external: createExternalFunction(projectDir, hasTsConfig ? tsconfigPath : undefined),
       plugins: getPlugins()
     });
-    const esmOutputPath = path43.join(outputDir, "index.js");
+    const esmOutputPath = path45.join(outputDir, "index.js");
     await esmBundle.write({
       file: esmOutputPath,
       format: "es",
       sourcemap: false
     });
-    console.log(`ESM bundle written to ${path43.relative(projectDir, esmOutputPath)}`);
+    console.log(`ESM bundle written to ${path45.relative(projectDir, esmOutputPath)}`);
     console.log("Building CommonJS bundle...");
     const cjsBundle = await rollup({
       input,
       external: createExternalFunction(projectDir, hasTsConfig ? tsconfigPath : undefined),
       plugins: getPlugins()
     });
-    const cjsOutputPath = path43.join(outputDir, "index.cjs");
+    const cjsOutputPath = path45.join(outputDir, "index.cjs");
     console.log("Writing CJS bundle to:", cjsOutputPath);
     await cjsBundle.write({
       file: cjsOutputPath,
       format: "cjs",
       sourcemap: false
     });
-    console.log(`CommonJS bundle written to ${path43.relative(projectDir, cjsOutputPath)}`);
+    console.log(`CommonJS bundle written to ${path45.relative(projectDir, cjsOutputPath)}`);
     console.log("Generating type declarations...");
     const dtsBundle = await rollup({
       input,
@@ -173436,9 +173633,9 @@ var transpileFile = async ({
     dtsContent = dtsContent.replace(/import \* as [\w_]+ from ['"]react\/jsx-runtime['"];?\s*\n?/g, "");
     dtsContent = dtsContent.replace(/[\w_]+\.JSX\.Element/g, "any");
     dtsContent = dtsContent.replace(/export\s*{\s*};\s*$/gm, "").trim();
-    const dtsOutputPath = path43.join(outputDir, "index.d.ts");
-    fs43.writeFileSync(dtsOutputPath, dtsContent);
-    console.log(`Type declarations written to ${path43.relative(projectDir, dtsOutputPath)}`);
+    const dtsOutputPath = path45.join(outputDir, "index.d.ts");
+    fs45.writeFileSync(dtsOutputPath, dtsContent);
+    console.log(`Type declarations written to ${path45.relative(projectDir, dtsOutputPath)}`);
     console.log(kleur_default.green("Transpilation complete!"));
     return true;
   } catch (err) {
@@ -173451,17 +173648,17 @@ var transpileFile = async ({
 };
 
 // cli/utils/validate-main-in-dist.ts
-import fs44 from "node:fs";
-import path44 from "node:path";
+import fs46 from "node:fs";
+import path46 from "node:path";
 var validateMainInDist = (projectDir, distDir) => {
-  const packageJsonPath = path44.join(projectDir, "package.json");
-  if (!fs44.existsSync(packageJsonPath))
+  const packageJsonPath = path46.join(projectDir, "package.json");
+  if (!fs46.existsSync(packageJsonPath))
     return;
-  const packageJson = JSON.parse(fs44.readFileSync(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(fs46.readFileSync(packageJsonPath, "utf-8"));
   if (typeof packageJson.main !== "string")
     return;
-  const resolvedMainPath = path44.resolve(projectDir, packageJson.main);
-  const isMainInDist = resolvedMainPath === distDir || resolvedMainPath.startsWith(`${distDir}${path44.sep}`);
+  const resolvedMainPath = path46.resolve(projectDir, packageJson.main);
+  const isMainInDist = resolvedMainPath === distDir || resolvedMainPath.startsWith(`${distDir}${path46.sep}`);
   if (!isMainInDist) {
     console.warn('When using transpilation, your package\'s "main" field should point inside the `dist/*` directory, usually to "dist/index.js"');
   }
@@ -173483,9 +173680,9 @@ async function getLatestTscircuitCdnUrl() {
 }
 
 // cli/build/register.ts
-var normalizeRelativePath = (projectDir, targetPath) => path45.relative(projectDir, targetPath).split(path45.sep).join("/");
+var normalizeRelativePath = (projectDir, targetPath) => path47.relative(projectDir, targetPath).split(path47.sep).join("/");
 var registerBuild = (program3) => {
-  program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").option("--ci", "Run install and optional prebuild/build commands (or default CI build)").option("--ignore-errors", "Do not exit with code 1 on errors").option("--ignore-warnings", "Do not log warnings").option("--disable-pcb", "Disable PCB outputs").option("--disable-parts-engine", "Disable the parts engine").option("--site", "Generate a static site in the dist directory").option("--transpile", "Transpile the entry file to JavaScript").option("--preview-images", "Generate preview images in the dist directory").option("--all-images", "Generate preview images for every successful build output").option("--kicad", "Generate KiCad project directories for each successful build output").option("--preview-gltf", "Generate a GLTF file from the preview entrypoint").option("--use-cdn-javascript", "Use CDN-hosted JavaScript instead of bundled standalone file for --site").action(async (file, options) => {
+  program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").option("--ci", "Run install and optional prebuild/build commands (or default CI build)").option("--ignore-errors", "Do not exit with code 1 on errors").option("--ignore-warnings", "Do not log warnings").option("--disable-pcb", "Disable PCB outputs").option("--disable-parts-engine", "Disable the parts engine").option("--site", "Generate a static site in the dist directory").option("--transpile", "Transpile the entry file to JavaScript").option("--preview-images", "Generate preview images in the dist directory").option("--all-images", "Generate preview images for every successful build output").option("--kicad", "Generate KiCad project directories for each successful build output").option("--preview-gltf", "Generate a GLTF file from the preview entrypoint").option("--kicad-pcm", "Generate KiCad PCM (Plugin and Content Manager) assets in dist/pcm").option("--use-cdn-javascript", "Use CDN-hosted JavaScript instead of bundled standalone file for --site").action(async (file, options) => {
     try {
       const {
         projectDir,
@@ -173516,8 +173713,8 @@ var registerBuild = (program3) => {
         }
         return config;
       })();
-      const distDir = path45.join(projectDir, "dist");
-      fs45.mkdirSync(distDir, { recursive: true });
+      const distDir = path47.join(projectDir, "dist");
+      fs47.mkdirSync(distDir, { recursive: true });
       console.log(`Building ${circuitFiles.length} file(s)...`);
       let hasErrors = false;
       const staticFileReferences = [];
@@ -173525,10 +173722,10 @@ var registerBuild = (program3) => {
       const kicadProjects = [];
       const shouldGenerateKicad = resolvedOptions?.kicad || resolvedOptions?.kicadFootprintLibrary;
       for (const filePath of circuitFiles) {
-        const relative10 = path45.relative(projectDir, filePath);
+        const relative10 = path47.relative(projectDir, filePath);
         console.log(`Building ${relative10}...`);
         const outputDirName = relative10.replace(/(\.board|\.circuit)?\.tsx$/, "");
-        const outputPath = path45.join(distDir, outputDirName, "circuit.json");
+        const outputPath = path47.join(distDir, outputDirName, "circuit.json");
         const buildOutcome = await buildFile(filePath, outputPath, projectDir, {
           ignoreErrors: resolvedOptions?.ignoreErrors,
           ignoreWarnings: resolvedOptions?.ignoreWarnings,
@@ -173542,17 +173739,17 @@ var registerBuild = (program3) => {
         if (!buildOutcome.ok) {
           hasErrors = true;
         } else if (resolvedOptions?.site) {
-          const normalizedSourcePath = relative10.split(path45.sep).join("/");
-          const relativeOutputPath = path45.join(outputDirName, "circuit.json");
-          const normalizedOutputPath = relativeOutputPath.split(path45.sep).join("/");
+          const normalizedSourcePath = relative10.split(path47.sep).join("/");
+          const relativeOutputPath = path47.join(outputDirName, "circuit.json");
+          const normalizedOutputPath = relativeOutputPath.split(path47.sep).join("/");
           staticFileReferences.push({
             filePath: normalizedSourcePath,
             fileStaticAssetUrl: `./${normalizedOutputPath}`
           });
         }
         if (buildOutcome.ok && shouldGenerateKicad && buildOutcome.circuitJson) {
-          const projectOutputDir = path45.join(distDir, outputDirName, "kicad");
-          const projectName = path45.basename(outputDirName);
+          const projectOutputDir = path47.join(distDir, outputDirName, "kicad");
+          const projectName = path47.basename(outputDirName);
           const project = await generateKicadProject({
             circuitJson: buildOutcome.circuitJson,
             outputDir: projectOutputDir,
@@ -173615,14 +173812,14 @@ var registerBuild = (program3) => {
         if (resolvedOptions?.useCdnJavascript) {
           standaloneScriptSrc = await getLatestTscircuitCdnUrl();
         } else {
-          fs45.writeFileSync(path45.join(distDir, "standalone.min.js"), standalone_min_default);
+          fs47.writeFileSync(path47.join(distDir, "standalone.min.js"), standalone_min_default);
         }
         const indexHtml = getStaticIndexHtmlFile({
           files: staticFileReferences,
           standaloneScriptSrc,
           defaultMainComponentPath: siteDefaultComponentPath ? normalizeRelativePath(projectDir, siteDefaultComponentPath) : undefined
         });
-        fs45.writeFileSync(path45.join(distDir, "index.html"), indexHtml);
+        fs47.writeFileSync(path47.join(distDir, "index.html"), indexHtml);
       }
       if (resolvedOptions?.kicadFootprintLibrary) {
         console.log("Generating KiCad footprint library...");
@@ -173637,15 +173834,15 @@ var registerBuild = (program3) => {
             process.exit(1);
           }
         } else {
-          const libraryName = path45.basename(projectDir);
-          const kicadLibOutputDir = path45.join(distDir, "kicad-library");
+          const libraryName = path47.basename(projectDir);
+          const kicadLibOutputDir = path47.join(distDir, "kicad-library");
           try {
             await convertToKicadLibrary({
               filePath: entryFile,
               libraryName,
               outputDir: kicadLibOutputDir
             });
-            console.log(`  KiCad library generated at ${kleur_default.dim(path45.relative(process.cwd(), kicadLibOutputDir))}`);
+            console.log(`  KiCad library generated at ${kleur_default.dim(path47.relative(process.cwd(), kicadLibOutputDir))}`);
           } catch (err) {
             console.error(`Error generating KiCad library: ${err instanceof Error ? err.message : err}`);
             if (!resolvedOptions?.ignoreErrors) {
@@ -173654,6 +173851,32 @@ var registerBuild = (program3) => {
           }
         }
       }
+      if (resolvedOptions?.kicadPcm) {
+        console.log("Generating KiCad PCM assets...");
+        const { mainEntrypoint: kicadEntrypoint } = await getBuildEntrypoints({
+          fileOrDir: file,
+          includeBoardFiles: false
+        });
+        if (!kicadEntrypoint) {
+          console.error("No entry file found for KiCad PCM generation. Make sure you have a lib/index.ts or set mainEntrypoint in tscircuit.config.json");
+          if (!resolvedOptions?.ignoreErrors) {
+            process.exit(1);
+          }
+        } else {
+          try {
+            await buildKicadPcm({
+              entryFile: kicadEntrypoint,
+              projectDir,
+              distDir
+            });
+          } catch (err) {
+            console.error(`Error generating KiCad PCM assets: ${err instanceof Error ? err.message : err}`);
+            if (!resolvedOptions?.ignoreErrors) {
+              process.exit(1);
+            }
+          }
+        }
+      }
       const successCount = builtFiles.filter((f2) => f2.ok).length;
       const failCount = builtFiles.length - successCount;
       const enabledOpts = [
@@ -173663,6 +173886,7 @@ var registerBuild = (program3) => {
         resolvedOptions?.allImages && "all-images",
         resolvedOptions?.kicad && "kicad",
         resolvedOptions?.kicadFootprintLibrary && "kicad-footprint-library",
+        resolvedOptions?.kicadPcm && "kicad-pcm",
         resolvedOptions?.previewGltf && "preview-gltf"
       ].filter(Boolean);
       console.log("");
@@ -173671,7 +173895,7 @@ var registerBuild = (program3) => {
       if (enabledOpts.length > 0) {
         console.log(`  Options   ${kleur_default.cyan(enabledOpts.join(", "))}`);
       }
-      console.log(`  Output    ${kleur_default.dim(path45.relative(process.cwd(), distDir) || "dist")}`);
+      console.log(`  Output    ${kleur_default.dim(path47.relative(process.cwd(), distDir) || "dist")}`);
       console.log(hasErrors ? kleur_default.yellow(`
 ⚠ Build completed with errors`) : kleur_default.green(`
 ✓ Done`));
@@ -173685,8 +173909,8 @@ var registerBuild = (program3) => {
 };
 
 // lib/shared/snapshot-project.ts
-import fs47 from "node:fs";
-import path46 from "node:path";
+import fs49 from "node:fs";
+import path48 from "node:path";
 import looksSame2 from "looks-same";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg3,
@@ -173697,7 +173921,7 @@ import { renderGLTFToPNGBufferFromGLBBuffer as renderGLTFToPNGBufferFromGLBBuffe
 
 // lib/shared/compare-images.ts
 import looksSame from "looks-same";
-import fs46 from "node:fs/promises";
+import fs48 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
   const { equal: equal2 } = await looksSame(buffer1, buffer2, {
     strict: false,
@@ -173713,7 +173937,7 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
         tolerance: 2
       });
     } else {
-      await fs46.writeFile(diffPath, buffer2);
+      await fs48.writeFile(diffPath, buffer2);
     }
   }
   return { equal: equal2 };
@@ -173738,7 +173962,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f2) => path46.resolve(projectDir, f2));
+  const resolvedPaths = filePaths.map((f2) => path48.resolve(projectDir, f2));
   const boardFiles = findBoardFiles({
     projectDir,
     ignore,
@@ -173752,7 +173976,7 @@ var snapshotProject = async ({
   const mismatches = [];
   let didUpdate = false;
   for (const file of boardFiles) {
-    const relativeFilePath = path46.relative(projectDir, file);
+    const relativeFilePath = path48.relative(projectDir, file);
     let circuitJson;
     let pcbSvg;
     let schSvg;
@@ -173807,17 +174031,17 @@ var snapshotProject = async ({
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         if (errorMessage.includes("No pcb_board found in circuit JSON")) {
-          const fileDir = path46.dirname(file);
-          const relativeDir = path46.relative(projectDir, fileDir);
-          const snapDir2 = snapshotsDirName ? path46.join(projectDir, snapshotsDirName, relativeDir) : path46.join(fileDir, "__snapshots__");
-          const base2 = path46.basename(file).replace(/\.tsx$/, "");
-          const snap3dPath = path46.join(snapDir2, `${base2}-3d.snap.png`);
-          const existing3dSnapshot = fs47.existsSync(snap3dPath);
+          const fileDir = path48.dirname(file);
+          const relativeDir = path48.relative(projectDir, fileDir);
+          const snapDir2 = snapshotsDirName ? path48.join(projectDir, snapshotsDirName, relativeDir) : path48.join(fileDir, "__snapshots__");
+          const base2 = path48.basename(file).replace(/\.tsx$/, "");
+          const snap3dPath = path48.join(snapDir2, `${base2}-3d.snap.png`);
+          const existing3dSnapshot = fs49.existsSync(snap3dPath);
           if (existing3dSnapshot) {
             onError(kleur_default.red(`
 ❌ Failed to generate 3D snapshot for ${relativeFilePath}:
 `) + kleur_default.red(`   No pcb_board found in circuit JSON
-`) + kleur_default.red(`   Existing snapshot: ${path46.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path48.relative(projectDir, snap3dPath)}
 `));
             return onExit2(1);
           } else {
@@ -173833,9 +174057,9 @@ var snapshotProject = async ({
         }
       }
     }
-    const snapDir = snapshotsDirName ? path46.join(projectDir, snapshotsDirName, path46.relative(projectDir, path46.dirname(file))) : path46.join(path46.dirname(file), "__snapshots__");
-    fs47.mkdirSync(snapDir, { recursive: true });
-    const base = path46.basename(file).replace(/\.tsx$/, "");
+    const snapDir = snapshotsDirName ? path48.join(projectDir, snapshotsDirName, path48.relative(projectDir, path48.dirname(file))) : path48.join(path48.dirname(file), "__snapshots__");
+    fs49.mkdirSync(snapDir, { recursive: true });
+    const base = path48.basename(file).replace(/\.tsx$/, "");
     const snapshots = [];
     if (pcbOnly || !schematicOnly) {
       snapshots.push({ type: "pcb", content: pcbSvg, isBinary: false });
@@ -173853,31 +174077,31 @@ var snapshotProject = async ({
     for (const snapshot of snapshots) {
       const { type } = snapshot;
       const is3d = type === "3d";
-      const snapPath = path46.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-      const existing = fs47.existsSync(snapPath);
+      const snapPath = path48.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+      const existing = fs49.existsSync(snapPath);
       const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
       const newContentForFile = snapshot.content;
       if (!existing) {
-        fs47.writeFileSync(snapPath, newContentForFile);
-        console.log("✅", kleur_default.gray(path46.relative(projectDir, snapPath)));
+        fs49.writeFileSync(snapPath, newContentForFile);
+        console.log("✅", kleur_default.gray(path48.relative(projectDir, snapPath)));
         didUpdate = true;
         continue;
       }
-      const oldContentBuffer = fs47.readFileSync(snapPath);
+      const oldContentBuffer = fs49.readFileSync(snapPath);
       const diffPath = snapPath.replace(is3d ? ".snap.png" : ".snap.svg", is3d ? ".diff.png" : ".diff.svg");
       const { equal: equal2 } = await compareAndCreateDiff(oldContentBuffer, newContentBuffer, diffPath);
       if (update) {
         if (!forceUpdate && equal2) {
-          console.log("✅", kleur_default.gray(path46.relative(projectDir, snapPath)));
+          console.log("✅", kleur_default.gray(path48.relative(projectDir, snapPath)));
         } else {
-          fs47.writeFileSync(snapPath, newContentForFile);
-          console.log("✅", kleur_default.gray(path46.relative(projectDir, snapPath)));
+          fs49.writeFileSync(snapPath, newContentForFile);
+          console.log("✅", kleur_default.gray(path48.relative(projectDir, snapPath)));
           didUpdate = true;
         }
       } else if (!equal2) {
         mismatches.push(`${snapPath} (diff: ${diffPath})`);
       } else {
-        console.log("✅", kleur_default.gray(path46.relative(projectDir, snapPath)));
+        console.log("✅", kleur_default.gray(path48.relative(projectDir, snapPath)));
       }
     }
   }
@@ -173916,22 +174140,22 @@ var registerSnapshot = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs48 from "node:fs";
-import path47 from "node:path";
+import fs50 from "node:fs";
+import path49 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path47.resolve(startDir);
-    while (dir !== path47.parse(dir).root) {
-      if (fs48.existsSync(path47.join(dir, ".git"))) {
+    let dir = path49.resolve(startDir);
+    while (dir !== path49.parse(dir).root) {
+      if (fs50.existsSync(path49.join(dir, ".git"))) {
         return dir;
       }
-      dir = path47.dirname(dir);
+      dir = path49.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path47.join(gitRoot, ".github", "workflows");
-  fs48.mkdirSync(workflowsDir, { recursive: true });
+  const workflowsDir = path49.join(gitRoot, ".github", "workflows");
+  fs50.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -173970,8 +174194,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path47.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path47.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path49.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path49.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -174009,8 +174233,8 @@ function registerAuthSetupNpmrc(program3) {
 }
 
 // cli/convert/register.ts
-import fs49 from "node:fs/promises";
-import path48 from "node:path";
+import fs51 from "node:fs/promises";
+import path50 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
 
 // node_modules/@tscircuit/mm/dist/index.js
@@ -174131,15 +174355,15 @@ var convertCircuitJsonToTscircuit = (circuitJson, opts) => {
 var registerConvert = (program3) => {
   program3.command("convert").description("Convert a .kicad_mod footprint to a tscircuit component").argument("<file>", "Path to the .kicad_mod file").option("-o, --output <path>", "Output TSX file path").option("-n, --name <component>", "Component name for export").action(async (file, options) => {
     try {
-      const inputPath = path48.resolve(file);
-      const modContent = await fs49.readFile(inputPath, "utf-8");
+      const inputPath = path50.resolve(file);
+      const modContent = await fs51.readFile(inputPath, "utf-8");
       const circuitJson = await parseKicadModToCircuitJson(modContent);
-      const componentName = options.name ?? path48.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path50.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path48.resolve(options.output) : path48.join(path48.dirname(inputPath), `${componentName}.tsx`);
-      await fs49.writeFile(outputPath, tsx);
+      const outputPath = options.output ? path50.resolve(options.output) : path50.join(path50.dirname(inputPath), `${componentName}.tsx`);
+      await fs51.writeFile(outputPath, tsx);
       console.log(kleur_default.green(`Converted ${outputPath}`));
     } catch (error) {
       console.error(kleur_default.red("Failed to convert footprint:"), error instanceof Error ? error.message : error);
@@ -174255,7 +174479,7 @@ var registerInstall = (program3) => {
 };
 
 // cli/transpile/register.ts
-import path49 from "node:path";
+import path51 from "node:path";
 var registerTranspile = (program3) => {
   program3.command("transpile").description("Transpile TypeScript/TSX to JavaScript (ESM, CommonJS, and type declarations)").argument("[file]", "Path to the entry file").action(async (file) => {
     try {
@@ -174263,7 +174487,7 @@ var registerTranspile = (program3) => {
         fileOrDir: file,
         includeBoardFiles: false
       });
-      const distDir = path49.join(projectDir, "dist");
+      const distDir = path51.join(projectDir, "dist");
       validateMainInDist(projectDir, distDir);
       console.log("Transpiling entry file...");
       const entryFile = mainEntrypoint || circuitFiles[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.769",
+  "version": "0.1.771",
   "main": "dist/main.js",
   "devDependencies": {
     "@babel/standalone": "^7.26.9",

package/types/tscircuit.config.schema.json

@@ -60,6 +60,10 @@
           "type": "boolean",
           "description": "Enable KiCad library output in build."
         },
+        "kicadPcm": {
+          "type": "boolean",
+          "description": "Enable KiCad PCM (Plugin and Content Manager) assets output in build."
+        },
         "previewImages": {
           "type": "boolean",
           "description": "Enable preview image outputs in build."