@tscircuit/cli 0.1.800 → 0.1.801

package/dist/main.js

@@ -73386,6 +73386,7 @@ var projectConfigSchema = z.object({
   prebuildCommand: z.string().optional(),
   buildCommand: z.string().optional(),
   kicadLibraryEntrypointPath: z.string().optional(),
+  kicadLibraryName: z.string().optional(),
   alwaysUseLatestTscircuitOnCloud: z.boolean().optional(),
   build: z.object({
     circuitJson: z.boolean().optional(),
@@ -74266,7 +74267,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.799";
+var version = "0.1.800";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -172826,8 +172827,8 @@ var registerRemove = (program3) => {
 };
 
 // cli/build/register.ts
-import path49 from "node:path";
-import fs49 from "node:fs";
+import path50 from "node:path";
+import fs50 from "node:fs";
 
 // cli/build/build-file.ts
 import path36 from "node:path";
@@ -173556,8 +173557,8 @@ var generateKicadProject = async ({
 };
 
 // cli/build/build-kicad-pcm.ts
-import path44 from "node:path";
-import fs44 from "node:fs";
+import path45 from "node:path";
+import fs45 from "node:fs";
 
 // lib/shared/generate-pcm-assets.ts
 var import_jszip3 = __toESM2(require_lib4(), 1);
@@ -173569,19 +173570,20 @@ async function generatePcmAssets(options) {
     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.`,
+    description = "",
+    descriptionFull = `Visit https://tscircuit.com/${author}/${packageName} for more information.`,
     license = "MIT",
     kicadLibraryPath,
     outputDir,
-    baseUrl
+    baseUrl,
+    displayName = `${author}/${packageName}`
   } = options;
   const identifier = `com.tscircuit.${author}.${packageName}`.toLowerCase().replace(/[^a-z0-9.-]/g, "-").slice(0, 50);
   fs43.mkdirSync(outputDir, { recursive: true });
   console.log("Creating metadata.json...");
   const metadata = {
     $schema: "https://go.kicad.org/pcm/schemas/v1",
-    name: `tscircuit ${packageName}`,
+    name: displayName,
     description: description.slice(0, 500),
     description_full: descriptionFull.slice(0, 5000),
     identifier,
@@ -173617,7 +173619,7 @@ async function generatePcmAssets(options) {
     packages: [
       {
         identifier,
-        name: `tscircuit ${packageName}`,
+        name: displayName,
         description: description.slice(0, 500),
         description_full: descriptionFull.slice(0, 5000),
         type: "library",
@@ -173650,7 +173652,7 @@ async function generatePcmAssets(options) {
   const packagesJsonUrl = baseUrl ? `${baseUrl}/pcm/packages.json` : "./packages.json";
   const repositoryJson = {
     $schema: "https://go.kicad.org/pcm/schemas/v1",
-    name: `tscircuit ${author}/${packageName}`,
+    name: displayName,
     maintainer: {
       name: author,
       contact: {
@@ -173716,24 +173718,46 @@ async function createPcmZip(options) {
   fs43.writeFileSync(outputPath, zipBuffer);
 }
 
+// lib/utils/resolve-kicad-library-name.ts
+import path44 from "node:path";
+import fs44 from "node:fs";
+function resolveKicadLibraryName({
+  projectDir
+}) {
+  const projectConfig2 = loadProjectConfig(projectDir);
+  if (projectConfig2?.kicadLibraryName) {
+    return projectConfig2.kicadLibraryName;
+  }
+  const packageJsonPath = path44.join(projectDir, "package.json");
+  if (fs44.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs44.readFileSync(packageJsonPath, "utf-8"));
+    const unscopedName = getUnscopedPackageName(packageJson.name || "");
+    if (unscopedName) {
+      return unscopedName.replace("@tsci/", "").replace(/\./g, "-");
+    }
+  }
+  throw new Error(`Couldn't resolve KiCad library name. Please set kicadLibraryName in tscircuit.config.json or add the "name" field to package.json`);
+}
+
 // cli/build/build-kicad-pcm.ts
 async function buildKicadPcm({
   entryFile,
   projectDir,
   distDir
 }) {
-  const packageJsonPath = path44.join(projectDir, "package.json");
-  if (!fs44.existsSync(packageJsonPath)) {
+  const packageJsonPath = path45.join(projectDir, "package.json");
+  if (!fs45.existsSync(packageJsonPath)) {
     throw new Error("No package.json found for KiCad PCM generation");
   }
-  const packageJson = JSON.parse(fs44.readFileSync(packageJsonPath, "utf-8"));
-  const packageName = packageJson.name?.split("/").pop()?.split(".").pop() || path44.basename(projectDir);
+  const packageJson = JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8"));
+  const projectConfig2 = loadProjectConfig(projectDir);
+  const packageName = packageJson.name?.split("/").pop()?.split(".").pop() || path45.basename(projectDir);
   const version2 = packageJson.version || "1.0.0";
   const author = getPackageAuthor(packageJson.name || "") || "tscircuit";
   const description = packageJson.description || "";
-  const libraryName = path44.basename(projectDir);
-  const kicadLibOutputDir = path44.join(distDir, "kicad-library");
-  if (!fs44.existsSync(kicadLibOutputDir)) {
+  const libraryName = resolveKicadLibraryName({ projectDir });
+  const kicadLibOutputDir = path45.join(distDir, "kicad-library");
+  if (!fs45.existsSync(kicadLibOutputDir)) {
     console.log("Converting to KiCad library...");
     await convertToKicadLibrary({
       filePath: entryFile,
@@ -173741,7 +173765,7 @@ async function buildKicadPcm({
       outputDir: kicadLibOutputDir
     });
   }
-  const pcmOutputDir = path44.join(distDir, "pcm");
+  const pcmOutputDir = path45.join(distDir, "pcm");
   const envDeploymentUrl = process.env.TSCIRCUIT_DEPLOYMENT_URL?.replace(/\/+$/, "");
   const baseUrl = envDeploymentUrl ?? `https://${author}--${packageName}.tscircuit.app`;
   console.log("Generating PCM assets...");
@@ -173752,15 +173776,16 @@ async function buildKicadPcm({
     description,
     kicadLibraryPath: kicadLibOutputDir,
     outputDir: pcmOutputDir,
-    baseUrl
+    baseUrl,
+    displayName: projectConfig2?.kicadLibraryName || undefined
   });
-  console.log(`  KiCad PCM assets generated at ${kleur_default.dim(path44.relative(process.cwd(), pcmOutputDir))}`);
+  console.log(`  KiCad PCM assets generated at ${kleur_default.dim(path45.relative(process.cwd(), pcmOutputDir))}`);
   console.log(`  Repository URL: ${kleur_default.cyan(`${baseUrl}/pcm/repository.json`)}`);
 }
 
 // cli/build/transpile/index.ts
-import path46 from "node:path";
-import fs46 from "node:fs";
+import path47 from "node:path";
+import fs47 from "node:fs";
 import { rollup } from "rollup";
 import typescript from "@rollup/plugin-typescript";
 import resolve11 from "@rollup/plugin-node-resolve";
@@ -173769,11 +173794,11 @@ import json from "@rollup/plugin-json";
 import dts from "rollup-plugin-dts";
 
 // cli/build/transpile/static-asset-plugin.ts
-import fs45 from "node:fs";
-import path45 from "node:path";
+import fs46 from "node:fs";
+import path46 from "node:path";
 import { createHash } from "node:crypto";
 function normalizePathSeparators(filePath) {
-  return filePath.split(path45.sep).join("/");
+  return filePath.split(path46.sep).join("/");
 }
 var STATIC_ASSET_EXTENSIONS = new Set([
   ".glb",
@@ -173804,24 +173829,24 @@ var createStaticAssetPlugin = ({
   return {
     name: "tsci-static-assets",
     resolveId(source, importer) {
-      const ext = path45.extname(source).toLowerCase();
+      const ext = path46.extname(source).toLowerCase();
       if (!STATIC_ASSET_EXTENSIONS.has(ext))
         return null;
-      if (path45.isAbsolute(source)) {
-        return fs45.existsSync(source) ? { id: normalizePathSeparators(source), external: true } : null;
+      if (path46.isAbsolute(source)) {
+        return fs46.existsSync(source) ? { id: normalizePathSeparators(source), external: true } : null;
       }
       if (importer) {
-        const importerNative = importer.split("/").join(path45.sep);
-        const resolvedFromImporter = path45.resolve(path45.dirname(importerNative), source);
-        if (fs45.existsSync(resolvedFromImporter)) {
+        const importerNative = importer.split("/").join(path46.sep);
+        const resolvedFromImporter = path46.resolve(path46.dirname(importerNative), source);
+        if (fs46.existsSync(resolvedFromImporter)) {
           return {
             id: normalizePathSeparators(resolvedFromImporter),
             external: true
           };
         }
       }
-      const resolvedFromProject = path45.resolve(resolvedBaseUrl, source);
-      if (fs45.existsSync(resolvedFromProject)) {
+      const resolvedFromProject = path46.resolve(resolvedBaseUrl, source);
+      if (fs46.existsSync(resolvedFromProject)) {
         return {
           id: normalizePathSeparators(resolvedFromProject),
           external: true
@@ -173834,8 +173859,8 @@ var createStaticAssetPlugin = ({
           const wildcard = isWildcard ? source.slice(patternPrefix.length) : "";
           for (const target of targets) {
             const targetPath = isWildcard ? target.replace("*", wildcard) : target;
-            const resolvedTarget = path45.resolve(resolvedBaseUrl, targetPath);
-            if (fs45.existsSync(resolvedTarget)) {
+            const resolvedTarget = path46.resolve(resolvedBaseUrl, targetPath);
+            if (fs46.existsSync(resolvedTarget)) {
               return {
                 id: normalizePathSeparators(resolvedTarget),
                 external: true
@@ -173861,18 +173886,18 @@ var createStaticAssetPlugin = ({
         if (chunk.type !== "chunk")
           continue;
         for (const importedId of chunk.imports) {
-          const ext = path45.extname(importedId).toLowerCase();
+          const ext = path46.extname(importedId).toLowerCase();
           if (!STATIC_ASSET_EXTENSIONS.has(ext))
             continue;
           if (!copiedAssets.has(importedId)) {
-            const assetDir = path45.join(outputDir, "assets");
-            fs45.mkdirSync(assetDir, { recursive: true });
-            const nativePath = importedId.split("/").join(path45.sep);
-            const fileBuffer = fs45.readFileSync(nativePath);
+            const assetDir = path46.join(outputDir, "assets");
+            fs46.mkdirSync(assetDir, { recursive: true });
+            const nativePath = importedId.split("/").join(path46.sep);
+            const fileBuffer = fs46.readFileSync(nativePath);
             const hash = createHash("sha1").update(fileBuffer).digest("hex").slice(0, 8);
-            const fileName = `${path45.basename(importedId, ext)}-${hash}${ext}`;
-            const outputFilePath = path45.join(assetDir, fileName);
-            fs45.writeFileSync(outputFilePath, fileBuffer);
+            const fileName = `${path46.basename(importedId, ext)}-${hash}${ext}`;
+            const outputFilePath = path46.join(assetDir, fileName);
+            fs46.writeFileSync(outputFilePath, fileBuffer);
             copiedAssets.set(importedId, `./assets/${fileName}`);
             assetIdToOutputPath.set(importedId, `./assets/${fileName}`);
           }
@@ -173894,17 +173919,17 @@ function escapeRegExp(string) {
 
 // cli/build/transpile/index.ts
 var createExternalFunction = (projectDir, tsconfigPath) => (id) => {
-  if (id.startsWith(".") || id.startsWith("/") || path46.isAbsolute(id)) {
+  if (id.startsWith(".") || id.startsWith("/") || path47.isAbsolute(id)) {
     return false;
   }
   let baseUrl = projectDir;
   let pathMappings = {};
-  if (tsconfigPath && fs46.existsSync(tsconfigPath)) {
+  if (tsconfigPath && fs47.existsSync(tsconfigPath)) {
     try {
-      const tsconfigContent = fs46.readFileSync(tsconfigPath, "utf-8");
+      const tsconfigContent = fs47.readFileSync(tsconfigPath, "utf-8");
       const tsconfig = JSON.parse(tsconfigContent);
       if (tsconfig.compilerOptions?.baseUrl) {
-        baseUrl = path46.resolve(path46.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
+        baseUrl = path47.resolve(path47.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
       }
       if (tsconfig.compilerOptions?.paths) {
         pathMappings = tsconfig.compilerOptions.paths;
@@ -173918,17 +173943,17 @@ var createExternalFunction = (projectDir, tsconfigPath) => (id) => {
     }
   }
   const potentialPaths = [
-    path46.join(baseUrl, id),
-    path46.join(baseUrl, `${id}.ts`),
-    path46.join(baseUrl, `${id}.tsx`),
-    path46.join(baseUrl, `${id}.js`),
-    path46.join(baseUrl, `${id}.jsx`),
-    path46.join(baseUrl, id, "index.ts"),
-    path46.join(baseUrl, id, "index.tsx"),
-    path46.join(baseUrl, id, "index.js"),
-    path46.join(baseUrl, id, "index.jsx")
+    path47.join(baseUrl, id),
+    path47.join(baseUrl, `${id}.ts`),
+    path47.join(baseUrl, `${id}.tsx`),
+    path47.join(baseUrl, `${id}.js`),
+    path47.join(baseUrl, `${id}.jsx`),
+    path47.join(baseUrl, id, "index.ts"),
+    path47.join(baseUrl, id, "index.tsx"),
+    path47.join(baseUrl, id, "index.js"),
+    path47.join(baseUrl, id, "index.jsx")
   ];
-  if (potentialPaths.some((p4) => fs46.existsSync(p4))) {
+  if (potentialPaths.some((p4) => fs47.existsSync(p4))) {
     return false;
   }
   return true;
@@ -173939,17 +173964,17 @@ var transpileFile = async ({
   projectDir
 }) => {
   try {
-    fs46.mkdirSync(outputDir, { recursive: true });
-    const tsconfigPath = path46.join(projectDir, "tsconfig.json");
-    const hasTsConfig = fs46.existsSync(tsconfigPath);
+    fs47.mkdirSync(outputDir, { recursive: true });
+    const tsconfigPath = path47.join(projectDir, "tsconfig.json");
+    const hasTsConfig = fs47.existsSync(tsconfigPath);
     let tsconfigBaseUrl = projectDir;
     let tsconfigPathMappings;
     if (hasTsConfig) {
       try {
-        const tsconfigContent = fs46.readFileSync(tsconfigPath, "utf-8");
+        const tsconfigContent = fs47.readFileSync(tsconfigPath, "utf-8");
         const tsconfig = JSON.parse(tsconfigContent);
         if (tsconfig.compilerOptions?.baseUrl) {
-          tsconfigBaseUrl = path46.resolve(path46.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
+          tsconfigBaseUrl = path47.resolve(path47.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
         }
         if (tsconfig.compilerOptions?.paths) {
           tsconfigPathMappings = tsconfig.compilerOptions.paths;
@@ -174004,27 +174029,27 @@ var transpileFile = async ({
       external: createExternalFunction(projectDir, hasTsConfig ? tsconfigPath : undefined),
       plugins: getPlugins()
     });
-    const esmOutputPath = path46.join(outputDir, "index.js");
+    const esmOutputPath = path47.join(outputDir, "index.js");
     await esmBundle.write({
       file: esmOutputPath,
       format: "es",
       sourcemap: false
     });
-    console.log(`ESM bundle written to ${path46.relative(projectDir, esmOutputPath)}`);
+    console.log(`ESM bundle written to ${path47.relative(projectDir, esmOutputPath)}`);
     console.log("Building CommonJS bundle...");
     const cjsBundle = await rollup({
       input,
       external: createExternalFunction(projectDir, hasTsConfig ? tsconfigPath : undefined),
       plugins: getPlugins()
     });
-    const cjsOutputPath = path46.join(outputDir, "index.cjs");
+    const cjsOutputPath = path47.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 ${path46.relative(projectDir, cjsOutputPath)}`);
+    console.log(`CommonJS bundle written to ${path47.relative(projectDir, cjsOutputPath)}`);
     console.log("Generating type declarations...");
     const dtsBundle = await rollup({
       input,
@@ -174049,9 +174074,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 = path46.join(outputDir, "index.d.ts");
-    fs46.writeFileSync(dtsOutputPath, dtsContent);
-    console.log(`Type declarations written to ${path46.relative(projectDir, dtsOutputPath)}`);
+    const dtsOutputPath = path47.join(outputDir, "index.d.ts");
+    fs47.writeFileSync(dtsOutputPath, dtsContent);
+    console.log(`Type declarations written to ${path47.relative(projectDir, dtsOutputPath)}`);
     console.log(kleur_default.green("Transpilation complete!"));
     return true;
   } catch (err) {
@@ -174064,17 +174089,17 @@ var transpileFile = async ({
 };
 
 // cli/utils/validate-main-in-dist.ts
-import fs47 from "node:fs";
-import path47 from "node:path";
+import fs48 from "node:fs";
+import path48 from "node:path";
 var validateMainInDist = (projectDir, distDir) => {
-  const packageJsonPath = path47.join(projectDir, "package.json");
-  if (!fs47.existsSync(packageJsonPath))
+  const packageJsonPath = path48.join(projectDir, "package.json");
+  if (!fs48.existsSync(packageJsonPath))
     return;
-  const packageJson = JSON.parse(fs47.readFileSync(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(fs48.readFileSync(packageJsonPath, "utf-8"));
   if (typeof packageJson.main !== "string")
     return;
-  const resolvedMainPath = path47.resolve(projectDir, packageJson.main);
-  const isMainInDist = resolvedMainPath === distDir || resolvedMainPath.startsWith(`${distDir}${path47.sep}`);
+  const resolvedMainPath = path48.resolve(projectDir, packageJson.main);
+  const isMainInDist = resolvedMainPath === distDir || resolvedMainPath.startsWith(`${distDir}${path48.sep}`);
   if (!isMainInDist) {
     console.warn('When using transpilation, your package\'s "main" field should point inside the `dist/*` directory, usually to "dist/index.js"');
   }
@@ -174096,19 +174121,19 @@ async function getLatestTscircuitCdnUrl() {
 }
 
 // cli/build/worker-pool.ts
-import path48 from "node:path";
-import fs48 from "node:fs";
+import path49 from "node:path";
+import fs49 from "node:fs";
 import { Worker } from "node:worker_threads";
 var getWorkerEntrypointPath = () => {
-  const tsPath = path48.join(import.meta.dir, "build-worker-entrypoint.ts");
-  if (fs48.existsSync(tsPath)) {
+  const tsPath = path49.join(import.meta.dir, "build-worker-entrypoint.ts");
+  if (fs49.existsSync(tsPath)) {
     return tsPath;
   }
-  const jsBundledPath = path48.join(import.meta.dir, "build", "build-worker-entrypoint.js");
-  if (fs48.existsSync(jsBundledPath)) {
+  const jsBundledPath = path49.join(import.meta.dir, "build", "build-worker-entrypoint.js");
+  if (fs49.existsSync(jsBundledPath)) {
     return jsBundledPath;
   }
-  return path48.join(import.meta.dir, "build-worker-entrypoint.js");
+  return path49.join(import.meta.dir, "build-worker-entrypoint.js");
 };
 
 class WorkerPool {
@@ -174264,7 +174289,7 @@ async function buildFilesWithWorkerPool(options) {
 }
 
 // cli/build/register.ts
-var normalizeRelativePath = (projectDir, targetPath) => path49.relative(projectDir, targetPath).split(path49.sep).join("/");
+var normalizeRelativePath = (projectDir, targetPath) => path50.relative(projectDir, targetPath).split(path50.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("--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").option("--concurrency <number>", "Number of files to build in parallel (default: 1)", "1").action(async (file, options) => {
     try {
@@ -174297,8 +174322,8 @@ var registerBuild = (program3) => {
         }
         return config;
       })();
-      const distDir = path49.join(projectDir, "dist");
-      fs49.mkdirSync(distDir, { recursive: true });
+      const distDir = path50.join(projectDir, "dist");
+      fs50.mkdirSync(distDir, { recursive: true });
       const concurrencyValue = Math.max(1, Number.parseInt(resolvedOptions?.concurrency || "1", 10));
       if (concurrencyValue > 1) {
         console.log(`Building ${circuitFiles.length} file(s) with concurrency ${concurrencyValue}...`);
@@ -174316,7 +174341,7 @@ var registerBuild = (program3) => {
         platformConfig: platformConfig2
       };
       const processBuildResult = async (filePath, outputPath, buildOutcome) => {
-        const relative10 = path49.relative(projectDir, filePath);
+        const relative10 = path50.relative(projectDir, filePath);
         const outputDirName = relative10.replace(/(\.board|\.circuit)?\.tsx$/, "");
         builtFiles.push({
           sourcePath: filePath,
@@ -174326,9 +174351,9 @@ var registerBuild = (program3) => {
         if (!buildOutcome.ok) {
           hasErrors = true;
         } else if (resolvedOptions?.site) {
-          const normalizedSourcePath = relative10.split(path49.sep).join("/");
-          const relativeOutputPath = path49.join(outputDirName, "circuit.json");
-          const normalizedOutputPath = relativeOutputPath.split(path49.sep).join("/");
+          const normalizedSourcePath = relative10.split(path50.sep).join("/");
+          const relativeOutputPath = path50.join(outputDirName, "circuit.json");
+          const normalizedOutputPath = relativeOutputPath.split(path50.sep).join("/");
           staticFileReferences.push({
             filePath: normalizedSourcePath,
             fileStaticAssetUrl: `./${normalizedOutputPath}`
@@ -174336,12 +174361,12 @@ var registerBuild = (program3) => {
         }
         if (buildOutcome.ok && shouldGenerateKicad) {
           let circuitJson = buildOutcome.circuitJson;
-          if (!circuitJson && fs49.existsSync(outputPath)) {
-            circuitJson = JSON.parse(fs49.readFileSync(outputPath, "utf-8"));
+          if (!circuitJson && fs50.existsSync(outputPath)) {
+            circuitJson = JSON.parse(fs50.readFileSync(outputPath, "utf-8"));
           }
           if (circuitJson) {
-            const projectOutputDir = path49.join(distDir, outputDirName, "kicad");
-            const projectName = path49.basename(outputDirName);
+            const projectOutputDir = path50.join(distDir, outputDirName, "kicad");
+            const projectName = path50.basename(outputDirName);
             const project = await generateKicadProject({
               circuitJson,
               outputDir: projectOutputDir,
@@ -174357,19 +174382,19 @@ var registerBuild = (program3) => {
       };
       const buildSequentially = async () => {
         for (const filePath of circuitFiles) {
-          const relative10 = path49.relative(projectDir, filePath);
+          const relative10 = path50.relative(projectDir, filePath);
           console.log(`Building ${relative10}...`);
           const outputDirName = relative10.replace(/(\.board|\.circuit)?\.tsx$/, "");
-          const outputPath = path49.join(distDir, outputDirName, "circuit.json");
+          const outputPath = path50.join(distDir, outputDirName, "circuit.json");
           const buildOutcome = await buildFile(filePath, outputPath, projectDir, buildOptions);
           await processBuildResult(filePath, outputPath, buildOutcome);
         }
       };
       const buildWithWorkers = async () => {
         const filesToBuild = circuitFiles.map((filePath) => {
-          const relative10 = path49.relative(projectDir, filePath);
+          const relative10 = path50.relative(projectDir, filePath);
           const outputDirName = relative10.replace(/(\.board|\.circuit)?\.tsx$/, "");
-          const outputPath = path49.join(distDir, outputDirName, "circuit.json");
+          const outputPath = path50.join(distDir, outputDirName, "circuit.json");
           return { filePath, outputPath };
         });
         await buildFilesWithWorkerPool({
@@ -174383,7 +174408,7 @@ var registerBuild = (program3) => {
             }
           },
           onJobComplete: async (result) => {
-            const relative10 = path49.relative(projectDir, result.filePath);
+            const relative10 = path50.relative(projectDir, result.filePath);
             if (result.ok) {
               console.log(kleur_default.green(`✓ ${relative10}`));
             } else {
@@ -174453,14 +174478,14 @@ var registerBuild = (program3) => {
         if (resolvedOptions?.useCdnJavascript) {
           standaloneScriptSrc = await getLatestTscircuitCdnUrl();
         } else {
-          fs49.writeFileSync(path49.join(distDir, "standalone.min.js"), standalone_min_default);
+          fs50.writeFileSync(path50.join(distDir, "standalone.min.js"), standalone_min_default);
         }
         const indexHtml = getStaticIndexHtmlFile({
           files: staticFileReferences,
           standaloneScriptSrc,
           defaultMainComponentPath: siteDefaultComponentPath ? normalizeRelativePath(projectDir, siteDefaultComponentPath) : undefined
         });
-        fs49.writeFileSync(path49.join(distDir, "index.html"), indexHtml);
+        fs50.writeFileSync(path50.join(distDir, "index.html"), indexHtml);
       }
       if (resolvedOptions?.kicadFootprintLibrary) {
         console.log("Generating KiCad footprint library...");
@@ -174479,15 +174504,15 @@ var registerBuild = (program3) => {
             process.exit(1);
           }
         } else {
-          const libraryName = path49.basename(projectDir);
-          const kicadLibOutputDir = path49.join(distDir, "kicad-library");
+          const libraryName = resolveKicadLibraryName({ projectDir });
+          const kicadLibOutputDir = path50.join(distDir, "kicad-library");
           try {
             await convertToKicadLibrary({
               filePath: entryFile,
               libraryName,
               outputDir: kicadLibOutputDir
             });
-            console.log(`  KiCad library generated at ${kleur_default.dim(path49.relative(process.cwd(), kicadLibOutputDir))}`);
+            console.log(`  KiCad library generated at ${kleur_default.dim(path50.relative(process.cwd(), kicadLibOutputDir))}`);
           } catch (err) {
             console.error(`Error generating KiCad library: ${err instanceof Error ? err.message : err}`);
             if (!resolvedOptions?.ignoreErrors) {
@@ -174545,7 +174570,7 @@ var registerBuild = (program3) => {
       if (enabledOpts.length > 0) {
         console.log(`  Options   ${kleur_default.cyan(enabledOpts.join(", "))}`);
       }
-      console.log(`  Output    ${kleur_default.dim(path49.relative(process.cwd(), distDir) || "dist")}`);
+      console.log(`  Output    ${kleur_default.dim(path50.relative(process.cwd(), distDir) || "dist")}`);
       console.log(hasErrors ? kleur_default.yellow(`
 ⚠ Build completed with errors`) : kleur_default.green(`
 ✓ Done`));
@@ -174559,8 +174584,8 @@ var registerBuild = (program3) => {
 };
 
 // lib/shared/snapshot-project.ts
-import fs51 from "node:fs";
-import path50 from "node:path";
+import fs52 from "node:fs";
+import path51 from "node:path";
 import looksSame2 from "looks-same";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg3,
@@ -174571,7 +174596,7 @@ import { renderGLTFToPNGBufferFromGLBBuffer as renderGLTFToPNGBufferFromGLBBuffe
 
 // lib/shared/compare-images.ts
 import looksSame from "looks-same";
-import fs50 from "node:fs/promises";
+import fs51 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
   const { equal: equal2 } = await looksSame(buffer1, buffer2, {
     strict: false,
@@ -174587,7 +174612,7 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
         tolerance: 2
       });
     } else {
-      await fs50.writeFile(diffPath, buffer2);
+      await fs51.writeFile(diffPath, buffer2);
     }
   }
   return { equal: equal2 };
@@ -174612,7 +174637,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f2) => path50.resolve(projectDir, f2));
+  const resolvedPaths = filePaths.map((f2) => path51.resolve(projectDir, f2));
   const boardFiles = findBoardFiles({
     projectDir,
     ignore,
@@ -174626,7 +174651,7 @@ var snapshotProject = async ({
   const mismatches = [];
   let didUpdate = false;
   for (const file of boardFiles) {
-    const relativeFilePath = path50.relative(projectDir, file);
+    const relativeFilePath = path51.relative(projectDir, file);
     let circuitJson;
     let pcbSvg;
     let schSvg;
@@ -174681,17 +174706,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 = path50.dirname(file);
-          const relativeDir = path50.relative(projectDir, fileDir);
-          const snapDir2 = snapshotsDirName ? path50.join(projectDir, snapshotsDirName, relativeDir) : path50.join(fileDir, "__snapshots__");
-          const base2 = path50.basename(file).replace(/\.tsx$/, "");
-          const snap3dPath = path50.join(snapDir2, `${base2}-3d.snap.png`);
-          const existing3dSnapshot = fs51.existsSync(snap3dPath);
+          const fileDir = path51.dirname(file);
+          const relativeDir = path51.relative(projectDir, fileDir);
+          const snapDir2 = snapshotsDirName ? path51.join(projectDir, snapshotsDirName, relativeDir) : path51.join(fileDir, "__snapshots__");
+          const base2 = path51.basename(file).replace(/\.tsx$/, "");
+          const snap3dPath = path51.join(snapDir2, `${base2}-3d.snap.png`);
+          const existing3dSnapshot = fs52.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: ${path50.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path51.relative(projectDir, snap3dPath)}
 `));
             return onExit2(1);
           } else {
@@ -174707,9 +174732,9 @@ var snapshotProject = async ({
         }
       }
     }
-    const snapDir = snapshotsDirName ? path50.join(projectDir, snapshotsDirName, path50.relative(projectDir, path50.dirname(file))) : path50.join(path50.dirname(file), "__snapshots__");
-    fs51.mkdirSync(snapDir, { recursive: true });
-    const base = path50.basename(file).replace(/\.tsx$/, "");
+    const snapDir = snapshotsDirName ? path51.join(projectDir, snapshotsDirName, path51.relative(projectDir, path51.dirname(file))) : path51.join(path51.dirname(file), "__snapshots__");
+    fs52.mkdirSync(snapDir, { recursive: true });
+    const base = path51.basename(file).replace(/\.tsx$/, "");
     const snapshots = [];
     if (pcbOnly || !schematicOnly) {
       snapshots.push({ type: "pcb", content: pcbSvg, isBinary: false });
@@ -174727,31 +174752,31 @@ var snapshotProject = async ({
     for (const snapshot of snapshots) {
       const { type } = snapshot;
       const is3d = type === "3d";
-      const snapPath = path50.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-      const existing = fs51.existsSync(snapPath);
+      const snapPath = path51.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+      const existing = fs52.existsSync(snapPath);
       const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
       const newContentForFile = snapshot.content;
       if (!existing) {
-        fs51.writeFileSync(snapPath, newContentForFile);
-        console.log("✅", kleur_default.gray(path50.relative(projectDir, snapPath)));
+        fs52.writeFileSync(snapPath, newContentForFile);
+        console.log("✅", kleur_default.gray(path51.relative(projectDir, snapPath)));
         didUpdate = true;
         continue;
       }
-      const oldContentBuffer = fs51.readFileSync(snapPath);
+      const oldContentBuffer = fs52.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(path50.relative(projectDir, snapPath)));
+          console.log("✅", kleur_default.gray(path51.relative(projectDir, snapPath)));
         } else {
-          fs51.writeFileSync(snapPath, newContentForFile);
-          console.log("✅", kleur_default.gray(path50.relative(projectDir, snapPath)));
+          fs52.writeFileSync(snapPath, newContentForFile);
+          console.log("✅", kleur_default.gray(path51.relative(projectDir, snapPath)));
           didUpdate = true;
         }
       } else if (!equal2) {
         mismatches.push(`${snapPath} (diff: ${diffPath})`);
       } else {
-        console.log("✅", kleur_default.gray(path50.relative(projectDir, snapPath)));
+        console.log("✅", kleur_default.gray(path51.relative(projectDir, snapPath)));
       }
     }
   }
@@ -174790,22 +174815,22 @@ var registerSnapshot = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs52 from "node:fs";
-import path51 from "node:path";
+import fs53 from "node:fs";
+import path52 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path51.resolve(startDir);
-    while (dir !== path51.parse(dir).root) {
-      if (fs52.existsSync(path51.join(dir, ".git"))) {
+    let dir = path52.resolve(startDir);
+    while (dir !== path52.parse(dir).root) {
+      if (fs53.existsSync(path52.join(dir, ".git"))) {
         return dir;
       }
-      dir = path51.dirname(dir);
+      dir = path52.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path51.join(gitRoot, ".github", "workflows");
-  fs52.mkdirSync(workflowsDir, { recursive: true });
+  const workflowsDir = path52.join(gitRoot, ".github", "workflows");
+  fs53.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -174844,8 +174869,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path51.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path51.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path52.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path52.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -174883,8 +174908,8 @@ function registerAuthSetupNpmrc(program3) {
 }
 
 // cli/convert/register.ts
-import fs53 from "node:fs/promises";
-import path52 from "node:path";
+import fs54 from "node:fs/promises";
+import path53 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
 
 // node_modules/@tscircuit/mm/dist/index.js
@@ -175005,15 +175030,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 = path52.resolve(file);
-      const modContent = await fs53.readFile(inputPath, "utf-8");
+      const inputPath = path53.resolve(file);
+      const modContent = await fs54.readFile(inputPath, "utf-8");
       const circuitJson = await parseKicadModToCircuitJson(modContent);
-      const componentName = options.name ?? path52.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path53.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path52.resolve(options.output) : path52.join(path52.dirname(inputPath), `${componentName}.tsx`);
-      await fs53.writeFile(outputPath, tsx);
+      const outputPath = options.output ? path53.resolve(options.output) : path53.join(path53.dirname(inputPath), `${componentName}.tsx`);
+      await fs54.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);
@@ -175129,7 +175154,7 @@ var registerInstall = (program3) => {
 };
 
 // cli/transpile/register.ts
-import path53 from "node:path";
+import path54 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 {
@@ -175137,7 +175162,7 @@ var registerTranspile = (program3) => {
         fileOrDir: file,
         includeBoardFiles: false
       });
-      const distDir = path53.join(projectDir, "dist");
+      const distDir = path54.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.800",
+  "version": "0.1.801",
   "main": "dist/main.js",
   "devDependencies": {
     "@babel/standalone": "^7.26.9",

package/types/tscircuit.config.schema.json

@@ -52,6 +52,10 @@
       "type": "string",
       "description": "Entry file for KiCad footprint library generation."
     },
+    "kicadLibraryName": {
+      "type": "string",
+      "description": "Name for the generated KiCad library. Falls back to package.json name, then directory name."
+    },
     "alwaysUseLatestTscircuitOnCloud": {
       "type": "boolean",
       "description": "Always use the latest TSCircuit version when building on the cloud."