@tscircuit/cli 0.1.1628 → 0.1.1629

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 fs6 from "node:fs";
-import path5 from "node:path";
+import fs7 from "node:fs";
+import path6 from "node:path";
 
 // node_modules/circuit-json-to-3d-png/dist/index.js
 function normalizeDir(dir) {
@@ -2776,8 +2776,8 @@ function init(open, close) {
 var kleur_default = $;
 
 // lib/shared/generate-circuit-json.tsx
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs4 from "node:fs";
+import path4 from "node:path";
 import { pathToFileURL } from "node:url";
 import Debug from "debug";
 
@@ -2798,14 +2798,416 @@ var abbreviateStringifyObject = (obj) => {
 // lib/shared/generate-circuit-json.tsx
 var import_make_vfs = __toESM(require_dist(), 1);
 
-// lib/shared/importFromUserLand.ts
-import { createRequire as createRequire2 } from "node:module";
+// lib/shared/autorouter-diagnostics.ts
 import fs from "node:fs";
 import path from "node:path";
+var DEFAULT_DEBUG_DIR = path.join("dist", "autorouter-debug");
+var PROGRESS_LOG_INTERVAL_MS = 1e4;
+var parseAutorouterTimeout = (duration) => {
+  const trimmed = duration.trim();
+  const match = trimmed.match(/^(\d+(?:\.\d+)?)(ms|s|m)?$/);
+  if (!match) {
+    throw new Error(`Invalid --autorouter-timeout value "${duration}". Use values like "120s", "2m", or "5000ms".`);
+  }
+  const value = Number.parseFloat(match[1]);
+  const unit = match[2] ?? "ms";
+  const multiplier = unit === "m" ? 60000 : unit === "s" ? 1000 : 1;
+  const timeoutMs = Math.round(value * multiplier);
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("--autorouter-timeout must be greater than zero");
+  }
+  return timeoutMs;
+};
+var parseAutorouterDumpSrjMode = (value) => {
+  if (value === undefined || value === false)
+    return;
+  if (value === true || value === "")
+    return "failed";
+  if (value === "all" || value === "failed")
+    return value;
+  const phaseMatch = value.match(/^phase:(\d+)$/);
+  if (phaseMatch)
+    return `phase:${Number.parseInt(phaseMatch[1], 10)}`;
+  throw new Error(`Invalid --autorouter-dump-srj value "${value}". Use "all", "failed", or "phase:<index>".`);
+};
+
+class AutorouterPhaseTimeoutError extends Error {
+  debugArtifactPath;
+  constructor(message, debugArtifactPath) {
+    super(message);
+    this.name = "AutorouterPhaseTimeoutError";
+    this.debugArtifactPath = debugArtifactPath;
+  }
+}
+
+class AutorouterDiagnostics {
+  options;
+  phaseOrdinalBySubcircuit = new Map;
+  traceCountBySubcircuit = new Map;
+  activePhase = null;
+  completedPhaseTraces = [];
+  summary = [];
+  rootCircuit;
+  constructor(options = {}) {
+    this.options = {
+      ...options,
+      debugDir: options.debugDir ?? DEFAULT_DEBUG_DIR,
+      log: options.log ?? console.log
+    };
+  }
+  get isActive() {
+    return Boolean(this.options.enabled || this.options.timeoutMs || this.options.dumpSrj || this.options.logOnError || this.options.longRunningLogThresholdMs);
+  }
+  attachToRootCircuit(rootCircuit) {
+    if (!this.isActive)
+      return;
+    this.rootCircuit = rootCircuit;
+    rootCircuit.on?.("autorouting:start", (event) => this.handleStart(event));
+    rootCircuit.on?.("autorouting:progress", (event) => this.handleProgress(event));
+    rootCircuit.on?.("autorouting:end", (event) => this.handleEnd(event));
+    rootCircuit.on?.("autorouting:error", (event) => this.handleError(event));
+  }
+  checkTimeout() {
+    this.checkLongRunning();
+    if (!this.options.timeoutMs || !this.activePhase)
+      return;
+    const elapsedMs = performance.now() - this.activePhase.startedAt;
+    if (elapsedMs < this.options.timeoutMs)
+      return;
+    const artifactPath = this.writeTimeoutArtifact(this.activePhase, elapsedMs);
+    const phaseLabel = this.getPhaseLabel(this.activePhase);
+    const message = `Autorouter timeout after ${this.formatElapsed(elapsedMs)} in ${phaseLabel}.`;
+    this.log(kleur_default.red(message));
+    this.log(`Wrote debug artifact: ${path.relative(process.cwd(), artifactPath)}`);
+    throw new AutorouterPhaseTimeoutError(message, artifactPath);
+  }
+  finalize(circuitJson) {
+    if (!this.isActive || this.summary.length === 0 || !this.options.enabled && !this.options.dumpSrj) {
+      return;
+    }
+    this.writeJson("board.meta.json", {
+      type: "autorouter_debug_summary",
+      generatedAt: new Date().toISOString(),
+      phaseCount: this.summary.length,
+      phases: this.summary,
+      circuitJsonElementCount: circuitJson?.length
+    });
+  }
+  handleStart(event) {
+    const simpleRouteJson = event.simpleRouteJson;
+    const subcircuitId = event.subcircuit_id ?? event.subcircuitId ?? "unknown-subcircuit";
+    const previousOrdinal = this.phaseOrdinalBySubcircuit.get(subcircuitId) ?? 0;
+    const phaseOrdinal = event.phaseOrdinal ?? previousOrdinal + 1;
+    this.phaseOrdinalBySubcircuit.set(subcircuitId, phaseOrdinal);
+    const routingPhaseIndex = event.routingPhaseIndex ?? phaseOrdinal - 1;
+    const connectionCount = event.connectionCount ?? simpleRouteJson?.connections?.length ?? 0;
+    const obstacleCount = event.obstacleCount ?? simpleRouteJson?.obstacles?.length ?? 0;
+    const previousTraceCount = event.previousTraceCount ?? this.traceCountBySubcircuit.get(subcircuitId) ?? 0;
+    this.activePhase = {
+      subcircuitId,
+      componentDisplayName: event.componentDisplayName ?? subcircuitId,
+      routingPhaseIndex,
+      phaseOrdinal,
+      phaseCount: event.phaseCount,
+      connectionCount,
+      obstacleCount,
+      previousTraceCount,
+      startedAt: performance.now(),
+      startedAtIso: new Date().toISOString(),
+      simpleRouteJson,
+      routerDescription: this.formatRouter(event),
+      lastProgressLogAt: 0,
+      hasLoggedStart: false,
+      longRunningLoggingStarted: false
+    };
+    if (this.options.enabled) {
+      this.logPhaseStart(this.activePhase);
+    }
+    if (this.shouldDumpInput(routingPhaseIndex)) {
+      this.writeJson(this.getPhaseFileName(this.activePhase, "input.simple-route.json"), simpleRouteJson ?? {});
+    }
+  }
+  handleProgress(event) {
+    if (!this.activePhase)
+      return;
+    const now = performance.now();
+    this.activePhase.lastProgress = event;
+    if (!this.shouldLogPhaseDetails(this.activePhase))
+      return;
+    if (this.activePhase.lastProgressLogAt > 0 && now - this.activePhase.lastProgressLogAt < PROGRESS_LOG_INTERVAL_MS) {
+      return;
+    }
+    this.activePhase.lastProgressLogAt = now;
+    this.logProgress(this.activePhase, event, now);
+  }
+  handleEnd(event) {
+    const activePhase = this.matchActivePhase(event);
+    if (!activePhase)
+      return;
+    const elapsedMs = performance.now() - activePhase.startedAt;
+    const outputSrj = event.simpleRouteJson;
+    const outputTraceCount = outputSrj?.traces?.length ?? 0;
+    const outputJumperCount = outputSrj?.jumpers?.length ?? 0;
+    const errorCount = this.countErrors(outputSrj);
+    const cumulativeTraceCount = activePhase.previousTraceCount + outputTraceCount;
+    this.traceCountBySubcircuit.set(activePhase.subcircuitId, cumulativeTraceCount);
+    this.completedPhaseTraces.push(...outputSrj?.traces ?? []);
+    this.summary.push({
+      subcircuit_id: activePhase.subcircuitId,
+      componentDisplayName: activePhase.componentDisplayName,
+      routingPhaseIndex: activePhase.routingPhaseIndex,
+      phaseOrdinal: activePhase.phaseOrdinal,
+      phaseCount: activePhase.phaseCount,
+      connectionCount: activePhase.connectionCount,
+      obstacleCount: activePhase.obstacleCount,
+      previousTraceCount: activePhase.previousTraceCount,
+      outputTraceCount,
+      outputJumperCount,
+      errorCount,
+      elapsedMs: Math.round(elapsedMs),
+      startedAt: activePhase.startedAtIso,
+      completedAt: new Date().toISOString()
+    });
+    if (this.shouldLogPhaseDetails(activePhase) || this.didCrossLongRunningThreshold(activePhase, elapsedMs)) {
+      if (!activePhase.hasLoggedStart) {
+        this.startLongRunningLogging(activePhase, elapsedMs);
+      }
+      this.logPhaseEnd(activePhase, {
+        outputTraceCount,
+        outputJumperCount,
+        errorCount,
+        elapsedMs
+      });
+    }
+    if (this.shouldDumpSuccessfulOutput(activePhase.routingPhaseIndex)) {
+      this.writeJson(this.getPhaseFileName(activePhase, "output.traces.json"), outputSrj?.traces ?? []);
+    }
+    if (this.activePhase === activePhase) {
+      this.activePhase = null;
+    }
+  }
+  handleError(event) {
+    const activePhase = this.matchActivePhase(event);
+    if (!activePhase)
+      return;
+    const elapsedMs = performance.now() - activePhase.startedAt;
+    const error = this.serializeError(event.error);
+    this.summary.push({
+      subcircuit_id: activePhase.subcircuitId,
+      componentDisplayName: activePhase.componentDisplayName,
+      routingPhaseIndex: activePhase.routingPhaseIndex,
+      phaseOrdinal: activePhase.phaseOrdinal,
+      phaseCount: activePhase.phaseCount,
+      connectionCount: activePhase.connectionCount,
+      obstacleCount: activePhase.obstacleCount,
+      previousTraceCount: activePhase.previousTraceCount,
+      elapsedMs: Math.round(elapsedMs),
+      error,
+      startedAt: activePhase.startedAtIso,
+      completedAt: new Date().toISOString()
+    });
+    if (this.options.enabled || this.options.logOnError) {
+      if (!activePhase.hasLoggedStart) {
+        this.logPhaseStart(activePhase, "failed");
+      }
+      this.log(`  ${this.getPhaseLabel(activePhase)} error after ${this.formatElapsed(elapsedMs)}: ${error.message}`);
+    }
+    if (this.shouldDumpFailedInput(activePhase.routingPhaseIndex)) {
+      this.writeJson(this.getPhaseFileName(activePhase, "input.simple-route.json"), event.simpleRouteJson ?? activePhase.simpleRouteJson ?? {});
+      this.writeJson(this.getPhaseFileName(activePhase, "error.json"), {
+        type: "autorouter_phase_error",
+        subcircuit_id: activePhase.subcircuitId,
+        routingPhaseIndex: activePhase.routingPhaseIndex,
+        phaseOrdinal: activePhase.phaseOrdinal,
+        phaseCount: activePhase.phaseCount,
+        elapsedMs: Math.round(elapsedMs),
+        connectionCount: activePhase.connectionCount,
+        obstacleCount: activePhase.obstacleCount,
+        previousTraceCount: activePhase.previousTraceCount,
+        error
+      });
+    }
+    if (this.activePhase === activePhase) {
+      this.activePhase = null;
+    }
+  }
+  writeTimeoutArtifact(activePhase, elapsedMs) {
+    const inputFile = this.getPhaseFileName(activePhase, "input.simple-route.json");
+    const previousTracesFile = this.getPhaseFileName(activePhase, "previous-output.traces.json");
+    const timeoutFile = this.getPhaseFileName(activePhase, "timeout.json");
+    const boardFile = "board.source-and-pcb.circuit.json";
+    this.writeJson(inputFile, activePhase.simpleRouteJson ?? {});
+    this.writeJson(previousTracesFile, this.completedPhaseTraces);
+    this.writeJson(boardFile, this.getCurrentCircuitJson());
+    return this.writeJson(timeoutFile, {
+      type: "autorouter_phase_timeout",
+      subcircuit_id: activePhase.subcircuitId,
+      componentDisplayName: activePhase.componentDisplayName,
+      routingPhaseIndex: activePhase.routingPhaseIndex,
+      phaseOrdinal: activePhase.phaseOrdinal,
+      phaseCount: activePhase.phaseCount,
+      elapsedMs: Math.round(elapsedMs),
+      connectionCount: activePhase.connectionCount,
+      obstacleCount: activePhase.obstacleCount,
+      previousTraceCount: activePhase.previousTraceCount,
+      autorouter: {
+        kind: "default-or-core"
+      },
+      files: {
+        inputSimpleRouteJson: inputFile,
+        previousOutputTraces: previousTracesFile,
+        boardCircuitJson: boardFile
+      },
+      lastProgress: activePhase.lastProgress
+    });
+  }
+  checkLongRunning() {
+    if (!this.activePhase)
+      return;
+    const elapsedMs = performance.now() - this.activePhase.startedAt;
+    if (!this.didCrossLongRunningThreshold(this.activePhase, elapsedMs))
+      return;
+    this.startLongRunningLogging(this.activePhase, elapsedMs);
+  }
+  didCrossLongRunningThreshold(activePhase, elapsedMs) {
+    return Boolean(!this.options.enabled && this.options.longRunningLogThresholdMs && !activePhase.longRunningLoggingStarted && elapsedMs >= this.options.longRunningLogThresholdMs);
+  }
+  startLongRunningLogging(activePhase, elapsedMs) {
+    activePhase.longRunningLoggingStarted = true;
+    this.log(kleur_default.yellow(`Autorouting ${this.getPhaseLabel(activePhase)} has been running for ${this.formatElapsed(elapsedMs)}; enabling phase diagnostics. Re-run with --autorouter-debug for full autorouter logs from the start.`));
+    this.logPhaseStart(activePhase, "long-running");
+    if (activePhase.lastProgress) {
+      this.logProgress(activePhase, activePhase.lastProgress, performance.now());
+    }
+  }
+  shouldLogPhaseDetails(activePhase) {
+    return Boolean(this.options.enabled || activePhase.longRunningLoggingStarted);
+  }
+  logPhaseStart(activePhase, reason) {
+    const reasonText = reason ? ` ${reason}` : "";
+    this.log([
+      `Autorouting ${activePhase.componentDisplayName} (${activePhase.subcircuitId}) ${this.getPhaseLabel(activePhase)}${reasonText} start:`,
+      `connections=${activePhase.connectionCount},`,
+      `obstacles=${activePhase.obstacleCount},`,
+      `previous_traces=${activePhase.previousTraceCount}`,
+      activePhase.routerDescription ? `, ${activePhase.routerDescription}` : ""
+    ].join(" "));
+    const connectionNames = this.getConnectionNames(activePhase.simpleRouteJson);
+    if (connectionNames.length > 0) {
+      this.log(`  connections: ${connectionNames.join(", ")}`);
+    }
+    activePhase.hasLoggedStart = true;
+  }
+  logProgress(activePhase, event, now) {
+    const elapsedMs = event.elapsedMs ?? now - activePhase.startedAt;
+    const details = [
+      event.solverName ? `solver=${event.solverName}` : null,
+      event.phase ? `solver_phase=${event.phase}` : null,
+      event.iteration !== undefined ? `iter=${event.iteration}` : event.steps !== undefined ? `steps=${event.steps}` : null,
+      event.progress !== undefined ? `progress=${Math.round(event.progress * 100)}%` : null,
+      event.iterationsPerSecond !== undefined ? `iterations_per_second=${Math.round(event.iterationsPerSecond)}` : null,
+      `elapsed=${this.formatElapsed(elapsedMs)}`
+    ].filter(Boolean);
+    this.log(`  ${this.getPhaseLabel(activePhase)} progress: ${details.join(" ")}`);
+  }
+  logPhaseEnd(activePhase, {
+    outputTraceCount,
+    outputJumperCount,
+    errorCount,
+    elapsedMs
+  }) {
+    this.log(`  ${this.getPhaseLabel(activePhase)} done: routed_traces=${outputTraceCount}, jumpers=${outputJumperCount}, errors=${errorCount}, elapsed=${this.formatElapsed(elapsedMs)}`);
+  }
+  matchActivePhase(event) {
+    if (!this.activePhase)
+      return null;
+    const subcircuitId = event.subcircuit_id ?? event.subcircuitId;
+    if (subcircuitId && subcircuitId !== this.activePhase.subcircuitId) {
+      return null;
+    }
+    return this.activePhase;
+  }
+  shouldDumpInput(routingPhaseIndex) {
+    return this.options.dumpSrj === "all" || this.options.dumpSrj === `phase:${routingPhaseIndex}`;
+  }
+  shouldDumpSuccessfulOutput(routingPhaseIndex) {
+    return this.options.dumpSrj === "all" || this.options.dumpSrj === `phase:${routingPhaseIndex}`;
+  }
+  shouldDumpFailedInput(routingPhaseIndex) {
+    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));
+    return filePath;
+  }
+  getPhaseFileName(activePhase, suffix) {
+    const phaseNumber = activePhase.routingPhaseIndex;
+    return `phase-${phaseNumber}.${suffix}`;
+  }
+  getPhaseLabel(activePhase) {
+    if (activePhase.phaseCount) {
+      return `phase ${activePhase.phaseOrdinal}/${activePhase.phaseCount}`;
+    }
+    return `phase ${activePhase.phaseOrdinal}`;
+  }
+  formatElapsed(elapsedMs) {
+    if (elapsedMs < 1000)
+      return `${Math.round(elapsedMs)}ms`;
+    return `${(elapsedMs / 1000).toFixed(1)}s`;
+  }
+  formatRouter(event) {
+    const parts = [
+      event.autorouterName ? `router=${event.autorouterName}` : null,
+      event.autorouterVersion ? `version=${event.autorouterVersion}` : null,
+      event.effort !== undefined ? `effort=${event.effort}` : null
+    ].filter(Boolean);
+    return parts.join(", ");
+  }
+  getConnectionNames(simpleRouteJson) {
+    return (simpleRouteJson?.connections ?? []).map((connection) => {
+      const name = connection.name ?? connection.rootConnectionName ?? connection.source_trace_id;
+      return typeof name === "string" ? name : null;
+    }).filter((name) => Boolean(name));
+  }
+  countErrors(simpleRouteJson) {
+    const errors = simpleRouteJson?.errors;
+    return Array.isArray(errors) ? errors.length : 0;
+  }
+  getCurrentCircuitJson() {
+    try {
+      return this.rootCircuit?.db?.toArray?.() ?? [];
+    } catch {
+      return [];
+    }
+  }
+  serializeError(error) {
+    if (error instanceof Error) {
+      return { message: error.message, stack: error.stack };
+    }
+    if (typeof error === "string") {
+      return { message: error };
+    }
+    return {
+      message: error?.message ?? "Unknown autorouting error",
+      stack: error?.stack
+    };
+  }
+  log(message) {
+    this.options.log(message);
+  }
+}
+
+// lib/shared/importFromUserLand.ts
+import { createRequire as createRequire2 } from "node:module";
+import fs2 from "node:fs";
+import path2 from "node:path";
 async function importFromUserLand(moduleName) {
-  const userModulePath = path.join(process.cwd(), "node_modules", moduleName);
-  if (fs.existsSync(userModulePath)) {
-    const userRequire = createRequire2(path.join(process.cwd(), "noop.js"));
+  const userModulePath = path2.join(process.cwd(), "node_modules", moduleName);
+  if (fs2.existsSync(userModulePath)) {
+    const userRequire = createRequire2(path2.join(process.cwd(), "noop.js"));
     try {
       const resolvedUserPath = userRequire.resolve(moduleName);
       return await import(resolvedUserPath);
@@ -2828,8 +3230,8 @@ async function importFromUserLand(moduleName) {
 }
 
 // lib/shared/register-static-asset-loaders.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 var STATIC_ASSET_EXTENSIONS = [
   ".glb",
   ".gltf",
@@ -2854,15 +3256,15 @@ var TEXT_STATIC_ASSET_EXTENSIONS = new Set([
   ".kicad_sch"
 ]);
 var readFileContentForStaticLoader = (filePath) => {
-  const ext = path2.extname(filePath).toLowerCase();
+  const ext = path3.extname(filePath).toLowerCase();
   if (TEXT_STATIC_ASSET_EXTENSIONS.has(ext)) {
-    return fs2.readFileSync(filePath, "utf-8");
+    return fs3.readFileSync(filePath, "utf-8");
   }
-  const buffer = fs2.readFileSync(filePath);
+  const buffer = fs3.readFileSync(filePath);
   return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
 };
 var getStaticFileLoader = (filePath) => {
-  const extWithDot = path2.extname(filePath).toLowerCase();
+  const extWithDot = path3.extname(filePath).toLowerCase();
   const ext = extWithDot.replace(/^\./, "");
   return activePlatformConfig?.staticFileLoaderMap?.[ext] ?? activePlatformConfig?.staticFileLoaderMap?.[extWithDot];
 };
@@ -2876,12 +3278,12 @@ var normalizeStaticFileLoaderResult = (result) => {
   };
 };
 var getBaseUrlFromTsConfig = () => {
-  const tsconfigPath = path2.join(process.cwd(), "tsconfig.json");
+  const tsconfigPath = path3.join(process.cwd(), "tsconfig.json");
   try {
-    if (!fs2.existsSync(tsconfigPath)) {
+    if (!fs3.existsSync(tsconfigPath)) {
       return null;
     }
-    const tsconfigContent = fs2.readFileSync(tsconfigPath, "utf-8");
+    const tsconfigContent = fs3.readFileSync(tsconfigPath, "utf-8");
     const tsconfig = JSON.parse(tsconfigContent);
     if (tsconfig.compilerOptions?.baseUrl) {
       return tsconfig.compilerOptions.baseUrl;
@@ -2908,8 +3310,8 @@ var registerStaticAssetLoaders = (platformConfig) => {
               loader: "object"
             };
           }
-          const baseDir = baseUrl ? path2.resolve(process.cwd(), baseUrl) : process.cwd();
-          const relativePath = path2.relative(baseDir, args.path).split(path2.sep).join("/");
+          const baseDir = baseUrl ? path3.resolve(process.cwd(), baseUrl) : process.cwd();
+          const relativePath = path3.relative(baseDir, args.path).split(path3.sep).join("/");
           const pathStr = `./${relativePath}`;
           return {
             exports: {
@@ -2948,7 +3350,8 @@ async function generateCircuitJson({
   saveToFile = false,
   platformConfig,
   injectedProps,
-  onAsyncEffectStatus
+  onAsyncEffectStatus,
+  autorouterDiagnostics: autorouterDiagnosticsOptions
 }) {
   debug(`Generating circuit JSON for ${filePath}`);
   const React = await importFromUserLand("react");
@@ -2958,12 +3361,14 @@ async function generateCircuitJson({
   const runner = new userLandTscircuit.RootCircuit({
     platform: platformConfig
   });
-  const absoluteFilePath = path3.isAbsolute(filePath) ? filePath : path3.resolve(process.cwd(), filePath);
-  const projectDir = path3.dirname(absoluteFilePath);
+  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 resolvedOutputDir = outputDir ?? projectDir;
-  const relativeComponentPath = path3.relative(projectDir, absoluteFilePath);
-  const baseFileName = outputFileName || path3.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path3.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  const relativeComponentPath = path4.relative(projectDir, absoluteFilePath);
+  const baseFileName = outputFileName || path4.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path4.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
   debug(`Project directory: ${projectDir}`);
   debug(`Relative component path: ${relativeComponentPath}`);
   debug(`Output path: ${outputPath}`);
@@ -2983,7 +3388,7 @@ async function generateCircuitJson({
           return false;
         if (normalizedFilePath.match(/^\.[^/]/))
           return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path3.extname(normalizedFilePath)))
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path4.extname(normalizedFilePath)))
           return false;
         return true;
       },
@@ -3010,14 +3415,16 @@ async function generateCircuitJson({
       loggedAsyncEffectNames.add(asyncEffectName);
       onAsyncEffectStatus?.(asyncEffectName);
     }
+    autorouterDiagnostics.checkTimeout();
     await new Promise((resolve2) => setTimeout(resolve2, 100));
     runner.render();
   }
   runner.emit("renderComplete");
   const circuitJson = await runner.getCircuitJson();
+  autorouterDiagnostics.finalize(circuitJson);
   if (saveToFile) {
     debug(`Saving circuit JSON to ${outputPath}`);
-    fs3.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    fs4.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
   }
   return {
     circuitJson,
@@ -3028,28 +3435,28 @@ async function generateCircuitJson({
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
 import { createHash } from "node:crypto";
-import fs4 from "node:fs";
-import path4 from "node:path";
+import fs5 from "node:fs";
+import path5 from "node:path";
 import { getPlatformConfig } from "@tscircuit/eval/platform-config";
-function createLocalCacheEngine(cacheDir = path4.join(process.cwd(), ".tscircuit", "cache")) {
+function createLocalCacheEngine(cacheDir = path5.join(process.cwd(), ".tscircuit", "cache")) {
   return {
     getItem: (key) => {
       try {
         const hash = createHash("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path4.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        return fs4.readFileSync(filePath, "utf-8");
+        const filePath = path5.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        return fs5.readFileSync(filePath, "utf-8");
       } catch {
         return null;
       }
     },
     setItem: (key, value) => {
       try {
-        fs4.mkdirSync(cacheDir, { recursive: true });
+        fs5.mkdirSync(cacheDir, { recursive: true });
         const hash = createHash("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path4.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        fs4.writeFileSync(filePath, value);
+        const filePath = path5.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        fs5.writeFileSync(filePath, value);
       } catch {}
     }
   };
@@ -3065,15 +3472,15 @@ function getPlatformConfigWithCliDefaults(userConfig) {
         loadFromUrl: async (url) => {
           let fetchUrl = url;
           if (url.startsWith("./") || url.startsWith("../")) {
-            const absolutePath = path4.resolve(process.cwd(), url);
+            const absolutePath = path5.resolve(process.cwd(), url);
             fetchUrl = `file://${absolutePath}`;
           } else if (url.startsWith("/")) {
-            if (fs4.existsSync(url)) {
+            if (fs5.existsSync(url)) {
               fetchUrl = `file://${url}`;
             } else {
               const relativePath = `.${url}`;
-              const absolutePath = path4.resolve(process.cwd(), relativePath);
-              if (fs4.existsSync(absolutePath)) {
+              const absolutePath = path5.resolve(process.cwd(), relativePath);
+              if (fs5.existsSync(absolutePath)) {
                 fetchUrl = `file://${absolutePath}`;
               } else {
                 fetchUrl = `file://${url}`;
@@ -3146,7 +3553,7 @@ var getSimulationSvgAssetsFromCircuitJson = (circuitJson) => {
 
 // lib/shared/compare-images.ts
 import looksSame from "@tscircuit/image-utils/looks-same";
-import fs5 from "node:fs/promises";
+import fs6 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true) => {
   const b1 = Buffer.from(buffer1);
   const b2 = Buffer.from(buffer2);
@@ -3162,9 +3569,9 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true)
         highlightColor: "#ff00ff",
         tolerance: 2
       });
-      await fs5.writeFile(diffPath, diffBuffer);
+      await fs6.writeFile(diffPath, diffBuffer);
     } else {
-      await fs5.writeFile(diffPath, buffer2);
+      await fs6.writeFile(diffPath, buffer2);
     }
   }
   return { equal };
@@ -3193,7 +3600,7 @@ var processSnapshotFile = async ({
   cameraPreset,
   pcbLayer
 }) => {
-  const relativeFilePath = path5.relative(projectDir, file);
+  const relativeFilePath = path6.relative(projectDir, file);
   const successPaths = [];
   const warningMessages = [];
   const mismatches = [];
@@ -3204,7 +3611,7 @@ var processSnapshotFile = async ({
   let simulationSvgAssets;
   try {
     if (isCircuitJsonFile(file)) {
-      const parsed = JSON.parse(fs6.readFileSync(file, "utf-8"));
+      const parsed = JSON.parse(fs7.readFileSync(file, "utf-8"));
       circuitJson = Array.isArray(parsed) ? parsed : [];
     } else {
       const platformConfigWithCliDefaults = getPlatformConfigWithCliDefaults(platformConfig);
@@ -3288,12 +3695,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 = path5.dirname(file);
-        const relativeDir = path5.relative(projectDir, fileDir);
-        const snapDir2 = snapshotsDirName ? path5.join(projectDir, snapshotsDirName, relativeDir) : path5.join(fileDir, "__snapshots__");
-        const base2 = path5.basename(file).replace(/\.[^.]+$/, "");
-        const snap3dPath = path5.join(snapDir2, `${base2}-3d.snap.png`);
-        const existing3dSnapshot = fs6.existsSync(snap3dPath);
+        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);
         if (existing3dSnapshot) {
           return {
             ok: false,
@@ -3304,7 +3711,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: ${path5.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path6.relative(projectDir, snap3dPath)}
 `)
           };
         }
@@ -3325,9 +3732,9 @@ var processSnapshotFile = async ({
       }
     }
   }
-  const snapDir = snapshotsDirName ? path5.join(projectDir, snapshotsDirName, path5.relative(projectDir, path5.dirname(file))) : path5.join(path5.dirname(file), "__snapshots__");
-  fs6.mkdirSync(snapDir, { recursive: true });
-  const base = path5.basename(file).replace(/\.[^.]+$/, "");
+  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 snapshots = [];
   if (!simulationOnly && (pcbOnly || !schematicOnly)) {
     let pcbSnapshotType = "pcb";
@@ -3361,17 +3768,17 @@ var processSnapshotFile = async ({
   for (const snapshot of snapshots) {
     const { type } = snapshot;
     const is3d = type === "3d";
-    const snapPath = path5.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-    const existing = fs6.existsSync(snapPath);
+    const snapPath = path6.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+    const existing = fs7.existsSync(snapPath);
     const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
     const newContentForFile = snapshot.content;
     if (!existing) {
-      fs6.writeFileSync(snapPath, newContentForFile);
-      successPaths.push(path5.relative(projectDir, snapPath));
+      fs7.writeFileSync(snapPath, newContentForFile);
+      successPaths.push(path6.relative(projectDir, snapPath));
       didUpdate = true;
       continue;
     }
-    const oldContentBuffer = fs6.readFileSync(snapPath);
+    const oldContentBuffer = fs7.readFileSync(snapPath);
     let equal;
     let diffPath;
     if (createDiff) {
@@ -3383,16 +3790,16 @@ var processSnapshotFile = async ({
     }
     if (update) {
       if (!forceUpdate && equal) {
-        successPaths.push(path5.relative(projectDir, snapPath));
+        successPaths.push(path6.relative(projectDir, snapPath));
       } else {
-        fs6.writeFileSync(snapPath, newContentForFile);
-        successPaths.push(path5.relative(projectDir, snapPath));
+        fs7.writeFileSync(snapPath, newContentForFile);
+        successPaths.push(path6.relative(projectDir, snapPath));
         didUpdate = true;
       }
     } else if (!equal) {
       mismatches.push(diffPath ? `${snapPath} (diff: ${diffPath})` : snapPath);
     } else {
-      successPaths.push(path5.relative(projectDir, snapPath));
+      successPaths.push(path6.relative(projectDir, snapPath));
     }
   }
   return {
@@ -3405,8 +3812,8 @@ var processSnapshotFile = async ({
 };
 
 // lib/project-config/index.ts
-import * as fs7 from "node:fs";
-import * as path6 from "node:path";
+import * as fs8 from "node:fs";
+import * as path7 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // lib/project-config/project-config-schema.ts
@@ -3481,10 +3888,10 @@ var stripWrappingQuotes = (value) => {
 var loadProjectEnv = (projectDir) => {
   const initialEnvKeys = new Set(Object.keys(process.env));
   for (const envFileName of ENV_FILENAMES) {
-    const envPath = path6.join(projectDir, envFileName);
-    if (!fs7.existsSync(envPath))
+    const envPath = path7.join(projectDir, envFileName);
+    if (!fs8.existsSync(envPath))
       continue;
-    const envContent = fs7.readFileSync(envPath, "utf8");
+    const envContent = fs8.readFileSync(envPath, "utf8");
     for (const rawLine of envContent.split(/\r?\n/)) {
       const line = rawLine.trim();
       if (!line || line.startsWith("#"))
@@ -3502,12 +3909,12 @@ var loadProjectEnv = (projectDir) => {
   }
 };
 var loadProjectConfigSync = (projectDir = process.cwd()) => {
-  const configPath = path6.join(projectDir, CONFIG_FILENAME);
-  if (!fs7.existsSync(configPath)) {
+  const configPath = path7.join(projectDir, CONFIG_FILENAME);
+  if (!fs8.existsSync(configPath)) {
     return null;
   }
   try {
-    const configContent = fs7.readFileSync(configPath, "utf8");
+    const configContent = fs8.readFileSync(configPath, "utf8");
     const parsedConfig = JSON.parse(configContent);
     return projectConfigSchema.parse(parsedConfig);
   } catch (error) {
@@ -3518,12 +3925,12 @@ var loadProjectConfigSync = (projectDir = process.cwd()) => {
 var loadProjectConfigModule = async (projectDir) => {
   loadProjectEnv(projectDir);
   for (const configFileName of CONFIG_MODULE_FILENAMES) {
-    const configPath = path6.join(projectDir, configFileName);
-    if (!fs7.existsSync(configPath))
+    const configPath = path7.join(projectDir, configFileName);
+    if (!fs8.existsSync(configPath))
       continue;
     try {
       const moduleUrl = pathToFileURL2(configPath);
-      const stat = fs7.statSync(configPath);
+      const stat = fs8.statSync(configPath);
       moduleUrl.searchParams.set("tsci", String(stat.mtimeMs));
       const importedModule = await import(moduleUrl.href);
       const exportedConfig = importedModule.default ?? importedModule.config ?? importedModule;
@@ -3570,13 +3977,13 @@ var getSnapshotsDir = (projectDir = process.cwd()) => {
   return config?.snapshotsDir;
 };
 var saveProjectConfig = (config, projectDir = process.cwd()) => {
-  const configPath = path6.join(projectDir, CONFIG_FILENAME);
+  const configPath = path7.join(projectDir, CONFIG_FILENAME);
   try {
     const configWithSchema = {
       $schema: CONFIG_SCHEMA_URL,
       ...config ?? {}
     };
-    fs7.writeFileSync(configPath, JSON.stringify(configWithSchema, null, 2));
+    fs8.writeFileSync(configPath, JSON.stringify(configWithSchema, null, 2));
     return true;
   } catch (error) {
     console.error(`Error saving tscircuit config: ${error}`);