@tscircuit/cli 0.1.730 → 0.1.732

package/dist/main.js

@@ -73245,6 +73245,7 @@ var projectConfigSchema = z.object({
   ignoredFiles: z.array(z.string()).optional(),
   includeBoardFiles: z.array(z.string()).optional(),
   snapshotsDir: z.string().optional(),
+  prebuildCommand: z.string().optional(),
   buildCommand: z.string().optional(),
   build: z.object({
     circuitJson: z.boolean().optional(),
@@ -74124,7 +74125,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.729";
+var version = "0.1.731";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -84815,11 +84816,12 @@ var availableGlobalConfigKeys = [
 var availableProjectConfigKeys = [
   "mainEntrypoint",
   "previewComponentPath",
+  "prebuildCommand",
   "buildCommand"
 ];
 var registerConfigSet = (program3) => {
   const configCommand = program3.commands.find((c) => c.name() === "config");
-  configCommand.command("set").description("Set a configuration value (global or project-specific)").argument("<key>", "Configuration key (e.g., alwaysCloneWithAuthorName, mainEntrypoint, previewComponentPath, buildCommand)").argument("<value>", "Value to set").action((key, value) => {
+  configCommand.command("set").description("Set a configuration value (global or project-specific)").argument("<key>", "Configuration key (e.g., alwaysCloneWithAuthorName, mainEntrypoint, previewComponentPath, prebuildCommand, buildCommand)").argument("<value>", "Value to set").action((key, value) => {
     if (availableGlobalConfigKeys.some((k) => k === key)) {
       if (key === "alwaysCloneWithAuthorName") {
         const booleanValue = value.toLowerCase() === "true";
@@ -84828,7 +84830,7 @@ var registerConfigSet = (program3) => {
       }
     } else if (availableProjectConfigKeys.some((k) => k === key)) {
       const projectDir = process.cwd();
-      if (key === "mainEntrypoint" || key === "previewComponentPath" || key === "buildCommand") {
+      if (key === "mainEntrypoint" || key === "previewComponentPath" || key === "prebuildCommand" || key === "buildCommand") {
         const projectConfig = loadProjectConfig(projectDir) ?? {};
         projectConfig[key] = value;
         if (saveProjectConfig(projectConfig, projectDir)) {
@@ -187290,8 +187292,8 @@ var registerRemove = (program3) => {
 };
 
 // cli/build/register.ts
-import path42 from "node:path";
-import fs41 from "node:fs";
+import path44 from "node:path";
+import fs43 from "node:fs";
 
 // cli/build/build-file.ts
 import path34 from "node:path";
@@ -187425,21 +187427,156 @@ var logTypeReexportHint = (error, entryFilePath) => {
 `));
 };
 
-// cli/build/get-build-entrypoints.ts
+// cli/build/build-ci.ts
+import { execSync as execSync3 } from "node:child_process";
+
+// lib/shared/install-project-dependencies.ts
+import fs35 from "node:fs";
+import path36 from "node:path";
+
+// lib/shared/collect-tsci-dependencies.ts
 import fs34 from "node:fs";
 import path35 from "node:path";
+var DEFAULT_PATTERNS = ["**/*.{ts,tsx,js,jsx}"];
+var DEFAULT_IGNORES = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.tsci/**"
+];
+var IMPORT_PATTERN = /["'`](@tsci\/[A-Za-z0-9._/-]+)["'`]/g;
+function collectTsciDependencies({
+  cwd = process.cwd(),
+  patterns = DEFAULT_PATTERNS,
+  ignore = DEFAULT_IGNORES
+} = {}) {
+  const searchRoot = path35.resolve(cwd);
+  const files = globbySync(patterns, {
+    cwd: searchRoot,
+    absolute: true,
+    ignore,
+    gitignore: true
+  });
+  const dependencies2 = new Set;
+  for (const filePath of files) {
+    try {
+      const fileContents = fs34.readFileSync(filePath, "utf-8");
+      let match;
+      while (true) {
+        match = IMPORT_PATTERN.exec(fileContents);
+        if (match === null)
+          break;
+        dependencies2.add(match[1]);
+      }
+    } catch (error) {}
+  }
+  return Array.from(dependencies2);
+}
+
+// lib/shared/install-project-dependencies.ts
+async function installProjectDependencies({
+  cwd = process.cwd()
+} = {}) {
+  const projectRoot = path36.resolve(cwd);
+  const packageJsonPath = path36.join(projectRoot, "package.json");
+  const npmrcPath = path36.join(projectRoot, ".npmrc");
+  const packageManager = getPackageManager();
+  if (!fs35.existsSync(projectRoot)) {
+    throw new Error(`Directory not found: ${projectRoot}`);
+  }
+  let packageJsonCreated = false;
+  if (!fs35.existsSync(packageJsonPath)) {
+    console.log("No package.json found. Generating a new one.");
+    generatePackageJson(projectRoot);
+    packageJsonCreated = true;
+  } else {
+    console.log("Found existing package.json.");
+  }
+  if (!fs35.existsSync(npmrcPath)) {
+    console.log("Creating .npmrc with tscircuit registry configuration.");
+    fs35.writeFileSync(npmrcPath, "@tsci:registry=https://npm.tscircuit.com");
+  }
+  const packageJson = JSON.parse(fs35.readFileSync(packageJsonPath, "utf-8"));
+  if (packageJsonCreated) {
+    const tsciDependencies = collectTsciDependencies({ cwd: projectRoot });
+    if (tsciDependencies.length > 0) {
+      packageJson.dependencies = packageJson.dependencies || {};
+      for (const dependency of tsciDependencies) {
+        if (!packageJson.dependencies[dependency]) {
+          packageJson.dependencies[dependency] = "latest";
+        }
+      }
+      console.log(`Added ${tsciDependencies.length} @tsci dependencies to package.json.`);
+    } else {
+      console.log("No @tsci dependencies detected in circuit files.");
+    }
+  }
+  fs35.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`);
+  console.log(`Installing dependencies using ${kleur_default.bold(packageManager.name)}...`);
+  try {
+    packageManager.installAll({ cwd: projectRoot });
+    console.log("Dependencies installed successfully.");
+  } catch (error) {
+    console.warn("Failed to automatically install dependencies.");
+    console.warn(`Please run \`${packageManager.getInstallAllCommand()}\` manually.`);
+    handleRegistryAuthError({ error, projectDir: projectRoot });
+    throw error;
+  }
+}
+
+// cli/build/build-ci.ts
+var runCommand = (command, cwd) => {
+  console.log(kleur_default.cyan(`Running: ${command}`));
+  execSync3(command, { stdio: "inherit", cwd });
+};
+var applyCiBuildOptions = async ({
+  projectDir,
+  options
+}) => {
+  if (!options?.ci) {
+    return { resolvedOptions: options, handled: false };
+  }
+  await installProjectDependencies({ cwd: projectDir });
+  const projectConfig = loadProjectConfig(projectDir);
+  const prebuildCommand = projectConfig?.prebuildCommand?.trim();
+  const buildCommand = projectConfig?.buildCommand?.trim();
+  if (prebuildCommand) {
+    runCommand(prebuildCommand, projectDir);
+  }
+  if (buildCommand) {
+    runCommand(buildCommand, projectDir);
+    return { resolvedOptions: options, handled: true };
+  }
+  return {
+    resolvedOptions: {
+      ...options,
+      previewImages: options?.previewImages ?? true,
+      transpile: options?.transpile ?? true,
+      site: options?.site ?? true,
+      useCdnJavascript: options?.useCdnJavascript ?? true,
+      ignoreErrors: options?.ignoreErrors ?? true
+    },
+    handled: false
+  };
+};
+
+// cli/build/get-build-entrypoints.ts
+import fs36 from "node:fs";
+import path37 from "node:path";
 var isSubPath2 = (maybeChild, maybeParent) => {
-  const relative10 = path35.relative(maybeParent, maybeChild);
-  return relative10 === "" || !relative10.startsWith("..") && !path35.isAbsolute(relative10);
+  const relative10 = path37.relative(maybeParent, maybeChild);
+  return relative10 === "" || !relative10.startsWith("..") && !path37.isAbsolute(relative10);
 };
 var findProjectRoot = (startDir) => {
   let currentDir = startDir;
-  while (currentDir !== path35.dirname(currentDir)) {
-    const packageJsonPath = path35.join(currentDir, "package.json");
-    if (fs34.existsSync(packageJsonPath)) {
+  while (currentDir !== path37.dirname(currentDir)) {
+    const packageJsonPath = path37.join(currentDir, "package.json");
+    if (fs36.existsSync(packageJsonPath)) {
       return currentDir;
     }
-    currentDir = path35.dirname(currentDir);
+    currentDir = path37.dirname(currentDir);
   }
   return startDir;
 };
@@ -187448,11 +187585,11 @@ async function getBuildEntrypoints({
   rootDir = process.cwd(),
   includeBoardFiles = true
 }) {
-  const resolvedRoot = path35.resolve(rootDir);
+  const resolvedRoot = path37.resolve(rootDir);
   const includeBoardFilePatterns = includeBoardFiles ? getBoardFilePatterns(resolvedRoot) : [];
   const buildFromProjectDir = async () => {
     const projectConfig = loadProjectConfig(resolvedRoot);
-    const resolvedPreviewComponentPath = projectConfig?.previewComponentPath ? path35.resolve(resolvedRoot, projectConfig.previewComponentPath) : undefined;
+    const resolvedPreviewComponentPath = projectConfig?.previewComponentPath ? path37.resolve(resolvedRoot, projectConfig.previewComponentPath) : undefined;
     if (includeBoardFiles) {
       const files = findBoardFiles({ projectDir: resolvedRoot });
       if (files.length > 0) {
@@ -187487,10 +187624,10 @@ async function getBuildEntrypoints({
     };
   };
   if (fileOrDir) {
-    const resolved = path35.resolve(resolvedRoot, fileOrDir);
-    if (fs34.existsSync(resolved) && fs34.statSync(resolved).isDirectory()) {
+    const resolved = path37.resolve(resolvedRoot, fileOrDir);
+    if (fs36.existsSync(resolved) && fs36.statSync(resolved).isDirectory()) {
       const projectConfig2 = loadProjectConfig(resolvedRoot);
-      const resolvedPreviewComponentPath2 = projectConfig2?.previewComponentPath ? path35.resolve(resolvedRoot, projectConfig2.previewComponentPath) : undefined;
+      const resolvedPreviewComponentPath2 = projectConfig2?.previewComponentPath ? path37.resolve(resolvedRoot, projectConfig2.previewComponentPath) : undefined;
       if (includeBoardFiles) {
         const circuitFiles = findBoardFiles({
           projectDir: resolvedRoot,
@@ -187522,10 +187659,10 @@ async function getBuildEntrypoints({
         circuitFiles: mainEntrypoint ? [mainEntrypoint] : []
       };
     }
-    const fileDir = path35.dirname(resolved);
+    const fileDir = path37.dirname(resolved);
     const projectDir = findProjectRoot(fileDir);
     const projectConfig = loadProjectConfig(projectDir);
-    const resolvedPreviewComponentPath = projectConfig?.previewComponentPath ? path35.resolve(projectDir, projectConfig.previewComponentPath) : undefined;
+    const resolvedPreviewComponentPath = projectConfig?.previewComponentPath ? path37.resolve(projectDir, projectConfig.previewComponentPath) : undefined;
     return {
       projectDir,
       previewComponentPath: resolvedPreviewComponentPath,
@@ -187567,8 +187704,8 @@ ${scriptBlock}      <script src="https://cdn.tailwindcss.com"></script>
 };
 
 // cli/build/build-preview-images.ts
-import fs35 from "node:fs";
-import path36 from "node:path";
+import fs37 from "node:fs";
+import path38 from "node:path";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg2,
   convertCircuitJsonToSchematicSvg as convertCircuitJsonToSchematicSvg2
@@ -187644,21 +187781,21 @@ var generatePreviewAssets = async ({
   outputDir,
   distDir
 }) => {
-  const prefixRelative = path36.relative(distDir, outputDir) || ".";
+  const prefixRelative = path38.relative(distDir, outputDir) || ".";
   const prefix = prefixRelative === "." ? "" : `[${prefixRelative}] `;
   let circuitJson;
   try {
-    const circuitJsonRaw = fs35.readFileSync(build.outputPath, "utf-8");
+    const circuitJsonRaw = fs37.readFileSync(build.outputPath, "utf-8");
     circuitJson = JSON.parse(circuitJsonRaw);
   } catch (error) {
     console.error(`${prefix}Failed to read circuit JSON:`, error);
     return;
   }
-  fs35.mkdirSync(outputDir, { recursive: true });
+  fs37.mkdirSync(outputDir, { recursive: true });
   try {
     console.log(`${prefix}Generating PCB SVG...`);
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson);
-    fs35.writeFileSync(path36.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
+    fs37.writeFileSync(path38.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
     console.log(`${prefix}Written pcb.svg`);
   } catch (error) {
     console.error(`${prefix}Failed to generate PCB SVG:`, error);
@@ -187666,7 +187803,7 @@ var generatePreviewAssets = async ({
   try {
     console.log(`${prefix}Generating schematic SVG...`);
     const schematicSvg = convertCircuitJsonToSchematicSvg2(circuitJson);
-    fs35.writeFileSync(path36.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
+    fs37.writeFileSync(path38.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
     console.log(`${prefix}Written schematic.svg`);
   } catch (error) {
     console.error(`${prefix}Failed to generate schematic SVG:`, error);
@@ -187683,7 +187820,7 @@ var generatePreviewAssets = async ({
       camPos: [10, 10, 10],
       lookAt: [0, 0, 0]
     });
-    fs35.writeFileSync(path36.join(outputDir, "3d.png"), Buffer.from(normalizeToUint8Array(pngBuffer)));
+    fs37.writeFileSync(path38.join(outputDir, "3d.png"), Buffer.from(normalizeToUint8Array(pngBuffer)));
     console.log(`${prefix}Written 3d.png`);
   } catch (error) {
     console.error(`${prefix}Failed to generate 3D PNG:`, error);
@@ -187698,14 +187835,14 @@ var buildPreviewImages = async ({
 }) => {
   const successfulBuilds = builtFiles.filter((file) => file.ok);
   const previewEntrypoint = previewComponentPath || mainEntrypoint;
-  const resolvedPreviewEntrypoint = previewEntrypoint ? path36.resolve(previewEntrypoint) : undefined;
+  const resolvedPreviewEntrypoint = previewEntrypoint ? path38.resolve(previewEntrypoint) : undefined;
   if (allImages) {
     if (successfulBuilds.length === 0) {
       console.warn("No successful build output available for preview image generation.");
       return;
     }
     for (const build of successfulBuilds) {
-      const outputDir = path36.dirname(build.outputPath);
+      const outputDir = path38.dirname(build.outputPath);
       await generatePreviewAssets({
         build,
         outputDir,
@@ -187716,7 +187853,7 @@ var buildPreviewImages = async ({
   }
   const previewBuild = (() => {
     if (resolvedPreviewEntrypoint) {
-      const match = successfulBuilds.find((built) => path36.resolve(built.sourcePath) === resolvedPreviewEntrypoint);
+      const match = successfulBuilds.find((built) => path38.resolve(built.sourcePath) === resolvedPreviewEntrypoint);
       if (match)
         return match;
     }
@@ -187734,8 +187871,8 @@ var buildPreviewImages = async ({
 };
 
 // cli/build/build-preview-gltf.ts
-import fs36 from "node:fs";
-import path37 from "node:path";
+import fs38 from "node:fs";
+import path39 from "node:path";
 import { convertCircuitJsonToGltf as convertCircuitJsonToGltf3 } from "circuit-json-to-gltf";
 var buildPreviewGltf = async ({
   builtFiles,
@@ -187745,10 +187882,10 @@ var buildPreviewGltf = async ({
 }) => {
   const successfulBuilds = builtFiles.filter((file) => file.ok);
   const previewEntrypoint = previewComponentPath || mainEntrypoint;
-  const resolvedPreviewEntrypoint = previewEntrypoint ? path37.resolve(previewEntrypoint) : undefined;
+  const resolvedPreviewEntrypoint = previewEntrypoint ? path39.resolve(previewEntrypoint) : undefined;
   const previewBuild = (() => {
     if (resolvedPreviewEntrypoint) {
-      const match = successfulBuilds.find((built) => path37.resolve(built.sourcePath) === resolvedPreviewEntrypoint);
+      const match = successfulBuilds.find((built) => path39.resolve(built.sourcePath) === resolvedPreviewEntrypoint);
       if (match)
         return match;
     }
@@ -187760,16 +187897,16 @@ var buildPreviewGltf = async ({
   }
   let circuitJson;
   try {
-    const circuitJsonRaw = fs36.readFileSync(previewBuild.outputPath, "utf-8");
+    const circuitJsonRaw = fs38.readFileSync(previewBuild.outputPath, "utf-8");
     circuitJson = JSON.parse(circuitJsonRaw);
   } catch (error) {
     console.error("Failed to read circuit JSON:", error);
     return;
   }
   const sourcePath = previewBuild.sourcePath;
-  const sourceBasename = path37.basename(sourcePath);
+  const sourceBasename = path39.basename(sourcePath);
   const gltfFilename = sourceBasename.replace(/(\.(board|circuit))?\.tsx?$/, ".gltf");
-  const outputPath = path37.join(distDir, gltfFilename);
+  const outputPath = path39.join(distDir, gltfFilename);
   try {
     console.log("Converting circuit to GLTF...");
     const circuitJsonWithFileUrls = convertModelUrlsToFileUrls(circuitJson);
@@ -187777,7 +187914,7 @@ var buildPreviewGltf = async ({
       format: "gltf"
     });
     const gltfContent = JSON.stringify(gltfData, null, 2);
-    fs36.writeFileSync(outputPath, gltfContent, "utf-8");
+    fs38.writeFileSync(outputPath, gltfContent, "utf-8");
     console.log(`Written ${gltfFilename}`);
   } catch (error) {
     console.error("Failed to generate GLTF:", error);
@@ -187785,8 +187922,8 @@ var buildPreviewGltf = async ({
 };
 
 // cli/build/generate-kicad-project.ts
-import fs37 from "node:fs";
-import path38 from "node:path";
+import fs39 from "node:fs";
+import path40 from "node:path";
 var createKicadProContent = ({
   projectName,
   schematicFileName,
@@ -187826,10 +187963,10 @@ var generateKicadProject = async ({
     boardFileName
   });
   if (writeFiles) {
-    fs37.mkdirSync(outputDir, { recursive: true });
-    fs37.writeFileSync(path38.join(outputDir, schematicFileName), schContent);
-    fs37.writeFileSync(path38.join(outputDir, boardFileName), pcbContent);
-    fs37.writeFileSync(path38.join(outputDir, projectFileName), proContent);
+    fs39.mkdirSync(outputDir, { recursive: true });
+    fs39.writeFileSync(path40.join(outputDir, schematicFileName), schContent);
+    fs39.writeFileSync(path40.join(outputDir, boardFileName), pcbContent);
+    fs39.writeFileSync(path40.join(outputDir, projectFileName), proContent);
   }
   return {
     pcbContent,
@@ -187841,8 +187978,8 @@ var generateKicadProject = async ({
 };
 
 // cli/build/transpile/index.ts
-import path40 from "node:path";
-import fs39 from "node:fs";
+import path42 from "node:path";
+import fs41 from "node:fs";
 import { rollup } from "rollup";
 import typescript from "@rollup/plugin-typescript";
 import resolve11 from "@rollup/plugin-node-resolve";
@@ -187851,11 +187988,11 @@ import json from "@rollup/plugin-json";
 import dts from "rollup-plugin-dts";
 
 // cli/build/transpile/static-asset-plugin.ts
-import fs38 from "node:fs";
-import path39 from "node:path";
+import fs40 from "node:fs";
+import path41 from "node:path";
 import { createHash } from "node:crypto";
 function normalizePathSeparators(filePath) {
-  return filePath.split(path39.sep).join("/");
+  return filePath.split(path41.sep).join("/");
 }
 var STATIC_ASSET_EXTENSIONS = new Set([
   ".glb",
@@ -187886,24 +188023,24 @@ var createStaticAssetPlugin = ({
   return {
     name: "tsci-static-assets",
     resolveId(source, importer) {
-      const ext = path39.extname(source).toLowerCase();
+      const ext = path41.extname(source).toLowerCase();
       if (!STATIC_ASSET_EXTENSIONS.has(ext))
         return null;
-      if (path39.isAbsolute(source)) {
-        return fs38.existsSync(source) ? { id: normalizePathSeparators(source), external: true } : null;
+      if (path41.isAbsolute(source)) {
+        return fs40.existsSync(source) ? { id: normalizePathSeparators(source), external: true } : null;
       }
       if (importer) {
-        const importerNative = importer.split("/").join(path39.sep);
-        const resolvedFromImporter = path39.resolve(path39.dirname(importerNative), source);
-        if (fs38.existsSync(resolvedFromImporter)) {
+        const importerNative = importer.split("/").join(path41.sep);
+        const resolvedFromImporter = path41.resolve(path41.dirname(importerNative), source);
+        if (fs40.existsSync(resolvedFromImporter)) {
           return {
             id: normalizePathSeparators(resolvedFromImporter),
             external: true
           };
         }
       }
-      const resolvedFromProject = path39.resolve(resolvedBaseUrl, source);
-      if (fs38.existsSync(resolvedFromProject)) {
+      const resolvedFromProject = path41.resolve(resolvedBaseUrl, source);
+      if (fs40.existsSync(resolvedFromProject)) {
         return {
           id: normalizePathSeparators(resolvedFromProject),
           external: true
@@ -187916,8 +188053,8 @@ var createStaticAssetPlugin = ({
           const wildcard = isWildcard ? source.slice(patternPrefix.length) : "";
           for (const target of targets) {
             const targetPath = isWildcard ? target.replace("*", wildcard) : target;
-            const resolvedTarget = path39.resolve(resolvedBaseUrl, targetPath);
-            if (fs38.existsSync(resolvedTarget)) {
+            const resolvedTarget = path41.resolve(resolvedBaseUrl, targetPath);
+            if (fs40.existsSync(resolvedTarget)) {
               return {
                 id: normalizePathSeparators(resolvedTarget),
                 external: true
@@ -187943,18 +188080,18 @@ var createStaticAssetPlugin = ({
         if (chunk.type !== "chunk")
           continue;
         for (const importedId of chunk.imports) {
-          const ext = path39.extname(importedId).toLowerCase();
+          const ext = path41.extname(importedId).toLowerCase();
           if (!STATIC_ASSET_EXTENSIONS.has(ext))
             continue;
           if (!copiedAssets.has(importedId)) {
-            const assetDir = path39.join(outputDir, "assets");
-            fs38.mkdirSync(assetDir, { recursive: true });
-            const nativePath = importedId.split("/").join(path39.sep);
-            const fileBuffer = fs38.readFileSync(nativePath);
+            const assetDir = path41.join(outputDir, "assets");
+            fs40.mkdirSync(assetDir, { recursive: true });
+            const nativePath = importedId.split("/").join(path41.sep);
+            const fileBuffer = fs40.readFileSync(nativePath);
             const hash = createHash("sha1").update(fileBuffer).digest("hex").slice(0, 8);
-            const fileName = `${path39.basename(importedId, ext)}-${hash}${ext}`;
-            const outputFilePath = path39.join(assetDir, fileName);
-            fs38.writeFileSync(outputFilePath, fileBuffer);
+            const fileName = `${path41.basename(importedId, ext)}-${hash}${ext}`;
+            const outputFilePath = path41.join(assetDir, fileName);
+            fs40.writeFileSync(outputFilePath, fileBuffer);
             copiedAssets.set(importedId, `./assets/${fileName}`);
             assetIdToOutputPath.set(importedId, `./assets/${fileName}`);
           }
@@ -187976,17 +188113,17 @@ function escapeRegExp(string) {
 
 // cli/build/transpile/index.ts
 var createExternalFunction = (projectDir, tsconfigPath) => (id2) => {
-  if (id2.startsWith(".") || id2.startsWith("/") || path40.isAbsolute(id2)) {
+  if (id2.startsWith(".") || id2.startsWith("/") || path42.isAbsolute(id2)) {
     return false;
   }
   let baseUrl = projectDir;
   let pathMappings = {};
-  if (tsconfigPath && fs39.existsSync(tsconfigPath)) {
+  if (tsconfigPath && fs41.existsSync(tsconfigPath)) {
     try {
-      const tsconfigContent = fs39.readFileSync(tsconfigPath, "utf-8");
+      const tsconfigContent = fs41.readFileSync(tsconfigPath, "utf-8");
       const tsconfig = JSON.parse(tsconfigContent);
       if (tsconfig.compilerOptions?.baseUrl) {
-        baseUrl = path40.resolve(path40.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
+        baseUrl = path42.resolve(path42.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
       }
       if (tsconfig.compilerOptions?.paths) {
         pathMappings = tsconfig.compilerOptions.paths;
@@ -188000,17 +188137,17 @@ var createExternalFunction = (projectDir, tsconfigPath) => (id2) => {
     }
   }
   const potentialPaths = [
-    path40.join(baseUrl, id2),
-    path40.join(baseUrl, `${id2}.ts`),
-    path40.join(baseUrl, `${id2}.tsx`),
-    path40.join(baseUrl, `${id2}.js`),
-    path40.join(baseUrl, `${id2}.jsx`),
-    path40.join(baseUrl, id2, "index.ts"),
-    path40.join(baseUrl, id2, "index.tsx"),
-    path40.join(baseUrl, id2, "index.js"),
-    path40.join(baseUrl, id2, "index.jsx")
+    path42.join(baseUrl, id2),
+    path42.join(baseUrl, `${id2}.ts`),
+    path42.join(baseUrl, `${id2}.tsx`),
+    path42.join(baseUrl, `${id2}.js`),
+    path42.join(baseUrl, `${id2}.jsx`),
+    path42.join(baseUrl, id2, "index.ts"),
+    path42.join(baseUrl, id2, "index.tsx"),
+    path42.join(baseUrl, id2, "index.js"),
+    path42.join(baseUrl, id2, "index.jsx")
   ];
-  if (potentialPaths.some((p) => fs39.existsSync(p))) {
+  if (potentialPaths.some((p) => fs41.existsSync(p))) {
     return false;
   }
   return true;
@@ -188021,17 +188158,17 @@ var transpileFile = async ({
   projectDir
 }) => {
   try {
-    fs39.mkdirSync(outputDir, { recursive: true });
-    const tsconfigPath = path40.join(projectDir, "tsconfig.json");
-    const hasTsConfig = fs39.existsSync(tsconfigPath);
+    fs41.mkdirSync(outputDir, { recursive: true });
+    const tsconfigPath = path42.join(projectDir, "tsconfig.json");
+    const hasTsConfig = fs41.existsSync(tsconfigPath);
     let tsconfigBaseUrl = projectDir;
     let tsconfigPathMappings;
     if (hasTsConfig) {
       try {
-        const tsconfigContent = fs39.readFileSync(tsconfigPath, "utf-8");
+        const tsconfigContent = fs41.readFileSync(tsconfigPath, "utf-8");
         const tsconfig = JSON.parse(tsconfigContent);
         if (tsconfig.compilerOptions?.baseUrl) {
-          tsconfigBaseUrl = path40.resolve(path40.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
+          tsconfigBaseUrl = path42.resolve(path42.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
         }
         if (tsconfig.compilerOptions?.paths) {
           tsconfigPathMappings = tsconfig.compilerOptions.paths;
@@ -188086,27 +188223,27 @@ var transpileFile = async ({
       external: createExternalFunction(projectDir, hasTsConfig ? tsconfigPath : undefined),
       plugins: getPlugins()
     });
-    const esmOutputPath = path40.join(outputDir, "index.js");
+    const esmOutputPath = path42.join(outputDir, "index.js");
     await esmBundle.write({
       file: esmOutputPath,
       format: "es",
       sourcemap: false
     });
-    console.log(`ESM bundle written to ${path40.relative(projectDir, esmOutputPath)}`);
+    console.log(`ESM bundle written to ${path42.relative(projectDir, esmOutputPath)}`);
     console.log("Building CommonJS bundle...");
     const cjsBundle = await rollup({
       input,
       external: createExternalFunction(projectDir, hasTsConfig ? tsconfigPath : undefined),
       plugins: getPlugins()
     });
-    const cjsOutputPath = path40.join(outputDir, "index.cjs");
+    const cjsOutputPath = path42.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 ${path40.relative(projectDir, cjsOutputPath)}`);
+    console.log(`CommonJS bundle written to ${path42.relative(projectDir, cjsOutputPath)}`);
     console.log("Generating type declarations...");
     const dtsBundle = await rollup({
       input,
@@ -188131,9 +188268,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 = path40.join(outputDir, "index.d.ts");
-    fs39.writeFileSync(dtsOutputPath, dtsContent);
-    console.log(`Type declarations written to ${path40.relative(projectDir, dtsOutputPath)}`);
+    const dtsOutputPath = path42.join(outputDir, "index.d.ts");
+    fs41.writeFileSync(dtsOutputPath, dtsContent);
+    console.log(`Type declarations written to ${path42.relative(projectDir, dtsOutputPath)}`);
     console.log(kleur_default.green("Transpilation complete!"));
     return true;
   } catch (err) {
@@ -188146,17 +188283,17 @@ var transpileFile = async ({
 };
 
 // cli/utils/validate-main-in-dist.ts
-import fs40 from "node:fs";
-import path41 from "node:path";
+import fs42 from "node:fs";
+import path43 from "node:path";
 var validateMainInDist = (projectDir, distDir) => {
-  const packageJsonPath = path41.join(projectDir, "package.json");
-  if (!fs40.existsSync(packageJsonPath))
+  const packageJsonPath = path43.join(projectDir, "package.json");
+  if (!fs42.existsSync(packageJsonPath))
     return;
-  const packageJson = JSON.parse(fs40.readFileSync(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(fs42.readFileSync(packageJsonPath, "utf-8"));
   if (typeof packageJson.main !== "string")
     return;
-  const resolvedMainPath = path41.resolve(projectDir, packageJson.main);
-  const isMainInDist = resolvedMainPath === distDir || resolvedMainPath.startsWith(`${distDir}${path41.sep}`);
+  const resolvedMainPath = path43.resolve(projectDir, packageJson.main);
+  const isMainInDist = resolvedMainPath === distDir || resolvedMainPath.startsWith(`${distDir}${path43.sep}`);
   if (!isMainInDist) {
     console.warn('When using transpilation, your package\'s "main" field should point inside the `dist/*` directory, usually to "dist/index.js"');
   }
@@ -188179,7 +188316,7 @@ async function getLatestTscircuitCdnUrl() {
 
 // cli/build/register.ts
 var registerBuild = (program3) => {
-  program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").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("--use-cdn-javascript", "Use CDN-hosted JavaScript instead of bundled standalone file for --site").action(async (file, options) => {
     try {
       const {
         projectDir,
@@ -188189,34 +188326,42 @@ var registerBuild = (program3) => {
       } = await getBuildEntrypoints({
         fileOrDir: file
       });
+      const { resolvedOptions, handled } = await applyCiBuildOptions({
+        projectDir,
+        options
+      });
+      if (handled) {
+        return;
+      }
       const platformConfig2 = (() => {
-        if (!options?.disablePcb && !options?.disablePartsEngine)
+        if (!resolvedOptions?.disablePcb && !resolvedOptions?.disablePartsEngine) {
           return;
+        }
         const config = {};
-        if (options?.disablePcb) {
+        if (resolvedOptions?.disablePcb) {
           config.pcbDisabled = true;
         }
-        if (options?.disablePartsEngine) {
+        if (resolvedOptions?.disablePartsEngine) {
           config.partsEngineDisabled = true;
         }
         return config;
       })();
-      const distDir = path42.join(projectDir, "dist");
-      fs41.mkdirSync(distDir, { recursive: true });
+      const distDir = path44.join(projectDir, "dist");
+      fs43.mkdirSync(distDir, { recursive: true });
       console.log(`Building ${circuitFiles.length} file(s)...`);
       let hasErrors = false;
       const staticFileReferences = [];
       const builtFiles = [];
       const kicadProjects = [];
-      const shouldGenerateKicad = options?.kicad || options?.kicadFootprintLibrary;
+      const shouldGenerateKicad = resolvedOptions?.kicad || resolvedOptions?.kicadFootprintLibrary;
       for (const filePath of circuitFiles) {
-        const relative10 = path42.relative(projectDir, filePath);
+        const relative10 = path44.relative(projectDir, filePath);
         console.log(`Building ${relative10}...`);
         const outputDirName = relative10.replace(/(\.board|\.circuit)?\.tsx$/, "");
-        const outputPath = path42.join(distDir, outputDirName, "circuit.json");
+        const outputPath = path44.join(distDir, outputDirName, "circuit.json");
         const buildOutcome = await buildFile(filePath, outputPath, projectDir, {
-          ignoreErrors: options?.ignoreErrors,
-          ignoreWarnings: options?.ignoreWarnings,
+          ignoreErrors: resolvedOptions?.ignoreErrors,
+          ignoreWarnings: resolvedOptions?.ignoreWarnings,
           platformConfig: platformConfig2
         });
         builtFiles.push({
@@ -188226,23 +188371,23 @@ var registerBuild = (program3) => {
         });
         if (!buildOutcome.ok) {
           hasErrors = true;
-        } else if (options?.site) {
-          const normalizedSourcePath = relative10.split(path42.sep).join("/");
-          const relativeOutputPath = path42.join(outputDirName, "circuit.json");
-          const normalizedOutputPath = relativeOutputPath.split(path42.sep).join("/");
+        } else if (resolvedOptions?.site) {
+          const normalizedSourcePath = relative10.split(path44.sep).join("/");
+          const relativeOutputPath = path44.join(outputDirName, "circuit.json");
+          const normalizedOutputPath = relativeOutputPath.split(path44.sep).join("/");
           staticFileReferences.push({
             filePath: normalizedSourcePath,
             fileStaticAssetUrl: `./${normalizedOutputPath}`
           });
         }
         if (buildOutcome.ok && shouldGenerateKicad && buildOutcome.circuitJson) {
-          const projectOutputDir = path42.join(distDir, outputDirName, "kicad");
-          const projectName = path42.basename(outputDirName);
+          const projectOutputDir = path44.join(distDir, outputDirName, "kicad");
+          const projectName = path44.basename(outputDirName);
           const project = await generateKicadProject({
             circuitJson: buildOutcome.circuitJson,
             outputDir: projectOutputDir,
             projectName,
-            writeFiles: Boolean(options?.kicad)
+            writeFiles: Boolean(resolvedOptions?.kicad)
           });
           kicadProjects.push({
             ...project,
@@ -188250,21 +188395,21 @@ var registerBuild = (program3) => {
           });
         }
       }
-      if (hasErrors && !options?.ignoreErrors) {
+      if (hasErrors && !resolvedOptions?.ignoreErrors) {
         process.exit(1);
       }
-      const shouldGeneratePreviewImages = options?.previewImages || options?.allImages;
+      const shouldGeneratePreviewImages = resolvedOptions?.previewImages || resolvedOptions?.allImages;
       if (shouldGeneratePreviewImages) {
-        console.log(options?.allImages ? "Generating preview images for all builds..." : "Generating preview images...");
+        console.log(resolvedOptions?.allImages ? "Generating preview images for all builds..." : "Generating preview images...");
         await buildPreviewImages({
           builtFiles,
           distDir,
           mainEntrypoint,
           previewComponentPath,
-          allImages: options?.allImages
+          allImages: resolvedOptions?.allImages
         });
       }
-      if (options?.previewGltf) {
+      if (resolvedOptions?.previewGltf) {
         console.log("Generating preview GLTF...");
         await buildPreviewGltf({
           builtFiles,
@@ -188273,7 +188418,7 @@ var registerBuild = (program3) => {
           previewComponentPath
         });
       }
-      if (options?.transpile) {
+      if (resolvedOptions?.transpile) {
         validateMainInDist(projectDir, distDir);
         console.log("Transpiling entry file...");
         const { mainEntrypoint: transpileEntrypoint } = await getBuildEntrypoints({
@@ -188295,28 +188440,28 @@ var registerBuild = (program3) => {
           process.exit(1);
         }
       }
-      if (options?.site) {
+      if (resolvedOptions?.site) {
         let standaloneScriptSrc = "./standalone.min.js";
-        if (options?.useCdnJavascript) {
+        if (resolvedOptions?.useCdnJavascript) {
           standaloneScriptSrc = await getLatestTscircuitCdnUrl();
         } else {
-          fs41.writeFileSync(path42.join(distDir, "standalone.min.js"), standalone_min_default);
+          fs43.writeFileSync(path44.join(distDir, "standalone.min.js"), standalone_min_default);
         }
         const indexHtml = getStaticIndexHtmlFile({
           files: staticFileReferences,
           standaloneScriptSrc
         });
-        fs41.writeFileSync(path42.join(distDir, "index.html"), indexHtml);
+        fs43.writeFileSync(path44.join(distDir, "index.html"), indexHtml);
       }
       const successCount = builtFiles.filter((f) => f.ok).length;
       const failCount = builtFiles.length - successCount;
       const enabledOpts = [
-        options?.site && "site",
-        options?.transpile && "transpile",
-        options?.previewImages && "preview-images",
-        options?.allImages && "all-images",
-        options?.kicad && "kicad",
-        options?.previewGltf && "preview-gltf"
+        resolvedOptions?.site && "site",
+        resolvedOptions?.transpile && "transpile",
+        resolvedOptions?.previewImages && "preview-images",
+        resolvedOptions?.allImages && "all-images",
+        resolvedOptions?.kicad && "kicad",
+        resolvedOptions?.previewGltf && "preview-gltf"
       ].filter(Boolean);
       console.log("");
       console.log(kleur_default.bold("Build complete"));
@@ -188324,7 +188469,7 @@ var registerBuild = (program3) => {
       if (enabledOpts.length > 0) {
         console.log(`  Options   ${kleur_default.cyan(enabledOpts.join(", "))}`);
       }
-      console.log(`  Output    ${kleur_default.dim(path42.relative(process.cwd(), distDir) || "dist")}`);
+      console.log(`  Output    ${kleur_default.dim(path44.relative(process.cwd(), distDir) || "dist")}`);
       console.log(hasErrors ? kleur_default.yellow(`
 ⚠ Build completed with errors`) : kleur_default.green(`
 ✓ Done`));
@@ -188338,8 +188483,8 @@ var registerBuild = (program3) => {
 };
 
 // lib/shared/snapshot-project.ts
-import fs43 from "node:fs";
-import path43 from "node:path";
+import fs45 from "node:fs";
+import path45 from "node:path";
 import looksSame2 from "looks-same";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg3,
@@ -188350,7 +188495,7 @@ import { renderGLTFToPNGBufferFromGLBBuffer as renderGLTFToPNGBufferFromGLBBuffe
 
 // lib/shared/compare-images.ts
 import looksSame from "looks-same";
-import fs42 from "node:fs/promises";
+import fs44 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
   const { equal: equal2 } = await looksSame(buffer1, buffer2, {
     strict: false,
@@ -188366,7 +188511,7 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
         tolerance: 2
       });
     } else {
-      await fs42.writeFile(diffPath, buffer2);
+      await fs44.writeFile(diffPath, buffer2);
     }
   }
   return { equal: equal2 };
@@ -188391,7 +188536,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f) => path43.resolve(projectDir, f));
+  const resolvedPaths = filePaths.map((f) => path45.resolve(projectDir, f));
   const boardFiles = findBoardFiles({
     projectDir,
     ignore,
@@ -188405,7 +188550,7 @@ var snapshotProject = async ({
   const mismatches = [];
   let didUpdate = false;
   for (const file of boardFiles) {
-    const relativeFilePath = path43.relative(projectDir, file);
+    const relativeFilePath = path45.relative(projectDir, file);
     let circuitJson;
     let pcbSvg;
     let schSvg;
@@ -188460,17 +188605,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 = path43.dirname(file);
-          const relativeDir = path43.relative(projectDir, fileDir);
-          const snapDir2 = snapshotsDirName ? path43.join(projectDir, snapshotsDirName, relativeDir) : path43.join(fileDir, "__snapshots__");
-          const base2 = path43.basename(file).replace(/\.tsx$/, "");
-          const snap3dPath = path43.join(snapDir2, `${base2}-3d.snap.png`);
-          const existing3dSnapshot = fs43.existsSync(snap3dPath);
+          const fileDir = path45.dirname(file);
+          const relativeDir = path45.relative(projectDir, fileDir);
+          const snapDir2 = snapshotsDirName ? path45.join(projectDir, snapshotsDirName, relativeDir) : path45.join(fileDir, "__snapshots__");
+          const base2 = path45.basename(file).replace(/\.tsx$/, "");
+          const snap3dPath = path45.join(snapDir2, `${base2}-3d.snap.png`);
+          const existing3dSnapshot = fs45.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: ${path43.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path45.relative(projectDir, snap3dPath)}
 `));
             return onExit2(1);
           } else {
@@ -188486,9 +188631,9 @@ var snapshotProject = async ({
         }
       }
     }
-    const snapDir = snapshotsDirName ? path43.join(projectDir, snapshotsDirName, path43.relative(projectDir, path43.dirname(file))) : path43.join(path43.dirname(file), "__snapshots__");
-    fs43.mkdirSync(snapDir, { recursive: true });
-    const base = path43.basename(file).replace(/\.tsx$/, "");
+    const snapDir = snapshotsDirName ? path45.join(projectDir, snapshotsDirName, path45.relative(projectDir, path45.dirname(file))) : path45.join(path45.dirname(file), "__snapshots__");
+    fs45.mkdirSync(snapDir, { recursive: true });
+    const base = path45.basename(file).replace(/\.tsx$/, "");
     const snapshots = [];
     if (pcbOnly || !schematicOnly) {
       snapshots.push({ type: "pcb", content: pcbSvg, isBinary: false });
@@ -188506,31 +188651,31 @@ var snapshotProject = async ({
     for (const snapshot of snapshots) {
       const { type } = snapshot;
       const is3d = type === "3d";
-      const snapPath = path43.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-      const existing = fs43.existsSync(snapPath);
+      const snapPath = path45.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+      const existing = fs45.existsSync(snapPath);
       const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
       const newContentForFile = snapshot.content;
       if (!existing) {
-        fs43.writeFileSync(snapPath, newContentForFile);
-        console.log("✅", kleur_default.gray(path43.relative(projectDir, snapPath)));
+        fs45.writeFileSync(snapPath, newContentForFile);
+        console.log("✅", kleur_default.gray(path45.relative(projectDir, snapPath)));
         didUpdate = true;
         continue;
       }
-      const oldContentBuffer = fs43.readFileSync(snapPath);
+      const oldContentBuffer = fs45.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(path43.relative(projectDir, snapPath)));
+          console.log("✅", kleur_default.gray(path45.relative(projectDir, snapPath)));
         } else {
-          fs43.writeFileSync(snapPath, newContentForFile);
-          console.log("✅", kleur_default.gray(path43.relative(projectDir, snapPath)));
+          fs45.writeFileSync(snapPath, newContentForFile);
+          console.log("✅", kleur_default.gray(path45.relative(projectDir, snapPath)));
           didUpdate = true;
         }
       } else if (!equal2) {
         mismatches.push(`${snapPath} (diff: ${diffPath})`);
       } else {
-        console.log("✅", kleur_default.gray(path43.relative(projectDir, snapPath)));
+        console.log("✅", kleur_default.gray(path45.relative(projectDir, snapPath)));
       }
     }
   }
@@ -188569,22 +188714,22 @@ var registerSnapshot = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs44 from "node:fs";
-import path44 from "node:path";
+import fs46 from "node:fs";
+import path46 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path44.resolve(startDir);
-    while (dir !== path44.parse(dir).root) {
-      if (fs44.existsSync(path44.join(dir, ".git"))) {
+    let dir = path46.resolve(startDir);
+    while (dir !== path46.parse(dir).root) {
+      if (fs46.existsSync(path46.join(dir, ".git"))) {
         return dir;
       }
-      dir = path44.dirname(dir);
+      dir = path46.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path44.join(gitRoot, ".github", "workflows");
-  fs44.mkdirSync(workflowsDir, { recursive: true });
+  const workflowsDir = path46.join(gitRoot, ".github", "workflows");
+  fs46.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -188623,8 +188768,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path44.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path44.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path46.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path46.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -188662,8 +188807,8 @@ function registerAuthSetupNpmrc(program3) {
 }
 
 // cli/convert/register.ts
-import fs45 from "node:fs/promises";
-import path45 from "node:path";
+import fs47 from "node:fs/promises";
+import path47 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
 
 // node_modules/@tscircuit/mm/dist/index.js
@@ -188783,15 +188928,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 = path45.resolve(file);
-      const modContent = await fs45.readFile(inputPath, "utf-8");
+      const inputPath = path47.resolve(file);
+      const modContent = await fs47.readFile(inputPath, "utf-8");
       const circuitJson = await parseKicadModToCircuitJson(modContent);
-      const componentName = options.name ?? path45.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path47.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path45.resolve(options.output) : path45.join(path45.dirname(inputPath), `${componentName}.tsx`);
-      await fs45.writeFile(outputPath, tsx);
+      const outputPath = options.output ? path47.resolve(options.output) : path47.join(path47.dirname(inputPath), `${componentName}.tsx`);
+      await fs47.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);
@@ -188886,102 +189031,6 @@ var registerSimulate = (program3) => {
   });
 };
 
-// lib/shared/install-project-dependencies.ts
-import fs47 from "node:fs";
-import path47 from "node:path";
-
-// lib/shared/collect-tsci-dependencies.ts
-import fs46 from "node:fs";
-import path46 from "node:path";
-var DEFAULT_PATTERNS = ["**/*.{ts,tsx,js,jsx}"];
-var DEFAULT_IGNORES = [
-  "**/node_modules/**",
-  "**/.git/**",
-  "**/dist/**",
-  "**/build/**",
-  "**/.tsci/**"
-];
-var IMPORT_PATTERN = /["'`](@tsci\/[A-Za-z0-9._/-]+)["'`]/g;
-function collectTsciDependencies({
-  cwd = process.cwd(),
-  patterns = DEFAULT_PATTERNS,
-  ignore = DEFAULT_IGNORES
-} = {}) {
-  const searchRoot = path46.resolve(cwd);
-  const files = globbySync(patterns, {
-    cwd: searchRoot,
-    absolute: true,
-    ignore,
-    gitignore: true
-  });
-  const dependencies2 = new Set;
-  for (const filePath of files) {
-    try {
-      const fileContents = fs46.readFileSync(filePath, "utf-8");
-      let match;
-      while (true) {
-        match = IMPORT_PATTERN.exec(fileContents);
-        if (match === null)
-          break;
-        dependencies2.add(match[1]);
-      }
-    } catch (error) {}
-  }
-  return Array.from(dependencies2);
-}
-
-// lib/shared/install-project-dependencies.ts
-async function installProjectDependencies({
-  cwd = process.cwd()
-} = {}) {
-  const projectRoot = path47.resolve(cwd);
-  const packageJsonPath = path47.join(projectRoot, "package.json");
-  const npmrcPath = path47.join(projectRoot, ".npmrc");
-  const packageManager = getPackageManager();
-  if (!fs47.existsSync(projectRoot)) {
-    throw new Error(`Directory not found: ${projectRoot}`);
-  }
-  let packageJsonCreated = false;
-  if (!fs47.existsSync(packageJsonPath)) {
-    console.log("No package.json found. Generating a new one.");
-    generatePackageJson(projectRoot);
-    packageJsonCreated = true;
-  } else {
-    console.log("Found existing package.json.");
-  }
-  if (!fs47.existsSync(npmrcPath)) {
-    console.log("Creating .npmrc with tscircuit registry configuration.");
-    fs47.writeFileSync(npmrcPath, "@tsci:registry=https://npm.tscircuit.com");
-  }
-  const packageJson = JSON.parse(fs47.readFileSync(packageJsonPath, "utf-8"));
-  if (packageJsonCreated) {
-    const tsciDependencies = collectTsciDependencies({ cwd: projectRoot });
-    if (tsciDependencies.length > 0) {
-      packageJson.dependencies = packageJson.dependencies || {};
-      for (const dependency of tsciDependencies) {
-        if (!packageJson.dependencies[dependency]) {
-          packageJson.dependencies[dependency] = "latest";
-        }
-      }
-      console.log(`Added ${tsciDependencies.length} @tsci dependencies to package.json.`);
-    } else {
-      console.log("No @tsci dependencies detected in circuit files.");
-    }
-  }
-  fs47.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
-`);
-  console.log(`Installing dependencies using ${kleur_default.bold(packageManager.name)}...`);
-  try {
-    packageManager.installAll({ cwd: projectRoot });
-    console.log("Dependencies installed successfully.");
-  } catch (error) {
-    console.warn("Failed to automatically install dependencies.");
-    console.warn(`Please run \`${packageManager.getInstallAllCommand()}\` manually.`);
-    handleRegistryAuthError({ error, projectDir: projectRoot });
-    throw error;
-  }
-}
-
 // cli/install/register.ts
 var registerInstall = (program3) => {
   program3.command("install [packageSpec]").description("Install project dependencies, or install a specific package (e.g., tsci install https://github.com/espressif/kicad-libraries)").action(async (packageSpec) => {

package/package.json

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

package/types/tscircuit.config.schema.json

@@ -36,6 +36,10 @@
       "type": "string",
       "description": "Directory path for storing snapshots."
     },
+    "prebuildCommand": {
+      "type": "string",
+      "description": "Command to run before builds."
+    },
     "buildCommand": {
       "type": "string",
       "description": "Override command used for cloud builds."