@tscircuit/cli 0.1.2453 → 0.1.2454

package/dist/cli/build/build.worker.js

@@ -31483,7 +31483,7 @@ var init_dot_prop = __esm(() => {
 });
 
 // node_modules/env-paths/index.js
-import path13 from "node:path";
+import path14 from "node:path";
 import os from "node:os";
 import process3 from "node:process";
 function envPaths(name, { suffix = "nodejs" } = {}) {
@@ -31502,32 +31502,32 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
   return linux(name);
 }
 var homedir, tmpdir, env, macos = (name) => {
-  const library = path13.join(homedir, "Library");
+  const library = path14.join(homedir, "Library");
   return {
-    data: path13.join(library, "Application Support", name),
-    config: path13.join(library, "Preferences", name),
-    cache: path13.join(library, "Caches", name),
-    log: path13.join(library, "Logs", name),
-    temp: path13.join(tmpdir, name)
+    data: path14.join(library, "Application Support", name),
+    config: path14.join(library, "Preferences", name),
+    cache: path14.join(library, "Caches", name),
+    log: path14.join(library, "Logs", name),
+    temp: path14.join(tmpdir, name)
   };
 }, windows = (name) => {
-  const appData = env.APPDATA || path13.join(homedir, "AppData", "Roaming");
-  const localAppData = env.LOCALAPPDATA || path13.join(homedir, "AppData", "Local");
+  const appData = env.APPDATA || path14.join(homedir, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path14.join(homedir, "AppData", "Local");
   return {
-    data: path13.join(localAppData, name, "Data"),
-    config: path13.join(appData, name, "Config"),
-    cache: path13.join(localAppData, name, "Cache"),
-    log: path13.join(localAppData, name, "Log"),
-    temp: path13.join(tmpdir, name)
+    data: path14.join(localAppData, name, "Data"),
+    config: path14.join(appData, name, "Config"),
+    cache: path14.join(localAppData, name, "Cache"),
+    log: path14.join(localAppData, name, "Log"),
+    temp: path14.join(tmpdir, name)
   };
 }, linux = (name) => {
-  const username = path13.basename(homedir);
+  const username = path14.basename(homedir);
   return {
-    data: path13.join(env.XDG_DATA_HOME || path13.join(homedir, ".local", "share"), name),
-    config: path13.join(env.XDG_CONFIG_HOME || path13.join(homedir, ".config"), name),
-    cache: path13.join(env.XDG_CACHE_HOME || path13.join(homedir, ".cache"), name),
-    log: path13.join(env.XDG_STATE_HOME || path13.join(homedir, ".local", "state"), name),
-    temp: path13.join(tmpdir, username, name)
+    data: path14.join(env.XDG_DATA_HOME || path14.join(homedir, ".local", "share"), name),
+    config: path14.join(env.XDG_CONFIG_HOME || path14.join(homedir, ".config"), name),
+    cache: path14.join(env.XDG_CACHE_HOME || path14.join(homedir, ".cache"), name),
+    log: path14.join(env.XDG_STATE_HOME || path14.join(homedir, ".local", "state"), name),
+    temp: path14.join(tmpdir, username, name)
   };
 };
 var init_env_paths = __esm(() => {
@@ -31685,7 +31685,7 @@ var init_constants2 = __esm(() => {
 });
 
 // node_modules/stubborn-fs/dist/index.js
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import { promisify } from "node:util";
 var FS, dist_default;
 var init_dist4 = __esm(() => {
@@ -31694,41 +31694,41 @@ var init_dist4 = __esm(() => {
   init_constants2();
   FS = {
     attempt: {
-      chmod: attemptify_async_default(promisify(fs10.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-      chown: attemptify_async_default(promisify(fs10.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-      close: attemptify_async_default(promisify(fs10.close), ATTEMPTIFY_NOOP_OPTIONS),
-      fsync: attemptify_async_default(promisify(fs10.fsync), ATTEMPTIFY_NOOP_OPTIONS),
-      mkdir: attemptify_async_default(promisify(fs10.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
-      realpath: attemptify_async_default(promisify(fs10.realpath), ATTEMPTIFY_NOOP_OPTIONS),
-      stat: attemptify_async_default(promisify(fs10.stat), ATTEMPTIFY_NOOP_OPTIONS),
-      unlink: attemptify_async_default(promisify(fs10.unlink), ATTEMPTIFY_NOOP_OPTIONS),
-      chmodSync: attemptify_sync_default(fs10.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-      chownSync: attemptify_sync_default(fs10.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-      closeSync: attemptify_sync_default(fs10.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
-      existsSync: attemptify_sync_default(fs10.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
-      fsyncSync: attemptify_sync_default(fs10.fsync, ATTEMPTIFY_NOOP_OPTIONS),
-      mkdirSync: attemptify_sync_default(fs10.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
-      realpathSync: attemptify_sync_default(fs10.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
-      statSync: attemptify_sync_default(fs10.statSync, ATTEMPTIFY_NOOP_OPTIONS),
-      unlinkSync: attemptify_sync_default(fs10.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
+      chmod: attemptify_async_default(promisify(fs11.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+      chown: attemptify_async_default(promisify(fs11.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+      close: attemptify_async_default(promisify(fs11.close), ATTEMPTIFY_NOOP_OPTIONS),
+      fsync: attemptify_async_default(promisify(fs11.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+      mkdir: attemptify_async_default(promisify(fs11.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+      realpath: attemptify_async_default(promisify(fs11.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+      stat: attemptify_async_default(promisify(fs11.stat), ATTEMPTIFY_NOOP_OPTIONS),
+      unlink: attemptify_async_default(promisify(fs11.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+      chmodSync: attemptify_sync_default(fs11.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+      chownSync: attemptify_sync_default(fs11.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+      closeSync: attemptify_sync_default(fs11.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+      existsSync: attemptify_sync_default(fs11.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+      fsyncSync: attemptify_sync_default(fs11.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+      mkdirSync: attemptify_sync_default(fs11.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+      realpathSync: attemptify_sync_default(fs11.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+      statSync: attemptify_sync_default(fs11.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+      unlinkSync: attemptify_sync_default(fs11.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
     },
     retry: {
-      close: retryify_async_default(promisify(fs10.close), RETRYIFY_OPTIONS),
-      fsync: retryify_async_default(promisify(fs10.fsync), RETRYIFY_OPTIONS),
-      open: retryify_async_default(promisify(fs10.open), RETRYIFY_OPTIONS),
-      readFile: retryify_async_default(promisify(fs10.readFile), RETRYIFY_OPTIONS),
-      rename: retryify_async_default(promisify(fs10.rename), RETRYIFY_OPTIONS),
-      stat: retryify_async_default(promisify(fs10.stat), RETRYIFY_OPTIONS),
-      write: retryify_async_default(promisify(fs10.write), RETRYIFY_OPTIONS),
-      writeFile: retryify_async_default(promisify(fs10.writeFile), RETRYIFY_OPTIONS),
-      closeSync: retryify_sync_default(fs10.closeSync, RETRYIFY_OPTIONS),
-      fsyncSync: retryify_sync_default(fs10.fsyncSync, RETRYIFY_OPTIONS),
-      openSync: retryify_sync_default(fs10.openSync, RETRYIFY_OPTIONS),
-      readFileSync: retryify_sync_default(fs10.readFileSync, RETRYIFY_OPTIONS),
-      renameSync: retryify_sync_default(fs10.renameSync, RETRYIFY_OPTIONS),
-      statSync: retryify_sync_default(fs10.statSync, RETRYIFY_OPTIONS),
-      writeSync: retryify_sync_default(fs10.writeSync, RETRYIFY_OPTIONS),
-      writeFileSync: retryify_sync_default(fs10.writeFileSync, RETRYIFY_OPTIONS)
+      close: retryify_async_default(promisify(fs11.close), RETRYIFY_OPTIONS),
+      fsync: retryify_async_default(promisify(fs11.fsync), RETRYIFY_OPTIONS),
+      open: retryify_async_default(promisify(fs11.open), RETRYIFY_OPTIONS),
+      readFile: retryify_async_default(promisify(fs11.readFile), RETRYIFY_OPTIONS),
+      rename: retryify_async_default(promisify(fs11.rename), RETRYIFY_OPTIONS),
+      stat: retryify_async_default(promisify(fs11.stat), RETRYIFY_OPTIONS),
+      write: retryify_async_default(promisify(fs11.write), RETRYIFY_OPTIONS),
+      writeFile: retryify_async_default(promisify(fs11.writeFile), RETRYIFY_OPTIONS),
+      closeSync: retryify_sync_default(fs11.closeSync, RETRYIFY_OPTIONS),
+      fsyncSync: retryify_sync_default(fs11.fsyncSync, RETRYIFY_OPTIONS),
+      openSync: retryify_sync_default(fs11.openSync, RETRYIFY_OPTIONS),
+      readFileSync: retryify_sync_default(fs11.readFileSync, RETRYIFY_OPTIONS),
+      renameSync: retryify_sync_default(fs11.renameSync, RETRYIFY_OPTIONS),
+      statSync: retryify_sync_default(fs11.statSync, RETRYIFY_OPTIONS),
+      writeSync: retryify_sync_default(fs11.writeSync, RETRYIFY_OPTIONS),
+      writeFileSync: retryify_sync_default(fs11.writeFileSync, RETRYIFY_OPTIONS)
     }
   };
   dist_default = FS;
@@ -31835,7 +31835,7 @@ var init_node = __esm(() => {
 });
 
 // node_modules/atomically/dist/utils/temp.js
-import path14 from "node:path";
+import path15 from "node:path";
 var Temp, temp_default;
 var init_temp = __esm(() => {
   init_dist4();
@@ -31877,7 +31877,7 @@ var init_temp = __esm(() => {
       }
     },
     truncate: (filePath) => {
-      const basename = path14.basename(filePath);
+      const basename = path15.basename(filePath);
       if (basename.length <= LIMIT_BASENAME_LENGTH)
         return filePath;
       const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename);
@@ -31892,7 +31892,7 @@ var init_temp = __esm(() => {
 });
 
 // node_modules/atomically/dist/index.js
-import path15 from "node:path";
+import path16 from "node:path";
 function writeFileSync2(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
   if (isString(options))
     return writeFileSync2(filePath, data, { encoding: options });
@@ -31921,7 +31921,7 @@ function writeFileSync2(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
       }
     }
     if (!filePathExists) {
-      const parentPath = path15.dirname(filePath);
+      const parentPath = path16.dirname(filePath);
       dist_default.attempt.mkdirSync(parentPath, {
         mode: DEFAULT_FOLDER_MODE,
         recursive: true
@@ -39865,8 +39865,8 @@ var init_uint8array_extras = __esm(() => {
 // node_modules/conf/dist/source/index.js
 import { isDeepStrictEqual } from "node:util";
 import process8 from "node:process";
-import fs11 from "node:fs";
-import path16 from "node:path";
+import fs12 from "node:fs";
+import path17 from "node:path";
 import crypto from "node:crypto";
 import assert3 from "node:assert";
 var import__2020, import_ajv_formats, import_semver2, ajvFormats, encryptionAlgorithm = "aes-256-cbc", createPlainObject = () => Object.create(null), isExist = (data) => data !== undefined && data !== null, checkValueType = (key, value) => {
@@ -39952,7 +39952,7 @@ var init_source = __esm(() => {
       this.events = new EventTarget;
       this.#encryptionKey = options.encryptionKey;
       const fileExtension = options.fileExtension ? `.${options.fileExtension}` : "";
-      this.path = path16.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
+      this.path = path17.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
       const fileStore = this.store;
       const store = Object.assign(createPlainObject(), options.defaults, fileStore);
       if (options.migrations) {
@@ -40055,7 +40055,7 @@ var init_source = __esm(() => {
     }
     get store() {
       try {
-        const data = fs11.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
+        const data = fs12.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
         const dataString = this._encryptData(data);
         const deserializedData = this._deserialize(dataString);
         this._validate(deserializedData);
@@ -40126,7 +40126,7 @@ var init_source = __esm(() => {
       throw new Error("Config schema violation: " + errors.join("; "));
     }
     _ensureDirectory() {
-      fs11.mkdirSync(path16.dirname(this.path), { recursive: true });
+      fs12.mkdirSync(path17.dirname(this.path), { recursive: true });
     }
     _write(value) {
       let data = this._serialize(value);
@@ -40137,13 +40137,13 @@ var init_source = __esm(() => {
         data = concatUint8Arrays2([initializationVector, stringToUint8Array(":"), cipher.update(stringToUint8Array(data)), cipher.final()]);
       }
       if (process8.env.SNAP) {
-        fs11.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+        fs12.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
       } else {
         try {
           writeFileSync2(this.path, data, { mode: this.#options.configFileMode });
         } catch (error) {
           if (error?.code === "EXDEV") {
-            fs11.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+            fs12.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
             return;
           }
           throw error;
@@ -40152,15 +40152,15 @@ var init_source = __esm(() => {
     }
     _watch() {
       this._ensureDirectory();
-      if (!fs11.existsSync(this.path)) {
+      if (!fs12.existsSync(this.path)) {
         this._write(createPlainObject());
       }
       if (process8.platform === "win32") {
-        fs11.watch(this.path, { persistent: false }, debounce_fn_default(() => {
+        fs12.watch(this.path, { persistent: false }, debounce_fn_default(() => {
           this.events.dispatchEvent(new Event("change"));
         }, { wait: 100 }));
       } else {
-        fs11.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
+        fs12.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
           this.events.dispatchEvent(new Event("change"));
         }, { wait: 5000 }));
       }
@@ -40300,9 +40300,9 @@ var init_esm2 = __esm(() => {
 });
 
 // lib/shared/handle-registry-auth-error.ts
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 import os2 from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 function isUnauthorizedError(error) {
   const output = [
     error instanceof Error ? error.message : "",
@@ -40322,9 +40322,9 @@ function isUnauthorizedError(error) {
   return /\b(401|E401)\b/i.test(output) || /unauthorized/i.test(output);
 }
 function hasTsciAuthToken(npmrcPath) {
-  if (!fs12.existsSync(npmrcPath))
+  if (!fs13.existsSync(npmrcPath))
     return false;
-  const content = fs12.readFileSync(npmrcPath, "utf-8");
+  const content = fs13.readFileSync(npmrcPath, "utf-8");
   return AUTH_TOKEN_REGEX.test(content);
 }
 function handleRegistryAuthError({
@@ -40334,8 +40334,8 @@ function handleRegistryAuthError({
   if (!isUnauthorizedError(error))
     return;
   const npmrcPaths = [
-    path17.join(projectDir, ".npmrc"),
-    path17.join(os2.homedir(), ".npmrc")
+    path18.join(projectDir, ".npmrc"),
+    path18.join(os2.homedir(), ".npmrc")
   ];
   const hasToken = npmrcPaths.some(hasTsciAuthToken);
   if (hasToken) {
@@ -40351,9 +40351,9 @@ var init_handle_registry_auth_error = __esm(() => {
 });
 
 // lib/cli-config/index.ts
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 import os3 from "node:os";
-import path18 from "node:path";
+import path19 from "node:path";
 var getCliConfig = (opts = {}) => {
   return new Conf({
     projectName: "tscircuit",
@@ -40363,13 +40363,13 @@ var getCliConfig = (opts = {}) => {
   return process.env.TSCIRCUIT_TOKEN || cliConfig.get("sessionToken");
 }, getSessionTokenFromNpmrc = () => {
   const npmrcPaths = [
-    path18.join(process.cwd(), ".npmrc"),
-    path18.join(os3.homedir(), ".npmrc")
+    path19.join(process.cwd(), ".npmrc"),
+    path19.join(os3.homedir(), ".npmrc")
   ];
   for (const npmrcPath of npmrcPaths) {
-    if (!fs13.existsSync(npmrcPath))
+    if (!fs14.existsSync(npmrcPath))
       continue;
-    const content = fs13.readFileSync(npmrcPath, "utf-8");
+    const content = fs14.readFileSync(npmrcPath, "utf-8");
     const match = content.match(AUTH_TOKEN_REGEX);
     if (match?.[1]) {
       return match[1].trim();
@@ -40413,7 +40413,7 @@ var init_get_circuit_json_to_gltf_options = __esm(() => {
 });
 
 // cli/build/convert-model-urls-to-file-urls.ts
-import path19 from "node:path";
+import path20 from "node:path";
 import { pathToFileURL as pathToFileURL5 } from "node:url";
 var convertModelUrlsToFileUrls = (circuitJson) => {
   const modelUrlKeys = [
@@ -40440,7 +40440,7 @@ var convertModelUrlsToFileUrls = (circuitJson) => {
         if (value.startsWith("/") || value.match(/^[a-zA-Z]:\\/)) {
           updated[key] = pathToFileURL5(value).href;
         } else if (value.startsWith(".")) {
-          updated[key] = pathToFileURL5(path19.resolve(process.cwd(), value)).href;
+          updated[key] = pathToFileURL5(path20.resolve(process.cwd(), value)).href;
         }
       }
     }
@@ -40453,8 +40453,8 @@ var init_convert_model_urls_to_file_urls = () => {};
 import { parentPort } from "node:worker_threads";
 
 // cli/build/worker-build-handlers.ts
-import fs15 from "node:fs";
-import path21 from "node:path";
+import fs16 from "node:fs";
+import path22 from "node:path";
 
 // lib/project-config/index.ts
 import * as fs from "node:fs";
@@ -40676,6 +40676,7 @@ var saveProjectConfig = (config, projectDir = process.cwd()) => {
 };
 
 // lib/shared/circuit-json-diagnostics.ts
+var getIssueType = (issue) => issue.warning_type ?? issue.error_type ?? issue.type ?? "unknown_issue";
 function analyzeCircuitJson(circuitJson) {
   const errors = [];
   const warnings = [];
@@ -40703,16 +40704,60 @@ function formatCircuitJsonDiagnostics({
 }) {
   const lines = [`Errors: ${errors.length}`, `Warnings: ${warnings.length}`];
   for (const issue of [...errors, ...warnings]) {
-    const issueType = issue.warning_type ?? issue.error_type ?? issue.type ?? "unknown_issue";
-    lines.push(`- ${issueType}: ${issue.message ?? ""}`);
+    lines.push(`- ${getIssueType(issue)}: ${issue.message ?? ""}`);
   }
   return lines.join(`
 `);
 }
 
+// lib/shared/collapse-repeated-issues.ts
+var MAX_ISSUES_LOGGED_PER_TYPE = 10;
+function collapseRepeatedIssues(issues, { maxPerType = MAX_ISSUES_LOGGED_PER_TYPE } = {}) {
+  const countByType = new Map;
+  const issuesToLog = [];
+  for (const issue of issues) {
+    const issueType = getIssueType(issue);
+    const count = (countByType.get(issueType) ?? 0) + 1;
+    countByType.set(issueType, count);
+    if (count <= maxPerType)
+      issuesToLog.push(issue);
+  }
+  const omittedLines = [];
+  for (const [issueType, count] of countByType) {
+    if (count > maxPerType) {
+      omittedLines.push(`… ${count - maxPerType} more ${issueType} not shown`);
+    }
+  }
+  return { issuesToLog, omittedLines };
+}
+function getIssueTypeCountLines(issues) {
+  const countByType = new Map;
+  for (const issue of issues) {
+    const issueType = getIssueType(issue);
+    countByType.set(issueType, (countByType.get(issueType) ?? 0) + 1);
+  }
+  const width = String(Math.max(0, ...countByType.values())).length;
+  return [...countByType].sort(([typeA, a], [typeB, b]) => b - a || typeA.localeCompare(typeB)).map(([issueType, count]) => `  ${String(count).padStart(width)}  ${issueType}`);
+}
+
+// lib/shared/write-build-errors-file.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+var BUILD_ERRORS_FILE_NAME = "errors.json";
+function writeBuildErrorsFile(circuitJsonOutputPath, errors) {
+  const errorsFilePath = path2.join(path2.dirname(circuitJsonOutputPath), BUILD_ERRORS_FILE_NAME);
+  if (errors.length === 0) {
+    fs2.rmSync(errorsFilePath, { force: true });
+    return null;
+  }
+  fs2.writeFileSync(errorsFilePath, `${JSON.stringify(errors, null, 2)}
+`);
+  return errorsFilePath;
+}
+
 // lib/shared/generate-circuit-json.tsx
-import fs8 from "node:fs";
-import path10 from "node:path";
+import fs9 from "node:fs";
+import path11 from "node:path";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
 import Debug from "debug";
 
@@ -40735,8 +40780,8 @@ var import_make_vfs = __toESM(require_dist(), 1);
 
 // lib/shared/autorouter-diagnostics.ts
 init_kleur();
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 import { convertCircuitJsonToPcbSvg } from "circuit-to-svg";
 
 // lib/shared/compute-cost-summary.ts
@@ -40769,7 +40814,7 @@ var convertSvgToPngBuffer = (svg) => {
 };
 
 // lib/shared/autorouter-diagnostics.ts
-var DEFAULT_DEBUG_DIR = path2.join("dist", "autorouter-debug");
+var DEFAULT_DEBUG_DIR = path3.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) => {
@@ -41236,10 +41281,10 @@ class AutorouterDiagnostics {
     return this.options.dumpSrj === "all" || this.options.dumpSrj === "failed" || this.options.dumpSrj === `phase:${routingPhaseIndex}`;
   }
   writeJson(fileName, value) {
-    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));
+    const debugDir = path3.resolve(this.options.debugDir ?? DEFAULT_DEBUG_DIR);
+    fs3.mkdirSync(debugDir, { recursive: true });
+    const filePath = path3.join(debugDir, fileName);
+    fs3.writeFileSync(filePath, JSON.stringify(value, null, 2));
     this.logArtifact(filePath);
     return filePath;
   }
@@ -41247,10 +41292,10 @@ class AutorouterDiagnostics {
     try {
       const pcbSvg = convertCircuitJsonToPcbSvg(circuitJson, options);
       const png = convertSvgToPngBuffer(pcbSvg);
-      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);
+      const debugDir = path3.resolve(this.options.debugDir ?? DEFAULT_DEBUG_DIR);
+      fs3.mkdirSync(debugDir, { recursive: true });
+      const filePath = path3.join(debugDir, fileName);
+      fs3.writeFileSync(filePath, png);
       this.logArtifact(filePath);
     } catch (error) {
       const serializedError = this.serializeError(error instanceof Error ? error : String(error));
@@ -41258,7 +41303,7 @@ class AutorouterDiagnostics {
     }
   }
   logArtifact(filePath) {
-    this.log(`Wrote debug artifact: ${path2.relative(process.cwd(), filePath)}`);
+    this.log(`Wrote debug artifact: ${path3.relative(process.cwd(), filePath)}`);
   }
   getCircuitJsonWithCompletedPhaseTraces() {
     const circuitJson = [...this.getCurrentCircuitJson()];
@@ -41468,13 +41513,13 @@ class AutorouterDiagnostics {
 }
 
 // lib/shared/autorouting-artifacts.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs4 from "node:fs";
+import path4 from "node:path";
 import { createHash } from "node:crypto";
 function attachAutoroutingArtifacts(root, filePath, projectDir = process.cwd()) {
-  const entryPath = path3.relative(projectDir, path3.resolve(projectDir, filePath));
-  const entryKey = `${path3.basename(filePath).replace(/[^a-zA-Z0-9_-]/g, "-")}-${createHash("sha256").update(entryPath).digest("hex").slice(0, 10)}`;
-  const directory = path3.resolve(projectDir, ".tscircuit", "autorouting-artifacts", entryKey);
+  const entryPath = path4.relative(projectDir, path4.resolve(projectDir, filePath));
+  const entryKey = `${path4.basename(filePath).replace(/[^a-zA-Z0-9_-]/g, "-")}-${createHash("sha256").update(entryPath).digest("hex").slice(0, 10)}`;
+  const directory = path4.resolve(projectDir, ".tscircuit", "autorouting-artifacts", entryKey);
   let warnedUnsupportedVersion = false;
   root.on("autorouting:end", (event) => {
     try {
@@ -41494,14 +41539,14 @@ function attachAutoroutingArtifacts(root, filePath, projectDir = process.cwd())
       const order = event._actualRoutingPhaseOrderIndex;
       const safeSubcircuit = event.subcircuit_id.replace(/[^a-zA-Z0-9_-]/g, "-");
       const stage = event.phaseStageIndex === undefined ? "" : `-stage-${event.phaseStageIndex}`;
-      const outputPath = path3.join(directory, `${safeSubcircuit}-phase-${phase}-order-${order}${stage}.pcb-trace-paths.json`);
+      const outputPath = path4.join(directory, `${safeSubcircuit}-phase-${phase}-order-${order}${stage}.pcb-trace-paths.json`);
       const contents = `${JSON.stringify(event.pcbTracePaths, null, 2)}
 `;
-      fs3.mkdirSync(directory, { recursive: true });
-      if (!fs3.existsSync(outputPath) || fs3.readFileSync(outputPath, "utf8") !== contents) {
-        fs3.writeFileSync(outputPath, contents);
+      fs4.mkdirSync(directory, { recursive: true });
+      if (!fs4.existsSync(outputPath) || fs4.readFileSync(outputPath, "utf8") !== contents) {
+        fs4.writeFileSync(outputPath, contents);
       }
-      console.log(`Saved autorouting paths to ${path3.relative(projectDir, outputPath)} (import this JSON into <autoroutingphase pcbTracePaths={...} />).`);
+      console.log(`Saved autorouting paths to ${path4.relative(projectDir, outputPath)} (import this JSON into <autoroutingphase pcbTracePaths={...} />).`);
     } catch (error) {
       console.warn(`Could not save autorouting paths for ${event.subcircuit_id}: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -41510,7 +41555,7 @@ function attachAutoroutingArtifacts(root, filePath, projectDir = process.cwd())
 
 // lib/shared/importFromUserLand.ts
 import { createRequire as createRequire2 } from "node:module";
-import path6 from "node:path";
+import path7 from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 
 // node_modules/import-meta-resolve/lib/resolve.js
@@ -41518,15 +41563,15 @@ import assert2 from "node:assert";
 import { statSync as statSync2, realpathSync } from "node:fs";
 import process2 from "node:process";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
-import path5 from "node:path";
+import path6 from "node:path";
 import { builtinModules } from "node:module";
 
 // node_modules/import-meta-resolve/lib/get-format.js
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // node_modules/import-meta-resolve/lib/package-json-reader.js
-import fs4 from "node:fs";
-import path4 from "node:path";
+import fs5 from "node:fs";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // node_modules/import-meta-resolve/lib/errors.js
@@ -41759,7 +41804,7 @@ function read(jsonPath, { base, specifier }) {
   }
   let string;
   try {
-    string = fs4.readFileSync(path4.toNamespacedPath(jsonPath), "utf8");
+    string = fs5.readFileSync(path5.toNamespacedPath(jsonPath), "utf8");
   } catch (error) {
     const exception = error;
     if (exception.code !== "ENOENT") {
@@ -41976,7 +42021,7 @@ function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
   if (!main) {
     process2.emitWarning(`No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(packagePath.length)}", imported from ${basePath}.
 Default "index" lookups for the main are deprecated for ES modules.`, "DeprecationWarning", "DEP0151");
-  } else if (path5.resolve(packagePath, main) !== urlPath) {
+  } else if (path6.resolve(packagePath, main) !== urlPath) {
     process2.emitWarning(`Package ${packagePath} has a "main" field set to "${main}", ` + `excluding the full filename and extension to the resolved file at "${urlPath.slice(packagePath.length)}", imported from ${basePath}.
  Automatic extension resolution of the "main" field is ` + "deprecated for ES modules.", "DeprecationWarning", "DEP0151");
   }
@@ -42058,7 +42103,7 @@ function finalizeResolution(resolved, base, preserveSymlinks) {
   if (!preserveSymlinks) {
     const real = realpathSync(filePath);
     const { search, hash } = resolved;
-    resolved = pathToFileURL2(real + (filePath.endsWith(path5.sep) ? "/" : ""));
+    resolved = pathToFileURL2(real + (filePath.endsWith(path6.sep) ? "/" : ""));
     resolved.search = search;
     resolved.hash = hash;
   }
@@ -42526,7 +42571,7 @@ function resolve(specifier, parent) {
 // lib/shared/importFromUserLand.ts
 async function importFromUserLand(moduleName, projectDir = process.cwd()) {
   for (const parent of [
-    pathToFileURL3(path6.join(projectDir, "noop.js")).href,
+    pathToFileURL3(path7.join(projectDir, "noop.js")).href,
     import.meta.url
   ]) {
     let resolved;
@@ -42547,8 +42592,8 @@ async function importFromUserLand(moduleName, projectDir = process.cwd()) {
 }
 
 // lib/shared/register-static-asset-loaders.ts
-import fs5 from "node:fs";
-import path7 from "node:path";
+import fs6 from "node:fs";
+import path8 from "node:path";
 var STATIC_ASSET_EXTENSIONS = [
   ".glb",
   ".gltf",
@@ -42575,15 +42620,15 @@ var TEXT_STATIC_ASSET_EXTENSIONS = new Set([
   ".kicad_sym"
 ]);
 var readFileContentForStaticLoader = (filePath) => {
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path8.extname(filePath).toLowerCase();
   if (TEXT_STATIC_ASSET_EXTENSIONS.has(ext)) {
-    return fs5.readFileSync(filePath, "utf-8");
+    return fs6.readFileSync(filePath, "utf-8");
   }
-  const buffer = fs5.readFileSync(filePath);
+  const buffer = fs6.readFileSync(filePath);
   return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
 };
 var getStaticFileLoader = (filePath) => {
-  const extWithDot = path7.extname(filePath).toLowerCase();
+  const extWithDot = path8.extname(filePath).toLowerCase();
   const ext = extWithDot.replace(/^\./, "");
   return activePlatformConfig?.staticFileLoaderMap?.[ext] ?? activePlatformConfig?.staticFileLoaderMap?.[extWithDot];
 };
@@ -42597,12 +42642,12 @@ var normalizeStaticFileLoaderResult = (result) => {
   };
 };
 var getBaseUrlFromTsConfig = (projectDir) => {
-  const tsconfigPath = path7.join(projectDir, "tsconfig.json");
+  const tsconfigPath = path8.join(projectDir, "tsconfig.json");
   try {
-    if (!fs5.existsSync(tsconfigPath)) {
+    if (!fs6.existsSync(tsconfigPath)) {
       return null;
     }
-    const tsconfigContent = fs5.readFileSync(tsconfigPath, "utf-8");
+    const tsconfigContent = fs6.readFileSync(tsconfigPath, "utf-8");
     const tsconfig = JSON.parse(tsconfigContent);
     if (tsconfig.compilerOptions?.baseUrl) {
       return tsconfig.compilerOptions.baseUrl;
@@ -42629,8 +42674,8 @@ var registerStaticAssetLoaders = (platformConfig, projectDir = process.cwd()) =>
               loader: "object"
             };
           }
-          const baseDir = baseUrl ? path7.resolve(projectDir, baseUrl) : projectDir;
-          const relativePath = path7.relative(baseDir, args.path).split(path7.sep).join("/");
+          const baseDir = baseUrl ? path8.resolve(projectDir, baseUrl) : projectDir;
+          const relativePath = path8.relative(baseDir, args.path).split(path8.sep).join("/");
           const pathStr = `./${relativePath}`;
           return {
             exports: {
@@ -42646,8 +42691,8 @@ var registerStaticAssetLoaders = (platformConfig, projectDir = process.cwd()) =>
 };
 
 // lib/shared/circuit-json-build-cache.ts
-import fs6 from "node:fs";
-import path8 from "node:path";
+import fs7 from "node:fs";
+import path9 from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 var SOURCE_FILE_EXTENSIONS = new Set([
   ".tsx",
@@ -42671,43 +42716,43 @@ var IGNORED_DIRECTORY_NAMES = new Set([
   ".git"
 ]);
 var isPathInside = (childPath, parentPath) => {
-  const relative = path8.relative(parentPath, childPath);
-  return relative === "" || !relative.startsWith("..") && !path8.isAbsolute(relative);
+  const relative = path9.relative(parentPath, childPath);
+  return relative === "" || !relative.startsWith("..") && !path9.isAbsolute(relative);
 };
 var findCircuitProjectDir = (filePath) => {
-  const absoluteFilePath = path8.resolve(filePath);
-  let currentDir = path8.dirname(absoluteFilePath);
+  const absoluteFilePath = path9.resolve(filePath);
+  let currentDir = path9.dirname(absoluteFilePath);
   while (true) {
-    if (fs6.existsSync(path8.join(currentDir, "package.json"))) {
+    if (fs7.existsSync(path9.join(currentDir, "package.json"))) {
       return currentDir;
     }
-    const parentDir = path8.dirname(currentDir);
+    const parentDir = path9.dirname(currentDir);
     if (parentDir === currentDir)
       break;
     currentDir = parentDir;
   }
-  const cwd = path8.resolve(process.cwd());
-  return isPathInside(absoluteFilePath, cwd) ? cwd : path8.dirname(absoluteFilePath);
+  const cwd = path9.resolve(process.cwd());
+  return isPathInside(absoluteFilePath, cwd) ? cwd : path9.dirname(absoluteFilePath);
 };
 var getCircuitJsonOutputDirName = (relativePath) => {
   const normalizedRelativePath = relativePath.toLowerCase().replaceAll("\\", "/");
   if (normalizedRelativePath === "circuit.json" || normalizedRelativePath.endsWith("/circuit.json")) {
-    return path8.dirname(relativePath);
+    return path9.dirname(relativePath);
   }
   return relativePath.replace(/(\.board|\.circuit)?\.tsx$/, "").replace(/\.circuit\.json$/, "");
 };
 var getCircuitJsonBuildOutputPath = (filePath) => {
-  const absoluteFilePath = path8.resolve(filePath);
+  const absoluteFilePath = path9.resolve(filePath);
   const projectDir = findCircuitProjectDir(absoluteFilePath);
-  const relativePath = path8.relative(projectDir, absoluteFilePath);
-  return path8.join(projectDir, "dist", getCircuitJsonOutputDirName(relativePath), "circuit.json");
+  const relativePath = path9.relative(projectDir, absoluteFilePath);
+  return path9.join(projectDir, "dist", getCircuitJsonOutputDirName(relativePath), "circuit.json");
 };
 var getSourceFilePaths = (projectDir) => {
   const sourceFilePaths = [];
   const visit = (directoryPath) => {
-    const entries = fs6.readdirSync(directoryPath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    const entries = fs7.readdirSync(directoryPath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const entryPath = path8.join(directoryPath, entry.name);
+      const entryPath = path9.join(directoryPath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRECTORY_NAMES.has(entry.name) || entry.name.startsWith(".")) {
           continue;
@@ -42715,7 +42760,7 @@ var getSourceFilePaths = (projectDir) => {
         visit(entryPath);
         continue;
       }
-      if (!entry.isFile() || entry.name.endsWith(".circuit.json") || !SOURCE_FILE_EXTENSIONS.has(path8.extname(entry.name).toLowerCase())) {
+      if (!entry.isFile() || entry.name.endsWith(".circuit.json") || !SOURCE_FILE_EXTENSIONS.has(path9.extname(entry.name).toLowerCase())) {
         continue;
       }
       sourceFilePaths.push(entryPath);
@@ -42728,8 +42773,8 @@ var getSourceFilesystemMd5Hash = (filePath) => {
   const projectDir = findCircuitProjectDir(filePath);
   const hash = createHash2("md5");
   for (const sourceFilePath of getSourceFilePaths(projectDir)) {
-    const relativePath = path8.relative(projectDir, sourceFilePath).split(path8.sep).join("/");
-    const content = fs6.readFileSync(sourceFilePath);
+    const relativePath = path9.relative(projectDir, sourceFilePath).split(path9.sep).join("/");
+    const content = fs7.readFileSync(sourceFilePath);
     hash.update(`${Buffer.byteLength(relativePath)}:`);
     hash.update(relativePath);
     hash.update(`${content.byteLength}:`);
@@ -42764,7 +42809,7 @@ var readCurrentCircuitJsonBuild = ({
 }) => {
   const outputPath = getCircuitJsonBuildOutputPath(filePath);
   try {
-    const parsed = JSON.parse(fs6.readFileSync(outputPath, "utf-8"));
+    const parsed = JSON.parse(fs7.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);
@@ -42778,8 +42823,8 @@ var readCurrentCircuitJsonBuild = ({
 };
 
 // lib/shared/solver-diagnostics.ts
-import fs7 from "node:fs";
-import path9 from "node:path";
+import fs8 from "node:fs";
+import path10 from "node:path";
 var escapeJsonPointerSegment = (segment) => segment.replaceAll("~", "~0").replaceAll("/", "~1");
 var cloneAsJson = (value, ancestors = new WeakMap, path = "#") => {
   if (value === undefined)
@@ -42880,8 +42925,8 @@ class SolverDiagnostics {
   finalize() {
     if (!this.options.enabled)
       return;
-    fs7.mkdirSync(path9.dirname(this.options.outputPath), { recursive: true });
-    fs7.writeFileSync(this.options.outputPath, `${JSON.stringify({
+    fs8.mkdirSync(path10.dirname(this.options.outputPath), { recursive: true });
+    fs8.writeFileSync(this.options.outputPath, `${JSON.stringify({
       format: "tscircuit_solver_debug_v1",
       entrypoint: this.options.entrypoint,
       solvers: this.solverInvocations
@@ -42924,7 +42969,7 @@ async function generateCircuitJson({
 }) {
   debug(`Generating circuit JSON for ${filePath}`);
   const currentSourceFilesystemMd5Hash = sourceFilesystemMd5Hash ?? getSourceFilesystemMd5Hash(filePath);
-  const projectRootDir = path10.resolve(projectDirOption ?? process.cwd());
+  const projectRootDir = path11.resolve(projectDirOption ?? process.cwd());
   const React = await importFromUserLand("react", projectRootDir);
   globalThis.React = React;
   registerStaticAssetLoaders(platformConfig, projectRootDir);
@@ -42937,12 +42982,12 @@ async function generateCircuitJson({
   const solverDiagnostics = solverDiagnosticsOptions ? new SolverDiagnostics(solverDiagnosticsOptions) : null;
   solverDiagnostics?.attachToRootCircuit(runner);
   attachAutoroutingArtifacts(runner, filePath, projectRootDir);
-  const absoluteFilePath = path10.isAbsolute(filePath) ? filePath : path10.resolve(projectRootDir, filePath);
-  const sourceDir = path10.dirname(absoluteFilePath);
+  const absoluteFilePath = path11.isAbsolute(filePath) ? filePath : path11.resolve(projectRootDir, filePath);
+  const sourceDir = path11.dirname(absoluteFilePath);
   const resolvedOutputDir = outputDir ?? sourceDir;
-  const relativeComponentPath = path10.relative(sourceDir, absoluteFilePath);
-  const baseFileName = outputFileName || path10.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path10.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  const relativeComponentPath = path11.relative(sourceDir, absoluteFilePath);
+  const baseFileName = outputFileName || path11.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path11.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
   debug(`Project directory: ${sourceDir}`);
   debug(`Relative component path: ${relativeComponentPath}`);
   debug(`Output path: ${outputPath}`);
@@ -42962,7 +43007,7 @@ async function generateCircuitJson({
           return false;
         if (normalizedFilePath.match(/^\.[^/]/))
           return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path10.extname(normalizedFilePath)))
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path11.extname(normalizedFilePath)))
           return false;
         return true;
       },
@@ -43007,7 +43052,7 @@ async function generateCircuitJson({
   await autorouterDiagnostics.finalize(circuitJson);
   if (saveToFile) {
     debug(`Saving circuit JSON to ${outputPath}`);
-    fs8.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    fs9.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
   }
   return {
     circuitJson,
@@ -43020,8 +43065,8 @@ async function generateCircuitJson({
 // lib/shared/get-platform-config-with-cli-defaults.ts
 var import_semver = __toESM(require_semver2(), 1);
 import { createHash as createHash3 } from "node:crypto";
-import fs9 from "node:fs";
-import path11 from "node:path";
+import fs10 from "node:fs";
+import path12 from "node:path";
 import { getPlatformConfig } from "@tscircuit/eval/platform-config";
 
 // lib/shared/platform-config-utils.ts
@@ -43082,25 +43127,25 @@ var getPlatformFetch = (upstreamFetch = globalThis.fetch) => {
 };
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
-function createLocalCacheEngine(cacheDir = path11.join(process.cwd(), ".tscircuit", "cache")) {
+function createLocalCacheEngine(cacheDir = path12.join(process.cwd(), ".tscircuit", "cache")) {
   return {
     getItem: (key) => {
       try {
         const hash = createHash3("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path11.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        return fs9.readFileSync(filePath, "utf-8");
+        const filePath = path12.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        return fs10.readFileSync(filePath, "utf-8");
       } catch {
         return null;
       }
     },
     setItem: (key, value) => {
       try {
-        fs9.mkdirSync(cacheDir, { recursive: true });
+        fs10.mkdirSync(cacheDir, { recursive: true });
         const hash = createHash3("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path11.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        fs9.writeFileSync(filePath, value);
+        const filePath = path12.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        fs10.writeFileSync(filePath, value);
       } catch {}
     }
   };
@@ -43108,7 +43153,7 @@ function createLocalCacheEngine(cacheDir = path11.join(process.cwd(), ".tscircui
 function getPlatformConfigWithCliDefaults(userConfig, options) {
   const projectDir = options?.projectDir ?? process.cwd();
   const basePlatformConfig = getPlatformConfig();
-  const cacheDir = path11.join(projectDir, ".tscircuit", "cache");
+  const cacheDir = path12.join(projectDir, ".tscircuit", "cache");
   const defaultConfig = {
     ...basePlatformConfig,
     autorouterThreads: process.versions.bun && !import_semver.default.satisfies(process.versions.bun, ">=1.4.2") ? 1 : 4,
@@ -43120,15 +43165,15 @@ function getPlatformConfigWithCliDefaults(userConfig, options) {
         loadFromUrl: async (url) => {
           let fetchUrl = url;
           if (url.startsWith("./") || url.startsWith("../")) {
-            const absolutePath = path11.resolve(projectDir, url);
+            const absolutePath = path12.resolve(projectDir, url);
             fetchUrl = `file://${absolutePath}`;
           } else if (url.startsWith("/")) {
-            if (fs9.existsSync(url)) {
+            if (fs10.existsSync(url)) {
               fetchUrl = `file://${url}`;
             } else {
               const relativePath = `.${url}`;
-              const absolutePath = path11.resolve(projectDir, relativePath);
-              if (fs9.existsSync(absolutePath)) {
+              const absolutePath = path12.resolve(projectDir, relativePath);
+              if (fs10.existsSync(absolutePath)) {
                 fetchUrl = `file://${absolutePath}`;
               } else {
                 fetchUrl = `file://${url}`;
@@ -43397,8 +43442,8 @@ function convertCircuitJsonToPcbSvg2(elements, options = {}) {
 }
 
 // cli/build/worker-output-generators.ts
-import fs14 from "node:fs";
-import path20 from "node:path";
+import fs15 from "node:fs";
+import path21 from "node:path";
 
 // node_modules/circuit-json-to-3d-png/dist/index.js
 function normalizeDir(dir) {
@@ -62420,7 +62465,7 @@ var getSystemSvgAssets = async (circuitJson) => {
 // lib/shared/load-local-step-model-fs-map.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile } from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 var isRemoteUrl = (value) => /^https?:\/\//i.test(value);
 async function loadLocalStepModelFsMap(circuitJson) {
   const fsMap = {};
@@ -62432,7 +62477,7 @@ async function loadLocalStepModelFsMap(circuitJson) {
       continue;
     if (isRemoteUrl(modelUrl) || fsMap[modelUrl])
       continue;
-    const localPath = path12.resolve(process.cwd(), modelUrl);
+    const localPath = path13.resolve(process.cwd(), modelUrl);
     if (!existsSync2(localPath))
       continue;
     fsMap[modelUrl] = await readFile(localPath, "utf-8");
@@ -62542,13 +62587,13 @@ var writeDiagramSvgAssetsFromCircuitJson = async (circuitJson, outputDir, imageF
     });
   }
   const generatedNames = new Set(assets.map((asset) => asset.fileName));
-  for (const fileName of fs14.readdirSync(outputDir)) {
+  for (const fileName of fs15.readdirSync(outputDir)) {
     const selected = imageFormats.systemSvgs && /^system(?:-.*)?\.svg$/.test(fileName) || imageFormats.assemblySvgs && fileName === "assembly.svg";
     if (selected && !generatedNames.has(fileName))
-      fs14.rmSync(path20.join(outputDir, fileName), { force: true });
+      fs15.rmSync(path21.join(outputDir, fileName), { force: true });
   }
   for (const { fileName, svg } of assets)
-    fs14.writeFileSync(path20.join(outputDir, fileName), svg, "utf-8");
+    fs15.writeFileSync(path21.join(outputDir, fileName), svg, "utf-8");
   return assets.map((asset) => asset.fileName);
 };
 var writeSimulationSvgAssetsFromCircuitJson = (circuitJson, outputDir, imageFormats) => {
@@ -62564,12 +62609,12 @@ var writeSimulationSvgAssetsFromCircuitJson = (circuitJson, outputDir, imageForm
   for (const simulationSvgAsset of simulationSvgAssets) {
     if (imageFormats.simulationSvgs) {
       const fileName = hasMultipleSimulations ? `simulation-${simulationSvgAsset.fileNameSuffix}.svg` : "simulation.svg";
-      fs14.writeFileSync(path20.join(outputDir, fileName), simulationSvgAsset.simulationSvg, "utf-8");
+      fs15.writeFileSync(path21.join(outputDir, fileName), simulationSvgAsset.simulationSvg, "utf-8");
       simulationFileNames.push(fileName);
     }
     if (imageFormats.simulationSchematicSvgs) {
       const fileName = hasMultipleSimulations ? `simulation-schematic-${simulationSvgAsset.fileNameSuffix}.svg` : "simulation-schematic.svg";
-      fs14.writeFileSync(path20.join(outputDir, fileName), simulationSvgAsset.schematicSimulationSvg, "utf-8");
+      fs15.writeFileSync(path21.join(outputDir, fileName), simulationSvgAsset.schematicSimulationSvg, "utf-8");
       schematicSimulationFileNames.push(fileName);
     }
   }
@@ -62579,8 +62624,8 @@ var writeGlbFromCircuitJson = async (circuitJson, glbOutputPath) => {
   const circuitJsonWithFileUrls = convertModelUrlsToFileUrls(circuitJson);
   const glbBuffer = await convertCircuitJsonToGltf(circuitJsonWithFileUrls, getCircuitJsonToGltfOptions({ format: "glb" }));
   const glbData = normalizeToUint8Array2(glbBuffer);
-  fs14.mkdirSync(path20.dirname(glbOutputPath), { recursive: true });
-  fs14.writeFileSync(glbOutputPath, Buffer.from(glbData));
+  fs15.mkdirSync(path21.dirname(glbOutputPath), { recursive: true });
+  fs15.writeFileSync(glbOutputPath, Buffer.from(glbData));
 };
 var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
   const stepContent = await circuitJsonToStep(circuitJson, {
@@ -62589,46 +62634,46 @@ var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
     includeExternalMeshes: true,
     fsMap: await loadLocalStepModelFsMap(circuitJson)
   });
-  fs14.mkdirSync(path20.dirname(stepOutputPath), { recursive: true });
-  fs14.writeFileSync(stepOutputPath, stepContent);
+  fs15.mkdirSync(path21.dirname(stepOutputPath), { recursive: true });
+  fs15.writeFileSync(stepOutputPath, stepContent);
 };
 var writeImageAssetsFromCircuitJson = async (circuitJson, options) => {
   const { outputDir, imageFormats, pcbSnapshotSettings } = options;
-  fs14.mkdirSync(outputDir, { recursive: true });
+  fs15.mkdirSync(outputDir, { recursive: true });
   const hasSchematic = circuitJson.some((e) => e.type.startsWith("schematic_"));
   if (!hasSchematic) {
     if (imageFormats.schematicSvgs)
-      fs14.rmSync(path20.join(outputDir, "schematic.svg"), { force: true });
+      fs15.rmSync(path21.join(outputDir, "schematic.svg"), { force: true });
     if (imageFormats.schematicPngs)
-      fs14.rmSync(path20.join(outputDir, "schematic.png"), { force: true });
+      fs15.rmSync(path21.join(outputDir, "schematic.png"), { force: true });
   }
   if (imageFormats.pcbSvgs) {
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson, pcbSnapshotSettings);
-    fs14.writeFileSync(path20.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
+    fs15.writeFileSync(path21.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
   }
   if (imageFormats.pcbPngs) {
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson, pcbSnapshotSettings);
-    fs14.writeFileSync(path20.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
+    fs15.writeFileSync(path21.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
   }
   if (imageFormats.schematicSvgs && hasSchematic) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs14.writeFileSync(path20.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
+    fs15.writeFileSync(path21.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
   }
   if (imageFormats.schematicPngs && hasSchematic) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs14.writeFileSync(path20.join(outputDir, "schematic.png"), await convertSvgToPngBuffer(schematicSvg));
+    fs15.writeFileSync(path21.join(outputDir, "schematic.png"), await convertSvgToPngBuffer(schematicSvg));
   }
   writeSimulationSvgAssetsFromCircuitJson(circuitJson, outputDir, imageFormats);
   await writeDiagramSvgAssetsFromCircuitJson(circuitJson, outputDir, imageFormats);
   if (imageFormats.threeDPngs) {
     const pngBuffer = await render3dThumbnail(circuitJson);
-    fs14.writeFileSync(path20.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
+    fs15.writeFileSync(path21.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
   }
 };
 
 // cli/build/worker-build-handlers.ts
 var loadCircuitJsonFromInputFile = (filePath) => {
-  const parsed = JSON.parse(fs15.readFileSync(filePath, "utf-8"));
+  const parsed = JSON.parse(fs16.readFileSync(filePath, "utf-8"));
   return Array.isArray(parsed) ? parsed : [];
 };
 var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath, previewOutputDir, projectDir, options, workerLog, workerStatus) => {
@@ -62636,7 +62681,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
   const warnings = [];
   const startedAt = options?.profile ? performance.now() : 0;
   try {
-    workerLog(`Generating circuit JSON for ${path21.relative(projectDir, filePath)}...`);
+    workerLog(`Generating circuit JSON for ${path22.relative(projectDir, filePath)}...`);
     await registerStaticAssetLoaders(undefined, projectDir);
     const projectConfig = await loadRuntimeProjectConfig(projectDir);
     const platformConfig = mergePlatformConfigs(projectConfig?.platformConfig, options?.platformConfig);
@@ -62660,27 +62705,44 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
         workerStatus(`waiting on ${asyncEffectName}…`);
       }
     })).circuitJson;
-    fs15.mkdirSync(path21.dirname(outputPath), { recursive: true });
-    fs15.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
-    workerLog(`Circuit JSON written to ${path21.relative(projectDir, outputPath)}`);
+    fs16.mkdirSync(path22.dirname(outputPath), { recursive: true });
+    fs16.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    workerLog(`Circuit JSON written to ${path22.relative(projectDir, outputPath)}`);
     const diagnostics = analyzeCircuitJson(circuitJson);
     const filteredDiagnostics = filterDiagnosticsByDrcCategory({
       errors: diagnostics.errors,
       warnings: diagnostics.warnings,
       ignoreOptions: options
     });
+    const errorsFilePath = writeBuildErrorsFile(outputPath, filteredDiagnostics.errors);
     if (!options?.ignoreWarnings) {
+      const { issuesToLog, omittedLines } = collapseRepeatedIssues(filteredDiagnostics.warnings);
+      const loggedWarnings = new Set(issuesToLog);
       for (const warn of filteredDiagnostics.warnings) {
         const msg = warn.message || JSON.stringify(warn);
         warnings.push(msg);
-        workerLog(`Warning: ${msg}`);
+        if (loggedWarnings.has(warn))
+          workerLog(`Warning: ${msg}`);
       }
+      for (const line of omittedLines)
+        workerLog(`Warning: ${line}`);
     }
     if (!options?.ignoreErrors) {
+      const { issuesToLog, omittedLines } = collapseRepeatedIssues(filteredDiagnostics.errors);
+      const loggedErrors = new Set(issuesToLog);
       for (const err of filteredDiagnostics.errors) {
         const msg = err.message || JSON.stringify(err);
         errors.push(msg);
-        workerLog(`Error: ${msg}`);
+        if (loggedErrors.has(err))
+          workerLog(`Error: ${msg}`);
+      }
+      for (const line of omittedLines)
+        workerLog(`Error: ${line}`);
+      if (errorsFilePath) {
+        workerLog(`${filteredDiagnostics.errors.length} error(s), all written to ${path22.relative(projectDir, errorsFilePath)}:`);
+        for (const line of getIssueTypeCountLines(filteredDiagnostics.errors)) {
+          workerLog(line);
+        }
       }
     }
     const hasErrors = filteredDiagnostics.errors.length > 0 && !options?.ignoreErrors;
@@ -62692,7 +62754,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     let previewError;
     if (glbOutputPath) {
       try {
-        workerLog(`Converting ${path21.relative(projectDir, outputPath)} to GLB in same worker...`);
+        workerLog(`Converting ${path22.relative(projectDir, outputPath)} to GLB in same worker...`);
         await writeGlbFromCircuitJson(circuitJson, glbOutputPath);
         glbOk = true;
       } catch (err) {
@@ -62703,7 +62765,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (stepOutputPath) {
       try {
-        workerLog(`Converting ${path21.relative(projectDir, outputPath)} to STEP in same worker...`);
+        workerLog(`Converting ${path22.relative(projectDir, outputPath)} to STEP in same worker...`);
         await writeStepFromCircuitJson(circuitJson, stepOutputPath);
         stepOk = true;
       } catch (err) {
@@ -62714,8 +62776,8 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (options?.generatePreviewAssets) {
       try {
-        const resolvedPreviewOutputDir = previewOutputDir ?? path21.dirname(outputPath);
-        workerLog(`Generating preview assets for ${path21.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
+        const resolvedPreviewOutputDir = previewOutputDir ?? path22.dirname(outputPath);
+        workerLog(`Generating preview assets for ${path22.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
         await writeImageAssetsFromCircuitJson(circuitJson, {
           outputDir: resolvedPreviewOutputDir,
           imageFormats: options?.imageFormats ?? DEFAULT_IMAGE_FORMAT_SELECTION,

package/dist/cli/main.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/cli/main.js
-size: 47929051 bytes
-sha256: 24912cb606fda118b7172cda29c2f60b3053f65a63a32104ed6d42062f343cd2
+size: 47931472 bytes
+sha256: 5a3ffc748fb63fa2f59e1ff26b70a30fd2ed5df4a712cdd525d66ec4857fb16d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.2453",
+  "version": "0.1.2454",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/cli"