@tscircuit/cli 0.1.1797 → 0.1.1798

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

@@ -2485,8 +2485,8 @@ export default {
 import { parentPort } from "node:worker_threads";
 
 // lib/shared/process-snapshot-file.ts
-import fs8 from "node:fs";
-import path7 from "node:path";
+import fs9 from "node:fs";
+import path8 from "node:path";
 
 // node_modules/circuit-json-to-3d-png/dist/index.js
 function normalizeDir(dir) {
@@ -2908,8 +2908,8 @@ var readCurrentCircuitJsonBuild = ({
 };
 
 // lib/shared/generate-circuit-json.tsx
-import fs5 from "node:fs";
-import path5 from "node:path";
+import fs6 from "node:fs";
+import path6 from "node:path";
 import { pathToFileURL } from "node:url";
 import Debug from "debug";
 
@@ -3615,6 +3615,120 @@ var registerStaticAssetLoaders = (platformConfig) => {
   }
 };
 
+// lib/shared/solver-diagnostics.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+var escapeJsonPointerSegment = (segment) => segment.replaceAll("~", "~0").replaceAll("/", "~1");
+var cloneAsJson = (value, ancestors = new WeakMap, path6 = "#") => {
+  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, path6);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((item, index) => cloneAsJson(item, ancestors, `${path6}/${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, `${path6}/entries/${index}/0`),
+          cloneAsJson(item, ancestors, `${path6}/entries/${index}/1`)
+        ])
+      };
+    }
+    if (value instanceof Set) {
+      return {
+        value_type: "set",
+        values: Array.from(value.values(), (item, index) => cloneAsJson(item, ancestors, `${path6}/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, `${path6}/${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;
+    fs5.mkdirSync(path5.dirname(this.options.outputPath), { recursive: true });
+    fs5.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");
@@ -3642,6 +3756,7 @@ async function generateCircuitJson({
   injectedProps,
   onAsyncEffectStatus,
   autorouterDiagnostics: autorouterDiagnosticsOptions,
+  solverDiagnostics: solverDiagnosticsOptions,
   sourceFilesystemMd5Hash
 }) {
   debug(`Generating circuit JSON for ${filePath}`);
@@ -3655,12 +3770,14 @@ async function generateCircuitJson({
   });
   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 solverDiagnostics = solverDiagnosticsOptions ? new SolverDiagnostics(solverDiagnosticsOptions) : null;
+  solverDiagnostics?.attachToRootCircuit(runner);
+  const absoluteFilePath = path6.isAbsolute(filePath) ? filePath : path6.resolve(process.cwd(), filePath);
+  const projectDir = path6.dirname(absoluteFilePath);
   const resolvedOutputDir = outputDir ?? projectDir;
-  const relativeComponentPath = path5.relative(projectDir, absoluteFilePath);
-  const baseFileName = outputFileName || path5.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path5.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  const relativeComponentPath = path6.relative(projectDir, absoluteFilePath);
+  const baseFileName = outputFileName || path6.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path6.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
   debug(`Project directory: ${projectDir}`);
   debug(`Relative component path: ${relativeComponentPath}`);
   debug(`Output path: ${outputPath}`);
@@ -3680,7 +3797,7 @@ async function generateCircuitJson({
           return false;
         if (normalizedFilePath.match(/^\.[^/]/))
           return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path5.extname(normalizedFilePath)))
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path6.extname(normalizedFilePath)))
           return false;
         return true;
       },
@@ -3712,11 +3829,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}`);
-    fs5.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    fs6.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
   }
   return {
     circuitJson,
@@ -3751,28 +3869,28 @@ var getOrGenerateCircuitJson = async (options) => {
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
 import { createHash as createHash2 } from "node:crypto";
-import fs6 from "node:fs";
-import path6 from "node:path";
+import fs7 from "node:fs";
+import path7 from "node:path";
 import { getPlatformConfig } from "@tscircuit/eval/platform-config";
-function createLocalCacheEngine(cacheDir = path6.join(process.cwd(), ".tscircuit", "cache")) {
+function createLocalCacheEngine(cacheDir = path7.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 = path6.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        return fs6.readFileSync(filePath, "utf-8");
+        const filePath = path7.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        return fs7.readFileSync(filePath, "utf-8");
       } catch {
         return null;
       }
     },
     setItem: (key, value) => {
       try {
-        fs6.mkdirSync(cacheDir, { recursive: true });
+        fs7.mkdirSync(cacheDir, { recursive: true });
         const hash = createHash2("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path6.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        fs6.writeFileSync(filePath, value);
+        const filePath = path7.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        fs7.writeFileSync(filePath, value);
       } catch {}
     }
   };
@@ -3788,15 +3906,15 @@ function getPlatformConfigWithCliDefaults(userConfig) {
         loadFromUrl: async (url) => {
           let fetchUrl = url;
           if (url.startsWith("./") || url.startsWith("../")) {
-            const absolutePath = path6.resolve(process.cwd(), url);
+            const absolutePath = path7.resolve(process.cwd(), url);
             fetchUrl = `file://${absolutePath}`;
           } else if (url.startsWith("/")) {
-            if (fs6.existsSync(url)) {
+            if (fs7.existsSync(url)) {
               fetchUrl = `file://${url}`;
             } else {
               const relativePath = `.${url}`;
-              const absolutePath = path6.resolve(process.cwd(), relativePath);
-              if (fs6.existsSync(absolutePath)) {
+              const absolutePath = path7.resolve(process.cwd(), relativePath);
+              if (fs7.existsSync(absolutePath)) {
                 fetchUrl = `file://${absolutePath}`;
               } else {
                 fetchUrl = `file://${url}`;
@@ -3895,7 +4013,7 @@ var getSimulationSvgAssetsFromCircuitJson = (circuitJson) => {
 
 // lib/shared/compare-images.ts
 import looksSame from "@tscircuit/image-utils/looks-same";
-import fs7 from "node:fs/promises";
+import fs8 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true) => {
   const b1 = Buffer.from(buffer1);
   const b2 = Buffer.from(buffer2);
@@ -3911,9 +4029,9 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath, createDiff = true)
         highlightColor: "#ff00ff",
         tolerance: 2
       });
-      await fs7.writeFile(diffPath, diffBuffer);
+      await fs8.writeFile(diffPath, diffBuffer);
     } else {
-      await fs7.writeFile(diffPath, buffer2);
+      await fs8.writeFile(diffPath, buffer2);
     }
   }
   return { equal };
@@ -3942,7 +4060,7 @@ var processSnapshotFile = async ({
   cameraPreset,
   pcbLayer
 }) => {
-  const relativeFilePath = path7.relative(projectDir, file);
+  const relativeFilePath = path8.relative(projectDir, file);
   const successPaths = [];
   const warningMessages = [];
   const mismatches = [];
@@ -3953,7 +4071,7 @@ var processSnapshotFile = async ({
   let simulationSvgAssets = [];
   try {
     if (isCircuitJsonFile(file)) {
-      const parsed = JSON.parse(fs8.readFileSync(file, "utf-8"));
+      const parsed = JSON.parse(fs9.readFileSync(file, "utf-8"));
       circuitJson = Array.isArray(parsed) ? parsed : [];
     } else {
       const platformConfigWithCliDefaults = getPlatformConfigWithCliDefaults(platformConfig);
@@ -4037,12 +4155,12 @@ var processSnapshotFile = async ({
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("No pcb_board found in circuit JSON")) {
-        const fileDir = path7.dirname(file);
-        const relativeDir = path7.relative(projectDir, fileDir);
-        const snapDir2 = snapshotsDirName ? path7.join(projectDir, snapshotsDirName, relativeDir) : path7.join(fileDir, "__snapshots__");
-        const base2 = path7.basename(file).replace(/\.[^.]+$/, "");
-        const snap3dPath = path7.join(snapDir2, `${base2}-3d.snap.png`);
-        const existing3dSnapshot = fs8.existsSync(snap3dPath);
+        const fileDir = path8.dirname(file);
+        const relativeDir = path8.relative(projectDir, fileDir);
+        const snapDir2 = snapshotsDirName ? path8.join(projectDir, snapshotsDirName, relativeDir) : path8.join(fileDir, "__snapshots__");
+        const base2 = path8.basename(file).replace(/\.[^.]+$/, "");
+        const snap3dPath = path8.join(snapDir2, `${base2}-3d.snap.png`);
+        const existing3dSnapshot = fs9.existsSync(snap3dPath);
         if (existing3dSnapshot) {
           return {
             ok: false,
@@ -4053,7 +4171,7 @@ var processSnapshotFile = async ({
             errorMessage: kleur_default.red(`
 ❌ Failed to generate 3D snapshot for ${relativeFilePath}:
 `) + kleur_default.red(`   No pcb_board found in circuit JSON
-`) + kleur_default.red(`   Existing snapshot: ${path7.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path8.relative(projectDir, snap3dPath)}
 `)
           };
         }
@@ -4074,9 +4192,9 @@ var processSnapshotFile = async ({
       }
     }
   }
-  const snapDir = snapshotsDirName ? path7.join(projectDir, snapshotsDirName, path7.relative(projectDir, path7.dirname(file))) : path7.join(path7.dirname(file), "__snapshots__");
-  fs8.mkdirSync(snapDir, { recursive: true });
-  const base = path7.basename(file).replace(/\.[^.]+$/, "");
+  const snapDir = snapshotsDirName ? path8.join(projectDir, snapshotsDirName, path8.relative(projectDir, path8.dirname(file))) : path8.join(path8.dirname(file), "__snapshots__");
+  fs9.mkdirSync(snapDir, { recursive: true });
+  const base = path8.basename(file).replace(/\.[^.]+$/, "");
   const snapshots = [];
   if (!simulationOnly && (pcbOnly || !schematicOnly)) {
     let pcbSnapshotType = "pcb";
@@ -4115,17 +4233,17 @@ var processSnapshotFile = async ({
   for (const snapshot of snapshots) {
     const { type } = snapshot;
     const is3d = type === "3d";
-    const snapPath = path7.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-    const existing = fs8.existsSync(snapPath);
+    const snapPath = path8.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+    const existing = fs9.existsSync(snapPath);
     const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
     const newContentForFile = snapshot.content;
     if (!existing) {
-      fs8.writeFileSync(snapPath, newContentForFile);
-      successPaths.push(path7.relative(projectDir, snapPath));
+      fs9.writeFileSync(snapPath, newContentForFile);
+      successPaths.push(path8.relative(projectDir, snapPath));
       didUpdate = true;
       continue;
     }
-    const oldContentBuffer = fs8.readFileSync(snapPath);
+    const oldContentBuffer = fs9.readFileSync(snapPath);
     let equal;
     let diffPath;
     if (createDiff) {
@@ -4137,16 +4255,16 @@ var processSnapshotFile = async ({
     }
     if (update) {
       if (!forceUpdate && equal) {
-        successPaths.push(path7.relative(projectDir, snapPath));
+        successPaths.push(path8.relative(projectDir, snapPath));
       } else {
-        fs8.writeFileSync(snapPath, newContentForFile);
-        successPaths.push(path7.relative(projectDir, snapPath));
+        fs9.writeFileSync(snapPath, newContentForFile);
+        successPaths.push(path8.relative(projectDir, snapPath));
         didUpdate = true;
       }
     } else if (!equal) {
       mismatches.push(diffPath ? `${snapPath} (diff: ${diffPath})` : snapPath);
     } else {
-      successPaths.push(path7.relative(projectDir, snapPath));
+      successPaths.push(path8.relative(projectDir, snapPath));
     }
   }
   return {
@@ -4159,8 +4277,8 @@ var processSnapshotFile = async ({
 };
 
 // lib/project-config/index.ts
-import * as fs9 from "node:fs";
-import * as path8 from "node:path";
+import * as fs10 from "node:fs";
+import * as path9 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // lib/project-config/project-config-schema.ts
@@ -4240,10 +4358,10 @@ var stripWrappingQuotes = (value) => {
 var loadProjectEnv = (projectDir) => {
   const initialEnvKeys = new Set(Object.keys(process.env));
   for (const envFileName of ENV_FILENAMES) {
-    const envPath = path8.join(projectDir, envFileName);
-    if (!fs9.existsSync(envPath))
+    const envPath = path9.join(projectDir, envFileName);
+    if (!fs10.existsSync(envPath))
       continue;
-    const envContent = fs9.readFileSync(envPath, "utf8");
+    const envContent = fs10.readFileSync(envPath, "utf8");
     for (const rawLine of envContent.split(/\r?\n/)) {
       const line = rawLine.trim();
       if (!line || line.startsWith("#"))
@@ -4261,12 +4379,12 @@ var loadProjectEnv = (projectDir) => {
   }
 };
 var loadProjectConfigSync = (projectDir = process.cwd()) => {
-  const configPath = path8.join(projectDir, CONFIG_FILENAME);
-  if (!fs9.existsSync(configPath)) {
+  const configPath = path9.join(projectDir, CONFIG_FILENAME);
+  if (!fs10.existsSync(configPath)) {
     return null;
   }
   try {
-    const configContent = fs9.readFileSync(configPath, "utf8");
+    const configContent = fs10.readFileSync(configPath, "utf8");
     const parsedConfig = JSON.parse(configContent);
     return projectConfigSchema.parse(parsedConfig);
   } catch (error) {
@@ -4277,12 +4395,12 @@ var loadProjectConfigSync = (projectDir = process.cwd()) => {
 var loadProjectConfigModule = async (projectDir) => {
   loadProjectEnv(projectDir);
   for (const configFileName of CONFIG_MODULE_FILENAMES) {
-    const configPath = path8.join(projectDir, configFileName);
-    if (!fs9.existsSync(configPath))
+    const configPath = path9.join(projectDir, configFileName);
+    if (!fs10.existsSync(configPath))
       continue;
     try {
       const moduleUrl = pathToFileURL2(configPath);
-      const stat = fs9.statSync(configPath);
+      const stat = fs10.statSync(configPath);
       moduleUrl.searchParams.set("tsci", String(stat.mtimeMs));
       const importedModule = await import(moduleUrl.href);
       const exportedConfig = importedModule.default ?? importedModule.config ?? importedModule;
@@ -4329,13 +4447,13 @@ var getSnapshotsDir = (projectDir = process.cwd()) => {
   return config?.snapshotsDir;
 };
 var saveProjectConfig = (config, projectDir = process.cwd()) => {
-  const configPath = path8.join(projectDir, CONFIG_FILENAME);
+  const configPath = path9.join(projectDir, CONFIG_FILENAME);
   try {
     const configWithSchema = {
       $schema: CONFIG_SCHEMA_URL,
       ...config ?? {}
     };
-    fs9.writeFileSync(configPath, JSON.stringify(configWithSchema, null, 2));
+    fs10.writeFileSync(configPath, JSON.stringify(configWithSchema, null, 2));
     return true;
   } catch (error) {
     console.error(`Error saving tscircuit config: ${error}`);

package/dist/lib/index.js

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

package/package.json

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