@tscircuit/cli 0.1.469 → 0.1.470

package/dist/main.js

@@ -1596,7 +1596,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         return arg.length > 1 && arg[0] === "-";
       }
       const negativeNumberArg = (arg) => {
-        if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg))
+        if (!/^-(\d+|\d*\.\d+)(e[+-]?\d+)?$/.test(arg))
           return false;
         return !this._getCommandAndAncestors().some((cmd) => cmd.options.map((opt) => opt.short).some((short) => /^-\d$/.test(short)));
       };
@@ -52173,9 +52173,9 @@ var require_fs = __commonJS((exports2) => {
 var require_path = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", { value: true });
   exports2.convertPosixPathToPattern = exports2.convertWindowsPathToPattern = exports2.convertPathToPattern = exports2.escapePosixPath = exports2.escapeWindowsPath = exports2.escape = exports2.removeLeadingDotSegment = exports2.makeAbsolute = exports2.unixify = undefined;
-  var os3 = __require("os");
+  var os2 = __require("os");
   var path14 = __require("path");
-  var IS_WINDOWS_PLATFORM = os3.platform() === "win32";
+  var IS_WINDOWS_PLATFORM = os2.platform() === "win32";
   var LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
   var POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
   var WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
@@ -53442,7 +53442,7 @@ var require_braces = __commonJS((exports2, module2) => {
   module2.exports = braces;
 });
 
-// node_modules/picomatch/lib/constants.js
+// node_modules/micromatch/node_modules/picomatch/lib/constants.js
 var require_constants3 = __commonJS((exports2, module2) => {
   var path14 = __require("path");
   var WIN_SLASH = "\\\\/";
@@ -53582,7 +53582,7 @@ var require_constants3 = __commonJS((exports2, module2) => {
   };
 });
 
-// node_modules/picomatch/lib/utils.js
+// node_modules/micromatch/node_modules/picomatch/lib/utils.js
 var require_utils3 = __commonJS((exports2) => {
   var path14 = __require("path");
   var win32 = process.platform === "win32";
@@ -53642,7 +53642,7 @@ var require_utils3 = __commonJS((exports2) => {
   };
 });
 
-// node_modules/picomatch/lib/scan.js
+// node_modules/micromatch/node_modules/picomatch/lib/scan.js
 var require_scan = __commonJS((exports2, module2) => {
   var utils = require_utils3();
   var {
@@ -53957,7 +53957,7 @@ var require_scan = __commonJS((exports2, module2) => {
   module2.exports = scan;
 });
 
-// node_modules/picomatch/lib/parse.js
+// node_modules/micromatch/node_modules/picomatch/lib/parse.js
 var require_parse3 = __commonJS((exports2, module2) => {
   var constants = require_constants3();
   var utils = require_utils3();
@@ -54735,7 +54735,7 @@ var require_parse3 = __commonJS((exports2, module2) => {
   module2.exports = parse3;
 });
 
-// node_modules/picomatch/lib/picomatch.js
+// node_modules/micromatch/node_modules/picomatch/lib/picomatch.js
 var require_picomatch = __commonJS((exports2, module2) => {
   var path14 = __require("path");
   var scan = require_scan();
@@ -57205,8 +57205,8 @@ var require_settings4 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", { value: true });
   exports2.DEFAULT_FILE_SYSTEM_ADAPTER = undefined;
   var fs13 = __require("fs");
-  var os3 = __require("os");
-  var CPU_COUNT = Math.max(os3.cpus().length, 1);
+  var os2 = __require("os");
+  var CPU_COUNT = Math.max(os2.cpus().length, 1);
   exports2.DEFAULT_FILE_SYSTEM_ADAPTER = {
     lstat: fs13.lstat,
     lstatSync: fs13.lstatSync,
@@ -70470,13 +70470,18 @@ import path7 from "node:path";
 import fs4 from "node:fs";
 import { promisify } from "node:util";
 
-// node_modules/stubborn-fs/dist/attemptify.js
-var attemptifyAsync = (fn, onError) => {
+// node_modules/stubborn-utils/dist/attemptify_async.js
+var attemptifyAsync = (fn, options) => {
+  const { onError } = options;
   return function attemptified(...args) {
     return fn.apply(undefined, args).catch(onError);
   };
 };
-var attemptifySync = (fn, onError) => {
+var attemptify_async_default = attemptifyAsync;
+
+// node_modules/stubborn-utils/dist/attemptify_sync.js
+var attemptifySync = (fn, options) => {
+  const { onError } = options;
   return function attemptified(...args) {
     try {
       return fn.apply(undefined, args);
@@ -70485,14 +70490,62 @@ var attemptifySync = (fn, onError) => {
     }
   };
 };
+var attemptify_sync_default = attemptifySync;
+
+// node_modules/stubborn-utils/dist/constants.js
+var RETRY_INTERVAL = 250;
+
+// node_modules/stubborn-utils/dist/retryify_async.js
+var retryifyAsync = (fn, options) => {
+  const { isRetriable } = options;
+  return function retryified(options2) {
+    const { timeout } = options2;
+    const interval = options2.interval ?? RETRY_INTERVAL;
+    const timestamp = Date.now() + timeout;
+    return function attempt(...args) {
+      return fn.apply(undefined, args).catch((error) => {
+        if (!isRetriable(error))
+          throw error;
+        if (Date.now() >= timestamp)
+          throw error;
+        const delay = Math.round(interval * Math.random());
+        if (delay > 0) {
+          const delayPromise = new Promise((resolve) => setTimeout(resolve, delay));
+          return delayPromise.then(() => attempt.apply(undefined, args));
+        } else {
+          return attempt.apply(undefined, args);
+        }
+      });
+    };
+  };
+};
+var retryify_async_default = retryifyAsync;
+
+// node_modules/stubborn-utils/dist/retryify_sync.js
+var retryifySync = (fn, options) => {
+  const { isRetriable } = options;
+  return function retryified(options2) {
+    const { timeout } = options2;
+    const timestamp = Date.now() + timeout;
+    return function attempt(...args) {
+      while (true) {
+        try {
+          return fn.apply(undefined, args);
+        } catch (error) {
+          if (!isRetriable(error))
+            throw error;
+          if (Date.now() >= timestamp)
+            throw error;
+          continue;
+        }
+      }
+    };
+  };
+};
+var retryify_sync_default = retryifySync;
 
 // node_modules/stubborn-fs/dist/constants.js
 import process3 from "node:process";
-var IS_USER_ROOT = process3.getuid ? !process3.getuid() : false;
-var LIMIT_FILES_DESCRIPTORS = 1e4;
-var NOOP = () => {
-  return;
-};
 
 // node_modules/stubborn-fs/dist/handlers.js
 var Handlers = {
@@ -70527,153 +70580,70 @@ var Handlers = {
 };
 var handlers_default = Handlers;
 
-// node_modules/stubborn-fs/dist/retryify_queue.js
-class RetryfyQueue {
-  constructor() {
-    this.interval = 25;
-    this.intervalId = undefined;
-    this.limit = LIMIT_FILES_DESCRIPTORS;
-    this.queueActive = new Set;
-    this.queueWaiting = new Set;
-    this.init = () => {
-      if (this.intervalId)
-        return;
-      this.intervalId = setInterval(this.tick, this.interval);
-    };
-    this.reset = () => {
-      if (!this.intervalId)
-        return;
-      clearInterval(this.intervalId);
-      delete this.intervalId;
-    };
-    this.add = (fn) => {
-      this.queueWaiting.add(fn);
-      if (this.queueActive.size < this.limit / 2) {
-        this.tick();
-      } else {
-        this.init();
-      }
-    };
-    this.remove = (fn) => {
-      this.queueWaiting.delete(fn);
-      this.queueActive.delete(fn);
-    };
-    this.schedule = () => {
-      return new Promise((resolve) => {
-        const cleanup = () => this.remove(resolver);
-        const resolver = () => resolve(cleanup);
-        this.add(resolver);
-      });
-    };
-    this.tick = () => {
-      if (this.queueActive.size >= this.limit)
-        return;
-      if (!this.queueWaiting.size)
-        return this.reset();
-      for (const fn of this.queueWaiting) {
-        if (this.queueActive.size >= this.limit)
-          break;
-        this.queueWaiting.delete(fn);
-        this.queueActive.add(fn);
-        fn();
-      }
-    };
+// node_modules/stubborn-fs/dist/constants.js
+var ATTEMPTIFY_CHANGE_ERROR_OPTIONS = {
+  onError: handlers_default.onChangeError
+};
+var ATTEMPTIFY_NOOP_OPTIONS = {
+  onError: () => {
+    return;
   }
-}
-var retryify_queue_default = new RetryfyQueue;
-
-// node_modules/stubborn-fs/dist/retryify.js
-var retryifyAsync = (fn, isRetriableError) => {
-  return function retrified(timestamp) {
-    return function attempt(...args) {
-      return retryify_queue_default.schedule().then((cleanup) => {
-        const onResolve = (result) => {
-          cleanup();
-          return result;
-        };
-        const onReject = (error) => {
-          cleanup();
-          if (Date.now() >= timestamp)
-            throw error;
-          if (isRetriableError(error)) {
-            const delay = Math.round(100 * Math.random());
-            const delayPromise = new Promise((resolve) => setTimeout(resolve, delay));
-            return delayPromise.then(() => attempt.apply(undefined, args));
-          }
-          throw error;
-        };
-        return fn.apply(undefined, args).then(onResolve, onReject);
-      });
-    };
-  };
 };
-var retryifySync = (fn, isRetriableError) => {
-  return function retrified(timestamp) {
-    return function attempt(...args) {
-      try {
-        return fn.apply(undefined, args);
-      } catch (error) {
-        if (Date.now() > timestamp)
-          throw error;
-        if (isRetriableError(error))
-          return attempt.apply(undefined, args);
-        throw error;
-      }
-    };
-  };
+var IS_USER_ROOT = process3.getuid ? !process3.getuid() : false;
+var RETRYIFY_OPTIONS = {
+  isRetriable: handlers_default.isRetriableError
 };
 
 // node_modules/stubborn-fs/dist/index.js
 var FS = {
   attempt: {
-    chmod: attemptifyAsync(promisify(fs4.chmod), handlers_default.onChangeError),
-    chown: attemptifyAsync(promisify(fs4.chown), handlers_default.onChangeError),
-    close: attemptifyAsync(promisify(fs4.close), NOOP),
-    fsync: attemptifyAsync(promisify(fs4.fsync), NOOP),
-    mkdir: attemptifyAsync(promisify(fs4.mkdir), NOOP),
-    realpath: attemptifyAsync(promisify(fs4.realpath), NOOP),
-    stat: attemptifyAsync(promisify(fs4.stat), NOOP),
-    unlink: attemptifyAsync(promisify(fs4.unlink), NOOP),
-    chmodSync: attemptifySync(fs4.chmodSync, handlers_default.onChangeError),
-    chownSync: attemptifySync(fs4.chownSync, handlers_default.onChangeError),
-    closeSync: attemptifySync(fs4.closeSync, NOOP),
-    existsSync: attemptifySync(fs4.existsSync, NOOP),
-    fsyncSync: attemptifySync(fs4.fsync, NOOP),
-    mkdirSync: attemptifySync(fs4.mkdirSync, NOOP),
-    realpathSync: attemptifySync(fs4.realpathSync, NOOP),
-    statSync: attemptifySync(fs4.statSync, NOOP),
-    unlinkSync: attemptifySync(fs4.unlinkSync, NOOP)
+    chmod: attemptify_async_default(promisify(fs4.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chown: attemptify_async_default(promisify(fs4.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    close: attemptify_async_default(promisify(fs4.close), ATTEMPTIFY_NOOP_OPTIONS),
+    fsync: attemptify_async_default(promisify(fs4.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+    mkdir: attemptify_async_default(promisify(fs4.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+    realpath: attemptify_async_default(promisify(fs4.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+    stat: attemptify_async_default(promisify(fs4.stat), ATTEMPTIFY_NOOP_OPTIONS),
+    unlink: attemptify_async_default(promisify(fs4.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+    chmodSync: attemptify_sync_default(fs4.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    chownSync: attemptify_sync_default(fs4.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+    closeSync: attemptify_sync_default(fs4.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+    existsSync: attemptify_sync_default(fs4.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+    fsyncSync: attemptify_sync_default(fs4.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+    mkdirSync: attemptify_sync_default(fs4.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+    realpathSync: attemptify_sync_default(fs4.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+    statSync: attemptify_sync_default(fs4.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+    unlinkSync: attemptify_sync_default(fs4.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
   },
   retry: {
-    close: retryifyAsync(promisify(fs4.close), handlers_default.isRetriableError),
-    fsync: retryifyAsync(promisify(fs4.fsync), handlers_default.isRetriableError),
-    open: retryifyAsync(promisify(fs4.open), handlers_default.isRetriableError),
-    readFile: retryifyAsync(promisify(fs4.readFile), handlers_default.isRetriableError),
-    rename: retryifyAsync(promisify(fs4.rename), handlers_default.isRetriableError),
-    stat: retryifyAsync(promisify(fs4.stat), handlers_default.isRetriableError),
-    write: retryifyAsync(promisify(fs4.write), handlers_default.isRetriableError),
-    writeFile: retryifyAsync(promisify(fs4.writeFile), handlers_default.isRetriableError),
-    closeSync: retryifySync(fs4.closeSync, handlers_default.isRetriableError),
-    fsyncSync: retryifySync(fs4.fsyncSync, handlers_default.isRetriableError),
-    openSync: retryifySync(fs4.openSync, handlers_default.isRetriableError),
-    readFileSync: retryifySync(fs4.readFileSync, handlers_default.isRetriableError),
-    renameSync: retryifySync(fs4.renameSync, handlers_default.isRetriableError),
-    statSync: retryifySync(fs4.statSync, handlers_default.isRetriableError),
-    writeSync: retryifySync(fs4.writeSync, handlers_default.isRetriableError),
-    writeFileSync: retryifySync(fs4.writeFileSync, handlers_default.isRetriableError)
+    close: retryify_async_default(promisify(fs4.close), RETRYIFY_OPTIONS),
+    fsync: retryify_async_default(promisify(fs4.fsync), RETRYIFY_OPTIONS),
+    open: retryify_async_default(promisify(fs4.open), RETRYIFY_OPTIONS),
+    readFile: retryify_async_default(promisify(fs4.readFile), RETRYIFY_OPTIONS),
+    rename: retryify_async_default(promisify(fs4.rename), RETRYIFY_OPTIONS),
+    stat: retryify_async_default(promisify(fs4.stat), RETRYIFY_OPTIONS),
+    write: retryify_async_default(promisify(fs4.write), RETRYIFY_OPTIONS),
+    writeFile: retryify_async_default(promisify(fs4.writeFile), RETRYIFY_OPTIONS),
+    closeSync: retryify_sync_default(fs4.closeSync, RETRYIFY_OPTIONS),
+    fsyncSync: retryify_sync_default(fs4.fsyncSync, RETRYIFY_OPTIONS),
+    openSync: retryify_sync_default(fs4.openSync, RETRYIFY_OPTIONS),
+    readFileSync: retryify_sync_default(fs4.readFileSync, RETRYIFY_OPTIONS),
+    renameSync: retryify_sync_default(fs4.renameSync, RETRYIFY_OPTIONS),
+    statSync: retryify_sync_default(fs4.statSync, RETRYIFY_OPTIONS),
+    writeSync: retryify_sync_default(fs4.writeSync, RETRYIFY_OPTIONS),
+    writeFileSync: retryify_sync_default(fs4.writeFileSync, RETRYIFY_OPTIONS)
   }
 };
 var dist_default = FS;
 
 // node_modules/atomically/dist/constants.js
-import os2 from "node:os";
 import process4 from "node:process";
 var DEFAULT_ENCODING = "utf8";
 var DEFAULT_FILE_MODE = 438;
 var DEFAULT_FOLDER_MODE = 511;
 var DEFAULT_WRITE_OPTIONS = {};
-var DEFAULT_USER_UID = os2.userInfo().uid;
-var DEFAULT_USER_GID = os2.userInfo().gid;
+var DEFAULT_USER_UID = process4.geteuid ? process4.geteuid() : -1;
+var DEFAULT_USER_GID = process4.getegid ? process4.getegid() : -1;
 var DEFAULT_TIMEOUT_SYNC = 1000;
 var IS_POSIX = !!process4.getuid;
 var IS_USER_ROOT2 = process4.getuid ? !process4.getuid() : false;
@@ -70702,12 +70672,12 @@ var IS_LINUX = process5.platform === "linux";
 var IS_WINDOWS = process5.platform === "win32";
 
 // node_modules/when-exit/dist/node/signals.js
-var Signals = ["SIGABRT", "SIGALRM", "SIGHUP", "SIGINT", "SIGTERM"];
+var Signals = ["SIGHUP", "SIGINT", "SIGTERM"];
 if (!IS_WINDOWS) {
-  Signals.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+  Signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
 }
 if (IS_LINUX) {
-  Signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+  Signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
 }
 var signals_default = Signals;
 
@@ -70808,7 +70778,8 @@ var temp_default = Temp;
 function writeFileSync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
   if (isString(options))
     return writeFileSync(filePath, data, { encoding: options });
-  const timeout = Date.now() + ((options.timeout ?? DEFAULT_TIMEOUT_SYNC) || -1);
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT_SYNC;
+  const retryOptions = { timeout };
   let tempDisposer = null;
   let tempPath = null;
   let fd = null;
@@ -70838,23 +70809,23 @@ function writeFileSync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
         recursive: true
       });
     }
-    fd = dist_default.retry.openSync(timeout)(tempPath, "w", options.mode || DEFAULT_FILE_MODE);
+    fd = dist_default.retry.openSync(retryOptions)(tempPath, "w", options.mode || DEFAULT_FILE_MODE);
     if (options.tmpCreated) {
       options.tmpCreated(tempPath);
     }
     if (isString(data)) {
-      dist_default.retry.writeSync(timeout)(fd, data, 0, options.encoding || DEFAULT_ENCODING);
+      dist_default.retry.writeSync(retryOptions)(fd, data, 0, options.encoding || DEFAULT_ENCODING);
     } else if (!isUndefined(data)) {
-      dist_default.retry.writeSync(timeout)(fd, data, 0, data.length, 0);
+      dist_default.retry.writeSync(retryOptions)(fd, data, 0, data.length, 0);
     }
     if (options.fsync !== false) {
       if (options.fsyncWait !== false) {
-        dist_default.retry.fsyncSync(timeout)(fd);
+        dist_default.retry.fsyncSync(retryOptions)(fd);
       } else {
         dist_default.attempt.fsync(fd);
       }
     }
-    dist_default.retry.closeSync(timeout)(fd);
+    dist_default.retry.closeSync(retryOptions)(fd);
     fd = null;
     if (options.chown && (options.chown.uid !== DEFAULT_USER_UID || options.chown.gid !== DEFAULT_USER_GID)) {
       dist_default.attempt.chownSync(tempPath, options.chown.uid, options.chown.gid);
@@ -70863,13 +70834,13 @@ function writeFileSync(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
       dist_default.attempt.chmodSync(tempPath, options.mode);
     }
     try {
-      dist_default.retry.renameSync(timeout)(tempPath, filePath);
+      dist_default.retry.renameSync(retryOptions)(tempPath, filePath);
     } catch (error) {
       if (!isException(error))
         throw error;
       if (error.code !== "ENAMETOOLONG")
         throw error;
-      dist_default.retry.renameSync(timeout)(tempPath, temp_default.truncate(filePath));
+      dist_default.retry.renameSync(retryOptions)(tempPath, temp_default.truncate(filePath));
     }
     tempDisposer();
     tempPath = null;
@@ -71595,13 +71566,36 @@ class HTTPError extends Error {
   }
 }
 
-// node_modules/ky/distribution/errors/TimeoutError.js
-class TimeoutError extends Error {
-  request;
-  constructor(request) {
-    super(`Request timed out: ${request.method} ${request.url}`);
-    this.name = "TimeoutError";
-    this.request = request;
+// node_modules/ky/distribution/errors/NonError.js
+class NonError extends Error {
+  name = "NonError";
+  value;
+  constructor(value) {
+    let message = "Non-error value was thrown";
+    try {
+      if (typeof value === "string") {
+        message = value;
+      } else if (value && typeof value === "object" && "message" in value && typeof value.message === "string") {
+        message = value.message;
+      }
+    } catch {}
+    super(message);
+    this.value = value;
+  }
+}
+
+// node_modules/ky/distribution/errors/ForceRetryError.js
+class ForceRetryError extends Error {
+  name = "ForceRetryError";
+  customDelay;
+  code;
+  customRequest;
+  constructor(options) {
+    const cause = options?.cause ? options.cause instanceof Error ? options.cause : new NonError(options.cause) : undefined;
+    super(options?.code ? `Forced retry: ${options.code}` : "Forced retry", cause ? { cause } : undefined);
+    this.customDelay = options?.delay;
+    this.code = options?.code;
+    this.customRequest = options?.request;
   }
 }
 
@@ -71650,6 +71644,14 @@ var responseTypes = {
 var maxSafeTimeout = 2147483647;
 var usualFormBoundarySize = new TextEncoder().encode("------WebKitFormBoundaryaxpyiPgbbPti10Rw").length;
 var stop = Symbol("stop");
+
+class RetryMarker {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+}
+var retry = (options) => new RetryMarker(options);
 var kyOptionKeys = {
   json: true,
   parseJson: true,
@@ -71662,7 +71664,11 @@ var kyOptionKeys = {
   throwHttpErrors: true,
   onDownloadProgress: true,
   onUploadProgress: true,
-  fetch: true
+  fetch: true,
+  context: true
+};
+var vendorSpecificOptions = {
+  next: true
 };
 var requestOptionsRegistry = {
   method: true,
@@ -71678,9 +71684,7 @@ var requestOptionsRegistry = {
   keepalive: true,
   signal: true,
   window: true,
-  dispatcher: true,
-  duplex: true,
-  priority: true
+  duplex: true
 };
 
 // node_modules/ky/distribution/utils/body.js
@@ -71757,7 +71761,7 @@ var streamResponse = (response, onDownloadProgress) => {
       headers: response.headers
     });
   }
-  const totalBytes = Number(response.headers.get("content-length")) || 0;
+  const totalBytes = Math.max(0, Number(response.headers.get("content-length")) || 0);
   return new Response(withProgress(response.body, totalBytes, onDownloadProgress), {
     status: response.status,
     statusText: response.statusText,
@@ -71809,10 +71813,44 @@ var mergeHooks = (original = {}, incoming = {}) => ({
   afterResponse: newHookValue(original, incoming, "afterResponse"),
   beforeError: newHookValue(original, incoming, "beforeError")
 });
+var appendSearchParameters = (target, source) => {
+  const result = new URLSearchParams;
+  for (const input of [target, source]) {
+    if (input === undefined) {
+      continue;
+    }
+    if (input instanceof URLSearchParams) {
+      for (const [key, value] of input.entries()) {
+        result.append(key, value);
+      }
+    } else if (Array.isArray(input)) {
+      for (const pair of input) {
+        if (!Array.isArray(pair) || pair.length !== 2) {
+          throw new TypeError("Array search parameters must be provided in [[key, value], ...] format");
+        }
+        result.append(String(pair[0]), String(pair[1]));
+      }
+    } else if (isObject2(input)) {
+      for (const [key, value] of Object.entries(input)) {
+        if (value !== undefined) {
+          result.append(key, String(value));
+        }
+      }
+    } else {
+      const parameters = new URLSearchParams(input);
+      for (const [key, value] of parameters.entries()) {
+        result.append(key, value);
+      }
+    }
+  }
+  return result;
+};
 var deepMerge = (...sources) => {
   let returnValue = {};
   let headers = {};
   let hooks = {};
+  let searchParameters;
+  const signals = [];
   for (const source of sources) {
     if (Array.isArray(source)) {
       if (!Array.isArray(returnValue)) {
@@ -71821,6 +71859,28 @@ var deepMerge = (...sources) => {
       returnValue = [...returnValue, ...source];
     } else if (isObject2(source)) {
       for (let [key, value] of Object.entries(source)) {
+        if (key === "signal" && value instanceof globalThis.AbortSignal) {
+          signals.push(value);
+          continue;
+        }
+        if (key === "context") {
+          if (value !== undefined && value !== null && (!isObject2(value) || Array.isArray(value))) {
+            throw new TypeError("The `context` option must be an object");
+          }
+          returnValue = {
+            ...returnValue,
+            context: value === undefined || value === null ? {} : { ...returnValue.context, ...value }
+          };
+          continue;
+        }
+        if (key === "searchParams") {
+          if (value === undefined || value === null) {
+            searchParameters = undefined;
+          } else {
+            searchParameters = searchParameters === undefined ? value : appendSearchParameters(searchParameters, value);
+          }
+          continue;
+        }
         if (isObject2(value) && key in returnValue) {
           value = deepMerge(returnValue[key], value);
         }
@@ -71836,6 +71896,21 @@ var deepMerge = (...sources) => {
       }
     }
   }
+  if (searchParameters !== undefined) {
+    returnValue.searchParams = searchParameters;
+  }
+  if (signals.length > 0) {
+    if (signals.length === 1) {
+      returnValue.signal = signals[0];
+    } else if (supportsAbortSignal) {
+      returnValue.signal = AbortSignal.any(signals);
+    } else {
+      returnValue.signal = signals.at(-1);
+    }
+  }
+  if (returnValue.context === undefined) {
+    returnValue.context = {};
+  }
   return returnValue;
 };
 
@@ -71851,27 +71926,39 @@ var defaultRetryOptions = {
   afterStatusCodes: retryAfterStatusCodes,
   maxRetryAfter: Number.POSITIVE_INFINITY,
   backoffLimit: Number.POSITIVE_INFINITY,
-  delay: (attemptCount) => 0.3 * 2 ** (attemptCount - 1) * 1000
+  delay: (attemptCount) => 0.3 * 2 ** (attemptCount - 1) * 1000,
+  jitter: undefined,
+  retryOnTimeout: false
 };
-var normalizeRetryOptions = (retry = {}) => {
-  if (typeof retry === "number") {
+var normalizeRetryOptions = (retry2 = {}) => {
+  if (typeof retry2 === "number") {
     return {
       ...defaultRetryOptions,
-      limit: retry
+      limit: retry2
     };
   }
-  if (retry.methods && !Array.isArray(retry.methods)) {
+  if (retry2.methods && !Array.isArray(retry2.methods)) {
     throw new Error("retry.methods must be an array");
   }
-  if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
+  if (retry2.statusCodes && !Array.isArray(retry2.statusCodes)) {
     throw new Error("retry.statusCodes must be an array");
   }
   return {
     ...defaultRetryOptions,
-    ...retry
+    ...retry2
   };
 };
 
+// node_modules/ky/distribution/errors/TimeoutError.js
+class TimeoutError extends Error {
+  request;
+  constructor(request) {
+    super(`Request timed out: ${request.method} ${request.url}`);
+    this.name = "TimeoutError";
+    this.request = request;
+  }
+}
+
 // node_modules/ky/distribution/utils/timeout.js
 async function timeout(request, init2, abortController, options) {
   return new Promise((resolve, reject) => {
@@ -71909,7 +71996,10 @@ async function delay(ms, { signal }) {
 var findUnknownOptions = (request, options) => {
   const unknownOptions = {};
   for (const key in options) {
-    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && !(key in request)) {
+    if (!Object.hasOwn(options, key)) {
+      continue;
+    }
+    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && (!(key in request) || (key in vendorSpecificOptions))) {
       unknownOptions[key] = options[key];
     }
   }
@@ -71934,44 +72024,59 @@ var hasSearchParameters = (search) => {
   return Boolean(search);
 };
 
+// node_modules/ky/distribution/utils/type-guards.js
+function isHTTPError(error) {
+  return error instanceof HTTPError || error?.name === HTTPError.name;
+}
+function isTimeoutError(error) {
+  return error instanceof TimeoutError || error?.name === TimeoutError.name;
+}
+
 // node_modules/ky/distribution/core/Ky.js
 class Ky {
   static create(input, options) {
     const ky = new Ky(input, options);
     const function_ = async () => {
-      if (typeof ky._options.timeout === "number" && ky._options.timeout > maxSafeTimeout) {
+      if (typeof ky.#options.timeout === "number" && ky.#options.timeout > maxSafeTimeout) {
         throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
       }
       await Promise.resolve();
-      let response = await ky._fetch();
-      for (const hook of ky._options.hooks.afterResponse) {
-        const modifiedResponse = await hook(ky.request, ky._options, ky._decorateResponse(response.clone()));
+      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;
         }
+        if (modifiedResponse instanceof RetryMarker) {
+          await Promise.all([
+            clonedResponse.body?.cancel(),
+            response.body?.cancel()
+          ]);
+          throw new ForceRetryError(modifiedResponse.options);
+        }
       }
-      ky._decorateResponse(response);
-      if (!response.ok && ky._options.throwHttpErrors) {
-        let error = new HTTPError(response, ky.request, ky._options);
-        for (const hook of ky._options.hooks.beforeError) {
-          error = await hook(error);
+      ky.#decorateResponse(response);
+      if (!response.ok && (typeof ky.#options.throwHttpErrors === "function" ? ky.#options.throwHttpErrors(response.status) : ky.#options.throwHttpErrors)) {
+        let error = new HTTPError(response, ky.request, ky.#getNormalizedOptions());
+        for (const hook of ky.#options.hooks.beforeError) {
+          error = await hook(error, { retryCount: ky.#retryCount });
         }
         throw error;
       }
-      if (ky._options.onDownloadProgress) {
-        if (typeof ky._options.onDownloadProgress !== "function") {
+      if (ky.#options.onDownloadProgress) {
+        if (typeof ky.#options.onDownloadProgress !== "function") {
           throw new TypeError("The `onDownloadProgress` option must be a function");
         }
         if (!supportsResponseStreams) {
           throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
         }
-        return streamResponse(response.clone(), ky._options.onDownloadProgress);
+        return streamResponse(response.clone(), ky.#options.onDownloadProgress);
       }
       return response;
     };
-    const isRetriableMethod = ky._options.retry.methods.includes(ky.request.method.toLowerCase());
-    const result = (isRetriableMethod ? ky._retry(function_) : function_()).finally(async () => {
-      const originalRequest = ky._originalRequest;
+    const result = ky.#retry(function_).finally(async () => {
+      const originalRequest = ky.#originalRequest;
       const cleanupPromises = [];
       if (originalRequest && !originalRequest.bodyUsed) {
         cleanupPromises.push(originalRequest.body?.cancel());
@@ -72013,150 +72118,215 @@ class Ky {
     return searchParams;
   }
   request;
-  abortController;
-  _retryCount = 0;
-  _input;
-  _options;
-  _originalRequest;
+  #abortController;
+  #retryCount = 0;
+  #input;
+  #options;
+  #originalRequest;
+  #userProvidedAbortSignal;
+  #cachedNormalizedOptions;
   constructor(input, options = {}) {
-    this._input = input;
-    this._options = {
+    this.#input = input;
+    this.#options = {
       ...options,
-      headers: mergeHeaders(this._input.headers, options.headers),
+      headers: mergeHeaders(this.#input.headers, options.headers),
       hooks: mergeHooks({
         beforeRequest: [],
         beforeRetry: [],
         beforeError: [],
         afterResponse: []
       }, options.hooks),
-      method: normalizeRequestMethod(options.method ?? this._input.method ?? "GET"),
+      method: normalizeRequestMethod(options.method ?? this.#input.method ?? "GET"),
       prefixUrl: String(options.prefixUrl || ""),
       retry: normalizeRetryOptions(options.retry),
-      throwHttpErrors: options.throwHttpErrors !== false,
+      throwHttpErrors: options.throwHttpErrors ?? true,
       timeout: options.timeout ?? 1e4,
-      fetch: options.fetch ?? globalThis.fetch.bind(globalThis)
+      fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
+      context: options.context ?? {}
     };
-    if (typeof this._input !== "string" && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
+    if (typeof this.#input !== "string" && !(this.#input instanceof URL || this.#input instanceof globalThis.Request)) {
       throw new TypeError("`input` must be a string, URL, or Request");
     }
-    if (this._options.prefixUrl && typeof this._input === "string") {
-      if (this._input.startsWith("/")) {
+    if (this.#options.prefixUrl && typeof this.#input === "string") {
+      if (this.#input.startsWith("/")) {
         throw new Error("`input` must not begin with a slash when using `prefixUrl`");
       }
-      if (!this._options.prefixUrl.endsWith("/")) {
-        this._options.prefixUrl += "/";
+      if (!this.#options.prefixUrl.endsWith("/")) {
+        this.#options.prefixUrl += "/";
       }
-      this._input = this._options.prefixUrl + this._input;
+      this.#input = this.#options.prefixUrl + this.#input;
     }
     if (supportsAbortController && supportsAbortSignal) {
-      const originalSignal = this._options.signal ?? this._input.signal;
-      this.abortController = new globalThis.AbortController;
-      this._options.signal = originalSignal ? AbortSignal.any([originalSignal, this.abortController.signal]) : this.abortController.signal;
+      this.#userProvidedAbortSignal = this.#options.signal ?? this.#input.signal;
+      this.#abortController = new globalThis.AbortController;
+      this.#options.signal = this.#userProvidedAbortSignal ? AbortSignal.any([this.#userProvidedAbortSignal, this.#abortController.signal]) : this.#abortController.signal;
     }
     if (supportsRequestStreams) {
-      this._options.duplex = "half";
+      this.#options.duplex = "half";
+    }
+    if (this.#options.json !== undefined) {
+      this.#options.body = this.#options.stringifyJson?.(this.#options.json) ?? JSON.stringify(this.#options.json);
+      this.#options.headers.set("content-type", this.#options.headers.get("content-type") ?? "application/json");
     }
-    if (this._options.json !== undefined) {
-      this._options.body = this._options.stringifyJson?.(this._options.json) ?? JSON.stringify(this._options.json);
-      this._options.headers.set("content-type", this._options.headers.get("content-type") ?? "application/json");
+    const userProvidedContentType = options.headers && new globalThis.Headers(options.headers).has("content-type");
+    if (this.#input instanceof globalThis.Request && (supportsFormData && this.#options.body instanceof globalThis.FormData || this.#options.body instanceof URLSearchParams) && !userProvidedContentType) {
+      this.#options.headers.delete("content-type");
     }
-    this.request = new globalThis.Request(this._input, this._options);
-    if (hasSearchParameters(this._options.searchParams)) {
-      const textSearchParams = typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(Ky.#normalizeSearchParams(this._options.searchParams)).toString();
+    this.request = new globalThis.Request(this.#input, this.#options);
+    if (hasSearchParameters(this.#options.searchParams)) {
+      const textSearchParams = typeof this.#options.searchParams === "string" ? this.#options.searchParams.replace(/^\?/, "") : new URLSearchParams(Ky.#normalizeSearchParams(this.#options.searchParams)).toString();
       const searchParams = "?" + textSearchParams;
       const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
-      if ((supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers["content-type"])) {
-        this.request.headers.delete("content-type");
-      }
-      this.request = new globalThis.Request(new globalThis.Request(url, { ...this.request }), this._options);
+      this.request = new globalThis.Request(url, this.#options);
     }
-    if (this._options.onUploadProgress) {
-      if (typeof this._options.onUploadProgress !== "function") {
+    if (this.#options.onUploadProgress) {
+      if (typeof this.#options.onUploadProgress !== "function") {
         throw new TypeError("The `onUploadProgress` option must be a function");
       }
       if (!supportsRequestStreams) {
         throw new Error("Request streams are not supported in your environment. The `duplex` option for `Request` is not available.");
       }
-      const originalBody = this.request.body;
-      if (originalBody) {
-        this.request = streamRequest(this.request, this._options.onUploadProgress, this._options.body);
+      this.request = this.#wrapRequestWithUploadProgress(this.request, this.#options.body ?? undefined);
+    }
+  }
+  #calculateDelay() {
+    const retryDelay = this.#options.retry.delay(this.#retryCount);
+    let jitteredDelay = retryDelay;
+    if (this.#options.retry.jitter === true) {
+      jitteredDelay = Math.random() * retryDelay;
+    } else if (typeof this.#options.retry.jitter === "function") {
+      jitteredDelay = this.#options.retry.jitter(retryDelay);
+      if (!Number.isFinite(jitteredDelay) || jitteredDelay < 0) {
+        jitteredDelay = retryDelay;
       }
     }
+    return Math.min(this.#options.retry.backoffLimit, jitteredDelay);
   }
-  _calculateRetryDelay(error) {
-    this._retryCount++;
-    if (this._retryCount > this._options.retry.limit || error instanceof TimeoutError) {
+  async#calculateRetryDelay(error) {
+    this.#retryCount++;
+    if (this.#retryCount > this.#options.retry.limit) {
+      throw error;
+    }
+    const errorObject = error instanceof Error ? error : new NonError(error);
+    if (errorObject instanceof ForceRetryError) {
+      return errorObject.customDelay ?? this.#calculateDelay();
+    }
+    if (!this.#options.retry.methods.includes(this.request.method.toLowerCase())) {
+      throw error;
+    }
+    if (this.#options.retry.shouldRetry !== undefined) {
+      const result = await this.#options.retry.shouldRetry({ error: errorObject, retryCount: this.#retryCount });
+      if (result === false) {
+        throw error;
+      }
+      if (result === true) {
+        return this.#calculateDelay();
+      }
+    }
+    if (isTimeoutError(error) && !this.#options.retry.retryOnTimeout) {
       throw error;
     }
-    if (error instanceof HTTPError) {
-      if (!this._options.retry.statusCodes.includes(error.response.status)) {
+    if (isHTTPError(error)) {
+      if (!this.#options.retry.statusCodes.includes(error.response.status)) {
         throw error;
       }
-      const retryAfter = error.response.headers.get("Retry-After") ?? error.response.headers.get("RateLimit-Reset") ?? error.response.headers.get("X-RateLimit-Reset") ?? error.response.headers.get("X-Rate-Limit-Reset");
-      if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
+      const retryAfter = error.response.headers.get("Retry-After") ?? error.response.headers.get("RateLimit-Reset") ?? error.response.headers.get("X-RateLimit-Retry-After") ?? error.response.headers.get("X-RateLimit-Reset") ?? error.response.headers.get("X-Rate-Limit-Reset");
+      if (retryAfter && this.#options.retry.afterStatusCodes.includes(error.response.status)) {
         let after = Number(retryAfter) * 1000;
         if (Number.isNaN(after)) {
           after = Date.parse(retryAfter) - Date.now();
         } else if (after >= Date.parse("2024-01-01")) {
           after -= Date.now();
         }
-        const max = this._options.retry.maxRetryAfter ?? after;
+        const max = this.#options.retry.maxRetryAfter ?? after;
         return after < max ? after : max;
       }
       if (error.response.status === 413) {
         throw error;
       }
     }
-    const retryDelay = this._options.retry.delay(this._retryCount);
-    return Math.min(this._options.retry.backoffLimit, retryDelay);
+    return this.#calculateDelay();
   }
-  _decorateResponse(response) {
-    if (this._options.parseJson) {
-      response.json = async () => this._options.parseJson(await response.text());
+  #decorateResponse(response) {
+    if (this.#options.parseJson) {
+      response.json = async () => this.#options.parseJson(await response.text());
     }
     return response;
   }
-  async _retry(function_) {
+  async#retry(function_) {
     try {
       return await function_();
     } catch (error) {
-      const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
-      if (this._retryCount < 1) {
+      const ms = Math.min(await this.#calculateRetryDelay(error), maxSafeTimeout);
+      if (this.#retryCount < 1) {
         throw error;
       }
-      await delay(ms, { signal: this._options.signal });
-      for (const hook of this._options.hooks.beforeRetry) {
+      await delay(ms, this.#userProvidedAbortSignal ? { signal: this.#userProvidedAbortSignal } : {});
+      if (error instanceof ForceRetryError && error.customRequest) {
+        const managedRequest = this.#options.signal ? new globalThis.Request(error.customRequest, { signal: this.#options.signal }) : new globalThis.Request(error.customRequest);
+        this.#assignRequest(managedRequest);
+      }
+      for (const hook of this.#options.hooks.beforeRetry) {
         const hookResult = await hook({
           request: this.request,
-          options: this._options,
+          options: this.#getNormalizedOptions(),
           error,
-          retryCount: this._retryCount
+          retryCount: this.#retryCount
         });
+        if (hookResult instanceof globalThis.Request) {
+          this.#assignRequest(hookResult);
+          break;
+        }
+        if (hookResult instanceof globalThis.Response) {
+          return hookResult;
+        }
         if (hookResult === stop) {
           return;
         }
       }
-      return this._retry(function_);
+      return this.#retry(function_);
     }
   }
-  async _fetch() {
-    for (const hook of this._options.hooks.beforeRequest) {
-      const result = await hook(this.request, this._options);
-      if (result instanceof Request) {
-        this.request = result;
-        break;
-      }
+  async#fetch() {
+    if (this.#abortController?.signal.aborted) {
+      this.#abortController = new globalThis.AbortController;
+      this.#options.signal = this.#userProvidedAbortSignal ? AbortSignal.any([this.#userProvidedAbortSignal, this.#abortController.signal]) : this.#abortController.signal;
+      this.request = new globalThis.Request(this.request, { signal: this.#options.signal });
+    }
+    for (const hook of this.#options.hooks.beforeRequest) {
+      const result = await hook(this.request, this.#getNormalizedOptions(), { retryCount: this.#retryCount });
       if (result instanceof Response) {
         return result;
       }
+      if (result instanceof globalThis.Request) {
+        this.#assignRequest(result);
+        break;
+      }
+    }
+    const nonRequestOptions = findUnknownOptions(this.request, this.#options);
+    this.#originalRequest = this.request;
+    this.request = this.#originalRequest.clone();
+    if (this.#options.timeout === false) {
+      return this.#options.fetch(this.#originalRequest, nonRequestOptions);
     }
-    const nonRequestOptions = findUnknownOptions(this.request, this._options);
-    this._originalRequest = this.request;
-    this.request = this._originalRequest.clone();
-    if (this._options.timeout === false) {
-      return this._options.fetch(this._originalRequest, nonRequestOptions);
+    return timeout(this.#originalRequest, nonRequestOptions, this.#abortController, this.#options);
+  }
+  #getNormalizedOptions() {
+    if (!this.#cachedNormalizedOptions) {
+      const { hooks, ...normalizedOptions } = this.#options;
+      this.#cachedNormalizedOptions = Object.freeze(normalizedOptions);
     }
-    return timeout(this._originalRequest, nonRequestOptions, this.abortController, this._options);
+    return this.#cachedNormalizedOptions;
+  }
+  #assignRequest(request) {
+    this.#cachedNormalizedOptions = undefined;
+    this.request = this.#wrapRequestWithUploadProgress(request);
+  }
+  #wrapRequestWithUploadProgress(request, originalBody) {
+    if (!this.#options.onUploadProgress || !request.body) {
+      return request;
+    }
+    return streamRequest(request, this.#options.onUploadProgress, originalBody ?? this.#options.body ?? undefined);
   }
 }
 
@@ -72175,6 +72345,7 @@ var createInstance = (defaults) => {
     return createInstance(validateAndMerge(defaults, newDefaults));
   };
   ky.stop = stop;
+  ky.retry = retry;
   return ky;
 };
 var ky = createInstance();
@@ -72198,7 +72369,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.468";
+var version = "0.1.469";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -72209,7 +72380,7 @@ var package_default = {
     "@tscircuit/circuit-json-util": "0.0.67",
     "@tscircuit/fake-snippets": "^0.0.128",
     "@tscircuit/file-server": "^0.0.32",
-    "@tscircuit/math-utils": "0.0.21",
+    "@tscircuit/math-utils": "0.0.29",
     "@tscircuit/props": "^0.0.371",
     "@tscircuit/runframe": "^0.0.1233",
     "@tscircuit/schematic-match-adapt": "^0.0.22",
@@ -72223,6 +72394,7 @@ var package_default = {
     "@types/semver": "^7.5.8",
     "bun-match-svg": "^0.0.12",
     chokidar: "4.0.1",
+    "circuit-json": "^0.0.306",
     "circuit-json-to-gltf": "^0.0.14",
     "circuit-json-to-kicad": "^0.0.3",
     "circuit-json-to-readable-netlist": "^0.0.13",
@@ -72257,10 +72429,9 @@ var package_default = {
     semver: "^7.6.3",
     sharp: "0.32.6",
     tempy: "^3.1.0",
-    tscircuit: "^0.0.757-libonly",
+    tscircuit: "^0.0.878-libonly",
     tsx: "^4.7.1",
     "typed-ky": "^0.0.4",
-    "circuit-json": "^0.0.275",
     zod: "3"
   },
   peerDependencies: {
@@ -94235,10 +94406,10 @@ var getSpiceWithPaddedSim = (circuitJson, options) => {
 // lib/eecircuit-engine/run-simulation.ts
 import { promises as fs26, existsSync as existsSync9 } from "node:fs";
 import path26 from "node:path";
-import os3 from "node:os";
+import os2 from "node:os";
 var sim = null;
 var fetchSimulation = async () => {
-  const tempFilePath = path26.join(os3.tmpdir(), "eecircuit-engine-1.5.2.mjs");
+  const tempFilePath = path26.join(os2.tmpdir(), "eecircuit-engine-1.5.2.mjs");
   if (!existsSync9(tempFilePath)) {
     const url = "https://cdn.jsdelivr.net/npm/eecircuit-engine@1.5.2/+esm";
     const response = await fetch(url);
@@ -100996,7 +101167,7 @@ var zo = rs.find((t2) => t2.text === "{REF}");
 zo.y = 0;
 zo.x = 0.35;
 zo.anchor = "middle_left";
-var os4 = es;
+var os3 = es;
 var is = { paths: { path11: { type: "path", points: [{ x: -0.39, y: 0 }, { x: 0.06, y: -0.01 }], color: "primary", fill: false }, path40: { type: "path", points: [{ x: 0.07, y: 0.19 }, { x: 0.07, y: -0.18 }], color: "primary", fill: false }, "path12-1": { type: "path", points: [{ x: 0.28, y: 0.53 }, { x: 0.28, y: 0.11 }], color: "primary", fill: false }, "path12-1-5": { type: "path", points: [{ x: 0.29, y: -0.53 }, { x: 0.29, y: -0.1 }], color: "primary", fill: false }, path2: { type: "path", points: [{ x: 0.07, y: 0.11 }, { x: 0.29, y: 0.11 }], color: "primary", fill: false }, "path2-5": { type: "path", points: [{ x: 0.07, y: -0.1 }, { x: 0.29, y: -0.1 }], color: "primary", fill: false }, path15: { type: "path", points: [{ x: -0.08, y: 0.06 }, { x: -0.08, y: -0.07 }, { x: 0.01, y: 0 }, { x: -0.08, y: 0.06 }], color: "primary", fill: true } }, texts: { top1: { type: "text", text: "{REF}", x: -0.15, y: 0.36 }, bottom1: { type: "text", text: "{VAL}", x: 0.04, y: -0.42 } }, refblocks: { top1: { x: 0.28, y: 0.55 }, bottom1: { x: 0.29, y: -0.55 }, left1: { x: -0.4, y: 0 } }, bounds: { minX: -0.43, maxX: 0.43, minY: -0.58, maxY: 0.58, width: 0.85, height: 1.16, centerX: 0, centerY: 0 }, circles: { path1: { type: "circle", x: 0.14, y: 0, radius: 0.29, color: "primary", fill: false } } };
 var { paths: ud, texts: ls, bounds: Ke, refblocks: Oo, circles: vd } = is;
 var t0 = s({ primitives: [...Object.values(ud), ...Object.values(vd), { ...ls.top1, anchor: "middle_right", x: 0 }, { ...ls.bottom1, anchor: "middle_right", x: 0 }], ports: [{ ...Oo.top1, labels: ["1", "drain"] }, { ...Oo.bottom1, labels: ["2", "source"] }, { ...Oo.left1, labels: ["3", "gate"] }], size: { width: Ke.width, height: Ke.height }, center: { x: Ke.centerX, y: Ke.centerY } });
@@ -101585,7 +101756,7 @@ var mb = Cl.primitives.find((t3) => t3.type === "text" && t3.text === "{VAL}");
 sb.anchor = "middle_left";
 mb.anchor = "middle_right";
 var B1 = Cl;
-var q1 = { ac_voltmeter_down: Ul, ac_voltmeter_horz: Wl, ac_voltmeter_left: Zl, ac_voltmeter_right: Kl, ac_voltmeter_up: ep, ac_voltmeter_vert: op, avalanche_diode_down: lp, avalanche_diode_horz: pp, avalanche_diode_left: yp, avalanche_diode_right: xp, avalanche_diode_up: mp, avalanche_diode_vert: fp, backward_diode_down: cp, backward_diode_left: Dt, backward_diode_right: _p, backward_diode_up: gp, battery_horz: Wt, battery_vert: Ap, boxresistor_down: Fp, boxresistor_left: Ep, boxresistor_right: Lp, boxresistor_small_down: jp, boxresistor_small_left: zp, boxresistor_small_right: Jp, boxresistor_small_up: Mp, boxresistor_up: Ip, bridged_ground_down: Dp, bridged_ground_left: Wp, bridged_ground_right: te, bridged_ground_up: Qp, capacitor_down: ta, capacitor_left: ea, capacitor_polarized_down: oa, capacitor_polarized_left: ia, capacitor_polarized_right: pa, capacitor_polarized_up: ya, capacitor_right: xa, capacitor_up: ma, constant_current_diode_down: fa, constant_current_diode_horz: ha, constant_current_diode_left: da, constant_current_diode_right: ba, constant_current_diode_up: ga, constant_current_diode_vert: va, crystal_4pin_down: wa, crystal_4pin_left: Aa, crystal_4pin_right: Pa, crystal_4pin_up: Sa, crystal_down: Ra, crystal_left: Ta, crystal_right: Ea, crystal_up: Xa, darlington_pair_transistor_down: La, darlington_pair_transistor_horz: Va, darlington_pair_transistor_left: ja, darlington_pair_transistor_right: ka, darlington_pair_transistor_up: za, darlington_pair_transistor_vert: Oa, dc_ammeter_horz: wt, dc_ammeter_vert: Ca, dc_voltmeter_down: Ia, dc_voltmeter_horz: qa, dc_voltmeter_left: Ua, dc_voltmeter_right: Wa, dc_voltmeter_up: Za, dc_voltmeter_vert: Ka, diac_down: ty, diac_horz: ey, diac_left: ry, diac_right: oy, diac_up: iy, diac_vert: ly, diode_down: ay, diode_left: yy, diode_right: $2, diode_up: xy, dpdt_normally_closed_switch_down: my, dpdt_normally_closed_switch_left: ny, dpdt_normally_closed_switch_right: M, dpdt_normally_closed_switch_up: fy, dpdt_switch_down: cy, dpdt_switch_left: dy, dpdt_switch_right: C, dpdt_switch_up: by, dpst_normally_closed_switch_down: gy, dpst_normally_closed_switch_left: uy, dpst_normally_closed_switch_right: N, dpst_normally_closed_switch_up: vy, dpst_switch_down: Ay, dpst_switch_left: Py, dpst_switch_right: I, dpst_switch_up: Sy, ferrite_bead_down: Ry, ferrite_bead_left: Ty, ferrite_bead_right: Fe, ferrite_bead_up: Se, filled_diode_down: Yy, filled_diode_horz: Ly, filled_diode_left: jy, filled_diode_right: zy, filled_diode_up: Jy, filled_diode_vert: My, frequency_meter_horz: At2, frequency_meter_vert: By, fuse_horz: ke, fuse_vert: Uy, ground_down: Gy, ground_horz: Wy, ground_left: Hy, ground_right: Zy, ground_up: Qy, ground_vert: Ky2, ground2_down: ex, ground2_left: ox, ground2_right: lx, ground2_up: ax, gunn_diode_horz: yx, gunn_diode_vert: xx, icled_down: mx, icled_left: nx, icled_right: q, icled_up: fx, igbt_transistor_horz: ze, igbt_transistor_vert: dx, illuminated_push_button_normally_open_horz: Oe, illuminated_push_button_normally_open_vert: ux, inductor_down: Px, inductor_left: Sx, inductor_right: _t, inductor_up: $e, laser_diode_down: Fx, laser_diode_left: Rx, laser_diode_right: D, laser_diode_up: Tx, led_down: Lx, led_left: Vx, led_right: gt, led_up: Ce, light_dependent_resistor_horz: Ie, light_dependent_resistor_vert: $x, mosfet_depletion_normally_on_horz: qe, mosfet_depletion_normally_on_vert: Ix, mushroom_head_normally_open_momentary_horz: Ue, mushroom_head_normally_open_momentary_vert: Ux, n_channel_d_mosfet_transistor_horz: He, n_channel_d_mosfet_transistor_vert: Qx, n_channel_e_mosfet_transistor_horz: Qe, n_channel_e_mosfet_transistor_vert: os4, njfet_transistor_horz: t0, njfet_transistor_vert: ys, not_connected_down: ms, not_connected_left: ns, not_connected_right: U, not_connected_up: fs28, npn_bipolar_transistor_down: hs, npn_bipolar_transistor_horz: cs, npn_bipolar_transistor_left: ds, npn_bipolar_transistor_right: bs, npn_bipolar_transistor_up: _s, npn_bipolar_transistor_vert: gs, opamp_no_power_down: vs, opamp_no_power_left: ws, opamp_no_power_right: G, opamp_no_power_up: As, opamp_with_power_down: Ss, opamp_with_power_left: Fs, opamp_with_power_right: W, opamp_with_power_up: Rs, p_channel_d_mosfet_transistor_horz: a0, p_channel_d_mosfet_transistor_vert: Ls, p_channel_e_mosfet_transistor_horz: x0, p_channel_e_mosfet_transistor_vert: Os, photodiode_horz: s0, photodiode_vert: Cs, pjfet_transistor_horz: n0, pjfet_transistor_vert: Ds, pnp_bipolar_transistor_down: Us, pnp_bipolar_transistor_horz: Gs, pnp_bipolar_transistor_left: Ws, pnp_bipolar_transistor_right: Hs, pnp_bipolar_transistor_up: Zs, pnp_bipolar_transistor_vert: Qs, potentiometer_horz: g0, potentiometer_vert: rm, potentiometer2_down: pm, potentiometer2_left: am, potentiometer2_right: H, potentiometer2_up: ym, potentiometer3_down: xm, potentiometer3_left: sm, potentiometer3_right: mm, potentiometer3_up: nm, power_factor_meter_horz: S0, power_factor_meter_vert: dm, push_button_normally_closed_momentary_horz: R0, push_button_normally_closed_momentary_vert: um, push_button_normally_open_momentary_horz: E0, push_button_normally_open_momentary_vert: Pm, rectifier_diode_horz: L0, rectifier_diode_vert: Rm, resistor_down: Em, resistor_left: Xm, resistor_right: Vm, resistor_up: km, resonator_down: Om, resonator_horz: M0, resonator_left: Jm, resonator_right: K, resonator_up: $m, resonator_vert: Mm, schottky_diode_down: Nm, schottky_diode_left: Im, schottky_diode_right: tt, schottky_diode_up: Bm, silicon_controlled_rectifier_horz: C0, silicon_controlled_rectifier_vert: Um, solderjumper2_bridged12_down: Gm, solderjumper2_bridged12_left: Wm, solderjumper2_bridged12_right: Hm, solderjumper2_bridged12_up: Zm, solderjumper2_down: Qm, solderjumper2_left: Km, solderjumper2_right: tn, solderjumper2_up: en, solderjumper3_bridged12_down: rn, solderjumper3_bridged12_left: on2, solderjumper3_bridged12_right: ln, solderjumper3_bridged12_up: pn, solderjumper3_bridged123_down: an, solderjumper3_bridged123_left: yn, solderjumper3_bridged123_right: xn, solderjumper3_bridged123_up: sn, solderjumper3_bridged23_down: mn, solderjumper3_bridged23_left: nn, solderjumper3_bridged23_right: fn, solderjumper3_bridged23_up: hn, solderjumper3_down: cn, solderjumper3_left: dn, solderjumper3_right: bn, solderjumper3_up: _n, spdt_normally_closed_switch_down: un, spdt_normally_closed_switch_left: vn, spdt_normally_closed_switch_right: at, spdt_normally_closed_switch_up: wn, spdt_switch_down: Pn, spdt_switch_left: Sn, spdt_switch_right: yt, spdt_switch_up: Fn, spst_normally_closed_switch_down: Rn, spst_normally_closed_switch_left: Tn, spst_normally_closed_switch_right: xt, spst_normally_closed_switch_up: En, spst_switch_down: Yn, spst_switch_left: Xn, spst_switch_right: st, spst_switch_up: Ln, square_wave_down: Vn, square_wave_left: jn, square_wave_right: kn, square_wave_up: zn, step_recovery_diode_horz: N0, step_recovery_diode_vert: On, tachometer_horz: Tt, tachometer_vert: Cn, testpoint_down: Bn, testpoint_left: qn, testpoint_right: nt, testpoint_up: Gn, tilted_ground_down: Hn, tilted_ground_left: Zn, tilted_ground_right: ut, tilted_ground_up: B0, triac_horz: q0, triac_vert: t1, tunnel_diode_horz: U0, tunnel_diode_vert: i1, unijunction_transistor_horz: W0, unijunction_transistor_vert: s1, usbc: n1, var_meter_horz: Z0, var_meter_vert: c1, varactor_diode_horz: K0, varactor_diode_vert: g1, varistor_horz: er, varistor_vert: A1, varmeter_horz: Et, varmeter_vert: R1, vcc_down: T1, vcc_left: E1, vcc_right: Y1, vcc_up: X1, volt_meter_horz: or, volt_meter_vert: L1, watt_hour_meter_horz: Yt, watt_hour_meter_vert: z1, wattmeter_horz: Xt, wattmeter_vert: M1, zener_diode_horz: ar, zener_diode_vert: B1 };
+var q1 = { ac_voltmeter_down: Ul, ac_voltmeter_horz: Wl, ac_voltmeter_left: Zl, ac_voltmeter_right: Kl, ac_voltmeter_up: ep, ac_voltmeter_vert: op, avalanche_diode_down: lp, avalanche_diode_horz: pp, avalanche_diode_left: yp, avalanche_diode_right: xp, avalanche_diode_up: mp, avalanche_diode_vert: fp, backward_diode_down: cp, backward_diode_left: Dt, backward_diode_right: _p, backward_diode_up: gp, battery_horz: Wt, battery_vert: Ap, boxresistor_down: Fp, boxresistor_left: Ep, boxresistor_right: Lp, boxresistor_small_down: jp, boxresistor_small_left: zp, boxresistor_small_right: Jp, boxresistor_small_up: Mp, boxresistor_up: Ip, bridged_ground_down: Dp, bridged_ground_left: Wp, bridged_ground_right: te, bridged_ground_up: Qp, capacitor_down: ta, capacitor_left: ea, capacitor_polarized_down: oa, capacitor_polarized_left: ia, capacitor_polarized_right: pa, capacitor_polarized_up: ya, capacitor_right: xa, capacitor_up: ma, constant_current_diode_down: fa, constant_current_diode_horz: ha, constant_current_diode_left: da, constant_current_diode_right: ba, constant_current_diode_up: ga, constant_current_diode_vert: va, crystal_4pin_down: wa, crystal_4pin_left: Aa, crystal_4pin_right: Pa, crystal_4pin_up: Sa, crystal_down: Ra, crystal_left: Ta, crystal_right: Ea, crystal_up: Xa, darlington_pair_transistor_down: La, darlington_pair_transistor_horz: Va, darlington_pair_transistor_left: ja, darlington_pair_transistor_right: ka, darlington_pair_transistor_up: za, darlington_pair_transistor_vert: Oa, dc_ammeter_horz: wt, dc_ammeter_vert: Ca, dc_voltmeter_down: Ia, dc_voltmeter_horz: qa, dc_voltmeter_left: Ua, dc_voltmeter_right: Wa, dc_voltmeter_up: Za, dc_voltmeter_vert: Ka, diac_down: ty, diac_horz: ey, diac_left: ry, diac_right: oy, diac_up: iy, diac_vert: ly, diode_down: ay, diode_left: yy, diode_right: $2, diode_up: xy, dpdt_normally_closed_switch_down: my, dpdt_normally_closed_switch_left: ny, dpdt_normally_closed_switch_right: M, dpdt_normally_closed_switch_up: fy, dpdt_switch_down: cy, dpdt_switch_left: dy, dpdt_switch_right: C, dpdt_switch_up: by, dpst_normally_closed_switch_down: gy, dpst_normally_closed_switch_left: uy, dpst_normally_closed_switch_right: N, dpst_normally_closed_switch_up: vy, dpst_switch_down: Ay, dpst_switch_left: Py, dpst_switch_right: I, dpst_switch_up: Sy, ferrite_bead_down: Ry, ferrite_bead_left: Ty, ferrite_bead_right: Fe, ferrite_bead_up: Se, filled_diode_down: Yy, filled_diode_horz: Ly, filled_diode_left: jy, filled_diode_right: zy, filled_diode_up: Jy, filled_diode_vert: My, frequency_meter_horz: At2, frequency_meter_vert: By, fuse_horz: ke, fuse_vert: Uy, ground_down: Gy, ground_horz: Wy, ground_left: Hy, ground_right: Zy, ground_up: Qy, ground_vert: Ky2, ground2_down: ex, ground2_left: ox, ground2_right: lx, ground2_up: ax, gunn_diode_horz: yx, gunn_diode_vert: xx, icled_down: mx, icled_left: nx, icled_right: q, icled_up: fx, igbt_transistor_horz: ze, igbt_transistor_vert: dx, illuminated_push_button_normally_open_horz: Oe, illuminated_push_button_normally_open_vert: ux, inductor_down: Px, inductor_left: Sx, inductor_right: _t, inductor_up: $e, laser_diode_down: Fx, laser_diode_left: Rx, laser_diode_right: D, laser_diode_up: Tx, led_down: Lx, led_left: Vx, led_right: gt, led_up: Ce, light_dependent_resistor_horz: Ie, light_dependent_resistor_vert: $x, mosfet_depletion_normally_on_horz: qe, mosfet_depletion_normally_on_vert: Ix, mushroom_head_normally_open_momentary_horz: Ue, mushroom_head_normally_open_momentary_vert: Ux, n_channel_d_mosfet_transistor_horz: He, n_channel_d_mosfet_transistor_vert: Qx, n_channel_e_mosfet_transistor_horz: Qe, n_channel_e_mosfet_transistor_vert: os3, njfet_transistor_horz: t0, njfet_transistor_vert: ys, not_connected_down: ms, not_connected_left: ns, not_connected_right: U, not_connected_up: fs28, npn_bipolar_transistor_down: hs, npn_bipolar_transistor_horz: cs, npn_bipolar_transistor_left: ds, npn_bipolar_transistor_right: bs, npn_bipolar_transistor_up: _s, npn_bipolar_transistor_vert: gs, opamp_no_power_down: vs, opamp_no_power_left: ws, opamp_no_power_right: G, opamp_no_power_up: As, opamp_with_power_down: Ss, opamp_with_power_left: Fs, opamp_with_power_right: W, opamp_with_power_up: Rs, p_channel_d_mosfet_transistor_horz: a0, p_channel_d_mosfet_transistor_vert: Ls, p_channel_e_mosfet_transistor_horz: x0, p_channel_e_mosfet_transistor_vert: Os, photodiode_horz: s0, photodiode_vert: Cs, pjfet_transistor_horz: n0, pjfet_transistor_vert: Ds, pnp_bipolar_transistor_down: Us, pnp_bipolar_transistor_horz: Gs, pnp_bipolar_transistor_left: Ws, pnp_bipolar_transistor_right: Hs, pnp_bipolar_transistor_up: Zs, pnp_bipolar_transistor_vert: Qs, potentiometer_horz: g0, potentiometer_vert: rm, potentiometer2_down: pm, potentiometer2_left: am, potentiometer2_right: H, potentiometer2_up: ym, potentiometer3_down: xm, potentiometer3_left: sm, potentiometer3_right: mm, potentiometer3_up: nm, power_factor_meter_horz: S0, power_factor_meter_vert: dm, push_button_normally_closed_momentary_horz: R0, push_button_normally_closed_momentary_vert: um, push_button_normally_open_momentary_horz: E0, push_button_normally_open_momentary_vert: Pm, rectifier_diode_horz: L0, rectifier_diode_vert: Rm, resistor_down: Em, resistor_left: Xm, resistor_right: Vm, resistor_up: km, resonator_down: Om, resonator_horz: M0, resonator_left: Jm, resonator_right: K, resonator_up: $m, resonator_vert: Mm, schottky_diode_down: Nm, schottky_diode_left: Im, schottky_diode_right: tt, schottky_diode_up: Bm, silicon_controlled_rectifier_horz: C0, silicon_controlled_rectifier_vert: Um, solderjumper2_bridged12_down: Gm, solderjumper2_bridged12_left: Wm, solderjumper2_bridged12_right: Hm, solderjumper2_bridged12_up: Zm, solderjumper2_down: Qm, solderjumper2_left: Km, solderjumper2_right: tn, solderjumper2_up: en, solderjumper3_bridged12_down: rn, solderjumper3_bridged12_left: on2, solderjumper3_bridged12_right: ln, solderjumper3_bridged12_up: pn, solderjumper3_bridged123_down: an, solderjumper3_bridged123_left: yn, solderjumper3_bridged123_right: xn, solderjumper3_bridged123_up: sn, solderjumper3_bridged23_down: mn, solderjumper3_bridged23_left: nn, solderjumper3_bridged23_right: fn, solderjumper3_bridged23_up: hn, solderjumper3_down: cn, solderjumper3_left: dn, solderjumper3_right: bn, solderjumper3_up: _n, spdt_normally_closed_switch_down: un, spdt_normally_closed_switch_left: vn, spdt_normally_closed_switch_right: at, spdt_normally_closed_switch_up: wn, spdt_switch_down: Pn, spdt_switch_left: Sn, spdt_switch_right: yt, spdt_switch_up: Fn, spst_normally_closed_switch_down: Rn, spst_normally_closed_switch_left: Tn, spst_normally_closed_switch_right: xt, spst_normally_closed_switch_up: En, spst_switch_down: Yn, spst_switch_left: Xn, spst_switch_right: st, spst_switch_up: Ln, square_wave_down: Vn, square_wave_left: jn, square_wave_right: kn, square_wave_up: zn, step_recovery_diode_horz: N0, step_recovery_diode_vert: On, tachometer_horz: Tt, tachometer_vert: Cn, testpoint_down: Bn, testpoint_left: qn, testpoint_right: nt, testpoint_up: Gn, tilted_ground_down: Hn, tilted_ground_left: Zn, tilted_ground_right: ut, tilted_ground_up: B0, triac_horz: q0, triac_vert: t1, tunnel_diode_horz: U0, tunnel_diode_vert: i1, unijunction_transistor_horz: W0, unijunction_transistor_vert: s1, usbc: n1, var_meter_horz: Z0, var_meter_vert: c1, varactor_diode_horz: K0, varactor_diode_vert: g1, varistor_horz: er, varistor_vert: A1, varmeter_horz: Et, varmeter_vert: R1, vcc_down: T1, vcc_left: E1, vcc_right: Y1, vcc_up: X1, volt_meter_horz: or, volt_meter_vert: L1, watt_hour_meter_horz: Yt, watt_hour_meter_vert: z1, wattmeter_horz: Xt, wattmeter_vert: M1, zener_diode_horz: ar, zener_diode_vert: B1 };
 var Y$ = Object.fromEntries(Object.keys(q1).map((t3) => [t3, t3]));
 function doesLineIntersectLine([a12, a22], [b12, b22], {
   lineThickness = 0
@@ -109281,7 +109452,7 @@ Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fet
       function attachSuspenseRetryListeners(finishedWork, wakeables) {
         var retryCache = getRetryCache(finishedWork);
         wakeables.forEach(function(wakeable) {
-          var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+          var retry2 = resolveRetryWakeable.bind(null, finishedWork, wakeable);
           if (!retryCache.has(wakeable)) {
             retryCache.add(wakeable);
             if (isDevToolsPresent)
@@ -109289,7 +109460,7 @@ Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fet
                 restorePendingUpdaters(inProgressRoot, inProgressLanes);
               else
                 throw Error("Expected finished root and lanes to be set. This is a bug in React.");
-            wakeable.then(retry, retry);
+            wakeable.then(retry2, retry2);
           }
         });
       }
@@ -121836,8 +122007,8 @@ Check the render method of \`` + ownerName + "`.";
             } else if (isSuspenseInstancePending(suspenseInstance)) {
               workInProgress2.flags |= DidCapture;
               workInProgress2.child = current22.child;
-              var retry = retryDehydratedSuspenseBoundary.bind(null, current22);
-              registerSuspenseInstanceRetry(suspenseInstance, retry);
+              var retry2 = retryDehydratedSuspenseBoundary.bind(null, current22);
+              registerSuspenseInstanceRetry(suspenseInstance, retry2);
               return null;
             } else {
               reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress2, suspenseInstance, suspenseState.treeContext);
@@ -124391,7 +124562,7 @@ Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-f
               retryCache = finishedWork.stateNode = new PossiblyWeakSet;
             }
             wakeables.forEach(function(wakeable) {
-              var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+              var retry2 = resolveRetryWakeable.bind(null, finishedWork, wakeable);
               if (!retryCache.has(wakeable)) {
                 retryCache.add(wakeable);
                 {
@@ -124403,7 +124574,7 @@ Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-f
                     }
                   }
                 }
-                wakeable.then(retry, retry);
+                wakeable.then(retry2, retry2);
               }
             });
           }
@@ -140951,7 +141122,7 @@ var import_debug62 = __toESM3(require_browser(), 1);
 var import_react = __toESM3(require_react(), 1);
 var import_react_reconciler = __toESM3(require_react_reconciler(), 1);
 var import_react_reconciler_18 = __toESM3(require_react_reconciler_18(), 1);
-var import_constants13 = __toESM3(require_constants6(), 1);
+var import_constants14 = __toESM3(require_constants6(), 1);
 var import_debug72 = __toESM3(require_browser(), 1);
 var import_debug82 = __toESM3(require_browser(), 1);
 var esm_exports2 = {};
@@ -185986,9 +186157,9 @@ var hostConfig = {
   detachDeletedInstance: (node) => {
     throw new Error("Function not implemented.");
   },
-  getCurrentEventPriority: () => import_constants13.DefaultEventPriority,
-  getCurrentUpdatePriority: () => import_constants13.DefaultEventPriority,
-  resolveUpdatePriority: () => import_constants13.DefaultEventPriority,
+  getCurrentEventPriority: () => import_constants14.DefaultEventPriority,
+  getCurrentUpdatePriority: () => import_constants14.DefaultEventPriority,
+  resolveUpdatePriority: () => import_constants14.DefaultEventPriority,
   setCurrentUpdatePriority: () => {},
   maySuspendCommit: () => false,
   supportsHydration: false
@@ -195691,8 +195862,8 @@ var registerRemove = (program3) => {
 };
 
 // cli/build/register.ts
-import path32 from "node:path";
-import fs33 from "node:fs";
+import path33 from "node:path";
+import fs34 from "node:fs";
 
 // cli/build/build-file.ts
 import path29 from "node:path";
@@ -195966,9 +196137,118 @@ var buildPreviewImages = async ({
   });
 };
 
+// cli/build/transpile.ts
+import path32 from "node:path";
+import fs33 from "node:fs";
+import { rollup } from "rollup";
+import typescript from "@rollup/plugin-typescript";
+import resolve11 from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+import dts from "rollup-plugin-dts";
+var transpileFile = async ({
+  input,
+  outputDir,
+  projectDir
+}) => {
+  try {
+    fs33.mkdirSync(outputDir, { recursive: true });
+    console.log("Building ESM bundle...");
+    const esmBundle = await rollup({
+      input,
+      external: (id2) => {
+        return !id2.startsWith(".") && !id2.startsWith("/");
+      },
+      plugins: [
+        resolve11({
+          extensions: [".ts", ".tsx", ".js", ".jsx"]
+        }),
+        commonjs(),
+        typescript({
+          jsx: "react",
+          tsconfig: false,
+          compilerOptions: {
+            target: "ES2020",
+            module: "ESNext",
+            jsx: "react",
+            declaration: false,
+            sourceMap: false,
+            skipLibCheck: true
+          }
+        })
+      ]
+    });
+    await esmBundle.write({
+      file: path32.join(outputDir, "index.js"),
+      format: "es",
+      sourcemap: false
+    });
+    console.log(`ESM bundle written to ${path32.relative(projectDir, path32.join(outputDir, "index.js"))}`);
+    console.log("Building CommonJS bundle...");
+    const cjsBundle = await rollup({
+      input,
+      external: (id2) => {
+        return !id2.startsWith(".") && !id2.startsWith("/");
+      },
+      plugins: [
+        resolve11({
+          extensions: [".ts", ".tsx", ".js", ".jsx"]
+        }),
+        commonjs(),
+        typescript({
+          jsx: "react",
+          tsconfig: false,
+          compilerOptions: {
+            target: "ES2020",
+            module: "CommonJS",
+            jsx: "react",
+            declaration: false,
+            sourceMap: false,
+            skipLibCheck: true
+          }
+        })
+      ]
+    });
+    await cjsBundle.write({
+      file: path32.join(outputDir, "index.cjs"),
+      format: "cjs",
+      sourcemap: false
+    });
+    console.log(`CommonJS bundle written to ${path32.relative(projectDir, path32.join(outputDir, "index.cjs"))}`);
+    console.log("Generating type declarations...");
+    const dtsBundle = await rollup({
+      input,
+      external: (id2) => {
+        return !id2.startsWith(".") && !id2.startsWith("/");
+      },
+      plugins: [
+        dts({
+          respectExternal: true
+        })
+      ]
+    });
+    const dtsOutput = await dtsBundle.generate({
+      format: "es"
+    });
+    let dtsContent = dtsOutput.output[0].code;
+    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();
+    fs33.writeFileSync(path32.join(outputDir, "index.d.ts"), dtsContent);
+    console.log(`Type declarations written to ${path32.relative(projectDir, path32.join(outputDir, "index.d.ts"))}`);
+    console.log(kleur_default.green("Transpilation complete!"));
+    return true;
+  } catch (err) {
+    console.error(kleur_default.red(`Transpilation failed: ${err}`));
+    if (err instanceof Error && err.stack) {
+      console.error(err.stack);
+    }
+    return false;
+  }
+};
+
 // cli/build/register.ts
 var registerBuild = (program3) => {
-  program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").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("--preview-images", "Generate preview images in the dist directory").option("--all-images", "Generate preview images for every successful build output").action(async (file, options) => {
+  program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").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").action(async (file, options) => {
     try {
       const { projectDir, circuitFiles, mainEntrypoint } = await getBuildEntrypoints({
         fileOrDir: file
@@ -195985,17 +196265,17 @@ var registerBuild = (program3) => {
         }
         return config;
       })();
-      const distDir = path32.join(projectDir, "dist");
-      fs33.mkdirSync(distDir, { recursive: true });
+      const distDir = path33.join(projectDir, "dist");
+      fs34.mkdirSync(distDir, { recursive: true });
       console.log(`Building ${circuitFiles.length} file(s)...`);
       let hasErrors = false;
       const staticFileReferences = [];
       const builtFiles = [];
       for (const filePath of circuitFiles) {
-        const relative9 = path32.relative(projectDir, filePath);
+        const relative9 = path33.relative(projectDir, filePath);
         console.log(`Building ${relative9}...`);
         const outputDirName = relative9.replace(/(\.board|\.circuit)?\.tsx$/, "");
-        const outputPath = path32.join(distDir, outputDirName, "circuit.json");
+        const outputPath = path33.join(distDir, outputDirName, "circuit.json");
         const ok = await buildFile(filePath, outputPath, projectDir, {
           ignoreErrors: options?.ignoreErrors,
           ignoreWarnings: options?.ignoreWarnings,
@@ -196009,9 +196289,9 @@ var registerBuild = (program3) => {
         if (!ok) {
           hasErrors = true;
         } else if (options?.site) {
-          const normalizedSourcePath = relative9.split(path32.sep).join("/");
-          const relativeOutputPath = path32.join(outputDirName, "circuit.json");
-          const normalizedOutputPath = relativeOutputPath.split(path32.sep).join("/");
+          const normalizedSourcePath = relative9.split(path33.sep).join("/");
+          const relativeOutputPath = path33.join(outputDirName, "circuit.json");
+          const normalizedOutputPath = relativeOutputPath.split(path33.sep).join("/");
           staticFileReferences.push({
             filePath: normalizedSourcePath,
             fileStaticAssetUrl: `./${normalizedOutputPath}`
@@ -196031,13 +196311,30 @@ var registerBuild = (program3) => {
           allImages: options?.allImages
         });
       }
+      if (options?.transpile) {
+        console.log("Transpiling entry file...");
+        const entryFile = mainEntrypoint || circuitFiles[0];
+        if (!entryFile) {
+          console.error("No entry file found for transpilation");
+          process.exit(1);
+        }
+        const transpileSuccess = await transpileFile({
+          input: entryFile,
+          outputDir: distDir,
+          projectDir
+        });
+        if (!transpileSuccess) {
+          console.error("Transpilation failed");
+          process.exit(1);
+        }
+      }
       if (options?.site) {
         const indexHtml = getStaticIndexHtmlFile({
           files: staticFileReferences,
           standaloneScriptSrc: "./standalone.min.js"
         });
-        fs33.writeFileSync(path32.join(distDir, "index.html"), indexHtml);
-        fs33.writeFileSync(path32.join(distDir, "standalone.min.js"), standalone_min_default);
+        fs34.writeFileSync(path33.join(distDir, "index.html"), indexHtml);
+        fs34.writeFileSync(path33.join(distDir, "standalone.min.js"), standalone_min_default);
       }
       console.log("Build complete!");
       process.exit(0);
@@ -196050,8 +196347,8 @@ var registerBuild = (program3) => {
 };
 
 // lib/shared/snapshot-project.ts
-import fs35 from "node:fs";
-import path33 from "node:path";
+import fs36 from "node:fs";
+import path34 from "node:path";
 import looksSame2 from "looks-same";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg3,
@@ -196062,7 +196359,7 @@ import { renderGLTFToPNGBufferFromGLBBuffer as renderGLTFToPNGBufferFromGLBBuffe
 
 // lib/shared/compare-images.ts
 import looksSame from "looks-same";
-import fs34 from "node:fs/promises";
+import fs35 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
   const { equal: equal2 } = await looksSame(buffer1, buffer2, {
     strict: false,
@@ -196078,7 +196375,7 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
         tolerance: 2
       });
     } else {
-      await fs34.writeFile(diffPath, buffer2);
+      await fs35.writeFile(diffPath, buffer2);
     }
   }
   return { equal: equal2 };
@@ -196103,7 +196400,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f) => path33.resolve(projectDir, f));
+  const resolvedPaths = filePaths.map((f) => path34.resolve(projectDir, f));
   const boardFiles = findBoardFiles({
     projectDir,
     ignore,
@@ -196117,7 +196414,7 @@ var snapshotProject = async ({
   const mismatches = [];
   let didUpdate = false;
   for (const file of boardFiles) {
-    const relativeFilePath = path33.relative(projectDir, file);
+    const relativeFilePath = path34.relative(projectDir, file);
     let circuitJson;
     let pcbSvg;
     let schSvg;
@@ -196171,17 +196468,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 = path33.dirname(file);
-          const relativeDir = path33.relative(projectDir, fileDir);
-          const snapDir2 = snapshotsDirName ? path33.join(projectDir, snapshotsDirName, relativeDir) : path33.join(fileDir, "__snapshots__");
-          const base2 = path33.basename(file).replace(/\.tsx$/, "");
-          const snap3dPath = path33.join(snapDir2, `${base2}-3d.snap.png`);
-          const existing3dSnapshot = fs35.existsSync(snap3dPath);
+          const fileDir = path34.dirname(file);
+          const relativeDir = path34.relative(projectDir, fileDir);
+          const snapDir2 = snapshotsDirName ? path34.join(projectDir, snapshotsDirName, relativeDir) : path34.join(fileDir, "__snapshots__");
+          const base2 = path34.basename(file).replace(/\.tsx$/, "");
+          const snap3dPath = path34.join(snapDir2, `${base2}-3d.snap.png`);
+          const existing3dSnapshot = fs36.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: ${path33.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path34.relative(projectDir, snap3dPath)}
 `));
             return onExit(1);
           } else {
@@ -196197,9 +196494,9 @@ var snapshotProject = async ({
         }
       }
     }
-    const snapDir = snapshotsDirName ? path33.join(projectDir, snapshotsDirName, path33.relative(projectDir, path33.dirname(file))) : path33.join(path33.dirname(file), "__snapshots__");
-    fs35.mkdirSync(snapDir, { recursive: true });
-    const base = path33.basename(file).replace(/\.tsx$/, "");
+    const snapDir = snapshotsDirName ? path34.join(projectDir, snapshotsDirName, path34.relative(projectDir, path34.dirname(file))) : path34.join(path34.dirname(file), "__snapshots__");
+    fs36.mkdirSync(snapDir, { recursive: true });
+    const base = path34.basename(file).replace(/\.tsx$/, "");
     const snapshots = [];
     if (pcbOnly || !schematicOnly) {
       snapshots.push({ type: "pcb", content: pcbSvg, isBinary: false });
@@ -196217,31 +196514,31 @@ var snapshotProject = async ({
     for (const snapshot of snapshots) {
       const { type } = snapshot;
       const is3d = type === "3d";
-      const snapPath = path33.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-      const existing = fs35.existsSync(snapPath);
+      const snapPath = path34.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+      const existing = fs36.existsSync(snapPath);
       const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
       const newContentForFile = snapshot.content;
       if (!existing) {
-        fs35.writeFileSync(snapPath, newContentForFile);
-        console.log("✅", kleur_default.gray(path33.relative(projectDir, snapPath)));
+        fs36.writeFileSync(snapPath, newContentForFile);
+        console.log("✅", kleur_default.gray(path34.relative(projectDir, snapPath)));
         didUpdate = true;
         continue;
       }
-      const oldContentBuffer = fs35.readFileSync(snapPath);
+      const oldContentBuffer = fs36.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(path33.relative(projectDir, snapPath)));
+          console.log("✅", kleur_default.gray(path34.relative(projectDir, snapPath)));
         } else {
-          fs35.writeFileSync(snapPath, newContentForFile);
-          console.log("✅", kleur_default.gray(path33.relative(projectDir, snapPath)));
+          fs36.writeFileSync(snapPath, newContentForFile);
+          console.log("✅", kleur_default.gray(path34.relative(projectDir, snapPath)));
           didUpdate = true;
         }
       } else if (!equal2) {
         mismatches.push(`${snapPath} (diff: ${diffPath})`);
       } else {
-        console.log("✅", kleur_default.gray(path33.relative(projectDir, snapPath)));
+        console.log("✅", kleur_default.gray(path34.relative(projectDir, snapPath)));
       }
     }
   }
@@ -196280,22 +196577,22 @@ var registerSnapshot = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs36 from "node:fs";
-import path34 from "node:path";
+import fs37 from "node:fs";
+import path35 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path34.resolve(startDir);
-    while (dir !== path34.parse(dir).root) {
-      if (fs36.existsSync(path34.join(dir, ".git"))) {
+    let dir = path35.resolve(startDir);
+    while (dir !== path35.parse(dir).root) {
+      if (fs37.existsSync(path35.join(dir, ".git"))) {
         return dir;
       }
-      dir = path34.dirname(dir);
+      dir = path35.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path34.join(gitRoot, ".github", "workflows");
-  fs36.mkdirSync(workflowsDir, { recursive: true });
+  const workflowsDir = path35.join(gitRoot, ".github", "workflows");
+  fs37.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -196334,8 +196631,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path34.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path34.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path35.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path35.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -196361,8 +196658,8 @@ var registerSetup = (program3) => {
 };
 
 // cli/convert/register.ts
-import fs37 from "node:fs/promises";
-import path35 from "node:path";
+import fs38 from "node:fs/promises";
+import path36 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
 
 // node_modules/@tscircuit/mm/dist/index.js
@@ -196482,15 +196779,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 = path35.resolve(file);
-      const modContent = await fs37.readFile(inputPath, "utf-8");
+      const inputPath = path36.resolve(file);
+      const modContent = await fs38.readFile(inputPath, "utf-8");
       const circuitJson = await parseKicadModToCircuitJson(modContent);
-      const componentName = options.name ?? path35.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path36.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path35.resolve(options.output) : path35.join(path35.dirname(inputPath), `${componentName}.tsx`);
-      await fs37.writeFile(outputPath, tsx);
+      const outputPath = options.output ? path36.resolve(options.output) : path36.join(path36.dirname(inputPath), `${componentName}.tsx`);
+      await fs38.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);