@tscircuit/cli 0.1.1628 → 0.1.1629

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

@@ -5608,8 +5608,8 @@ var require_utils = __commonJS((exports, module) => {
     }
     return ind;
   }
-  function removeDotSegments(path9) {
-    let input = path9;
+  function removeDotSegments(path10) {
+    let input = path10;
     const output = [];
     let nextSlash = -1;
     let len = 0;
@@ -5852,8 +5852,8 @@ var require_schemes = __commonJS((exports, module) => {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path9, query] = wsComponent.resourceName.split("?");
-      wsComponent.path = path9 && path9 !== "/" ? path9 : undefined;
+      const [path10, query] = wsComponent.resourceName.split("?");
+      wsComponent.path = path10 && path10 !== "/" ? path10 : undefined;
       wsComponent.query = query;
       wsComponent.resourceName = undefined;
     }
@@ -9791,12 +9791,12 @@ var require_dist2 = __commonJS((exports, module) => {
       throw new Error(`Unknown format "${name}"`);
     return f;
   };
-  function addFormats(ajv, list, fs7, exportName) {
+  function addFormats(ajv, list, fs8, exportName) {
     var _a;
     var _b;
     (_a = (_b = ajv.opts.code).formats) !== null && _a !== undefined || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
     for (const f of list)
-      ajv.addFormat(f, fs7[f]);
+      ajv.addFormat(f, fs8[f]);
   }
   module.exports = exports = formatsPlugin;
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -11651,8 +11651,8 @@ var require_semver2 = __commonJS((exports, module) => {
 import { parentPort } from "node:worker_threads";
 
 // cli/build/worker-build-handlers.ts
-import fs11 from "node:fs";
-import path15 from "node:path";
+import fs12 from "node:fs";
+import path16 from "node:path";
 
 // lib/project-config/index.ts
 import * as fs from "node:fs";
@@ -11858,8 +11858,8 @@ function analyzeCircuitJson(circuitJson) {
 }
 
 // lib/shared/generate-circuit-json.tsx
-import fs4 from "node:fs";
-import path4 from "node:path";
+import fs5 from "node:fs";
+import path5 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import Debug from "debug";
 
@@ -11880,14 +11880,515 @@ 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 fs2 from "node:fs";
 import path2 from "node:path";
+
+// node_modules/kleur/index.mjs
+var FORCE_COLOR;
+var NODE_DISABLE_COLORS;
+var NO_COLOR;
+var TERM;
+var isTTY = true;
+if (typeof process !== "undefined") {
+  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
+  isTTY = process.stdout && process.stdout.isTTY;
+}
+var $ = {
+  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY),
+  reset: init(0, 0),
+  bold: init(1, 22),
+  dim: init(2, 22),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  grey: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49)
+};
+function run(arr, str) {
+  let i = 0, tmp, beg = "", end = "";
+  for (;i < arr.length; i++) {
+    tmp = arr[i];
+    beg += tmp.open;
+    end += tmp.close;
+    if (!!~str.indexOf(tmp.close)) {
+      str = str.replace(tmp.rgx, tmp.close + tmp.open);
+    }
+  }
+  return beg + str + end;
+}
+function chain(has, keys) {
+  let ctx = { has, keys };
+  ctx.reset = $.reset.bind(ctx);
+  ctx.bold = $.bold.bind(ctx);
+  ctx.dim = $.dim.bind(ctx);
+  ctx.italic = $.italic.bind(ctx);
+  ctx.underline = $.underline.bind(ctx);
+  ctx.inverse = $.inverse.bind(ctx);
+  ctx.hidden = $.hidden.bind(ctx);
+  ctx.strikethrough = $.strikethrough.bind(ctx);
+  ctx.black = $.black.bind(ctx);
+  ctx.red = $.red.bind(ctx);
+  ctx.green = $.green.bind(ctx);
+  ctx.yellow = $.yellow.bind(ctx);
+  ctx.blue = $.blue.bind(ctx);
+  ctx.magenta = $.magenta.bind(ctx);
+  ctx.cyan = $.cyan.bind(ctx);
+  ctx.white = $.white.bind(ctx);
+  ctx.gray = $.gray.bind(ctx);
+  ctx.grey = $.grey.bind(ctx);
+  ctx.bgBlack = $.bgBlack.bind(ctx);
+  ctx.bgRed = $.bgRed.bind(ctx);
+  ctx.bgGreen = $.bgGreen.bind(ctx);
+  ctx.bgYellow = $.bgYellow.bind(ctx);
+  ctx.bgBlue = $.bgBlue.bind(ctx);
+  ctx.bgMagenta = $.bgMagenta.bind(ctx);
+  ctx.bgCyan = $.bgCyan.bind(ctx);
+  ctx.bgWhite = $.bgWhite.bind(ctx);
+  return ctx;
+}
+function init(open, close) {
+  let blk = {
+    open: `\x1B[${open}m`,
+    close: `\x1B[${close}m`,
+    rgx: new RegExp(`\\x1b\\[${close}m`, "g")
+  };
+  return function(txt) {
+    if (this !== undefined && this.has !== undefined) {
+      !!~this.has.indexOf(open) || (this.has.push(open), this.keys.push(blk));
+      return txt === undefined ? this : $.enabled ? run(this.keys, txt + "") : txt + "";
+    }
+    return txt === undefined ? chain([open], [blk]) : $.enabled ? run([blk], txt + "") : txt + "";
+  };
+}
+var kleur_default = $;
+
+// lib/shared/autorouter-diagnostics.ts
+var DEFAULT_DEBUG_DIR = path2.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: ${path2.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 = 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));
+    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 fs3 from "node:fs";
+import path3 from "node:path";
 async function importFromUserLand(moduleName) {
-  const userModulePath = path2.join(process.cwd(), "node_modules", moduleName);
-  if (fs2.existsSync(userModulePath)) {
-    const userRequire = createRequire2(path2.join(process.cwd(), "noop.js"));
+  const userModulePath = path3.join(process.cwd(), "node_modules", moduleName);
+  if (fs3.existsSync(userModulePath)) {
+    const userRequire = createRequire2(path3.join(process.cwd(), "noop.js"));
     try {
       const resolvedUserPath = userRequire.resolve(moduleName);
       return await import(resolvedUserPath);
@@ -11910,8 +12411,8 @@ async function importFromUserLand(moduleName) {
 }
 
 // lib/shared/register-static-asset-loaders.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs4 from "node:fs";
+import path4 from "node:path";
 var STATIC_ASSET_EXTENSIONS = [
   ".glb",
   ".gltf",
@@ -11936,15 +12437,15 @@ var TEXT_STATIC_ASSET_EXTENSIONS = new Set([
   ".kicad_sch"
 ]);
 var readFileContentForStaticLoader = (filePath) => {
-  const ext = path3.extname(filePath).toLowerCase();
+  const ext = path4.extname(filePath).toLowerCase();
   if (TEXT_STATIC_ASSET_EXTENSIONS.has(ext)) {
-    return fs3.readFileSync(filePath, "utf-8");
+    return fs4.readFileSync(filePath, "utf-8");
   }
-  const buffer = fs3.readFileSync(filePath);
+  const buffer = fs4.readFileSync(filePath);
   return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
 };
 var getStaticFileLoader = (filePath) => {
-  const extWithDot = path3.extname(filePath).toLowerCase();
+  const extWithDot = path4.extname(filePath).toLowerCase();
   const ext = extWithDot.replace(/^\./, "");
   return activePlatformConfig?.staticFileLoaderMap?.[ext] ?? activePlatformConfig?.staticFileLoaderMap?.[extWithDot];
 };
@@ -11958,12 +12459,12 @@ var normalizeStaticFileLoaderResult = (result) => {
   };
 };
 var getBaseUrlFromTsConfig = () => {
-  const tsconfigPath = path3.join(process.cwd(), "tsconfig.json");
+  const tsconfigPath = path4.join(process.cwd(), "tsconfig.json");
   try {
-    if (!fs3.existsSync(tsconfigPath)) {
+    if (!fs4.existsSync(tsconfigPath)) {
       return null;
     }
-    const tsconfigContent = fs3.readFileSync(tsconfigPath, "utf-8");
+    const tsconfigContent = fs4.readFileSync(tsconfigPath, "utf-8");
     const tsconfig = JSON.parse(tsconfigContent);
     if (tsconfig.compilerOptions?.baseUrl) {
       return tsconfig.compilerOptions.baseUrl;
@@ -11990,8 +12491,8 @@ var registerStaticAssetLoaders = (platformConfig) => {
               loader: "object"
             };
           }
-          const baseDir = baseUrl ? path3.resolve(process.cwd(), baseUrl) : process.cwd();
-          const relativePath = path3.relative(baseDir, args.path).split(path3.sep).join("/");
+          const baseDir = baseUrl ? path4.resolve(process.cwd(), baseUrl) : process.cwd();
+          const relativePath = path4.relative(baseDir, args.path).split(path4.sep).join("/");
           const pathStr = `./${relativePath}`;
           return {
             exports: {
@@ -12030,7 +12531,8 @@ async function generateCircuitJson({
   saveToFile = false,
   platformConfig,
   injectedProps,
-  onAsyncEffectStatus
+  onAsyncEffectStatus,
+  autorouterDiagnostics: autorouterDiagnosticsOptions
 }) {
   debug(`Generating circuit JSON for ${filePath}`);
   const React = await importFromUserLand("react");
@@ -12040,12 +12542,14 @@ async function generateCircuitJson({
   const runner = new userLandTscircuit.RootCircuit({
     platform: platformConfig
   });
-  const absoluteFilePath = path4.isAbsolute(filePath) ? filePath : path4.resolve(process.cwd(), filePath);
-  const projectDir = path4.dirname(absoluteFilePath);
+  const autorouterDiagnostics = new AutorouterDiagnostics(autorouterDiagnosticsOptions);
+  autorouterDiagnostics.attachToRootCircuit(runner);
+  const absoluteFilePath = path5.isAbsolute(filePath) ? filePath : path5.resolve(process.cwd(), filePath);
+  const projectDir = path5.dirname(absoluteFilePath);
   const resolvedOutputDir = outputDir ?? projectDir;
-  const relativeComponentPath = path4.relative(projectDir, absoluteFilePath);
-  const baseFileName = outputFileName || path4.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path4.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  const relativeComponentPath = path5.relative(projectDir, absoluteFilePath);
+  const baseFileName = outputFileName || path5.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path5.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
   debug(`Project directory: ${projectDir}`);
   debug(`Relative component path: ${relativeComponentPath}`);
   debug(`Output path: ${outputPath}`);
@@ -12065,7 +12569,7 @@ async function generateCircuitJson({
           return false;
         if (normalizedFilePath.match(/^\.[^/]/))
           return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path4.extname(normalizedFilePath)))
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path5.extname(normalizedFilePath)))
           return false;
         return true;
       },
@@ -12092,14 +12596,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}`);
-    fs4.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    fs5.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
   }
   return {
     circuitJson,
@@ -12110,28 +12616,28 @@ async function generateCircuitJson({
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
 import { createHash } from "node:crypto";
-import fs5 from "node:fs";
-import path5 from "node:path";
+import fs6 from "node:fs";
+import path6 from "node:path";
 import { getPlatformConfig } from "@tscircuit/eval/platform-config";
-function createLocalCacheEngine(cacheDir = path5.join(process.cwd(), ".tscircuit", "cache")) {
+function createLocalCacheEngine(cacheDir = path6.join(process.cwd(), ".tscircuit", "cache")) {
   return {
     getItem: (key) => {
       try {
         const hash = createHash("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path5.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        return fs5.readFileSync(filePath, "utf-8");
+        const filePath = path6.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        return fs6.readFileSync(filePath, "utf-8");
       } catch {
         return null;
       }
     },
     setItem: (key, value) => {
       try {
-        fs5.mkdirSync(cacheDir, { recursive: true });
+        fs6.mkdirSync(cacheDir, { recursive: true });
         const hash = createHash("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path5.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        fs5.writeFileSync(filePath, value);
+        const filePath = path6.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        fs6.writeFileSync(filePath, value);
       } catch {}
     }
   };
@@ -12147,15 +12653,15 @@ function getPlatformConfigWithCliDefaults(userConfig) {
         loadFromUrl: async (url) => {
           let fetchUrl = url;
           if (url.startsWith("./") || url.startsWith("../")) {
-            const absolutePath = path5.resolve(process.cwd(), url);
+            const absolutePath = path6.resolve(process.cwd(), url);
             fetchUrl = `file://${absolutePath}`;
           } else if (url.startsWith("/")) {
-            if (fs5.existsSync(url)) {
+            if (fs6.existsSync(url)) {
               fetchUrl = `file://${url}`;
             } else {
               const relativePath = `.${url}`;
-              const absolutePath = path5.resolve(process.cwd(), relativePath);
-              if (fs5.existsSync(absolutePath)) {
+              const absolutePath = path6.resolve(process.cwd(), relativePath);
+              if (fs6.existsSync(absolutePath)) {
                 fetchUrl = `file://${absolutePath}`;
               } else {
                 fetchUrl = `file://${url}`;
@@ -12380,8 +12886,8 @@ var resolveImageFormatSelection = (options) => {
 };
 
 // cli/build/worker-output-generators.ts
-import fs10 from "node:fs";
-import path14 from "node:path";
+import fs11 from "node:fs";
+import path15 from "node:path";
 
 // node_modules/circuit-json-to-3d-png/dist/index.js
 function normalizeDir(dir) {
@@ -14862,8 +15368,8 @@ import {
 // node_modules/conf/dist/source/index.js
 import { isDeepStrictEqual } from "node:util";
 import process7 from "node:process";
-import fs7 from "node:fs";
-import path9 from "node:path";
+import fs8 from "node:fs";
+import path10 from "node:path";
 import crypto from "node:crypto";
 import assert from "node:assert";
 
@@ -14878,12 +15384,12 @@ var disallowedKeys = new Set([
   "constructor"
 ]);
 var digits = new Set("0123456789");
-function getPathSegments(path6) {
+function getPathSegments(path7) {
   const parts = [];
   let currentSegment = "";
   let currentPart = "start";
   let isIgnoring = false;
-  for (const character of path6) {
+  for (const character of path7) {
     switch (character) {
       case "\\": {
         if (currentPart === "index") {
@@ -15005,11 +15511,11 @@ function assertNotStringIndex(object, key) {
     throw new Error("Cannot use string index");
   }
 }
-function getProperty(object, path6, value) {
-  if (!isObject(object) || typeof path6 !== "string") {
+function getProperty(object, path7, value) {
+  if (!isObject(object) || typeof path7 !== "string") {
     return value === undefined ? object : value;
   }
-  const pathArray = getPathSegments(path6);
+  const pathArray = getPathSegments(path7);
   if (pathArray.length === 0) {
     return value;
   }
@@ -15029,12 +15535,12 @@ function getProperty(object, path6, value) {
   }
   return object === undefined ? value : object;
 }
-function setProperty(object, path6, value) {
-  if (!isObject(object) || typeof path6 !== "string") {
+function setProperty(object, path7, value) {
+  if (!isObject(object) || typeof path7 !== "string") {
     return object;
   }
   const root = object;
-  const pathArray = getPathSegments(path6);
+  const pathArray = getPathSegments(path7);
   for (let index = 0;index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -15047,11 +15553,11 @@ function setProperty(object, path6, value) {
   }
   return root;
 }
-function deleteProperty(object, path6) {
-  if (!isObject(object) || typeof path6 !== "string") {
+function deleteProperty(object, path7) {
+  if (!isObject(object) || typeof path7 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path6);
+  const pathArray = getPathSegments(path7);
   for (let index = 0;index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -15065,11 +15571,11 @@ function deleteProperty(object, path6) {
     }
   }
 }
-function hasProperty(object, path6) {
-  if (!isObject(object) || typeof path6 !== "string") {
+function hasProperty(object, path7) {
+  if (!isObject(object) || typeof path7 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path6);
+  const pathArray = getPathSegments(path7);
   if (pathArray.length === 0) {
     return false;
   }
@@ -15083,41 +15589,41 @@ function hasProperty(object, path6) {
 }
 
 // node_modules/env-paths/index.js
-import path6 from "node:path";
+import path7 from "node:path";
 import os from "node:os";
 import process2 from "node:process";
 var homedir = os.homedir();
 var tmpdir = os.tmpdir();
 var { env } = process2;
 var macos = (name) => {
-  const library = path6.join(homedir, "Library");
+  const library = path7.join(homedir, "Library");
   return {
-    data: path6.join(library, "Application Support", name),
-    config: path6.join(library, "Preferences", name),
-    cache: path6.join(library, "Caches", name),
-    log: path6.join(library, "Logs", name),
-    temp: path6.join(tmpdir, name)
+    data: path7.join(library, "Application Support", name),
+    config: path7.join(library, "Preferences", name),
+    cache: path7.join(library, "Caches", name),
+    log: path7.join(library, "Logs", name),
+    temp: path7.join(tmpdir, name)
   };
 };
 var windows = (name) => {
-  const appData = env.APPDATA || path6.join(homedir, "AppData", "Roaming");
-  const localAppData = env.LOCALAPPDATA || path6.join(homedir, "AppData", "Local");
+  const appData = env.APPDATA || path7.join(homedir, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path7.join(homedir, "AppData", "Local");
   return {
-    data: path6.join(localAppData, name, "Data"),
-    config: path6.join(appData, name, "Config"),
-    cache: path6.join(localAppData, name, "Cache"),
-    log: path6.join(localAppData, name, "Log"),
-    temp: path6.join(tmpdir, name)
+    data: path7.join(localAppData, name, "Data"),
+    config: path7.join(appData, name, "Config"),
+    cache: path7.join(localAppData, name, "Cache"),
+    log: path7.join(localAppData, name, "Log"),
+    temp: path7.join(tmpdir, name)
   };
 };
 var linux = (name) => {
-  const username = path6.basename(homedir);
+  const username = path7.basename(homedir);
   return {
-    data: path6.join(env.XDG_DATA_HOME || path6.join(homedir, ".local", "share"), name),
-    config: path6.join(env.XDG_CONFIG_HOME || path6.join(homedir, ".config"), name),
-    cache: path6.join(env.XDG_CACHE_HOME || path6.join(homedir, ".cache"), name),
-    log: path6.join(env.XDG_STATE_HOME || path6.join(homedir, ".local", "state"), name),
-    temp: path6.join(tmpdir, username, name)
+    data: path7.join(env.XDG_DATA_HOME || path7.join(homedir, ".local", "share"), name),
+    config: path7.join(env.XDG_CONFIG_HOME || path7.join(homedir, ".config"), name),
+    cache: path7.join(env.XDG_CACHE_HOME || path7.join(homedir, ".cache"), name),
+    log: path7.join(env.XDG_STATE_HOME || path7.join(homedir, ".local", "state"), name),
+    temp: path7.join(tmpdir, username, name)
   };
 };
 function envPaths(name, { suffix = "nodejs" } = {}) {
@@ -15137,10 +15643,10 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
 }
 
 // node_modules/atomically/dist/index.js
-import path8 from "node:path";
+import path9 from "node:path";
 
 // node_modules/stubborn-fs/dist/index.js
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import { promisify } from "node:util";
 
 // node_modules/stubborn-utils/dist/attemptify_async.js
@@ -15270,41 +15776,41 @@ var RETRYIFY_OPTIONS = {
 // node_modules/stubborn-fs/dist/index.js
 var FS = {
   attempt: {
-    chmod: attemptify_async_default(promisify(fs6.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    chown: attemptify_async_default(promisify(fs6.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    close: attemptify_async_default(promisify(fs6.close), ATTEMPTIFY_NOOP_OPTIONS),
-    fsync: attemptify_async_default(promisify(fs6.fsync), ATTEMPTIFY_NOOP_OPTIONS),
-    mkdir: attemptify_async_default(promisify(fs6.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
-    realpath: attemptify_async_default(promisify(fs6.realpath), ATTEMPTIFY_NOOP_OPTIONS),
-    stat: attemptify_async_default(promisify(fs6.stat), ATTEMPTIFY_NOOP_OPTIONS),
-    unlink: attemptify_async_default(promisify(fs6.unlink), ATTEMPTIFY_NOOP_OPTIONS),
-    chmodSync: attemptify_sync_default(fs6.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    chownSync: attemptify_sync_default(fs6.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    closeSync: attemptify_sync_default(fs6.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
-    existsSync: attemptify_sync_default(fs6.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
-    fsyncSync: attemptify_sync_default(fs6.fsync, ATTEMPTIFY_NOOP_OPTIONS),
-    mkdirSync: attemptify_sync_default(fs6.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
-    realpathSync: attemptify_sync_default(fs6.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
-    statSync: attemptify_sync_default(fs6.statSync, ATTEMPTIFY_NOOP_OPTIONS),
-    unlinkSync: attemptify_sync_default(fs6.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
+    chmod: attemptify_async_default(promisify(fs7.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chown: attemptify_async_default(promisify(fs7.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    close: attemptify_async_default(promisify(fs7.close), ATTEMPTIFY_NOOP_OPTIONS),
+    fsync: attemptify_async_default(promisify(fs7.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+    mkdir: attemptify_async_default(promisify(fs7.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+    realpath: attemptify_async_default(promisify(fs7.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+    stat: attemptify_async_default(promisify(fs7.stat), ATTEMPTIFY_NOOP_OPTIONS),
+    unlink: attemptify_async_default(promisify(fs7.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+    chmodSync: attemptify_sync_default(fs7.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chownSync: attemptify_sync_default(fs7.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    closeSync: attemptify_sync_default(fs7.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+    existsSync: attemptify_sync_default(fs7.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+    fsyncSync: attemptify_sync_default(fs7.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+    mkdirSync: attemptify_sync_default(fs7.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+    realpathSync: attemptify_sync_default(fs7.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+    statSync: attemptify_sync_default(fs7.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+    unlinkSync: attemptify_sync_default(fs7.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
   },
   retry: {
-    close: retryify_async_default(promisify(fs6.close), RETRYIFY_OPTIONS),
-    fsync: retryify_async_default(promisify(fs6.fsync), RETRYIFY_OPTIONS),
-    open: retryify_async_default(promisify(fs6.open), RETRYIFY_OPTIONS),
-    readFile: retryify_async_default(promisify(fs6.readFile), RETRYIFY_OPTIONS),
-    rename: retryify_async_default(promisify(fs6.rename), RETRYIFY_OPTIONS),
-    stat: retryify_async_default(promisify(fs6.stat), RETRYIFY_OPTIONS),
-    write: retryify_async_default(promisify(fs6.write), RETRYIFY_OPTIONS),
-    writeFile: retryify_async_default(promisify(fs6.writeFile), RETRYIFY_OPTIONS),
-    closeSync: retryify_sync_default(fs6.closeSync, RETRYIFY_OPTIONS),
-    fsyncSync: retryify_sync_default(fs6.fsyncSync, RETRYIFY_OPTIONS),
-    openSync: retryify_sync_default(fs6.openSync, RETRYIFY_OPTIONS),
-    readFileSync: retryify_sync_default(fs6.readFileSync, RETRYIFY_OPTIONS),
-    renameSync: retryify_sync_default(fs6.renameSync, RETRYIFY_OPTIONS),
-    statSync: retryify_sync_default(fs6.statSync, RETRYIFY_OPTIONS),
-    writeSync: retryify_sync_default(fs6.writeSync, RETRYIFY_OPTIONS),
-    writeFileSync: retryify_sync_default(fs6.writeFileSync, RETRYIFY_OPTIONS)
+    close: retryify_async_default(promisify(fs7.close), RETRYIFY_OPTIONS),
+    fsync: retryify_async_default(promisify(fs7.fsync), RETRYIFY_OPTIONS),
+    open: retryify_async_default(promisify(fs7.open), RETRYIFY_OPTIONS),
+    readFile: retryify_async_default(promisify(fs7.readFile), RETRYIFY_OPTIONS),
+    rename: retryify_async_default(promisify(fs7.rename), RETRYIFY_OPTIONS),
+    stat: retryify_async_default(promisify(fs7.stat), RETRYIFY_OPTIONS),
+    write: retryify_async_default(promisify(fs7.write), RETRYIFY_OPTIONS),
+    writeFile: retryify_async_default(promisify(fs7.writeFile), RETRYIFY_OPTIONS),
+    closeSync: retryify_sync_default(fs7.closeSync, RETRYIFY_OPTIONS),
+    fsyncSync: retryify_sync_default(fs7.fsyncSync, RETRYIFY_OPTIONS),
+    openSync: retryify_sync_default(fs7.openSync, RETRYIFY_OPTIONS),
+    readFileSync: retryify_sync_default(fs7.readFileSync, RETRYIFY_OPTIONS),
+    renameSync: retryify_sync_default(fs7.renameSync, RETRYIFY_OPTIONS),
+    statSync: retryify_sync_default(fs7.statSync, RETRYIFY_OPTIONS),
+    writeSync: retryify_sync_default(fs7.writeSync, RETRYIFY_OPTIONS),
+    writeFileSync: retryify_sync_default(fs7.writeFileSync, RETRYIFY_OPTIONS)
   }
 };
 var dist_default = FS;
@@ -15334,7 +15840,7 @@ var isUndefined = (value) => {
 };
 
 // node_modules/atomically/dist/utils/temp.js
-import path7 from "node:path";
+import path8 from "node:path";
 
 // node_modules/when-exit/dist/node/interceptor.js
 import process6 from "node:process";
@@ -15434,7 +15940,7 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename = path7.basename(filePath);
+    const basename = path8.basename(filePath);
     if (basename.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
     const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename);
@@ -15476,7 +15982,7 @@ function writeFileSync2(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
       }
     }
     if (!filePathExists) {
-      const parentPath = path8.dirname(filePath);
+      const parentPath = path9.dirname(filePath);
       dist_default.attempt.mkdirSync(parentPath, {
         mode: DEFAULT_FOLDER_MODE,
         recursive: true
@@ -15792,7 +16298,7 @@ class Conf {
     this.events = new EventTarget;
     this.#encryptionKey = options.encryptionKey;
     const fileExtension = options.fileExtension ? `.${options.fileExtension}` : "";
-    this.path = path9.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
+    this.path = path10.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
     const fileStore = this.store;
     const store = Object.assign(createPlainObject(), options.defaults, fileStore);
     if (options.migrations) {
@@ -15895,7 +16401,7 @@ class Conf {
   }
   get store() {
     try {
-      const data = fs7.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
+      const data = fs8.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
       const dataString = this._encryptData(data);
       const deserializedData = this._deserialize(dataString);
       this._validate(deserializedData);
@@ -15966,7 +16472,7 @@ class Conf {
     throw new Error("Config schema violation: " + errors.join("; "));
   }
   _ensureDirectory() {
-    fs7.mkdirSync(path9.dirname(this.path), { recursive: true });
+    fs8.mkdirSync(path10.dirname(this.path), { recursive: true });
   }
   _write(value) {
     let data = this._serialize(value);
@@ -15977,13 +16483,13 @@ class Conf {
       data = concatUint8Arrays([initializationVector, stringToUint8Array(":"), cipher.update(stringToUint8Array(data)), cipher.final()]);
     }
     if (process7.env.SNAP) {
-      fs7.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+      fs8.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
     } else {
       try {
         writeFileSync2(this.path, data, { mode: this.#options.configFileMode });
       } catch (error) {
         if (error?.code === "EXDEV") {
-          fs7.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+          fs8.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
           return;
         }
         throw error;
@@ -15992,15 +16498,15 @@ class Conf {
   }
   _watch() {
     this._ensureDirectory();
-    if (!fs7.existsSync(this.path)) {
+    if (!fs8.existsSync(this.path)) {
       this._write(createPlainObject());
     }
     if (process7.platform === "win32") {
-      fs7.watch(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs8.watch(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 100 }));
     } else {
-      fs7.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs8.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 5000 }));
     }
@@ -16136,113 +16642,14 @@ function jwtDecode(token, options) {
 }
 
 // lib/cli-config/index.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import os3 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 
 // lib/shared/handle-registry-auth-error.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import os2 from "node:os";
-import path10 from "node:path";
-
-// node_modules/kleur/index.mjs
-var FORCE_COLOR;
-var NODE_DISABLE_COLORS;
-var NO_COLOR;
-var TERM;
-var isTTY = true;
-if (typeof process !== "undefined") {
-  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
-  isTTY = process.stdout && process.stdout.isTTY;
-}
-var $ = {
-  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY),
-  reset: init(0, 0),
-  bold: init(1, 22),
-  dim: init(2, 22),
-  italic: init(3, 23),
-  underline: init(4, 24),
-  inverse: init(7, 27),
-  hidden: init(8, 28),
-  strikethrough: init(9, 29),
-  black: init(30, 39),
-  red: init(31, 39),
-  green: init(32, 39),
-  yellow: init(33, 39),
-  blue: init(34, 39),
-  magenta: init(35, 39),
-  cyan: init(36, 39),
-  white: init(37, 39),
-  gray: init(90, 39),
-  grey: init(90, 39),
-  bgBlack: init(40, 49),
-  bgRed: init(41, 49),
-  bgGreen: init(42, 49),
-  bgYellow: init(43, 49),
-  bgBlue: init(44, 49),
-  bgMagenta: init(45, 49),
-  bgCyan: init(46, 49),
-  bgWhite: init(47, 49)
-};
-function run(arr, str) {
-  let i = 0, tmp, beg = "", end = "";
-  for (;i < arr.length; i++) {
-    tmp = arr[i];
-    beg += tmp.open;
-    end += tmp.close;
-    if (!!~str.indexOf(tmp.close)) {
-      str = str.replace(tmp.rgx, tmp.close + tmp.open);
-    }
-  }
-  return beg + str + end;
-}
-function chain(has, keys) {
-  let ctx = { has, keys };
-  ctx.reset = $.reset.bind(ctx);
-  ctx.bold = $.bold.bind(ctx);
-  ctx.dim = $.dim.bind(ctx);
-  ctx.italic = $.italic.bind(ctx);
-  ctx.underline = $.underline.bind(ctx);
-  ctx.inverse = $.inverse.bind(ctx);
-  ctx.hidden = $.hidden.bind(ctx);
-  ctx.strikethrough = $.strikethrough.bind(ctx);
-  ctx.black = $.black.bind(ctx);
-  ctx.red = $.red.bind(ctx);
-  ctx.green = $.green.bind(ctx);
-  ctx.yellow = $.yellow.bind(ctx);
-  ctx.blue = $.blue.bind(ctx);
-  ctx.magenta = $.magenta.bind(ctx);
-  ctx.cyan = $.cyan.bind(ctx);
-  ctx.white = $.white.bind(ctx);
-  ctx.gray = $.gray.bind(ctx);
-  ctx.grey = $.grey.bind(ctx);
-  ctx.bgBlack = $.bgBlack.bind(ctx);
-  ctx.bgRed = $.bgRed.bind(ctx);
-  ctx.bgGreen = $.bgGreen.bind(ctx);
-  ctx.bgYellow = $.bgYellow.bind(ctx);
-  ctx.bgBlue = $.bgBlue.bind(ctx);
-  ctx.bgMagenta = $.bgMagenta.bind(ctx);
-  ctx.bgCyan = $.bgCyan.bind(ctx);
-  ctx.bgWhite = $.bgWhite.bind(ctx);
-  return ctx;
-}
-function init(open, close) {
-  let blk = {
-    open: `\x1B[${open}m`,
-    close: `\x1B[${close}m`,
-    rgx: new RegExp(`\\x1b\\[${close}m`, "g")
-  };
-  return function(txt) {
-    if (this !== undefined && this.has !== undefined) {
-      !!~this.has.indexOf(open) || (this.has.push(open), this.keys.push(blk));
-      return txt === undefined ? this : $.enabled ? run(this.keys, txt + "") : txt + "";
-    }
-    return txt === undefined ? chain([open], [blk]) : $.enabled ? run([blk], txt + "") : txt + "";
-  };
-}
-var kleur_default = $;
-
-// lib/shared/handle-registry-auth-error.ts
+import path11 from "node:path";
 var AUTH_TOKEN_REGEX = /^\/\/npm\.tscircuit\.com\/:_authToken=(.+)$/m;
 function isUnauthorizedError(error) {
   const output = [
@@ -16263,9 +16670,9 @@ function isUnauthorizedError(error) {
   return /\b(401|E401)\b/i.test(output) || /unauthorized/i.test(output);
 }
 function hasTsciAuthToken(npmrcPath) {
-  if (!fs8.existsSync(npmrcPath))
+  if (!fs9.existsSync(npmrcPath))
     return false;
-  const content = fs8.readFileSync(npmrcPath, "utf-8");
+  const content = fs9.readFileSync(npmrcPath, "utf-8");
   return AUTH_TOKEN_REGEX.test(content);
 }
 function handleRegistryAuthError({
@@ -16275,8 +16682,8 @@ function handleRegistryAuthError({
   if (!isUnauthorizedError(error))
     return;
   const npmrcPaths = [
-    path10.join(projectDir, ".npmrc"),
-    path10.join(os2.homedir(), ".npmrc")
+    path11.join(projectDir, ".npmrc"),
+    path11.join(os2.homedir(), ".npmrc")
   ];
   const hasToken = npmrcPaths.some(hasTsciAuthToken);
   if (hasToken) {
@@ -16299,13 +16706,13 @@ var getSessionToken = () => {
 };
 var getSessionTokenFromNpmrc = () => {
   const npmrcPaths = [
-    path11.join(process.cwd(), ".npmrc"),
-    path11.join(os3.homedir(), ".npmrc")
+    path12.join(process.cwd(), ".npmrc"),
+    path12.join(os3.homedir(), ".npmrc")
   ];
   for (const npmrcPath of npmrcPaths) {
-    if (!fs9.existsSync(npmrcPath))
+    if (!fs10.existsSync(npmrcPath))
       continue;
-    const content = fs9.readFileSync(npmrcPath, "utf-8");
+    const content = fs10.readFileSync(npmrcPath, "utf-8");
     const match = content.match(AUTH_TOKEN_REGEX);
     if (match?.[1]) {
       return match[1].trim();
@@ -16343,7 +16750,7 @@ var getCircuitJsonToGltfOptions = ({
 };
 
 // cli/build/convert-model-urls-to-file-urls.ts
-import path12 from "node:path";
+import path13 from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 var convertModelUrlsToFileUrls = (circuitJson) => {
   const modelUrlKeys2 = [
@@ -16370,7 +16777,7 @@ var convertModelUrlsToFileUrls = (circuitJson) => {
         if (value.startsWith("/") || value.match(/^[a-zA-Z]:\\/)) {
           updated[key] = pathToFileURL3(value).href;
         } else if (value.startsWith(".")) {
-          updated[key] = pathToFileURL3(path12.resolve(process.cwd(), value)).href;
+          updated[key] = pathToFileURL3(path13.resolve(process.cwd(), value)).href;
         }
       }
     }
@@ -16411,7 +16818,7 @@ var convertSvgToPngBuffer = async (svg) => {
 // lib/shared/load-local-step-model-fs-map.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile } from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 var isRemoteUrl = (value) => /^https?:\/\//i.test(value);
 async function loadLocalStepModelFsMap(circuitJson) {
   const fsMap = {};
@@ -16423,7 +16830,7 @@ async function loadLocalStepModelFsMap(circuitJson) {
       continue;
     if (isRemoteUrl(modelUrl) || fsMap[modelUrl])
       continue;
-    const localPath = path13.resolve(process.cwd(), modelUrl);
+    const localPath = path14.resolve(process.cwd(), modelUrl);
     if (!existsSync2(localPath))
       continue;
     fsMap[modelUrl] = await readFile(localPath, "utf-8");
@@ -16479,10 +16886,10 @@ var writeSimulationSvgAssetsFromCircuitJson = (circuitJson, outputDir, imageForm
   if (!simulationSvgAssets)
     return false;
   if (imageFormats.simulationSvgs) {
-    fs10.writeFileSync(path14.join(outputDir, "simulation.svg"), simulationSvgAssets.simulationSvg, "utf-8");
+    fs11.writeFileSync(path15.join(outputDir, "simulation.svg"), simulationSvgAssets.simulationSvg, "utf-8");
   }
   if (imageFormats.simulationSchematicSvgs) {
-    fs10.writeFileSync(path14.join(outputDir, "simulation-schematic.svg"), simulationSvgAssets.schematicSimulationSvg, "utf-8");
+    fs11.writeFileSync(path15.join(outputDir, "simulation-schematic.svg"), simulationSvgAssets.schematicSimulationSvg, "utf-8");
   }
   return true;
 };
@@ -16490,8 +16897,8 @@ var writeGlbFromCircuitJson = async (circuitJson, glbOutputPath) => {
   const circuitJsonWithFileUrls = convertModelUrlsToFileUrls(circuitJson);
   const glbBuffer = await convertCircuitJsonToGltf(circuitJsonWithFileUrls, getCircuitJsonToGltfOptions({ format: "glb" }));
   const glbData = normalizeToUint8Array2(glbBuffer);
-  fs10.mkdirSync(path14.dirname(glbOutputPath), { recursive: true });
-  fs10.writeFileSync(glbOutputPath, Buffer.from(glbData));
+  fs11.mkdirSync(path15.dirname(glbOutputPath), { recursive: true });
+  fs11.writeFileSync(glbOutputPath, Buffer.from(glbData));
 };
 var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
   const stepContent = await circuitJsonToStep(circuitJson, {
@@ -16499,34 +16906,34 @@ var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
     includeExternalMeshes: true,
     fsMap: await loadLocalStepModelFsMap(circuitJson)
   });
-  fs10.mkdirSync(path14.dirname(stepOutputPath), { recursive: true });
-  fs10.writeFileSync(stepOutputPath, stepContent);
+  fs11.mkdirSync(path15.dirname(stepOutputPath), { recursive: true });
+  fs11.writeFileSync(stepOutputPath, stepContent);
 };
 var writeImageAssetsFromCircuitJson = async (circuitJson, options) => {
   const { outputDir, imageFormats, pcbSnapshotSettings } = options;
-  fs10.mkdirSync(outputDir, { recursive: true });
+  fs11.mkdirSync(outputDir, { recursive: true });
   if (imageFormats.pcbSvgs) {
     const pcbSvg = convertCircuitJsonToPcbSvg(circuitJson, pcbSnapshotSettings);
-    fs10.writeFileSync(path14.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
+    fs11.writeFileSync(path15.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
   }
   if (imageFormats.pcbPngs) {
     const pcbSvg = convertCircuitJsonToPcbSvg(circuitJson, pcbSnapshotSettings);
-    fs10.writeFileSync(path14.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
+    fs11.writeFileSync(path15.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
   }
   if (imageFormats.schematicSvgs) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs10.writeFileSync(path14.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
+    fs11.writeFileSync(path15.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
   }
   writeSimulationSvgAssetsFromCircuitJson(circuitJson, outputDir, imageFormats);
   if (imageFormats.threeDPngs) {
     const pngBuffer = await renderCircuitJsonTo3dPng(circuitJson);
-    fs10.writeFileSync(path14.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
+    fs11.writeFileSync(path15.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
   }
 };
 
 // cli/build/worker-build-handlers.ts
 var loadCircuitJsonFromInputFile = (filePath) => {
-  const parsed = JSON.parse(fs11.readFileSync(filePath, "utf-8"));
+  const parsed = JSON.parse(fs12.readFileSync(filePath, "utf-8"));
   return Array.isArray(parsed) ? parsed : [];
 };
 var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath, previewOutputDir, projectDir, options, workerLog, workerStatus) => {
@@ -16535,7 +16942,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
   const startedAt = options?.profile ? performance.now() : 0;
   try {
     process.chdir(projectDir);
-    workerLog(`Generating circuit JSON for ${path15.relative(projectDir, filePath)}...`);
+    workerLog(`Generating circuit JSON for ${path16.relative(projectDir, filePath)}...`);
     await registerStaticAssetLoaders();
     const projectConfig = await loadRuntimeProjectConfig(projectDir);
     const platformConfig = mergePlatformConfigs(projectConfig?.platformConfig, options?.platformConfig);
@@ -16546,13 +16953,17 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
       filePath,
       platformConfig: platformConfigWithCliDefaults,
       injectedProps: options?.injectedProps,
+      autorouterDiagnostics: options?.autorouterDiagnostics ? {
+        ...options.autorouterDiagnostics,
+        log: (message) => workerLog(message)
+      } : undefined,
       onAsyncEffectStatus: (asyncEffectName) => {
         workerStatus(`waiting on ${asyncEffectName}…`);
       }
     })).circuitJson;
-    fs11.mkdirSync(path15.dirname(outputPath), { recursive: true });
-    fs11.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
-    workerLog(`Circuit JSON written to ${path15.relative(projectDir, outputPath)}`);
+    fs12.mkdirSync(path16.dirname(outputPath), { recursive: true });
+    fs12.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    workerLog(`Circuit JSON written to ${path16.relative(projectDir, outputPath)}`);
     const diagnostics = analyzeCircuitJson(circuitJson);
     const filteredDiagnostics = filterDiagnosticsByDrcCategory({
       errors: diagnostics.errors,
@@ -16582,7 +16993,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     let previewError;
     if (glbOutputPath) {
       try {
-        workerLog(`Converting ${path15.relative(projectDir, outputPath)} to GLB in same worker...`);
+        workerLog(`Converting ${path16.relative(projectDir, outputPath)} to GLB in same worker...`);
         await writeGlbFromCircuitJson(circuitJson, glbOutputPath);
         glbOk = true;
       } catch (err) {
@@ -16593,7 +17004,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (stepOutputPath) {
       try {
-        workerLog(`Converting ${path15.relative(projectDir, outputPath)} to STEP in same worker...`);
+        workerLog(`Converting ${path16.relative(projectDir, outputPath)} to STEP in same worker...`);
         await writeStepFromCircuitJson(circuitJson, stepOutputPath);
         stepOk = true;
       } catch (err) {
@@ -16604,8 +17015,8 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (options?.generatePreviewAssets) {
       try {
-        const resolvedPreviewOutputDir = previewOutputDir ?? path15.dirname(outputPath);
-        workerLog(`Generating preview assets for ${path15.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
+        const resolvedPreviewOutputDir = previewOutputDir ?? path16.dirname(outputPath);
+        workerLog(`Generating preview assets for ${path16.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
         await writeImageAssetsFromCircuitJson(circuitJson, {
           outputDir: resolvedPreviewOutputDir,
           imageFormats: options?.imageFormats ?? DEFAULT_IMAGE_FORMAT_SELECTION,