@tscircuit/cli 0.1.306 → 0.1.307

package/dist/main.js

@@ -69,7 +69,7 @@ var require_argument = __commonJS((exports2) => {
           this._name = name;
           break;
       }
-      if (this._name.length > 3 && this._name.slice(-3) === "...") {
+      if (this._name.endsWith("...")) {
         this.variadic = true;
         this._name = this._name.slice(0, -3);
       }
@@ -77,11 +77,12 @@ var require_argument = __commonJS((exports2) => {
     name() {
       return this._name;
     }
-    _concatValue(value, previous) {
+    _collectValue(value, previous) {
       if (previous === this.defaultValue || !Array.isArray(previous)) {
         return [value];
       }
-      return previous.concat(value);
+      previous.push(value);
+      return previous;
     }
     default(value, description) {
       this.defaultValue = value;
@@ -99,7 +100,7 @@ var require_argument = __commonJS((exports2) => {
           throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
         }
         if (this.variadic) {
-          return this._concatValue(arg, previous);
+          return this._collectValue(arg, previous);
         }
         return arg;
       };
@@ -546,11 +547,12 @@ var require_option = __commonJS((exports2) => {
       this.hidden = !!hide;
       return this;
     }
-    _concatValue(value, previous) {
+    _collectValue(value, previous) {
       if (previous === this.defaultValue || !Array.isArray(previous)) {
         return [value];
       }
-      return previous.concat(value);
+      previous.push(value);
+      return previous;
     }
     choices(values) {
       this.argChoices = values.slice();
@@ -559,7 +561,7 @@ var require_option = __commonJS((exports2) => {
           throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
         }
         if (this.variadic) {
-          return this._concatValue(arg, previous);
+          return this._collectValue(arg, previous);
         }
         return arg;
       };
@@ -865,7 +867,10 @@ var require_command = __commonJS((exports2) => {
     configureOutput(configuration) {
       if (configuration === undefined)
         return this._outputConfiguration;
-      this._outputConfiguration = Object.assign({}, this._outputConfiguration, configuration);
+      this._outputConfiguration = {
+        ...this._outputConfiguration,
+        ...configuration
+      };
       return this;
     }
     showHelpAfterError(displayHelp = true) {
@@ -914,7 +919,7 @@ var require_command = __commonJS((exports2) => {
     }
     addArgument(argument) {
       const previousArgument = this.registeredArguments.slice(-1)[0];
-      if (previousArgument && previousArgument.variadic) {
+      if (previousArgument?.variadic) {
         throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
       }
       if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
@@ -1069,7 +1074,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (val !== null && option.parseArg) {
           val = this._callParseArg(option, val, oldValue, invalidValueMessage);
         } else if (val !== null && option.variadic) {
-          val = option._concatValue(val, oldValue);
+          val = option._collectValue(val, oldValue);
         }
         if (val == null) {
           if (option.negate) {
@@ -1444,7 +1449,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this.processedArgs = processedArgs;
     }
     _chainOrCall(promise, fn) {
-      if (promise && promise.then && typeof promise.then === "function") {
+      if (promise?.then && typeof promise.then === "function") {
         return promise.then(() => fn());
       }
       return fn();
@@ -1521,7 +1526,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
         return promiseChain;
       }
-      if (this.parent && this.parent.listenerCount(commandEvent)) {
+      if (this.parent?.listenerCount(commandEvent)) {
         checkForUnknownOptions();
         this._processArguments();
         this.parent.emit(commandEvent, operands, unknown);
@@ -1583,11 +1588,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         cmd._checkForConflictingLocalOptions();
       });
     }
-    parseOptions(argv) {
+    parseOptions(args) {
       const operands = [];
       const unknown = [];
       let dest = operands;
-      const args = argv.slice();
       function maybeOption(arg) {
         return arg.length > 1 && arg[0] === "-";
       }
@@ -1597,12 +1601,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
         return !this._getCommandAndAncestors().some((cmd) => cmd.options.map((opt) => opt.short).some((short) => /^-\d$/.test(short)));
       };
       let activeVariadicOption = null;
-      while (args.length) {
-        const arg = args.shift();
+      let activeGroup = null;
+      let i = 0;
+      while (i < args.length || activeGroup) {
+        const arg = activeGroup ?? args[i++];
+        activeGroup = null;
         if (arg === "--") {
           if (dest === unknown)
             dest.push(arg);
-          dest.push(...args);
+          dest.push(...args.slice(i));
           break;
         }
         if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
@@ -1614,14 +1621,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
           const option = this._findOption(arg);
           if (option) {
             if (option.required) {
-              const value = args.shift();
+              const value = args[i++];
               if (value === undefined)
                 this.optionMissingArgument(option);
               this.emit(`option:${option.name()}`, value);
             } else if (option.optional) {
               let value = null;
-              if (args.length > 0 && (!maybeOption(args[0]) || negativeNumberArg(args[0]))) {
-                value = args.shift();
+              if (i < args.length && (!maybeOption(args[i]) || negativeNumberArg(args[i]))) {
+                value = args[i++];
               }
               this.emit(`option:${option.name()}`, value);
             } else {
@@ -1638,7 +1645,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
               this.emit(`option:${option.name()}`, arg.slice(2));
             } else {
               this.emit(`option:${option.name()}`);
-              args.unshift(`-${arg.slice(2)}`);
+              activeGroup = `-${arg.slice(2)}`;
             }
             continue;
           }
@@ -1657,25 +1664,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
           if (this._findCommand(arg)) {
             operands.push(arg);
-            if (args.length > 0)
-              unknown.push(...args);
+            unknown.push(...args.slice(i));
             break;
           } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
-            operands.push(arg);
-            if (args.length > 0)
-              operands.push(...args);
+            operands.push(arg, ...args.slice(i));
             break;
           } else if (this._defaultCommandName) {
-            unknown.push(arg);
-            if (args.length > 0)
-              unknown.push(...args);
+            unknown.push(arg, ...args.slice(i));
             break;
           }
         }
         if (this._passThroughOptions) {
-          dest.push(arg);
-          if (args.length > 0)
-            dest.push(...args);
+          dest.push(arg, ...args.slice(i));
           break;
         }
         dest.push(arg);
@@ -5114,91 +5114,60 @@ var require_data = __commonJS((exports2, module2) => {
   };
 });
 
-// node_modules/fast-uri/lib/scopedChars.js
-var require_scopedChars = __commonJS((exports2, module2) => {
-  var HEX = {
-    0: 0,
-    1: 1,
-    2: 2,
-    3: 3,
-    4: 4,
-    5: 5,
-    6: 6,
-    7: 7,
-    8: 8,
-    9: 9,
-    a: 10,
-    A: 10,
-    b: 11,
-    B: 11,
-    c: 12,
-    C: 12,
-    d: 13,
-    D: 13,
-    e: 14,
-    E: 14,
-    f: 15,
-    F: 15
-  };
-  module2.exports = {
-    HEX
-  };
-});
-
 // node_modules/fast-uri/lib/utils.js
 var require_utils = __commonJS((exports2, module2) => {
-  var { HEX } = require_scopedChars();
-  var IPV4_REG = /^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u;
-  function normalizeIPv4(host) {
-    if (findToken(host, ".") < 3) {
-      return { host, isIPV4: false };
-    }
-    const matches = host.match(IPV4_REG) || [];
-    const [address] = matches;
-    if (address) {
-      return { host: stripLeadingZeros(address, "."), isIPV4: true };
-    } else {
-      return { host, isIPV4: false };
-    }
-  }
-  function stringArrayToHexStripped(input, keepZero = false) {
+  var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
+  var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+  function stringArrayToHexStripped(input) {
     let acc = "";
-    let strip = true;
-    for (const c of input) {
-      if (HEX[c] === undefined)
-        return;
-      if (c !== "0" && strip === true)
-        strip = false;
-      if (!strip)
-        acc += c;
+    let code = 0;
+    let i = 0;
+    for (i = 0;i < input.length; i++) {
+      code = input[i].charCodeAt(0);
+      if (code === 48) {
+        continue;
+      }
+      if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) {
+        return "";
+      }
+      acc += input[i];
+      break;
+    }
+    for (i += 1;i < input.length; i++) {
+      code = input[i].charCodeAt(0);
+      if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) {
+        return "";
+      }
+      acc += input[i];
     }
-    if (keepZero && acc.length === 0)
-      acc = "0";
     return acc;
   }
+  var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
+  function consumeIsZone(buffer) {
+    buffer.length = 0;
+    return true;
+  }
+  function consumeHextets(buffer, address, output) {
+    if (buffer.length) {
+      const hex = stringArrayToHexStripped(buffer);
+      if (hex !== "") {
+        address.push(hex);
+      } else {
+        output.error = true;
+        return false;
+      }
+      buffer.length = 0;
+    }
+    return true;
+  }
   function getIPV6(input) {
     let tokenCount = 0;
     const output = { error: false, address: "", zone: "" };
     const address = [];
     const buffer = [];
-    let isZone = false;
     let endipv6Encountered = false;
     let endIpv6 = false;
-    function consume() {
-      if (buffer.length) {
-        if (isZone === false) {
-          const hex = stringArrayToHexStripped(buffer);
-          if (hex !== undefined) {
-            address.push(hex);
-          } else {
-            output.error = true;
-            return false;
-          }
-        }
-        buffer.length = 0;
-      }
-      return true;
-    }
+    let consume = consumeHextets;
     for (let i = 0;i < input.length; i++) {
       const cursor = input[i];
       if (cursor === "[" || cursor === "]") {
@@ -5208,31 +5177,30 @@ var require_utils = __commonJS((exports2, module2) => {
         if (endipv6Encountered === true) {
           endIpv6 = true;
         }
-        if (!consume()) {
+        if (!consume(buffer, address, output)) {
           break;
         }
-        tokenCount++;
-        address.push(":");
-        if (tokenCount > 7) {
+        if (++tokenCount > 7) {
           output.error = true;
           break;
         }
-        if (i - 1 >= 0 && input[i - 1] === ":") {
+        if (i > 0 && input[i - 1] === ":") {
           endipv6Encountered = true;
         }
+        address.push(":");
         continue;
       } else if (cursor === "%") {
-        if (!consume()) {
+        if (!consume(buffer, address, output)) {
           break;
         }
-        isZone = true;
+        consume = consumeIsZone;
       } else {
         buffer.push(cursor);
         continue;
       }
     }
     if (buffer.length) {
-      if (isZone) {
+      if (consume === consumeIsZone) {
         output.zone = buffer.join("");
       } else if (endIpv6) {
         address.push(buffer.join(""));
@@ -5255,33 +5223,11 @@ var require_utils = __commonJS((exports2, module2) => {
         newHost += "%" + ipv6.zone;
         escapedHost += "%25" + ipv6.zone;
       }
-      return { host: newHost, escapedHost, isIPV6: true };
+      return { host: newHost, isIPV6: true, escapedHost };
     } else {
       return { host, isIPV6: false };
     }
   }
-  function stripLeadingZeros(str, token) {
-    let out = "";
-    let skip = true;
-    const l = str.length;
-    for (let i = 0;i < l; i++) {
-      const c = str[i];
-      if (c === "0" && skip) {
-        if (i + 1 <= l && str[i + 1] === token || i + 1 === l) {
-          out += c;
-          skip = false;
-        }
-      } else {
-        if (c === token) {
-          skip = true;
-        } else {
-          skip = false;
-        }
-        out += c;
-      }
-    }
-    return out;
-  }
   function findToken(str, token) {
     let ind = 0;
     for (let i = 0;i < str.length; i++) {
@@ -5290,89 +5236,134 @@ var require_utils = __commonJS((exports2, module2) => {
     }
     return ind;
   }
-  var RDS1 = /^\.\.?\//u;
-  var RDS2 = /^\/\.(?:\/|$)/u;
-  var RDS3 = /^\/\.\.(?:\/|$)/u;
-  var RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/u;
-  function removeDotSegments(input) {
+  function removeDotSegments(path8) {
+    let input = path8;
     const output = [];
-    while (input.length) {
-      if (input.match(RDS1)) {
-        input = input.replace(RDS1, "");
-      } else if (input.match(RDS2)) {
-        input = input.replace(RDS2, "/");
-      } else if (input.match(RDS3)) {
-        input = input.replace(RDS3, "/");
-        output.pop();
-      } else if (input === "." || input === "..") {
-        input = "";
-      } else {
-        const im = input.match(RDS5);
-        if (im) {
-          const s = im[0];
-          input = input.slice(s.length);
-          output.push(s);
+    let nextSlash = -1;
+    let len = 0;
+    while (len = input.length) {
+      if (len === 1) {
+        if (input === ".") {
+          break;
+        } else if (input === "/") {
+          output.push("/");
+          break;
         } else {
-          throw new Error("Unexpected dot segment condition");
+          output.push(input);
+          break;
+        }
+      } else if (len === 2) {
+        if (input[0] === ".") {
+          if (input[1] === ".") {
+            break;
+          } else if (input[1] === "/") {
+            input = input.slice(2);
+            continue;
+          }
+        } else if (input[0] === "/") {
+          if (input[1] === "." || input[1] === "/") {
+            output.push("/");
+            break;
+          }
+        }
+      } else if (len === 3) {
+        if (input === "/..") {
+          if (output.length !== 0) {
+            output.pop();
+          }
+          output.push("/");
+          break;
+        }
+      }
+      if (input[0] === ".") {
+        if (input[1] === ".") {
+          if (input[2] === "/") {
+            input = input.slice(3);
+            continue;
+          }
+        } else if (input[1] === "/") {
+          input = input.slice(2);
+          continue;
+        }
+      } else if (input[0] === "/") {
+        if (input[1] === ".") {
+          if (input[2] === "/") {
+            input = input.slice(2);
+            continue;
+          } else if (input[2] === ".") {
+            if (input[3] === "/") {
+              input = input.slice(3);
+              if (output.length !== 0) {
+                output.pop();
+              }
+              continue;
+            }
+          }
         }
       }
+      if ((nextSlash = input.indexOf("/", 1)) === -1) {
+        output.push(input);
+        break;
+      } else {
+        output.push(input.slice(0, nextSlash));
+        input = input.slice(nextSlash);
+      }
     }
     return output.join("");
   }
-  function normalizeComponentEncoding(components, esc) {
+  function normalizeComponentEncoding(component, esc) {
     const func = esc !== true ? escape : unescape;
-    if (components.scheme !== undefined) {
-      components.scheme = func(components.scheme);
+    if (component.scheme !== undefined) {
+      component.scheme = func(component.scheme);
     }
-    if (components.userinfo !== undefined) {
-      components.userinfo = func(components.userinfo);
+    if (component.userinfo !== undefined) {
+      component.userinfo = func(component.userinfo);
     }
-    if (components.host !== undefined) {
-      components.host = func(components.host);
+    if (component.host !== undefined) {
+      component.host = func(component.host);
     }
-    if (components.path !== undefined) {
-      components.path = func(components.path);
+    if (component.path !== undefined) {
+      component.path = func(component.path);
     }
-    if (components.query !== undefined) {
-      components.query = func(components.query);
+    if (component.query !== undefined) {
+      component.query = func(component.query);
     }
-    if (components.fragment !== undefined) {
-      components.fragment = func(components.fragment);
+    if (component.fragment !== undefined) {
+      component.fragment = func(component.fragment);
     }
-    return components;
+    return component;
   }
-  function recomposeAuthority(components) {
+  function recomposeAuthority(component) {
     const uriTokens = [];
-    if (components.userinfo !== undefined) {
-      uriTokens.push(components.userinfo);
+    if (component.userinfo !== undefined) {
+      uriTokens.push(component.userinfo);
       uriTokens.push("@");
     }
-    if (components.host !== undefined) {
-      let host = unescape(components.host);
-      const ipV4res = normalizeIPv4(host);
-      if (ipV4res.isIPV4) {
-        host = ipV4res.host;
-      } else {
-        const ipV6res = normalizeIPv6(ipV4res.host);
+    if (component.host !== undefined) {
+      let host = unescape(component.host);
+      if (!isIPv4(host)) {
+        const ipV6res = normalizeIPv6(host);
         if (ipV6res.isIPV6 === true) {
           host = `[${ipV6res.escapedHost}]`;
         } else {
-          host = components.host;
+          host = component.host;
         }
       }
       uriTokens.push(host);
     }
-    if (typeof components.port === "number" || typeof components.port === "string") {
+    if (typeof component.port === "number" || typeof component.port === "string") {
       uriTokens.push(":");
-      uriTokens.push(String(components.port));
+      uriTokens.push(String(component.port));
     }
     return uriTokens.length ? uriTokens.join("") : undefined;
   }
   module2.exports = {
+    nonSimpleDomain,
     recomposeAuthority,
     normalizeComponentEncoding,
     removeDotSegments,
-    normalizeIPv4,
+    isIPv4,
+    isUUID,
     normalizeIPv6,
     stringArrayToHexStripped
   };
@@ -5380,99 +5371,121 @@ var require_utils = __commonJS((exports2, module2) => {
 
 // node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS((exports2, module2) => {
-  var UUID_REG = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu;
+  var { isUUID } = require_utils();
   var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
-  function isSecure(wsComponents) {
-    return typeof wsComponents.secure === "boolean" ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss";
+  var supportedSchemeNames = [
+    "http",
+    "https",
+    "ws",
+    "wss",
+    "urn",
+    "urn:uuid"
+  ];
+  function isValidSchemeName(name) {
+    return supportedSchemeNames.indexOf(name) !== -1;
   }
-  function httpParse(components) {
-    if (!components.host) {
-      components.error = components.error || "HTTP URIs must have a host.";
+  function wsIsSecure(wsComponent) {
+    if (wsComponent.secure === true) {
+      return true;
+    } else if (wsComponent.secure === false) {
+      return false;
+    } else if (wsComponent.scheme) {
+      return wsComponent.scheme.length === 3 && (wsComponent.scheme[0] === "w" || wsComponent.scheme[0] === "W") && (wsComponent.scheme[1] === "s" || wsComponent.scheme[1] === "S") && (wsComponent.scheme[2] === "s" || wsComponent.scheme[2] === "S");
+    } else {
+      return false;
+    }
+  }
+  function httpParse(component) {
+    if (!component.host) {
+      component.error = component.error || "HTTP URIs must have a host.";
     }
-    return components;
+    return component;
   }
-  function httpSerialize(components) {
-    const secure = String(components.scheme).toLowerCase() === "https";
-    if (components.port === (secure ? 443 : 80) || components.port === "") {
-      components.port = undefined;
+  function httpSerialize(component) {
+    const secure = String(component.scheme).toLowerCase() === "https";
+    if (component.port === (secure ? 443 : 80) || component.port === "") {
+      component.port = undefined;
     }
-    if (!components.path) {
-      components.path = "/";
+    if (!component.path) {
+      component.path = "/";
     }
-    return components;
+    return component;
   }
-  function wsParse(wsComponents) {
-    wsComponents.secure = isSecure(wsComponents);
-    wsComponents.resourceName = (wsComponents.path || "/") + (wsComponents.query ? "?" + wsComponents.query : "");
-    wsComponents.path = undefined;
-    wsComponents.query = undefined;
-    return wsComponents;
+  function wsParse(wsComponent) {
+    wsComponent.secure = wsIsSecure(wsComponent);
+    wsComponent.resourceName = (wsComponent.path || "/") + (wsComponent.query ? "?" + wsComponent.query : "");
+    wsComponent.path = undefined;
+    wsComponent.query = undefined;
+    return wsComponent;
   }
-  function wsSerialize(wsComponents) {
-    if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") {
-      wsComponents.port = undefined;
+  function wsSerialize(wsComponent) {
+    if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === "") {
+      wsComponent.port = undefined;
     }
-    if (typeof wsComponents.secure === "boolean") {
-      wsComponents.scheme = wsComponents.secure ? "wss" : "ws";
-      wsComponents.secure = undefined;
+    if (typeof wsComponent.secure === "boolean") {
+      wsComponent.scheme = wsComponent.secure ? "wss" : "ws";
+      wsComponent.secure = undefined;
     }
-    if (wsComponents.resourceName) {
-      const [path8, query] = wsComponents.resourceName.split("?");
-      wsComponents.path = path8 && path8 !== "/" ? path8 : undefined;
-      wsComponents.query = query;
-      wsComponents.resourceName = undefined;
+    if (wsComponent.resourceName) {
+      const [path8, query] = wsComponent.resourceName.split("?");
+      wsComponent.path = path8 && path8 !== "/" ? path8 : undefined;
+      wsComponent.query = query;
+      wsComponent.resourceName = undefined;
     }
-    wsComponents.fragment = undefined;
-    return wsComponents;
+    wsComponent.fragment = undefined;
+    return wsComponent;
   }
-  function urnParse(urnComponents, options) {
-    if (!urnComponents.path) {
-      urnComponents.error = "URN can not be parsed";
-      return urnComponents;
+  function urnParse(urnComponent, options) {
+    if (!urnComponent.path) {
+      urnComponent.error = "URN can not be parsed";
+      return urnComponent;
     }
-    const matches = urnComponents.path.match(URN_REG);
+    const matches = urnComponent.path.match(URN_REG);
     if (matches) {
-      const scheme = options.scheme || urnComponents.scheme || "urn";
-      urnComponents.nid = matches[1].toLowerCase();
-      urnComponents.nss = matches[2];
-      const urnScheme = `${scheme}:${options.nid || urnComponents.nid}`;
-      const schemeHandler = SCHEMES[urnScheme];
-      urnComponents.path = undefined;
+      const scheme = options.scheme || urnComponent.scheme || "urn";
+      urnComponent.nid = matches[1].toLowerCase();
+      urnComponent.nss = matches[2];
+      const urnScheme = `${scheme}:${options.nid || urnComponent.nid}`;
+      const schemeHandler = getSchemeHandler(urnScheme);
+      urnComponent.path = undefined;
       if (schemeHandler) {
-        urnComponents = schemeHandler.parse(urnComponents, options);
+        urnComponent = schemeHandler.parse(urnComponent, options);
       }
     } else {
-      urnComponents.error = urnComponents.error || "URN can not be parsed.";
+      urnComponent.error = urnComponent.error || "URN can not be parsed.";
     }
-    return urnComponents;
+    return urnComponent;
   }
-  function urnSerialize(urnComponents, options) {
-    const scheme = options.scheme || urnComponents.scheme || "urn";
-    const nid = urnComponents.nid.toLowerCase();
+  function urnSerialize(urnComponent, options) {
+    if (urnComponent.nid === undefined) {
+      throw new Error("URN without nid cannot be serialized");
+    }
+    const scheme = options.scheme || urnComponent.scheme || "urn";
+    const nid = urnComponent.nid.toLowerCase();
     const urnScheme = `${scheme}:${options.nid || nid}`;
-    const schemeHandler = SCHEMES[urnScheme];
+    const schemeHandler = getSchemeHandler(urnScheme);
     if (schemeHandler) {
-      urnComponents = schemeHandler.serialize(urnComponents, options);
+      urnComponent = schemeHandler.serialize(urnComponent, options);
     }
-    const uriComponents = urnComponents;
-    const nss = urnComponents.nss;
-    uriComponents.path = `${nid || options.nid}:${nss}`;
+    const uriComponent = urnComponent;
+    const nss = urnComponent.nss;
+    uriComponent.path = `${nid || options.nid}:${nss}`;
     options.skipEscape = true;
-    return uriComponents;
+    return uriComponent;
   }
-  function urnuuidParse(urnComponents, options) {
-    const uuidComponents = urnComponents;
-    uuidComponents.uuid = uuidComponents.nss;
-    uuidComponents.nss = undefined;
-    if (!options.tolerant && (!uuidComponents.uuid || !UUID_REG.test(uuidComponents.uuid))) {
-      uuidComponents.error = uuidComponents.error || "UUID is not valid.";
+  function urnuuidParse(urnComponent, options) {
+    const uuidComponent = urnComponent;
+    uuidComponent.uuid = uuidComponent.nss;
+    uuidComponent.nss = undefined;
+    if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) {
+      uuidComponent.error = uuidComponent.error || "UUID is not valid.";
     }
-    return uuidComponents;
+    return uuidComponent;
   }
-  function urnuuidSerialize(uuidComponents) {
-    const urnComponents = uuidComponents;
-    urnComponents.nss = (uuidComponents.uuid || "").toLowerCase();
-    return urnComponents;
+  function urnuuidSerialize(uuidComponent) {
+    const urnComponent = uuidComponent;
+    urnComponent.nss = (uuidComponent.uuid || "").toLowerCase();
+    return urnComponent;
   }
   var http = {
     scheme: "http",
@@ -5518,13 +5531,22 @@ var require_schemes = __commonJS((exports2, module2) => {
     urn,
     "urn:uuid": urnuuid
   };
-  module2.exports = SCHEMES;
+  Object.setPrototypeOf(SCHEMES, null);
+  function getSchemeHandler(scheme) {
+    return scheme && (SCHEMES[scheme] || SCHEMES[scheme.toLowerCase()]) || undefined;
+  }
+  module2.exports = {
+    wsIsSecure,
+    SCHEMES,
+    isValidSchemeName,
+    getSchemeHandler
+  };
 });
 
 // node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS((exports2, module2) => {
-  var { normalizeIPv6, normalizeIPv4, removeDotSegments, recomposeAuthority, normalizeComponentEncoding } = require_utils();
-  var SCHEMES = require_schemes();
+  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+  var { SCHEMES, getSchemeHandler } = require_schemes();
   function normalize(uri, options) {
     if (typeof uri === "string") {
       uri = serialize(parse(uri, options), options);
@@ -5534,11 +5556,12 @@ var require_fast_uri = __commonJS((exports2, module2) => {
     return uri;
   }
   function resolve(baseURI, relativeURI, options) {
-    const schemelessOptions = Object.assign({ scheme: "null" }, options);
-    const resolved = resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
-    return serialize(resolved, { ...schemelessOptions, skipEscape: true });
+    const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
+    const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+    schemelessOptions.skipEscape = true;
+    return serialize(resolved, schemelessOptions);
   }
-  function resolveComponents(base, relative, options, skipNormalization) {
+  function resolveComponent(base, relative, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
       base = parse(serialize(base, options), options);
@@ -5568,7 +5591,7 @@ var require_fast_uri = __commonJS((exports2, module2) => {
             target.query = base.query;
           }
         } else {
-          if (relative.path.charAt(0) === "/") {
+          if (relative.path[0] === "/") {
             target.path = removeDotSegments(relative.path);
           } else {
             if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) {
@@ -5607,7 +5630,7 @@ var require_fast_uri = __commonJS((exports2, module2) => {
     return uriA.toLowerCase() === uriB.toLowerCase();
   }
   function serialize(cmpts, opts) {
-    const components = {
+    const component = {
       host: cmpts.host,
       scheme: cmpts.scheme,
       userinfo: cmpts.userinfo,
@@ -5625,61 +5648,50 @@ var require_fast_uri = __commonJS((exports2, module2) => {
     };
     const options = Object.assign({}, opts);
     const uriTokens = [];
-    const schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
+    const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
     if (schemeHandler && schemeHandler.serialize)
-      schemeHandler.serialize(components, options);
-    if (components.path !== undefined) {
+      schemeHandler.serialize(component, options);
+    if (component.path !== undefined) {
       if (!options.skipEscape) {
-        components.path = escape(components.path);
-        if (components.scheme !== undefined) {
-          components.path = components.path.split("%3A").join(":");
+        component.path = escape(component.path);
+        if (component.scheme !== undefined) {
+          component.path = component.path.split("%3A").join(":");
         }
       } else {
-        components.path = unescape(components.path);
+        component.path = unescape(component.path);
       }
     }
-    if (options.reference !== "suffix" && components.scheme) {
-      uriTokens.push(components.scheme, ":");
+    if (options.reference !== "suffix" && component.scheme) {
+      uriTokens.push(component.scheme, ":");
     }
-    const authority = recomposeAuthority(components);
+    const authority = recomposeAuthority(component);
     if (authority !== undefined) {
       if (options.reference !== "suffix") {
         uriTokens.push("//");
       }
       uriTokens.push(authority);
-      if (components.path && components.path.charAt(0) !== "/") {
+      if (component.path && component.path[0] !== "/") {
         uriTokens.push("/");
       }
     }
-    if (components.path !== undefined) {
-      let s = components.path;
+    if (component.path !== undefined) {
+      let s = component.path;
       if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
         s = removeDotSegments(s);
       }
-      if (authority === undefined) {
-        s = s.replace(/^\/\//u, "/%2F");
+      if (authority === undefined && s[0] === "/" && s[1] === "/") {
+        s = "/%2F" + s.slice(2);
       }
       uriTokens.push(s);
     }
-    if (components.query !== undefined) {
-      uriTokens.push("?", components.query);
+    if (component.query !== undefined) {
+      uriTokens.push("?", component.query);
     }
-    if (components.fragment !== undefined) {
-      uriTokens.push("#", components.fragment);
+    if (component.fragment !== undefined) {
+      uriTokens.push("#", component.fragment);
     }
     return uriTokens.join("");
   }
-  var hexLookUp = Array.from({ length: 127 }, (_v, k) => /[^!"$&'()*+,\-.;=_`a-z{}~]/u.test(String.fromCharCode(k)));
-  function nonSimpleDomain(value) {
-    let code = 0;
-    for (let i = 0, len = value.length;i < len; ++i) {
-      code = value.charCodeAt(i);
-      if (code > 126 || hexLookUp[code]) {
-        return true;
-      }
-    }
-    return false;
-  }
   var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
   function parse(uri, opts) {
     const options = Object.assign({}, opts);
@@ -5692,10 +5704,14 @@ var require_fast_uri = __commonJS((exports2, module2) => {
       query: undefined,
       fragment: undefined
     };
-    const gotEncoding = uri.indexOf("%") !== -1;
     let isIP = false;
-    if (options.reference === "suffix")
-      uri = (options.scheme ? options.scheme + ":" : "") + "//" + uri;
+    if (options.reference === "suffix") {
+      if (options.scheme) {
+        uri = options.scheme + ":" + uri;
+      } else {
+        uri = "//" + uri;
+      }
+    }
     const matches = uri.match(URI_PARSE);
     if (matches) {
       parsed.scheme = matches[1];
@@ -5709,13 +5725,12 @@ var require_fast_uri = __commonJS((exports2, module2) => {
         parsed.port = matches[5];
       }
       if (parsed.host) {
-        const ipv4result = normalizeIPv4(parsed.host);
-        if (ipv4result.isIPV4 === false) {
-          const ipv6result = normalizeIPv6(ipv4result.host);
+        const ipv4result = isIPv4(parsed.host);
+        if (ipv4result === false) {
+          const ipv6result = normalizeIPv6(parsed.host);
           parsed.host = ipv6result.host.toLowerCase();
           isIP = ipv6result.isIPV6;
         } else {
-          parsed.host = ipv4result.host;
           isIP = true;
         }
       }
@@ -5731,7 +5746,7 @@ var require_fast_uri = __commonJS((exports2, module2) => {
       if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) {
         parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
       }
-      const schemeHandler = SCHEMES[(options.scheme || parsed.scheme || "").toLowerCase()];
+      const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
       if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
         if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
           try {
@@ -5742,11 +5757,13 @@ var require_fast_uri = __commonJS((exports2, module2) => {
         }
       }
       if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-        if (gotEncoding && parsed.scheme !== undefined) {
-          parsed.scheme = unescape(parsed.scheme);
-        }
-        if (gotEncoding && parsed.host !== undefined) {
-          parsed.host = unescape(parsed.host);
+        if (uri.indexOf("%") !== -1) {
+          if (parsed.scheme !== undefined) {
+            parsed.scheme = unescape(parsed.scheme);
+          }
+          if (parsed.host !== undefined) {
+            parsed.host = unescape(parsed.host);
+          }
         }
         if (parsed.path) {
           parsed.path = escape(unescape(parsed.path));
@@ -5767,7 +5784,7 @@ var require_fast_uri = __commonJS((exports2, module2) => {
     SCHEMES,
     normalize,
     resolve,
-    resolveComponents,
+    resolveComponent,
     equal,
     serialize,
     parse
@@ -9460,6 +9477,9 @@ var require_parse_options = __commonJS((exports2, module2) => {
 var require_identifiers = __commonJS((exports2, module2) => {
   var numeric = /^[0-9]+$/;
   var compareIdentifiers = (a, b) => {
+    if (typeof a === "number" && typeof b === "number") {
+      return a === b ? 0 : a < b ? -1 : 1;
+    }
     const anum = numeric.test(a);
     const bnum = numeric.test(b);
     if (anum && bnum) {
@@ -9562,7 +9582,25 @@ var require_semver = __commonJS((exports2, module2) => {
       if (!(other instanceof SemVer)) {
         other = new SemVer(other, this.options);
       }
-      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+      if (this.major < other.major) {
+        return -1;
+      }
+      if (this.major > other.major) {
+        return 1;
+      }
+      if (this.minor < other.minor) {
+        return -1;
+      }
+      if (this.minor > other.minor) {
+        return 1;
+      }
+      if (this.patch < other.patch) {
+        return -1;
+      }
+      if (this.patch > other.patch) {
+        return 1;
+      }
+      return 0;
     }
     comparePre(other) {
       if (!(other instanceof SemVer)) {
@@ -10239,6 +10277,7 @@ var require_range = __commonJS((exports2, module2) => {
     return result;
   };
   var parseComparator = (comp, options) => {
+    comp = comp.replace(re[t.BUILD], "");
     debug("comp", comp, options);
     comp = replaceCarets(comp, options);
     debug("caret", comp);
@@ -32698,9 +32737,9 @@ var crypto = new Crypto();
     };
   }
   function buildToReadableStream(dependencies) {
-    const { ReadableStream: ReadableStream2, Uint8Array: Uint8Array2 } = dependencies;
+    const { ReadableStream, Uint8Array: Uint8Array2 } = dependencies;
     return function toReadableStream(stream) {
-      return new ReadableStream2({
+      return new ReadableStream({
         start(controller) {
           stream.on("data", (chunk) => {
             controller.enqueue(new Uint8Array2([...new Uint8Array2(chunk)]));
@@ -71527,7 +71566,7 @@ class HTTPError extends Error {
   options;
   constructor(response, request, options) {
     const code = response.status || response.status === 0 ? response.status : "";
-    const title = response.statusText || "";
+    const title = response.statusText ?? "";
     const status = `${code} ${title}`.trim();
     const reason = status ? `status code ${status}` : "an unknown error";
     super(`Request failed with ${reason}: ${request.method} ${request.url}`);
@@ -71587,7 +71626,8 @@ var responseTypes = {
   text: "text/*",
   formData: "multipart/form-data",
   arrayBuffer: "*/*",
-  blob: "*/*"
+  blob: "*/*",
+  bytes: "*/*"
 };
 var maxSafeTimeout = 2147483647;
 var usualFormBoundarySize = new TextEncoder().encode("------WebKitFormBoundaryaxpyiPgbbPti10Rw").length;
@@ -71664,78 +71704,56 @@ var getBodySize = (body) => {
   }
   return 0;
 };
-var streamResponse = (response, onDownloadProgress) => {
-  const totalBytes = Number(response.headers.get("content-length")) || 0;
+var withProgress = (stream, totalBytes, onProgress) => {
+  let previousChunk;
   let transferredBytes = 0;
-  if (response.status === 204) {
-    if (onDownloadProgress) {
-      onDownloadProgress({ percent: 1, totalBytes, transferredBytes }, new Uint8Array);
+  return stream.pipeThrough(new TransformStream({
+    transform(currentChunk, controller) {
+      controller.enqueue(currentChunk);
+      if (previousChunk) {
+        transferredBytes += previousChunk.byteLength;
+        let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+        if (percent >= 1) {
+          percent = 1 - Number.EPSILON;
+        }
+        onProgress?.({ percent, totalBytes: Math.max(totalBytes, transferredBytes), transferredBytes }, previousChunk);
+      }
+      previousChunk = currentChunk;
+    },
+    flush() {
+      if (previousChunk) {
+        transferredBytes += previousChunk.byteLength;
+        onProgress?.({ percent: 1, totalBytes: Math.max(totalBytes, transferredBytes), transferredBytes }, previousChunk);
+      }
     }
+  }));
+};
+var streamResponse = (response, onDownloadProgress) => {
+  if (!response.body) {
+    return response;
+  }
+  if (response.status === 204) {
     return new Response(null, {
       status: response.status,
       statusText: response.statusText,
       headers: response.headers
     });
   }
-  return new Response(new ReadableStream({
-    async start(controller) {
-      const reader = response.body.getReader();
-      if (onDownloadProgress) {
-        onDownloadProgress({ percent: 0, transferredBytes: 0, totalBytes }, new Uint8Array);
-      }
-      async function read() {
-        const { done, value } = await reader.read();
-        if (done) {
-          controller.close();
-          return;
-        }
-        if (onDownloadProgress) {
-          transferredBytes += value.byteLength;
-          const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
-          onDownloadProgress({ percent, transferredBytes, totalBytes }, value);
-        }
-        controller.enqueue(value);
-        await read();
-      }
-      await read();
-    }
-  }), {
+  const totalBytes = Number(response.headers.get("content-length")) || 0;
+  return new Response(withProgress(response.body, totalBytes, onDownloadProgress), {
     status: response.status,
     statusText: response.statusText,
     headers: response.headers
   });
 };
-var streamRequest = (request, onUploadProgress) => {
-  const totalBytes = getBodySize(request.body);
-  let transferredBytes = 0;
+var streamRequest = (request, onUploadProgress, originalBody) => {
+  if (!request.body) {
+    return request;
+  }
+  const totalBytes = getBodySize(originalBody ?? request.body);
   return new Request(request, {
     duplex: "half",
-    body: new ReadableStream({
-      async start(controller) {
-        const reader = request.body instanceof ReadableStream ? request.body.getReader() : new Response("").body.getReader();
-        async function read() {
-          const { done, value } = await reader.read();
-          if (done) {
-            if (onUploadProgress) {
-              onUploadProgress({ percent: 1, transferredBytes, totalBytes: Math.max(totalBytes, transferredBytes) }, new Uint8Array);
-            }
-            controller.close();
-            return;
-          }
-          transferredBytes += value.byteLength;
-          let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
-          if (totalBytes < transferredBytes || percent === 1) {
-            percent = 0.99;
-          }
-          if (onUploadProgress) {
-            onUploadProgress({ percent: Number(percent.toFixed(2)), transferredBytes, totalBytes }, value);
-          }
-          controller.enqueue(value);
-          await read();
-        }
-        await read();
-      }
-    })
+    body: withProgress(request.body, totalBytes, onUploadProgress)
   });
 };
 
@@ -71879,6 +71897,24 @@ var findUnknownOptions = (request, options) => {
   }
   return unknownOptions;
 };
+var hasSearchParameters = (search) => {
+  if (search === undefined) {
+    return false;
+  }
+  if (Array.isArray(search)) {
+    return search.length > 0;
+  }
+  if (search instanceof URLSearchParams) {
+    return search.size > 0;
+  }
+  if (typeof search === "object") {
+    return Object.keys(search).length > 0;
+  }
+  if (typeof search === "string") {
+    return search.trim().length > 0;
+  }
+  return Boolean(search);
+};
 
 // node_modules/ky/distribution/core/Ky.js
 class Ky {
@@ -71917,11 +71953,20 @@ class Ky {
     };
     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 cleanupPromises = [];
+      if (originalRequest && !originalRequest.bodyUsed) {
+        cleanupPromises.push(originalRequest.body?.cancel());
+      }
       if (!ky.request.bodyUsed) {
-        await ky.request.body?.cancel();
+        cleanupPromises.push(ky.request.body?.cancel());
       }
+      await Promise.all(cleanupPromises);
     });
     for (const [type, mimeType] of Object.entries(responseTypes)) {
+      if (type === "bytes" && typeof globalThis.Response?.prototype?.bytes !== "function") {
+        continue;
+      }
       result[type] = async () => {
         ky.request.headers.set("accept", ky.request.headers.get("accept") || mimeType);
         const response = await result;
@@ -71929,25 +71974,32 @@ class Ky {
           if (response.status === 204) {
             return "";
           }
-          const arrayBuffer = await response.clone().arrayBuffer();
-          const responseSize = arrayBuffer.byteLength;
-          if (responseSize === 0) {
+          const text = await response.text();
+          if (text === "") {
             return "";
           }
           if (options.parseJson) {
-            return options.parseJson(await response.text());
+            return options.parseJson(text);
           }
+          return JSON.parse(text);
         }
         return response[type]();
       };
     }
     return result;
   }
+  static #normalizeSearchParams(searchParams) {
+    if (searchParams && typeof searchParams === "object" && !Array.isArray(searchParams) && !(searchParams instanceof URLSearchParams)) {
+      return Object.fromEntries(Object.entries(searchParams).filter(([, value]) => value !== undefined));
+    }
+    return searchParams;
+  }
   request;
   abortController;
   _retryCount = 0;
   _input;
   _options;
+  _originalRequest;
   constructor(input, options = {}) {
     this._input = input;
     this._options = {
@@ -71991,8 +72043,8 @@ class Ky {
       this._options.headers.set("content-type", this._options.headers.get("content-type") ?? "application/json");
     }
     this.request = new globalThis.Request(this._input, this._options);
-    if (this._options.searchParams) {
-      const textSearchParams = typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(this._options.searchParams).toString();
+    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"])) {
@@ -72009,7 +72061,7 @@ class Ky {
       }
       const originalBody = this.request.body;
       if (originalBody) {
-        this.request = streamRequest(this.request, this._options.onUploadProgress);
+        this.request = streamRequest(this.request, this._options.onUploadProgress, this._options.body);
       }
     }
   }
@@ -72081,12 +72133,12 @@ class Ky {
       }
     }
     const nonRequestOptions = findUnknownOptions(this.request, this._options);
-    const mainRequest = this.request;
-    this.request = mainRequest.clone();
+    this._originalRequest = this.request;
+    this.request = this._originalRequest.clone();
     if (this._options.timeout === false) {
-      return this._options.fetch(mainRequest, nonRequestOptions);
+      return this._options.fetch(this._originalRequest, nonRequestOptions);
     }
-    return timeout(mainRequest, nonRequestOptions, this.abortController, this._options);
+    return timeout(this._originalRequest, nonRequestOptions, this.abortController, this._options);
   }
 }
 
@@ -72128,7 +72180,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.305";
+var version = "0.1.306";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -72173,7 +72225,7 @@ var package_default = {
     jsonwebtoken: "^9.0.2",
     jszip: "^3.10.1",
     "jwt-decode": "^4.0.0",
-    "kicad-component-converter": "^0.1.14",
+    "kicad-component-converter": "^0.1.22",
     kicadts: "^0.0.9",
     kleur: "^4.1.5",
     ky: "^1.7.4",
@@ -72187,7 +72239,7 @@ var package_default = {
     semver: "^7.6.3",
     sharp: "0.32.6",
     tempy: "^3.1.0",
-    tscircuit: "^0.0.732",
+    tscircuit: "^0.0.735-libonly",
     tsx: "^4.7.1",
     "typed-ky": "^0.0.4",
     "circuit-json": "^0.0.275",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.306",
+  "version": "0.1.307",
   "main": "dist/main.js",
   "devDependencies": {
     "@babel/standalone": "^7.26.9",
@@ -42,7 +42,7 @@
     "jsonwebtoken": "^9.0.2",
     "jszip": "^3.10.1",
     "jwt-decode": "^4.0.0",
-    "kicad-component-converter": "^0.1.14",
+    "kicad-component-converter": "^0.1.22",
     "kicadts": "^0.0.9",
     "kleur": "^4.1.5",
     "ky": "^1.7.4",
@@ -56,7 +56,7 @@
     "semver": "^7.6.3",
     "sharp": "0.32.6",
     "tempy": "^3.1.0",
-    "tscircuit": "^0.0.732",
+    "tscircuit": "^0.0.735-libonly",
     "tsx": "^4.7.1",
     "typed-ky": "^0.0.4",
     "circuit-json": "^0.0.275",