@tscircuit/cli 0.1.1610 → 0.1.1611

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

@@ -522,11 +522,11 @@ var require_dist = __commonJS((exports, module) => {
                 if (pad) {
                   var need = width - c.length;
                   if (need > 0) {
-                    var z = new Array(need + 1).join("0");
+                    var z2 = new Array(need + 1).join("0");
                     if (i < 0)
-                      c = "-" + z + c.slice(1);
+                      c = "-" + z2 + c.slice(1);
                     else
-                      c = z + c;
+                      c = z2 + c;
                   }
                 }
               }
@@ -5608,8 +5608,8 @@ var require_utils = __commonJS((exports, module) => {
     }
     return ind;
   }
-  function removeDotSegments(path8) {
-    let input = path8;
+  function removeDotSegments(path9) {
+    let input = path9;
     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 [path8, query] = wsComponent.resourceName.split("?");
-      wsComponent.path = path8 && path8 !== "/" ? path8 : undefined;
+      const [path9, query] = wsComponent.resourceName.split("?");
+      wsComponent.path = path9 && path9 !== "/" ? path9 : 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, fs6, exportName) {
+  function addFormats(ajv, list, fs7, 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, fs6[f]);
+      ajv.addFormat(f, fs7[f]);
   }
   module.exports = exports = formatsPlugin;
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -10815,16 +10815,16 @@ var require_range = __commonJS((exports, module) => {
   };
   var replaceTilde = (comp, options) => {
     const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
-    const z = options.includePrerelease ? "-0" : "";
+    const z2 = options.includePrerelease ? "-0" : "";
     return comp.replace(r, (_, M, m, p, pr) => {
       debug2("tilde", comp, _, M, m, p, pr);
       let ret;
       if (isX(M)) {
         ret = "";
       } else if (isX(m)) {
-        ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        ret = `>=${M}.0.0${z2} <${+M + 1}.0.0-0`;
       } else if (isX(p)) {
-        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+        ret = `>=${M}.${m}.0${z2} <${M}.${+m + 1}.0-0`;
       } else if (pr) {
         debug2("replaceTilde pr", pr);
         ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
@@ -10841,19 +10841,19 @@ var require_range = __commonJS((exports, module) => {
   var replaceCaret = (comp, options) => {
     debug2("caret", comp, options);
     const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
-    const z = options.includePrerelease ? "-0" : "";
+    const z2 = options.includePrerelease ? "-0" : "";
     return comp.replace(r, (_, M, m, p, pr) => {
       debug2("caret", comp, _, M, m, p, pr);
       let ret;
       if (isX(M)) {
         ret = "";
       } else if (isX(m)) {
-        ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        ret = `>=${M}.0.0${z2} <${+M + 1}.0.0-0`;
       } else if (isX(p)) {
         if (M === "0") {
-          ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+          ret = `>=${M}.${m}.0${z2} <${M}.${+m + 1}.0-0`;
         } else {
-          ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+          ret = `>=${M}.${m}.0${z2} <${+M + 1}.0.0-0`;
         }
       } else if (pr) {
         debug2("replaceCaret pr", pr);
@@ -11651,8 +11651,188 @@ var require_semver2 = __commonJS((exports, module) => {
 import { parentPort } from "node:worker_threads";
 
 // cli/build/worker-build-handlers.ts
-import fs10 from "node:fs";
-import path14 from "node:path";
+import fs11 from "node:fs";
+import path15 from "node:path";
+
+// lib/project-config/index.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+
+// lib/project-config/project-config-schema.ts
+import { z } from "zod";
+var pcbSnapshotSettingsSchema = z.object({
+  showCourtyards: z.boolean().optional(),
+  showPcbNotes: z.boolean().optional(),
+  showFabricationNotes: z.boolean().optional()
+});
+var projectConfigSchema = z.object({
+  mainEntrypoint: z.string().optional(),
+  libraryEntrypoint: z.string().optional(),
+  previewComponentPath: z.string().optional(),
+  siteDefaultComponentPath: z.string().optional(),
+  ignoredFiles: z.array(z.string()).optional(),
+  includeBoardFiles: z.array(z.string()).optional(),
+  snapshotsDir: z.string().optional(),
+  pcbSnapshotSettings: pcbSnapshotSettingsSchema.optional(),
+  prebuildCommand: z.string().optional(),
+  buildCommand: z.string().optional(),
+  kicadProjectEntrypointPath: z.string().optional(),
+  kicadLibraryEntrypointPath: z.string().optional(),
+  kicadLibraryName: z.string().optional(),
+  alwaysUseLatestTscircuitOnCloud: z.boolean().optional(),
+  build: z.object({
+    circuitJson: z.boolean().optional(),
+    kicadProject: z.boolean().optional(),
+    kicadLibrary: z.boolean().optional(),
+    kicadPcm: z.boolean().optional(),
+    previewImages: z.boolean().optional(),
+    glbs: z.boolean().optional(),
+    step: z.boolean().optional(),
+    workerTimeoutMs: z.number().int().positive().optional(),
+    routingDisabled: z.boolean().optional(),
+    typescriptLibrary: z.boolean().optional()
+  }).optional()
+});
+
+// lib/project-config/index.ts
+var CONFIG_FILENAME = "tscircuit.config.json";
+var CONFIG_MODULE_FILENAMES = [
+  "tscircuit.config.ts",
+  "tscircuit.config.js"
+];
+var ENV_FILENAMES = [".env", ".env.local"];
+var CONFIG_SCHEMA_URL = "https://cdn.jsdelivr.net/npm/@tscircuit/cli/types/tscircuit.config.schema.json";
+var DEFAULT_BOARD_FILE_PATTERNS = [
+  "**/*.board.tsx",
+  "**/*.circuit.tsx",
+  "**/*.circuit.json"
+];
+var parseProjectConfigObject = (config) => {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error("tscircuit config must export an object");
+  }
+  const { platformConfig, ...serializableConfig } = config;
+  const parsedConfig = projectConfigSchema.parse(serializableConfig);
+  if (platformConfig === undefined) {
+    return parsedConfig;
+  }
+  return {
+    ...parsedConfig,
+    platformConfig
+  };
+};
+var stripWrappingQuotes = (value) => {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+};
+var loadProjectEnv = (projectDir) => {
+  const initialEnvKeys = new Set(Object.keys(process.env));
+  for (const envFileName of ENV_FILENAMES) {
+    const envPath = path.join(projectDir, envFileName);
+    if (!fs.existsSync(envPath))
+      continue;
+    const envContent = fs.readFileSync(envPath, "utf8");
+    for (const rawLine of envContent.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#"))
+        continue;
+      const lineWithoutExport = line.startsWith("export ") ? line.slice("export ".length) : line;
+      const separatorIndex = lineWithoutExport.indexOf("=");
+      if (separatorIndex <= 0)
+        continue;
+      const key = lineWithoutExport.slice(0, separatorIndex).trim();
+      if (!key || initialEnvKeys.has(key))
+        continue;
+      const value = stripWrappingQuotes(lineWithoutExport.slice(separatorIndex + 1).trim());
+      process.env[key] = value;
+    }
+  }
+};
+var loadProjectConfigSync = (projectDir = process.cwd()) => {
+  const configPath = path.join(projectDir, CONFIG_FILENAME);
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const configContent = fs.readFileSync(configPath, "utf8");
+    const parsedConfig = JSON.parse(configContent);
+    return projectConfigSchema.parse(parsedConfig);
+  } catch (error) {
+    console.error(`Error loading tscircuit config: ${error}`);
+    return null;
+  }
+};
+var loadProjectConfigModule = async (projectDir) => {
+  loadProjectEnv(projectDir);
+  for (const configFileName of CONFIG_MODULE_FILENAMES) {
+    const configPath = path.join(projectDir, configFileName);
+    if (!fs.existsSync(configPath))
+      continue;
+    try {
+      const moduleUrl = pathToFileURL(configPath);
+      const stat = fs.statSync(configPath);
+      moduleUrl.searchParams.set("tsci", String(stat.mtimeMs));
+      const importedModule = await import(moduleUrl.href);
+      const exportedConfig = importedModule.default ?? importedModule.config ?? importedModule;
+      return parseProjectConfigObject(exportedConfig);
+    } catch (error) {
+      console.error(`Error loading ${configFileName}: ${error}`);
+      return null;
+    }
+  }
+  return null;
+};
+var loadRuntimeProjectConfig = async (projectDir = process.cwd()) => {
+  const jsonConfig = loadProjectConfigSync(projectDir);
+  const moduleConfig = await loadProjectConfigModule(projectDir);
+  if (!jsonConfig && !moduleConfig) {
+    return null;
+  }
+  return {
+    ...jsonConfig ?? {},
+    ...moduleConfig ?? {},
+    build: {
+      ...jsonConfig?.build,
+      ...moduleConfig?.build
+    },
+    pcbSnapshotSettings: {
+      ...jsonConfig?.pcbSnapshotSettings,
+      ...moduleConfig?.pcbSnapshotSettings
+    }
+  };
+};
+var loadProjectConfig = (projectDir = process.cwd()) => {
+  return loadProjectConfigSync(projectDir);
+};
+var getBoardFilePatterns = (projectDir = process.cwd()) => {
+  const config = loadProjectConfigSync(projectDir);
+  const patterns = config?.includeBoardFiles?.filter((pattern) => pattern.trim());
+  if (patterns && patterns.length > 0) {
+    return patterns;
+  }
+  return DEFAULT_BOARD_FILE_PATTERNS;
+};
+var getSnapshotsDir = (projectDir = process.cwd()) => {
+  const config = loadProjectConfigSync(projectDir);
+  return config?.snapshotsDir;
+};
+var saveProjectConfig = (config, projectDir = process.cwd()) => {
+  const configPath = path.join(projectDir, CONFIG_FILENAME);
+  try {
+    const configWithSchema = {
+      $schema: CONFIG_SCHEMA_URL,
+      ...config ?? {}
+    };
+    fs.writeFileSync(configPath, JSON.stringify(configWithSchema, null, 2));
+    return true;
+  } catch (error) {
+    console.error(`Error saving tscircuit config: ${error}`);
+    return false;
+  }
+};
 
 // lib/shared/circuit-json-diagnostics.ts
 function analyzeCircuitJson(circuitJson) {
@@ -11678,9 +11858,9 @@ function analyzeCircuitJson(circuitJson) {
 }
 
 // lib/shared/generate-circuit-json.tsx
-import fs3 from "node:fs";
-import path3 from "node:path";
-import { pathToFileURL } from "node:url";
+import fs4 from "node:fs";
+import path4 from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 import Debug from "debug";
 
 // lib/utils/abbreviate-stringify-object.ts
@@ -11702,12 +11882,12 @@ var import_make_vfs = __toESM(require_dist(), 1);
 
 // lib/shared/importFromUserLand.ts
 import { createRequire as createRequire2 } from "node:module";
-import fs from "node:fs";
-import path from "node:path";
+import fs2 from "node:fs";
+import path2 from "node:path";
 async function importFromUserLand(moduleName) {
-  const userModulePath = path.join(process.cwd(), "node_modules", moduleName);
-  if (fs.existsSync(userModulePath)) {
-    const userRequire = createRequire2(path.join(process.cwd(), "noop.js"));
+  const userModulePath = path2.join(process.cwd(), "node_modules", moduleName);
+  if (fs2.existsSync(userModulePath)) {
+    const userRequire = createRequire2(path2.join(process.cwd(), "noop.js"));
     try {
       const resolvedUserPath = userRequire.resolve(moduleName);
       return await import(resolvedUserPath);
@@ -11730,8 +11910,8 @@ async function importFromUserLand(moduleName) {
 }
 
 // lib/shared/register-static-asset-loaders.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 var STATIC_ASSET_EXTENSIONS = [
   ".glb",
   ".gltf",
@@ -11756,15 +11936,15 @@ var TEXT_STATIC_ASSET_EXTENSIONS = new Set([
   ".kicad_sch"
 ]);
 var readFileContentForStaticLoader = (filePath) => {
-  const ext = path2.extname(filePath).toLowerCase();
+  const ext = path3.extname(filePath).toLowerCase();
   if (TEXT_STATIC_ASSET_EXTENSIONS.has(ext)) {
-    return fs2.readFileSync(filePath, "utf-8");
+    return fs3.readFileSync(filePath, "utf-8");
   }
-  const buffer = fs2.readFileSync(filePath);
+  const buffer = fs3.readFileSync(filePath);
   return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
 };
 var getStaticFileLoader = (filePath) => {
-  const extWithDot = path2.extname(filePath).toLowerCase();
+  const extWithDot = path3.extname(filePath).toLowerCase();
   const ext = extWithDot.replace(/^\./, "");
   return activePlatformConfig?.staticFileLoaderMap?.[ext] ?? activePlatformConfig?.staticFileLoaderMap?.[extWithDot];
 };
@@ -11778,12 +11958,12 @@ var normalizeStaticFileLoaderResult = (result) => {
   };
 };
 var getBaseUrlFromTsConfig = () => {
-  const tsconfigPath = path2.join(process.cwd(), "tsconfig.json");
+  const tsconfigPath = path3.join(process.cwd(), "tsconfig.json");
   try {
-    if (!fs2.existsSync(tsconfigPath)) {
+    if (!fs3.existsSync(tsconfigPath)) {
       return null;
     }
-    const tsconfigContent = fs2.readFileSync(tsconfigPath, "utf-8");
+    const tsconfigContent = fs3.readFileSync(tsconfigPath, "utf-8");
     const tsconfig = JSON.parse(tsconfigContent);
     if (tsconfig.compilerOptions?.baseUrl) {
       return tsconfig.compilerOptions.baseUrl;
@@ -11810,8 +11990,8 @@ var registerStaticAssetLoaders = (platformConfig) => {
               loader: "object"
             };
           }
-          const baseDir = baseUrl ? path2.resolve(process.cwd(), baseUrl) : process.cwd();
-          const relativePath = path2.relative(baseDir, args.path).split(path2.sep).join("/");
+          const baseDir = baseUrl ? path3.resolve(process.cwd(), baseUrl) : process.cwd();
+          const relativePath = path3.relative(baseDir, args.path).split(path3.sep).join("/");
           const pathStr = `./${relativePath}`;
           return {
             exports: {
@@ -11860,12 +12040,12 @@ async function generateCircuitJson({
   const runner = new userLandTscircuit.RootCircuit({
     platform: platformConfig
   });
-  const absoluteFilePath = path3.isAbsolute(filePath) ? filePath : path3.resolve(process.cwd(), filePath);
-  const projectDir = path3.dirname(absoluteFilePath);
+  const absoluteFilePath = path4.isAbsolute(filePath) ? filePath : path4.resolve(process.cwd(), filePath);
+  const projectDir = path4.dirname(absoluteFilePath);
   const resolvedOutputDir = outputDir ?? projectDir;
-  const relativeComponentPath = path3.relative(projectDir, absoluteFilePath);
-  const baseFileName = outputFileName || path3.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
-  const outputPath = path3.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
+  const relativeComponentPath = path4.relative(projectDir, absoluteFilePath);
+  const baseFileName = outputFileName || path4.basename(absoluteFilePath).replace(/\.[^.]+$/, "");
+  const outputPath = path4.join(resolvedOutputDir, `${baseFileName}.circuit.json`);
   debug(`Project directory: ${projectDir}`);
   debug(`Relative component path: ${relativeComponentPath}`);
   debug(`Output path: ${outputPath}`);
@@ -11885,7 +12065,7 @@ async function generateCircuitJson({
           return false;
         if (normalizedFilePath.match(/^\.[^/]/))
           return false;
-        if (!ALLOWED_FILE_EXTENSIONS.includes(path3.extname(normalizedFilePath)))
+        if (!ALLOWED_FILE_EXTENSIONS.includes(path4.extname(normalizedFilePath)))
           return false;
         return true;
       },
@@ -11893,7 +12073,7 @@ async function generateCircuitJson({
     })
   };
   debug(`fsMap: ${abbreviateStringifyObject(fsMap)}`);
-  const MainComponent = await import(pathToFileURL(absoluteFilePath).href);
+  const MainComponent = await import(pathToFileURL2(absoluteFilePath).href);
   const Component = MainComponent.default || (Object.keys(MainComponent).find((k) => k[0] === k[0].toUpperCase()) !== undefined ? MainComponent[Object.keys(MainComponent).find((k) => k[0] === k[0].toUpperCase())] : undefined);
   if (!Component) {
     throw new Error(`No component found in "${absoluteFilePath}". Make sure you export a component.`);
@@ -11919,7 +12099,7 @@ async function generateCircuitJson({
   const circuitJson = await runner.getCircuitJson();
   if (saveToFile) {
     debug(`Saving circuit JSON to ${outputPath}`);
-    fs3.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    fs4.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
   }
   return {
     circuitJson,
@@ -11930,28 +12110,28 @@ async function generateCircuitJson({
 
 // lib/shared/get-platform-config-with-cli-defaults.ts
 import { createHash } from "node:crypto";
-import fs4 from "node:fs";
-import path4 from "node:path";
+import fs5 from "node:fs";
+import path5 from "node:path";
 import { getPlatformConfig } from "@tscircuit/eval/platform-config";
-function createLocalCacheEngine(cacheDir = path4.join(process.cwd(), ".tscircuit", "cache")) {
+function createLocalCacheEngine(cacheDir = path5.join(process.cwd(), ".tscircuit", "cache")) {
   return {
     getItem: (key) => {
       try {
         const hash = createHash("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path4.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        return fs4.readFileSync(filePath, "utf-8");
+        const filePath = path5.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        return fs5.readFileSync(filePath, "utf-8");
       } catch {
         return null;
       }
     },
     setItem: (key, value) => {
       try {
-        fs4.mkdirSync(cacheDir, { recursive: true });
+        fs5.mkdirSync(cacheDir, { recursive: true });
         const hash = createHash("md5").update(key).digest("hex");
         const keyWithSafeCharacters = key.replace(/[^a-zA-Z0-9]/g, "_");
-        const filePath = path4.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
-        fs4.writeFileSync(filePath, value);
+        const filePath = path5.join(cacheDir, `${keyWithSafeCharacters.slice(keyWithSafeCharacters.length - 10, keyWithSafeCharacters.length)}-${hash}.json`);
+        fs5.writeFileSync(filePath, value);
       } catch {}
     }
   };
@@ -11967,15 +12147,15 @@ function getPlatformConfigWithCliDefaults(userConfig) {
         loadFromUrl: async (url) => {
           let fetchUrl = url;
           if (url.startsWith("./") || url.startsWith("../")) {
-            const absolutePath = path4.resolve(process.cwd(), url);
+            const absolutePath = path5.resolve(process.cwd(), url);
             fetchUrl = `file://${absolutePath}`;
           } else if (url.startsWith("/")) {
-            if (fs4.existsSync(url)) {
+            if (fs5.existsSync(url)) {
               fetchUrl = `file://${url}`;
             } else {
               const relativePath = `.${url}`;
-              const absolutePath = path4.resolve(process.cwd(), relativePath);
-              if (fs4.existsSync(absolutePath)) {
+              const absolutePath = path5.resolve(process.cwd(), relativePath);
+              if (fs5.existsSync(absolutePath)) {
                 fetchUrl = `file://${absolutePath}`;
               } else {
                 fetchUrl = `file://${url}`;
@@ -12007,6 +12187,40 @@ function getPlatformConfigWithCliDefaults(userConfig) {
   return mergedConfig;
 }
 
+// lib/shared/platform-config-utils.ts
+var mergePlatformConfigs = (...configs) => {
+  const definedConfigs = configs.filter(Boolean);
+  if (definedConfigs.length === 0) {
+    return;
+  }
+  return definedConfigs.reduce((mergedConfig, config) => {
+    return {
+      ...mergedConfig,
+      ...config,
+      footprintLibraryMap: {
+        ...mergedConfig.footprintLibraryMap,
+        ...config.footprintLibraryMap
+      },
+      footprintFileParserMap: {
+        ...mergedConfig.footprintFileParserMap,
+        ...config.footprintFileParserMap
+      },
+      staticFileLoaderMap: {
+        ...mergedConfig.staticFileLoaderMap,
+        ...config.staticFileLoaderMap
+      },
+      autorouterMap: {
+        ...mergedConfig.autorouterMap,
+        ...config.autorouterMap
+      },
+      spiceEngineMap: {
+        ...mergedConfig.spiceEngineMap,
+        ...config.spiceEngineMap
+      }
+    };
+  }, {});
+};
+
 // cli/build/drc-diagnostic-filter.ts
 import {
   categorizeErrorOrWarning
@@ -12166,8 +12380,8 @@ var resolveImageFormatSelection = (options) => {
 };
 
 // cli/build/worker-output-generators.ts
-import fs9 from "node:fs";
-import path13 from "node:path";
+import fs10 from "node:fs";
+import path14 from "node:path";
 
 // node_modules/circuit-json-to-3d-png/dist/index.js
 function normalizeDir(dir) {
@@ -12450,12 +12664,12 @@ var Axis2Placement3D = class _Axis2Placement3D extends Entity {
 };
 register("AXIS2_PLACEMENT_3D", Axis2Placement3D.parse.bind(Axis2Placement3D));
 var CartesianPoint = class _CartesianPoint extends Entity {
-  constructor(name, x, y, z) {
+  constructor(name, x, y, z2) {
     super();
     this.name = name;
     this.x = x;
     this.y = y;
-    this.z = z;
+    this.z = z2;
   }
   type = "CARTESIAN_POINT";
   static parse(a, ctx) {
@@ -13459,22 +13673,22 @@ function createStyledItems(repo, options) {
 function rotatePoint3(point, rotation) {
   if (!rotation)
     return point;
-  let { x, y, z } = point;
+  let { x, y, z: z2 } = point;
   if (rotation.x) {
     const cos = Math.cos(rotation.x);
     const sin = Math.sin(rotation.x);
-    const nextY = y * cos - z * sin;
-    const nextZ = y * sin + z * cos;
+    const nextY = y * cos - z2 * sin;
+    const nextZ = y * sin + z2 * cos;
     y = nextY;
-    z = nextZ;
+    z2 = nextZ;
   }
   if (rotation.y) {
     const cos = Math.cos(rotation.y);
     const sin = Math.sin(rotation.y);
-    const nextX = x * cos + z * sin;
-    const nextZ = -x * sin + z * cos;
+    const nextX = x * cos + z2 * sin;
+    const nextZ = -x * sin + z2 * cos;
     x = nextX;
-    z = nextZ;
+    z2 = nextZ;
   }
   if (rotation.z) {
     const cos = Math.cos(rotation.z);
@@ -13484,7 +13698,7 @@ function rotatePoint3(point, rotation) {
     x = nextX;
     y = nextY;
   }
-  return { x, y, z };
+  return { x, y, z: z2 };
 }
 function createVertex(repo, point) {
   return repo.add(new VertexPoint("", repo.add(new CartesianPoint("", point.x, point.y, point.z))));
@@ -13722,22 +13936,22 @@ function transformDirection(vector, rotation) {
   return rotateVector(vector, rotation);
 }
 function rotateVector(vector, rotation) {
-  let [x, y, z] = vector;
+  let [x, y, z2] = vector;
   if (rotation.x !== 0) {
     const cosX = Math.cos(rotation.x);
     const sinX = Math.sin(rotation.x);
-    const y1 = y * cosX - z * sinX;
-    const z1 = y * sinX + z * cosX;
+    const y1 = y * cosX - z2 * sinX;
+    const z1 = y * sinX + z2 * cosX;
     y = y1;
-    z = z1;
+    z2 = z1;
   }
   if (rotation.y !== 0) {
     const cosY = Math.cos(rotation.y);
     const sinY = Math.sin(rotation.y);
-    const x1 = x * cosY + z * sinY;
-    const z1 = -x * sinY + z * cosY;
+    const x1 = x * cosY + z2 * sinY;
+    const z1 = -x * sinY + z2 * cosY;
     x = x1;
-    z = z1;
+    z2 = z1;
   }
   if (rotation.z !== 0) {
     const cosZ = Math.cos(rotation.z);
@@ -13747,7 +13961,7 @@ function rotateVector(vector, rotation) {
     x = x1;
     y = y1;
   }
-  return [x, y, z];
+  return [x, y, z2];
 }
 async function readStepFile(modelUrl) {
   if (!/^https?:\/\//i.test(modelUrl)) {
@@ -13927,19 +14141,19 @@ function adjustTransformForPlacement(entries, transform, placement) {
   let maxY = -Infinity;
   let maxZ = -Infinity;
   for (const point of points) {
-    const [x, y, z] = rotateVector(point, rotationRadians);
+    const [x, y, z2] = rotateVector(point, rotationRadians);
     if (x < minX)
       minX = x;
     if (y < minY)
       minY = y;
-    if (z < minZ)
-      minZ = z;
+    if (z2 < minZ)
+      minZ = z2;
     if (x > maxX)
       maxX = x;
     if (y > maxY)
       maxY = y;
-    if (z > maxZ)
-      maxZ = z;
+    if (z2 > maxZ)
+      maxZ = z2;
   }
   if (!Number.isFinite(minX))
     return;
@@ -14169,21 +14383,21 @@ function rotatePoint(x, y, centerX, centerY, angle) {
     y: centerY + dx * sin + dy * cos
   };
 }
-function createVertexAt(repo, x, y, z) {
-  return repo.add(new VertexPoint("", repo.add(new CartesianPoint("", x, y, z))));
+function createVertexAt(repo, x, y, z2) {
+  return repo.add(new VertexPoint("", repo.add(new CartesianPoint("", x, y, z2))));
 }
-function createVertexCache(repo, z) {
+function createVertexCache(repo, z2) {
   const vertices = /* @__PURE__ */ new Map;
   const normalize = (value) => {
     const rounded = Number(value.toFixed(9));
     return Object.is(rounded, -0) ? 0 : rounded;
   };
   return (x, y) => {
-    const key = `${normalize(x)},${normalize(y)},${normalize(z)}`;
+    const key = `${normalize(x)},${normalize(y)},${normalize(z2)}`;
     const existing = vertices.get(key);
     if (existing)
       return existing;
-    const vertex = createVertexAt(repo, x, y, z);
+    const vertex = createVertexAt(repo, x, y, z2);
     vertices.set(key, vertex);
     return vertex;
   };
@@ -14216,13 +14430,13 @@ function createLineSegment(repo, start, end, getVertex) {
     end: endVertex
   };
 }
-function createArcSegment(repo, centerX, centerY, z, radius, startAngle, endAngle, rotation, centerX0, centerY0, getVertex) {
+function createArcSegment(repo, centerX, centerY, z2, radius, startAngle, endAngle, rotation, centerX0, centerY0, getVertex) {
   const start = rotatePoint(centerX + radius * Math.cos(startAngle), centerY + radius * Math.sin(startAngle), centerX0, centerY0, rotation);
   const end = rotatePoint(centerX + radius * Math.cos(endAngle), centerY + radius * Math.sin(endAngle), centerX0, centerY0, rotation);
   const center = rotatePoint(centerX, centerY, centerX0, centerY0, rotation);
   const startVertex = getVertex(start.x, start.y);
   const endVertex = getVertex(end.x, end.y);
-  const centerPoint = repo.add(new CartesianPoint("", center.x, center.y, z));
+  const centerPoint = repo.add(new CartesianPoint("", center.x, center.y, z2));
   const normalDir = repo.add(new Direction("", 0, 0, -1));
   const refDir = repo.add(new Direction("", Math.cos(rotation), Math.sin(rotation), 0));
   const placement = repo.add(new Axis2Placement3D("", centerPoint, normalDir, refDir));
@@ -14237,7 +14451,7 @@ function createArcSegment(repo, centerX, centerY, z, radius, startAngle, endAngl
     radius
   };
 }
-function createPillBoundarySegments(repo, hole, z) {
+function createPillBoundarySegments(repo, hole, z2) {
   const geom = getPillGeometry(hole);
   const {
     centerX,
@@ -14248,19 +14462,19 @@ function createPillBoundarySegments(repo, hole, z) {
     isHorizontal
   } = geom;
   const capOffset = straightHalfLength;
-  const getVertex = createVertexCache(repo, z);
+  const getVertex = createVertexCache(repo, z2);
   if (isHorizontal) {
     return [
-      createArcSegment(repo, centerX + capOffset, centerY, z, radius, -Math.PI / 2, Math.PI / 2, rotation, centerX, centerY, getVertex),
+      createArcSegment(repo, centerX + capOffset, centerY, z2, radius, -Math.PI / 2, Math.PI / 2, rotation, centerX, centerY, getVertex),
       createLineSegment(repo, rotatePoint(centerX + capOffset, centerY - radius, centerX, centerY, rotation), rotatePoint(centerX - capOffset, centerY - radius, centerX, centerY, rotation), getVertex),
-      createArcSegment(repo, centerX - capOffset, centerY, z, radius, Math.PI / 2, 3 * Math.PI / 2, rotation, centerX, centerY, getVertex),
+      createArcSegment(repo, centerX - capOffset, centerY, z2, radius, Math.PI / 2, 3 * Math.PI / 2, rotation, centerX, centerY, getVertex),
       createLineSegment(repo, rotatePoint(centerX - capOffset, centerY + radius, centerX, centerY, rotation), rotatePoint(centerX + capOffset, centerY + radius, centerX, centerY, rotation), getVertex)
     ];
   }
   return [
-    createArcSegment(repo, centerX, centerY - capOffset, z, radius, Math.PI, 0, rotation, centerX, centerY, getVertex),
+    createArcSegment(repo, centerX, centerY - capOffset, z2, radius, Math.PI, 0, rotation, centerX, centerY, getVertex),
     createLineSegment(repo, rotatePoint(centerX + radius, centerY - capOffset, centerX, centerY, rotation), rotatePoint(centerX + radius, centerY + capOffset, centerX, centerY, rotation), getVertex),
-    createArcSegment(repo, centerX, centerY + capOffset, z, radius, 0, Math.PI, rotation, centerX, centerY, getVertex),
+    createArcSegment(repo, centerX, centerY + capOffset, z2, radius, 0, Math.PI, rotation, centerX, centerY, getVertex),
     createLineSegment(repo, rotatePoint(centerX - radius, centerY + capOffset, centerX, centerY, rotation), rotatePoint(centerX - radius, centerY - capOffset, centerX, centerY, rotation), getVertex)
   ];
 }
@@ -14407,7 +14621,7 @@ async function circuitJsonToStep(circuitJson, options = {}) {
       [boardCenterX + halfWidth, boardCenterY + halfHeight, halfBoardThickness],
       [boardCenterX - halfWidth, boardCenterY + halfHeight, halfBoardThickness]
     ];
-    const vertices = corners.map(([x, y, z]) => repo.add(new VertexPoint("", repo.add(new CartesianPoint("", x, y, z)))));
+    const vertices = corners.map(([x, y, z2]) => repo.add(new VertexPoint("", repo.add(new CartesianPoint("", x, y, z2)))));
     bottomVertices = [vertices[0], vertices[1], vertices[2], vertices[3]];
     topVertices = [vertices[4], vertices[5], vertices[6], vertices[7]];
   }
@@ -14648,8 +14862,8 @@ import {
 // node_modules/conf/dist/source/index.js
 import { isDeepStrictEqual } from "node:util";
 import process7 from "node:process";
-import fs6 from "node:fs";
-import path8 from "node:path";
+import fs7 from "node:fs";
+import path9 from "node:path";
 import crypto from "node:crypto";
 import assert from "node:assert";
 
@@ -14664,12 +14878,12 @@ var disallowedKeys = new Set([
   "constructor"
 ]);
 var digits = new Set("0123456789");
-function getPathSegments(path5) {
+function getPathSegments(path6) {
   const parts = [];
   let currentSegment = "";
   let currentPart = "start";
   let isIgnoring = false;
-  for (const character of path5) {
+  for (const character of path6) {
     switch (character) {
       case "\\": {
         if (currentPart === "index") {
@@ -14791,11 +15005,11 @@ function assertNotStringIndex(object, key) {
     throw new Error("Cannot use string index");
   }
 }
-function getProperty(object, path5, value) {
-  if (!isObject(object) || typeof path5 !== "string") {
+function getProperty(object, path6, value) {
+  if (!isObject(object) || typeof path6 !== "string") {
     return value === undefined ? object : value;
   }
-  const pathArray = getPathSegments(path5);
+  const pathArray = getPathSegments(path6);
   if (pathArray.length === 0) {
     return value;
   }
@@ -14815,12 +15029,12 @@ function getProperty(object, path5, value) {
   }
   return object === undefined ? value : object;
 }
-function setProperty(object, path5, value) {
-  if (!isObject(object) || typeof path5 !== "string") {
+function setProperty(object, path6, value) {
+  if (!isObject(object) || typeof path6 !== "string") {
     return object;
   }
   const root = object;
-  const pathArray = getPathSegments(path5);
+  const pathArray = getPathSegments(path6);
   for (let index = 0;index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -14833,11 +15047,11 @@ function setProperty(object, path5, value) {
   }
   return root;
 }
-function deleteProperty(object, path5) {
-  if (!isObject(object) || typeof path5 !== "string") {
+function deleteProperty(object, path6) {
+  if (!isObject(object) || typeof path6 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path5);
+  const pathArray = getPathSegments(path6);
   for (let index = 0;index < pathArray.length; index++) {
     const key = pathArray[index];
     assertNotStringIndex(object, key);
@@ -14851,11 +15065,11 @@ function deleteProperty(object, path5) {
     }
   }
 }
-function hasProperty(object, path5) {
-  if (!isObject(object) || typeof path5 !== "string") {
+function hasProperty(object, path6) {
+  if (!isObject(object) || typeof path6 !== "string") {
     return false;
   }
-  const pathArray = getPathSegments(path5);
+  const pathArray = getPathSegments(path6);
   if (pathArray.length === 0) {
     return false;
   }
@@ -14869,41 +15083,41 @@ function hasProperty(object, path5) {
 }
 
 // node_modules/env-paths/index.js
-import path5 from "node:path";
+import path6 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 = path5.join(homedir, "Library");
+  const library = path6.join(homedir, "Library");
   return {
-    data: path5.join(library, "Application Support", name),
-    config: path5.join(library, "Preferences", name),
-    cache: path5.join(library, "Caches", name),
-    log: path5.join(library, "Logs", name),
-    temp: path5.join(tmpdir, name)
+    data: path6.join(library, "Application Support", name),
+    config: path6.join(library, "Preferences", name),
+    cache: path6.join(library, "Caches", name),
+    log: path6.join(library, "Logs", name),
+    temp: path6.join(tmpdir, name)
   };
 };
 var windows = (name) => {
-  const appData = env.APPDATA || path5.join(homedir, "AppData", "Roaming");
-  const localAppData = env.LOCALAPPDATA || path5.join(homedir, "AppData", "Local");
+  const appData = env.APPDATA || path6.join(homedir, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path6.join(homedir, "AppData", "Local");
   return {
-    data: path5.join(localAppData, name, "Data"),
-    config: path5.join(appData, name, "Config"),
-    cache: path5.join(localAppData, name, "Cache"),
-    log: path5.join(localAppData, name, "Log"),
-    temp: path5.join(tmpdir, name)
+    data: path6.join(localAppData, name, "Data"),
+    config: path6.join(appData, name, "Config"),
+    cache: path6.join(localAppData, name, "Cache"),
+    log: path6.join(localAppData, name, "Log"),
+    temp: path6.join(tmpdir, name)
   };
 };
 var linux = (name) => {
-  const username = path5.basename(homedir);
+  const username = path6.basename(homedir);
   return {
-    data: path5.join(env.XDG_DATA_HOME || path5.join(homedir, ".local", "share"), name),
-    config: path5.join(env.XDG_CONFIG_HOME || path5.join(homedir, ".config"), name),
-    cache: path5.join(env.XDG_CACHE_HOME || path5.join(homedir, ".cache"), name),
-    log: path5.join(env.XDG_STATE_HOME || path5.join(homedir, ".local", "state"), name),
-    temp: path5.join(tmpdir, username, name)
+    data: path6.join(env.XDG_DATA_HOME || path6.join(homedir, ".local", "share"), name),
+    config: path6.join(env.XDG_CONFIG_HOME || path6.join(homedir, ".config"), name),
+    cache: path6.join(env.XDG_CACHE_HOME || path6.join(homedir, ".cache"), name),
+    log: path6.join(env.XDG_STATE_HOME || path6.join(homedir, ".local", "state"), name),
+    temp: path6.join(tmpdir, username, name)
   };
 };
 function envPaths(name, { suffix = "nodejs" } = {}) {
@@ -14923,10 +15137,10 @@ function envPaths(name, { suffix = "nodejs" } = {}) {
 }
 
 // node_modules/atomically/dist/index.js
-import path7 from "node:path";
+import path8 from "node:path";
 
 // node_modules/stubborn-fs/dist/index.js
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import { promisify } from "node:util";
 
 // node_modules/stubborn-utils/dist/attemptify_async.js
@@ -15056,41 +15270,41 @@ var RETRYIFY_OPTIONS = {
 // node_modules/stubborn-fs/dist/index.js
 var FS = {
   attempt: {
-    chmod: attemptify_async_default(promisify(fs5.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    chown: attemptify_async_default(promisify(fs5.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    close: attemptify_async_default(promisify(fs5.close), ATTEMPTIFY_NOOP_OPTIONS),
-    fsync: attemptify_async_default(promisify(fs5.fsync), ATTEMPTIFY_NOOP_OPTIONS),
-    mkdir: attemptify_async_default(promisify(fs5.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
-    realpath: attemptify_async_default(promisify(fs5.realpath), ATTEMPTIFY_NOOP_OPTIONS),
-    stat: attemptify_async_default(promisify(fs5.stat), ATTEMPTIFY_NOOP_OPTIONS),
-    unlink: attemptify_async_default(promisify(fs5.unlink), ATTEMPTIFY_NOOP_OPTIONS),
-    chmodSync: attemptify_sync_default(fs5.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    chownSync: attemptify_sync_default(fs5.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-    closeSync: attemptify_sync_default(fs5.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
-    existsSync: attemptify_sync_default(fs5.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
-    fsyncSync: attemptify_sync_default(fs5.fsync, ATTEMPTIFY_NOOP_OPTIONS),
-    mkdirSync: attemptify_sync_default(fs5.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
-    realpathSync: attemptify_sync_default(fs5.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
-    statSync: attemptify_sync_default(fs5.statSync, ATTEMPTIFY_NOOP_OPTIONS),
-    unlinkSync: attemptify_sync_default(fs5.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
+    chmod: attemptify_async_default(promisify(fs6.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chown: attemptify_async_default(promisify(fs6.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    close: attemptify_async_default(promisify(fs6.close), ATTEMPTIFY_NOOP_OPTIONS),
+    fsync: attemptify_async_default(promisify(fs6.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+    mkdir: attemptify_async_default(promisify(fs6.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+    realpath: attemptify_async_default(promisify(fs6.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+    stat: attemptify_async_default(promisify(fs6.stat), ATTEMPTIFY_NOOP_OPTIONS),
+    unlink: attemptify_async_default(promisify(fs6.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+    chmodSync: attemptify_sync_default(fs6.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chownSync: attemptify_sync_default(fs6.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    closeSync: attemptify_sync_default(fs6.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+    existsSync: attemptify_sync_default(fs6.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+    fsyncSync: attemptify_sync_default(fs6.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+    mkdirSync: attemptify_sync_default(fs6.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+    realpathSync: attemptify_sync_default(fs6.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+    statSync: attemptify_sync_default(fs6.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+    unlinkSync: attemptify_sync_default(fs6.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
   },
   retry: {
-    close: retryify_async_default(promisify(fs5.close), RETRYIFY_OPTIONS),
-    fsync: retryify_async_default(promisify(fs5.fsync), RETRYIFY_OPTIONS),
-    open: retryify_async_default(promisify(fs5.open), RETRYIFY_OPTIONS),
-    readFile: retryify_async_default(promisify(fs5.readFile), RETRYIFY_OPTIONS),
-    rename: retryify_async_default(promisify(fs5.rename), RETRYIFY_OPTIONS),
-    stat: retryify_async_default(promisify(fs5.stat), RETRYIFY_OPTIONS),
-    write: retryify_async_default(promisify(fs5.write), RETRYIFY_OPTIONS),
-    writeFile: retryify_async_default(promisify(fs5.writeFile), RETRYIFY_OPTIONS),
-    closeSync: retryify_sync_default(fs5.closeSync, RETRYIFY_OPTIONS),
-    fsyncSync: retryify_sync_default(fs5.fsyncSync, RETRYIFY_OPTIONS),
-    openSync: retryify_sync_default(fs5.openSync, RETRYIFY_OPTIONS),
-    readFileSync: retryify_sync_default(fs5.readFileSync, RETRYIFY_OPTIONS),
-    renameSync: retryify_sync_default(fs5.renameSync, RETRYIFY_OPTIONS),
-    statSync: retryify_sync_default(fs5.statSync, RETRYIFY_OPTIONS),
-    writeSync: retryify_sync_default(fs5.writeSync, RETRYIFY_OPTIONS),
-    writeFileSync: retryify_sync_default(fs5.writeFileSync, RETRYIFY_OPTIONS)
+    close: retryify_async_default(promisify(fs6.close), RETRYIFY_OPTIONS),
+    fsync: retryify_async_default(promisify(fs6.fsync), RETRYIFY_OPTIONS),
+    open: retryify_async_default(promisify(fs6.open), RETRYIFY_OPTIONS),
+    readFile: retryify_async_default(promisify(fs6.readFile), RETRYIFY_OPTIONS),
+    rename: retryify_async_default(promisify(fs6.rename), RETRYIFY_OPTIONS),
+    stat: retryify_async_default(promisify(fs6.stat), RETRYIFY_OPTIONS),
+    write: retryify_async_default(promisify(fs6.write), RETRYIFY_OPTIONS),
+    writeFile: retryify_async_default(promisify(fs6.writeFile), RETRYIFY_OPTIONS),
+    closeSync: retryify_sync_default(fs6.closeSync, RETRYIFY_OPTIONS),
+    fsyncSync: retryify_sync_default(fs6.fsyncSync, RETRYIFY_OPTIONS),
+    openSync: retryify_sync_default(fs6.openSync, RETRYIFY_OPTIONS),
+    readFileSync: retryify_sync_default(fs6.readFileSync, RETRYIFY_OPTIONS),
+    renameSync: retryify_sync_default(fs6.renameSync, RETRYIFY_OPTIONS),
+    statSync: retryify_sync_default(fs6.statSync, RETRYIFY_OPTIONS),
+    writeSync: retryify_sync_default(fs6.writeSync, RETRYIFY_OPTIONS),
+    writeFileSync: retryify_sync_default(fs6.writeFileSync, RETRYIFY_OPTIONS)
   }
 };
 var dist_default = FS;
@@ -15120,7 +15334,7 @@ var isUndefined = (value) => {
 };
 
 // node_modules/atomically/dist/utils/temp.js
-import path6 from "node:path";
+import path7 from "node:path";
 
 // node_modules/when-exit/dist/node/interceptor.js
 import process6 from "node:process";
@@ -15220,7 +15434,7 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename = path6.basename(filePath);
+    const basename = path7.basename(filePath);
     if (basename.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
     const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename);
@@ -15234,9 +15448,9 @@ node_default(Temp.purgeSyncAll);
 var temp_default = Temp;
 
 // node_modules/atomically/dist/index.js
-function writeFileSync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
+function writeFileSync2(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
   if (isString(options))
-    return writeFileSync(filePath, data, { encoding: options });
+    return writeFileSync2(filePath, data, { encoding: options });
   const timeout = options.timeout ?? DEFAULT_TIMEOUT_SYNC;
   const retryOptions = { timeout };
   let tempDisposer = null;
@@ -15262,7 +15476,7 @@ function writeFileSync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
       }
     }
     if (!filePathExists) {
-      const parentPath = path7.dirname(filePath);
+      const parentPath = path8.dirname(filePath);
       dist_default.attempt.mkdirSync(parentPath, {
         mode: DEFAULT_FOLDER_MODE,
         recursive: true
@@ -15578,7 +15792,7 @@ class Conf {
     this.events = new EventTarget;
     this.#encryptionKey = options.encryptionKey;
     const fileExtension = options.fileExtension ? `.${options.fileExtension}` : "";
-    this.path = path8.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
+    this.path = path9.resolve(options.cwd, `${options.configName ?? "config"}${fileExtension}`);
     const fileStore = this.store;
     const store = Object.assign(createPlainObject(), options.defaults, fileStore);
     if (options.migrations) {
@@ -15681,7 +15895,7 @@ class Conf {
   }
   get store() {
     try {
-      const data = fs6.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
+      const data = fs7.readFileSync(this.path, this.#encryptionKey ? null : "utf8");
       const dataString = this._encryptData(data);
       const deserializedData = this._deserialize(dataString);
       this._validate(deserializedData);
@@ -15752,7 +15966,7 @@ class Conf {
     throw new Error("Config schema violation: " + errors.join("; "));
   }
   _ensureDirectory() {
-    fs6.mkdirSync(path8.dirname(this.path), { recursive: true });
+    fs7.mkdirSync(path9.dirname(this.path), { recursive: true });
   }
   _write(value) {
     let data = this._serialize(value);
@@ -15763,13 +15977,13 @@ class Conf {
       data = concatUint8Arrays([initializationVector, stringToUint8Array(":"), cipher.update(stringToUint8Array(data)), cipher.final()]);
     }
     if (process7.env.SNAP) {
-      fs6.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+      fs7.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
     } else {
       try {
-        writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+        writeFileSync2(this.path, data, { mode: this.#options.configFileMode });
       } catch (error) {
         if (error?.code === "EXDEV") {
-          fs6.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
+          fs7.writeFileSync(this.path, data, { mode: this.#options.configFileMode });
           return;
         }
         throw error;
@@ -15778,15 +15992,15 @@ class Conf {
   }
   _watch() {
     this._ensureDirectory();
-    if (!fs6.existsSync(this.path)) {
+    if (!fs7.existsSync(this.path)) {
       this._write(createPlainObject());
     }
     if (process7.platform === "win32") {
-      fs6.watch(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs7.watch(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 100 }));
     } else {
-      fs6.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
+      fs7.watchFile(this.path, { persistent: false }, debounce_fn_default(() => {
         this.events.dispatchEvent(new Event("change"));
       }, { wait: 5000 }));
     }
@@ -15922,14 +16136,14 @@ function jwtDecode(token, options) {
 }
 
 // lib/cli-config/index.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import os3 from "node:os";
-import path10 from "node:path";
+import path11 from "node:path";
 
 // lib/shared/handle-registry-auth-error.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import os2 from "node:os";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // node_modules/kleur/index.mjs
 var FORCE_COLOR;
@@ -16049,9 +16263,9 @@ function isUnauthorizedError(error) {
   return /\b(401|E401)\b/i.test(output) || /unauthorized/i.test(output);
 }
 function hasTsciAuthToken(npmrcPath) {
-  if (!fs7.existsSync(npmrcPath))
+  if (!fs8.existsSync(npmrcPath))
     return false;
-  const content = fs7.readFileSync(npmrcPath, "utf-8");
+  const content = fs8.readFileSync(npmrcPath, "utf-8");
   return AUTH_TOKEN_REGEX.test(content);
 }
 function handleRegistryAuthError({
@@ -16061,8 +16275,8 @@ function handleRegistryAuthError({
   if (!isUnauthorizedError(error))
     return;
   const npmrcPaths = [
-    path9.join(projectDir, ".npmrc"),
-    path9.join(os2.homedir(), ".npmrc")
+    path10.join(projectDir, ".npmrc"),
+    path10.join(os2.homedir(), ".npmrc")
   ];
   const hasToken = npmrcPaths.some(hasTsciAuthToken);
   if (hasToken) {
@@ -16085,13 +16299,13 @@ var getSessionToken = () => {
 };
 var getSessionTokenFromNpmrc = () => {
   const npmrcPaths = [
-    path10.join(process.cwd(), ".npmrc"),
-    path10.join(os3.homedir(), ".npmrc")
+    path11.join(process.cwd(), ".npmrc"),
+    path11.join(os3.homedir(), ".npmrc")
   ];
   for (const npmrcPath of npmrcPaths) {
-    if (!fs8.existsSync(npmrcPath))
+    if (!fs9.existsSync(npmrcPath))
       continue;
-    const content = fs8.readFileSync(npmrcPath, "utf-8");
+    const content = fs9.readFileSync(npmrcPath, "utf-8");
     const match = content.match(AUTH_TOKEN_REGEX);
     if (match?.[1]) {
       return match[1].trim();
@@ -16129,8 +16343,8 @@ var getCircuitJsonToGltfOptions = ({
 };
 
 // cli/build/convert-model-urls-to-file-urls.ts
-import path11 from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
+import path12 from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
 var convertModelUrlsToFileUrls = (circuitJson) => {
   const modelUrlKeys2 = [
     "model_glb_url",
@@ -16154,9 +16368,9 @@ var convertModelUrlsToFileUrls = (circuitJson) => {
         if (value.match(/^[a-zA-Z]+:\/\//))
           continue;
         if (value.startsWith("/") || value.match(/^[a-zA-Z]:\\/)) {
-          updated[key] = pathToFileURL2(value).href;
+          updated[key] = pathToFileURL3(value).href;
         } else if (value.startsWith(".")) {
-          updated[key] = pathToFileURL2(path11.resolve(process.cwd(), value)).href;
+          updated[key] = pathToFileURL3(path12.resolve(process.cwd(), value)).href;
         }
       }
     }
@@ -16195,9 +16409,9 @@ var convertSvgToPngBuffer = async (svg) => {
 };
 
 // lib/shared/load-local-step-model-fs-map.ts
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import { readFile } from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 var isRemoteUrl = (value) => /^https?:\/\//i.test(value);
 async function loadLocalStepModelFsMap(circuitJson) {
   const fsMap = {};
@@ -16209,8 +16423,8 @@ async function loadLocalStepModelFsMap(circuitJson) {
       continue;
     if (isRemoteUrl(modelUrl) || fsMap[modelUrl])
       continue;
-    const localPath = path12.resolve(process.cwd(), modelUrl);
-    if (!existsSync(localPath))
+    const localPath = path13.resolve(process.cwd(), modelUrl);
+    if (!existsSync2(localPath))
       continue;
     fsMap[modelUrl] = await readFile(localPath, "utf-8");
   }
@@ -16265,10 +16479,10 @@ var writeSimulationSvgAssetsFromCircuitJson = (circuitJson, outputDir, imageForm
   if (!simulationSvgAssets)
     return false;
   if (imageFormats.simulationSvgs) {
-    fs9.writeFileSync(path13.join(outputDir, "simulation.svg"), simulationSvgAssets.simulationSvg, "utf-8");
+    fs10.writeFileSync(path14.join(outputDir, "simulation.svg"), simulationSvgAssets.simulationSvg, "utf-8");
   }
   if (imageFormats.simulationSchematicSvgs) {
-    fs9.writeFileSync(path13.join(outputDir, "simulation-schematic.svg"), simulationSvgAssets.schematicSimulationSvg, "utf-8");
+    fs10.writeFileSync(path14.join(outputDir, "simulation-schematic.svg"), simulationSvgAssets.schematicSimulationSvg, "utf-8");
   }
   return true;
 };
@@ -16276,8 +16490,8 @@ var writeGlbFromCircuitJson = async (circuitJson, glbOutputPath) => {
   const circuitJsonWithFileUrls = convertModelUrlsToFileUrls(circuitJson);
   const glbBuffer = await convertCircuitJsonToGltf(circuitJsonWithFileUrls, getCircuitJsonToGltfOptions({ format: "glb" }));
   const glbData = normalizeToUint8Array2(glbBuffer);
-  fs9.mkdirSync(path13.dirname(glbOutputPath), { recursive: true });
-  fs9.writeFileSync(glbOutputPath, Buffer.from(glbData));
+  fs10.mkdirSync(path14.dirname(glbOutputPath), { recursive: true });
+  fs10.writeFileSync(glbOutputPath, Buffer.from(glbData));
 };
 var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
   const stepContent = await circuitJsonToStep(circuitJson, {
@@ -16285,34 +16499,34 @@ var writeStepFromCircuitJson = async (circuitJson, stepOutputPath) => {
     includeExternalMeshes: true,
     fsMap: await loadLocalStepModelFsMap(circuitJson)
   });
-  fs9.mkdirSync(path13.dirname(stepOutputPath), { recursive: true });
-  fs9.writeFileSync(stepOutputPath, stepContent);
+  fs10.mkdirSync(path14.dirname(stepOutputPath), { recursive: true });
+  fs10.writeFileSync(stepOutputPath, stepContent);
 };
 var writeImageAssetsFromCircuitJson = async (circuitJson, options) => {
   const { outputDir, imageFormats, pcbSnapshotSettings } = options;
-  fs9.mkdirSync(outputDir, { recursive: true });
+  fs10.mkdirSync(outputDir, { recursive: true });
   if (imageFormats.pcbSvgs) {
     const pcbSvg = convertCircuitJsonToPcbSvg(circuitJson, pcbSnapshotSettings);
-    fs9.writeFileSync(path13.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
+    fs10.writeFileSync(path14.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
   }
   if (imageFormats.pcbPngs) {
     const pcbSvg = convertCircuitJsonToPcbSvg(circuitJson, pcbSnapshotSettings);
-    fs9.writeFileSync(path13.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
+    fs10.writeFileSync(path14.join(outputDir, "pcb.png"), await convertSvgToPngBuffer(pcbSvg));
   }
   if (imageFormats.schematicSvgs) {
     const schematicSvg = convertCircuitJsonToSchematicSvg(circuitJson);
-    fs9.writeFileSync(path13.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
+    fs10.writeFileSync(path14.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
   }
   writeSimulationSvgAssetsFromCircuitJson(circuitJson, outputDir, imageFormats);
   if (imageFormats.threeDPngs) {
     const pngBuffer = await renderCircuitJsonTo3dPng(circuitJson);
-    fs9.writeFileSync(path13.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
+    fs10.writeFileSync(path14.join(outputDir, "3d.png"), Buffer.from(pngBuffer));
   }
 };
 
 // cli/build/worker-build-handlers.ts
 var loadCircuitJsonFromInputFile = (filePath) => {
-  const parsed = JSON.parse(fs10.readFileSync(filePath, "utf-8"));
+  const parsed = JSON.parse(fs11.readFileSync(filePath, "utf-8"));
   return Array.isArray(parsed) ? parsed : [];
 };
 var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath, previewOutputDir, projectDir, options, workerLog, workerStatus) => {
@@ -16321,9 +16535,11 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
   const startedAt = options?.profile ? performance.now() : 0;
   try {
     process.chdir(projectDir);
-    workerLog(`Generating circuit JSON for ${path14.relative(projectDir, filePath)}...`);
+    workerLog(`Generating circuit JSON for ${path15.relative(projectDir, filePath)}...`);
     await registerStaticAssetLoaders();
-    const platformConfigWithCliDefaults = getPlatformConfigWithCliDefaults(options?.platformConfig);
+    const projectConfig = await loadRuntimeProjectConfig(projectDir);
+    const platformConfig = mergePlatformConfigs(projectConfig?.platformConfig, options?.platformConfig);
+    const platformConfigWithCliDefaults = getPlatformConfigWithCliDefaults(platformConfig);
     const normalizedInputPath = filePath.toLowerCase().replaceAll("\\", "/");
     const isPrebuiltCircuitJson = normalizedInputPath.endsWith(".circuit.json") || normalizedInputPath.endsWith("/circuit.json");
     const circuitJson = isPrebuiltCircuitJson ? loadCircuitJsonFromInputFile(filePath) : (await generateCircuitJson({
@@ -16334,9 +16550,9 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
         workerStatus(`waiting on ${asyncEffectName}…`);
       }
     })).circuitJson;
-    fs10.mkdirSync(path14.dirname(outputPath), { recursive: true });
-    fs10.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
-    workerLog(`Circuit JSON written to ${path14.relative(projectDir, outputPath)}`);
+    fs11.mkdirSync(path15.dirname(outputPath), { recursive: true });
+    fs11.writeFileSync(outputPath, JSON.stringify(circuitJson, null, 2));
+    workerLog(`Circuit JSON written to ${path15.relative(projectDir, outputPath)}`);
     const diagnostics = analyzeCircuitJson(circuitJson);
     const filteredDiagnostics = filterDiagnosticsByDrcCategory({
       errors: diagnostics.errors,
@@ -16366,7 +16582,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     let previewError;
     if (glbOutputPath) {
       try {
-        workerLog(`Converting ${path14.relative(projectDir, outputPath)} to GLB in same worker...`);
+        workerLog(`Converting ${path15.relative(projectDir, outputPath)} to GLB in same worker...`);
         await writeGlbFromCircuitJson(circuitJson, glbOutputPath);
         glbOk = true;
       } catch (err) {
@@ -16377,7 +16593,7 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (stepOutputPath) {
       try {
-        workerLog(`Converting ${path14.relative(projectDir, outputPath)} to STEP in same worker...`);
+        workerLog(`Converting ${path15.relative(projectDir, outputPath)} to STEP in same worker...`);
         await writeStepFromCircuitJson(circuitJson, stepOutputPath);
         stepOk = true;
       } catch (err) {
@@ -16388,8 +16604,8 @@ var handleBuildFile = async (filePath, outputPath, glbOutputPath, stepOutputPath
     }
     if (options?.generatePreviewAssets) {
       try {
-        const resolvedPreviewOutputDir = previewOutputDir ?? path14.dirname(outputPath);
-        workerLog(`Generating preview assets for ${path14.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
+        const resolvedPreviewOutputDir = previewOutputDir ?? path15.dirname(outputPath);
+        workerLog(`Generating preview assets for ${path15.relative(projectDir, resolvedPreviewOutputDir)} in same worker...`);
         await writeImageAssetsFromCircuitJson(circuitJson, {
           outputDir: resolvedPreviewOutputDir,
           imageFormats: options?.imageFormats ?? DEFAULT_IMAGE_FORMAT_SELECTION,

package/dist/cli/main.js

@@ -93628,7 +93628,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1609";
+var version = "0.1.1610";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -109782,7 +109782,10 @@ var registerBuild = (program2) => {
           files: filesToBuild,
           projectDir,
           concurrency: concurrencyValue,
-          buildOptions,
+          buildOptions: {
+            ...buildOptions,
+            platformConfig: commandPlatformConfig
+          },
           workerJobTimeoutMs: projectConfig?.build?.workerTimeoutMs,
           stopOnFatal: true,
           onLog: (lines) => {

package/dist/lib/index.js

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

package/package.json

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