@tscircuit/cli 0.1.1648 → 0.1.1650

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

@@ -5608,8 +5608,8 @@ var require_utils = __commonJS((exports, module) => {
     }
     return ind;
   }
-  function removeDotSegments(path11) {
-    let input = path11;
+  function removeDotSegments(path12) {
+    let input = path12;
     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 [path11, query] = wsComponent.resourceName.split("?");
-      wsComponent.path = path11 && path11 !== "/" ? path11 : undefined;
+      const [path12, query] = wsComponent.resourceName.split("?");
+      wsComponent.path = path12 && path12 !== "/" ? path12 : 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, fs8, exportName) {
+  function addFormats(ajv, list, fs9, 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, fs8[f]);
+      ajv.addFormat(f, fs9[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 fs12 from "node:fs";
-import path16 from "node:path";
+import fs13 from "node:fs";
+import path17 from "node:path";
 
 // lib/project-config/index.ts
 import * as fs from "node:fs";
@@ -11858,8 +11858,8 @@ function analyzeCircuitJson(circuitJson) {
 }
 
 // lib/shared/generate-circuit-json.tsx
-import fs5 from "node:fs";
-import path5 from "node:path";
+import fs6 from "node:fs";
+import path6 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import Debug from "debug";
 
@@ -12626,6 +12626,137 @@ var registerStaticAssetLoaders = (platformConfig) => {
   }
 };
 
+// lib/shared/circuit-json-build-cache.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+import { createHash } from "node:crypto";
+var SOURCE_FILE_EXTENSIONS = new Set([
+  ".tsx",
+  ".ts",
+  ".jsx",
+  ".js",
+  ".json",
+  ".txt",
+  ".md",
+  ".obj",
+  ".kicad_mod",
+  ".kicad_pcb",
+  ".kicad_pro",
+  ".kicad_sch"
+]);
+var IGNORED_DIRECTORY_NAMES = new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".git"
+]);
+var isPathInside = (childPath, parentPath) => {
+  const relative2 = path5.relative(parentPath, childPath);
+  return relative2 === "" || !relative2.startsWith("..") && !path5.isAbsolute(relative2);
+};
+var findCircuitProjectDir = (filePath) => {
+  const absoluteFilePath = path5.resolve(filePath);
+  let currentDir = path5.dirname(absoluteFilePath);
+  while (true) {
+    if (fs5.existsSync(path5.join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    const parentDir = path5.dirname(currentDir);
+    if (parentDir === currentDir)
+      break;
+    currentDir = parentDir;
+  }
+  const cwd = path5.resolve(process.cwd());
+  return isPathInside(absoluteFilePath, cwd) ? cwd : path5.dirname(absoluteFilePath);
+};
+var getCircuitJsonOutputDirName = (relativePath) => {
+  const normalizedRelativePath = relativePath.toLowerCase().replaceAll("\\", "/");
+  if (normalizedRelativePath === "circuit.json" || normalizedRelativePath.endsWith("/circuit.json")) {
+    return path5.dirname(relativePath);
+  }
+  return relativePath.replace(/(\.board|\.circuit)?\.tsx$/, "").replace(/\.circuit\.json$/, "");
+};
+var getCircuitJsonBuildOutputPath = (filePath) => {
+  const absoluteFilePath = path5.resolve(filePath);
+  const projectDir = findCircuitProjectDir(absoluteFilePath);
+  const relativePath = path5.relative(projectDir, absoluteFilePath);
+  return path5.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));
+    for (const entry of entries) {
+      const entryPath = path5.join(directoryPath, entry.name);
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRECTORY_NAMES.has(entry.name) || entry.name.startsWith(".")) {
+          continue;
+        }
+        visit(entryPath);
+        continue;
+      }
+      if (!entry.isFile() || entry.name.endsWith(".circuit.json") || !SOURCE_FILE_EXTENSIONS.has(path5.extname(entry.name).toLowerCase())) {
+        continue;
+      }
+      sourceFilePaths.push(entryPath);
+    }
+  };
+  visit(projectDir);
+  return sourceFilePaths;
+};
+var getSourceFilesystemMd5Hash = (filePath) => {
+  const projectDir = findCircuitProjectDir(filePath);
+  const hash = createHash("md5");
+  for (const sourceFilePath of getSourceFilePaths(projectDir)) {
+    const relativePath = path5.relative(projectDir, sourceFilePath).split(path5.sep).join("/");
+    const content = fs5.readFileSync(sourceFilePath);
+    hash.update(`${Buffer.byteLength(relativePath)}:`);
+    hash.update(relativePath);
+    hash.update(`${content.byteLength}:`);
+    hash.update(content);
+  }
+  return hash.digest("hex");
+};
+var addSourceFilesystemHash = (circuitJson, sourceFilesystemMd5Hash) => {
+  let foundProjectMetadata = false;
+  const circuitJsonWithHash = circuitJson.map((element) => {
+    if (element.type !== "source_project_metadata")
+      return element;
+    foundProjectMetadata = true;
+    const metadataWithHash = {
+      ...element,
+      source_filesystem_md5_hash: sourceFilesystemMd5Hash
+    };
+    return metadataWithHash;
+  });
+  if (!foundProjectMetadata) {
+    const metadataWithHash = {
+      type: "source_project_metadata",
+      source_filesystem_md5_hash: sourceFilesystemMd5Hash
+    };
+    circuitJsonWithHash.push(metadataWithHash);
+  }
+  return circuitJsonWithHash;
+};
+var readCurrentCircuitJsonBuild = ({
+  filePath,
+  sourceFilesystemMd5Hash
+}) => {
+  const outputPath = getCircuitJsonBuildOutputPath(filePath);
+  try {
+    const parsed = JSON.parse(fs5.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);
+    return hasCurrentFilesystemHash ? {
+      circuitJson: parsed,
+      outputPath
+    } : null;
+  } catch {
+    return null;
+  }
+};
+
 // lib/shared/generate-circuit-json.tsx
 import { jsxDEV } from "react/jsx-dev-runtime";
 var debug = Debug("tsci:generate-circuit-json");
@@ -12651,9 +12782,11 @@ async function generateCircuitJson({
   platformConfig,
   injectedProps,
   onAsyncEffectStatus,
-  autorouterDiagnostics: autorouterDiagnosticsOptions
+  autorouterDiagnostics: autorouterDiagnosticsOptions,
+  sourceFilesystemMd5Hash
 }) {
   debug(`Generating circuit JSON for ${filePath}`);
+  const currentSourceFilesystemMd5Hash = sourceFilesystemMd5Hash ?? getSourceFilesystemMd5Hash(filePath);
   const React = await importFromUserLand("react");
   globalThis.React = React;
   registerStaticAssetLoaders(platformConfig);
@@ -12663,12 +12796,12 @@ 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 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}`);
@@ -12688,7 +12821,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;
       },
@@ -12720,11 +12853,11 @@ async function generateCircuitJson({
     runner.render();
   }
   runner.emit("renderComplete");
-  const circuitJson = await runner.getCircuitJson();
+  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,
@@ -12734,29 +12867,29 @@ async function generateCircuitJson({
 }
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
-import { createHash } from "node:crypto";
-import fs6 from "node:fs";
-import path6 from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+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 = createHash("md5").update(key).digest("hex");
+        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 });
-        const hash = createHash("md5").update(key).digest("hex");
+        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 {}
     }
   };
@@ -12772,15 +12905,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}`;
@@ -13005,8 +13138,8 @@ var resolveImageFormatSelection = (options) => {
 };
 
 // cli/build/worker-output-generators.ts
-import fs11 from "node:fs";
-import path15 from "node:path";
+import fs12 from "node:fs";
+import path16 from "node:path";
 
 // node_modules/circuit-json-to-3d-png/dist/index.js
 function normalizeDir(dir) {
@@ -15489,7 +15622,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 path7 from "node:path";
+import path8 from "node:path";
 var isRemoteUrl = (value) => /^https?:\/\//i.test(value);
 async function loadLocalStepModelFsMap(circuitJson) {
   const fsMap = {};
@@ -15501,7 +15634,7 @@ async function loadLocalStepModelFsMap(circuitJson) {
       continue;
     if (isRemoteUrl(modelUrl) || fsMap[modelUrl])
       continue;
-    const localPath = path7.resolve(process.cwd(), modelUrl);
+    const localPath = path8.resolve(process.cwd(), modelUrl);
     if (!existsSync2(localPath))
       continue;
     fsMap[modelUrl] = await readFile(localPath, "utf-8");
@@ -15551,8 +15684,8 @@ var getSimulationSvgAssetsFromCircuitJson = (circuitJson) => {
 // node_modules/conf/dist/source/index.js
 import { isDeepStrictEqual } from "node:util";
 import process7 from "node:process";
-import fs8 from "node:fs";
-import path11 from "node:path";
+import fs9 from "node:fs";
+import path12 from "node:path";
 import crypto from "node:crypto";
 import assert from "node:assert";
 
@@ -15567,12 +15700,12 @@ var disallowedKeys = new Set([
   "constructor"
 ]);
 var digits = new Set("0123456789");
-function getPathSegments(path8) {
+function getPathSegments(path9) {
   const parts = [];
   let currentSegment = "";
   let currentPart = "start";
   let isIgnoring = false;
-  for (const character of path8) {
+  for (const character of path9) {
     switch (character) {
       case "\\": {
         if (currentPart === "index") {
@@ -15694,11 +15827,11 @@ function assertNotStringIndex(object, key) {
     throw new Error("Cannot use string index");
   }
 }
-function getProperty(object, path8, value) {
-  if (!isObject(object) || typeof path8 !== "string") {
+function getProperty(object, path9, value) {
+  if (!isObject(object) || typeof path9 !== "string") {
     return value === undefined ? object : value;
   }
-  const pathArray = getPathSegments(path8);
+  const pathArray = getPathSegments(path9);
   if (pathArray.length === 0) {
     return value;
   }
@@ -15718,12 +15851,12 @@ function getProperty(object, path8, value) {
   }
   return object === undefined ? value : object;
 }
-function setProperty(object, path8, value) {
-  if (!isObject(object) || typeof path8 !== "string") {
+function setProperty(object, path9, value) {
+  if (!isObject(object) || typeof path9 !== "string") {
     return object;
   }
   const root = object;
-  const pathArray = getPathSegments(path8);
+  const pathArray = getPathSegments(path9);
   for (let index = 0;index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -15736,11 +15869,11 @@ function setProperty(object, path8, value) {
   }
   return root;
 }
-function deleteProperty(object, path8) {
-  if (!isObject(object) || typeof path8 !== "string") {
+function deleteProperty(object, path9) {
+  if (!isObject(object) || typeof path9 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path8);
+  const pathArray = getPathSegments(path9);
   for (let index = 0;index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -15754,11 +15887,11 @@ function deleteProperty(object, path8) {
     }
   }
 }
-function hasProperty(object, path8) {
-  if (!isObject(object) || typeof path8 !== "string") {
+function hasProperty(object, path9) {
+  if (!isObject(object) || typeof path9 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path8);
+  const pathArray = getPathSegments(path9);
   if (pathArray.length === 0) {
     return false;
   }
@@ -15772,41 +15905,41 @@ function hasProperty(object, path8) {
 }
 
 // node_modules/env-paths/index.js
-import path8 from "node:path";
+import path9 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 = path8.join(homedir, "Library");
+  const library = path9.join(homedir, "Library");
   return {
-    data: path8.join(library, "Application Support", name),
-    config: path8.join(library, "Preferences", name),
-    cache: path8.join(library, "Caches", name),
-    log: path8.join(library, "Logs", name),
-    temp: path8.join(tmpdir, name)
+    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)
   };
 };
 var windows = (name) => {
-  const appData = env.APPDATA || path8.join(homedir, "AppData", "Roaming");
-  const localAppData = env.LOCALAPPDATA || path8.join(homedir, "AppData", "Local");
+  const appData = env.APPDATA || path9.join(homedir, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path9.join(homedir, "AppData", "Local");
   return {
-    data: path8.join(localAppData, name, "Data"),
-    config: path8.join(appData, name, "Config"),
-    cache: path8.join(localAppData, name, "Cache"),
-    log: path8.join(localAppData, name, "Log"),
-    temp: path8.join(tmpdir, name)
+    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)
   };
 };
 var linux = (name) => {
-  const username = path8.basename(homedir);
+  const username = path9.basename(homedir);
   return {
-    data: path8.join(env.XDG_DATA_HOME || path8.join(homedir, ".local", "share"), name),
-    config: path8.join(env.XDG_CONFIG_HOME || path8.join(homedir, ".config"), name),
-    cache: path8.join(env.XDG_CACHE_HOME || path8.join(homedir, ".cache"), name),
-    log: path8.join(env.XDG_STATE_HOME || path8.join(homedir, ".local", "state"), name),
-    temp: path8.join(tmpdir, username, name)
+    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)
   };
 };
 function envPaths(name, { suffix = "nodejs" } = {}) {
@@ -15826,10 +15959,10 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
 }
 
 // node_modules/atomically/dist/index.js
-import path10 from "node:path";
+import path11 from "node:path";
 
 // node_modules/stubborn-fs/dist/index.js
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import { promisify } from "node:util";
 
 // node_modules/stubborn-utils/dist/attemptify_async.js
@@ -15959,41 +16092,41 @@ var RETRYIFY_OPTIONS = {
 // node_modules/stubborn-fs/dist/index.js
 var FS = {
   attempt: {
-    chmod: attemptify_async_default(promisify(fs7.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    chown: attemptify_async_default(promisify(fs7.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    close: attemptify_async_default(promisify(fs7.close), ATTEMPTIFY_NOOP_OPTIONS),
-    fsync: attemptify_async_default(promisify(fs7.fsync), ATTEMPTIFY_NOOP_OPTIONS),
-    mkdir: attemptify_async_default(promisify(fs7.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
-    realpath: attemptify_async_default(promisify(fs7.realpath), ATTEMPTIFY_NOOP_OPTIONS),
-    stat: attemptify_async_default(promisify(fs7.stat), ATTEMPTIFY_NOOP_OPTIONS),
-    unlink: attemptify_async_default(promisify(fs7.unlink), ATTEMPTIFY_NOOP_OPTIONS),
-    chmodSync: attemptify_sync_default(fs7.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    chownSync: attemptify_sync_default(fs7.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    closeSync: attemptify_sync_default(fs7.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
-    existsSync: attemptify_sync_default(fs7.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
-    fsyncSync: attemptify_sync_default(fs7.fsync, ATTEMPTIFY_NOOP_OPTIONS),
-    mkdirSync: attemptify_sync_default(fs7.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
-    realpathSync: attemptify_sync_default(fs7.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
-    statSync: attemptify_sync_default(fs7.statSync, ATTEMPTIFY_NOOP_OPTIONS),
-    unlinkSync: attemptify_sync_default(fs7.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
+    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)
   },
   retry: {
-    close: retryify_async_default(promisify(fs7.close), RETRYIFY_OPTIONS),
-    fsync: retryify_async_default(promisify(fs7.fsync), RETRYIFY_OPTIONS),
-    open: retryify_async_default(promisify(fs7.open), RETRYIFY_OPTIONS),
-    readFile: retryify_async_default(promisify(fs7.readFile), RETRYIFY_OPTIONS),
-    rename: retryify_async_default(promisify(fs7.rename), RETRYIFY_OPTIONS),
-    stat: retryify_async_default(promisify(fs7.stat), RETRYIFY_OPTIONS),
-    write: retryify_async_default(promisify(fs7.write), RETRYIFY_OPTIONS),
-    writeFile: retryify_async_default(promisify(fs7.writeFile), RETRYIFY_OPTIONS),
-    closeSync: retryify_sync_default(fs7.closeSync, RETRYIFY_OPTIONS),
-    fsyncSync: retryify_sync_default(fs7.fsyncSync, RETRYIFY_OPTIONS),
-    openSync: retryify_sync_default(fs7.openSync, RETRYIFY_OPTIONS),
-    readFileSync: retryify_sync_default(fs7.readFileSync, RETRYIFY_OPTIONS),
-    renameSync: retryify_sync_default(fs7.renameSync, RETRYIFY_OPTIONS),
-    statSync: retryify_sync_default(fs7.statSync, RETRYIFY_OPTIONS),
-    writeSync: retryify_sync_default(fs7.writeSync, RETRYIFY_OPTIONS),
-    writeFileSync: retryify_sync_default(fs7.writeFileSync, RETRYIFY_OPTIONS)
+    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)
   }
 };
 var dist_default = FS;
@@ -16023,7 +16156,7 @@ var isUndefined = (value) => {
 };
 
 // node_modules/atomically/dist/utils/temp.js
-import path9 from "node:path";
+import path10 from "node:path";
 
 // node_modules/when-exit/dist/node/interceptor.js
 import process6 from "node:process";
@@ -16123,7 +16256,7 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename = path9.basename(filePath);
+    const basename = path10.basename(filePath);
     if (basename.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
     const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename);
@@ -16165,7 +16298,7 @@ function writeFileSync2(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
       }
     }
     if (!filePathExists) {
-      const parentPath = path10.dirname(filePath);
+      const parentPath = path11.dirname(filePath);
       dist_default.attempt.mkdirSync(parentPath, {
         mode: DEFAULT_FOLDER_MODE,
         recursive: true
@@ -16481,7 +16614,7 @@ class Conf {
     this.events = new EventTarget;
     this.#encryptionKey = options.encryptionKey;
     const fileExtension = options.fileExtension ? `.${options.fileExtension}` : "";
-    this.path = path11.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
+    this.path = path12.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
     const fileStore = this.store;
     const store = Object.assign(createPlainObject(), options.defaults, fileStore);
     if (options.migrations) {
@@ -16584,7 +16717,7 @@ class Conf {
   }
   get store() {
     try {
-      const data = fs8.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
+      const data = fs9.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
       const dataString = this._encryptData(data);
       const deserializedData = this._deserialize(dataString);
       this._validate(deserializedData);
@@ -16655,7 +16788,7 @@ class Conf {
     throw new Error("Config schema violation: " + errors.join("; "));
   }
   _ensureDirectory() {
-    fs8.mkdirSync(path11.dirname(this.path), { recursive: true });
+    fs9.mkdirSync(path12.dirname(this.path), { recursive: true });
   }
   _write(value) {
     let data = this._serialize(value);
@@ -16666,13 +16799,13 @@ class Conf {
       data = concatUint8Arrays([initializationVector, stringToUint8Array(":"), cipher.update(stringToUint8Array(data)), cipher.final()]);
     }
     if (process7.env.SNAP) {
-      fs8.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+      fs9.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
     } else {
       try {
         writeFileSync2(this.path, data, { mode: this.#options.configFileMode });
       } catch (error) {
         if (error?.code === "EXDEV") {
-          fs8.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+          fs9.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
           return;
         }
         throw error;
@@ -16681,15 +16814,15 @@ class Conf {
   }
   _watch() {
     this._ensureDirectory();
-    if (!fs8.existsSync(this.path)) {
+    if (!fs9.existsSync(this.path)) {
       this._write(createPlainObject());
     }
     if (process7.platform === "win32") {
-      fs8.watch(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs9.watch(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 100 }));
     } else {
-      fs8.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs9.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 5000 }));
     }
@@ -16825,14 +16958,14 @@ function jwtDecode(token, options) {
 }
 
 // lib/cli-config/index.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import os3 from "node:os";
-import path13 from "node:path";
+import path14 from "node:path";
 
 // lib/shared/handle-registry-auth-error.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import os2 from "node:os";
-import path12 from "node:path";
+import path13 from "node:path";
 var AUTH_TOKEN_REGEX = /^\/\/npm\.tscircuit\.com\/:_authToken=(.+)$/m;
 function isUnauthorizedError(error) {
   const output = [
@@ -16853,9 +16986,9 @@ function isUnauthorizedError(error) {
   return /\b(401|E401)\b/i.test(output) || /unauthorized/i.test(output);
 }
 function hasTsciAuthToken(npmrcPath) {
-  if (!fs9.existsSync(npmrcPath))
+  if (!fs10.existsSync(npmrcPath))
     return false;
-  const content = fs9.readFileSync(npmrcPath, "utf-8");
+  const content = fs10.readFileSync(npmrcPath, "utf-8");
   return AUTH_TOKEN_REGEX.test(content);
 }
 function handleRegistryAuthError({
@@ -16865,8 +16998,8 @@ function handleRegistryAuthError({
   if (!isUnauthorizedError(error))
     return;
   const npmrcPaths = [
-    path12.join(projectDir, ".npmrc"),
-    path12.join(os2.homedir(), ".npmrc")
+    path13.join(projectDir, ".npmrc"),
+    path13.join(os2.homedir(), ".npmrc")
   ];
   const hasToken = npmrcPaths.some(hasTsciAuthToken);
   if (hasToken) {
@@ -16889,13 +17022,13 @@ var getSessionToken = () => {
 };
 var getSessionTokenFromNpmrc = () => {
   const npmrcPaths = [
-    path13.join(process.cwd(), ".npmrc"),
-    path13.join(os3.homedir(), ".npmrc")
+    path14.join(process.cwd(), ".npmrc"),
+    path14.join(os3.homedir(), ".npmrc")
   ];
   for (const npmrcPath of npmrcPaths) {
-    if (!fs10.existsSync(npmrcPath))
+    if (!fs11.existsSync(npmrcPath))
       continue;
-    const content = fs10.readFileSync(npmrcPath, "utf-8");
+    const content = fs11.readFileSync(npmrcPath, "utf-8");
     const match = content.match(AUTH_TOKEN_REGEX);
     if (match?.[1]) {
       return match[1].trim();
@@ -16933,7 +17066,7 @@ var getCircuitJsonToGltfOptions = ({
 };
 
 // cli/build/convert-model-urls-to-file-urls.ts
-import path14 from "node:path";
+import path15 from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 var convertModelUrlsToFileUrls = (circuitJson) => {
   const modelUrlKeys2 = [
@@ -16960,7 +17093,7 @@ var convertModelUrlsToFileUrls = (circuitJson) => {
         if (value.startsWith("/") || value.match(/^[a-zA-Z]:\\/)) {
           updated[key] = pathToFileURL3(value).href;
         } else if (value.startsWith(".")) {
-          updated[key] = pathToFileURL3(path14.resolve(process.cwd(), value)).href;
+          updated[key] = pathToFileURL3(path15.resolve(process.cwd(), value)).href;
         }
       }
     }
@@ -16996,10 +17129,10 @@ var writeSimulationSvgAssetsFromCircuitJson = (circuitJson, outputDir, imageForm
   if (!simulationSvgAssets)
     return false;
   if (imageFormats.simulationSvgs) {
-    fs11.writeFileSync(path15.join(outputDir, "simulation.svg"), simulationSvgAssets.simulationSvg, "utf-8");
+    fs12.writeFileSync(path16.join(outputDir, "simulation.svg"), simulationSvgAssets.simulationSvg, "utf-8");
   }
   if (imageFormats.simulationSchematicSvgs) {
-    fs11.writeFileSync(path15.join(outputDir, "simulation-schematic.svg"), simulationSvgAssets.schematicSimulationSvg, "utf-8");
+    fs12.writeFileSync(path16.join(outputDir, "simulation-schematic.svg"), simulationSvgAssets.schematicSimulationSvg, "utf-8");
   }
   return true;
 };
@@ -17007,8 +17140,8 @@ var writeGlbFromCircuitJson = async (circuitJson, glbOutputPath) => {
   const circuitJsonWithFileUrls = convertModelUrlsToFileUrls(circuitJson);
   const glbBuffer = await convertCircuitJsonToGltf(circuitJsonWithFileUrls, getCircuitJsonToGltfOptions({ format: "glb" }));
   const glbData = normalizeToUint8Array2(glbBuffer);
-  fs11.mkdirSync(path15.dirname(glbOutputPath), { recursive: true });
-  fs11.writeFileSync(glbOutputPath, Buffer.from(glbData));
+  fs12.mkdirSync(path16.dirname(glbOutputPath), { recursive: true });
+  fs12.writeFileSync(glbOutputPath, Buffer.from(glbData));
 };
 var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
   const stepContent = await circuitJsonToStep(circuitJson, {
@@ -17016,34 +17149,34 @@ var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
     includeExternalMeshes: true,
     fsMap: await loadLocalStepModelFsMap(circuitJson)
   });
-  fs11.mkdirSync(path15.dirname(stepOutputPath), { recursive: true });
-  fs11.writeFileSync(stepOutputPath, stepContent);
+  fs12.mkdirSync(path16.dirname(stepOutputPath), { recursive: true });
+  fs12.writeFileSync(stepOutputPath, stepContent);
 };
 var writeImageAssetsFromCircuitJson = async (circuitJson, options) => {
   const { outputDir, imageFormats, pcbSnapshotSettings } = options;
-  fs11.mkdirSync(outputDir, { recursive: true });
+  fs12.mkdirSync(outputDir, { recursive: true });
   if (imageFormats.pcbSvgs) {
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson, pcbSnapshotSettings);
-    fs11.writeFileSync(path15.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
+    fs12.writeFileSync(path16.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
   }
   if (imageFormats.pcbPngs) {
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson, pcbSnapshotSettings);
-    fs11.writeFileSync(path15.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
+    fs12.writeFileSync(path16.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
   }
   if (imageFormats.schematicSvgs) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs11.writeFileSync(path15.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
+    fs12.writeFileSync(path16.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
   }
   writeSimulationSvgAssetsFromCircuitJson(circuitJson, outputDir, imageFormats);
   if (imageFormats.threeDPngs) {
     const pngBuffer = await renderCircuitJsonTo3dPng(circuitJson);
-    fs11.writeFileSync(path15.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
+    fs12.writeFileSync(path16.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
   }
 };
 
 // cli/build/worker-build-handlers.ts
 var loadCircuitJsonFromInputFile = (filePath) => {
-  const parsed = JSON.parse(fs12.readFileSync(filePath, "utf-8"));
+  const parsed = JSON.parse(fs13.readFileSync(filePath, "utf-8"));
   return Array.isArray(parsed) ? parsed : [];
 };
 var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath, previewOutputDir, projectDir, options, workerLog, workerStatus) => {
@@ -17052,7 +17185,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
   const startedAt = options?.profile ? performance.now() : 0;
   try {
     process.chdir(projectDir);
-    workerLog(`Generating circuit JSON for ${path16.relative(projectDir, filePath)}...`);
+    workerLog(`Generating circuit JSON for ${path17.relative(projectDir, filePath)}...`);
     await registerStaticAssetLoaders();
     const projectConfig = await loadRuntimeProjectConfig(projectDir);
     const platformConfig = mergePlatformConfigs(projectConfig?.platformConfig, options?.platformConfig);
@@ -17071,9 +17204,9 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
         workerStatus(`waiting on ${asyncEffectName}…`);
       }
     })).circuitJson;
-    fs12.mkdirSync(path16.dirname(outputPath), { recursive: true });
-    fs12.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
-    workerLog(`Circuit JSON written to ${path16.relative(projectDir, outputPath)}`);
+    fs13.mkdirSync(path17.dirname(outputPath), { recursive: true });
+    fs13.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    workerLog(`Circuit JSON written to ${path17.relative(projectDir, outputPath)}`);
     const diagnostics = analyzeCircuitJson(circuitJson);
     const filteredDiagnostics = filterDiagnosticsByDrcCategory({
       errors: diagnostics.errors,
@@ -17103,7 +17236,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     let previewError;
     if (glbOutputPath) {
       try {
-        workerLog(`Converting ${path16.relative(projectDir, outputPath)} to GLB in same worker...`);
+        workerLog(`Converting ${path17.relative(projectDir, outputPath)} to GLB in same worker...`);
         await writeGlbFromCircuitJson(circuitJson, glbOutputPath);
         glbOk = true;
       } catch (err) {
@@ -17114,7 +17247,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (stepOutputPath) {
       try {
-        workerLog(`Converting ${path16.relative(projectDir, outputPath)} to STEP in same worker...`);
+        workerLog(`Converting ${path17.relative(projectDir, outputPath)} to STEP in same worker...`);
         await writeStepFromCircuitJson(circuitJson, stepOutputPath);
         stepOk = true;
       } catch (err) {
@@ -17125,8 +17258,8 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (options?.generatePreviewAssets) {
       try {
-        const resolvedPreviewOutputDir = previewOutputDir ?? path16.dirname(outputPath);
-        workerLog(`Generating preview assets for ${path16.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
+        const resolvedPreviewOutputDir = previewOutputDir ?? path17.dirname(outputPath);
+        workerLog(`Generating preview assets for ${path17.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
         await writeImageAssetsFromCircuitJson(circuitJson, {
           outputDir: resolvedPreviewOutputDir,
           imageFormats: options?.imageFormats ?? DEFAULT_IMAGE_FORMAT_SELECTION,