@tscircuit/cli 0.1.1797 → 0.1.1798

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

@@ -5608,8 +5608,8 @@ var require_utils = __commonJS((exports, module) => {
     }
     return ind;
   }
-  function removeDotSegments(path12) {
-    let input = path12;
+  function removeDotSegments(path13) {
+    let input = path13;
     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 [path12, query] = wsComponent.resourceName.split("?");
-      wsComponent.path = path12 && path12 !== "/" ? path12 : undefined;
+      const [path13, query] = wsComponent.resourceName.split("?");
+      wsComponent.path = path13 && path13 !== "/" ? path13 : 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, fs9, exportName) {
+  function addFormats(ajv, list, fs10, 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, fs9[f]);
+      ajv.addFormat(f, fs10[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 fs13 from "node:fs";
-import path17 from "node:path";
+import fs14 from "node:fs";
+import path18 from "node:path";
 
 // lib/project-config/index.ts
 import * as fs from "node:fs";
@@ -11863,8 +11863,8 @@ function analyzeCircuitJson(circuitJson) {
 }
 
 // lib/shared/generate-circuit-json.tsx
-import fs6 from "node:fs";
-import path6 from "node:path";
+import fs7 from "node:fs";
+import path7 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import Debug from "debug";
 
@@ -12799,6 +12799,120 @@ var readCurrentCircuitJsonBuild = ({
   }
 };
 
+// lib/shared/solver-diagnostics.ts
+import fs6 from "node:fs";
+import path6 from "node:path";
+var escapeJsonPointerSegment = (segment) => segment.replaceAll("~", "~0").replaceAll("/", "~1");
+var cloneAsJson = (value, ancestors = new WeakMap, path7 = "#") => {
+  if (value === undefined)
+    return { value_type: "undefined" };
+  if (typeof value === "bigint") {
+    return { value_type: "bigint", value: value.toString() };
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return { value_type: "number", value: value.toString() };
+  }
+  if (typeof value === "number" && Object.is(value, -0)) {
+    return { value_type: "number", value: "-0" };
+  }
+  if (typeof value === "symbol") {
+    return { value_type: "symbol", value: value.description ?? null };
+  }
+  if (typeof value === "function") {
+    return {
+      value_type: "function",
+      name: value.name || null,
+      source: value.toString()
+    };
+  }
+  if (value === null || typeof value !== "object")
+    return value;
+  const ancestorPath = ancestors.get(value);
+  if (ancestorPath) {
+    return { value_type: "circular_reference", path: ancestorPath };
+  }
+  ancestors.set(value, path7);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((item, index) => cloneAsJson(item, ancestors, `${path7}/${index}`));
+    }
+    if (value instanceof Date) {
+      return { value_type: "date", value: value.toISOString() };
+    }
+    if (value instanceof RegExp) {
+      return {
+        value_type: "regexp",
+        source: value.source,
+        flags: value.flags
+      };
+    }
+    if (value instanceof Map) {
+      return {
+        value_type: "map",
+        entries: Array.from(value.entries(), ([key, item], index) => [
+          cloneAsJson(key, ancestors, `${path7}/entries/${index}/0`),
+          cloneAsJson(item, ancestors, `${path7}/entries/${index}/1`)
+        ])
+      };
+    }
+    if (value instanceof Set) {
+      return {
+        value_type: "set",
+        values: Array.from(value.values(), (item, index) => cloneAsJson(item, ancestors, `${path7}/values/${index}`))
+      };
+    }
+    if (value instanceof Error) {
+      return {
+        value_type: "error",
+        name: value.name,
+        message: value.message,
+        stack: value.stack
+      };
+    }
+    const clonedObject = {};
+    for (const [key, item] of Object.entries(value)) {
+      clonedObject[key] = cloneAsJson(item, ancestors, `${path7}/${escapeJsonPointerSegment(key)}`);
+    }
+    return clonedObject;
+  } finally {
+    ancestors.delete(value);
+  }
+};
+
+class SolverDiagnostics {
+  options;
+  solverInvocations = [];
+  constructor(options) {
+    this.options = options;
+  }
+  attachToRootCircuit(rootCircuit) {
+    if (!this.options.enabled)
+      return;
+    rootCircuit.on?.("solver:started", (rawEvent) => {
+      const event = rawEvent;
+      const constructorArgs = Array.isArray(event.solverConstructorArgs) ? event.solverConstructorArgs : [event.solverParams];
+      this.solverInvocations.push({
+        sequence: this.solverInvocations.length,
+        solver_name: typeof event.solverName === "string" ? event.solverName : "unknown_solver",
+        component_name: typeof event.componentName === "string" ? event.componentName : null,
+        constructor_args: cloneAsJson(constructorArgs)
+      });
+    });
+  }
+  finalize() {
+    if (!this.options.enabled)
+      return;
+    fs6.mkdirSync(path6.dirname(this.options.outputPath), { recursive: true });
+    fs6.writeFileSync(this.options.outputPath, `${JSON.stringify({
+      format: "tscircuit_solver_debug_v1",
+      entrypoint: this.options.entrypoint,
+      solvers: this.solverInvocations
+    }, null, 2)}
+`);
+    this.options.log?.(`Solver inputs written to ${this.options.outputPath}`);
+  }
+}
+
 // lib/shared/generate-circuit-json.tsx
 import { jsxDEV } from "react/jsx-dev-runtime";
 var debug = Debug("tsci:generate-circuit-json");
@@ -12826,6 +12940,7 @@ async function generateCircuitJson({
   injectedProps,
   onAsyncEffectStatus,
   autorouterDiagnostics: autorouterDiagnosticsOptions,
+  solverDiagnostics: solverDiagnosticsOptions,
   sourceFilesystemMd5Hash
 }) {
   debug(`Generating circuit JSON for ${filePath}`);
@@ -12839,12 +12954,14 @@ async function generateCircuitJson({
   });
   const autorouterDiagnostics = new AutorouterDiagnostics(autorouterDiagnosticsOptions);
   autorouterDiagnostics.attachToRootCircuit(runner);
-  const absoluteFilePath = path6.isAbsolute(filePath) ? filePath : path6.resolve(process.cwd(), filePath);
-  const projectDir = path6.dirname(absoluteFilePath);
+  const solverDiagnostics = solverDiagnosticsOptions ? new SolverDiagnostics(solverDiagnosticsOptions) : null;
+  solverDiagnostics?.attachToRootCircuit(runner);
+  const absoluteFilePath = path7.isAbsolute(filePath) ? filePath : path7.resolve(process.cwd(), filePath);
+  const projectDir = path7.dirname(absoluteFilePath);
   const resolvedOutputDir = outputDir ?? projectDir;
-  const relativeComponentPath = path6.relative(projectDir, absoluteFilePath);
-  const baseFileName = outputFileName || path6.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path6.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  const relativeComponentPath = path7.relative(projectDir, absoluteFilePath);
+  const baseFileName = outputFileName || path7.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path7.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
   debug(`Project directory: ${projectDir}`);
   debug(`Relative component path: ${relativeComponentPath}`);
   debug(`Output path: ${outputPath}`);
@@ -12864,7 +12981,7 @@ async function generateCircuitJson({
           return false;
         if (normalizedFilePath.match(/^\.[^/]/))
           return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path6.extname(normalizedFilePath)))
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path7.extname(normalizedFilePath)))
           return false;
         return true;
       },
@@ -12896,11 +13013,12 @@ async function generateCircuitJson({
     runner.render();
   }
   runner.emit("renderComplete");
+  solverDiagnostics?.finalize();
   const circuitJson = addSourceFilesystemHash(await runner.getCircuitJson(), currentSourceFilesystemMd5Hash);
   await autorouterDiagnostics.finalize(circuitJson);
   if (saveToFile) {
     debug(`Saving circuit JSON to ${outputPath}`);
-    fs6.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    fs7.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
   }
   return {
     circuitJson,
@@ -12911,28 +13029,28 @@ async function generateCircuitJson({
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
 import { createHash as createHash2 } from "node:crypto";
-import fs7 from "node:fs";
-import path7 from "node:path";
+import fs8 from "node:fs";
+import path8 from "node:path";
 import { getPlatformConfig } from "@tscircuit/eval/platform-config";
-function createLocalCacheEngine(cacheDir = path7.join(process.cwd(), ".tscircuit", "cache")) {
+function createLocalCacheEngine(cacheDir = path8.join(process.cwd(), ".tscircuit", "cache")) {
   return {
     getItem: (key) => {
       try {
         const hash = createHash2("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path7.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        return fs7.readFileSync(filePath, "utf-8");
+        const filePath = path8.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        return fs8.readFileSync(filePath, "utf-8");
       } catch {
         return null;
       }
     },
     setItem: (key, value) => {
       try {
-        fs7.mkdirSync(cacheDir, { recursive: true });
+        fs8.mkdirSync(cacheDir, { recursive: true });
         const hash = createHash2("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path7.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        fs7.writeFileSync(filePath, value);
+        const filePath = path8.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        fs8.writeFileSync(filePath, value);
       } catch {}
     }
   };
@@ -12948,15 +13066,15 @@ function getPlatformConfigWithCliDefaults(userConfig) {
         loadFromUrl: async (url) => {
           let fetchUrl = url;
           if (url.startsWith("./") || url.startsWith("../")) {
-            const absolutePath = path7.resolve(process.cwd(), url);
+            const absolutePath = path8.resolve(process.cwd(), url);
             fetchUrl = `file://${absolutePath}`;
           } else if (url.startsWith("/")) {
-            if (fs7.existsSync(url)) {
+            if (fs8.existsSync(url)) {
               fetchUrl = `file://${url}`;
             } else {
               const relativePath = `.${url}`;
-              const absolutePath = path7.resolve(process.cwd(), relativePath);
-              if (fs7.existsSync(absolutePath)) {
+              const absolutePath = path8.resolve(process.cwd(), relativePath);
+              if (fs8.existsSync(absolutePath)) {
                 fetchUrl = `file://${absolutePath}`;
               } else {
                 fetchUrl = `file://${url}`;
@@ -13187,8 +13305,8 @@ var resolveImageFormatSelection = (options) => {
 };
 
 // cli/build/worker-output-generators.ts
-import fs12 from "node:fs";
-import path16 from "node:path";
+import fs13 from "node:fs";
+import path17 from "node:path";
 
 // node_modules/circuit-json-to-3d-png/dist/index.js
 function normalizeDir(dir) {
@@ -15671,7 +15789,7 @@ import {
 // lib/shared/load-local-step-model-fs-map.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 var isRemoteUrl = (value) => /^https?:\/\//i.test(value);
 async function loadLocalStepModelFsMap(circuitJson) {
   const fsMap = {};
@@ -15683,7 +15801,7 @@ async function loadLocalStepModelFsMap(circuitJson) {
       continue;
     if (isRemoteUrl(modelUrl) || fsMap[modelUrl])
       continue;
-    const localPath = path8.resolve(process.cwd(), modelUrl);
+    const localPath = path9.resolve(process.cwd(), modelUrl);
     if (!existsSync2(localPath))
       continue;
     fsMap[modelUrl] = await readFile(localPath, "utf-8");
@@ -15759,8 +15877,8 @@ var getSimulationSvgAssetsFromCircuitJson = (circuitJson) => {
 // node_modules/conf/dist/source/index.js
 import { isDeepStrictEqual } from "node:util";
 import process7 from "node:process";
-import fs9 from "node:fs";
-import path12 from "node:path";
+import fs10 from "node:fs";
+import path13 from "node:path";
 import crypto from "node:crypto";
 import assert from "node:assert";
 
@@ -15775,12 +15893,12 @@ var disallowedKeys = new Set([
   "constructor"
 ]);
 var digits = new Set("0123456789");
-function getPathSegments(path9) {
+function getPathSegments(path10) {
   const parts = [];
   let currentSegment = "";
   let currentPart = "start";
   let isIgnoring = false;
-  for (const character of path9) {
+  for (const character of path10) {
     switch (character) {
       case "\\": {
         if (currentPart === "index") {
@@ -15902,11 +16020,11 @@ function assertNotStringIndex(object, key) {
     throw new Error("Cannot use string index");
   }
 }
-function getProperty(object, path9, value) {
-  if (!isObject(object) || typeof path9 !== "string") {
+function getProperty(object, path10, value) {
+  if (!isObject(object) || typeof path10 !== "string") {
     return value === undefined ? object : value;
   }
-  const pathArray = getPathSegments(path9);
+  const pathArray = getPathSegments(path10);
   if (pathArray.length === 0) {
     return value;
   }
@@ -15926,12 +16044,12 @@ function getProperty(object, path9, value) {
   }
   return object === undefined ? value : object;
 }
-function setProperty(object, path9, value) {
-  if (!isObject(object) || typeof path9 !== "string") {
+function setProperty(object, path10, value) {
+  if (!isObject(object) || typeof path10 !== "string") {
     return object;
   }
   const root = object;
-  const pathArray = getPathSegments(path9);
+  const pathArray = getPathSegments(path10);
   for (let index = 0;index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -15944,11 +16062,11 @@ function setProperty(object, path9, value) {
   }
   return root;
 }
-function deleteProperty(object, path9) {
-  if (!isObject(object) || typeof path9 !== "string") {
+function deleteProperty(object, path10) {
+  if (!isObject(object) || typeof path10 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path9);
+  const pathArray = getPathSegments(path10);
   for (let index = 0;index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -15962,11 +16080,11 @@ function deleteProperty(object, path9) {
     }
   }
 }
-function hasProperty(object, path9) {
-  if (!isObject(object) || typeof path9 !== "string") {
+function hasProperty(object, path10) {
+  if (!isObject(object) || typeof path10 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path9);
+  const pathArray = getPathSegments(path10);
   if (pathArray.length === 0) {
     return false;
   }
@@ -15980,41 +16098,41 @@ function hasProperty(object, path9) {
 }
 
 // node_modules/env-paths/index.js
-import path9 from "node:path";
+import path10 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 = path9.join(homedir, "Library");
+  const library = path10.join(homedir, "Library");
   return {
-    data: path9.join(library, "Application Support", name),
-    config: path9.join(library, "Preferences", name),
-    cache: path9.join(library, "Caches", name),
-    log: path9.join(library, "Logs", name),
-    temp: path9.join(tmpdir, name)
+    data: path10.join(library, "Application Support", name),
+    config: path10.join(library, "Preferences", name),
+    cache: path10.join(library, "Caches", name),
+    log: path10.join(library, "Logs", name),
+    temp: path10.join(tmpdir, name)
   };
 };
 var windows = (name) => {
-  const appData = env.APPDATA || path9.join(homedir, "AppData", "Roaming");
-  const localAppData = env.LOCALAPPDATA || path9.join(homedir, "AppData", "Local");
+  const appData = env.APPDATA || path10.join(homedir, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path10.join(homedir, "AppData", "Local");
   return {
-    data: path9.join(localAppData, name, "Data"),
-    config: path9.join(appData, name, "Config"),
-    cache: path9.join(localAppData, name, "Cache"),
-    log: path9.join(localAppData, name, "Log"),
-    temp: path9.join(tmpdir, name)
+    data: path10.join(localAppData, name, "Data"),
+    config: path10.join(appData, name, "Config"),
+    cache: path10.join(localAppData, name, "Cache"),
+    log: path10.join(localAppData, name, "Log"),
+    temp: path10.join(tmpdir, name)
   };
 };
 var linux = (name) => {
-  const username = path9.basename(homedir);
+  const username = path10.basename(homedir);
   return {
-    data: path9.join(env.XDG_DATA_HOME || path9.join(homedir, ".local", "share"), name),
-    config: path9.join(env.XDG_CONFIG_HOME || path9.join(homedir, ".config"), name),
-    cache: path9.join(env.XDG_CACHE_HOME || path9.join(homedir, ".cache"), name),
-    log: path9.join(env.XDG_STATE_HOME || path9.join(homedir, ".local", "state"), name),
-    temp: path9.join(tmpdir, username, name)
+    data: path10.join(env.XDG_DATA_HOME || path10.join(homedir, ".local", "share"), name),
+    config: path10.join(env.XDG_CONFIG_HOME || path10.join(homedir, ".config"), name),
+    cache: path10.join(env.XDG_CACHE_HOME || path10.join(homedir, ".cache"), name),
+    log: path10.join(env.XDG_STATE_HOME || path10.join(homedir, ".local", "state"), name),
+    temp: path10.join(tmpdir, username, name)
   };
 };
 function envPaths(name, { suffix = "nodejs" } = {}) {
@@ -16034,10 +16152,10 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
 }
 
 // node_modules/atomically/dist/index.js
-import path11 from "node:path";
+import path12 from "node:path";
 
 // node_modules/stubborn-fs/dist/index.js
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import { promisify } from "node:util";
 
 // node_modules/stubborn-utils/dist/attemptify_async.js
@@ -16167,41 +16285,41 @@ var RETRYIFY_OPTIONS = {
 // node_modules/stubborn-fs/dist/index.js
 var FS = {
   attempt: {
-    chmod: attemptify_async_default(promisify(fs8.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    chown: attemptify_async_default(promisify(fs8.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    close: attemptify_async_default(promisify(fs8.close), ATTEMPTIFY_NOOP_OPTIONS),
-    fsync: attemptify_async_default(promisify(fs8.fsync), ATTEMPTIFY_NOOP_OPTIONS),
-    mkdir: attemptify_async_default(promisify(fs8.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
-    realpath: attemptify_async_default(promisify(fs8.realpath), ATTEMPTIFY_NOOP_OPTIONS),
-    stat: attemptify_async_default(promisify(fs8.stat), ATTEMPTIFY_NOOP_OPTIONS),
-    unlink: attemptify_async_default(promisify(fs8.unlink), ATTEMPTIFY_NOOP_OPTIONS),
-    chmodSync: attemptify_sync_default(fs8.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    chownSync: attemptify_sync_default(fs8.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    closeSync: attemptify_sync_default(fs8.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
-    existsSync: attemptify_sync_default(fs8.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
-    fsyncSync: attemptify_sync_default(fs8.fsync, ATTEMPTIFY_NOOP_OPTIONS),
-    mkdirSync: attemptify_sync_default(fs8.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
-    realpathSync: attemptify_sync_default(fs8.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
-    statSync: attemptify_sync_default(fs8.statSync, ATTEMPTIFY_NOOP_OPTIONS),
-    unlinkSync: attemptify_sync_default(fs8.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
+    chmod: attemptify_async_default(promisify(fs9.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chown: attemptify_async_default(promisify(fs9.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    close: attemptify_async_default(promisify(fs9.close), ATTEMPTIFY_NOOP_OPTIONS),
+    fsync: attemptify_async_default(promisify(fs9.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+    mkdir: attemptify_async_default(promisify(fs9.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+    realpath: attemptify_async_default(promisify(fs9.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+    stat: attemptify_async_default(promisify(fs9.stat), ATTEMPTIFY_NOOP_OPTIONS),
+    unlink: attemptify_async_default(promisify(fs9.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+    chmodSync: attemptify_sync_default(fs9.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chownSync: attemptify_sync_default(fs9.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    closeSync: attemptify_sync_default(fs9.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+    existsSync: attemptify_sync_default(fs9.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+    fsyncSync: attemptify_sync_default(fs9.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+    mkdirSync: attemptify_sync_default(fs9.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+    realpathSync: attemptify_sync_default(fs9.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+    statSync: attemptify_sync_default(fs9.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+    unlinkSync: attemptify_sync_default(fs9.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
   },
   retry: {
-    close: retryify_async_default(promisify(fs8.close), RETRYIFY_OPTIONS),
-    fsync: retryify_async_default(promisify(fs8.fsync), RETRYIFY_OPTIONS),
-    open: retryify_async_default(promisify(fs8.open), RETRYIFY_OPTIONS),
-    readFile: retryify_async_default(promisify(fs8.readFile), RETRYIFY_OPTIONS),
-    rename: retryify_async_default(promisify(fs8.rename), RETRYIFY_OPTIONS),
-    stat: retryify_async_default(promisify(fs8.stat), RETRYIFY_OPTIONS),
-    write: retryify_async_default(promisify(fs8.write), RETRYIFY_OPTIONS),
-    writeFile: retryify_async_default(promisify(fs8.writeFile), RETRYIFY_OPTIONS),
-    closeSync: retryify_sync_default(fs8.closeSync, RETRYIFY_OPTIONS),
-    fsyncSync: retryify_sync_default(fs8.fsyncSync, RETRYIFY_OPTIONS),
-    openSync: retryify_sync_default(fs8.openSync, RETRYIFY_OPTIONS),
-    readFileSync: retryify_sync_default(fs8.readFileSync, RETRYIFY_OPTIONS),
-    renameSync: retryify_sync_default(fs8.renameSync, RETRYIFY_OPTIONS),
-    statSync: retryify_sync_default(fs8.statSync, RETRYIFY_OPTIONS),
-    writeSync: retryify_sync_default(fs8.writeSync, RETRYIFY_OPTIONS),
-    writeFileSync: retryify_sync_default(fs8.writeFileSync, RETRYIFY_OPTIONS)
+    close: retryify_async_default(promisify(fs9.close), RETRYIFY_OPTIONS),
+    fsync: retryify_async_default(promisify(fs9.fsync), RETRYIFY_OPTIONS),
+    open: retryify_async_default(promisify(fs9.open), RETRYIFY_OPTIONS),
+    readFile: retryify_async_default(promisify(fs9.readFile), RETRYIFY_OPTIONS),
+    rename: retryify_async_default(promisify(fs9.rename), RETRYIFY_OPTIONS),
+    stat: retryify_async_default(promisify(fs9.stat), RETRYIFY_OPTIONS),
+    write: retryify_async_default(promisify(fs9.write), RETRYIFY_OPTIONS),
+    writeFile: retryify_async_default(promisify(fs9.writeFile), RETRYIFY_OPTIONS),
+    closeSync: retryify_sync_default(fs9.closeSync, RETRYIFY_OPTIONS),
+    fsyncSync: retryify_sync_default(fs9.fsyncSync, RETRYIFY_OPTIONS),
+    openSync: retryify_sync_default(fs9.openSync, RETRYIFY_OPTIONS),
+    readFileSync: retryify_sync_default(fs9.readFileSync, RETRYIFY_OPTIONS),
+    renameSync: retryify_sync_default(fs9.renameSync, RETRYIFY_OPTIONS),
+    statSync: retryify_sync_default(fs9.statSync, RETRYIFY_OPTIONS),
+    writeSync: retryify_sync_default(fs9.writeSync, RETRYIFY_OPTIONS),
+    writeFileSync: retryify_sync_default(fs9.writeFileSync, RETRYIFY_OPTIONS)
   }
 };
 var dist_default = FS;
@@ -16231,7 +16349,7 @@ var isUndefined = (value) => {
 };
 
 // node_modules/atomically/dist/utils/temp.js
-import path10 from "node:path";
+import path11 from "node:path";
 
 // node_modules/when-exit/dist/node/interceptor.js
 import process6 from "node:process";
@@ -16331,7 +16449,7 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename = path10.basename(filePath);
+    const basename = path11.basename(filePath);
     if (basename.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
     const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename);
@@ -16373,7 +16491,7 @@ function writeFileSync2(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
       }
     }
     if (!filePathExists) {
-      const parentPath = path11.dirname(filePath);
+      const parentPath = path12.dirname(filePath);
       dist_default.attempt.mkdirSync(parentPath, {
         mode: DEFAULT_FOLDER_MODE,
         recursive: true
@@ -16689,7 +16807,7 @@ class Conf {
     this.events = new EventTarget;
     this.#encryptionKey = options.encryptionKey;
     const fileExtension = options.fileExtension ? `.${options.fileExtension}` : "";
-    this.path = path12.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
+    this.path = path13.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
     const fileStore = this.store;
     const store = Object.assign(createPlainObject(), options.defaults, fileStore);
     if (options.migrations) {
@@ -16792,7 +16910,7 @@ class Conf {
   }
   get store() {
     try {
-      const data = fs9.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
+      const data = fs10.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
       const dataString = this._encryptData(data);
       const deserializedData = this._deserialize(dataString);
       this._validate(deserializedData);
@@ -16863,7 +16981,7 @@ class Conf {
     throw new Error("Config schema violation: " + errors.join("; "));
   }
   _ensureDirectory() {
-    fs9.mkdirSync(path12.dirname(this.path), { recursive: true });
+    fs10.mkdirSync(path13.dirname(this.path), { recursive: true });
   }
   _write(value) {
     let data = this._serialize(value);
@@ -16874,13 +16992,13 @@ class Conf {
       data = concatUint8Arrays([initializationVector, stringToUint8Array(":"), cipher.update(stringToUint8Array(data)), cipher.final()]);
     }
     if (process7.env.SNAP) {
-      fs9.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+      fs10.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
     } else {
       try {
         writeFileSync2(this.path, data, { mode: this.#options.configFileMode });
       } catch (error) {
         if (error?.code === "EXDEV") {
-          fs9.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+          fs10.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
           return;
         }
         throw error;
@@ -16889,15 +17007,15 @@ class Conf {
   }
   _watch() {
     this._ensureDirectory();
-    if (!fs9.existsSync(this.path)) {
+    if (!fs10.existsSync(this.path)) {
       this._write(createPlainObject());
     }
     if (process7.platform === "win32") {
-      fs9.watch(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs10.watch(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 100 }));
     } else {
-      fs9.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs10.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 5000 }));
     }
@@ -17033,14 +17151,14 @@ function jwtDecode(token, options) {
 }
 
 // lib/cli-config/index.ts
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 import os3 from "node:os";
-import path14 from "node:path";
+import path15 from "node:path";
 
 // lib/shared/handle-registry-auth-error.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import os2 from "node:os";
-import path13 from "node:path";
+import path14 from "node:path";
 var AUTH_TOKEN_REGEX = /^\/\/npm\.tscircuit\.com\/:_authToken=(.+)$/m;
 function isUnauthorizedError(error) {
   const output = [
@@ -17061,9 +17179,9 @@ function isUnauthorizedError(error) {
   return /\b(401|E401)\b/i.test(output) || /unauthorized/i.test(output);
 }
 function hasTsciAuthToken(npmrcPath) {
-  if (!fs10.existsSync(npmrcPath))
+  if (!fs11.existsSync(npmrcPath))
     return false;
-  const content = fs10.readFileSync(npmrcPath, "utf-8");
+  const content = fs11.readFileSync(npmrcPath, "utf-8");
   return AUTH_TOKEN_REGEX.test(content);
 }
 function handleRegistryAuthError({
@@ -17073,8 +17191,8 @@ function handleRegistryAuthError({
   if (!isUnauthorizedError(error))
     return;
   const npmrcPaths = [
-    path13.join(projectDir, ".npmrc"),
-    path13.join(os2.homedir(), ".npmrc")
+    path14.join(projectDir, ".npmrc"),
+    path14.join(os2.homedir(), ".npmrc")
   ];
   const hasToken = npmrcPaths.some(hasTsciAuthToken);
   if (hasToken) {
@@ -17097,13 +17215,13 @@ var getSessionToken = () => {
 };
 var getSessionTokenFromNpmrc = () => {
   const npmrcPaths = [
-    path14.join(process.cwd(), ".npmrc"),
-    path14.join(os3.homedir(), ".npmrc")
+    path15.join(process.cwd(), ".npmrc"),
+    path15.join(os3.homedir(), ".npmrc")
   ];
   for (const npmrcPath of npmrcPaths) {
-    if (!fs11.existsSync(npmrcPath))
+    if (!fs12.existsSync(npmrcPath))
       continue;
-    const content = fs11.readFileSync(npmrcPath, "utf-8");
+    const content = fs12.readFileSync(npmrcPath, "utf-8");
     const match = content.match(AUTH_TOKEN_REGEX);
     if (match?.[1]) {
       return match[1].trim();
@@ -17141,7 +17259,7 @@ var getCircuitJsonToGltfOptions = ({
 };
 
 // cli/build/convert-model-urls-to-file-urls.ts
-import path15 from "node:path";
+import path16 from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 var convertModelUrlsToFileUrls = (circuitJson) => {
   const modelUrlKeys2 = [
@@ -17168,7 +17286,7 @@ var convertModelUrlsToFileUrls = (circuitJson) => {
         if (value.startsWith("/") || value.match(/^[a-zA-Z]:\\/)) {
           updated[key] = pathToFileURL3(value).href;
         } else if (value.startsWith(".")) {
-          updated[key] = pathToFileURL3(path15.resolve(process.cwd(), value)).href;
+          updated[key] = pathToFileURL3(path16.resolve(process.cwd(), value)).href;
         }
       }
     }
@@ -17209,12 +17327,12 @@ var writeSimulationSvgAssetsFromCircuitJson = (circuitJson, outputDir, imageForm
   for (const simulationSvgAsset of simulationSvgAssets) {
     if (imageFormats.simulationSvgs) {
       const fileName = hasMultipleSimulations ? `simulation-${simulationSvgAsset.fileNameSuffix}.svg` : "simulation.svg";
-      fs12.writeFileSync(path16.join(outputDir, fileName), simulationSvgAsset.simulationSvg, "utf-8");
+      fs13.writeFileSync(path17.join(outputDir, fileName), simulationSvgAsset.simulationSvg, "utf-8");
       simulationFileNames.push(fileName);
     }
     if (imageFormats.simulationSchematicSvgs) {
       const fileName = hasMultipleSimulations ? `simulation-schematic-${simulationSvgAsset.fileNameSuffix}.svg` : "simulation-schematic.svg";
-      fs12.writeFileSync(path16.join(outputDir, fileName), simulationSvgAsset.schematicSimulationSvg, "utf-8");
+      fs13.writeFileSync(path17.join(outputDir, fileName), simulationSvgAsset.schematicSimulationSvg, "utf-8");
       schematicSimulationFileNames.push(fileName);
     }
   }
@@ -17224,8 +17342,8 @@ var writeGlbFromCircuitJson = async (circuitJson, glbOutputPath) => {
   const circuitJsonWithFileUrls = convertModelUrlsToFileUrls(circuitJson);
   const glbBuffer = await convertCircuitJsonToGltf(circuitJsonWithFileUrls, getCircuitJsonToGltfOptions({ format: "glb" }));
   const glbData = normalizeToUint8Array2(glbBuffer);
-  fs12.mkdirSync(path16.dirname(glbOutputPath), { recursive: true });
-  fs12.writeFileSync(glbOutputPath, Buffer.from(glbData));
+  fs13.mkdirSync(path17.dirname(glbOutputPath), { recursive: true });
+  fs13.writeFileSync(glbOutputPath, Buffer.from(glbData));
 };
 var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
   const stepContent = await circuitJsonToStep(circuitJson, {
@@ -17233,38 +17351,38 @@ var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
     includeExternalMeshes: true,
     fsMap: await loadLocalStepModelFsMap(circuitJson)
   });
-  fs12.mkdirSync(path16.dirname(stepOutputPath), { recursive: true });
-  fs12.writeFileSync(stepOutputPath, stepContent);
+  fs13.mkdirSync(path17.dirname(stepOutputPath), { recursive: true });
+  fs13.writeFileSync(stepOutputPath, stepContent);
 };
 var writeImageAssetsFromCircuitJson = async (circuitJson, options) => {
   const { outputDir, imageFormats, pcbSnapshotSettings } = options;
-  fs12.mkdirSync(outputDir, { recursive: true });
+  fs13.mkdirSync(outputDir, { recursive: true });
   if (imageFormats.pcbSvgs) {
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson, pcbSnapshotSettings);
-    fs12.writeFileSync(path16.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
+    fs13.writeFileSync(path17.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
   }
   if (imageFormats.pcbPngs) {
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson, pcbSnapshotSettings);
-    fs12.writeFileSync(path16.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
+    fs13.writeFileSync(path17.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
   }
   if (imageFormats.schematicSvgs) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs12.writeFileSync(path16.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
+    fs13.writeFileSync(path17.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
   }
   if (imageFormats.schematicPngs) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs12.writeFileSync(path16.join(outputDir, "schematic.png"), await convertSvgToPngBuffer(schematicSvg));
+    fs13.writeFileSync(path17.join(outputDir, "schematic.png"), await convertSvgToPngBuffer(schematicSvg));
   }
   writeSimulationSvgAssetsFromCircuitJson(circuitJson, outputDir, imageFormats);
   if (imageFormats.threeDPngs) {
     const pngBuffer = await renderCircuitJsonTo3dPng(circuitJson);
-    fs12.writeFileSync(path16.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
+    fs13.writeFileSync(path17.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
   }
 };
 
 // cli/build/worker-build-handlers.ts
 var loadCircuitJsonFromInputFile = (filePath) => {
-  const parsed = JSON.parse(fs13.readFileSync(filePath, "utf-8"));
+  const parsed = JSON.parse(fs14.readFileSync(filePath, "utf-8"));
   return Array.isArray(parsed) ? parsed : [];
 };
 var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath, previewOutputDir, projectDir, options, workerLog, workerStatus) => {
@@ -17273,7 +17391,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
   const startedAt = options?.profile ? performance.now() : 0;
   try {
     process.chdir(projectDir);
-    workerLog(`Generating circuit JSON for ${path17.relative(projectDir, filePath)}...`);
+    workerLog(`Generating circuit JSON for ${path18.relative(projectDir, filePath)}...`);
     await registerStaticAssetLoaders();
     const projectConfig = await loadRuntimeProjectConfig(projectDir);
     const platformConfig = mergePlatformConfigs(projectConfig?.platformConfig, options?.platformConfig);
@@ -17288,13 +17406,17 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
         ...options.autorouterDiagnostics,
         log: (message) => workerLog(message)
       } : undefined,
+      solverDiagnostics: options?.solverDiagnostics ? {
+        ...options.solverDiagnostics,
+        log: (message) => workerLog(message)
+      } : undefined,
       onAsyncEffectStatus: (asyncEffectName) => {
         workerStatus(`waiting on ${asyncEffectName}…`);
       }
     })).circuitJson;
-    fs13.mkdirSync(path17.dirname(outputPath), { recursive: true });
-    fs13.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
-    workerLog(`Circuit JSON written to ${path17.relative(projectDir, outputPath)}`);
+    fs14.mkdirSync(path18.dirname(outputPath), { recursive: true });
+    fs14.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    workerLog(`Circuit JSON written to ${path18.relative(projectDir, outputPath)}`);
     const diagnostics = analyzeCircuitJson(circuitJson);
     const filteredDiagnostics = filterDiagnosticsByDrcCategory({
       errors: diagnostics.errors,
@@ -17324,7 +17446,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     let previewError;
     if (glbOutputPath) {
       try {
-        workerLog(`Converting ${path17.relative(projectDir, outputPath)} to GLB in same worker...`);
+        workerLog(`Converting ${path18.relative(projectDir, outputPath)} to GLB in same worker...`);
         await writeGlbFromCircuitJson(circuitJson, glbOutputPath);
         glbOk = true;
       } catch (err) {
@@ -17335,7 +17457,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (stepOutputPath) {
       try {
-        workerLog(`Converting ${path17.relative(projectDir, outputPath)} to STEP in same worker...`);
+        workerLog(`Converting ${path18.relative(projectDir, outputPath)} to STEP in same worker...`);
         await writeStepFromCircuitJson(circuitJson, stepOutputPath);
         stepOk = true;
       } catch (err) {
@@ -17346,8 +17468,8 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (options?.generatePreviewAssets) {
       try {
-        const resolvedPreviewOutputDir = previewOutputDir ?? path17.dirname(outputPath);
-        workerLog(`Generating preview assets for ${path17.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
+        const resolvedPreviewOutputDir = previewOutputDir ?? path18.dirname(outputPath);
+        workerLog(`Generating preview assets for ${path18.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
         await writeImageAssetsFromCircuitJson(circuitJson, {
           outputDir: resolvedPreviewOutputDir,
           imageFormats: options?.imageFormats ?? DEFAULT_IMAGE_FORMAT_SELECTION,