@tscircuit/cli 0.1.2178 → 0.1.2180

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

@@ -12492,8 +12492,8 @@ var require_semver2 = __commonJS(function(exports, module) {
 import { parentPort } from "node:worker_threads";
 
 // cli/build/worker-build-handlers.ts
-import fs14 from "node:fs";
-import path18 from "node:path";
+import fs15 from "node:fs";
+import path19 from "node:path";
 
 // lib/project-config/index.ts
 import * as fs from "node:fs";
@@ -12727,8 +12727,8 @@ function formatCircuitJsonDiagnostics({
 }
 
 // lib/shared/generate-circuit-json.tsx
-import fs7 from "node:fs";
-import path7 from "node:path";
+import fs8 from "node:fs";
+import path8 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import Debug from "debug";
 
@@ -13479,14 +13479,55 @@ class AutorouterDiagnostics {
   }
 }
 
-// lib/shared/importFromUserLand.ts
-import { createRequire as createRequire2 } from "node:module";
+// lib/shared/autorouting-artifacts.ts
 import fs3 from "node:fs";
 import path3 from "node:path";
+import { createHash } from "node:crypto";
+function attachAutoroutingArtifacts(root, filePath, projectDir = process.cwd()) {
+  const entryPath = path3.relative(projectDir, path3.resolve(projectDir, filePath));
+  const entryKey = `${path3.basename(filePath).replace(/[^a-zA-Z0-9_-]/g, "-")}-${createHash("sha256").update(entryPath).digest("hex").slice(0, 10)}`;
+  const directory = path3.resolve(projectDir, ".tscircuit", "autorouting-artifacts", entryKey);
+  let warnedUnsupportedVersion = false;
+  root.on("autorouting:end", (event) => {
+    try {
+      if (event.pcbTracePathsUnavailableReason) {
+        throw new Error(event.pcbTracePathsUnavailableReason);
+      }
+      if (event.pcbTracePaths === undefined || event._actualRoutingPhaseOrderIndex === undefined) {
+        if (!warnedUnsupportedVersion) {
+          console.warn("Autorouting paths were not provided by this router. Use local routing and update your project's tscircuit package to save replayable JSON.");
+          warnedUnsupportedVersion = true;
+        }
+        return;
+      }
+      if (event.pcbTracePaths.length === 0)
+        return;
+      const phase = event.routingPhaseIndex ?? "default";
+      const order = event._actualRoutingPhaseOrderIndex;
+      const safeSubcircuit = event.subcircuit_id.replace(/[^a-zA-Z0-9_-]/g, "-");
+      const stage = event.phaseStageIndex === undefined ? "" : `-stage-${event.phaseStageIndex}`;
+      const outputPath = path3.join(directory, `${safeSubcircuit}-phase-${phase}-order-${order}${stage}.pcb-trace-paths.json`);
+      const contents = `${JSON.stringify(event.pcbTracePaths, null, 2)}
+`;
+      fs3.mkdirSync(directory, { recursive: true });
+      if (!fs3.existsSync(outputPath) || fs3.readFileSync(outputPath, "utf8") !== contents) {
+        fs3.writeFileSync(outputPath, contents);
+      }
+      console.log(`Saved autorouting paths to ${path3.relative(projectDir, outputPath)} (import this JSON into <autoroutingphase pcbTracePaths={...} />).`);
+    } catch (error) {
+      console.warn(`Could not save autorouting paths for ${event.subcircuit_id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+}
+
+// lib/shared/importFromUserLand.ts
+import { createRequire as createRequire2 } from "node:module";
+import fs4 from "node:fs";
+import path4 from "node:path";
 async function importFromUserLand(moduleName, projectDir = process.cwd()) {
-  const userModulePath = path3.join(projectDir, "node_modules", moduleName);
-  if (fs3.existsSync(userModulePath)) {
-    const userRequire = createRequire2(path3.join(projectDir, "noop.js"));
+  const userModulePath = path4.join(projectDir, "node_modules", moduleName);
+  if (fs4.existsSync(userModulePath)) {
+    const userRequire = createRequire2(path4.join(projectDir, "noop.js"));
     try {
       const resolvedUserPath = userRequire.resolve(moduleName);
       return await import(resolvedUserPath);
@@ -13509,8 +13550,8 @@ async function importFromUserLand(moduleName, projectDir = process.cwd()) {
 }
 
 // lib/shared/register-static-asset-loaders.ts
-import fs4 from "node:fs";
-import path4 from "node:path";
+import fs5 from "node:fs";
+import path5 from "node:path";
 var STATIC_ASSET_EXTENSIONS = [
   ".glb",
   ".gltf",
@@ -13537,15 +13578,15 @@ var TEXT_STATIC_ASSET_EXTENSIONS = new Set([
   ".kicad_sym"
 ]);
 var readFileContentForStaticLoader = (filePath) => {
-  const ext = path4.extname(filePath).toLowerCase();
+  const ext = path5.extname(filePath).toLowerCase();
   if (TEXT_STATIC_ASSET_EXTENSIONS.has(ext)) {
-    return fs4.readFileSync(filePath, "utf-8");
+    return fs5.readFileSync(filePath, "utf-8");
   }
-  const buffer = fs4.readFileSync(filePath);
+  const buffer = fs5.readFileSync(filePath);
   return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
 };
 var getStaticFileLoader = (filePath) => {
-  const extWithDot = path4.extname(filePath).toLowerCase();
+  const extWithDot = path5.extname(filePath).toLowerCase();
   const ext = extWithDot.replace(/^\./, "");
   return activePlatformConfig?.staticFileLoaderMap?.[ext] ?? activePlatformConfig?.staticFileLoaderMap?.[extWithDot];
 };
@@ -13559,12 +13600,12 @@ var normalizeStaticFileLoaderResult = (result) => {
   };
 };
 var getBaseUrlFromTsConfig = (projectDir) => {
-  const tsconfigPath = path4.join(projectDir, "tsconfig.json");
+  const tsconfigPath = path5.join(projectDir, "tsconfig.json");
   try {
-    if (!fs4.existsSync(tsconfigPath)) {
+    if (!fs5.existsSync(tsconfigPath)) {
       return null;
     }
-    const tsconfigContent = fs4.readFileSync(tsconfigPath, "utf-8");
+    const tsconfigContent = fs5.readFileSync(tsconfigPath, "utf-8");
     const tsconfig = JSON.parse(tsconfigContent);
     if (tsconfig.compilerOptions?.baseUrl) {
       return tsconfig.compilerOptions.baseUrl;
@@ -13591,8 +13632,8 @@ var registerStaticAssetLoaders = (platformConfig, projectDir = process.cwd()) =>
               loader: "object"
             };
           }
-          const baseDir = baseUrl ? path4.resolve(projectDir, baseUrl) : projectDir;
-          const relativePath = path4.relative(baseDir, args.path).split(path4.sep).join("/");
+          const baseDir = baseUrl ? path5.resolve(projectDir, baseUrl) : projectDir;
+          const relativePath = path5.relative(baseDir, args.path).split(path5.sep).join("/");
           const pathStr = `./${relativePath}`;
           return {
             exports: {
@@ -13608,9 +13649,9 @@ var registerStaticAssetLoaders = (platformConfig, projectDir = process.cwd()) =>
 };
 
 // lib/shared/circuit-json-build-cache.ts
-import fs5 from "node:fs";
-import path5 from "node:path";
-import { createHash } from "node:crypto";
+import fs6 from "node:fs";
+import path6 from "node:path";
+import { createHash as createHash2 } from "node:crypto";
 var SOURCE_FILE_EXTENSIONS = new Set([
   ".tsx",
   ".ts",
@@ -13633,43 +13674,43 @@ var IGNORED_DIRECTORY_NAMES = new Set([
   ".git"
 ]);
 var isPathInside = (childPath, parentPath) => {
-  const relative = path5.relative(parentPath, childPath);
-  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+  const relative = path6.relative(parentPath, childPath);
+  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
 };
 var findCircuitProjectDir = (filePath) => {
-  const absoluteFilePath = path5.resolve(filePath);
-  let currentDir = path5.dirname(absoluteFilePath);
+  const absoluteFilePath = path6.resolve(filePath);
+  let currentDir = path6.dirname(absoluteFilePath);
   while (true) {
-    if (fs5.existsSync(path5.join(currentDir, "package.json"))) {
+    if (fs6.existsSync(path6.join(currentDir, "package.json"))) {
       return currentDir;
     }
-    const parentDir = path5.dirname(currentDir);
+    const parentDir = path6.dirname(currentDir);
     if (parentDir === currentDir)
       break;
     currentDir = parentDir;
   }
-  const cwd = path5.resolve(process.cwd());
-  return isPathInside(absoluteFilePath, cwd) ? cwd : path5.dirname(absoluteFilePath);
+  const cwd = path6.resolve(process.cwd());
+  return isPathInside(absoluteFilePath, cwd) ? cwd : path6.dirname(absoluteFilePath);
 };
 var getCircuitJsonOutputDirName = (relativePath) => {
   const normalizedRelativePath = relativePath.toLowerCase().replaceAll("\\", "/");
   if (normalizedRelativePath === "circuit.json" || normalizedRelativePath.endsWith("/circuit.json")) {
-    return path5.dirname(relativePath);
+    return path6.dirname(relativePath);
   }
   return relativePath.replace(/(\.board|\.circuit)?\.tsx$/, "").replace(/\.circuit\.json$/, "");
 };
 var getCircuitJsonBuildOutputPath = (filePath) => {
-  const absoluteFilePath = path5.resolve(filePath);
+  const absoluteFilePath = path6.resolve(filePath);
   const projectDir = findCircuitProjectDir(absoluteFilePath);
-  const relativePath = path5.relative(projectDir, absoluteFilePath);
-  return path5.join(projectDir, "dist", getCircuitJsonOutputDirName(relativePath), "circuit.json");
+  const relativePath = path6.relative(projectDir, absoluteFilePath);
+  return path6.join(projectDir, "dist", getCircuitJsonOutputDirName(relativePath), "circuit.json");
 };
 var getSourceFilePaths = (projectDir) => {
   const sourceFilePaths = [];
   const visit = (directoryPath) => {
-    const entries = fs5.readdirSync(directoryPath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    const entries = fs6.readdirSync(directoryPath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const entryPath = path5.join(directoryPath, entry.name);
+      const entryPath = path6.join(directoryPath, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRECTORY_NAMES.has(entry.name) || entry.name.startsWith(".")) {
           continue;
@@ -13677,7 +13718,7 @@ var getSourceFilePaths = (projectDir) => {
         visit(entryPath);
         continue;
       }
-      if (!entry.isFile() || entry.name.endsWith(".circuit.json") || !SOURCE_FILE_EXTENSIONS.has(path5.extname(entry.name).toLowerCase())) {
+      if (!entry.isFile() || entry.name.endsWith(".circuit.json") || !SOURCE_FILE_EXTENSIONS.has(path6.extname(entry.name).toLowerCase())) {
         continue;
       }
       sourceFilePaths.push(entryPath);
@@ -13688,10 +13729,10 @@ var getSourceFilePaths = (projectDir) => {
 };
 var getSourceFilesystemMd5Hash = (filePath) => {
   const projectDir = findCircuitProjectDir(filePath);
-  const hash = createHash("md5");
+  const hash = createHash2("md5");
   for (const sourceFilePath of getSourceFilePaths(projectDir)) {
-    const relativePath = path5.relative(projectDir, sourceFilePath).split(path5.sep).join("/");
-    const content = fs5.readFileSync(sourceFilePath);
+    const relativePath = path6.relative(projectDir, sourceFilePath).split(path6.sep).join("/");
+    const content = fs6.readFileSync(sourceFilePath);
     hash.update(`${Buffer.byteLength(relativePath)}:`);
     hash.update(relativePath);
     hash.update(`${content.byteLength}:`);
@@ -13726,7 +13767,7 @@ var readCurrentCircuitJsonBuild = ({
 }) => {
   const outputPath = getCircuitJsonBuildOutputPath(filePath);
   try {
-    const parsed = JSON.parse(fs5.readFileSync(outputPath, "utf-8"));
+    const parsed = JSON.parse(fs6.readFileSync(outputPath, "utf-8"));
     if (!Array.isArray(parsed))
       return null;
     const hasCurrentFilesystemHash = parsed.some((element) => element?.type === "source_project_metadata" && element.source_filesystem_md5_hash === sourceFilesystemMd5Hash);
@@ -13740,8 +13781,8 @@ var readCurrentCircuitJsonBuild = ({
 };
 
 // lib/shared/solver-diagnostics.ts
-import fs6 from "node:fs";
-import path6 from "node:path";
+import fs7 from "node:fs";
+import path7 from "node:path";
 var escapeJsonPointerSegment = (segment) => segment.replaceAll("~", "~0").replaceAll("/", "~1");
 var cloneAsJson = (value, ancestors = new WeakMap, path = "#") => {
   if (value === undefined)
@@ -13842,8 +13883,8 @@ class SolverDiagnostics {
   finalize() {
     if (!this.options.enabled)
       return;
-    fs6.mkdirSync(path6.dirname(this.options.outputPath), { recursive: true });
-    fs6.writeFileSync(this.options.outputPath, `${JSON.stringify({
+    fs7.mkdirSync(path7.dirname(this.options.outputPath), { recursive: true });
+    fs7.writeFileSync(this.options.outputPath, `${JSON.stringify({
       format: "tscircuit_solver_debug_v1",
       entrypoint: this.options.entrypoint,
       solvers: this.solverInvocations
@@ -13886,7 +13927,7 @@ async function generateCircuitJson({
 }) {
   debug(`Generating circuit JSON for ${filePath}`);
   const currentSourceFilesystemMd5Hash = sourceFilesystemMd5Hash ?? getSourceFilesystemMd5Hash(filePath);
-  const projectRootDir = path7.resolve(projectDirOption ?? process.cwd());
+  const projectRootDir = path8.resolve(projectDirOption ?? process.cwd());
   const React = await importFromUserLand("react", projectRootDir);
   globalThis.React = React;
   registerStaticAssetLoaders(platformConfig, projectRootDir);
@@ -13898,12 +13939,13 @@ async function generateCircuitJson({
   autorouterDiagnostics.attachToRootCircuit(runner);
   const solverDiagnostics = solverDiagnosticsOptions ? new SolverDiagnostics(solverDiagnosticsOptions) : null;
   solverDiagnostics?.attachToRootCircuit(runner);
-  const absoluteFilePath = path7.isAbsolute(filePath) ? filePath : path7.resolve(projectRootDir, filePath);
-  const sourceDir = path7.dirname(absoluteFilePath);
+  attachAutoroutingArtifacts(runner, filePath, projectRootDir);
+  const absoluteFilePath = path8.isAbsolute(filePath) ? filePath : path8.resolve(projectRootDir, filePath);
+  const sourceDir = path8.dirname(absoluteFilePath);
   const resolvedOutputDir = outputDir ?? sourceDir;
-  const relativeComponentPath = path7.relative(sourceDir, absoluteFilePath);
-  const baseFileName = outputFileName || path7.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path7.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  const relativeComponentPath = path8.relative(sourceDir, absoluteFilePath);
+  const baseFileName = outputFileName || path8.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path8.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
   debug(`Project directory: ${sourceDir}`);
   debug(`Relative component path: ${relativeComponentPath}`);
   debug(`Output path: ${outputPath}`);
@@ -13923,7 +13965,7 @@ async function generateCircuitJson({
           return false;
         if (normalizedFilePath.match(/^\.[^/]/))
           return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path7.extname(normalizedFilePath)))
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path8.extname(normalizedFilePath)))
           return false;
         return true;
       },
@@ -13960,7 +14002,7 @@ async function generateCircuitJson({
   await autorouterDiagnostics.finalize(circuitJson);
   if (saveToFile) {
     debug(`Saving circuit JSON to ${outputPath}`);
-    fs7.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    fs8.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
   }
   return {
     circuitJson,
@@ -13970,9 +14012,9 @@ async function generateCircuitJson({
 }
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
-import { createHash as createHash2 } from "node:crypto";
-import fs8 from "node:fs";
-import path8 from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import fs9 from "node:fs";
+import path9 from "node:path";
 import { getPlatformConfig } from "@tscircuit/eval/platform-config";
 
 // lib/shared/platform-config-utils.ts
@@ -14010,25 +14052,25 @@ var mergePlatformConfigs = (...configs) => {
 };
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
-function createLocalCacheEngine(cacheDir = path8.join(process.cwd(), ".tscircuit", "cache")) {
+function createLocalCacheEngine(cacheDir = path9.join(process.cwd(), ".tscircuit", "cache")) {
   return {
     getItem: (key) => {
       try {
-        const hash = createHash2("md5").update(key).digest("hex");
+        const hash = createHash3("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path8.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        return fs8.readFileSync(filePath, "utf-8");
+        const filePath = path9.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        return fs9.readFileSync(filePath, "utf-8");
       } catch {
         return null;
       }
     },
     setItem: (key, value) => {
       try {
-        fs8.mkdirSync(cacheDir, { recursive: true });
-        const hash = createHash2("md5").update(key).digest("hex");
+        fs9.mkdirSync(cacheDir, { recursive: true });
+        const hash = createHash3("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path8.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        fs8.writeFileSync(filePath, value);
+        const filePath = path9.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        fs9.writeFileSync(filePath, value);
       } catch {}
     }
   };
@@ -14036,7 +14078,7 @@ function createLocalCacheEngine(cacheDir = path8.join(process.cwd(), ".tscircuit
 function getPlatformConfigWithCliDefaults(userConfig, options) {
   const projectDir = options?.projectDir ?? process.cwd();
   const basePlatformConfig = getPlatformConfig();
-  const cacheDir = path8.join(projectDir, ".tscircuit", "cache");
+  const cacheDir = path9.join(projectDir, ".tscircuit", "cache");
   const defaultConfig = {
     ...basePlatformConfig,
     localCacheEngine: createLocalCacheEngine(cacheDir),
@@ -14046,15 +14088,15 @@ function getPlatformConfigWithCliDefaults(userConfig, options) {
         loadFromUrl: async (url) => {
           let fetchUrl = url;
           if (url.startsWith("./") || url.startsWith("../")) {
-            const absolutePath = path8.resolve(projectDir, url);
+            const absolutePath = path9.resolve(projectDir, url);
             fetchUrl = `file://${absolutePath}`;
           } else if (url.startsWith("/")) {
-            if (fs8.existsSync(url)) {
+            if (fs9.existsSync(url)) {
               fetchUrl = `file://${url}`;
             } else {
               const relativePath = `.${url}`;
-              const absolutePath = path8.resolve(projectDir, relativePath);
-              if (fs8.existsSync(absolutePath)) {
+              const absolutePath = path9.resolve(projectDir, relativePath);
+              if (fs9.existsSync(absolutePath)) {
                 fetchUrl = `file://${absolutePath}`;
               } else {
                 fetchUrl = `file://${url}`;
@@ -23882,8 +23924,8 @@ function convertCircuitJsonToPcbSvg3(elements, options = {}) {
 }
 
 // cli/build/worker-output-generators.ts
-import fs13 from "node:fs";
-import path17 from "node:path";
+import fs14 from "node:fs";
+import path18 from "node:path";
 
 // node_modules/circuit-json-to-3d-png/dist/index.js
 function normalizeDir(dir) {
@@ -26363,7 +26405,7 @@ import { convertCircuitJsonToSchematicSvg } from "circuit-to-svg";
 // lib/shared/load-local-step-model-fs-map.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { readFile } from "node:fs/promises";
-import path9 from "node:path";
+import path10 from "node:path";
 var isRemoteUrl = (value) => /^https?:\/\//i.test(value);
 async function loadLocalStepModelFsMap(circuitJson) {
   const fsMap = {};
@@ -26375,7 +26417,7 @@ async function loadLocalStepModelFsMap(circuitJson) {
       continue;
     if (isRemoteUrl(modelUrl) || fsMap[modelUrl])
       continue;
-    const localPath = path9.resolve(process.cwd(), modelUrl);
+    const localPath = path10.resolve(process.cwd(), modelUrl);
     if (!existsSync2(localPath))
       continue;
     fsMap[modelUrl] = await readFile(localPath, "utf-8");
@@ -26451,8 +26493,8 @@ var getSimulationSvgAssetsFromCircuitJson = (circuitJson) => {
 // node_modules/conf/dist/source/index.js
 import { isDeepStrictEqual } from "node:util";
 import process7 from "node:process";
-import fs10 from "node:fs";
-import path13 from "node:path";
+import fs11 from "node:fs";
+import path14 from "node:path";
 import crypto from "node:crypto";
 import assert from "node:assert";
 
@@ -26672,41 +26714,41 @@ function hasProperty(object, path) {
 }
 
 // node_modules/env-paths/index.js
-import path10 from "node:path";
+import path11 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 = path10.join(homedir, "Library");
+  const library = path11.join(homedir, "Library");
   return {
-    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)
+    data: path11.join(library, "Application Support", name),
+    config: path11.join(library, "Preferences", name),
+    cache: path11.join(library, "Caches", name),
+    log: path11.join(library, "Logs", name),
+    temp: path11.join(tmpdir, name)
   };
 };
 var windows = (name) => {
-  const appData = env.APPDATA || path10.join(homedir, "AppData", "Roaming");
-  const localAppData = env.LOCALAPPDATA || path10.join(homedir, "AppData", "Local");
+  const appData = env.APPDATA || path11.join(homedir, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path11.join(homedir, "AppData", "Local");
   return {
-    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)
+    data: path11.join(localAppData, name, "Data"),
+    config: path11.join(appData, name, "Config"),
+    cache: path11.join(localAppData, name, "Cache"),
+    log: path11.join(localAppData, name, "Log"),
+    temp: path11.join(tmpdir, name)
   };
 };
 var linux = (name) => {
-  const username = path10.basename(homedir);
+  const username = path11.basename(homedir);
   return {
-    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)
+    data: path11.join(env.XDG_DATA_HOME || path11.join(homedir, ".local", "share"), name),
+    config: path11.join(env.XDG_CONFIG_HOME || path11.join(homedir, ".config"), name),
+    cache: path11.join(env.XDG_CACHE_HOME || path11.join(homedir, ".cache"), name),
+    log: path11.join(env.XDG_STATE_HOME || path11.join(homedir, ".local", "state"), name),
+    temp: path11.join(tmpdir, username, name)
   };
 };
 function envPaths(name, { suffix = "nodejs" } = {}) {
@@ -26726,10 +26768,10 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
 }
 
 // node_modules/atomically/dist/index.js
-import path12 from "node:path";
+import path13 from "node:path";
 
 // node_modules/stubborn-fs/dist/index.js
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import { promisify } from "node:util";
 
 // node_modules/stubborn-utils/dist/attemptify_async.js
@@ -26859,41 +26901,41 @@ var RETRYIFY_OPTIONS = {
 // node_modules/stubborn-fs/dist/index.js
 var FS = {
   attempt: {
-    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)
+    chmod: attemptify_async_default(promisify(fs10.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chown: attemptify_async_default(promisify(fs10.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    close: attemptify_async_default(promisify(fs10.close), ATTEMPTIFY_NOOP_OPTIONS),
+    fsync: attemptify_async_default(promisify(fs10.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+    mkdir: attemptify_async_default(promisify(fs10.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+    realpath: attemptify_async_default(promisify(fs10.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+    stat: attemptify_async_default(promisify(fs10.stat), ATTEMPTIFY_NOOP_OPTIONS),
+    unlink: attemptify_async_default(promisify(fs10.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+    chmodSync: attemptify_sync_default(fs10.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chownSync: attemptify_sync_default(fs10.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    closeSync: attemptify_sync_default(fs10.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+    existsSync: attemptify_sync_default(fs10.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+    fsyncSync: attemptify_sync_default(fs10.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+    mkdirSync: attemptify_sync_default(fs10.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+    realpathSync: attemptify_sync_default(fs10.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+    statSync: attemptify_sync_default(fs10.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+    unlinkSync: attemptify_sync_default(fs10.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
   },
   retry: {
-    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)
+    close: retryify_async_default(promisify(fs10.close), RETRYIFY_OPTIONS),
+    fsync: retryify_async_default(promisify(fs10.fsync), RETRYIFY_OPTIONS),
+    open: retryify_async_default(promisify(fs10.open), RETRYIFY_OPTIONS),
+    readFile: retryify_async_default(promisify(fs10.readFile), RETRYIFY_OPTIONS),
+    rename: retryify_async_default(promisify(fs10.rename), RETRYIFY_OPTIONS),
+    stat: retryify_async_default(promisify(fs10.stat), RETRYIFY_OPTIONS),
+    write: retryify_async_default(promisify(fs10.write), RETRYIFY_OPTIONS),
+    writeFile: retryify_async_default(promisify(fs10.writeFile), RETRYIFY_OPTIONS),
+    closeSync: retryify_sync_default(fs10.closeSync, RETRYIFY_OPTIONS),
+    fsyncSync: retryify_sync_default(fs10.fsyncSync, RETRYIFY_OPTIONS),
+    openSync: retryify_sync_default(fs10.openSync, RETRYIFY_OPTIONS),
+    readFileSync: retryify_sync_default(fs10.readFileSync, RETRYIFY_OPTIONS),
+    renameSync: retryify_sync_default(fs10.renameSync, RETRYIFY_OPTIONS),
+    statSync: retryify_sync_default(fs10.statSync, RETRYIFY_OPTIONS),
+    writeSync: retryify_sync_default(fs10.writeSync, RETRYIFY_OPTIONS),
+    writeFileSync: retryify_sync_default(fs10.writeFileSync, RETRYIFY_OPTIONS)
   }
 };
 var dist_default = FS;
@@ -26923,7 +26965,7 @@ var isUndefined = (value) => {
 };
 
 // node_modules/atomically/dist/utils/temp.js
-import path11 from "node:path";
+import path12 from "node:path";
 
 // node_modules/when-exit/dist/node/interceptor.js
 import process6 from "node:process";
@@ -27023,7 +27065,7 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename = path11.basename(filePath);
+    const basename = path12.basename(filePath);
     if (basename.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
     const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename);
@@ -27065,7 +27107,7 @@ function writeFileSync2(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
       }
     }
     if (!filePathExists) {
-      const parentPath = path12.dirname(filePath);
+      const parentPath = path13.dirname(filePath);
       dist_default.attempt.mkdirSync(parentPath, {
         mode: DEFAULT_FOLDER_MODE,
         recursive: true
@@ -27381,7 +27423,7 @@ class Conf {
     this.events = new EventTarget;
     this.#encryptionKey = options.encryptionKey;
     const fileExtension = options.fileExtension ? `.${options.fileExtension}` : "";
-    this.path = path13.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
+    this.path = path14.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
     const fileStore = this.store;
     const store = Object.assign(createPlainObject(), options.defaults, fileStore);
     if (options.migrations) {
@@ -27484,7 +27526,7 @@ class Conf {
   }
   get store() {
     try {
-      const data = fs10.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
+      const data = fs11.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
       const dataString = this._encryptData(data);
       const deserializedData = this._deserialize(dataString);
       this._validate(deserializedData);
@@ -27555,7 +27597,7 @@ class Conf {
     throw new Error("Config schema violation: " + errors.join("; "));
   }
   _ensureDirectory() {
-    fs10.mkdirSync(path13.dirname(this.path), { recursive: true });
+    fs11.mkdirSync(path14.dirname(this.path), { recursive: true });
   }
   _write(value) {
     let data = this._serialize(value);
@@ -27566,13 +27608,13 @@ class Conf {
       data = concatUint8Arrays([initializationVector, stringToUint8Array(":"), cipher.update(stringToUint8Array(data)), cipher.final()]);
     }
     if (process7.env.SNAP) {
-      fs10.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+      fs11.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
     } else {
       try {
         writeFileSync2(this.path, data, { mode: this.#options.configFileMode });
       } catch (error) {
         if (error?.code === "EXDEV") {
-          fs10.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+          fs11.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
           return;
         }
         throw error;
@@ -27581,15 +27623,15 @@ class Conf {
   }
   _watch() {
     this._ensureDirectory();
-    if (!fs10.existsSync(this.path)) {
+    if (!fs11.existsSync(this.path)) {
       this._write(createPlainObject());
     }
     if (process7.platform === "win32") {
-      fs10.watch(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs11.watch(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 100 }));
     } else {
-      fs10.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs11.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 5000 }));
     }
@@ -27725,14 +27767,14 @@ function jwtDecode(token, options) {
 }
 
 // lib/cli-config/index.ts
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 import os3 from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 
 // lib/shared/handle-registry-auth-error.ts
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 import os2 from "node:os";
-import path14 from "node:path";
+import path15 from "node:path";
 var AUTH_TOKEN_REGEX = /^\/\/npm\.tscircuit\.com\/:_authToken=(.+)$/m;
 function isUnauthorizedError(error) {
   const output = [
@@ -27753,9 +27795,9 @@ function isUnauthorizedError(error) {
   return /\b(401|E401)\b/i.test(output) || /unauthorized/i.test(output);
 }
 function hasTsciAuthToken(npmrcPath) {
-  if (!fs11.existsSync(npmrcPath))
+  if (!fs12.existsSync(npmrcPath))
     return false;
-  const content = fs11.readFileSync(npmrcPath, "utf-8");
+  const content = fs12.readFileSync(npmrcPath, "utf-8");
   return AUTH_TOKEN_REGEX.test(content);
 }
 function handleRegistryAuthError({
@@ -27765,8 +27807,8 @@ function handleRegistryAuthError({
   if (!isUnauthorizedError(error))
     return;
   const npmrcPaths = [
-    path14.join(projectDir, ".npmrc"),
-    path14.join(os2.homedir(), ".npmrc")
+    path15.join(projectDir, ".npmrc"),
+    path15.join(os2.homedir(), ".npmrc")
   ];
   const hasToken = npmrcPaths.some(hasTsciAuthToken);
   if (hasToken) {
@@ -27789,13 +27831,13 @@ var getSessionToken = () => {
 };
 var getSessionTokenFromNpmrc = () => {
   const npmrcPaths = [
-    path15.join(process.cwd(), ".npmrc"),
-    path15.join(os3.homedir(), ".npmrc")
+    path16.join(process.cwd(), ".npmrc"),
+    path16.join(os3.homedir(), ".npmrc")
   ];
   for (const npmrcPath of npmrcPaths) {
-    if (!fs12.existsSync(npmrcPath))
+    if (!fs13.existsSync(npmrcPath))
       continue;
-    const content = fs12.readFileSync(npmrcPath, "utf-8");
+    const content = fs13.readFileSync(npmrcPath, "utf-8");
     const match = content.match(AUTH_TOKEN_REGEX);
     if (match?.[1]) {
       return match[1].trim();
@@ -27833,7 +27875,7 @@ var getCircuitJsonToGltfOptions = ({
 };
 
 // cli/build/convert-model-urls-to-file-urls.ts
-import path16 from "node:path";
+import path17 from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 var convertModelUrlsToFileUrls = (circuitJson) => {
   const modelUrlKeys = [
@@ -27860,7 +27902,7 @@ var convertModelUrlsToFileUrls = (circuitJson) => {
         if (value.startsWith("/") || value.match(/^[a-zA-Z]:\\/)) {
           updated[key] = pathToFileURL3(value).href;
         } else if (value.startsWith(".")) {
-          updated[key] = pathToFileURL3(path16.resolve(process.cwd(), value)).href;
+          updated[key] = pathToFileURL3(path17.resolve(process.cwd(), value)).href;
         }
       }
     }
@@ -27901,12 +27943,12 @@ var writeSimulationSvgAssetsFromCircuitJson = (circuitJson, outputDir, imageForm
   for (const simulationSvgAsset of simulationSvgAssets) {
     if (imageFormats.simulationSvgs) {
       const fileName = hasMultipleSimulations ? `simulation-${simulationSvgAsset.fileNameSuffix}.svg` : "simulation.svg";
-      fs13.writeFileSync(path17.join(outputDir, fileName), simulationSvgAsset.simulationSvg, "utf-8");
+      fs14.writeFileSync(path18.join(outputDir, fileName), simulationSvgAsset.simulationSvg, "utf-8");
       simulationFileNames.push(fileName);
     }
     if (imageFormats.simulationSchematicSvgs) {
       const fileName = hasMultipleSimulations ? `simulation-schematic-${simulationSvgAsset.fileNameSuffix}.svg` : "simulation-schematic.svg";
-      fs13.writeFileSync(path17.join(outputDir, fileName), simulationSvgAsset.schematicSimulationSvg, "utf-8");
+      fs14.writeFileSync(path18.join(outputDir, fileName), simulationSvgAsset.schematicSimulationSvg, "utf-8");
       schematicSimulationFileNames.push(fileName);
     }
   }
@@ -27916,8 +27958,8 @@ var writeGlbFromCircuitJson = async (circuitJson, glbOutputPath) => {
   const circuitJsonWithFileUrls = convertModelUrlsToFileUrls(circuitJson);
   const glbBuffer = await convertCircuitJsonToGltf(circuitJsonWithFileUrls, getCircuitJsonToGltfOptions({ format: "glb" }));
   const glbData = normalizeToUint8Array2(glbBuffer);
-  fs13.mkdirSync(path17.dirname(glbOutputPath), { recursive: true });
-  fs13.writeFileSync(glbOutputPath, Buffer.from(glbData));
+  fs14.mkdirSync(path18.dirname(glbOutputPath), { recursive: true });
+  fs14.writeFileSync(glbOutputPath, Buffer.from(glbData));
 };
 var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
   const stepContent = await circuitJsonToStep(circuitJson, {
@@ -27925,38 +27967,38 @@ var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
     includeExternalMeshes: true,
     fsMap: await loadLocalStepModelFsMap(circuitJson)
   });
-  fs13.mkdirSync(path17.dirname(stepOutputPath), { recursive: true });
-  fs13.writeFileSync(stepOutputPath, stepContent);
+  fs14.mkdirSync(path18.dirname(stepOutputPath), { recursive: true });
+  fs14.writeFileSync(stepOutputPath, stepContent);
 };
 var writeImageAssetsFromCircuitJson = async (circuitJson, options) => {
   const { outputDir, imageFormats, pcbSnapshotSettings } = options;
-  fs13.mkdirSync(outputDir, { recursive: true });
+  fs14.mkdirSync(outputDir, { recursive: true });
   if (imageFormats.pcbSvgs) {
     const pcbSvg = convertCircuitJsonToPcbSvg3(circuitJson, pcbSnapshotSettings);
-    fs13.writeFileSync(path17.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
+    fs14.writeFileSync(path18.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
   }
   if (imageFormats.pcbPngs) {
     const pcbSvg = convertCircuitJsonToPcbSvg3(circuitJson, pcbSnapshotSettings);
-    fs13.writeFileSync(path17.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
+    fs14.writeFileSync(path18.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
   }
   if (imageFormats.schematicSvgs) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs13.writeFileSync(path17.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
+    fs14.writeFileSync(path18.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
   }
   if (imageFormats.schematicPngs) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs13.writeFileSync(path17.join(outputDir, "schematic.png"), await convertSvgToPngBuffer(schematicSvg));
+    fs14.writeFileSync(path18.join(outputDir, "schematic.png"), await convertSvgToPngBuffer(schematicSvg));
   }
   writeSimulationSvgAssetsFromCircuitJson(circuitJson, outputDir, imageFormats);
   if (imageFormats.threeDPngs) {
     const pngBuffer = await renderCircuitJsonTo3dPng(circuitJson);
-    fs13.writeFileSync(path17.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
+    fs14.writeFileSync(path18.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
   }
 };
 
 // cli/build/worker-build-handlers.ts
 var loadCircuitJsonFromInputFile = (filePath) => {
-  const parsed = JSON.parse(fs14.readFileSync(filePath, "utf-8"));
+  const parsed = JSON.parse(fs15.readFileSync(filePath, "utf-8"));
   return Array.isArray(parsed) ? parsed : [];
 };
 var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath, previewOutputDir, projectDir, options, workerLog, workerStatus) => {
@@ -27964,7 +28006,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
   const warnings = [];
   const startedAt = options?.profile ? performance.now() : 0;
   try {
-    workerLog(`Generating circuit JSON for ${path18.relative(projectDir, filePath)}...`);
+    workerLog(`Generating circuit JSON for ${path19.relative(projectDir, filePath)}...`);
     await registerStaticAssetLoaders(undefined, projectDir);
     const projectConfig = await loadRuntimeProjectConfig(projectDir);
     const platformConfig = mergePlatformConfigs(projectConfig?.platformConfig, options?.platformConfig);
@@ -27988,9 +28030,9 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
         workerStatus(`waiting on ${asyncEffectName}…`);
       }
     })).circuitJson;
-    fs14.mkdirSync(path18.dirname(outputPath), { recursive: true });
-    fs14.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
-    workerLog(`Circuit JSON written to ${path18.relative(projectDir, outputPath)}`);
+    fs15.mkdirSync(path19.dirname(outputPath), { recursive: true });
+    fs15.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    workerLog(`Circuit JSON written to ${path19.relative(projectDir, outputPath)}`);
     const diagnostics = analyzeCircuitJson(circuitJson);
     const filteredDiagnostics = filterDiagnosticsByDrcCategory({
       errors: diagnostics.errors,
@@ -28020,7 +28062,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     let previewError;
     if (glbOutputPath) {
       try {
-        workerLog(`Converting ${path18.relative(projectDir, outputPath)} to GLB in same worker...`);
+        workerLog(`Converting ${path19.relative(projectDir, outputPath)} to GLB in same worker...`);
         await writeGlbFromCircuitJson(circuitJson, glbOutputPath);
         glbOk = true;
       } catch (err) {
@@ -28031,7 +28073,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (stepOutputPath) {
       try {
-        workerLog(`Converting ${path18.relative(projectDir, outputPath)} to STEP in same worker...`);
+        workerLog(`Converting ${path19.relative(projectDir, outputPath)} to STEP in same worker...`);
         await writeStepFromCircuitJson(circuitJson, stepOutputPath);
         stepOk = true;
       } catch (err) {
@@ -28042,8 +28084,8 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (options?.generatePreviewAssets) {
       try {
-        const resolvedPreviewOutputDir = previewOutputDir ?? path18.dirname(outputPath);
-        workerLog(`Generating preview assets for ${path18.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
+        const resolvedPreviewOutputDir = previewOutputDir ?? path19.dirname(outputPath);
+        workerLog(`Generating preview assets for ${path19.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
         await writeImageAssetsFromCircuitJson(circuitJson, {
           outputDir: resolvedPreviewOutputDir,
           imageFormats: options?.imageFormats ?? DEFAULT_IMAGE_FORMAT_SELECTION,