@tscircuit/cli 0.1.1648 → 0.1.1650

package/dist/cli/snapshot/snapshot.worker.js

@@ -2485,8 +2485,8 @@ export default {
 import { parentPort } from "node:worker_threads";
 
 // lib/shared/process-snapshot-file.ts
-import fs7 from "node:fs";
-import path6 from "node:path";
+import fs8 from "node:fs";
+import path7 from "node:path";
 
 // node_modules/circuit-json-to-3d-png/dist/index.js
 function normalizeDir(dir) {
@@ -2775,9 +2775,140 @@ function init(open, close) {
 }
 var kleur_default = $;
 
+// lib/shared/circuit-json-build-cache.ts
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+var SOURCE_FILE_EXTENSIONS = new Set([
+  ".tsx",
+  ".ts",
+  ".jsx",
+  ".js",
+  ".json",
+  ".txt",
+  ".md",
+  ".obj",
+  ".kicad_mod",
+  ".kicad_pcb",
+  ".kicad_pro",
+  ".kicad_sch"
+]);
+var IGNORED_DIRECTORY_NAMES = new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".git"
+]);
+var isPathInside = (childPath, parentPath) => {
+  const relative = path.relative(parentPath, childPath);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+};
+var findCircuitProjectDir = (filePath) => {
+  const absoluteFilePath = path.resolve(filePath);
+  let currentDir = path.dirname(absoluteFilePath);
+  while (true) {
+    if (fs.existsSync(path.join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir)
+      break;
+    currentDir = parentDir;
+  }
+  const cwd = path.resolve(process.cwd());
+  return isPathInside(absoluteFilePath, cwd) ? cwd : path.dirname(absoluteFilePath);
+};
+var getCircuitJsonOutputDirName = (relativePath) => {
+  const normalizedRelativePath = relativePath.toLowerCase().replaceAll("\\", "/");
+  if (normalizedRelativePath === "circuit.json" || normalizedRelativePath.endsWith("/circuit.json")) {
+    return path.dirname(relativePath);
+  }
+  return relativePath.replace(/(\.board|\.circuit)?\.tsx$/, "").replace(/\.circuit\.json$/, "");
+};
+var getCircuitJsonBuildOutputPath = (filePath) => {
+  const absoluteFilePath = path.resolve(filePath);
+  const projectDir = findCircuitProjectDir(absoluteFilePath);
+  const relativePath = path.relative(projectDir, absoluteFilePath);
+  return path.join(projectDir, "dist", getCircuitJsonOutputDirName(relativePath), "circuit.json");
+};
+var getSourceFilePaths = (projectDir) => {
+  const sourceFilePaths = [];
+  const visit = (directoryPath) => {
+    const entries = fs.readdirSync(directoryPath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const entryPath = path.join(directoryPath, entry.name);
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRECTORY_NAMES.has(entry.name) || entry.name.startsWith(".")) {
+          continue;
+        }
+        visit(entryPath);
+        continue;
+      }
+      if (!entry.isFile() || entry.name.endsWith(".circuit.json") || !SOURCE_FILE_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
+        continue;
+      }
+      sourceFilePaths.push(entryPath);
+    }
+  };
+  visit(projectDir);
+  return sourceFilePaths;
+};
+var getSourceFilesystemMd5Hash = (filePath) => {
+  const projectDir = findCircuitProjectDir(filePath);
+  const hash = createHash("md5");
+  for (const sourceFilePath of getSourceFilePaths(projectDir)) {
+    const relativePath = path.relative(projectDir, sourceFilePath).split(path.sep).join("/");
+    const content = fs.readFileSync(sourceFilePath);
+    hash.update(`${Buffer.byteLength(relativePath)}:`);
+    hash.update(relativePath);
+    hash.update(`${content.byteLength}:`);
+    hash.update(content);
+  }
+  return hash.digest("hex");
+};
+var addSourceFilesystemHash = (circuitJson, sourceFilesystemMd5Hash) => {
+  let foundProjectMetadata = false;
+  const circuitJsonWithHash = circuitJson.map((element) => {
+    if (element.type !== "source_project_metadata")
+      return element;
+    foundProjectMetadata = true;
+    const metadataWithHash = {
+      ...element,
+      source_filesystem_md5_hash: sourceFilesystemMd5Hash
+    };
+    return metadataWithHash;
+  });
+  if (!foundProjectMetadata) {
+    const metadataWithHash = {
+      type: "source_project_metadata",
+      source_filesystem_md5_hash: sourceFilesystemMd5Hash
+    };
+    circuitJsonWithHash.push(metadataWithHash);
+  }
+  return circuitJsonWithHash;
+};
+var readCurrentCircuitJsonBuild = ({
+  filePath,
+  sourceFilesystemMd5Hash
+}) => {
+  const outputPath = getCircuitJsonBuildOutputPath(filePath);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(outputPath, "utf-8"));
+    if (!Array.isArray(parsed))
+      return null;
+    const hasCurrentFilesystemHash = parsed.some((element) => element?.type === "source_project_metadata" && element.source_filesystem_md5_hash === sourceFilesystemMd5Hash);
+    return hasCurrentFilesystemHash ? {
+      circuitJson: parsed,
+      outputPath
+    } : null;
+  } catch {
+    return null;
+  }
+};
+
 // lib/shared/generate-circuit-json.tsx
-import fs4 from "node:fs";
-import path4 from "node:path";
+import fs5 from "node:fs";
+import path5 from "node:path";
 import { pathToFileURL } from "node:url";
 import Debug from "debug";
 
@@ -2799,8 +2930,8 @@ var abbreviateStringifyObject = (obj) => {
 var import_make_vfs = __toESM(require_dist(), 1);
 
 // lib/shared/autorouter-diagnostics.ts
-import fs from "node:fs";
-import path from "node:path";
+import fs2 from "node:fs";
+import path2 from "node:path";
 import { convertCircuitJsonToPcbSvg } from "circuit-to-svg";
 
 // lib/shared/convert-svg-to-png.ts
@@ -2815,7 +2946,7 @@ var convertSvgToPngBuffer = (svg) => {
 };
 
 // lib/shared/autorouter-diagnostics.ts
-var DEFAULT_DEBUG_DIR = path.join("dist", "autorouter-debug");
+var DEFAULT_DEBUG_DIR = path2.join("dist", "autorouter-debug");
 var PROGRESS_LOG_INTERVAL_MS = 1e4;
 var CIRCUIT_JSON_ID_PATTERN = /\b(?:source|pcb|schematic|subcircuit|cad|simulation)_[a-z0-9_]*_\d+\b/gi;
 var parseAutorouterTimeout = (duration) => {
@@ -3160,24 +3291,24 @@ class AutorouterDiagnostics {
     return this.options.dumpSrj === "all" || this.options.dumpSrj === "failed" || this.options.dumpSrj === `phase:${routingPhaseIndex}`;
   }
   writeJson(fileName, value) {
-    const debugDir = path.resolve(this.options.debugDir ?? DEFAULT_DEBUG_DIR);
-    fs.mkdirSync(debugDir, { recursive: true });
-    const filePath = path.join(debugDir, fileName);
-    fs.writeFileSync(filePath, JSON.stringify(value, null, 2));
+    const debugDir = path2.resolve(this.options.debugDir ?? DEFAULT_DEBUG_DIR);
+    fs2.mkdirSync(debugDir, { recursive: true });
+    const filePath = path2.join(debugDir, fileName);
+    fs2.writeFileSync(filePath, JSON.stringify(value, null, 2));
     this.logArtifact(filePath);
     return filePath;
   }
   writePngSnapshot(fileName, circuitJson) {
     const pcbSvg = convertCircuitJsonToPcbSvg(circuitJson);
     const png = convertSvgToPngBuffer(pcbSvg);
-    const debugDir = path.resolve(this.options.debugDir ?? DEFAULT_DEBUG_DIR);
-    fs.mkdirSync(debugDir, { recursive: true });
-    const filePath = path.join(debugDir, fileName);
-    fs.writeFileSync(filePath, png);
+    const debugDir = path2.resolve(this.options.debugDir ?? DEFAULT_DEBUG_DIR);
+    fs2.mkdirSync(debugDir, { recursive: true });
+    const filePath = path2.join(debugDir, fileName);
+    fs2.writeFileSync(filePath, png);
     this.logArtifact(filePath);
   }
   logArtifact(filePath) {
-    this.log(`Wrote debug artifact: ${path.relative(process.cwd(), filePath)}`);
+    this.log(`Wrote debug artifact: ${path2.relative(process.cwd(), filePath)}`);
   }
   getCircuitJsonWithCompletedPhaseTraces() {
     const circuitJson = [...this.getCurrentCircuitJson()];
@@ -3323,12 +3454,12 @@ class AutorouterDiagnostics {
 
 // lib/shared/importFromUserLand.ts
 import { createRequire as createRequire2 } from "node:module";
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 async function importFromUserLand(moduleName) {
-  const userModulePath = path2.join(process.cwd(), "node_modules", moduleName);
-  if (fs2.existsSync(userModulePath)) {
-    const userRequire = createRequire2(path2.join(process.cwd(), "noop.js"));
+  const userModulePath = path3.join(process.cwd(), "node_modules", moduleName);
+  if (fs3.existsSync(userModulePath)) {
+    const userRequire = createRequire2(path3.join(process.cwd(), "noop.js"));
     try {
       const resolvedUserPath = userRequire.resolve(moduleName);
       return await import(resolvedUserPath);
@@ -3351,8 +3482,8 @@ async function importFromUserLand(moduleName) {
 }
 
 // lib/shared/register-static-asset-loaders.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs4 from "node:fs";
+import path4 from "node:path";
 var STATIC_ASSET_EXTENSIONS = [
   ".glb",
   ".gltf",
@@ -3377,15 +3508,15 @@ var TEXT_STATIC_ASSET_EXTENSIONS = new Set([
   ".kicad_sch"
 ]);
 var readFileContentForStaticLoader = (filePath) => {
-  const ext = path3.extname(filePath).toLowerCase();
+  const ext = path4.extname(filePath).toLowerCase();
   if (TEXT_STATIC_ASSET_EXTENSIONS.has(ext)) {
-    return fs3.readFileSync(filePath, "utf-8");
+    return fs4.readFileSync(filePath, "utf-8");
   }
-  const buffer = fs3.readFileSync(filePath);
+  const buffer = fs4.readFileSync(filePath);
   return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
 };
 var getStaticFileLoader = (filePath) => {
-  const extWithDot = path3.extname(filePath).toLowerCase();
+  const extWithDot = path4.extname(filePath).toLowerCase();
   const ext = extWithDot.replace(/^\./, "");
   return activePlatformConfig?.staticFileLoaderMap?.[ext] ?? activePlatformConfig?.staticFileLoaderMap?.[extWithDot];
 };
@@ -3399,12 +3530,12 @@ var normalizeStaticFileLoaderResult = (result) => {
   };
 };
 var getBaseUrlFromTsConfig = () => {
-  const tsconfigPath = path3.join(process.cwd(), "tsconfig.json");
+  const tsconfigPath = path4.join(process.cwd(), "tsconfig.json");
   try {
-    if (!fs3.existsSync(tsconfigPath)) {
+    if (!fs4.existsSync(tsconfigPath)) {
       return null;
     }
-    const tsconfigContent = fs3.readFileSync(tsconfigPath, "utf-8");
+    const tsconfigContent = fs4.readFileSync(tsconfigPath, "utf-8");
     const tsconfig = JSON.parse(tsconfigContent);
     if (tsconfig.compilerOptions?.baseUrl) {
       return tsconfig.compilerOptions.baseUrl;
@@ -3431,8 +3562,8 @@ var registerStaticAssetLoaders = (platformConfig) => {
               loader: "object"
             };
           }
-          const baseDir = baseUrl ? path3.resolve(process.cwd(), baseUrl) : process.cwd();
-          const relativePath = path3.relative(baseDir, args.path).split(path3.sep).join("/");
+          const baseDir = baseUrl ? path4.resolve(process.cwd(), baseUrl) : process.cwd();
+          const relativePath = path4.relative(baseDir, args.path).split(path4.sep).join("/");
           const pathStr = `./${relativePath}`;
           return {
             exports: {
@@ -3472,9 +3603,11 @@ async function generateCircuitJson({
   platformConfig,
   injectedProps,
   onAsyncEffectStatus,
-  autorouterDiagnostics: autorouterDiagnosticsOptions
+  autorouterDiagnostics: autorouterDiagnosticsOptions,
+  sourceFilesystemMd5Hash
 }) {
   debug(`Generating circuit JSON for ${filePath}`);
+  const currentSourceFilesystemMd5Hash = sourceFilesystemMd5Hash ?? getSourceFilesystemMd5Hash(filePath);
   const React = await importFromUserLand("react");
   globalThis.React = React;
   registerStaticAssetLoaders(platformConfig);
@@ -3484,12 +3617,12 @@ async function generateCircuitJson({
   });
   const autorouterDiagnostics = new AutorouterDiagnostics(autorouterDiagnosticsOptions);
   autorouterDiagnostics.attachToRootCircuit(runner);
-  const absoluteFilePath = path4.isAbsolute(filePath) ? filePath : path4.resolve(process.cwd(), filePath);
-  const projectDir = path4.dirname(absoluteFilePath);
+  const absoluteFilePath = path5.isAbsolute(filePath) ? filePath : path5.resolve(process.cwd(), filePath);
+  const projectDir = path5.dirname(absoluteFilePath);
   const resolvedOutputDir = outputDir ?? projectDir;
-  const relativeComponentPath = path4.relative(projectDir, absoluteFilePath);
-  const baseFileName = outputFileName || path4.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path4.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  const relativeComponentPath = path5.relative(projectDir, absoluteFilePath);
+  const baseFileName = outputFileName || path5.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path5.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
   debug(`Project directory: ${projectDir}`);
   debug(`Relative component path: ${relativeComponentPath}`);
   debug(`Output path: ${outputPath}`);
@@ -3509,7 +3642,7 @@ async function generateCircuitJson({
           return false;
         if (normalizedFilePath.match(/^\.[^/]/))
           return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path4.extname(normalizedFilePath)))
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path5.extname(normalizedFilePath)))
           return false;
         return true;
       },
@@ -3541,11 +3674,11 @@ async function generateCircuitJson({
     runner.render();
   }
   runner.emit("renderComplete");
-  const circuitJson = await runner.getCircuitJson();
+  const circuitJson = addSourceFilesystemHash(await runner.getCircuitJson(), currentSourceFilesystemMd5Hash);
   await autorouterDiagnostics.finalize(circuitJson);
   if (saveToFile) {
     debug(`Saving circuit JSON to ${outputPath}`);
-    fs4.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    fs5.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
   }
   return {
     circuitJson,
@@ -3554,30 +3687,54 @@ async function generateCircuitJson({
   };
 }
 
+// lib/shared/get-or-generate-circuit-json.ts
+var getOrGenerateCircuitJson = async (options) => {
+  const sourceFilesystemMd5Hash = getSourceFilesystemMd5Hash(options.filePath);
+  const cachedBuild = readCurrentCircuitJsonBuild({
+    filePath: options.filePath,
+    sourceFilesystemMd5Hash
+  });
+  if (cachedBuild) {
+    return {
+      ...cachedBuild,
+      rootCircuit: undefined,
+      cacheHit: true
+    };
+  }
+  const generated = await generateCircuitJson({
+    ...options,
+    sourceFilesystemMd5Hash
+  });
+  return {
+    ...generated,
+    cacheHit: false
+  };
+};
+
 // lib/shared/get-platform-config-with-cli-defaults.ts
-import { createHash } from "node:crypto";
-import fs5 from "node:fs";
-import path5 from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import fs6 from "node:fs";
+import path6 from "node:path";
 import { getPlatformConfig } from "@tscircuit/eval/platform-config";
-function createLocalCacheEngine(cacheDir = path5.join(process.cwd(), ".tscircuit", "cache")) {
+function createLocalCacheEngine(cacheDir = path6.join(process.cwd(), ".tscircuit", "cache")) {
   return {
     getItem: (key) => {
       try {
-        const hash = createHash("md5").update(key).digest("hex");
+        const hash = createHash2("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path5.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        return fs5.readFileSync(filePath, "utf-8");
+        const filePath = path6.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        return fs6.readFileSync(filePath, "utf-8");
       } catch {
         return null;
       }
     },
     setItem: (key, value) => {
       try {
-        fs5.mkdirSync(cacheDir, { recursive: true });
-        const hash = createHash("md5").update(key).digest("hex");
+        fs6.mkdirSync(cacheDir, { recursive: true });
+        const hash = createHash2("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path5.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        fs5.writeFileSync(filePath, value);
+        const filePath = path6.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        fs6.writeFileSync(filePath, value);
       } catch {}
     }
   };
@@ -3593,15 +3750,15 @@ function getPlatformConfigWithCliDefaults(userConfig) {
         loadFromUrl: async (url) => {
           let fetchUrl = url;
           if (url.startsWith("./") || url.startsWith("../")) {
-            const absolutePath = path5.resolve(process.cwd(), url);
+            const absolutePath = path6.resolve(process.cwd(), url);
             fetchUrl = `file://${absolutePath}`;
           } else if (url.startsWith("/")) {
-            if (fs5.existsSync(url)) {
+            if (fs6.existsSync(url)) {
               fetchUrl = `file://${url}`;
             } else {
               const relativePath = `.${url}`;
-              const absolutePath = path5.resolve(process.cwd(), relativePath);
-              if (fs5.existsSync(absolutePath)) {
+              const absolutePath = path6.resolve(process.cwd(), relativePath);
+              if (fs6.existsSync(absolutePath)) {
                 fetchUrl = `file://${absolutePath}`;
               } else {
                 fetchUrl = `file://${url}`;
@@ -3674,7 +3831,7 @@ var getSimulationSvgAssetsFromCircuitJson = (circuitJson) => {
 
 // lib/shared/compare-images.ts
 import looksSame from "@tscircuit/image-utils/looks-same";
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true) => {
   const b1 = Buffer.from(buffer1);
   const b2 = Buffer.from(buffer2);
@@ -3690,9 +3847,9 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true)
         highlightColor: "#ff00ff",
         tolerance: 2
       });
-      await fs6.writeFile(diffPath, diffBuffer);
+      await fs7.writeFile(diffPath, diffBuffer);
     } else {
-      await fs6.writeFile(diffPath, buffer2);
+      await fs7.writeFile(diffPath, buffer2);
     }
   }
   return { equal };
@@ -3721,7 +3878,7 @@ var processSnapshotFile = async ({
   cameraPreset,
   pcbLayer
 }) => {
-  const relativeFilePath = path6.relative(projectDir, file);
+  const relativeFilePath = path7.relative(projectDir, file);
   const successPaths = [];
   const warningMessages = [];
   const mismatches = [];
@@ -3732,11 +3889,11 @@ var processSnapshotFile = async ({
   let simulationSvgAssets;
   try {
     if (isCircuitJsonFile(file)) {
-      const parsed = JSON.parse(fs7.readFileSync(file, "utf-8"));
+      const parsed = JSON.parse(fs8.readFileSync(file, "utf-8"));
       circuitJson = Array.isArray(parsed) ? parsed : [];
     } else {
       const platformConfigWithCliDefaults = getPlatformConfigWithCliDefaults(platformConfig);
-      const result = await generateCircuitJson({
+      const result = await getOrGenerateCircuitJson({
         filePath: file,
         platformConfig: platformConfigWithCliDefaults
       });
@@ -3816,12 +3973,12 @@ var processSnapshotFile = async ({
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("No pcb_board found in circuit JSON")) {
-        const fileDir = path6.dirname(file);
-        const relativeDir = path6.relative(projectDir, fileDir);
-        const snapDir2 = snapshotsDirName ? path6.join(projectDir, snapshotsDirName, relativeDir) : path6.join(fileDir, "__snapshots__");
-        const base2 = path6.basename(file).replace(/\.[^.]+$/, "");
-        const snap3dPath = path6.join(snapDir2, `${base2}-3d.snap.png`);
-        const existing3dSnapshot = fs7.existsSync(snap3dPath);
+        const fileDir = path7.dirname(file);
+        const relativeDir = path7.relative(projectDir, fileDir);
+        const snapDir2 = snapshotsDirName ? path7.join(projectDir, snapshotsDirName, relativeDir) : path7.join(fileDir, "__snapshots__");
+        const base2 = path7.basename(file).replace(/\.[^.]+$/, "");
+        const snap3dPath = path7.join(snapDir2, `${base2}-3d.snap.png`);
+        const existing3dSnapshot = fs8.existsSync(snap3dPath);
         if (existing3dSnapshot) {
           return {
             ok: false,
@@ -3832,7 +3989,7 @@ var processSnapshotFile = async ({
             errorMessage: 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: ${path6.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path7.relative(projectDir, snap3dPath)}
 `)
           };
         }
@@ -3853,9 +4010,9 @@ var processSnapshotFile = async ({
       }
     }
   }
-  const snapDir = snapshotsDirName ? path6.join(projectDir, snapshotsDirName, path6.relative(projectDir, path6.dirname(file))) : path6.join(path6.dirname(file), "__snapshots__");
-  fs7.mkdirSync(snapDir, { recursive: true });
-  const base = path6.basename(file).replace(/\.[^.]+$/, "");
+  const snapDir = snapshotsDirName ? path7.join(projectDir, snapshotsDirName, path7.relative(projectDir, path7.dirname(file))) : path7.join(path7.dirname(file), "__snapshots__");
+  fs8.mkdirSync(snapDir, { recursive: true });
+  const base = path7.basename(file).replace(/\.[^.]+$/, "");
   const snapshots = [];
   if (!simulationOnly && (pcbOnly || !schematicOnly)) {
     let pcbSnapshotType = "pcb";
@@ -3889,17 +4046,17 @@ var processSnapshotFile = async ({
   for (const snapshot of snapshots) {
     const { type } = snapshot;
     const is3d = type === "3d";
-    const snapPath = path6.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-    const existing = fs7.existsSync(snapPath);
+    const snapPath = path7.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+    const existing = fs8.existsSync(snapPath);
     const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
     const newContentForFile = snapshot.content;
     if (!existing) {
-      fs7.writeFileSync(snapPath, newContentForFile);
-      successPaths.push(path6.relative(projectDir, snapPath));
+      fs8.writeFileSync(snapPath, newContentForFile);
+      successPaths.push(path7.relative(projectDir, snapPath));
       didUpdate = true;
       continue;
     }
-    const oldContentBuffer = fs7.readFileSync(snapPath);
+    const oldContentBuffer = fs8.readFileSync(snapPath);
     let equal;
     let diffPath;
     if (createDiff) {
@@ -3911,16 +4068,16 @@ var processSnapshotFile = async ({
     }
     if (update) {
       if (!forceUpdate && equal) {
-        successPaths.push(path6.relative(projectDir, snapPath));
+        successPaths.push(path7.relative(projectDir, snapPath));
       } else {
-        fs7.writeFileSync(snapPath, newContentForFile);
-        successPaths.push(path6.relative(projectDir, snapPath));
+        fs8.writeFileSync(snapPath, newContentForFile);
+        successPaths.push(path7.relative(projectDir, snapPath));
         didUpdate = true;
       }
     } else if (!equal) {
       mismatches.push(diffPath ? `${snapPath} (diff: ${diffPath})` : snapPath);
     } else {
-      successPaths.push(path6.relative(projectDir, snapPath));
+      successPaths.push(path7.relative(projectDir, snapPath));
     }
   }
   return {
@@ -3933,8 +4090,8 @@ var processSnapshotFile = async ({
 };
 
 // lib/project-config/index.ts
-import * as fs8 from "node:fs";
-import * as path7 from "node:path";
+import * as fs9 from "node:fs";
+import * as path8 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // lib/project-config/project-config-schema.ts
@@ -4009,10 +4166,10 @@ var stripWrappingQuotes = (value) => {
 var loadProjectEnv = (projectDir) => {
   const initialEnvKeys = new Set(Object.keys(process.env));
   for (const envFileName of ENV_FILENAMES) {
-    const envPath = path7.join(projectDir, envFileName);
-    if (!fs8.existsSync(envPath))
+    const envPath = path8.join(projectDir, envFileName);
+    if (!fs9.existsSync(envPath))
       continue;
-    const envContent = fs8.readFileSync(envPath, "utf8");
+    const envContent = fs9.readFileSync(envPath, "utf8");
     for (const rawLine of envContent.split(/\r?\n/)) {
       const line = rawLine.trim();
       if (!line || line.startsWith("#"))
@@ -4030,12 +4187,12 @@ var loadProjectEnv = (projectDir) => {
   }
 };
 var loadProjectConfigSync = (projectDir = process.cwd()) => {
-  const configPath = path7.join(projectDir, CONFIG_FILENAME);
-  if (!fs8.existsSync(configPath)) {
+  const configPath = path8.join(projectDir, CONFIG_FILENAME);
+  if (!fs9.existsSync(configPath)) {
     return null;
   }
   try {
-    const configContent = fs8.readFileSync(configPath, "utf8");
+    const configContent = fs9.readFileSync(configPath, "utf8");
     const parsedConfig = JSON.parse(configContent);
     return projectConfigSchema.parse(parsedConfig);
   } catch (error) {
@@ -4046,12 +4203,12 @@ var loadProjectConfigSync = (projectDir = process.cwd()) => {
 var loadProjectConfigModule = async (projectDir) => {
   loadProjectEnv(projectDir);
   for (const configFileName of CONFIG_MODULE_FILENAMES) {
-    const configPath = path7.join(projectDir, configFileName);
-    if (!fs8.existsSync(configPath))
+    const configPath = path8.join(projectDir, configFileName);
+    if (!fs9.existsSync(configPath))
       continue;
     try {
       const moduleUrl = pathToFileURL2(configPath);
-      const stat = fs8.statSync(configPath);
+      const stat = fs9.statSync(configPath);
       moduleUrl.searchParams.set("tsci", String(stat.mtimeMs));
       const importedModule = await import(moduleUrl.href);
       const exportedConfig = importedModule.default ?? importedModule.config ?? importedModule;
@@ -4098,13 +4255,13 @@ var getSnapshotsDir = (projectDir = process.cwd()) => {
   return config?.snapshotsDir;
 };
 var saveProjectConfig = (config, projectDir = process.cwd()) => {
-  const configPath = path7.join(projectDir, CONFIG_FILENAME);
+  const configPath = path8.join(projectDir, CONFIG_FILENAME);
   try {
     const configWithSchema = {
       $schema: CONFIG_SCHEMA_URL,
       ...config ?? {}
     };
-    fs8.writeFileSync(configPath, JSON.stringify(configWithSchema, null, 2));
+    fs9.writeFileSync(configPath, JSON.stringify(configWithSchema, null, 2));
     return true;
   } catch (error) {
     console.error(`Error saving tscircuit config: ${error}`);

package/dist/lib/index.js

@@ -65811,7 +65811,7 @@ var getNodeHandler = (winterSpec, { port, middleware = [] }) => {
   }));
 };
 // package.json
-var version = "0.1.1647";
+var version = "0.1.1649";
 var package_default = {
   name: "@tscircuit/cli",
   version,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.1648",
+  "version": "0.1.1650",
   "main": "dist/cli/main.js",
   "exports": {
     ".": "./dist/cli/main.js",