@tscircuit/cli 0.1.838 → 0.1.839

package/dist/main.js

@@ -56027,7 +56027,8 @@ var require_queue = __commonJS((exports2, module2) => {
       empty: noop2,
       kill,
       killAndDrain,
-      error
+      error,
+      abort
     };
     return self2;
     function running() {
@@ -56147,6 +56148,28 @@ var require_queue = __commonJS((exports2, module2) => {
       self2.drain();
       self2.drain = noop2;
     }
+    function abort() {
+      var current = queueHead;
+      queueHead = null;
+      queueTail = null;
+      while (current) {
+        var next = current.next;
+        var callback = current.callback;
+        var errorHandler2 = current.errorHandler;
+        var val = current.value;
+        var context2 = current.context;
+        current.value = null;
+        current.callback = noop2;
+        current.errorHandler = null;
+        if (errorHandler2) {
+          errorHandler2(new Error("abort"), val);
+        }
+        callback.call(context2, new Error("abort"));
+        current.release(current);
+        current = next;
+      }
+      self2.drain = noop2;
+    }
     function error(handler) {
       errorHandler = handler;
     }
@@ -73806,9 +73829,6 @@ var deepMerge = (...sources) => {
       returnValue.signal = signals.at(-1);
     }
   }
-  if (returnValue.context === undefined) {
-    returnValue.context = {};
-  }
   return returnValue;
 };
 
@@ -73838,12 +73858,14 @@ var normalizeRetryOptions = (retry2 = {}) => {
   if (retry2.methods && !Array.isArray(retry2.methods)) {
     throw new Error("retry.methods must be an array");
   }
+  retry2.methods &&= retry2.methods.map((method) => method.toLowerCase());
   if (retry2.statusCodes && !Array.isArray(retry2.statusCodes)) {
     throw new Error("retry.statusCodes must be an array");
   }
+  const normalizedRetry = Object.fromEntries(Object.entries(retry2).filter(([, value]) => value !== undefined));
   return {
     ...defaultRetryOptions,
-    ...retry2
+    ...normalizedRetry
   };
 };
 
@@ -73942,17 +73964,27 @@ class Ky {
       let response = await ky.#fetch();
       for (const hook of ky.#options.hooks.afterResponse) {
         const clonedResponse = ky.#decorateResponse(response.clone());
-        const modifiedResponse = await hook(ky.request, ky.#getNormalizedOptions(), clonedResponse, { retryCount: ky.#retryCount });
-        if (modifiedResponse instanceof globalThis.Response) {
-          response = modifiedResponse;
+        let modifiedResponse;
+        try {
+          modifiedResponse = await hook(ky.request, ky.#getNormalizedOptions(), clonedResponse, { retryCount: ky.#retryCount });
+        } catch (error) {
+          ky.#cancelResponseBody(clonedResponse);
+          ky.#cancelResponseBody(response);
+          throw error;
         }
         if (modifiedResponse instanceof RetryMarker) {
-          await Promise.all([
-            clonedResponse.body?.cancel(),
-            response.body?.cancel()
-          ]);
+          ky.#cancelResponseBody(clonedResponse);
+          ky.#cancelResponseBody(response);
           throw new ForceRetryError(modifiedResponse.options);
         }
+        const nextResponse = modifiedResponse instanceof globalThis.Response ? modifiedResponse : response;
+        if (clonedResponse !== nextResponse) {
+          ky.#cancelResponseBody(clonedResponse);
+        }
+        if (response !== nextResponse) {
+          ky.#cancelResponseBody(response);
+        }
+        response = nextResponse;
       }
       ky.#decorateResponse(response);
       if (!response.ok && (typeof ky.#options.throwHttpErrors === "function" ? ky.#options.throwHttpErrors(response.status) : ky.#options.throwHttpErrors)) {
@@ -73969,20 +74001,16 @@ class Ky {
         if (!supportsResponseStreams) {
           throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
         }
-        return streamResponse(response.clone(), ky.#options.onDownloadProgress);
+        const progressResponse = response.clone();
+        ky.#cancelResponseBody(response);
+        return streamResponse(progressResponse, ky.#options.onDownloadProgress);
       }
       return response;
     };
-    const result = ky.#retry(function_).finally(async () => {
+    const result = ky.#retry(function_).finally(() => {
       const originalRequest = ky.#originalRequest;
-      const cleanupPromises = [];
-      if (originalRequest && !originalRequest.bodyUsed) {
-        cleanupPromises.push(originalRequest.body?.cancel());
-      }
-      if (!ky.request.bodyUsed) {
-        cleanupPromises.push(ky.request.body?.cancel());
-      }
-      await Promise.all(cleanupPromises);
+      ky.#cancelBody(originalRequest?.body ?? undefined);
+      ky.#cancelBody(ky.request.body ?? undefined);
     });
     for (const [type, mimeType] of Object.entries(responseTypes)) {
       if (type === "bytes" && typeof globalThis.Response?.prototype?.bytes !== "function") {
@@ -74098,7 +74126,8 @@ class Ky {
         jitteredDelay = retryDelay;
       }
     }
-    return Math.min(this.#options.retry.backoffLimit, jitteredDelay);
+    const backoffLimit = this.#options.retry.backoffLimit ?? Number.POSITIVE_INFINITY;
+    return Math.min(backoffLimit, jitteredDelay);
   }
   async#calculateRetryDelay(error) {
     this.#retryCount++;
@@ -74151,6 +74180,17 @@ class Ky {
     }
     return response;
   }
+  #cancelBody(body) {
+    if (!body) {
+      return;
+    }
+    body.cancel().catch(() => {
+      return;
+    });
+  }
+  #cancelResponseBody(response) {
+    this.#cancelBody(response.body ?? undefined);
+  }
   async#retry(function_) {
     try {
       return await function_();
@@ -74267,7 +74307,7 @@ var getGlobalDepsInstallCommand = (packageManager, deps) => {
 import { execSync as execSync2 } from "node:child_process";
 var import_semver2 = __toESM2(require_semver2(), 1);
 // package.json
-var version = "0.1.837";
+var version = "0.1.838";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -74328,7 +74368,7 @@ var package_default = {
     semver: "^7.6.3",
     sharp: "0.32.6",
     tempy: "^3.1.0",
-    tscircuit: "^0.0.1160-libonly",
+    tscircuit: "^0.0.1224-libonly",
     tsx: "^4.7.1",
     "typed-ky": "^0.0.4",
     zod: "^3.23.8"
@@ -172884,12 +172924,12 @@ var registerRemove = (program3) => {
 };
 
 // cli/build/register.ts
-import path50 from "node:path";
-import fs50 from "node:fs";
+import path51 from "node:path";
+import fs51 from "node:fs";
 
 // cli/build/build-file.ts
-import path36 from "node:path";
-import fs36 from "node:fs";
+import path37 from "node:path";
+import fs37 from "node:fs";
 
 // lib/shared/circuit-json-diagnostics.ts
 function analyzeCircuitJson(circuitJson) {
@@ -172915,6 +172955,8 @@ function analyzeCircuitJson(circuitJson) {
 
 // lib/shared/get-complete-platform-config.ts
 import { getPlatformConfig } from "@tscircuit/eval/platform-config";
+import path36 from "node:path";
+import fs36 from "node:fs";
 function getCompletePlatformConfig(userConfig) {
   const basePlatformConfig = getPlatformConfig();
   const defaultConfig = {
@@ -172923,7 +172965,23 @@ function getCompletePlatformConfig(userConfig) {
       ...basePlatformConfig.footprintFileParserMap,
       kicad_mod: {
         loadFromUrl: async (url) => {
-          const fetchUrl = url.startsWith("/") ? `file://${url}` : url;
+          let fetchUrl = url;
+          if (url.startsWith("./") || url.startsWith("../")) {
+            const absolutePath = path36.resolve(process.cwd(), url);
+            fetchUrl = `file://${absolutePath}`;
+          } else if (url.startsWith("/")) {
+            if (fs36.existsSync(url)) {
+              fetchUrl = `file://${url}`;
+            } else {
+              const relativePath = `.${url}`;
+              const absolutePath = path36.resolve(process.cwd(), relativePath);
+              if (fs36.existsSync(absolutePath)) {
+                fetchUrl = `file://${absolutePath}`;
+              } else {
+                fetchUrl = `file://${url}`;
+              }
+            }
+          }
           return basePlatformConfig.footprintFileParserMap.kicad_mod.loadFromUrl(fetchUrl);
         }
       }
@@ -172951,9 +173009,9 @@ var buildFile = async (input, output, projectDir, options) => {
       filePath: input,
       platformConfig: completePlatformConfig
     });
-    fs36.mkdirSync(path36.dirname(output), { recursive: true });
-    fs36.writeFileSync(output, JSON.stringify(result.circuitJson, null, 2));
-    console.log(`Circuit JSON written to ${path36.relative(projectDir, output)}`);
+    fs37.mkdirSync(path37.dirname(output), { recursive: true });
+    fs37.writeFileSync(output, JSON.stringify(result.circuitJson, null, 2));
+    console.log(`Circuit JSON written to ${path37.relative(projectDir, output)}`);
     const { errors, warnings } = analyzeCircuitJson(result.circuitJson);
     if (!options?.ignoreWarnings) {
       for (const warn of warnings) {
@@ -172965,7 +173023,9 @@ var buildFile = async (input, output, projectDir, options) => {
       for (const err of errors) {
         const msg = err.message || JSON.stringify(err);
         console.error(kleur_default.red(msg));
-        console.log(err.stack);
+        if (err.stack) {
+          console.log(err.stack);
+        }
       }
     }
     if (errors.length > 0 && !options?.ignoreErrors) {
@@ -172992,7 +173052,7 @@ var logTsxExtensionHint = (error, entryFilePath) => {
   const isAggregateError = error instanceof AggregateError || String(error).includes("AggregateError");
   if (!isTsEntry || !isAggregateError)
     return;
-  const entryFileName = path36.basename(entryFilePath);
+  const entryFileName = path37.basename(entryFilePath);
   console.error([
     "",
     `It looks like "${entryFileName}" is a ".ts" file. tscircuit component files must use the ".tsx" extension.`,
@@ -173007,7 +173067,7 @@ var logTypeReexportHint = (error, entryFilePath) => {
   if (!match)
     return;
   const [, exportName, fromSpecifier] = match;
-  const entryFileName = path36.basename(entryFilePath);
+  const entryFileName = path37.basename(entryFilePath);
   console.error([
     "",
     `It looks like "${entryFileName}" re-exports the type-only symbol "${exportName}" from "${fromSpecifier}" without the "type" modifier.`,
@@ -173023,12 +173083,12 @@ var logTypeReexportHint = (error, entryFilePath) => {
 import { execSync as execSync3 } from "node:child_process";
 
 // lib/shared/install-project-dependencies.ts
-import fs38 from "node:fs";
-import path38 from "node:path";
+import fs39 from "node:fs";
+import path39 from "node:path";
 
 // lib/shared/collect-tsci-dependencies.ts
-import fs37 from "node:fs";
-import path37 from "node:path";
+import fs38 from "node:fs";
+import path38 from "node:path";
 var DEFAULT_PATTERNS = ["**/*.{ts,tsx,js,jsx}"];
 var DEFAULT_IGNORES = [
   "**/node_modules/**",
@@ -173043,7 +173103,7 @@ function collectTsciDependencies({
   patterns = DEFAULT_PATTERNS,
   ignore = DEFAULT_IGNORES
 } = {}) {
-  const searchRoot = path37.resolve(cwd);
+  const searchRoot = path38.resolve(cwd);
   const files = globbySync(patterns, {
     cwd: searchRoot,
     absolute: true,
@@ -173053,7 +173113,7 @@ function collectTsciDependencies({
   const dependencies2 = new Set;
   for (const filePath of files) {
     try {
-      const fileContents = fs37.readFileSync(filePath, "utf-8");
+      const fileContents = fs38.readFileSync(filePath, "utf-8");
       let match;
       while (true) {
         match = IMPORT_PATTERN.exec(fileContents);
@@ -173071,26 +173131,26 @@ async function installProjectDependencies({
   cwd = process.cwd(),
   skipTscircuitPackage = false
 } = {}) {
-  const projectRoot = path38.resolve(cwd);
-  const packageJsonPath = path38.join(projectRoot, "package.json");
-  const npmrcPath = path38.join(projectRoot, ".npmrc");
+  const projectRoot = path39.resolve(cwd);
+  const packageJsonPath = path39.join(projectRoot, "package.json");
+  const npmrcPath = path39.join(projectRoot, ".npmrc");
   const packageManager = getPackageManager();
-  if (!fs38.existsSync(projectRoot)) {
+  if (!fs39.existsSync(projectRoot)) {
     throw new Error(`Directory not found: ${projectRoot}`);
   }
   let packageJsonCreated = false;
-  if (!fs38.existsSync(packageJsonPath)) {
+  if (!fs39.existsSync(packageJsonPath)) {
     console.log("No package.json found. Generating a new one.");
     generatePackageJson(projectRoot);
     packageJsonCreated = true;
   } else {
     console.log("Found existing package.json.");
   }
-  if (!fs38.existsSync(npmrcPath)) {
+  if (!fs39.existsSync(npmrcPath)) {
     console.log("Creating .npmrc with tscircuit registry configuration.");
-    fs38.writeFileSync(npmrcPath, "@tsci:registry=https://npm.tscircuit.com");
+    fs39.writeFileSync(npmrcPath, "@tsci:registry=https://npm.tscircuit.com");
   }
-  const packageJson = JSON.parse(fs38.readFileSync(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(fs39.readFileSync(packageJsonPath, "utf-8"));
   if (skipTscircuitPackage) {
     const isTscircuitPackage = (name) => name === "tscircuit";
     if (packageJson.dependencies) {
@@ -173123,7 +173183,7 @@ async function installProjectDependencies({
       console.log("No @tsci dependencies detected in circuit files.");
     }
   }
-  fs38.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+  fs39.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
 `);
   console.log(`Installing dependencies using ${kleur_default.bold(packageManager.name)}...`);
   try {
@@ -173219,20 +173279,20 @@ var resolveBuildOptions = ({
 };
 
 // cli/build/get-build-entrypoints.ts
-import fs39 from "node:fs";
-import path39 from "node:path";
+import fs40 from "node:fs";
+import path40 from "node:path";
 var isSubPath2 = (maybeChild, maybeParent) => {
-  const relative10 = path39.relative(maybeParent, maybeChild);
-  return relative10 === "" || !relative10.startsWith("..") && !path39.isAbsolute(relative10);
+  const relative10 = path40.relative(maybeParent, maybeChild);
+  return relative10 === "" || !relative10.startsWith("..") && !path40.isAbsolute(relative10);
 };
 var findProjectRoot = (startDir) => {
   let currentDir = startDir;
-  while (currentDir !== path39.dirname(currentDir)) {
-    const packageJsonPath = path39.join(currentDir, "package.json");
-    if (fs39.existsSync(packageJsonPath)) {
+  while (currentDir !== path40.dirname(currentDir)) {
+    const packageJsonPath = path40.join(currentDir, "package.json");
+    if (fs40.existsSync(packageJsonPath)) {
       return currentDir;
     }
-    currentDir = path39.dirname(currentDir);
+    currentDir = path40.dirname(currentDir);
   }
   return startDir;
 };
@@ -173241,12 +173301,12 @@ async function getBuildEntrypoints({
   rootDir = process.cwd(),
   includeBoardFiles = true
 }) {
-  const resolvedRoot = path39.resolve(rootDir);
+  const resolvedRoot = path40.resolve(rootDir);
   const includeBoardFilePatterns = includeBoardFiles ? getBoardFilePatterns(resolvedRoot) : [];
   const buildFromProjectDir = async () => {
     const projectConfig2 = loadProjectConfig(resolvedRoot);
-    const resolvedPreviewComponentPath = projectConfig2?.previewComponentPath ? path39.resolve(resolvedRoot, projectConfig2.previewComponentPath) : undefined;
-    const resolvedSiteDefaultComponentPath = projectConfig2?.siteDefaultComponentPath ? path39.resolve(resolvedRoot, projectConfig2.siteDefaultComponentPath) : undefined;
+    const resolvedPreviewComponentPath = projectConfig2?.previewComponentPath ? path40.resolve(resolvedRoot, projectConfig2.previewComponentPath) : undefined;
+    const resolvedSiteDefaultComponentPath = projectConfig2?.siteDefaultComponentPath ? path40.resolve(resolvedRoot, projectConfig2.siteDefaultComponentPath) : undefined;
     if (includeBoardFiles) {
       const files = findBoardFiles({ projectDir: resolvedRoot });
       if (files.length > 0) {
@@ -173284,11 +173344,11 @@ async function getBuildEntrypoints({
     };
   };
   if (fileOrDir) {
-    const resolved = path39.resolve(resolvedRoot, fileOrDir);
-    if (fs39.existsSync(resolved) && fs39.statSync(resolved).isDirectory()) {
+    const resolved = path40.resolve(resolvedRoot, fileOrDir);
+    if (fs40.existsSync(resolved) && fs40.statSync(resolved).isDirectory()) {
       const projectConfig3 = loadProjectConfig(resolvedRoot);
-      const resolvedPreviewComponentPath2 = projectConfig3?.previewComponentPath ? path39.resolve(resolvedRoot, projectConfig3.previewComponentPath) : undefined;
-      const resolvedSiteDefaultComponentPath2 = projectConfig3?.siteDefaultComponentPath ? path39.resolve(resolvedRoot, projectConfig3.siteDefaultComponentPath) : undefined;
+      const resolvedPreviewComponentPath2 = projectConfig3?.previewComponentPath ? path40.resolve(resolvedRoot, projectConfig3.previewComponentPath) : undefined;
+      const resolvedSiteDefaultComponentPath2 = projectConfig3?.siteDefaultComponentPath ? path40.resolve(resolvedRoot, projectConfig3.siteDefaultComponentPath) : undefined;
       if (includeBoardFiles) {
         const circuitFiles = findBoardFiles({
           projectDir: resolvedRoot,
@@ -173322,11 +173382,11 @@ async function getBuildEntrypoints({
         circuitFiles: mainEntrypoint ? [mainEntrypoint] : []
       };
     }
-    const fileDir = path39.dirname(resolved);
+    const fileDir = path40.dirname(resolved);
     const projectDir = findProjectRoot(fileDir);
     const projectConfig2 = loadProjectConfig(projectDir);
-    const resolvedPreviewComponentPath = projectConfig2?.previewComponentPath ? path39.resolve(projectDir, projectConfig2.previewComponentPath) : undefined;
-    const resolvedSiteDefaultComponentPath = projectConfig2?.siteDefaultComponentPath ? path39.resolve(projectDir, projectConfig2.siteDefaultComponentPath) : undefined;
+    const resolvedPreviewComponentPath = projectConfig2?.previewComponentPath ? path40.resolve(projectDir, projectConfig2.previewComponentPath) : undefined;
+    const resolvedSiteDefaultComponentPath = projectConfig2?.siteDefaultComponentPath ? path40.resolve(projectDir, projectConfig2.siteDefaultComponentPath) : undefined;
     return {
       projectDir,
       previewComponentPath: resolvedPreviewComponentPath,
@@ -173373,8 +173433,8 @@ ${scriptBlock}      <script src="https://cdn.tailwindcss.com"></script>
 };
 
 // cli/build/build-preview-images.ts
-import fs40 from "node:fs";
-import path40 from "node:path";
+import fs41 from "node:fs";
+import path41 from "node:path";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg2,
   convertCircuitJsonToSchematicSvg as convertCircuitJsonToSchematicSvg2
@@ -173450,21 +173510,21 @@ var generatePreviewAssets = async ({
   outputDir,
   distDir
 }) => {
-  const prefixRelative = path40.relative(distDir, outputDir) || ".";
+  const prefixRelative = path41.relative(distDir, outputDir) || ".";
   const prefix = prefixRelative === "." ? "" : `[${prefixRelative}] `;
   let circuitJson;
   try {
-    const circuitJsonRaw = fs40.readFileSync(build.outputPath, "utf-8");
+    const circuitJsonRaw = fs41.readFileSync(build.outputPath, "utf-8");
     circuitJson = JSON.parse(circuitJsonRaw);
   } catch (error) {
     console.error(`${prefix}Failed to read circuit JSON:`, error);
     return;
   }
-  fs40.mkdirSync(outputDir, { recursive: true });
+  fs41.mkdirSync(outputDir, { recursive: true });
   try {
     console.log(`${prefix}Generating PCB SVG...`);
     const pcbSvg = convertCircuitJsonToPcbSvg2(circuitJson);
-    fs40.writeFileSync(path40.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
+    fs41.writeFileSync(path41.join(outputDir, "pcb.svg"), pcbSvg, "utf-8");
     console.log(`${prefix}Written pcb.svg`);
   } catch (error) {
     console.error(`${prefix}Failed to generate PCB SVG:`, error);
@@ -173472,7 +173532,7 @@ var generatePreviewAssets = async ({
   try {
     console.log(`${prefix}Generating schematic SVG...`);
     const schematicSvg = convertCircuitJsonToSchematicSvg2(circuitJson);
-    fs40.writeFileSync(path40.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
+    fs41.writeFileSync(path41.join(outputDir, "schematic.svg"), schematicSvg, "utf-8");
     console.log(`${prefix}Written schematic.svg`);
   } catch (error) {
     console.error(`${prefix}Failed to generate schematic SVG:`, error);
@@ -173489,7 +173549,7 @@ var generatePreviewAssets = async ({
       camPos: [10, 10, 10],
       lookAt: [0, 0, 0]
     });
-    fs40.writeFileSync(path40.join(outputDir, "3d.png"), Buffer.from(normalizeToUint8Array(pngBuffer)));
+    fs41.writeFileSync(path41.join(outputDir, "3d.png"), Buffer.from(normalizeToUint8Array(pngBuffer)));
     console.log(`${prefix}Written 3d.png`);
   } catch (error) {
     console.error(`${prefix}Failed to generate 3D PNG:`, error);
@@ -173504,14 +173564,14 @@ var buildPreviewImages = async ({
 }) => {
   const successfulBuilds = builtFiles.filter((file) => file.ok);
   const previewEntrypoint = previewComponentPath || mainEntrypoint;
-  const resolvedPreviewEntrypoint = previewEntrypoint ? path40.resolve(previewEntrypoint) : undefined;
+  const resolvedPreviewEntrypoint = previewEntrypoint ? path41.resolve(previewEntrypoint) : undefined;
   if (allImages) {
     if (successfulBuilds.length === 0) {
       console.warn("No successful build output available for preview image generation.");
       return;
     }
     for (const build of successfulBuilds) {
-      const outputDir = path40.dirname(build.outputPath);
+      const outputDir = path41.dirname(build.outputPath);
       await generatePreviewAssets({
         build,
         outputDir,
@@ -173522,7 +173582,7 @@ var buildPreviewImages = async ({
   }
   const previewBuild = (() => {
     if (resolvedPreviewEntrypoint) {
-      const match = successfulBuilds.find((built) => path40.resolve(built.sourcePath) === resolvedPreviewEntrypoint);
+      const match = successfulBuilds.find((built) => path41.resolve(built.sourcePath) === resolvedPreviewEntrypoint);
       if (match)
         return match;
     }
@@ -173540,8 +173600,8 @@ var buildPreviewImages = async ({
 };
 
 // cli/build/build-preview-gltf.ts
-import fs41 from "node:fs";
-import path41 from "node:path";
+import fs42 from "node:fs";
+import path42 from "node:path";
 import { convertCircuitJsonToGltf as convertCircuitJsonToGltf3 } from "circuit-json-to-gltf";
 var buildPreviewGltf = async ({
   builtFiles,
@@ -173551,10 +173611,10 @@ var buildPreviewGltf = async ({
 }) => {
   const successfulBuilds = builtFiles.filter((file) => file.ok);
   const previewEntrypoint = previewComponentPath || mainEntrypoint;
-  const resolvedPreviewEntrypoint = previewEntrypoint ? path41.resolve(previewEntrypoint) : undefined;
+  const resolvedPreviewEntrypoint = previewEntrypoint ? path42.resolve(previewEntrypoint) : undefined;
   const previewBuild = (() => {
     if (resolvedPreviewEntrypoint) {
-      const match = successfulBuilds.find((built) => path41.resolve(built.sourcePath) === resolvedPreviewEntrypoint);
+      const match = successfulBuilds.find((built) => path42.resolve(built.sourcePath) === resolvedPreviewEntrypoint);
       if (match)
         return match;
     }
@@ -173566,16 +173626,16 @@ var buildPreviewGltf = async ({
   }
   let circuitJson;
   try {
-    const circuitJsonRaw = fs41.readFileSync(previewBuild.outputPath, "utf-8");
+    const circuitJsonRaw = fs42.readFileSync(previewBuild.outputPath, "utf-8");
     circuitJson = JSON.parse(circuitJsonRaw);
   } catch (error) {
     console.error("Failed to read circuit JSON:", error);
     return;
   }
   const sourcePath = previewBuild.sourcePath;
-  const sourceBasename = path41.basename(sourcePath);
+  const sourceBasename = path42.basename(sourcePath);
   const gltfFilename = sourceBasename.replace(/(\.(board|circuit))?\.tsx?$/, ".gltf");
-  const outputPath = path41.join(distDir, gltfFilename);
+  const outputPath = path42.join(distDir, gltfFilename);
   try {
     console.log("Converting circuit to GLTF...");
     const circuitJsonWithFileUrls = convertModelUrlsToFileUrls(circuitJson);
@@ -173583,7 +173643,7 @@ var buildPreviewGltf = async ({
       format: "gltf"
     });
     const gltfContent = JSON.stringify(gltfData, null, 2);
-    fs41.writeFileSync(outputPath, gltfContent, "utf-8");
+    fs42.writeFileSync(outputPath, gltfContent, "utf-8");
     console.log(`Written ${gltfFilename}`);
   } catch (error) {
     console.error("Failed to generate GLTF:", error);
@@ -173591,8 +173651,8 @@ var buildPreviewGltf = async ({
 };
 
 // cli/build/generate-kicad-project.ts
-import fs42 from "node:fs";
-import path42 from "node:path";
+import fs43 from "node:fs";
+import path43 from "node:path";
 var createKicadProContent = ({
   projectName,
   schematicFileName,
@@ -173632,10 +173692,10 @@ var generateKicadProject = async ({
     boardFileName
   });
   if (writeFiles) {
-    fs42.mkdirSync(outputDir, { recursive: true });
-    fs42.writeFileSync(path42.join(outputDir, schematicFileName), schContent);
-    fs42.writeFileSync(path42.join(outputDir, boardFileName), pcbContent);
-    fs42.writeFileSync(path42.join(outputDir, projectFileName), proContent);
+    fs43.mkdirSync(outputDir, { recursive: true });
+    fs43.writeFileSync(path43.join(outputDir, schematicFileName), schContent);
+    fs43.writeFileSync(path43.join(outputDir, boardFileName), pcbContent);
+    fs43.writeFileSync(path43.join(outputDir, projectFileName), proContent);
   }
   return {
     pcbContent,
@@ -173647,13 +173707,13 @@ var generateKicadProject = async ({
 };
 
 // cli/build/build-kicad-pcm.ts
-import path45 from "node:path";
-import fs45 from "node:fs";
+import path46 from "node:path";
+import fs46 from "node:fs";
 
 // lib/shared/generate-pcm-assets.ts
 var import_jszip3 = __toESM2(require_lib4(), 1);
-import fs43 from "node:fs";
-import path43 from "node:path";
+import fs44 from "node:fs";
+import path44 from "node:path";
 import crypto3 from "node:crypto";
 async function generatePcmAssets(options) {
   const {
@@ -173669,7 +173729,7 @@ async function generatePcmAssets(options) {
     displayName = `${author}/${packageName}`
   } = options;
   const identifier = `com.tscircuit.${author}.${packageName}`.toLowerCase().replace(/[^a-z0-9.-]/g, "-").slice(0, 50);
-  fs43.mkdirSync(outputDir, { recursive: true });
+  fs44.mkdirSync(outputDir, { recursive: true });
   console.log("Creating metadata.json...");
   const metadata = {
     $schema: "https://go.kicad.org/pcm/schemas/v1",
@@ -173695,13 +173755,13 @@ async function generatePcmAssets(options) {
     ]
   };
   const zipFileName = `${identifier}-${version2}.zip`;
-  const zipFilePath = path43.join(outputDir, zipFileName);
+  const zipFilePath = path44.join(outputDir, zipFileName);
   await createPcmZip({
     kicadLibraryPath,
     metadata,
     outputPath: zipFilePath
   });
-  const zipBuffer = fs43.readFileSync(zipFilePath);
+  const zipBuffer = fs44.readFileSync(zipFilePath);
   const sha256 = crypto3.createHash("sha256").update(zipBuffer).digest("hex");
   const zipSize = zipBuffer.length;
   const downloadUrl = baseUrl ? `${baseUrl}/pcm/${zipFileName}` : `./${zipFileName}`;
@@ -173735,9 +173795,9 @@ async function generatePcmAssets(options) {
       }
     ]
   };
-  const packagesJsonPath = path43.join(outputDir, "packages.json");
-  fs43.writeFileSync(packagesJsonPath, JSON.stringify(packagesJson, null, 2));
-  const packagesJsonBuffer = fs43.readFileSync(packagesJsonPath);
+  const packagesJsonPath = path44.join(outputDir, "packages.json");
+  fs44.writeFileSync(packagesJsonPath, JSON.stringify(packagesJson, null, 2));
+  const packagesJsonBuffer = fs44.readFileSync(packagesJsonPath);
   const packagesJsonSha256 = crypto3.createHash("sha256").update(packagesJsonBuffer).digest("hex");
   const packagesJsonUrl = baseUrl ? `${baseUrl}/pcm/packages.json` : "./packages.json";
   const repositoryJson = {
@@ -173755,8 +173815,8 @@ async function generatePcmAssets(options) {
       update_timestamp: Math.floor(Date.now() / 1000)
     }
   };
-  const repositoryJsonPath = path43.join(outputDir, "repository.json");
-  fs43.writeFileSync(repositoryJsonPath, JSON.stringify(repositoryJson, null, 2));
+  const repositoryJsonPath = path44.join(outputDir, "repository.json");
+  fs44.writeFileSync(repositoryJsonPath, JSON.stringify(repositoryJson, null, 2));
   return {
     outputDir,
     repositoryJsonPath,
@@ -173768,14 +173828,14 @@ async function generatePcmAssets(options) {
 }
 function addDirectoryToZip(opts) {
   const { zip, dirPath, zipPath } = opts;
-  const entries = fs43.readdirSync(dirPath, { withFileTypes: true });
+  const entries = fs44.readdirSync(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path43.join(dirPath, entry.name);
+    const fullPath = path44.join(dirPath, entry.name);
     const entryZipPath = zipPath ? `${zipPath}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
       addDirectoryToZip({ zip, dirPath: fullPath, zipPath: entryZipPath });
     } else {
-      const content = fs43.readFileSync(fullPath);
+      const content = fs44.readFileSync(fullPath);
       zip.file(entryZipPath, content);
     }
   }
@@ -173784,18 +173844,18 @@ async function createPcmZip(options) {
   const { kicadLibraryPath, metadata, outputPath } = options;
   const zip = new import_jszip3.default;
   zip.file("metadata.json", JSON.stringify(metadata, null, 2));
-  const footprintsDir = path43.join(kicadLibraryPath, "footprints");
-  if (fs43.existsSync(footprintsDir)) {
+  const footprintsDir = path44.join(kicadLibraryPath, "footprints");
+  if (fs44.existsSync(footprintsDir)) {
     console.log("Adding footprints directory...");
     addDirectoryToZip({ zip, dirPath: footprintsDir, zipPath: "footprints" });
   }
-  const symbolsDir = path43.join(kicadLibraryPath, "symbols");
-  if (fs43.existsSync(symbolsDir)) {
+  const symbolsDir = path44.join(kicadLibraryPath, "symbols");
+  if (fs44.existsSync(symbolsDir)) {
     console.log("Adding symbols directory...");
     addDirectoryToZip({ zip, dirPath: symbolsDir, zipPath: "symbols" });
   }
-  const modelsDir = path43.join(kicadLibraryPath, "3dmodels");
-  if (fs43.existsSync(modelsDir)) {
+  const modelsDir = path44.join(kicadLibraryPath, "3dmodels");
+  if (fs44.existsSync(modelsDir)) {
     console.log("Adding 3dmodels directory...");
     addDirectoryToZip({ zip, dirPath: modelsDir, zipPath: "3dmodels" });
   }
@@ -173805,12 +173865,12 @@ async function createPcmZip(options) {
     compression: "DEFLATE",
     compressionOptions: { level: 9 }
   });
-  fs43.writeFileSync(outputPath, zipBuffer);
+  fs44.writeFileSync(outputPath, zipBuffer);
 }
 
 // lib/utils/resolve-kicad-library-name.ts
-import path44 from "node:path";
-import fs44 from "node:fs";
+import path45 from "node:path";
+import fs45 from "node:fs";
 function resolveKicadLibraryName({
   projectDir
 }) {
@@ -173818,9 +173878,9 @@ function resolveKicadLibraryName({
   if (projectConfig2?.kicadLibraryName) {
     return projectConfig2.kicadLibraryName;
   }
-  const packageJsonPath = path44.join(projectDir, "package.json");
-  if (fs44.existsSync(packageJsonPath)) {
-    const packageJson = JSON.parse(fs44.readFileSync(packageJsonPath, "utf-8"));
+  const packageJsonPath = path45.join(projectDir, "package.json");
+  if (fs45.existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8"));
     const unscopedName = getUnscopedPackageName(packageJson.name || "");
     if (unscopedName) {
       return unscopedName.replace("@tsci/", "").replace(/\./g, "-");
@@ -173835,18 +173895,18 @@ async function buildKicadPcm({
   projectDir,
   distDir
 }) {
-  const packageJsonPath = path45.join(projectDir, "package.json");
-  if (!fs45.existsSync(packageJsonPath)) {
+  const packageJsonPath = path46.join(projectDir, "package.json");
+  if (!fs46.existsSync(packageJsonPath)) {
     throw new Error("No package.json found for KiCad PCM generation");
   }
-  const packageJson = JSON.parse(fs45.readFileSync(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(fs46.readFileSync(packageJsonPath, "utf-8"));
   const projectConfig2 = loadProjectConfig(projectDir);
-  const packageName = packageJson.name?.split("/").pop()?.split(".").pop() || path45.basename(projectDir);
+  const packageName = packageJson.name?.split("/").pop()?.split(".").pop() || path46.basename(projectDir);
   const version2 = packageJson.version || "1.0.0";
   const author = getPackageAuthor(packageJson.name || "") || "tscircuit";
   const description = packageJson.description || "";
   const libraryName = resolveKicadLibraryName({ projectDir });
-  const kicadLibOutputDir = path45.join(distDir, "kicad-library");
+  const kicadLibOutputDir = path46.join(distDir, "kicad-library");
   const kicadPcmPackageId = `com_tscircuit_${author}_${packageName}`.replace(/\./g, "_");
   console.log("Converting to KiCad library for PCM...");
   await convertToKicadLibrary({
@@ -173856,7 +173916,7 @@ async function buildKicadPcm({
     isPcm: true,
     kicadPcmPackageId
   });
-  const pcmOutputDir = path45.join(distDir, "pcm");
+  const pcmOutputDir = path46.join(distDir, "pcm");
   const envDeploymentUrl = process.env.TSCIRCUIT_DEPLOYMENT_URL?.replace(/\/+$/, "");
   const baseUrl = envDeploymentUrl ?? `https://${author}--${packageName}.tscircuit.app`;
   console.log("Generating PCM assets...");
@@ -173870,13 +173930,13 @@ async function buildKicadPcm({
     baseUrl,
     displayName: projectConfig2?.kicadLibraryName || undefined
   });
-  console.log(`  KiCad PCM assets generated at ${kleur_default.dim(path45.relative(process.cwd(), pcmOutputDir))}`);
+  console.log(`  KiCad PCM assets generated at ${kleur_default.dim(path46.relative(process.cwd(), pcmOutputDir))}`);
   console.log(`  Repository URL: ${kleur_default.cyan(`${baseUrl}/pcm/repository.json`)}`);
 }
 
 // cli/build/transpile/index.ts
-import path47 from "node:path";
-import fs47 from "node:fs";
+import path48 from "node:path";
+import fs48 from "node:fs";
 import { rollup } from "rollup";
 import typescript from "@rollup/plugin-typescript";
 import resolve11 from "@rollup/plugin-node-resolve";
@@ -173885,11 +173945,11 @@ import json from "@rollup/plugin-json";
 import dts from "rollup-plugin-dts";
 
 // cli/build/transpile/static-asset-plugin.ts
-import fs46 from "node:fs";
-import path46 from "node:path";
+import fs47 from "node:fs";
+import path47 from "node:path";
 import { createHash } from "node:crypto";
 function normalizePathSeparators(filePath) {
-  return filePath.split(path46.sep).join("/");
+  return filePath.split(path47.sep).join("/");
 }
 var STATIC_ASSET_EXTENSIONS = new Set([
   ".glb",
@@ -173920,24 +173980,24 @@ var createStaticAssetPlugin = ({
   return {
     name: "tsci-static-assets",
     resolveId(source, importer) {
-      const ext = path46.extname(source).toLowerCase();
+      const ext = path47.extname(source).toLowerCase();
       if (!STATIC_ASSET_EXTENSIONS.has(ext))
         return null;
-      if (path46.isAbsolute(source)) {
-        return fs46.existsSync(source) ? { id: normalizePathSeparators(source), external: true } : null;
+      if (path47.isAbsolute(source)) {
+        return fs47.existsSync(source) ? { id: normalizePathSeparators(source), external: true } : null;
       }
       if (importer) {
-        const importerNative = importer.split("/").join(path46.sep);
-        const resolvedFromImporter = path46.resolve(path46.dirname(importerNative), source);
-        if (fs46.existsSync(resolvedFromImporter)) {
+        const importerNative = importer.split("/").join(path47.sep);
+        const resolvedFromImporter = path47.resolve(path47.dirname(importerNative), source);
+        if (fs47.existsSync(resolvedFromImporter)) {
           return {
             id: normalizePathSeparators(resolvedFromImporter),
             external: true
           };
         }
       }
-      const resolvedFromProject = path46.resolve(resolvedBaseUrl, source);
-      if (fs46.existsSync(resolvedFromProject)) {
+      const resolvedFromProject = path47.resolve(resolvedBaseUrl, source);
+      if (fs47.existsSync(resolvedFromProject)) {
         return {
           id: normalizePathSeparators(resolvedFromProject),
           external: true
@@ -173950,8 +174010,8 @@ var createStaticAssetPlugin = ({
           const wildcard = isWildcard ? source.slice(patternPrefix.length) : "";
           for (const target of targets) {
             const targetPath = isWildcard ? target.replace("*", wildcard) : target;
-            const resolvedTarget = path46.resolve(resolvedBaseUrl, targetPath);
-            if (fs46.existsSync(resolvedTarget)) {
+            const resolvedTarget = path47.resolve(resolvedBaseUrl, targetPath);
+            if (fs47.existsSync(resolvedTarget)) {
               return {
                 id: normalizePathSeparators(resolvedTarget),
                 external: true
@@ -173977,18 +174037,18 @@ var createStaticAssetPlugin = ({
         if (chunk.type !== "chunk")
           continue;
         for (const importedId of chunk.imports) {
-          const ext = path46.extname(importedId).toLowerCase();
+          const ext = path47.extname(importedId).toLowerCase();
           if (!STATIC_ASSET_EXTENSIONS.has(ext))
             continue;
           if (!copiedAssets.has(importedId)) {
-            const assetDir = path46.join(outputDir, "assets");
-            fs46.mkdirSync(assetDir, { recursive: true });
-            const nativePath = importedId.split("/").join(path46.sep);
-            const fileBuffer = fs46.readFileSync(nativePath);
+            const assetDir = path47.join(outputDir, "assets");
+            fs47.mkdirSync(assetDir, { recursive: true });
+            const nativePath = importedId.split("/").join(path47.sep);
+            const fileBuffer = fs47.readFileSync(nativePath);
             const hash = createHash("sha1").update(fileBuffer).digest("hex").slice(0, 8);
-            const fileName = `${path46.basename(importedId, ext)}-${hash}${ext}`;
-            const outputFilePath = path46.join(assetDir, fileName);
-            fs46.writeFileSync(outputFilePath, fileBuffer);
+            const fileName = `${path47.basename(importedId, ext)}-${hash}${ext}`;
+            const outputFilePath = path47.join(assetDir, fileName);
+            fs47.writeFileSync(outputFilePath, fileBuffer);
             copiedAssets.set(importedId, `./assets/${fileName}`);
             assetIdToOutputPath.set(importedId, `./assets/${fileName}`);
           }
@@ -174010,17 +174070,17 @@ function escapeRegExp(string) {
 
 // cli/build/transpile/index.ts
 var createExternalFunction = (projectDir, tsconfigPath) => (id) => {
-  if (id.startsWith(".") || id.startsWith("/") || path47.isAbsolute(id)) {
+  if (id.startsWith(".") || id.startsWith("/") || path48.isAbsolute(id)) {
     return false;
   }
   let baseUrl = projectDir;
   let pathMappings = {};
-  if (tsconfigPath && fs47.existsSync(tsconfigPath)) {
+  if (tsconfigPath && fs48.existsSync(tsconfigPath)) {
     try {
-      const tsconfigContent = fs47.readFileSync(tsconfigPath, "utf-8");
+      const tsconfigContent = fs48.readFileSync(tsconfigPath, "utf-8");
       const tsconfig = JSON.parse(tsconfigContent);
       if (tsconfig.compilerOptions?.baseUrl) {
-        baseUrl = path47.resolve(path47.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
+        baseUrl = path48.resolve(path48.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
       }
       if (tsconfig.compilerOptions?.paths) {
         pathMappings = tsconfig.compilerOptions.paths;
@@ -174034,17 +174094,17 @@ var createExternalFunction = (projectDir, tsconfigPath) => (id) => {
     }
   }
   const potentialPaths = [
-    path47.join(baseUrl, id),
-    path47.join(baseUrl, `${id}.ts`),
-    path47.join(baseUrl, `${id}.tsx`),
-    path47.join(baseUrl, `${id}.js`),
-    path47.join(baseUrl, `${id}.jsx`),
-    path47.join(baseUrl, id, "index.ts"),
-    path47.join(baseUrl, id, "index.tsx"),
-    path47.join(baseUrl, id, "index.js"),
-    path47.join(baseUrl, id, "index.jsx")
+    path48.join(baseUrl, id),
+    path48.join(baseUrl, `${id}.ts`),
+    path48.join(baseUrl, `${id}.tsx`),
+    path48.join(baseUrl, `${id}.js`),
+    path48.join(baseUrl, `${id}.jsx`),
+    path48.join(baseUrl, id, "index.ts"),
+    path48.join(baseUrl, id, "index.tsx"),
+    path48.join(baseUrl, id, "index.js"),
+    path48.join(baseUrl, id, "index.jsx")
   ];
-  if (potentialPaths.some((p4) => fs47.existsSync(p4))) {
+  if (potentialPaths.some((p4) => fs48.existsSync(p4))) {
     return false;
   }
   return true;
@@ -174055,17 +174115,17 @@ var transpileFile = async ({
   projectDir
 }) => {
   try {
-    fs47.mkdirSync(outputDir, { recursive: true });
-    const tsconfigPath = path47.join(projectDir, "tsconfig.json");
-    const hasTsConfig = fs47.existsSync(tsconfigPath);
+    fs48.mkdirSync(outputDir, { recursive: true });
+    const tsconfigPath = path48.join(projectDir, "tsconfig.json");
+    const hasTsConfig = fs48.existsSync(tsconfigPath);
     let tsconfigBaseUrl = projectDir;
     let tsconfigPathMappings;
     if (hasTsConfig) {
       try {
-        const tsconfigContent = fs47.readFileSync(tsconfigPath, "utf-8");
+        const tsconfigContent = fs48.readFileSync(tsconfigPath, "utf-8");
         const tsconfig = JSON.parse(tsconfigContent);
         if (tsconfig.compilerOptions?.baseUrl) {
-          tsconfigBaseUrl = path47.resolve(path47.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
+          tsconfigBaseUrl = path48.resolve(path48.dirname(tsconfigPath), tsconfig.compilerOptions.baseUrl);
         }
         if (tsconfig.compilerOptions?.paths) {
           tsconfigPathMappings = tsconfig.compilerOptions.paths;
@@ -174120,27 +174180,27 @@ var transpileFile = async ({
       external: createExternalFunction(projectDir, hasTsConfig ? tsconfigPath : undefined),
       plugins: getPlugins()
     });
-    const esmOutputPath = path47.join(outputDir, "index.js");
+    const esmOutputPath = path48.join(outputDir, "index.js");
     await esmBundle.write({
       file: esmOutputPath,
       format: "es",
       sourcemap: false
     });
-    console.log(`ESM bundle written to ${path47.relative(projectDir, esmOutputPath)}`);
+    console.log(`ESM bundle written to ${path48.relative(projectDir, esmOutputPath)}`);
     console.log("Building CommonJS bundle...");
     const cjsBundle = await rollup({
       input,
       external: createExternalFunction(projectDir, hasTsConfig ? tsconfigPath : undefined),
       plugins: getPlugins()
     });
-    const cjsOutputPath = path47.join(outputDir, "index.cjs");
+    const cjsOutputPath = path48.join(outputDir, "index.cjs");
     console.log("Writing CJS bundle to:", cjsOutputPath);
     await cjsBundle.write({
       file: cjsOutputPath,
       format: "cjs",
       sourcemap: false
     });
-    console.log(`CommonJS bundle written to ${path47.relative(projectDir, cjsOutputPath)}`);
+    console.log(`CommonJS bundle written to ${path48.relative(projectDir, cjsOutputPath)}`);
     console.log("Generating type declarations...");
     const dtsBundle = await rollup({
       input,
@@ -174165,9 +174225,9 @@ var transpileFile = async ({
     dtsContent = dtsContent.replace(/import \* as [\w_]+ from ['"]react\/jsx-runtime['"];?\s*\n?/g, "");
     dtsContent = dtsContent.replace(/[\w_]+\.JSX\.Element/g, "any");
     dtsContent = dtsContent.replace(/export\s*{\s*};\s*$/gm, "").trim();
-    const dtsOutputPath = path47.join(outputDir, "index.d.ts");
-    fs47.writeFileSync(dtsOutputPath, dtsContent);
-    console.log(`Type declarations written to ${path47.relative(projectDir, dtsOutputPath)}`);
+    const dtsOutputPath = path48.join(outputDir, "index.d.ts");
+    fs48.writeFileSync(dtsOutputPath, dtsContent);
+    console.log(`Type declarations written to ${path48.relative(projectDir, dtsOutputPath)}`);
     console.log(kleur_default.green("Transpilation complete!"));
     return true;
   } catch (err) {
@@ -174180,17 +174240,17 @@ var transpileFile = async ({
 };
 
 // cli/utils/validate-main-in-dist.ts
-import fs48 from "node:fs";
-import path48 from "node:path";
+import fs49 from "node:fs";
+import path49 from "node:path";
 var validateMainInDist = (projectDir, distDir) => {
-  const packageJsonPath = path48.join(projectDir, "package.json");
-  if (!fs48.existsSync(packageJsonPath))
+  const packageJsonPath = path49.join(projectDir, "package.json");
+  if (!fs49.existsSync(packageJsonPath))
     return;
-  const packageJson = JSON.parse(fs48.readFileSync(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(fs49.readFileSync(packageJsonPath, "utf-8"));
   if (typeof packageJson.main !== "string")
     return;
-  const resolvedMainPath = path48.resolve(projectDir, packageJson.main);
-  const isMainInDist = resolvedMainPath === distDir || resolvedMainPath.startsWith(`${distDir}${path48.sep}`);
+  const resolvedMainPath = path49.resolve(projectDir, packageJson.main);
+  const isMainInDist = resolvedMainPath === distDir || resolvedMainPath.startsWith(`${distDir}${path49.sep}`);
   if (!isMainInDist) {
     console.warn('When using transpilation, your package\'s "main" field should point inside the `dist/*` directory, usually to "dist/index.js"');
   }
@@ -174212,19 +174272,19 @@ async function getLatestTscircuitCdnUrl() {
 }
 
 // cli/build/worker-pool.ts
-import path49 from "node:path";
-import fs49 from "node:fs";
+import path50 from "node:path";
+import fs50 from "node:fs";
 import { Worker } from "node:worker_threads";
 var getWorkerEntrypointPath = () => {
-  const tsPath = path49.join(import.meta.dir, "build-worker-entrypoint.ts");
-  if (fs49.existsSync(tsPath)) {
+  const tsPath = path50.join(import.meta.dir, "build-worker-entrypoint.ts");
+  if (fs50.existsSync(tsPath)) {
     return tsPath;
   }
-  const jsBundledPath = path49.join(import.meta.dir, "build", "build-worker-entrypoint.js");
-  if (fs49.existsSync(jsBundledPath)) {
+  const jsBundledPath = path50.join(import.meta.dir, "build", "build-worker-entrypoint.js");
+  if (fs50.existsSync(jsBundledPath)) {
     return jsBundledPath;
   }
-  return path49.join(import.meta.dir, "build-worker-entrypoint.js");
+  return path50.join(import.meta.dir, "build-worker-entrypoint.js");
 };
 
 class WorkerPool {
@@ -174288,7 +174348,9 @@ class WorkerPool {
         threadWorker.busy = false;
       }
       if (this.onLog) {
-        this.onLog([`Worker error: ${error.message}`]);
+        this.onLog([
+          `Worker error: ${error instanceof Error ? error.message : String(error)}`
+        ]);
       }
     });
     threadWorker.worker.on("exit", (code) => {
@@ -174380,23 +174442,23 @@ async function buildFilesWithWorkerPool(options) {
 }
 
 // cli/build/register.ts
-var normalizeRelativePath = (projectDir, targetPath) => path50.relative(projectDir, targetPath).split(path50.sep).join("/");
+var normalizeRelativePath = (projectDir, targetPath) => path51.relative(projectDir, targetPath).split(path51.sep).join("/");
 var registerBuild = (program3) => {
   program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").option("--ci", "Run install and optional prebuild/build commands (or default CI build)").option("--ignore-errors", "Do not exit with code 1 on errors").option("--ignore-warnings", "Do not log warnings").option("--disable-pcb", "Disable PCB outputs").option("--disable-parts-engine", "Disable the parts engine").option("--site", "Generate a static site in the dist directory").option("--transpile", "Transpile the entry file to JavaScript").option("--preview-images", "Generate preview images in the dist directory").option("--all-images", "Generate preview images for every successful build output").option("--kicad", "Generate KiCad project directories for each successful build output").option("--kicad-library", "Generate KiCad library in dist/kicad-library").option("--preview-gltf", "Generate a GLTF file from the preview entrypoint").option("--kicad-pcm", "Generate KiCad PCM (Plugin and Content Manager) assets in dist/pcm").option("--use-cdn-javascript", "Use CDN-hosted JavaScript instead of bundled standalone file for --site").option("--concurrency <number>", "Number of files to build in parallel (default: 1)", "1").action(async (file, options) => {
     try {
-      const resolvedRoot = path50.resolve(process.cwd());
+      const resolvedRoot = path51.resolve(process.cwd());
       let projectDir;
       if (file) {
-        const resolved = path50.resolve(resolvedRoot, file);
-        if (fs50.existsSync(resolved) && fs50.statSync(resolved).isDirectory()) {
+        const resolved = path51.resolve(resolvedRoot, file);
+        if (fs51.existsSync(resolved) && fs51.statSync(resolved).isDirectory()) {
           projectDir = resolvedRoot;
         } else {
-          let currentDir = path50.dirname(resolved);
-          while (currentDir !== path50.dirname(currentDir)) {
-            if (fs50.existsSync(path50.join(currentDir, "package.json"))) {
+          let currentDir = path51.dirname(resolved);
+          while (currentDir !== path51.dirname(currentDir)) {
+            if (fs51.existsSync(path51.join(currentDir, "package.json"))) {
               break;
             }
-            currentDir = path50.dirname(currentDir);
+            currentDir = path51.dirname(currentDir);
           }
           projectDir = currentDir;
         }
@@ -174436,8 +174498,8 @@ var registerBuild = (program3) => {
         }
         return config;
       })();
-      const distDir = path50.join(projectDir, "dist");
-      fs50.mkdirSync(distDir, { recursive: true });
+      const distDir = path51.join(projectDir, "dist");
+      fs51.mkdirSync(distDir, { recursive: true });
       const concurrencyValue = Math.max(1, Number.parseInt(resolvedOptions?.concurrency || "1", 10));
       if (concurrencyValue > 1) {
         console.log(`Building ${circuitFiles.length} file(s) with concurrency ${concurrencyValue}...`);
@@ -174455,7 +174517,7 @@ var registerBuild = (program3) => {
         platformConfig: platformConfig2
       };
       const processBuildResult = async (filePath, outputPath, buildOutcome) => {
-        const relative10 = path50.relative(projectDir, filePath);
+        const relative10 = path51.relative(projectDir, filePath);
         const outputDirName = relative10.replace(/(\.board|\.circuit)?\.tsx$/, "");
         builtFiles.push({
           sourcePath: filePath,
@@ -174465,9 +174527,9 @@ var registerBuild = (program3) => {
         if (!buildOutcome.ok) {
           hasErrors = true;
         } else if (resolvedOptions?.site) {
-          const normalizedSourcePath = relative10.split(path50.sep).join("/");
-          const relativeOutputPath = path50.join(outputDirName, "circuit.json");
-          const normalizedOutputPath = relativeOutputPath.split(path50.sep).join("/");
+          const normalizedSourcePath = relative10.split(path51.sep).join("/");
+          const relativeOutputPath = path51.join(outputDirName, "circuit.json");
+          const normalizedOutputPath = relativeOutputPath.split(path51.sep).join("/");
           staticFileReferences.push({
             filePath: normalizedSourcePath,
             fileStaticAssetUrl: `./${normalizedOutputPath}`
@@ -174475,12 +174537,12 @@ var registerBuild = (program3) => {
         }
         if (buildOutcome.ok && shouldGenerateKicad) {
           let circuitJson = buildOutcome.circuitJson;
-          if (!circuitJson && fs50.existsSync(outputPath)) {
-            circuitJson = JSON.parse(fs50.readFileSync(outputPath, "utf-8"));
+          if (!circuitJson && fs51.existsSync(outputPath)) {
+            circuitJson = JSON.parse(fs51.readFileSync(outputPath, "utf-8"));
           }
           if (circuitJson) {
-            const projectOutputDir = path50.join(distDir, outputDirName, "kicad");
-            const projectName = path50.basename(outputDirName);
+            const projectOutputDir = path51.join(distDir, outputDirName, "kicad");
+            const projectName = path51.basename(outputDirName);
             const project = await generateKicadProject({
               circuitJson,
               outputDir: projectOutputDir,
@@ -174496,19 +174558,19 @@ var registerBuild = (program3) => {
       };
       const buildSequentially = async () => {
         for (const filePath of circuitFiles) {
-          const relative10 = path50.relative(projectDir, filePath);
+          const relative10 = path51.relative(projectDir, filePath);
           console.log(`Building ${relative10}...`);
           const outputDirName = relative10.replace(/(\.board|\.circuit)?\.tsx$/, "");
-          const outputPath = path50.join(distDir, outputDirName, "circuit.json");
+          const outputPath = path51.join(distDir, outputDirName, "circuit.json");
           const buildOutcome = await buildFile(filePath, outputPath, projectDir, buildOptions);
           await processBuildResult(filePath, outputPath, buildOutcome);
         }
       };
       const buildWithWorkers = async () => {
         const filesToBuild = circuitFiles.map((filePath) => {
-          const relative10 = path50.relative(projectDir, filePath);
+          const relative10 = path51.relative(projectDir, filePath);
           const outputDirName = relative10.replace(/(\.board|\.circuit)?\.tsx$/, "");
-          const outputPath = path50.join(distDir, outputDirName, "circuit.json");
+          const outputPath = path51.join(distDir, outputDirName, "circuit.json");
           return { filePath, outputPath };
         });
         await buildFilesWithWorkerPool({
@@ -174522,7 +174584,7 @@ var registerBuild = (program3) => {
             }
           },
           onJobComplete: async (result) => {
-            const relative10 = path50.relative(projectDir, result.filePath);
+            const relative10 = path51.relative(projectDir, result.filePath);
             if (result.ok) {
               console.log(kleur_default.green(`✓ ${relative10}`));
             } else {
@@ -174592,14 +174654,14 @@ var registerBuild = (program3) => {
         if (resolvedOptions?.useCdnJavascript) {
           standaloneScriptSrc = await getLatestTscircuitCdnUrl();
         } else {
-          fs50.writeFileSync(path50.join(distDir, "standalone.min.js"), standalone_min_default);
+          fs51.writeFileSync(path51.join(distDir, "standalone.min.js"), standalone_min_default);
         }
         const indexHtml = getStaticIndexHtmlFile({
           files: staticFileReferences,
           standaloneScriptSrc,
           defaultMainComponentPath: siteDefaultComponentPath ? normalizeRelativePath(projectDir, siteDefaultComponentPath) : undefined
         });
-        fs50.writeFileSync(path50.join(distDir, "index.html"), indexHtml);
+        fs51.writeFileSync(path51.join(distDir, "index.html"), indexHtml);
       }
       if (resolvedOptions?.kicadLibrary) {
         console.log("Generating KiCad library...");
@@ -174619,14 +174681,14 @@ var registerBuild = (program3) => {
           }
         } else {
           const libraryName = resolveKicadLibraryName({ projectDir });
-          const kicadLibOutputDir = path50.join(distDir, "kicad-library");
+          const kicadLibOutputDir = path51.join(distDir, "kicad-library");
           try {
             await convertToKicadLibrary({
               filePath: entryFile,
               libraryName,
               outputDir: kicadLibOutputDir
             });
-            console.log(`  KiCad library generated at ${kleur_default.dim(path50.relative(process.cwd(), kicadLibOutputDir))}`);
+            console.log(`  KiCad library generated at ${kleur_default.dim(path51.relative(process.cwd(), kicadLibOutputDir))}`);
           } catch (err) {
             console.error(`Error generating KiCad library: ${err instanceof Error ? err.message : err}`);
             if (!resolvedOptions?.ignoreErrors) {
@@ -174687,7 +174749,7 @@ var registerBuild = (program3) => {
       if (configAppliedOpts.length > 0) {
         console.log(`  Config    ${kleur_default.magenta(configAppliedOpts.join(", "))} ${kleur_default.dim("(from tscircuit.config.json)")}`);
       }
-      console.log(`  Output    ${kleur_default.dim(path50.relative(process.cwd(), distDir) || "dist")}`);
+      console.log(`  Output    ${kleur_default.dim(path51.relative(process.cwd(), distDir) || "dist")}`);
       console.log(hasErrors ? kleur_default.yellow(`
 ⚠ Build completed with errors`) : kleur_default.green(`
 ✓ Done`));
@@ -174701,8 +174763,8 @@ var registerBuild = (program3) => {
 };
 
 // lib/shared/snapshot-project.ts
-import fs52 from "node:fs";
-import path51 from "node:path";
+import fs53 from "node:fs";
+import path52 from "node:path";
 import looksSame2 from "looks-same";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg3,
@@ -174713,7 +174775,7 @@ import { renderGLTFToPNGBufferFromGLBBuffer as renderGLTFToPNGBufferFromGLBBuffe
 
 // lib/shared/compare-images.ts
 import looksSame from "looks-same";
-import fs51 from "node:fs/promises";
+import fs52 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
   const { equal: equal2 } = await looksSame(buffer1, buffer2, {
     strict: false,
@@ -174729,7 +174791,7 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
         tolerance: 2
       });
     } else {
-      await fs51.writeFile(diffPath, buffer2);
+      await fs52.writeFile(diffPath, buffer2);
     }
   }
   return { equal: equal2 };
@@ -174754,7 +174816,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f2) => path51.resolve(projectDir, f2));
+  const resolvedPaths = filePaths.map((f2) => path52.resolve(projectDir, f2));
   const boardFiles = findBoardFiles({
     projectDir,
     ignore,
@@ -174768,7 +174830,7 @@ var snapshotProject = async ({
   const mismatches = [];
   let didUpdate = false;
   for (const file of boardFiles) {
-    const relativeFilePath = path51.relative(projectDir, file);
+    const relativeFilePath = path52.relative(projectDir, file);
     let circuitJson;
     let pcbSvg;
     let schSvg;
@@ -174823,17 +174885,17 @@ var snapshotProject = async ({
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         if (errorMessage.includes("No pcb_board found in circuit JSON")) {
-          const fileDir = path51.dirname(file);
-          const relativeDir = path51.relative(projectDir, fileDir);
-          const snapDir2 = snapshotsDirName ? path51.join(projectDir, snapshotsDirName, relativeDir) : path51.join(fileDir, "__snapshots__");
-          const base2 = path51.basename(file).replace(/\.tsx$/, "");
-          const snap3dPath = path51.join(snapDir2, `${base2}-3d.snap.png`);
-          const existing3dSnapshot = fs52.existsSync(snap3dPath);
+          const fileDir = path52.dirname(file);
+          const relativeDir = path52.relative(projectDir, fileDir);
+          const snapDir2 = snapshotsDirName ? path52.join(projectDir, snapshotsDirName, relativeDir) : path52.join(fileDir, "__snapshots__");
+          const base2 = path52.basename(file).replace(/\.tsx$/, "");
+          const snap3dPath = path52.join(snapDir2, `${base2}-3d.snap.png`);
+          const existing3dSnapshot = fs53.existsSync(snap3dPath);
           if (existing3dSnapshot) {
             onError(kleur_default.red(`
 ❌ Failed to generate 3D snapshot for ${relativeFilePath}:
 `) + kleur_default.red(`   No pcb_board found in circuit JSON
-`) + kleur_default.red(`   Existing snapshot: ${path51.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path52.relative(projectDir, snap3dPath)}
 `));
             return onExit2(1);
           } else {
@@ -174849,9 +174911,9 @@ var snapshotProject = async ({
         }
       }
     }
-    const snapDir = snapshotsDirName ? path51.join(projectDir, snapshotsDirName, path51.relative(projectDir, path51.dirname(file))) : path51.join(path51.dirname(file), "__snapshots__");
-    fs52.mkdirSync(snapDir, { recursive: true });
-    const base = path51.basename(file).replace(/\.tsx$/, "");
+    const snapDir = snapshotsDirName ? path52.join(projectDir, snapshotsDirName, path52.relative(projectDir, path52.dirname(file))) : path52.join(path52.dirname(file), "__snapshots__");
+    fs53.mkdirSync(snapDir, { recursive: true });
+    const base = path52.basename(file).replace(/\.tsx$/, "");
     const snapshots = [];
     if (pcbOnly || !schematicOnly) {
       snapshots.push({ type: "pcb", content: pcbSvg, isBinary: false });
@@ -174869,31 +174931,31 @@ var snapshotProject = async ({
     for (const snapshot of snapshots) {
       const { type } = snapshot;
       const is3d = type === "3d";
-      const snapPath = path51.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-      const existing = fs52.existsSync(snapPath);
+      const snapPath = path52.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+      const existing = fs53.existsSync(snapPath);
       const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
       const newContentForFile = snapshot.content;
       if (!existing) {
-        fs52.writeFileSync(snapPath, newContentForFile);
-        console.log("✅", kleur_default.gray(path51.relative(projectDir, snapPath)));
+        fs53.writeFileSync(snapPath, newContentForFile);
+        console.log("✅", kleur_default.gray(path52.relative(projectDir, snapPath)));
         didUpdate = true;
         continue;
       }
-      const oldContentBuffer = fs52.readFileSync(snapPath);
+      const oldContentBuffer = fs53.readFileSync(snapPath);
       const diffPath = snapPath.replace(is3d ? ".snap.png" : ".snap.svg", is3d ? ".diff.png" : ".diff.svg");
       const { equal: equal2 } = await compareAndCreateDiff(oldContentBuffer, newContentBuffer, diffPath);
       if (update) {
         if (!forceUpdate && equal2) {
-          console.log("✅", kleur_default.gray(path51.relative(projectDir, snapPath)));
+          console.log("✅", kleur_default.gray(path52.relative(projectDir, snapPath)));
         } else {
-          fs52.writeFileSync(snapPath, newContentForFile);
-          console.log("✅", kleur_default.gray(path51.relative(projectDir, snapPath)));
+          fs53.writeFileSync(snapPath, newContentForFile);
+          console.log("✅", kleur_default.gray(path52.relative(projectDir, snapPath)));
           didUpdate = true;
         }
       } else if (!equal2) {
         mismatches.push(`${snapPath} (diff: ${diffPath})`);
       } else {
-        console.log("✅", kleur_default.gray(path51.relative(projectDir, snapPath)));
+        console.log("✅", kleur_default.gray(path52.relative(projectDir, snapPath)));
       }
     }
   }
@@ -174932,22 +174994,22 @@ var registerSnapshot = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs53 from "node:fs";
-import path52 from "node:path";
+import fs54 from "node:fs";
+import path53 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path52.resolve(startDir);
-    while (dir !== path52.parse(dir).root) {
-      if (fs53.existsSync(path52.join(dir, ".git"))) {
+    let dir = path53.resolve(startDir);
+    while (dir !== path53.parse(dir).root) {
+      if (fs54.existsSync(path53.join(dir, ".git"))) {
         return dir;
       }
-      dir = path52.dirname(dir);
+      dir = path53.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path52.join(gitRoot, ".github", "workflows");
-  fs53.mkdirSync(workflowsDir, { recursive: true });
+  const workflowsDir = path53.join(gitRoot, ".github", "workflows");
+  fs54.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -174986,8 +175048,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path52.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path52.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path53.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path53.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -175025,8 +175087,8 @@ function registerAuthSetupNpmrc(program3) {
 }
 
 // cli/convert/register.ts
-import fs54 from "node:fs/promises";
-import path53 from "node:path";
+import fs55 from "node:fs/promises";
+import path54 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
 
 // node_modules/@tscircuit/mm/dist/index.js
@@ -175147,15 +175209,15 @@ var convertCircuitJsonToTscircuit = (circuitJson, opts) => {
 var registerConvert = (program3) => {
   program3.command("convert").description("Convert a .kicad_mod footprint to a tscircuit component").argument("<file>", "Path to the .kicad_mod file").option("-o, --output <path>", "Output TSX file path").option("-n, --name <component>", "Component name for export").action(async (file, options) => {
     try {
-      const inputPath = path53.resolve(file);
-      const modContent = await fs54.readFile(inputPath, "utf-8");
+      const inputPath = path54.resolve(file);
+      const modContent = await fs55.readFile(inputPath, "utf-8");
       const circuitJson = await parseKicadModToCircuitJson(modContent);
-      const componentName = options.name ?? path53.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path54.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path53.resolve(options.output) : path53.join(path53.dirname(inputPath), `${componentName}.tsx`);
-      await fs54.writeFile(outputPath, tsx);
+      const outputPath = options.output ? path54.resolve(options.output) : path54.join(path54.dirname(inputPath), `${componentName}.tsx`);
+      await fs55.writeFile(outputPath, tsx);
       console.log(kleur_default.green(`Converted ${outputPath}`));
     } catch (error) {
       console.error(kleur_default.red("Failed to convert footprint:"), error instanceof Error ? error.message : error);
@@ -175271,7 +175333,7 @@ var registerInstall = (program3) => {
 };
 
 // cli/transpile/register.ts
-import path54 from "node:path";
+import path55 from "node:path";
 var registerTranspile = (program3) => {
   program3.command("transpile").description("Transpile TypeScript/TSX to JavaScript (ESM, CommonJS, and type declarations)").argument("[file]", "Path to the entry file").action(async (file) => {
     try {
@@ -175279,7 +175341,7 @@ var registerTranspile = (program3) => {
         fileOrDir: file,
         includeBoardFiles: false
       });
-      const distDir = path54.join(projectDir, "dist");
+      const distDir = path55.join(projectDir, "dist");
       validateMainInDist(projectDir, distDir);
       console.log("Transpiling entry file...");
       const entryFile = mainEntrypoint || circuitFiles[0];
@@ -175307,6 +175369,8 @@ var registerTranspile = (program3) => {
 };
 
 // lib/shared/register-static-asset-loaders.ts
+import fs56 from "node:fs";
+import path56 from "node:path";
 var TEXT_STATIC_ASSET_EXTENSIONS = [
   ".gltf",
   ".step",
@@ -175317,17 +175381,34 @@ var TEXT_STATIC_ASSET_EXTENSIONS = [
 ];
 var staticAssetFilter = new RegExp(`(${TEXT_STATIC_ASSET_EXTENSIONS.map((ext) => ext.replace(".", "\\.")).join("|")})$`, "i");
 var registered = false;
+var getBaseUrlFromTsConfig = () => {
+  const tsconfigPath = path56.join(process.cwd(), "tsconfig.json");
+  try {
+    if (!fs56.existsSync(tsconfigPath)) {
+      return null;
+    }
+    const tsconfigContent = fs56.readFileSync(tsconfigPath, "utf-8");
+    const tsconfig = JSON.parse(tsconfigContent);
+    if (tsconfig.compilerOptions?.baseUrl) {
+      return tsconfig.compilerOptions.baseUrl;
+    }
+  } catch {}
+  return null;
+};
 var registerStaticAssetLoaders = () => {
   if (registered)
     return;
   registered = true;
   if (typeof Bun !== "undefined" && typeof Bun.plugin === "function") {
+    const baseUrl = getBaseUrlFromTsConfig();
     Bun.plugin({
       name: "tsci-static-assets",
       setup(build) {
         build.onLoad({ filter: staticAssetFilter }, (args) => {
+          const baseDir = baseUrl ? path56.resolve(process.cwd(), baseUrl) : process.cwd();
+          const relativePath = path56.relative(baseDir, args.path).split(path56.sep).join("/");
           return {
-            contents: `export default ${JSON.stringify(args.path)};`,
+            contents: `export default ${JSON.stringify(`./${relativePath}`)};`,
             loader: "js"
           };
         });