@v5x/serial 0.5.4 → 0.5.6

package/dist/index.cjs

@@ -0,0 +1,4175 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// ../../node_modules/.bun/neverthrow@8.2.0/node_modules/neverthrow/dist/index.cjs.js
+var require_index_cjs = __commonJS(function(exports2) {
+  var defaultErrorConfig = {
+    withStackTrace: false
+  };
+  var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+    const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+    const maybeStack = config.withStackTrace ? new Error().stack : undefined;
+    return {
+      data,
+      message,
+      stack: maybeStack
+    };
+  };
+  function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator["throw"](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  }
+  function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m)
+      return m.call(o);
+    if (o && typeof o.length === "number")
+      return {
+        next: function() {
+          if (o && i >= o.length)
+            o = undefined;
+          return { value: o && o[i++], done: !o };
+        }
+      };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+  }
+  function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+  }
+  function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator)
+      throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+      return this;
+    }, i;
+    function awaitReturn(f) {
+      return function(v) {
+        return Promise.resolve(v).then(f, reject);
+      };
+    }
+    function verb(n, f) {
+      if (g[n]) {
+        i[n] = function(v) {
+          return new Promise(function(a, b) {
+            q.push([n, v, a, b]) > 1 || resume(n, v);
+          });
+        };
+        if (f)
+          i[n] = f(i[n]);
+      }
+    }
+    function resume(n, v) {
+      try {
+        step(g[n](v));
+      } catch (e) {
+        settle(q[0][3], e);
+      }
+    }
+    function step(r) {
+      r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+    }
+    function fulfill(value) {
+      resume("next", value);
+    }
+    function reject(value) {
+      resume("throw", value);
+    }
+    function settle(f, v) {
+      if (f(v), q.shift(), q.length)
+        resume(q[0][0], q[0][1]);
+    }
+  }
+  function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function(e) {
+      throw e;
+    }), verb("return"), i[Symbol.iterator] = function() {
+      return this;
+    }, i;
+    function verb(n, f) {
+      i[n] = o[n] ? function(v) {
+        return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
+      } : f;
+    }
+  }
+  function __asyncValues(o) {
+    if (!Symbol.asyncIterator)
+      throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+      return this;
+    }, i);
+    function verb(n) {
+      i[n] = o[n] && function(v) {
+        return new Promise(function(resolve, reject) {
+          v = o[n](v), settle(resolve, reject, v.done, v.value);
+        });
+      };
+    }
+    function settle(resolve, reject, d, v) {
+      Promise.resolve(v).then(function(v2) {
+        resolve({ value: v2, done: d });
+      }, reject);
+    }
+  }
+
+  class ResultAsync {
+    constructor(res) {
+      this._promise = res;
+    }
+    static fromSafePromise(promise) {
+      const newPromise = promise.then((value) => new Ok(value));
+      return new ResultAsync(newPromise);
+    }
+    static fromPromise(promise, errorFn) {
+      const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
+      return new ResultAsync(newPromise);
+    }
+    static fromThrowable(fn, errorFn) {
+      return (...args) => {
+        return new ResultAsync((() => __awaiter(this, undefined, undefined, function* () {
+          try {
+            return new Ok(yield fn(...args));
+          } catch (error) {
+            return new Err(errorFn ? errorFn(error) : error);
+          }
+        }))());
+      };
+    }
+    static combine(asyncResultList) {
+      return combineResultAsyncList(asyncResultList);
+    }
+    static combineWithAllErrors(asyncResultList) {
+      return combineResultAsyncListWithAllErrors(asyncResultList);
+    }
+    map(f) {
+      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+        if (res.isErr()) {
+          return new Err(res.error);
+        }
+        return new Ok(yield f(res.value));
+      })));
+    }
+    andThrough(f) {
+      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+        if (res.isErr()) {
+          return new Err(res.error);
+        }
+        const newRes = yield f(res.value);
+        if (newRes.isErr()) {
+          return new Err(newRes.error);
+        }
+        return new Ok(res.value);
+      })));
+    }
+    andTee(f) {
+      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+        if (res.isErr()) {
+          return new Err(res.error);
+        }
+        try {
+          yield f(res.value);
+        } catch (e) {}
+        return new Ok(res.value);
+      })));
+    }
+    orTee(f) {
+      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+        if (res.isOk()) {
+          return new Ok(res.value);
+        }
+        try {
+          yield f(res.error);
+        } catch (e) {}
+        return new Err(res.error);
+      })));
+    }
+    mapErr(f) {
+      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+        if (res.isOk()) {
+          return new Ok(res.value);
+        }
+        return new Err(yield f(res.error));
+      })));
+    }
+    andThen(f) {
+      return new ResultAsync(this._promise.then((res) => {
+        if (res.isErr()) {
+          return new Err(res.error);
+        }
+        const newValue = f(res.value);
+        return newValue instanceof ResultAsync ? newValue._promise : newValue;
+      }));
+    }
+    orElse(f) {
+      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
+        if (res.isErr()) {
+          return f(res.error);
+        }
+        return new Ok(res.value);
+      })));
+    }
+    match(ok2, _err) {
+      return this._promise.then((res) => res.match(ok2, _err));
+    }
+    unwrapOr(t) {
+      return this._promise.then((res) => res.unwrapOr(t));
+    }
+    safeUnwrap() {
+      return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+        return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+      });
+    }
+    then(successCallback, failureCallback) {
+      return this._promise.then(successCallback, failureCallback);
+    }
+    [Symbol.asyncIterator]() {
+      return __asyncGenerator(this, arguments, function* _a() {
+        const result = yield __await(this._promise);
+        if (result.isErr()) {
+          yield yield __await(errAsync(result.error));
+        }
+        return yield __await(result.value);
+      });
+    }
+  }
+  function okAsync(value) {
+    return new ResultAsync(Promise.resolve(new Ok(value)));
+  }
+  function errAsync(err2) {
+    return new ResultAsync(Promise.resolve(new Err(err2)));
+  }
+  var fromPromise = ResultAsync.fromPromise;
+  var fromSafePromise = ResultAsync.fromSafePromise;
+  var fromAsyncThrowable = ResultAsync.fromThrowable;
+  var combineResultList = (resultList) => {
+    let acc = ok([]);
+    for (const result of resultList) {
+      if (result.isErr()) {
+        acc = err(result.error);
+        break;
+      } else {
+        acc.map((list) => list.push(result.value));
+      }
+    }
+    return acc;
+  };
+  var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+  var combineResultListWithAllErrors = (resultList) => {
+    let acc = ok([]);
+    for (const result of resultList) {
+      if (result.isErr() && acc.isErr()) {
+        acc.error.push(result.error);
+      } else if (result.isErr() && acc.isOk()) {
+        acc = err([result.error]);
+      } else if (result.isOk() && acc.isOk()) {
+        acc.value.push(result.value);
+      }
+    }
+    return acc;
+  };
+  var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+  exports2.Result = undefined;
+  (function(Result) {
+    function fromThrowable2(fn, errorFn) {
+      return (...args) => {
+        try {
+          const result = fn(...args);
+          return ok(result);
+        } catch (e) {
+          return err(errorFn ? errorFn(e) : e);
+        }
+      };
+    }
+    Result.fromThrowable = fromThrowable2;
+    function combine(resultList) {
+      return combineResultList(resultList);
+    }
+    Result.combine = combine;
+    function combineWithAllErrors(resultList) {
+      return combineResultListWithAllErrors(resultList);
+    }
+    Result.combineWithAllErrors = combineWithAllErrors;
+  })(exports2.Result || (exports2.Result = {}));
+  function ok(value) {
+    return new Ok(value);
+  }
+  function err(err2) {
+    return new Err(err2);
+  }
+  function safeTry(body) {
+    const n = body().next();
+    if (n instanceof Promise) {
+      return new ResultAsync(n.then((r) => r.value));
+    }
+    return n.value;
+  }
+
+  class Ok {
+    constructor(value) {
+      this.value = value;
+    }
+    isOk() {
+      return true;
+    }
+    isErr() {
+      return !this.isOk();
+    }
+    map(f) {
+      return ok(f(this.value));
+    }
+    mapErr(_f) {
+      return ok(this.value);
+    }
+    andThen(f) {
+      return f(this.value);
+    }
+    andThrough(f) {
+      return f(this.value).map((_value) => this.value);
+    }
+    andTee(f) {
+      try {
+        f(this.value);
+      } catch (e) {}
+      return ok(this.value);
+    }
+    orTee(_f) {
+      return ok(this.value);
+    }
+    orElse(_f) {
+      return ok(this.value);
+    }
+    asyncAndThen(f) {
+      return f(this.value);
+    }
+    asyncAndThrough(f) {
+      return f(this.value).map(() => this.value);
+    }
+    asyncMap(f) {
+      return ResultAsync.fromSafePromise(f(this.value));
+    }
+    unwrapOr(_v) {
+      return this.value;
+    }
+    match(ok2, _err) {
+      return ok2(this.value);
+    }
+    safeUnwrap() {
+      const value = this.value;
+      return function* () {
+        return value;
+      }();
+    }
+    _unsafeUnwrap(_) {
+      return this.value;
+    }
+    _unsafeUnwrapErr(config) {
+      throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+    }
+    *[Symbol.iterator]() {
+      return this.value;
+    }
+  }
+
+  class Err {
+    constructor(error) {
+      this.error = error;
+    }
+    isOk() {
+      return false;
+    }
+    isErr() {
+      return !this.isOk();
+    }
+    map(_f) {
+      return err(this.error);
+    }
+    mapErr(f) {
+      return err(f(this.error));
+    }
+    andThrough(_f) {
+      return err(this.error);
+    }
+    andTee(_f) {
+      return err(this.error);
+    }
+    orTee(f) {
+      try {
+        f(this.error);
+      } catch (e) {}
+      return err(this.error);
+    }
+    andThen(_f) {
+      return err(this.error);
+    }
+    orElse(f) {
+      return f(this.error);
+    }
+    asyncAndThen(_f) {
+      return errAsync(this.error);
+    }
+    asyncAndThrough(_f) {
+      return errAsync(this.error);
+    }
+    asyncMap(_f) {
+      return errAsync(this.error);
+    }
+    unwrapOr(v) {
+      return v;
+    }
+    match(_ok, err2) {
+      return err2(this.error);
+    }
+    safeUnwrap() {
+      const error = this.error;
+      return function* () {
+        yield err(error);
+        throw new Error("Do not use this generator out of `safeTry`");
+      }();
+    }
+    _unsafeUnwrap(config) {
+      throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+    }
+    _unsafeUnwrapErr(_) {
+      return this.error;
+    }
+    *[Symbol.iterator]() {
+      const self = this;
+      yield self;
+      return self;
+    }
+  }
+  var fromThrowable = exports2.Result.fromThrowable;
+  exports2.Err = Err;
+  exports2.Ok = Ok;
+  exports2.ResultAsync = ResultAsync;
+  exports2.err = err;
+  exports2.errAsync = errAsync;
+  exports2.fromAsyncThrowable = fromAsyncThrowable;
+  exports2.fromPromise = fromPromise;
+  exports2.fromSafePromise = fromSafePromise;
+  exports2.fromThrowable = fromThrowable;
+  exports2.ok = ok;
+  exports2.okAsync = okAsync;
+  exports2.safeTry = safeTry;
+});
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  uploadFirmware: () => uploadFirmware,
+  toVexSerialError: () => toVexSerialError,
+  sleepUntilAsync: () => sleepUntilAsync,
+  sleepUntil: () => sleepUntil,
+  sleep: () => sleep,
+  encodeFixedText: () => encodeFixedText,
+  downloadFileFromInternet: () => downloadFileFromInternet,
+  WriteKeyValueReplyD2HPacket: () => WriteKeyValueReplyD2HPacket,
+  WriteKeyValueH2DPacket: () => WriteKeyValueH2DPacket,
+  WriteFileReplyD2HPacket: () => WriteFileReplyD2HPacket,
+  WriteFileH2DPacket: () => WriteFileH2DPacket,
+  VexTransferError: () => VexTransferError,
+  VexSerialError: () => VexSerialError,
+  VexSerialDevice: () => VexSerialDevice,
+  VexSerialConnection: () => VexSerialConnection,
+  VexProtocolError: () => VexProtocolError,
+  VexNotConnectedError: () => VexNotConnectedError,
+  VexIoError: () => VexIoError,
+  VexInvalidArgumentError: () => VexInvalidArgumentError,
+  VexFirmwareVersion: () => VexFirmwareVersion,
+  VexFirmwareError: () => VexFirmwareError,
+  VexEventTarget: () => VexEventTarget,
+  VexEventEmitter: () => VexEventEmitter,
+  VexDownloadError: () => VexDownloadError,
+  V5SmartDevice: () => V5SmartDevice,
+  V5SerialDeviceState: () => V5SerialDeviceState,
+  V5SerialDevice: () => V5SerialDevice,
+  V5SerialConnection: () => V5SerialConnection,
+  V5Radio: () => V5Radio,
+  V5Controller: () => V5Controller,
+  V5BrainSettings: () => V5BrainSettings,
+  V5BrainButton: () => V5BrainButton,
+  V5Brain: () => V5Brain,
+  V5Battery: () => V5Battery,
+  UpdateMatchModeH2DPacket: () => UpdateMatchModeH2DPacket,
+  USER_PROG_CHUNK_SIZE: () => USER_PROG_CHUNK_SIZE,
+  USER_FLASH_USR_CODE_START: () => USER_FLASH_USR_CODE_START,
+  USER_FLASH_SYS_CODE_START: () => USER_FLASH_SYS_CODE_START,
+  USER_FLASH_START_C: () => USER_FLASH_START_C,
+  USER_FLASH_START_B: () => USER_FLASH_START_B,
+  USER_FLASH_START: () => USER_FLASH_START,
+  USER_FLASH_MAX_FILE_SIZE: () => USER_FLASH_MAX_FILE_SIZE,
+  USER_FLASH_END_C: () => USER_FLASH_END_C,
+  USER_FLASH_END_B: () => USER_FLASH_END_B,
+  USER_FLASH_END: () => USER_FLASH_END,
+  SystemVersionReplyD2HPacket: () => SystemVersionReplyD2HPacket,
+  SystemVersionH2DPacket: () => SystemVersionH2DPacket,
+  SmartDeviceType: () => SmartDeviceType,
+  SerialDeviceType: () => SerialDeviceType,
+  SendDashTouchReplyD2HPacket: () => SendDashTouchReplyD2HPacket,
+  SendDashTouchH2DPacket: () => SendDashTouchH2DPacket,
+  SelectDashScreen: () => SelectDashScreen,
+  SelectDashReplyD2HPacket: () => SelectDashReplyD2HPacket,
+  SelectDashH2DPacket: () => SelectDashH2DPacket,
+  ScreenCaptureReplyD2HPacket: () => ScreenCaptureReplyD2HPacket,
+  ScreenCaptureH2DPacket: () => ScreenCaptureH2DPacket,
+  ReadLogPageReplyD2HPacket: () => ReadLogPageReplyD2HPacket,
+  ReadLogPageH2DPacket: () => ReadLogPageH2DPacket,
+  ReadKeyValueReplyD2HPacket: () => ReadKeyValueReplyD2HPacket,
+  ReadKeyValueH2DPacket: () => ReadKeyValueH2DPacket,
+  ReadFileReplyD2HPacket: () => ReadFileReplyD2HPacket,
+  ReadFileH2DPacket: () => ReadFileH2DPacket,
+  RadioChannelType: () => RadioChannelType,
+  Query1ReplyD2HPacket: () => Query1ReplyD2HPacket,
+  Query1H2DPacket: () => Query1H2DPacket,
+  ProgramIniConfig: () => ProgramIniConfig,
+  PacketView: () => PacketView,
+  PacketEncoder: () => PacketEncoder,
+  Packet: () => Packet,
+  MatchStatusReplyD2HPacket: () => MatchStatusReplyD2HPacket,
+  MatchModeReplyD2HPacket: () => MatchModeReplyD2HPacket,
+  LoadFileActionReplyD2HPacket: () => LoadFileActionReplyD2HPacket,
+  LoadFileActionH2DPacket: () => LoadFileActionH2DPacket,
+  LinkFileReplyD2HPacket: () => LinkFileReplyD2HPacket,
+  LinkFileH2DPacket: () => LinkFileH2DPacket,
+  InitFileTransferReplyD2HPacket: () => InitFileTransferReplyD2HPacket,
+  InitFileTransferH2DPacket: () => InitFileTransferH2DPacket,
+  HostBoundPacket: () => HostBoundPacket,
+  GetSystemStatusReplyD2HPacket: () => GetSystemStatusReplyD2HPacket,
+  GetSystemStatusH2DPacket: () => GetSystemStatusH2DPacket,
+  GetSystemFlagsReplyD2HPacket: () => GetSystemFlagsReplyD2HPacket,
+  GetSystemFlagsH2DPacket: () => GetSystemFlagsH2DPacket,
+  GetSlot5to8InfoReplyD2HPacket: () => GetSlot5to8InfoReplyD2HPacket,
+  GetSlot5to8InfoH2DPacket: () => GetSlot5to8InfoH2DPacket,
+  GetSlot1to4InfoReplyD2HPacket: () => GetSlot1to4InfoReplyD2HPacket,
+  GetSlot1to4InfoH2DPacket: () => GetSlot1to4InfoH2DPacket,
+  GetRadioStatusReplyD2HPacket: () => GetRadioStatusReplyD2HPacket,
+  GetRadioStatusH2DPacket: () => GetRadioStatusH2DPacket,
+  GetRadioModeH2DPacket: () => GetRadioModeH2DPacket,
+  GetProgramSlotInfoReplyD2HPacket: () => GetProgramSlotInfoReplyD2HPacket,
+  GetProgramSlotInfoH2DPacket: () => GetProgramSlotInfoH2DPacket,
+  GetMatchStatusH2DPacket: () => GetMatchStatusH2DPacket,
+  GetLogCountReplyD2HPacket: () => GetLogCountReplyD2HPacket,
+  GetLogCountH2DPacket: () => GetLogCountH2DPacket,
+  GetFileMetadataReplyD2HPacket: () => GetFileMetadataReplyD2HPacket,
+  GetFileMetadataH2DPacket: () => GetFileMetadataH2DPacket,
+  GetFdtStatusReplyD2HPacket: () => GetFdtStatusReplyD2HPacket,
+  GetFdtStatusH2DPacket: () => GetFdtStatusH2DPacket,
+  GetDirectoryFileCountReplyD2HPacket: () => GetDirectoryFileCountReplyD2HPacket,
+  GetDirectoryFileCountH2DPacket: () => GetDirectoryFileCountH2DPacket,
+  GetDirectoryEntryReplyD2HPacket: () => GetDirectoryEntryReplyD2HPacket,
+  GetDirectoryEntryH2DPacket: () => GetDirectoryEntryH2DPacket,
+  GetDeviceStatusReplyD2HPacket: () => GetDeviceStatusReplyD2HPacket,
+  GetDeviceStatusH2DPacket: () => GetDeviceStatusH2DPacket,
+  FileVendor: () => FileVendor,
+  FileLoadAction: () => FileLoadAction,
+  FileInitOption: () => FileInitOption,
+  FileInitAction: () => FileInitAction,
+  FileFormatReplyD2HPacket: () => FileFormatReplyD2HPacket,
+  FileFormatH2DPacket: () => FileFormatH2DPacket,
+  FileExitAction: () => FileExitAction,
+  FileDownloadTarget: () => FileDownloadTarget,
+  FileControlReplyD2HPacket: () => FileControlReplyD2HPacket,
+  FileControlH2DPacket: () => FileControlH2DPacket,
+  FileClearUpReplyD2HPacket: () => FileClearUpReplyD2HPacket,
+  FileClearUpH2DPacket: () => FileClearUpH2DPacket,
+  FactoryStatusReplyD2HPacket: () => FactoryStatusReplyD2HPacket,
+  FactoryStatusH2DPacket: () => FactoryStatusH2DPacket,
+  FactoryEnableReplyD2HPacket: () => FactoryEnableReplyD2HPacket,
+  FactoryEnableH2DPacket: () => FactoryEnableH2DPacket,
+  ExitFileTransferReplyD2HPacket: () => ExitFileTransferReplyD2HPacket,
+  ExitFileTransferH2DPacket: () => ExitFileTransferH2DPacket,
+  EraseFileReplyD2HPacket: () => EraseFileReplyD2HPacket,
+  EraseFileH2DPacket: () => EraseFileH2DPacket,
+  DeviceBoundPacket: () => DeviceBoundPacket,
+  AckType: () => AckType
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/Vex.ts
+var USER_PROG_CHUNK_SIZE = 4096;
+var USER_FLASH_START = 50331648;
+var USER_FLASH_SYS_CODE_START = 54525952;
+var USER_FLASH_USR_CODE_START = 58720256;
+var USER_FLASH_END = 134217728;
+var USER_FLASH_MAX_FILE_SIZE = 2097152;
+var USER_FLASH_START_B = 270532608;
+var USER_FLASH_END_B = 272629760;
+var USER_FLASH_START_C = 807403520;
+var USER_FLASH_END_C = 822083584;
+var FileVendor;
+((FileVendor2) => {
+  FileVendor2[FileVendor2["USER"] = 1] = "USER";
+  FileVendor2[FileVendor2["SYS"] = 15] = "SYS";
+  FileVendor2[FileVendor2["DEV1"] = 16] = "DEV1";
+  FileVendor2[FileVendor2["DEV2"] = 24] = "DEV2";
+  FileVendor2[FileVendor2["DEV3"] = 32] = "DEV3";
+  FileVendor2[FileVendor2["DEV4"] = 40] = "DEV4";
+  FileVendor2[FileVendor2["DEV5"] = 48] = "DEV5";
+  FileVendor2[FileVendor2["DEV6"] = 56] = "DEV6";
+  FileVendor2[FileVendor2["VEXVM"] = 64] = "VEXVM";
+  FileVendor2[FileVendor2["VEX"] = 240] = "VEX";
+  FileVendor2[FileVendor2["UNDEFINED"] = 241] = "UNDEFINED";
+})(FileVendor ||= {});
+var FileDownloadTarget;
+((FileDownloadTarget2) => {
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_DDR"] = 0] = "FILE_TARGET_DDR";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_QSPI"] = 1] = "FILE_TARGET_QSPI";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_CBUF"] = 2] = "FILE_TARGET_CBUF";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_VBUF"] = 3] = "FILE_TARGET_VBUF";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_DDRC"] = 4] = "FILE_TARGET_DDRC";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_DDRE"] = 5] = "FILE_TARGET_DDRE";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_FLASH"] = 6] = "FILE_TARGET_FLASH";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_RADIO"] = 7] = "FILE_TARGET_RADIO";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_A1"] = 13] = "FILE_TARGET_A1";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_B1"] = 14] = "FILE_TARGET_B1";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_B2"] = 15] = "FILE_TARGET_B2";
+})(FileDownloadTarget ||= {});
+var FileInitAction;
+((FileInitAction2) => {
+  FileInitAction2[FileInitAction2["WRITE"] = 1] = "WRITE";
+  FileInitAction2[FileInitAction2["READ"] = 2] = "READ";
+})(FileInitAction ||= {});
+var FileInitOption;
+((FileInitOption2) => {
+  FileInitOption2[FileInitOption2["NONE"] = 0] = "NONE";
+  FileInitOption2[FileInitOption2["OVERWRITE"] = 1] = "OVERWRITE";
+})(FileInitOption ||= {});
+var FileLoadAction;
+((FileLoadAction2) => {
+  FileLoadAction2[FileLoadAction2["RUN"] = 0] = "RUN";
+  FileLoadAction2[FileLoadAction2["STOP"] = 128] = "STOP";
+})(FileLoadAction ||= {});
+var FileExitAction;
+((FileExitAction2) => {
+  FileExitAction2[FileExitAction2["EXIT_NONE"] = 0] = "EXIT_NONE";
+  FileExitAction2[FileExitAction2["EXIT_RUN"] = 1] = "EXIT_RUN";
+  FileExitAction2[FileExitAction2["EXIT_HALT"] = 3] = "EXIT_HALT";
+})(FileExitAction ||= {});
+var RadioChannelType;
+((RadioChannelType2) => {
+  RadioChannelType2[RadioChannelType2["PIT"] = 0] = "PIT";
+  RadioChannelType2[RadioChannelType2["DOWNLOAD"] = 1] = "DOWNLOAD";
+})(RadioChannelType ||= {});
+var AckType;
+((AckType2) => {
+  AckType2[AckType2["CDC2_ACK"] = 118] = "CDC2_ACK";
+  AckType2[AckType2["CDC2_NACK"] = 255] = "CDC2_NACK";
+  AckType2[AckType2["CDC2_NACK_PACKET_CRC"] = 206] = "CDC2_NACK_PACKET_CRC";
+  AckType2[AckType2["CDC2_NACK_CMD_LENGTH"] = 208] = "CDC2_NACK_CMD_LENGTH";
+  AckType2[AckType2["CDC2_NACK_SIZE"] = 209] = "CDC2_NACK_SIZE";
+  AckType2[AckType2["CDC2_NACK_CRC"] = 210] = "CDC2_NACK_CRC";
+  AckType2[AckType2["CDC2_NACK_FILE"] = 211] = "CDC2_NACK_FILE";
+  AckType2[AckType2["CDC2_NACK_INIT"] = 212] = "CDC2_NACK_INIT";
+  AckType2[AckType2["CDC2_NACK_FUNC"] = 213] = "CDC2_NACK_FUNC";
+  AckType2[AckType2["CDC2_NACK_ALIGN"] = 214] = "CDC2_NACK_ALIGN";
+  AckType2[AckType2["CDC2_NACK_ADDR"] = 215] = "CDC2_NACK_ADDR";
+  AckType2[AckType2["CDC2_NACK_INCOMPLETE"] = 216] = "CDC2_NACK_INCOMPLETE";
+  AckType2[AckType2["CDC2_NACK_DIR_INDEX"] = 217] = "CDC2_NACK_DIR_INDEX";
+  AckType2[AckType2["CDC2_NACK_MAX_USER_FILES"] = 218] = "CDC2_NACK_MAX_USER_FILES";
+  AckType2[AckType2["CDC2_NACK_FILE_EXISTS"] = 219] = "CDC2_NACK_FILE_EXISTS";
+  AckType2[AckType2["CDC2_NACK_FILE_SYS_FULL"] = 220] = "CDC2_NACK_FILE_SYS_FULL";
+  AckType2[AckType2["TIMEOUT"] = 256] = "TIMEOUT";
+  AckType2[AckType2["WRITE_ERROR"] = 257] = "WRITE_ERROR";
+})(AckType ||= {});
+var SmartDeviceType;
+((SmartDeviceType2) => {
+  SmartDeviceType2[SmartDeviceType2["EMPTY"] = 0] = "EMPTY";
+  SmartDeviceType2[SmartDeviceType2["V5_POWER"] = 1] = "V5_POWER";
+  SmartDeviceType2[SmartDeviceType2["MOTOR"] = 2] = "MOTOR";
+  SmartDeviceType2[SmartDeviceType2["LED"] = 3] = "LED";
+  SmartDeviceType2[SmartDeviceType2["ABS_ENCODER_SENSOR"] = 4] = "ABS_ENCODER_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["CR_MOTOR"] = 5] = "CR_MOTOR";
+  SmartDeviceType2[SmartDeviceType2["IMU_SENSOR"] = 6] = "IMU_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["DISTANCE_SENSOR"] = 7] = "DISTANCE_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["RADIO_SENSOR"] = 8] = "RADIO_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["CONTROLLER"] = 9] = "CONTROLLER";
+  SmartDeviceType2[SmartDeviceType2["BRAIN"] = 10] = "BRAIN";
+  SmartDeviceType2[SmartDeviceType2["VISION_SENSOR"] = 11] = "VISION_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["ADI"] = 12] = "ADI";
+  SmartDeviceType2[SmartDeviceType2["PARTNER_CONTROLLER"] = 13] = "PARTNER_CONTROLLER";
+  SmartDeviceType2[SmartDeviceType2["BATTERY"] = 14] = "BATTERY";
+  SmartDeviceType2[SmartDeviceType2["SOL"] = 15] = "SOL";
+  SmartDeviceType2[SmartDeviceType2["OPTICAL_SENSOR"] = 16] = "OPTICAL_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["MAGNET"] = 17] = "MAGNET";
+  SmartDeviceType2[SmartDeviceType2["GPS_SENSOR"] = 20] = "GPS_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["UNDEFINED_SENSOR"] = 255] = "UNDEFINED_SENSOR";
+})(SmartDeviceType ||= {});
+var SerialDeviceType;
+((SerialDeviceType2) => {
+  SerialDeviceType2[SerialDeviceType2["V5_BRAIN"] = 1281] = "V5_BRAIN";
+  SerialDeviceType2[SerialDeviceType2["V5_BRAIN_DFU"] = 1282] = "V5_BRAIN_DFU";
+  SerialDeviceType2[SerialDeviceType2["V5_CONTROLLER"] = 1283] = "V5_CONTROLLER";
+  SerialDeviceType2[SerialDeviceType2["XILINX"] = 256] = "XILINX";
+  SerialDeviceType2[SerialDeviceType2["IQ_BRAIN"] = 2] = "IQ_BRAIN";
+  SerialDeviceType2[SerialDeviceType2["IQ_BRAIN2"] = 3] = "IQ_BRAIN2";
+  SerialDeviceType2[SerialDeviceType2["IQ_BRAIN_DFU"] = 255] = "IQ_BRAIN_DFU";
+  SerialDeviceType2[SerialDeviceType2["IQ2_BRAIN"] = 512] = "IQ2_BRAIN";
+  SerialDeviceType2[SerialDeviceType2["IQ2_BRAIN_DFU"] = 527] = "IQ2_BRAIN_DFU";
+  SerialDeviceType2[SerialDeviceType2["IQ2_CONTROLLER"] = 528] = "IQ2_CONTROLLER";
+  SerialDeviceType2[SerialDeviceType2["IQ2_CONTROLLER_DFU"] = 543] = "IQ2_CONTROLLER_DFU";
+  SerialDeviceType2[SerialDeviceType2["EXP_BRAIN"] = 1536] = "EXP_BRAIN";
+  SerialDeviceType2[SerialDeviceType2["EXP_BRAIN_DFU"] = 1551] = "EXP_BRAIN_DFU";
+  SerialDeviceType2[SerialDeviceType2["EXP_CONTROLLER"] = 1552] = "EXP_CONTROLLER";
+  SerialDeviceType2[SerialDeviceType2["EXP_CONTROLLER_DFU"] = 1567] = "EXP_CONTROLLER_DFU";
+  SerialDeviceType2[SerialDeviceType2["PIXY"] = 61440] = "PIXY";
+  SerialDeviceType2[SerialDeviceType2["PIXY_DFU"] = 12] = "PIXY_DFU";
+  SerialDeviceType2[SerialDeviceType2["VEXCAM"] = 1287] = "VEXCAM";
+  SerialDeviceType2[SerialDeviceType2["VEXCAM_DFU"] = 1288] = "VEXCAM_DFU";
+  SerialDeviceType2[SerialDeviceType2["SENSOR_TEST"] = 1535] = "SENSOR_TEST";
+  SerialDeviceType2[SerialDeviceType2["CORTEX_PROGCBL"] = 10] = "CORTEX_PROGCBL";
+  SerialDeviceType2[SerialDeviceType2["CORTEX_BRAIN"] = 11] = "CORTEX_BRAIN";
+  SerialDeviceType2[SerialDeviceType2["CORTEX_JOYSTK"] = 12] = "CORTEX_JOYSTK";
+  SerialDeviceType2[SerialDeviceType2["VEXNET_KEY_20"] = 7] = "VEXNET_KEY_20";
+  SerialDeviceType2[SerialDeviceType2["VEXNET_KEY_10"] = 9587] = "VEXNET_KEY_10";
+  SerialDeviceType2[SerialDeviceType2["PROLIFIC"] = 8963] = "PROLIFIC";
+})(SerialDeviceType ||= {});
+var SelectDashScreen;
+((SelectDashScreen2) => {
+  SelectDashScreen2[SelectDashScreen2["HOME"] = 0] = "HOME";
+  SelectDashScreen2[SelectDashScreen2["BATTERY"] = 1] = "BATTERY";
+  SelectDashScreen2[SelectDashScreen2["LED"] = 3] = "LED";
+  SelectDashScreen2[SelectDashScreen2["MATCH_CONFIG"] = 4] = "MATCH_CONFIG";
+  SelectDashScreen2[SelectDashScreen2["MATCH_CONFIG_MORE"] = 5] = "MATCH_CONFIG_MORE";
+  SelectDashScreen2[SelectDashScreen2["WIRING"] = 6] = "WIRING";
+  SelectDashScreen2[SelectDashScreen2["RADIO"] = 8] = "RADIO";
+  SelectDashScreen2[SelectDashScreen2["BRAIN"] = 10] = "BRAIN";
+  SelectDashScreen2[SelectDashScreen2["RUN_PROGRAM"] = 13] = "RUN_PROGRAM";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_LEFT_MAPPING"] = 14] = "DRIVE_PROGRAM_CONTROL_LEFT_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_MENU"] = 15] = "DRIVE_PROGRAM_MENU";
+  SelectDashScreen2[SelectDashScreen2["DEVICES"] = 16] = "DEVICES";
+  SelectDashScreen2[SelectDashScreen2["USER_PROGRAM_FOLDER"] = 17] = "USER_PROGRAM_FOLDER";
+  SelectDashScreen2[SelectDashScreen2["VEX_PROGRAM_FOLDER"] = 18] = "VEX_PROGRAM_FOLDER";
+  SelectDashScreen2[SelectDashScreen2["SETTINGS"] = 19] = "SETTINGS";
+  SelectDashScreen2[SelectDashScreen2["SCARY_CONFIGURATION"] = 20] = "SCARY_CONFIGURATION";
+  SelectDashScreen2[SelectDashScreen2["LANGUAGE"] = 21] = "LANGUAGE";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_MOTOR_CONFIG"] = 22] = "DRIVE_MOTOR_CONFIG";
+  SelectDashScreen2[SelectDashScreen2["PROGRAM_MENU"] = 24] = "PROGRAM_MENU";
+  SelectDashScreen2[SelectDashScreen2["SHUTDOWN"] = 25] = "SHUTDOWN";
+  SelectDashScreen2[SelectDashScreen2["CONTROLLER_2_MAPPING"] = 26] = "CONTROLLER_2_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["SCARY_CONFIGURATION_MORE"] = 27] = "SCARY_CONFIGURATION_MORE";
+  SelectDashScreen2[SelectDashScreen2["CONFIRM_XX"] = 28] = "CONFIRM_XX";
+  SelectDashScreen2[SelectDashScreen2["CONTROLLER_1_MAPPING"] = 29] = "CONTROLLER_1_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_DUAL_MAPPING"] = 30] = "DRIVE_PROGRAM_CONTROL_DUAL_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_SPLIT_MAPPING"] = 31] = "DRIVE_PROGRAM_CONTROL_SPLIT_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_RIGHT_MAPPING"] = 32] = "DRIVE_PROGRAM_CONTROL_RIGHT_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["MATCH_2_4_PLAYERS"] = 33] = "MATCH_2_4_PLAYERS";
+  SelectDashScreen2[SelectDashScreen2["EVENT_LOG"] = 34] = "EVENT_LOG";
+  SelectDashScreen2[SelectDashScreen2["USER_PROGRAM_WIRING"] = 40] = "USER_PROGRAM_WIRING";
+  SelectDashScreen2[SelectDashScreen2["CLAWBOT_PROGRAM_MENU"] = 41] = "CLAWBOT_PROGRAM_MENU";
+  SelectDashScreen2[SelectDashScreen2["ABOUT"] = 42] = "ABOUT";
+  SelectDashScreen2[SelectDashScreen2["LANGUAGE_MORE"] = 43] = "LANGUAGE_MORE";
+  SelectDashScreen2[SelectDashScreen2["OBJECT_COLOR"] = 45] = "OBJECT_COLOR";
+  SelectDashScreen2[SelectDashScreen2["SIGNATURE_ID"] = 46] = "SIGNATURE_ID";
+  SelectDashScreen2[SelectDashScreen2["LOG_DATA"] = 47] = "LOG_DATA";
+})(SelectDashScreen ||= {});
+// src/VexError.ts
+class VexSerialError extends Error {
+  kind;
+  ackType = undefined;
+  constructor(kind, message) {
+    super(message);
+    this.name = "VexSerialError";
+    this.kind = kind;
+  }
+}
+
+class VexNotConnectedError extends VexSerialError {
+  constructor(message = "no connection to a V5 device") {
+    super("not-connected", message);
+    this.name = "VexNotConnectedError";
+  }
+}
+
+class VexInvalidArgumentError extends VexSerialError {
+  constructor(message) {
+    super("invalid-argument", message);
+    this.name = "VexInvalidArgumentError";
+  }
+}
+
+class VexProtocolError extends VexSerialError {
+  ackType;
+  constructor(message, ackType) {
+    super("protocol", message);
+    this.name = "VexProtocolError";
+    this.ackType = ackType;
+  }
+}
+
+class VexTransferError extends VexSerialError {
+  constructor(message) {
+    super("transfer", message);
+    this.name = "VexTransferError";
+  }
+}
+
+class VexDownloadError extends VexSerialError {
+  constructor(message) {
+    super("download", message);
+    this.name = "VexDownloadError";
+  }
+}
+
+class VexFirmwareError extends VexSerialError {
+  constructor(message) {
+    super("firmware", message);
+    this.name = "VexFirmwareError";
+  }
+}
+
+class VexIoError extends VexSerialError {
+  constructor(message) {
+    super("io", message);
+    this.name = "VexIoError";
+  }
+}
+function toVexSerialError(error, fallback = "io") {
+  if (error instanceof VexSerialError)
+    return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new VexSerialError(fallback, message);
+}
+
+// src/VexEvent.ts
+class VexEventEmitter {
+  handlerMap;
+  constructor() {
+    this.handlerMap = new Map;
+  }
+  on(eventName, listener) {
+    let listeners = this.handlerMap.get(eventName);
+    listeners ??= [];
+    listeners.push(listener);
+    this.handlerMap.set(eventName, listeners);
+  }
+  remove(eventName, listener) {
+    let listeners = this.handlerMap.get(eventName);
+    listeners ??= [];
+    const index = listeners.indexOf(listener);
+    if (index > -1) {
+      listeners.splice(index, 1);
+    }
+    this.handlerMap.set(eventName, listeners);
+  }
+  emit(eventName, data) {
+    const errors = [];
+    for (const callback of [...this.handlerMap.get(eventName) ?? []]) {
+      try {
+        callback(data);
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length === 1)
+      throw errors[0];
+    if (errors.length > 1) {
+      throw new AggregateError(errors, `listeners for ${String(eventName)} failed`);
+    }
+  }
+  clearListeners() {
+    this.handlerMap.clear();
+  }
+}
+
+class VexEventTarget {
+  emitter;
+  constructor() {
+    this.emitter = new VexEventEmitter;
+  }
+  emit(eventName, data) {
+    this.emitter.emit(this.normalizeEventName(eventName), data);
+  }
+  on(eventName, listener) {
+    this.emitter.on(this.normalizeEventName(eventName), listener);
+  }
+  remove(eventName, listener) {
+    this.emitter.remove(this.normalizeEventName(eventName), listener);
+  }
+  clearListeners() {
+    this.emitter.clearListeners();
+  }
+  normalizeEventName(eventName) {
+    return String(eventName);
+  }
+}
+
+// src/VexConnection.ts
+var import_neverthrow = __toESM(require_index_cjs(), 1);
+
+// src/VexPacketBase.ts
+var MATCH_STATUS_ALT_ACK = 167;
+
+class Packet {
+  data;
+  static ENCODER;
+  constructor(rawData) {
+    this.data = rawData instanceof ArrayBuffer ? new Uint8Array(rawData) : rawData;
+  }
+}
+
+class DeviceBoundPacket extends Packet {
+  static COMMAND_ID;
+  static COMMAND_EXTENDED_ID;
+  get commandId() {
+    return this.constructor.COMMAND_ID;
+  }
+  get commandExtendedId() {
+    return this.constructor.COMMAND_EXTENDED_ID;
+  }
+  constructor(payload) {
+    const { COMMAND_ID: cmd, COMMAND_EXTENDED_ID: ext } = new.target;
+    const encoder = Packet.ENCODER;
+    super(ext === undefined ? payload === undefined ? encoder.cdcCommand(cmd) : encoder.cdcCommandWithData(cmd, payload) : payload === undefined ? encoder.cdc2Command(cmd, ext) : encoder.cdc2CommandWithData(cmd, ext, payload));
+  }
+}
+
+class HostBoundPacket extends Packet {
+  static COMMAND_ID;
+  static COMMAND_EXTENDED_ID;
+  ack;
+  payloadSize;
+  ackIndex;
+  constructor(data) {
+    super(data);
+    this.payloadSize = Packet.ENCODER.getPayloadSize(this.data);
+    this.ackIndex = Packet.ENCODER.getHostHeaderLength(this.data) + 1;
+    this.ack = this.data[this.ackIndex];
+  }
+  static isValidPacket(data, n) {
+    const ack = data[n + 1];
+    return ack === 118 /* CDC2_ACK */ || ack === MATCH_STATUS_ALT_ACK;
+  }
+}
+
+// src/VexCRC.ts
+var POLYNOMIAL_CRC32 = 79764919;
+var POLYNOMIAL_CRC16 = 4129;
+function genTable16() {
+  const table = new Uint16Array(256);
+  for (let i = 0;i < 256; i++) {
+    let acc = i << 8;
+    for (let j = 0;j < 8; j++) {
+      acc = (acc & 32768) !== 0 ? acc << 1 ^ POLYNOMIAL_CRC16 : acc << 1;
+    }
+    table[i] = acc & 65535;
+  }
+  return table;
+}
+function genTable32() {
+  const table = new Uint32Array(256);
+  for (let i = 0;i < 256; i++) {
+    let acc = i << 24;
+    for (let j = 0;j < 8; j++) {
+      acc = (acc & 2147483648) !== 0 ? acc << 1 ^ POLYNOMIAL_CRC32 : acc << 1;
+    }
+    table[i] = acc;
+  }
+  return table;
+}
+var CRC16_TABLE = genTable16();
+var CRC32_TABLE = genTable32();
+
+class CrcGenerator {
+  crc32Table = CRC32_TABLE;
+  static POLYNOMIAL_CRC32 = POLYNOMIAL_CRC32;
+  static POLYNOMIAL_CRC16 = POLYNOMIAL_CRC16;
+  crc16(buf, initValue) {
+    let acc = initValue;
+    for (let j = 0;j < buf.length; j++) {
+      acc = (acc << 8 ^ CRC16_TABLE[(acc >>> 8 ^ buf[j]) & 255]) >>> 0;
+    }
+    return acc & 65535;
+  }
+  crc32(buf, initValue) {
+    let acc = initValue;
+    for (let j = 0;j < buf.length; j++) {
+      acc = (acc << 8 ^ CRC32_TABLE[(acc >>> 24 ^ buf[j]) & 255]) >>> 0;
+    }
+    return acc >>> 0;
+  }
+}
+
+// src/VexPacketModels.ts
+var exports_VexPacketModels = {};
+__export(exports_VexPacketModels, {
+  WriteKeyValueReplyD2HPacket: () => WriteKeyValueReplyD2HPacket,
+  WriteKeyValueH2DPacket: () => WriteKeyValueH2DPacket,
+  WriteFileReplyD2HPacket: () => WriteFileReplyD2HPacket,
+  WriteFileH2DPacket: () => WriteFileH2DPacket,
+  UpdateMatchModeH2DPacket: () => UpdateMatchModeH2DPacket,
+  SystemVersionReplyD2HPacket: () => SystemVersionReplyD2HPacket,
+  SystemVersionH2DPacket: () => SystemVersionH2DPacket,
+  SendDashTouchReplyD2HPacket: () => SendDashTouchReplyD2HPacket,
+  SendDashTouchH2DPacket: () => SendDashTouchH2DPacket,
+  SelectDashReplyD2HPacket: () => SelectDashReplyD2HPacket,
+  SelectDashH2DPacket: () => SelectDashH2DPacket,
+  ScreenCaptureReplyD2HPacket: () => ScreenCaptureReplyD2HPacket,
+  ScreenCaptureH2DPacket: () => ScreenCaptureH2DPacket,
+  ReadLogPageReplyD2HPacket: () => ReadLogPageReplyD2HPacket,
+  ReadLogPageH2DPacket: () => ReadLogPageH2DPacket,
+  ReadKeyValueReplyD2HPacket: () => ReadKeyValueReplyD2HPacket,
+  ReadKeyValueH2DPacket: () => ReadKeyValueH2DPacket,
+  ReadFileReplyD2HPacket: () => ReadFileReplyD2HPacket,
+  ReadFileH2DPacket: () => ReadFileH2DPacket,
+  Query1ReplyD2HPacket: () => Query1ReplyD2HPacket,
+  Query1H2DPacket: () => Query1H2DPacket,
+  MatchStatusReplyD2HPacket: () => MatchStatusReplyD2HPacket,
+  MatchModeReplyD2HPacket: () => MatchModeReplyD2HPacket,
+  LoadFileActionReplyD2HPacket: () => LoadFileActionReplyD2HPacket,
+  LoadFileActionH2DPacket: () => LoadFileActionH2DPacket,
+  LinkFileReplyD2HPacket: () => LinkFileReplyD2HPacket,
+  LinkFileH2DPacket: () => LinkFileH2DPacket,
+  InitFileTransferReplyD2HPacket: () => InitFileTransferReplyD2HPacket,
+  InitFileTransferH2DPacket: () => InitFileTransferH2DPacket,
+  GetSystemStatusReplyD2HPacket: () => GetSystemStatusReplyD2HPacket,
+  GetSystemStatusH2DPacket: () => GetSystemStatusH2DPacket,
+  GetSystemFlagsReplyD2HPacket: () => GetSystemFlagsReplyD2HPacket,
+  GetSystemFlagsH2DPacket: () => GetSystemFlagsH2DPacket,
+  GetSlot5to8InfoReplyD2HPacket: () => GetSlot5to8InfoReplyD2HPacket,
+  GetSlot5to8InfoH2DPacket: () => GetSlot5to8InfoH2DPacket,
+  GetSlot1to4InfoReplyD2HPacket: () => GetSlot1to4InfoReplyD2HPacket,
+  GetSlot1to4InfoH2DPacket: () => GetSlot1to4InfoH2DPacket,
+  GetRadioStatusReplyD2HPacket: () => GetRadioStatusReplyD2HPacket,
+  GetRadioStatusH2DPacket: () => GetRadioStatusH2DPacket,
+  GetRadioModeH2DPacket: () => GetRadioModeH2DPacket,
+  GetProgramSlotInfoReplyD2HPacket: () => GetProgramSlotInfoReplyD2HPacket,
+  GetProgramSlotInfoH2DPacket: () => GetProgramSlotInfoH2DPacket,
+  GetMatchStatusH2DPacket: () => GetMatchStatusH2DPacket,
+  GetLogCountReplyD2HPacket: () => GetLogCountReplyD2HPacket,
+  GetLogCountH2DPacket: () => GetLogCountH2DPacket,
+  GetFileMetadataReplyD2HPacket: () => GetFileMetadataReplyD2HPacket,
+  GetFileMetadataH2DPacket: () => GetFileMetadataH2DPacket,
+  GetFdtStatusReplyD2HPacket: () => GetFdtStatusReplyD2HPacket,
+  GetFdtStatusH2DPacket: () => GetFdtStatusH2DPacket,
+  GetDirectoryFileCountReplyD2HPacket: () => GetDirectoryFileCountReplyD2HPacket,
+  GetDirectoryFileCountH2DPacket: () => GetDirectoryFileCountH2DPacket,
+  GetDirectoryEntryReplyD2HPacket: () => GetDirectoryEntryReplyD2HPacket,
+  GetDirectoryEntryH2DPacket: () => GetDirectoryEntryH2DPacket,
+  GetDeviceStatusReplyD2HPacket: () => GetDeviceStatusReplyD2HPacket,
+  GetDeviceStatusH2DPacket: () => GetDeviceStatusH2DPacket,
+  FileFormatReplyD2HPacket: () => FileFormatReplyD2HPacket,
+  FileFormatH2DPacket: () => FileFormatH2DPacket,
+  FileControlReplyD2HPacket: () => FileControlReplyD2HPacket,
+  FileControlH2DPacket: () => FileControlH2DPacket,
+  FileClearUpReplyD2HPacket: () => FileClearUpReplyD2HPacket,
+  FileClearUpH2DPacket: () => FileClearUpH2DPacket,
+  FactoryStatusReplyD2HPacket: () => FactoryStatusReplyD2HPacket,
+  FactoryStatusH2DPacket: () => FactoryStatusH2DPacket,
+  FactoryEnableReplyD2HPacket: () => FactoryEnableReplyD2HPacket,
+  FactoryEnableH2DPacket: () => FactoryEnableH2DPacket,
+  ExitFileTransferReplyD2HPacket: () => ExitFileTransferReplyD2HPacket,
+  ExitFileTransferH2DPacket: () => ExitFileTransferH2DPacket,
+  EraseFileReplyD2HPacket: () => EraseFileReplyD2HPacket,
+  EraseFileH2DPacket: () => EraseFileH2DPacket
+});
+
+// src/VexFirmwareVersion.ts
+class VexFirmwareVersion {
+  major;
+  minor;
+  build;
+  beta;
+  constructor(major, minor, build, beta) {
+    this.major = major;
+    this.minor = minor;
+    this.build = build;
+    this.beta = beta;
+  }
+  static fromString(version) {
+    const parts = version.toLowerCase().replace(/b/g, "").split(".").map((x) => parseInt(x, 10));
+    while (parts.length < 4)
+      parts.push(0);
+    return new VexFirmwareVersion(parts[0], parts[1], parts[2], parts[3]);
+  }
+  static fromUint8Array(data, offset = 0, reverse = false) {
+    return new VexFirmwareVersion(data[offset + (reverse ? 3 : 0)], data[offset + (reverse ? 2 : 1)], data[offset + (reverse ? 1 : 2)], data[offset + (reverse ? 0 : 3)]);
+  }
+  static allZero() {
+    return new VexFirmwareVersion(0, 0, 0, 0);
+  }
+  static fromCatalogString(version) {
+    return VexFirmwareVersion.fromString(version.replace(/_/g, "."));
+  }
+  isBeta() {
+    return this.beta !== 0;
+  }
+  toUint8Array(reverse = false) {
+    const data = new Uint8Array(4);
+    data[reverse ? 3 : 0] = this.major;
+    data[reverse ? 2 : 1] = this.minor;
+    data[reverse ? 1 : 2] = this.build;
+    data[reverse ? 0 : 3] = this.beta;
+    return data;
+  }
+  toUserString() {
+    return `${this.major}.${this.minor}.${this.build}`;
+  }
+  toInternalString() {
+    return `${this.toUserString()}.b${this.beta}`;
+  }
+  compare(that) {
+    for (const [a, b] of [
+      [this.major, that.major],
+      [this.minor, that.minor],
+      [this.build, that.build],
+      [this.beta, that.beta]
+    ]) {
+      const delta = a - b;
+      if (delta !== 0)
+        return delta;
+    }
+    return 0;
+  }
+}
+
+// src/VexPacketView.ts
+var textDecoder = new TextDecoder("UTF-8");
+
+class PacketView extends DataView {
+  position = 0;
+  littleEndianDefault = true;
+  constructor(buffer, offset = 0, length = buffer.byteLength - offset) {
+    super(buffer, offset, length);
+  }
+  static fromPacket(packet) {
+    const view = new PacketView(packet.data.buffer, packet.data.byteOffset);
+    view.position = packet.ackIndex + 1;
+    return view;
+  }
+  nextInt8() {
+    return this.getInt8(this.position++);
+  }
+  nextUint8() {
+    return this.getUint8(this.position++);
+  }
+  nextInt16(littleEndian = this.littleEndianDefault) {
+    const result = this.getInt16(this.position, littleEndian);
+    this.position += 2;
+    return result;
+  }
+  nextUint16(littleEndian = this.littleEndianDefault) {
+    const result = this.getUint16(this.position, littleEndian);
+    this.position += 2;
+    return result;
+  }
+  nextInt32(littleEndian = this.littleEndianDefault) {
+    const result = this.getInt32(this.position, littleEndian);
+    this.position += 4;
+    return result;
+  }
+  nextUint32(littleEndian = this.littleEndianDefault) {
+    const result = this.getUint32(this.position, littleEndian);
+    this.position += 4;
+    return result;
+  }
+  nextString(length) {
+    const result = textDecoder.decode(new Uint8Array(this.buffer, this.byteOffset + this.position, length));
+    this.position += length;
+    return result;
+  }
+  nextNTBS(length) {
+    const start = this.position;
+    const result = this.nextVarNTBS(length);
+    this.position = start + length;
+    return result;
+  }
+  nextVarNTBS(length) {
+    const start = this.position;
+    let byteLength = 0;
+    for (let i = 0;i < length; i++) {
+      if (this.byteLength <= this.position)
+        break;
+      const g = this.nextUint8();
+      if (g === 0)
+        break;
+      byteLength++;
+    }
+    return textDecoder.decode(new Uint8Array(this.buffer, this.byteOffset + start, byteLength));
+  }
+  nextVersion(reverse = false) {
+    const result = VexFirmwareVersion.fromUint8Array(new Uint8Array(this.buffer, this.byteOffset, this.byteLength), this.position, reverse);
+    this.position += 4;
+    return result;
+  }
+}
+
+// src/VexPacketModels.ts
+var textEncoder = new TextEncoder;
+function filePayload(a, b, fileName) {
+  const payload = new Uint8Array(26);
+  payload[0] = a;
+  payload[1] = b;
+  payload.set(encodeFixedText(fileName, "Filename", 23), 2);
+  return payload;
+}
+var clamp100 = (value) => value !== undefined && value > 100 ? 100 : value;
+
+class Query1H2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 33;
+  static COMMAND_EXTENDED_ID = undefined;
+}
+
+class SystemVersionH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 164;
+  static COMMAND_EXTENDED_ID = undefined;
+}
+
+class UpdateMatchModeH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 88;
+  static COMMAND_EXTENDED_ID = 193;
+  constructor(mode, matchClock) {
+    const bit1 = mode === "autonomous" ? 10 : mode === "driver" ? 8 : 11;
+    const payload = new Uint8Array(5);
+    payload[0] = bit1 & 15;
+    new DataView(payload.buffer).setUint32(1, matchClock, true);
+    super(payload);
+  }
+}
+
+class GetMatchStatusH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 88;
+  static COMMAND_EXTENDED_ID = 194;
+}
+
+class GetRadioModeH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 88;
+  static COMMAND_EXTENDED_ID = 65;
+  constructor(mode) {
+    super(Uint8Array.of(mode));
+  }
+}
+
+class FileControlH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 16;
+  constructor(a, b) {
+    super(Uint8Array.of(a, b));
+  }
+}
+
+class InitFileTransferH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 17;
+  constructor(operation, target, vendor, options, binary, addr, name, type, version = new VexFirmwareVersion(1, 0, 0, 0)) {
+    const payload = new Uint8Array(52);
+    const view = new DataView(payload.buffer);
+    payload[0] = operation;
+    payload[1] = target;
+    payload[2] = vendor;
+    payload[3] = options;
+    view.setUint32(4, binary.length, true);
+    view.setUint32(8, addr, true);
+    view.setUint32(12, operation === 1 /* WRITE */ ? Packet.ENCODER.crcgen.crc32(binary, 0) : 0, true);
+    let ext = /(?:\.([^.]+))?$/.exec(name)?.[1] ?? "";
+    if (ext === "gz")
+      ext = "bin";
+    payload.set(encodeFixedText(type ?? ext, "File type", 4), 16);
+    const timestamp = (Date.now() / 1000 >>> 0) - PacketEncoder.J2000_EPOCH;
+    view.setUint32(20, timestamp, true);
+    payload.set(version.toUint8Array(), 24);
+    payload.set(encodeFixedText(name, "Filename", 23), 28);
+    super(payload);
+  }
+}
+
+class ExitFileTransferH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 18;
+  constructor(action) {
+    super(Uint8Array.of(action));
+  }
+}
+
+class WriteFileH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 19;
+  constructor(addr, buf) {
+    const payload = new Uint8Array(4 + buf.length);
+    new DataView(payload.buffer).setUint32(0, addr, true);
+    payload.set(buf, 4);
+    super(payload);
+  }
+}
+
+class ReadFileH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 20;
+  constructor(addr, size) {
+    const payload = new Uint8Array(6);
+    const view = new DataView(payload.buffer);
+    view.setUint32(0, addr, true);
+    view.setUint16(4, size, true);
+    super(payload);
+  }
+}
+
+class LinkFileH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 21;
+  constructor(vendor, fileName, options) {
+    super(filePayload(vendor, options, fileName));
+  }
+}
+
+class GetDirectoryFileCountH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 22;
+  constructor(vendor) {
+    super(Uint8Array.of(vendor, 0));
+  }
+}
+
+class GetDirectoryEntryH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 23;
+  constructor(index) {
+    super(Uint8Array.of(index, 0));
+  }
+}
+
+class LoadFileActionH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 24;
+  constructor(vendor, actionId, fileNameOrSlotNumber) {
+    const fileName = typeof fileNameOrSlotNumber === "string" ? fileNameOrSlotNumber : `___s_${fileNameOrSlotNumber - 1}.bin`;
+    super(filePayload(vendor, actionId, fileName));
+  }
+}
+
+class GetFileMetadataH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 25;
+  constructor(vendor, fileName, options) {
+    super(filePayload(vendor, options, fileName));
+  }
+}
+
+class EraseFileH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 27;
+  constructor(vendor, fileName) {
+    super(filePayload(vendor, 128, fileName));
+  }
+}
+
+class GetProgramSlotInfoH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 28;
+  constructor(vendor, fileName) {
+    super(filePayload(vendor, 0, fileName));
+  }
+}
+
+class FileClearUpH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 30;
+  constructor(vendor) {
+    super(Uint8Array.of(vendor, 0));
+  }
+}
+
+class FileFormatH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 31;
+  constructor() {
+    super(Uint8Array.of(68, 67, 66, 65));
+  }
+}
+
+class GetSystemFlagsH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 32;
+}
+
+class GetDeviceStatusH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 33;
+}
+
+class GetSystemStatusH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 34;
+}
+
+class GetFdtStatusH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 35;
+}
+
+class GetLogCountH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 36;
+}
+
+class ReadLogPageH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 37;
+  constructor(offset, count) {
+    const payload = new Uint8Array(8);
+    const view = new DataView(payload.buffer);
+    view.setUint32(0, offset, true);
+    view.setUint32(4, count, true);
+    super(payload);
+  }
+}
+
+class GetRadioStatusH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 38;
+}
+
+class ScreenCaptureH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 40;
+  constructor(e) {
+    super(Uint8Array.of(e));
+  }
+}
+
+class SendDashTouchH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 42;
+  constructor(x, y, press) {
+    const payload = new Uint8Array(6);
+    const view = new DataView(payload.buffer);
+    view.setUint16(0, x, true);
+    view.setUint16(2, y, true);
+    view.setUint16(4, press ? 1 : 0, true);
+    super(payload);
+  }
+}
+
+class SelectDashH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 43;
+  constructor(screen, port) {
+    super(Uint8Array.of(screen, port));
+  }
+}
+
+class ReadKeyValueH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 46;
+  constructor(key) {
+    const payload = new Uint8Array(32);
+    payload.set(encodeFixedText(key, "Key", 31), 0);
+    super(payload);
+  }
+}
+
+class WriteKeyValueH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 47;
+  constructor(key, value) {
+    const strk = encodeFixedText(key, "Key", 31);
+    const strv = textEncoder.encode(value);
+    if (strk.byteLength + strv.byteLength + 20 > 32767) {
+      throw new RangeError("Key and value are too large for a protocol packet");
+    }
+    const payload = new Uint8Array(strk.length + strv.length + 20);
+    payload.set(strk, 0);
+    payload.set(strv, strk.length + 1);
+    super(payload);
+  }
+}
+
+class GetSlot1to4InfoH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 49;
+}
+
+class GetSlot5to8InfoH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 50;
+}
+
+class FactoryStatusH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 241;
+}
+
+class FactoryEnableH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 255;
+  constructor() {
+    super(Uint8Array.of(77, 76, 75, 74));
+  }
+}
+
+class Query1ReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 33;
+  static COMMAND_EXTENDED_ID = undefined;
+  joystickFlag1;
+  joystickFlag2;
+  brainFlag1;
+  brainFlag2;
+  bootloadFlag1;
+  bootloadFlag2;
+  constructor(data) {
+    super(data);
+    this.joystickFlag1 = this.data[4];
+    this.joystickFlag2 = this.data[5];
+    this.brainFlag1 = this.data[6];
+    this.brainFlag2 = this.data[7];
+    this.bootloadFlag1 = this.data[10];
+    this.bootloadFlag2 = this.data[11];
+  }
+}
+
+class SystemVersionReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 164;
+  static COMMAND_EXTENDED_ID = undefined;
+  version;
+  hardware;
+  constructor(data) {
+    super(data);
+    this.version = new VexFirmwareVersion(this.data[4], this.data[5], this.data[6], this.data[8]);
+    this.hardware = this.data[7];
+  }
+}
+
+class MatchModeReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 88;
+  static COMMAND_EXTENDED_ID = 193;
+  modebit;
+  constructor(data) {
+    super(data);
+    this.modebit = PacketView.fromPacket(this).nextUint8();
+  }
+}
+
+class MatchStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 88;
+  static COMMAND_EXTENDED_ID = 194;
+  rssi;
+  systemStatusBits;
+  radioStatusBits;
+  fieldStatusBits;
+  matchClock;
+  brainBatteryPercent;
+  controllerBatteryPercent;
+  partnerControllerBatteryPercent;
+  pad;
+  buttons;
+  activeProgram;
+  radioType;
+  radioChannel;
+  radioSlot;
+  robotName;
+  controllerFlags;
+  rxSignalQuality;
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    const n = this.ackIndex;
+    this.rssi = view.nextInt8();
+    this.systemStatusBits = view.nextUint16();
+    this.radioStatusBits = view.nextUint16();
+    this.fieldStatusBits = view.nextUint8();
+    this.matchClock = view.nextUint8();
+    this.brainBatteryPercent = view.nextUint8();
+    this.controllerBatteryPercent = view.nextUint8();
+    this.partnerControllerBatteryPercent = view.nextUint8();
+    this.pad = view.nextUint8();
+    this.buttons = view.nextUint16();
+    this.activeProgram = view.nextUint8();
+    this.radioType = view.nextUint8();
+    this.radioChannel = view.nextUint8();
+    this.radioSlot = view.nextUint8();
+    this.controllerFlags = view.getUint8(n + 28);
+    this.rxSignalQuality = view.getUint8(n + 29);
+    const raw = new TextDecoder("UTF-8").decode(this.data.slice(n + 18, n + this.payloadSize + 28));
+    const end = raw.indexOf("\x00");
+    this.robotName = end > -1 ? raw.slice(0, end) : raw;
+  }
+}
+
+class FileControlReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 16;
+}
+
+class InitFileTransferReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 17;
+  windowSize;
+  fileSize;
+  crc32;
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    this.windowSize = view.nextUint16();
+    this.fileSize = view.nextUint32();
+    this.crc32 = view.nextUint32();
+  }
+}
+
+class ExitFileTransferReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 18;
+}
+
+class WriteFileReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 19;
+}
+
+class ReadFileReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 20;
+  addr;
+  length;
+  buf;
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    this.addr = view.nextUint32();
+    this.length = this.payloadSize - 8;
+    this.buf = this.data.slice(view.position, view.position + this.length).buffer;
+  }
+}
+
+class LinkFileReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 21;
+}
+
+class GetDirectoryFileCountReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 22;
+  count;
+  constructor(data) {
+    super(data);
+    this.count = PacketView.fromPacket(this).nextUint16();
+  }
+}
+
+class GetDirectoryEntryReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 23;
+  file;
+  constructor(data) {
+    super(data);
+    if (this.payloadSize <= 4)
+      return;
+    const view = PacketView.fromPacket(this);
+    this.file = {
+      index: view.nextUint8(),
+      size: view.nextUint32(),
+      loadAddress: view.nextUint32(),
+      crc32: view.nextUint32(),
+      type: view.nextString(4),
+      timestamp: view.nextUint32() + PacketEncoder.J2000_EPOCH,
+      version: view.nextVersion(),
+      filename: view.nextNTBS(32)
+    };
+  }
+}
+
+class LoadFileActionReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 24;
+}
+
+class GetFileMetadataReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 25;
+  file;
+  constructor(data) {
+    super(data);
+    if (this.payloadSize <= 4)
+      return;
+    const view = PacketView.fromPacket(this);
+    view.nextUint8();
+    this.file = {
+      size: view.nextUint32(),
+      loadAddress: view.nextUint32(),
+      crc32: view.nextUint32(),
+      type: view.nextString(4),
+      timestamp: view.nextUint32() + PacketEncoder.J2000_EPOCH,
+      version: view.nextVersion()
+    };
+  }
+}
+
+class EraseFileReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 27;
+}
+
+class GetProgramSlotInfoReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 28;
+  requestedSlot;
+  slot;
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    this.slot = view.nextUint8();
+    this.requestedSlot = view.nextUint8();
+  }
+}
+
+class FileClearUpReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 30;
+}
+
+class FileFormatReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 31;
+}
+
+class GetSystemFlagsReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 32;
+  flags;
+  radioSearching = false;
+  radioQuality;
+  controllerBatteryPercent;
+  partnerControllerBatteryPercent;
+  battery;
+  currentProgram = 0;
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    this.flags = view.nextUint32();
+    const hasPartner = (8192 & this.flags) !== 0;
+    const hasRadio = (1536 & this.flags) === 1536;
+    const byte1 = view.nextUint8();
+    const byte2 = view.nextUint8();
+    if (this.payloadSize === 11) {
+      this.battery = clamp100(8 * (byte1 & 15));
+      if ((this.flags & 256) !== 0 || hasRadio) {
+        this.controllerBatteryPercent = clamp100(8 * (byte1 >> 4 & 15));
+      }
+      if (hasRadio)
+        this.radioQuality = clamp100(8 * (byte2 & 15));
+      this.radioSearching = (this.flags & 1536) === 512;
+      if (hasPartner) {
+        this.partnerControllerBatteryPercent = clamp100(8 * (byte2 >> 4 & 15));
+      }
+      this.currentProgram = view.nextUint8();
+    }
+  }
+}
+
+class GetDeviceStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 33;
+  count;
+  devices;
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    this.count = view.nextUint8();
+    this.devices = [];
+    for (let i = 0;i < this.count; i++) {
+      this.devices.push({
+        port: view.nextUint8(),
+        type: view.nextUint8(),
+        status: view.nextUint8(),
+        betaversion: view.nextUint8(),
+        version: view.nextUint16(),
+        bootversion: view.nextUint16()
+      });
+    }
+  }
+}
+
+class GetSystemStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 34;
+  systemVersion;
+  cpu0Version;
+  cpu1Version;
+  nxpVersion = VexFirmwareVersion.allZero();
+  touchVersion;
+  uniqueId = 1234;
+  sysflags = [0, 0, 0, 0, 0, 0, 0];
+  eventBrain = false;
+  romBootloaderActive = false;
+  ramBootloaderActive = false;
+  goldenVersion = VexFirmwareVersion.allZero();
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    view.nextUint8();
+    this.systemVersion = view.nextVersion();
+    this.cpu0Version = view.nextVersion();
+    this.cpu1Version = view.nextVersion();
+    this.touchVersion = view.nextVersion(true);
+    if (this.payloadSize > 25) {
+      this.uniqueId = view.nextUint32();
+      this.sysflags = [
+        view.nextUint8(),
+        view.nextUint8(),
+        view.nextUint8(),
+        view.nextUint8(),
+        view.nextUint8(),
+        0,
+        view.nextUint8()
+      ];
+      const flags6 = this.sysflags[6];
+      this.eventBrain = (1 & flags6) !== 0;
+      this.romBootloaderActive = (2 & flags6) !== 0;
+      this.ramBootloaderActive = (4 & flags6) !== 0;
+      view.nextUint16();
+      this.goldenVersion = view.nextVersion();
+    }
+    if (this.payloadSize > 37) {
+      this.nxpVersion = view.nextVersion();
+    }
+  }
+}
+
+class GetFdtStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 35;
+  count;
+  status;
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    this.count = view.nextUint8();
+    this.status = [];
+    for (let i = 0;i < this.count; i++) {
+      this.status.push({
+        index: view.nextUint8(),
+        type: view.nextUint8(),
+        status: view.nextUint8(),
+        betaversion: view.nextUint8(),
+        version: view.nextUint16(),
+        bootversion: view.nextUint16()
+      });
+    }
+  }
+}
+
+class GetLogCountReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 36;
+  count;
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    view.nextUint8();
+    this.count = view.nextUint32();
+  }
+}
+
+class ReadLogPageReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 37;
+  offset;
+  count;
+  entries;
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    const size = view.nextUint8();
+    this.offset = view.nextUint32();
+    this.count = view.nextUint16();
+    this.entries = [];
+    let j = this.ackIndex + 8;
+    for (let i = 0;i < this.count; i++) {
+      this.entries.push({
+        code: view.getUint8(j),
+        type: view.getUint8(j + 1),
+        desc: view.getUint8(j + 2),
+        spare: view.getUint8(j + 3),
+        time: view.getUint32(j + 4, true)
+      });
+      j += size;
+    }
+  }
+}
+
+class GetRadioStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 38;
+  device;
+  quality;
+  strength;
+  channel;
+  timeslot;
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    this.device = view.nextUint8();
+    this.quality = view.nextUint16();
+    this.strength = view.nextInt16();
+    this.channel = this.data[this.ackIndex + 6];
+    this.timeslot = this.data[this.ackIndex + 7];
+  }
+}
+
+class ScreenCaptureReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 40;
+}
+
+class SendDashTouchReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 42;
+}
+
+class SelectDashReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 43;
+}
+
+class ReadKeyValueReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 46;
+  value;
+  constructor(data) {
+    super(data);
+    this.value = PacketView.fromPacket(this).nextVarNTBS(255);
+  }
+}
+
+class WriteKeyValueReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 47;
+}
+
+class GetSlot1to4InfoReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 49;
+  slotFlags;
+  slots;
+  constructor(data, start = 1) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    this.slotFlags = view.nextUint8();
+    this.slots = [];
+    for (let i = 0;i < 4; i++) {
+      if ((this.slotFlags & 1 << start - 1 + i) === 0)
+        continue;
+      const icon = view.nextUint16();
+      const nameLen = view.nextUint8();
+      this.slots.push({
+        slot: start + i,
+        icon,
+        name: view.nextString(nameLen)
+      });
+    }
+  }
+}
+
+class GetSlot5to8InfoReplyD2HPacket extends GetSlot1to4InfoReplyD2HPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 50;
+  slotStartIndex = 5;
+  constructor(data) {
+    super(data, 5);
+  }
+}
+
+class FactoryStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 241;
+  status;
+  percent;
+  constructor(data) {
+    super(data);
+    const view = PacketView.fromPacket(this);
+    this.status = view.nextUint8();
+    this.percent = view.nextUint8();
+  }
+}
+
+class FactoryEnableReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 255;
+}
+
+// src/VexPacketEncoder.ts
+var textEncoder2 = new TextEncoder;
+var HEADER_TO_DEVICE = Uint8Array.of(201, 54, 184, 71);
+function encodeFixedText(value, field, maxBytes) {
+  const encoded = textEncoder2.encode(value);
+  if (encoded.byteLength > maxBytes) {
+    throw new RangeError(`${field} must be at most ${maxBytes} UTF-8 bytes`);
+  }
+  return encoded;
+}
+
+class PacketEncoder {
+  static HEADERS_LENGTH = 4;
+  static HEADER_TO_DEVICE = [201, 54, 184, 71];
+  static HEADER_TO_HOST = [170, 85];
+  static J2000_EPOCH = 946684800;
+  vexVersion = 0;
+  crcgen = new CrcGenerator;
+  allPacketsTable = new Map;
+  static getInstance() {
+    Packet.ENCODER ??= new PacketEncoder;
+    return Packet.ENCODER;
+  }
+  constructor() {
+    for (const packet of Object.values(exports_VexPacketModels)) {
+      if (typeof packet === "function" && packet.prototype instanceof HostBoundPacket) {
+        const type = packet;
+        let byExtendedId = this.allPacketsTable.get(type.COMMAND_ID);
+        if (byExtendedId === undefined) {
+          byExtendedId = new Map;
+          this.allPacketsTable.set(type.COMMAND_ID, byExtendedId);
+        }
+        byExtendedId.set(type.COMMAND_EXTENDED_ID, type);
+      }
+    }
+  }
+  getPacketType(commandId, commandExtendedId) {
+    if (commandId === undefined)
+      return;
+    return this.allPacketsTable.get(commandId)?.get(commandExtendedId);
+  }
+  createHeader(buf) {
+    if (buf === undefined || buf.byteLength < PacketEncoder.HEADERS_LENGTH) {
+      buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH);
+    }
+    const h = new Uint8Array(buf);
+    h.set(HEADER_TO_DEVICE);
+    return h;
+  }
+  cdcCommand(cmd) {
+    const h = new Uint8Array(5);
+    h.set(HEADER_TO_DEVICE);
+    h[4] = cmd;
+    return h;
+  }
+  cdcCommandWithData(cmd, data) {
+    const h = new Uint8Array(6 + data.length);
+    h.set(HEADER_TO_DEVICE);
+    h[4] = cmd;
+    h[5] = data.length;
+    h.set(data, 6);
+    return h;
+  }
+  cdc2Command(cmd, ext) {
+    const h = new Uint8Array(9);
+    h.set(HEADER_TO_DEVICE);
+    h[4] = cmd;
+    h[5] = ext;
+    h[6] = 0;
+    this.appendCrc16(h);
+    return h;
+  }
+  cdc2CommandBufferLength(data) {
+    return PacketEncoder.HEADERS_LENGTH + data.length + 5 + (data.length > 127 ? 1 : 0);
+  }
+  cdc2CommandWithData(cmd, ext, data) {
+    const h = new Uint8Array(this.cdc2CommandBufferLength(data));
+    h.set(HEADER_TO_DEVICE);
+    h[4] = cmd;
+    h[5] = ext;
+    if (data.length < 128) {
+      h[6] = data.length;
+      h.set(data, 7);
+    } else {
+      h[6] = data.length >>> 8 | 128;
+      h[7] = data.length & 255;
+      h.set(data, 8);
+    }
+    this.appendCrc16(h);
+    return h;
+  }
+  appendCrc16(h) {
+    const crc = this.crcgen.crc16(h.subarray(0, h.length - 2), 0);
+    h[h.length - 2] = crc >>> 8;
+    h[h.length - 1] = crc & 255;
+  }
+  validateHeader(data) {
+    return data[0] === PacketEncoder.HEADER_TO_HOST[0] && data[1] === PacketEncoder.HEADER_TO_HOST[1];
+  }
+  validateMessageCdc(data) {
+    const crc = (data[data.byteLength - 2] << 8) + data[data.byteLength - 1];
+    return this.crcgen.crc16(data.subarray(0, data.byteLength - 2), 0) === crc;
+  }
+  getPayloadSize(data) {
+    const a = data[3];
+    return (a & 128) === 0 ? a : ((a & 127) << 8) + data[4];
+  }
+  getHostHeaderLength(data) {
+    return (data[3] & 128) === 0 ? 4 : 5;
+  }
+}
+
+// src/VexConnection.ts
+var thePacketEncoder = PacketEncoder.getInstance();
+var SCREEN_CAPTURE_HEIGHT = 272;
+var SCREEN_CAPTURE_WIDTH = 480;
+var SCREEN_CAPTURE_CHANNELS = 3;
+var SCREEN_CAPTURE_MESSAGE_WIDTH = 512;
+var SCREEN_CAPTURE_MESSAGE_CHANNELS = 4;
+
+class VexSerialConnection extends VexEventTarget {
+  filters = [{ usbVendorId: 10376 }];
+  writer;
+  reader;
+  port;
+  serial;
+  callbacksQueue = [];
+  _onPortDisconnect = null;
+  _closePromise = null;
+  _wasConnected = false;
+  fileTransferTail = Promise.resolve();
+  fileTransferDepth = 0;
+  get isConnected() {
+    return this.port !== undefined && this.reader !== undefined && this.writer !== undefined;
+  }
+  get isFileTransferring() {
+    return this.fileTransferDepth > 0;
+  }
+  constructor(serial) {
+    super();
+    this.serial = serial;
+  }
+  reportWarning(message, details) {
+    this.emit("warning", { message, details });
+  }
+  async close() {
+    if (this._closePromise)
+      return this._closePromise;
+    if (!this._hasOpenResources())
+      return;
+    this._closePromise = this._doClose();
+    try {
+      await this._closePromise;
+    } finally {
+      this._closePromise = null;
+    }
+  }
+  _hasOpenResources() {
+    return this.port !== undefined || this.reader !== undefined || this.writer !== undefined || this._onPortDisconnect !== null || this.callbacksQueue.length > 0;
+  }
+  async _doClose() {
+    for (const callback of this.callbacksQueue.splice(0)) {
+      clearTimeout(callback.timeout);
+      callback.callback(255 /* CDC2_NACK */);
+    }
+    const onDisconnect = this._onPortDisconnect;
+    this._onPortDisconnect = null;
+    if (onDisconnect !== null) {
+      try {
+        this.port?.removeEventListener("disconnect", onDisconnect);
+      } catch {}
+    }
+    const writer = this.writer;
+    this.writer = undefined;
+    if (writer !== undefined) {
+      try {
+        await writer.close();
+      } catch {} finally {
+        try {
+          writer.releaseLock();
+        } catch {}
+      }
+    }
+    const reader = this.reader;
+    this.reader = undefined;
+    if (reader !== undefined) {
+      try {
+        await reader.cancel();
+      } catch {}
+      try {
+        while (true) {
+          const { done } = await reader.read();
+          if (done)
+            break;
+        }
+      } catch {} finally {
+        try {
+          reader.releaseLock();
+        } catch {}
+      }
+    }
+    const port = this.port;
+    this.port = undefined;
+    if (port !== undefined) {
+      try {
+        await port.close();
+      } catch (e) {
+        this.reportWarning("failed to close the serial port", e);
+      }
+    }
+    if (this._wasConnected) {
+      this._wasConnected = false;
+      this.emit("disconnected", undefined);
+    }
+  }
+  open(use = 0, askUser = true) {
+    return new import_neverthrow.ResultAsync(this._open(use, askUser));
+  }
+  async _open(use, askUser) {
+    if (this._closePromise !== null)
+      await this._closePromise;
+    if (this.port !== undefined) {
+      return import_neverthrow.err(new VexIoError("Already connected."));
+    }
+    const ports = (await this.serial.getPorts()).filter((p) => {
+      const info = p.getInfo();
+      return this.filters.find((f) => (f.usbVendorId === undefined || f.usbVendorId === info.usbVendorId) && (f.usbProductId === undefined || f.usbProductId === info.usbProductId));
+    }).filter((candidate) => candidate.readable === null);
+    let port = ports[use];
+    if (port == null && askUser) {
+      try {
+        port = await this.serial.requestPort({ filters: this.filters });
+      } catch {}
+    }
+    if (port == null)
+      return import_neverthrow.ok("no-port");
+    if (port.readable != null)
+      return import_neverthrow.ok("busy");
+    try {
+      this.port = port;
+      await port.open({ baudRate: 115200 });
+      this._onPortDisconnect = () => {
+        this.close();
+      };
+      this.port.addEventListener("disconnect", this._onPortDisconnect);
+      this.writer = this.port.writable.getWriter();
+      this.reader = this.port.readable.getReader();
+      this.startReader();
+      this._wasConnected = true;
+      this.emit("connected", undefined);
+      return import_neverthrow.ok("opened");
+    } catch (e) {
+      await this.close();
+      return import_neverthrow.err(toVexSerialError(e, "io"));
+    }
+  }
+  async writeDataAsync(rawData, timeout = 1000) {
+    return new Promise((resolve) => {
+      if (this.writer === undefined) {
+        resolve(255 /* CDC2_NACK */);
+        return;
+      }
+      const data = rawData instanceof DeviceBoundPacket ? rawData.data : rawData;
+      const cb = {
+        callback: resolve,
+        timeout: setTimeout(() => {
+          const index = this.callbacksQueue.indexOf(cb);
+          if (index === -1)
+            return;
+          this.callbacksQueue.splice(index, 1);
+          cb.callback(256 /* TIMEOUT */);
+        }, timeout),
+        wantedCommandId: rawData instanceof DeviceBoundPacket ? rawData.commandId : undefined,
+        wantedCommandExId: rawData instanceof DeviceBoundPacket ? rawData.commandExtendedId : undefined
+      };
+      this.callbacksQueue.push(cb);
+      this.writer.write(data).catch(() => {
+        const index = this.callbacksQueue.indexOf(cb);
+        if (index === -1)
+          return;
+        this.callbacksQueue.splice(index, 1);
+        clearTimeout(cb.timeout);
+        resolve(257 /* WRITE_ERROR */);
+      });
+    });
+  }
+  request(packet, ReplyType, timeout = 1000) {
+    return new import_neverthrow.ResultAsync((async () => {
+      const result = await this.writeDataAsync(packet, timeout);
+      if (result instanceof ReplyType)
+        return import_neverthrow.ok(result);
+      return import_neverthrow.err(new VexProtocolError(expectedReplyMessage(packet, ReplyType, result), typeof result === "number" ? result : undefined));
+    })());
+  }
+  async readData(cache, expectedSize) {
+    if (this.reader == null)
+      throw new Error("No reader");
+    while (cache.byteLength < expectedSize) {
+      const { value: readData, done: isDone } = await this.reader.read();
+      if (isDone)
+        throw new Error("No data");
+      cache = binaryArrayJoin(cache, readData);
+    }
+    return cache;
+  }
+  async startReader() {
+    let cache = new Uint8Array([]);
+    let sliceIdx = 0;
+    for (;; )
+      try {
+        cache = await this.readData(cache, 5);
+        sliceIdx = 0;
+        while (!thePacketEncoder.validateHeader(cache)) {
+          const nextHeader = cache.findIndex((byte, index) => index > 0 && byte === PacketEncoder.HEADER_TO_HOST[0] && cache[index + 1] === PacketEncoder.HEADER_TO_HOST[1]);
+          if (nextHeader >= 0) {
+            cache = cache.slice(nextHeader);
+          } else {
+            cache = cache.slice(cache.at(-1) === PacketEncoder.HEADER_TO_HOST[0] ? -1 : cache.length);
+          }
+          cache = await this.readData(cache, 5);
+        }
+        const payloadExpectedSize = thePacketEncoder.getPayloadSize(cache);
+        const n = thePacketEncoder.getHostHeaderLength(cache);
+        const totalSize = n + payloadExpectedSize;
+        cache = await this.readData(cache, totalSize);
+        sliceIdx = totalSize;
+        const cmdId = cache[2];
+        const hasExtId = cmdId === 88 || cmdId === 86;
+        const cmdExId = hasExtId ? cache[n] : undefined;
+        const ack = cache[n + 1];
+        if (hasExtId) {
+          if (!thePacketEncoder.validateMessageCdc(cache))
+            throw new Error("Invalid message CDC");
+        }
+        let matchIdx = -1;
+        let untypedIdx = -1;
+        for (let i = 0;i < this.callbacksQueue.length; i++) {
+          const candidate = this.callbacksQueue[i];
+          if (candidate.wantedCommandId === undefined && candidate.wantedCommandExId === undefined) {
+            if (untypedIdx === -1)
+              untypedIdx = i;
+            continue;
+          }
+          if ((candidate.wantedCommandId === undefined || candidate.wantedCommandId === cmdId) && (candidate.wantedCommandExId === undefined || candidate.wantedCommandExId === cmdExId)) {
+            matchIdx = i;
+            break;
+          }
+        }
+        if (matchIdx === -1)
+          matchIdx = untypedIdx;
+        if (matchIdx === -1) {
+          this.reportWarning("received a reply with no matching request", {
+            commandId: cmdId,
+            commandExtendedId: cmdExId,
+            ack
+          });
+          continue;
+        }
+        const callbackInfo = this.callbacksQueue[matchIdx];
+        const wantedCmdId = callbackInfo.wantedCommandId;
+        const wantedCmdExId = callbackInfo.wantedCommandExId;
+        const data = cache.slice(0, sliceIdx);
+        const PackageType = thePacketEncoder.getPacketType(wantedCmdId, wantedCmdExId);
+        if (wantedCmdId === undefined || PackageType === undefined) {
+          if (wantedCmdId !== undefined) {
+            this.reportWarning("no packet class is registered for the wanted command", { commandId: wantedCmdId, commandExtendedId: wantedCmdExId });
+          }
+          callbackInfo.callback(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
+        } else {
+          if (!hasExtId || PackageType.isValidPacket(data, n)) {
+            callbackInfo.callback(new PackageType(data));
+          } else {
+            this.reportWarning("reply failed packet validation; delivering its ack instead", { commandId: cmdId, commandExtendedId: cmdExId, ack });
+            callbackInfo.callback(ack);
+          }
+        }
+        clearTimeout(callbackInfo.timeout);
+        this.callbacksQueue.splice(matchIdx, 1);
+      } catch (e) {
+        if (!(e instanceof Error && e.message === "No data")) {
+          this.reportWarning("reader loop stopped by a read error", {
+            error: e,
+            pendingBytes: cache
+          });
+        }
+        await this.close();
+        break;
+      } finally {
+        cache = cache.slice(sliceIdx);
+      }
+  }
+  query1() {
+    return this.request(new Query1H2DPacket, Query1ReplyD2HPacket, 100);
+  }
+  getSystemVersion() {
+    return this.request(new SystemVersionH2DPacket, SystemVersionReplyD2HPacket).map((result) => result.version);
+  }
+}
+
+class V5SerialConnection extends VexSerialConnection {
+  filters = [
+    { usbVendorId: 10376, usbProductId: 1281 /* V5_BRAIN */ },
+    { usbVendorId: 10376, usbProductId: 1282 /* V5_BRAIN_DFU */ },
+    { usbVendorId: 10376, usbProductId: 1283 /* V5_CONTROLLER */ }
+  ];
+  async withFileTransfer(operation) {
+    const previous = this.fileTransferTail;
+    let release = () => {};
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.fileTransferTail = previous.then(() => current);
+    this.fileTransferDepth++;
+    try {
+      await previous;
+      return await operation();
+    } finally {
+      this.fileTransferDepth--;
+      release();
+    }
+  }
+  getDeviceStatus() {
+    return this.request(new GetDeviceStatusH2DPacket, GetDeviceStatusReplyD2HPacket);
+  }
+  getRadioStatus() {
+    return this.request(new GetRadioStatusH2DPacket, GetRadioStatusReplyD2HPacket);
+  }
+  getSystemFlags() {
+    return this.request(new GetSystemFlagsH2DPacket, GetSystemFlagsReplyD2HPacket);
+  }
+  getSystemStatus(timeout = 1000) {
+    return this.request(new GetSystemStatusH2DPacket, GetSystemStatusReplyD2HPacket, timeout);
+  }
+  getMatchStatus() {
+    return this.request(new GetMatchStatusH2DPacket, MatchStatusReplyD2HPacket);
+  }
+  uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback) {
+    return wrapTransfer(this, () => this._uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback));
+  }
+  async _uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback) {
+    const iniFileBuffer = new TextEncoder().encode(iniConfig.createIni());
+    const basename = iniConfig.baseName;
+    const iniRequest = {
+      filename: basename + ".ini",
+      buf: iniFileBuffer,
+      downloadTarget: 1 /* FILE_TARGET_QSPI */,
+      vendor: 1 /* USER */,
+      autoRun: false
+    };
+    const r1 = await this.uploadFileToDeviceUnlocked(iniRequest, (current, total) => {
+      progressCallback("INI", current, total);
+    });
+    if (r1.isErr())
+      return import_neverthrow.err(r1.error);
+    if (!r1.value)
+      return import_neverthrow.ok(false);
+    const coldRequest = coldFileBuf !== undefined ? {
+      filename: basename + "_lib.bin",
+      buf: coldFileBuf,
+      downloadTarget: 1 /* FILE_TARGET_QSPI */,
+      vendor: 24 /* DEV2 */,
+      autoRun: false
+    } : undefined;
+    if (coldRequest != null) {
+      const r2 = await this.uploadFileToDeviceUnlocked(coldRequest, (current, total) => {
+        progressCallback("COLD", current, total);
+      });
+      if (r2.isErr())
+        return import_neverthrow.err(r2.error);
+      if (!r2.value)
+        return import_neverthrow.ok(false);
+    }
+    const binRequest = {
+      filename: basename + ".bin",
+      buf: binFileBuf,
+      downloadTarget: 1 /* FILE_TARGET_QSPI */,
+      vendor: 1 /* USER */,
+      loadAddress: coldFileBuf != null ? 125829120 : undefined,
+      autoRun: iniConfig.autorun,
+      linkedFile: coldRequest
+    };
+    const r3 = await this.uploadFileToDeviceUnlocked(binRequest, (current, total) => {
+      progressCallback("BIN", current, total);
+    });
+    return r3;
+  }
+  downloadFileToHost(request, downloadTarget = 1 /* FILE_TARGET_QSPI */, progressCallback) {
+    return wrapTransfer(this, () => this.downloadFileToHostUnlocked(request, downloadTarget, progressCallback));
+  }
+  downloadFileToHostUnlocked(request, downloadTarget = 1 /* FILE_TARGET_QSPI */, progressCallback) {
+    return new import_neverthrow.ResultAsync(this._downloadFileToHostUnlocked(request, downloadTarget, progressCallback));
+  }
+  async _downloadFileToHostUnlocked(request, downloadTarget, progressCallback) {
+    const { filename, vendor, loadAddress, size } = request;
+    let nextAddress = loadAddress ?? USER_FLASH_USR_CODE_START;
+    const p1Result = await this.request(new InitFileTransferH2DPacket(2 /* READ */, downloadTarget, vendor, 0 /* NONE */, new Uint8Array, nextAddress, filename, ""), InitFileTransferReplyD2HPacket);
+    if (p1Result.isErr())
+      return import_neverthrow.err(p1Result.error);
+    let transferFailed = true;
+    let result = import_neverthrow.ok(new Uint8Array);
+    try {
+      const p1 = p1Result.value;
+      const fileSize = size ?? p1.fileSize;
+      const bufferChunkSize = getTransferChunkSize(p1.windowSize);
+      let bufferOffset = 0;
+      const fileBuf = new Uint8Array(fileSize);
+      while (bufferOffset < fileSize) {
+        const requestedSize = Math.min(bufferChunkSize, fileSize - bufferOffset);
+        const p2Result = await this.request(new ReadFileH2DPacket(nextAddress, requestedSize), ReadFileReplyD2HPacket, 3000);
+        if (p2Result.isErr())
+          throw p2Result.error;
+        const p2 = p2Result.value;
+        if (p2.addr !== nextAddress) {
+          throw new VexTransferError(`ReadFileReplyD2HPacket returned address ${p2.addr}, expected ${nextAddress}`);
+        }
+        if (p2.length <= 0 || p2.length > requestedSize || p2.buf.byteLength !== p2.length) {
+          throw new VexTransferError(`ReadFileReplyD2HPacket returned invalid length ${p2.length}`);
+        }
+        fileBuf.set(new Uint8Array(p2.buf), bufferOffset);
+        bufferOffset += p2.length;
+        nextAddress += p2.length;
+        progressCallback?.(bufferOffset, fileSize);
+      }
+      transferFailed = false;
+      result = import_neverthrow.ok(fileBuf);
+    } catch (e) {
+      result = import_neverthrow.err(e instanceof VexSerialError ? e : toVexSerialError(e, "transfer"));
+    } finally {
+      try {
+        const exitResult = await this.request(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */), ExitFileTransferReplyD2HPacket, 30000);
+        if (!transferFailed && exitResult.isErr())
+          result = import_neverthrow.err(exitResult.error);
+      } catch (e) {
+        if (!transferFailed)
+          result = import_neverthrow.err(toVexSerialError(e, "io"));
+      }
+    }
+    return result;
+  }
+  uploadFileToDevice(request, progressCallback) {
+    return wrapTransfer(this, () => this.uploadFileToDeviceUnlocked(request, progressCallback));
+  }
+  async uploadFileToDeviceUnlocked(request, progressCallback) {
+    let {
+      filename,
+      buf,
+      downloadTarget,
+      vendor,
+      loadAddress,
+      exttype,
+      autoRun,
+      linkedFile
+    } = request;
+    if (buf === undefined) {
+      return import_neverthrow.err(new VexTransferError("no buffer provided for upload"));
+    }
+    downloadTarget = downloadTarget ?? 1 /* FILE_TARGET_QSPI */;
+    vendor = vendor ?? 1 /* USER */;
+    let nextAddress = loadAddress ?? USER_FLASH_USR_CODE_START;
+    const p1Result = await this.request(new InitFileTransferH2DPacket(1 /* WRITE */, downloadTarget, vendor, 1 /* OVERWRITE */, buf, nextAddress, filename, exttype), InitFileTransferReplyD2HPacket);
+    if (p1Result.isErr())
+      return import_neverthrow.err(p1Result.error);
+    const p1 = p1Result.value;
+    const bufferChunkSize = getTransferChunkSize(p1.windowSize);
+    let bufferOffset = 0;
+    let lastBlock = false;
+    let transferFailed = true;
+    let result = import_neverthrow.ok(false);
+    try {
+      if (linkedFile !== undefined) {
+        const p3Result = await this.request(new LinkFileH2DPacket(linkedFile.vendor ?? 1 /* USER */, linkedFile.filename, 0), LinkFileReplyD2HPacket, 1e4);
+        if (p3Result.isErr())
+          throw p3Result.error;
+      }
+      while (!lastBlock) {
+        let tmpbuf;
+        if (buf.byteLength - bufferOffset > bufferChunkSize) {
+          tmpbuf = buf.subarray(bufferOffset, bufferOffset + bufferChunkSize);
+        } else {
+          const length = (buf.byteLength - bufferOffset + 3) / 4 >>> 0;
+          tmpbuf = new Uint8Array(length * 4);
+          tmpbuf.set(buf.subarray(bufferOffset, buf.byteLength));
+          lastBlock = true;
+        }
+        const p2Result = await this.request(new WriteFileH2DPacket(nextAddress, tmpbuf), WriteFileReplyD2HPacket, 3000);
+        if (p2Result.isErr())
+          throw p2Result.error;
+        bufferOffset += bufferChunkSize;
+        nextAddress += bufferChunkSize;
+        progressCallback?.(Math.min(bufferOffset, buf.byteLength), buf.byteLength);
+      }
+      transferFailed = false;
+    } catch (e) {
+      result = import_neverthrow.err(e instanceof VexSerialError ? e : toVexSerialError(e, "transfer"));
+    } finally {
+      try {
+        const exitResult = await this.request(new ExitFileTransferH2DPacket(transferFailed ? 3 /* EXIT_HALT */ : autoRun ? 1 /* EXIT_RUN */ : 3 /* EXIT_HALT */), ExitFileTransferReplyD2HPacket, 30000);
+        if (!transferFailed) {
+          result = exitResult.map(() => true);
+        }
+      } catch (cleanupError) {
+        if (!transferFailed) {
+          result = import_neverthrow.err(toVexSerialError(cleanupError, "io"));
+        }
+      }
+    }
+    return result;
+  }
+  removeFile(request) {
+    return new import_neverthrow.ResultAsync(this.withFileTransfer(async () => {
+      let vendor, filename;
+      if (typeof request === "string") {
+        vendor = 1 /* USER */;
+        filename = request;
+      } else {
+        vendor = request.vendor;
+        filename = request.filename;
+      }
+      let result;
+      try {
+        const eraseResult = await this.request(new EraseFileH2DPacket(vendor, filename), EraseFileReplyD2HPacket);
+        result = eraseResult.map(() => {
+          return;
+        });
+      } catch (e) {
+        result = import_neverthrow.err(toVexSerialError(e, "io"));
+      }
+      try {
+        const exitResult = await this.request(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */), ExitFileTransferReplyD2HPacket, 30000);
+        if (result.isOk() && exitResult.isErr())
+          result = import_neverthrow.err(exitResult.error);
+      } catch (e) {
+        if (result.isOk())
+          result = import_neverthrow.err(toVexSerialError(e, "io"));
+      }
+      return result;
+    }));
+  }
+  removeAllFiles() {
+    return new import_neverthrow.ResultAsync(this.withFileTransfer(async () => {
+      let result;
+      try {
+        const clearResult = await this.request(new FileClearUpH2DPacket(1 /* USER */), FileClearUpReplyD2HPacket, 30000);
+        result = clearResult.map(() => {
+          return;
+        });
+      } catch (e) {
+        result = import_neverthrow.err(toVexSerialError(e, "io"));
+      }
+      try {
+        const exitResult = await this.request(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */), ExitFileTransferReplyD2HPacket, 30000);
+        if (result.isOk() && exitResult.isErr())
+          result = import_neverthrow.err(exitResult.error);
+      } catch (e) {
+        if (result.isOk())
+          result = import_neverthrow.err(toVexSerialError(e, "io"));
+      }
+      return result;
+    }));
+  }
+  captureScreenSetup() {
+    return this.request(new ScreenCaptureH2DPacket(0), ScreenCaptureReplyD2HPacket);
+  }
+  captureScreen(progressCallback) {
+    return wrapTransfer(this, () => this._captureScreen(progressCallback));
+  }
+  async _captureScreen(progressCallback) {
+    const response = await this.captureScreenSetup();
+    if (response.isErr()) {
+      return import_neverthrow.err(response.error);
+    }
+    const framebuffer = await this.downloadFileToHostUnlocked({
+      filename: "screen",
+      vendor: 15 /* SYS */,
+      loadAddress: 0,
+      size: SCREEN_CAPTURE_MESSAGE_WIDTH * SCREEN_CAPTURE_HEIGHT * SCREEN_CAPTURE_MESSAGE_CHANNELS
+    }, 2 /* FILE_TARGET_CBUF */, progressCallback);
+    if (framebuffer.isErr())
+      return import_neverthrow.err(framebuffer.error);
+    return import_neverthrow.ok(convertScreenCapture(framebuffer.value));
+  }
+  setMatchMode(mode) {
+    return this.request(new UpdateMatchModeH2DPacket(mode, 0), MatchModeReplyD2HPacket);
+  }
+  runProgram(value) {
+    return this.loadProgram(value);
+  }
+  loadProgram(value) {
+    return this.request(new LoadFileActionH2DPacket(1 /* USER */, 0 /* RUN */, value), LoadFileActionReplyD2HPacket);
+  }
+  stopProgram() {
+    return this.request(new LoadFileActionH2DPacket(1 /* USER */, 128 /* STOP */, ""), LoadFileActionReplyD2HPacket);
+  }
+  mockTouch(x, y, press) {
+    return this.request(new SendDashTouchH2DPacket(x, y, press), SendDashTouchReplyD2HPacket);
+  }
+  openScreen(screen, port) {
+    return this.request(new SelectDashH2DPacket(screen, port), SelectDashReplyD2HPacket);
+  }
+}
+function binaryArrayJoin(left, right) {
+  const leftSize = left != null ? left.byteLength : 0;
+  const rightSize = right != null ? right.byteLength : 0;
+  const all = new Uint8Array(leftSize + rightSize);
+  if (all.length === 0)
+    return new Uint8Array;
+  if (left != null)
+    all.set(new Uint8Array(left), 0);
+  if (right != null)
+    all.set(new Uint8Array(right), leftSize);
+  return all;
+}
+function getTransferChunkSize(windowSize) {
+  return windowSize > 0 && windowSize <= USER_PROG_CHUNK_SIZE ? windowSize : USER_PROG_CHUNK_SIZE;
+}
+function convertScreenCapture(framebuffer) {
+  const pixels = new Uint8Array(SCREEN_CAPTURE_WIDTH * SCREEN_CAPTURE_HEIGHT * SCREEN_CAPTURE_CHANNELS);
+  for (let row = 0;row < SCREEN_CAPTURE_HEIGHT; row++) {
+    for (let column = 0;column < SCREEN_CAPTURE_WIDTH; column++) {
+      const source = (row * SCREEN_CAPTURE_MESSAGE_WIDTH + column) * SCREEN_CAPTURE_MESSAGE_CHANNELS;
+      const target = (row * SCREEN_CAPTURE_WIDTH + column) * SCREEN_CAPTURE_CHANNELS;
+      pixels[target] = framebuffer[source + 2] ?? 0;
+      pixels[target + 1] = framebuffer[source + 1] ?? 0;
+      pixels[target + 2] = framebuffer[source] ?? 0;
+    }
+  }
+  return pixels;
+}
+function wrapTransfer(conn, operation) {
+  return new import_neverthrow.ResultAsync(conn.withFileTransfer(async () => {
+    try {
+      return await operation();
+    } catch (e) {
+      if (e instanceof VexSerialError)
+        return import_neverthrow.err(e);
+      return import_neverthrow.err(toVexSerialError(e, "io"));
+    }
+  }));
+}
+function expectedReplyMessage(packet, ReplyType, reply) {
+  const expected = `expected ${ReplyType.name} for ${packet.constructor.name}`;
+  if (typeof reply === "number")
+    return `${expected}; received ${ackTypeName(reply)}`;
+  if (reply instanceof ArrayBuffer)
+    return `${expected}; received raw ArrayBuffer`;
+  return `${expected}; received ${reply.constructor.name}`;
+}
+function ackTypeName(ackType) {
+  return `AckType.${AckType[ackType] ?? "UNKNOWN"} (${ackType})`;
+}
+// src/VexDeviceState.ts
+var import_neverthrow4 = __toESM(require_index_cjs(), 1);
+
+// src/VexFirmware.ts
+var import_neverthrow2 = __toESM(require_index_cjs(), 1);
+var MAX_CATALOG_BYTES = 4 * 1024;
+var MAX_VEXOS_BYTES = 64 * 1024 * 1024;
+var MAX_FIRMWARE_IMAGE_BYTES = 32 * 1024 * 1024;
+var MAX_AGGREGATE_IMAGE_BYTES = 48 * 1024 * 1024;
+function downloadFileFromInternet(link, options = {}) {
+  const { maxBytes = Number.POSITIVE_INFINITY, timeout = 30000 } = options;
+  if (maxBytes <= 0) {
+    return import_neverthrow2.errAsync(new VexInvalidArgumentError("maxBytes must be positive"));
+  }
+  if (timeout < 0) {
+    return import_neverthrow2.errAsync(new VexInvalidArgumentError("timeout must be non-negative"));
+  }
+  return new import_neverthrow2.ResultAsync(runDownload(link, maxBytes, timeout));
+}
+async function runDownload(link, maxBytes, timeout) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    let response;
+    try {
+      response = await fetch(link, { signal: controller.signal });
+    } catch (e) {
+      return import_neverthrow2.err(new VexDownloadError(`failed to download ${link} (${e instanceof Error ? e.message : String(e)})`));
+    }
+    if (!response.ok) {
+      return import_neverthrow2.err(new VexDownloadError(`failed to download ${link} (${response.status})`));
+    }
+    const declaredLength = response.headers.get("content-length");
+    if (declaredLength !== null) {
+      const declared = Number.parseInt(declaredLength, 10);
+      if (!Number.isNaN(declared) && declared > 0 && declared > maxBytes) {
+        return import_neverthrow2.err(new VexDownloadError(`declared content length ${declared} exceeds limit ${maxBytes} for ${link}`));
+      }
+    }
+    if (response.body == null) {
+      return import_neverthrow2.err(new VexDownloadError(`no response body for ${link}`));
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+      for (;; ) {
+        const { value, done } = await reader.read();
+        if (done)
+          break;
+        if (value === undefined)
+          continue;
+        total += value.byteLength;
+        if (total > maxBytes) {
+          try {
+            await reader.cancel();
+          } catch {}
+          return import_neverthrow2.err(new VexDownloadError(`downloaded body exceeds limit ${maxBytes} for ${link}`));
+        }
+        chunks.push(value);
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {}
+    }
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return import_neverthrow2.ok(result.buffer);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function sleepUntilAsync(f, timeout, interval = 20) {
+  if (timeout < 0) {
+    return import_neverthrow2.errAsync(new VexInvalidArgumentError("timeout must be non-negative"));
+  }
+  if (interval <= 0) {
+    return import_neverthrow2.errAsync(new VexInvalidArgumentError("interval must be positive"));
+  }
+  return new import_neverthrow2.ResultAsync(runSleepUntilAsync(f, timeout, interval));
+}
+async function runSleepUntilAsync(f, timeout, interval) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() <= deadline) {
+    try {
+      if (await f())
+        return import_neverthrow2.ok(true);
+    } catch (e) {
+      return import_neverthrow2.err(toVexSerialError(e, "io"));
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0)
+      break;
+    await sleepInner(Math.min(interval, remaining));
+  }
+  return import_neverthrow2.ok(false);
+}
+function sleepUntil(f, timeout, interval = 20) {
+  if (timeout < 0) {
+    return import_neverthrow2.errAsync(new VexInvalidArgumentError("timeout must be non-negative"));
+  }
+  if (interval <= 0) {
+    return import_neverthrow2.errAsync(new VexInvalidArgumentError("interval must be positive"));
+  }
+  return new import_neverthrow2.ResultAsync(runSleepUntil(f, timeout, interval));
+}
+async function runSleepUntil(f, timeout, interval) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() <= deadline) {
+    try {
+      if (f())
+        return import_neverthrow2.ok(true);
+    } catch (e) {
+      return import_neverthrow2.err(toVexSerialError(e, "io"));
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0)
+      break;
+    await sleepInner(Math.min(interval, remaining));
+  }
+  return import_neverthrow2.ok(false);
+}
+function sleep(ms) {
+  if (ms < 0) {
+    return import_neverthrow2.errAsync(new VexInvalidArgumentError("ms must be non-negative"));
+  }
+  return import_neverthrow2.ResultAsync.fromSafePromise(sleepInner(ms));
+}
+async function sleepInner(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function flashFactoryImage(conn, options, pcb) {
+  const { image, label, downloadTarget } = options;
+  pcb(`FACTORY ENB ${label}`, 0, 0);
+  const enableReply = await conn.request(new FactoryEnableH2DPacket, FactoryEnableReplyD2HPacket);
+  if (enableReply.isErr())
+    return import_neverthrow2.err(enableReply.error);
+  const writeRequest = {
+    filename: "null.bin",
+    vendor: 1 /* USER */,
+    loadAddress: USER_FLASH_USR_CODE_START,
+    buf: image.buf,
+    downloadTarget,
+    exttype: "bin",
+    autoRun: true,
+    linkedFile: undefined
+  };
+  const upload = await conn.uploadFileToDevice(writeRequest, (c, t) => {
+    pcb(`UPLOAD ${label}`, c, t);
+  });
+  if (upload.isErr())
+    return import_neverthrow2.err(upload.error);
+  if (!upload.value) {
+    return import_neverthrow2.err(new VexFirmwareError(`${label} upload was rejected by device`));
+  }
+  const deadline = Date.now() + 120000;
+  while (Date.now() < deadline) {
+    const statusReply = await conn.request(new FactoryStatusH2DPacket, FactoryStatusReplyD2HPacket, 1e4);
+    if (statusReply.isErr())
+      return import_neverthrow2.err(statusReply.error);
+    reportFactoryStatus(label, statusReply.value, pcb);
+    if (statusReply.value.status === 0 && statusReply.value.percent === 100) {
+      return import_neverthrow2.ok(undefined);
+    }
+    await sleepInner(500);
+  }
+  return import_neverthrow2.err(new VexFirmwareError(`${label} factory status timed out`));
+}
+function reportFactoryStatus(label, reply, pcb) {
+  switch (reply.status) {
+    case 2:
+      pcb(`ERASE ${label}`, reply.percent, 100);
+      break;
+    case 3:
+      pcb(`WRITE ${label}`, reply.percent, 100);
+      break;
+    case 4:
+      pcb(`VERIFY ${label}`, reply.percent, 100);
+      break;
+    case 8:
+      pcb(`FINISHING ${label}`, reply.percent, 100);
+      break;
+  }
+}
+async function extractFirmwareImages(usingVersion, vexos) {
+  const { unzip } = await import("unzipit");
+  const { entries } = await unzip(vexos);
+  const expectedPaths = new Set([
+    `${usingVersion}/BOOT.bin`,
+    `${usingVersion}/assets.bin`
+  ]);
+  const unexpected = [];
+  for (const name of Object.keys(entries)) {
+    if (!expectedPaths.has(name))
+      unexpected.push(name);
+  }
+  if (unexpected.length > 0) {
+    throw new VexFirmwareError(`VEXos archive contains unexpected entries: ${unexpected.join(", ")}`);
+  }
+  const ordered = [];
+  let aggregate = 0;
+  for (const name of expectedPaths) {
+    const entry = entries[name];
+    if (entry === undefined) {
+      throw new VexFirmwareError(`VEXos archive is missing ${name}`);
+    }
+    if (entry.encrypted) {
+      throw new VexFirmwareError(`VEXos entry ${name} is encrypted`);
+    }
+    if (entry.size <= 0) {
+      throw new VexFirmwareError(`VEXos entry ${name} is empty`);
+    }
+    if (entry.size > MAX_FIRMWARE_IMAGE_BYTES) {
+      throw new VexFirmwareError(`VEXos entry ${name} (${entry.size} bytes) exceeds per-entry limit ${MAX_FIRMWARE_IMAGE_BYTES}`);
+    }
+    aggregate += entry.size;
+    if (aggregate > MAX_AGGREGATE_IMAGE_BYTES) {
+      throw new VexFirmwareError(`VEXos aggregate extracted size exceeds limit ${MAX_AGGREGATE_IMAGE_BYTES}`);
+    }
+    const buf = new Uint8Array(await entry.arrayBuffer());
+    if (buf.byteLength === 0) {
+      throw new VexFirmwareError(`VEXos entry ${name} is empty`);
+    }
+    if (buf.byteLength !== entry.size) {
+      throw new VexFirmwareError(`VEXos entry ${name} size does not match its metadata (${buf.byteLength} vs ${entry.size})`);
+    }
+    ordered.push({ name, buf });
+  }
+  return ordered;
+}
+function uploadFirmware(state, publicUrl = "https://content.vexrobotics.com/vexos/public/V5/", usingVersion, progressCallback) {
+  return new import_neverthrow2.ResultAsync(runUploadFirmware(state, publicUrl, usingVersion, progressCallback));
+}
+async function runUploadFirmware(state, publicUrl, usingVersion, progressCallback) {
+  const device = state._instance;
+  const conn = device.connection;
+  if (conn == null || !conn.isConnected) {
+    return import_neverthrow2.err(new VexNotConnectedError);
+  }
+  const pcb = progressCallback ?? (() => {});
+  let version = usingVersion;
+  if (version === undefined) {
+    pcb("FETCH CATALOG", 0, 1);
+    const catalog = await downloadFileFromInternet(publicUrl + "catalog.txt", {
+      maxBytes: MAX_CATALOG_BYTES
+    });
+    if (catalog.isErr())
+      return import_neverthrow2.err(catalog.error);
+    version = new TextDecoder().decode(catalog.value).trim();
+    pcb("FETCH CATALOG", 1, 1);
+  }
+  if (!/^[A-Za-z0-9._-]+$/.test(version)) {
+    return import_neverthrow2.err(new VexFirmwareError(`invalid VEXos version: ${version}`));
+  }
+  pcb("FETCH VEXOS", 0, 1);
+  const vexosResult = await downloadFileFromInternet(publicUrl + version + ".vexos", { maxBytes: MAX_VEXOS_BYTES });
+  if (vexosResult.isErr())
+    return import_neverthrow2.err(vexosResult.error);
+  const vexos = vexosResult.value;
+  if (vexos.byteLength === 0) {
+    return import_neverthrow2.err(new VexFirmwareError("VEXos archive is empty"));
+  }
+  pcb("FETCH VEXOS", 1, 1);
+  pcb("UNZIP VEXOS", 0, 1);
+  let images;
+  try {
+    images = await extractFirmwareImages(version, vexos);
+  } catch (e) {
+    if (e instanceof VexSerialError)
+      return import_neverthrow2.err(e);
+    return import_neverthrow2.err(toVexSerialError(e, "firmware"));
+  }
+  pcb("UNZIP VEXOS", 1, 1);
+  return state.withRefreshPaused(async () => {
+    const boot = images.find((image) => image.name.endsWith("BOOT.bin"));
+    if (boot === undefined) {
+      return import_neverthrow2.err(new VexFirmwareError("VEXos archive is missing BOOT.bin"));
+    }
+    const assertImage = images.find((image) => image.name.endsWith("assets.bin"));
+    if (assertImage === undefined) {
+      return import_neverthrow2.err(new VexFirmwareError("VEXos archive is missing assets.bin"));
+    }
+    const bootFlash = await flashFactoryImage(conn, {
+      image: boot,
+      label: "BOOT",
+      downloadTarget: 14 /* FILE_TARGET_B1 */
+    }, pcb);
+    if (bootFlash.isErr())
+      return import_neverthrow2.err(bootFlash.error);
+    const assetsFlash = await flashFactoryImage(conn, {
+      image: assertImage,
+      label: "ASSETS",
+      downloadTarget: 13 /* FILE_TARGET_A1 */
+    }, pcb);
+    if (assetsFlash.isErr())
+      return import_neverthrow2.err(assetsFlash.error);
+    return import_neverthrow2.ok(true);
+  });
+}
+
+// src/VexTransfers.ts
+var import_neverthrow3 = __toESM(require_index_cjs(), 1);
+function getValue(state, key) {
+  return new import_neverthrow3.ResultAsync((async () => {
+    const conn = state._instance.connection;
+    if (conn == null || !conn.isConnected) {
+      return import_neverthrow3.err(new VexNotConnectedError);
+    }
+    return conn.request(new ReadKeyValueH2DPacket(key), ReadKeyValueReplyD2HPacket).map((result) => result.value);
+  })());
+}
+function setValue(state, key, value) {
+  return new import_neverthrow3.ResultAsync((async () => {
+    const conn = state._instance.connection;
+    if (conn == null || !conn.isConnected) {
+      return import_neverthrow3.err(new VexNotConnectedError);
+    }
+    return conn.request(new WriteKeyValueH2DPacket(key, value), WriteKeyValueReplyD2HPacket).map(() => {
+      return;
+    });
+  })());
+}
+function listFiles(state, vendor = 1 /* USER */) {
+  return new import_neverthrow3.ResultAsync((async () => {
+    const conn = state._instance.connection;
+    if (conn == null || !conn.isConnected) {
+      return import_neverthrow3.err(new VexNotConnectedError);
+    }
+    const countResult = await conn.request(new GetDirectoryFileCountH2DPacket(vendor), GetDirectoryFileCountReplyD2HPacket);
+    if (countResult.isErr())
+      return import_neverthrow3.err(countResult.error);
+    const files = [];
+    for (let i = 0;i < countResult.value.count; i++) {
+      const entryResult = await conn.request(new GetDirectoryEntryH2DPacket(i), GetDirectoryEntryReplyD2HPacket);
+      if (entryResult.isErr())
+        return import_neverthrow3.err(entryResult.error);
+      if (entryResult.value.file != null) {
+        files.push({
+          filename: entryResult.value.file.filename,
+          vendor,
+          loadAddress: entryResult.value.file.loadAddress,
+          size: entryResult.value.file.size,
+          crc32: entryResult.value.file.crc32,
+          type: entryResult.value.file.type,
+          timestamp: entryResult.value.file.timestamp,
+          version: entryResult.value.file.version
+        });
+      }
+    }
+    return import_neverthrow3.ok(files);
+  })());
+}
+function listProgram(state) {
+  return new import_neverthrow3.ResultAsync((async () => {
+    const conn = state._instance.connection;
+    if (conn == null || !conn.isConnected) {
+      return import_neverthrow3.err(new VexNotConnectedError);
+    }
+    const files = await listFiles(state, 1 /* USER */);
+    if (files.isErr())
+      return import_neverthrow3.err(files.error);
+    const programList = [];
+    const iniFiles = files.value.filter((file) => file.filename.endsWith(".ini"));
+    for (let i = 0;i < iniFiles.length; i++) {
+      const ini = iniFiles[i];
+      if (ini.size === 0)
+        continue;
+      const programName = /(.+?)(\.[^.]*$|$)/.exec(ini.filename)?.[1] ?? "";
+      const bin = files.value.find((file) => file.filename === programName + ".bin");
+      if (bin == null || bin.timestamp === 0 || bin.size === 0)
+        continue;
+      const n = new Date;
+      n.setTime(1000 * bin.timestamp);
+      const program = {
+        name: programName,
+        binfile: bin.filename,
+        size: ini.size + bin.size,
+        slot: -1,
+        time: n,
+        requestedSlot: -1
+      };
+      const slotInfo = await conn.request(new GetProgramSlotInfoH2DPacket(1 /* USER */, program.binfile), GetProgramSlotInfoReplyD2HPacket);
+      if (slotInfo.isOk()) {
+        program.slot = slotInfo.value.slot;
+        program.requestedSlot = slotInfo.value.requestedSlot;
+      }
+      programList.push(program);
+    }
+    return import_neverthrow3.ok(programList);
+  })());
+}
+function readFile(state, request, downloadTarget = 1 /* FILE_TARGET_QSPI */, progressCallback) {
+  return new import_neverthrow3.ResultAsync((async () => {
+    const conn = state._instance.connection;
+    if (conn == null || !conn.isConnected) {
+      return import_neverthrow3.err(new VexNotConnectedError);
+    }
+    let handle;
+    if (typeof request === "string") {
+      handle = { filename: request, vendor: 1 /* USER */ };
+    } else {
+      handle = request;
+    }
+    return state.withRefreshPaused(() => conn.downloadFileToHost(handle, downloadTarget, progressCallback));
+  })());
+}
+function removeFile(state, request) {
+  return new import_neverthrow3.ResultAsync((async () => {
+    const conn = state._instance.connection;
+    if (conn == null || !conn.isConnected) {
+      return import_neverthrow3.err(new VexNotConnectedError);
+    }
+    return state.withRefreshPaused(() => conn.removeFile(request));
+  })());
+}
+function removeAllFiles(state) {
+  return new import_neverthrow3.ResultAsync((async () => {
+    const conn = state._instance.connection;
+    if (conn == null || !conn.isConnected) {
+      return import_neverthrow3.err(new VexNotConnectedError);
+    }
+    return state.withRefreshPaused(() => conn.removeAllFiles());
+  })());
+}
+function uploadProgram(state, iniConfig, binFileBuf, coldFileBuf, progressCallback) {
+  return new import_neverthrow3.ResultAsync(runUploadProgram(state, iniConfig, binFileBuf, coldFileBuf, progressCallback));
+}
+async function runUploadProgram(state, iniConfig, binFileBuf, coldFileBuf, progressCallback) {
+  const device = state._instance;
+  const conn = device.connection;
+  if (conn == null || !conn.isConnected) {
+    return import_neverthrow3.err(new VexNotConnectedError);
+  }
+  let switchedToDownload = false;
+  return state.withRefreshPaused(async () => {
+    try {
+      if (device.isV5Controller) {
+        await sleep(250);
+        const refreshed = await device.refresh();
+        if (refreshed.isErr() || !refreshed.value) {
+          return import_neverthrow3.err(new VexProtocolError("device is unavailable"));
+        }
+        progressCallback("CHANNEL", 0, 1);
+        const p1 = await device.radio.changeChannel(1 /* DOWNLOAD */);
+        if (p1.isErr())
+          return import_neverthrow3.err(p1.error);
+        switchedToDownload = true;
+        await sleep(250);
+        const transferred = await sleepUntilAsync(async () => (await conn?.getSystemStatus(150))?.isOk() ?? false, 1e4, 200);
+        if (transferred.isErr())
+          return import_neverthrow3.err(transferred.error);
+        if (!transferred.value) {
+          return import_neverthrow3.err(new VexProtocolError("channel switch timed out"));
+        }
+        progressCallback("CHANNEL", 1, 1);
+      }
+      const p2 = await conn.uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback);
+      if (p2.isErr())
+        return import_neverthrow3.err(p2.error);
+      if (!p2.value)
+        return import_neverthrow3.err(new VexProtocolError("program upload rejected"));
+      if (device.isV5Controller) {
+        if (!device.brain.isAvailable) {
+          return import_neverthrow3.err(new VexProtocolError("brain unavailable after upload"));
+        }
+        progressCallback("CHANNEL", 0, 1);
+        const p3 = await device.radio.changeChannel(0 /* PIT */);
+        if (p3.isErr())
+          return import_neverthrow3.err(p3.error);
+        switchedToDownload = false;
+        await sleep(250);
+        const transferred = await sleepUntilAsync(async () => (await conn?.getSystemStatus(150))?.isOk() ?? false, 1e4, 200);
+        if (transferred.isErr())
+          return import_neverthrow3.err(transferred.error);
+        if (!transferred.value) {
+          return import_neverthrow3.err(new VexProtocolError("channel switch timed out"));
+        }
+        progressCallback("CHANNEL", 1, 1);
+      }
+      return import_neverthrow3.ok(true);
+    } finally {
+      if (switchedToDownload) {
+        await device.radio.changeChannel(0 /* PIT */);
+      }
+    }
+  });
+}
+function writeFile(state, request, progressCallback) {
+  return new import_neverthrow3.ResultAsync((async () => {
+    const conn = state._instance.connection;
+    if (conn == null || !conn.isConnected) {
+      return import_neverthrow3.err(new VexNotConnectedError);
+    }
+    return state.withRefreshPaused(() => conn.uploadFileToDevice(request, progressCallback));
+  })());
+}
+function captureScreen(state, progressCallback) {
+  return new import_neverthrow3.ResultAsync((async () => {
+    const conn = state._instance.connection;
+    if (conn == null || !conn.isConnected) {
+      return import_neverthrow3.err(new VexNotConnectedError);
+    }
+    return state.withRefreshPaused(() => conn.captureScreen(progressCallback));
+  })());
+}
+
+// src/VexDeviceState.ts
+class VexSerialDevice extends VexEventTarget {
+  connection;
+  defaultSerial;
+  get isConnected() {
+    return this.connection != null ? this.connection.isConnected : false;
+  }
+  get deviceType() {
+    return this.isConnected ? this.connection?.port?.getInfo().usbProductId : undefined;
+  }
+  constructor(defaultSerial) {
+    super();
+    this.defaultSerial = defaultSerial;
+  }
+}
+
+class V5SerialDeviceState {
+  _instance;
+  refreshPauseDepth = 0;
+  get isRefreshPaused() {
+    return this.refreshPauseDepth > 0;
+  }
+  get isFileTransferring() {
+    return this.isRefreshPaused;
+  }
+  async withRefreshPaused(operation) {
+    this.refreshPauseDepth++;
+    try {
+      return await operation();
+    } finally {
+      this.refreshPauseDepth--;
+    }
+  }
+  async withFileTransfer(operation) {
+    return this.withRefreshPaused(operation);
+  }
+  brain = {
+    activeProgram: 0,
+    battery: {
+      batteryPercent: 0,
+      isCharging: false
+    },
+    button: {
+      isPressed: false,
+      isDoublePressed: false
+    },
+    cpu0Version: VexFirmwareVersion.allZero(),
+    cpu1Version: VexFirmwareVersion.allZero(),
+    isAvailable: false,
+    settings: {
+      isScreenReversed: false,
+      isWhiteTheme: false,
+      usingLanguage: 0
+    },
+    systemVersion: VexFirmwareVersion.allZero(),
+    uniqueId: 0
+  };
+  controllers = [
+    {
+      battery: 0,
+      isAvailable: false,
+      isCharging: false
+    },
+    {
+      battery: 0,
+      isAvailable: false,
+      isCharging: false
+    }
+  ];
+  devices = [];
+  isFieldControllerConnected = false;
+  matchMode = "disabled";
+  radio = {
+    channel: 0,
+    isAvailable: false,
+    isConnected: false,
+    isVexNet: false,
+    isRadioData: false,
+    latency: 0,
+    signalQuality: 0,
+    signalStrength: 0
+  };
+  constructor(instance) {
+    this._instance = instance;
+  }
+}
+
+class V5Brain {
+  state;
+  batteryFacade;
+  buttonFacade;
+  settingsFacade;
+  constructor(state) {
+    this.state = state;
+    this.batteryFacade = new V5Battery(state);
+    this.buttonFacade = new V5BrainButton(state);
+    this.settingsFacade = new V5BrainSettings(state);
+  }
+  get isRunningProgram() {
+    return this.activeProgram !== 0;
+  }
+  get activeProgram() {
+    return this.state.brain.activeProgram;
+  }
+  set activeProgram(value) {
+    this.setActiveProgram(value).mapErr(() => {});
+  }
+  setActiveProgram(value) {
+    return new import_neverthrow4.ResultAsync((async () => {
+      if (this.state.brain.activeProgram === value)
+        return import_neverthrow4.ok(undefined);
+      const conn = this.state._instance.connection;
+      if (conn == null)
+        return import_neverthrow4.err(new VexNotConnectedError);
+      const result = value === 0 ? await conn.stopProgram() : await conn.loadProgram(value);
+      if (result.isErr())
+        return import_neverthrow4.err(result.error);
+      this.state.brain.activeProgram = value;
+      return import_neverthrow4.ok(undefined);
+    })());
+  }
+  runProgram(slot) {
+    return new import_neverthrow4.ResultAsync((async () => {
+      const conn = this.state._instance.connection;
+      if (conn == null)
+        return import_neverthrow4.err(new VexNotConnectedError);
+      const reply = await conn.runProgram(slot);
+      if (reply.isErr())
+        return import_neverthrow4.err(reply.error);
+      if (typeof slot === "number")
+        this.state.brain.activeProgram = slot;
+      return import_neverthrow4.ok(undefined);
+    })());
+  }
+  stopProgram() {
+    return new import_neverthrow4.ResultAsync((async () => {
+      const conn = this.state._instance.connection;
+      if (conn == null)
+        return import_neverthrow4.err(new VexNotConnectedError);
+      const reply = await conn.stopProgram();
+      if (reply.isErr())
+        return import_neverthrow4.err(reply.error);
+      this.state.brain.activeProgram = 0;
+      return import_neverthrow4.ok(undefined);
+    })());
+  }
+  get battery() {
+    return this.batteryFacade;
+  }
+  get button() {
+    return this.buttonFacade;
+  }
+  get cpu0Version() {
+    return this.state.brain.cpu0Version;
+  }
+  get cpu1Version() {
+    return this.state.brain.cpu1Version;
+  }
+  get isAvailable() {
+    return this.state.brain.isAvailable;
+  }
+  get settings() {
+    return this.settingsFacade;
+  }
+  get systemVersion() {
+    return this.state.brain.systemVersion;
+  }
+  get uniqueId() {
+    return this.state.brain.uniqueId;
+  }
+  getValue(key) {
+    return getValue(this.state, key);
+  }
+  setValue(key, value) {
+    return setValue(this.state, key, value);
+  }
+  listFiles(vendor = 1 /* USER */) {
+    return listFiles(this.state, vendor);
+  }
+  listProgram() {
+    return listProgram(this.state);
+  }
+  readFile(request, downloadTarget = 1 /* FILE_TARGET_QSPI */, progressCallback) {
+    return readFile(this.state, request, downloadTarget, progressCallback);
+  }
+  removeFile(request) {
+    return removeFile(this.state, request);
+  }
+  removeAllFiles() {
+    return removeAllFiles(this.state);
+  }
+  uploadFirmware(publicUrl = "https://content.vexrobotics.com/vexos/public/V5/", usingVersion, progressCallback) {
+    return uploadFirmware(this.state, publicUrl, usingVersion, progressCallback);
+  }
+  uploadProgram(iniConfig, binFileBuf, coldFileBuf, progressCallback) {
+    return uploadProgram(this.state, iniConfig, binFileBuf, coldFileBuf, progressCallback);
+  }
+  writeFile(request, progressCallback) {
+    return writeFile(this.state, request, progressCallback);
+  }
+  captureScreen(progressCallback) {
+    return captureScreen(this.state, progressCallback);
+  }
+}
+
+class V5Battery {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  get batteryPercent() {
+    return this.state.brain.battery.batteryPercent;
+  }
+  get isCharging() {
+    return this.state.brain.battery.isCharging;
+  }
+}
+
+class V5BrainButton {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  get isPressed() {
+    return this.state.brain.button.isPressed;
+  }
+  get isDoublePressed() {
+    return this.state.brain.button.isDoublePressed;
+  }
+}
+
+class V5BrainSettings {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  get isScreenReversed() {
+    return this.state.brain.settings.isScreenReversed;
+  }
+  get isWhiteTheme() {
+    return this.state.brain.settings.isWhiteTheme;
+  }
+  get usingLanguage() {
+    return this.state.brain.settings.usingLanguage;
+  }
+}
+
+class V5Controller {
+  state;
+  controllerIndex;
+  constructor(state, controllerIndex) {
+    this.state = state;
+    this.controllerIndex = controllerIndex;
+  }
+  get batteryPercent() {
+    return this.state.controllers[this.controllerIndex].battery;
+  }
+  get isMasterController() {
+    return this.controllerIndex === 0;
+  }
+  get isAvailable() {
+    return this.state.controllers[this.controllerIndex].isAvailable;
+  }
+  get isCharging() {
+    return this.state.controllers[this.controllerIndex].isCharging;
+  }
+}
+
+class V5SmartDevice {
+  state;
+  deviceIndex;
+  constructor(state, index) {
+    this.state = state;
+    this.deviceIndex = index;
+  }
+  getDeviceInfo() {
+    return this.state.devices[this.deviceIndex];
+  }
+  get isAvailable() {
+    return this.getDeviceInfo() !== undefined;
+  }
+  get port() {
+    return this.deviceIndex;
+  }
+  get type() {
+    return this.getDeviceInfo()?.type ?? 0 /* EMPTY */;
+  }
+  get version() {
+    return this.getDeviceInfo()?.version ?? 0;
+  }
+}
+
+class V5Radio {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  get channel() {
+    return this.state.radio.channel;
+  }
+  get isAvailable() {
+    return this.state.radio.isAvailable;
+  }
+  get isConnected() {
+    return this.state.radio.isConnected;
+  }
+  get isVexNet() {
+    return this.state.radio.isVexNet;
+  }
+  get isRadioData() {
+    return this.state.radio.isRadioData;
+  }
+  get latency() {
+    return this.state.radio.latency;
+  }
+  changeChannel(channel) {
+    return new import_neverthrow4.ResultAsync((async () => {
+      const conn = this.state._instance.connection;
+      if (conn == null || !conn.isConnected) {
+        return import_neverthrow4.err(new VexNotConnectedError);
+      }
+      return conn.request(new FileControlH2DPacket(1, channel), FileControlReplyD2HPacket).map(() => {
+        return;
+      });
+    })());
+  }
+}
+
+// src/VexDevice.ts
+var import_neverthrow5 = __toESM(require_index_cjs(), 1);
+function unrefTimerIfPossible(timer) {
+  if (typeof timer !== "object" || timer === null || !("unref" in timer))
+    return;
+  const unref = timer.unref;
+  if (typeof unref === "function")
+    unref.call(timer);
+}
+
+class V5SerialDevice extends VexSerialDevice {
+  autoReconnect = true;
+  pauseRefreshOnFileTransfer = true;
+  _isReconnecting = false;
+  _isDisconnecting = false;
+  _refreshInterval;
+  state = new V5SerialDeviceState(this);
+  _disposed = false;
+  _refreshGeneration = 0;
+  _autoRefresh = false;
+  _isLastRefreshComplete = true;
+  _brain = new V5Brain(this.state);
+  _controllers = [
+    new V5Controller(this.state, 0),
+    new V5Controller(this.state, 1)
+  ];
+  _radio = new V5Radio(this.state);
+  _deviceFacades = [];
+  constructor(defaultSerial, autoRefresh = false) {
+    super(defaultSerial);
+    this.autoRefresh = autoRefresh;
+  }
+  get autoRefresh() {
+    return this._autoRefresh;
+  }
+  set autoRefresh(value) {
+    if (this._autoRefresh === value)
+      return;
+    this._autoRefresh = value;
+    if (value) {
+      this._startRefreshInterval();
+    } else {
+      this._stopRefreshInterval();
+    }
+  }
+  _startRefreshInterval() {
+    if (this._refreshInterval !== undefined || this._disposed)
+      return;
+    this._refreshInterval = setInterval(() => {
+      if (this._disposed)
+        return;
+      if (this._autoRefresh && this._isLastRefreshComplete) {
+        if (!this.isConnected) {
+          this.state.brain.isAvailable = false;
+          return;
+        }
+        if (!this.pauseRefreshOnFileTransfer || !this.state.isRefreshPaused) {
+          this._isLastRefreshComplete = false;
+          (async () => {
+            try {
+              const r = await this.refresh();
+              if (r.isErr())
+                this.emit("error", r.error);
+            } catch (error) {
+              this.emit("error", error);
+            } finally {
+              this._isLastRefreshComplete = true;
+            }
+          })();
+        }
+      }
+    }, 200);
+    unrefTimerIfPossible(this._refreshInterval);
+  }
+  _stopRefreshInterval() {
+    if (this._refreshInterval === undefined)
+      return;
+    clearInterval(this._refreshInterval);
+    this._refreshInterval = undefined;
+  }
+  get isV5Controller() {
+    return this.deviceType === 1283 /* V5_CONTROLLER */;
+  }
+  get brain() {
+    return this._brain;
+  }
+  get controllers() {
+    return this._controllers;
+  }
+  get devices() {
+    const rtn = [];
+    for (let i = 1;i < this.state.devices.length; i++) {
+      if (this.state.devices[i] != null) {
+        const facade = this._deviceFacades[i] ?? new V5SmartDevice(this.state, i);
+        this._deviceFacades[i] = facade;
+        rtn.push(facade);
+      }
+    }
+    return rtn;
+  }
+  get isFieldControllerConnected() {
+    return this.state.isFieldControllerConnected;
+  }
+  get matchMode() {
+    return this.state.matchMode;
+  }
+  set matchMode(value) {
+    this.setMatchMode(value).mapErr(() => {});
+  }
+  setMatchMode(mode) {
+    return new import_neverthrow5.ResultAsync((async () => {
+      const reply = await this.connection?.setMatchMode(mode);
+      if (reply === undefined)
+        return import_neverthrow5.err(new VexNotConnectedError);
+      if (reply.isErr())
+        return import_neverthrow5.err(reply.error);
+      this.state.matchMode = mode;
+      return import_neverthrow5.ok(undefined);
+    })());
+  }
+  get radio() {
+    return this._radio;
+  }
+  mockTouch(x, y, press) {
+    return new import_neverthrow5.ResultAsync((async () => {
+      const reply = await this.connection?.mockTouch(x, y, press);
+      if (reply === undefined)
+        return import_neverthrow5.err(new VexNotConnectedError);
+      if (reply.isErr())
+        return import_neverthrow5.err(reply.error);
+      return import_neverthrow5.ok(undefined);
+    })());
+  }
+  connect(conn) {
+    return new import_neverthrow5.ResultAsync(this._connect(conn));
+  }
+  async _connect(conn) {
+    if (this.isConnected)
+      return import_neverthrow5.ok(undefined);
+    if (conn != null) {
+      if (!conn.isConnected) {
+        const opened = await conn.open();
+        if (opened.isErr() || opened.value !== "opened") {
+          return import_neverthrow5.err(new VexIoError("failed to open the supplied connection"));
+        }
+      }
+      const q = await conn.query1();
+      if (q.isErr()) {
+        await conn.close();
+        return import_neverthrow5.err(q.error);
+      }
+      this.connection = conn;
+    } else {
+      let tryIdx = 0;
+      while (true) {
+        const c = new V5SerialConnection(this.defaultSerial);
+        const result = await c.open(tryIdx++, true);
+        if (result.isErr()) {
+          await c.close();
+          return import_neverthrow5.err(result.error);
+        }
+        if (result.value === "no-port") {
+          return import_neverthrow5.err(new VexNotConnectedError("no V5 device was found"));
+        }
+        if (result.value === "busy") {
+          await c.close();
+          continue;
+        }
+        const q = await c.query1();
+        if (q.isErr()) {
+          await c.close();
+          continue;
+        }
+        this.connection = c;
+        break;
+      }
+    }
+    if (!this.isConnected)
+      return import_neverthrow5.err(new VexNotConnectedError);
+    await this.doAfterConnect();
+    return import_neverthrow5.ok(undefined);
+  }
+  async disconnect() {
+    this._isDisconnecting = true;
+    const connection = this.connection;
+    this.connection = undefined;
+    try {
+      await connection?.close();
+    } finally {
+      this._isDisconnecting = false;
+    }
+  }
+  async dispose() {
+    this.autoReconnect = false;
+    this.autoRefresh = false;
+    this._disposed = true;
+    await this.disconnect();
+  }
+  reconnect(timeout = 0) {
+    return new import_neverthrow5.ResultAsync(this._reconnect(timeout));
+  }
+  async _reconnect(timeout) {
+    if (this.isConnected)
+      return import_neverthrow5.ok(undefined);
+    if (timeout < 0) {
+      return import_neverthrow5.err(new VexInvalidArgumentError("timeout must be non-negative"));
+    }
+    const endTime = Date.now() + timeout;
+    if (this._isReconnecting) {
+      if (timeout === 0) {
+        await this.waitForReconnectToFinish();
+      } else {
+        const waited = await sleepUntil(() => !this._isReconnecting, timeout);
+        if (waited.isErr() || !waited.value) {
+          return import_neverthrow5.err(new VexNotConnectedError);
+        }
+      }
+      if (this.isConnected)
+        return import_neverthrow5.ok(undefined);
+    }
+    this._isReconnecting = true;
+    try {
+      while (timeout === 0 || Date.now() < endTime) {
+        let tryIdx = 0;
+        while (true) {
+          const c = new V5SerialConnection(this.defaultSerial);
+          const result = await c.open(tryIdx++, false);
+          if (result.isErr()) {
+            await c.close();
+            return import_neverthrow5.err(result.error);
+          }
+          if (result.value === "no-port")
+            break;
+          if (result.value === "busy") {
+            await c.close();
+            continue;
+          }
+          const status = await c.getSystemStatus(200);
+          if (status.isErr()) {
+            await c.close();
+            continue;
+          }
+          if (this.brain.uniqueId !== 0 && status.value.uniqueId !== this.brain.uniqueId) {
+            await c.close();
+            continue;
+          }
+          this.connection = c;
+          break;
+        }
+        if (this.isConnected)
+          break;
+        const getPortCount = async () => (await this.defaultSerial.getPorts()).length;
+        const portsCount = await getPortCount();
+        await sleepUntilAsync(async () => await getPortCount() !== portsCount, 1000);
+      }
+    } catch (e) {
+      return import_neverthrow5.err(toVexSerialError(e));
+    } finally {
+      this._isReconnecting = false;
+    }
+    if (!this.isConnected)
+      return import_neverthrow5.err(new VexNotConnectedError);
+    await this.doAfterConnect();
+    return import_neverthrow5.ok(undefined);
+  }
+  async waitForReconnectToFinish() {
+    while (this._isReconnecting) {
+      const r = await sleepUntil(() => !this._isReconnecting, 1000);
+      if (r.isOk() && r.value)
+        return;
+    }
+  }
+  async doAfterConnect() {
+    if (this.connection == null)
+      return;
+    this.connection.on("disconnected", (_data) => {
+      if (this._isDisconnecting)
+        return;
+      this.emit("disconnected", undefined);
+      if (this.autoReconnect) {
+        this.reconnect().mapErr((e) => this.emit("error", e));
+      }
+    });
+    await this.refresh();
+  }
+  refresh() {
+    return new import_neverthrow5.ResultAsync(this._refresh());
+  }
+  async _refresh() {
+    if (this._disposed)
+      return import_neverthrow5.ok(false);
+    const generation = ++this._refreshGeneration;
+    const conn = this.connection;
+    if (conn == null || !conn.isConnected) {
+      this._applySnapshotIfCurrent(generation, { isAvailable: false });
+      return import_neverthrow5.ok(false);
+    }
+    const ssPacket = await conn.getSystemStatus();
+    if (generation !== this._refreshGeneration || this._disposed)
+      return import_neverthrow5.ok(false);
+    if (ssPacket.isErr()) {
+      this._applySnapshotIfCurrent(generation, { isAvailable: false });
+      return import_neverthrow5.ok(false);
+    }
+    const sfPacket = await conn.getSystemFlags();
+    if (generation !== this._refreshGeneration || this._disposed)
+      return import_neverthrow5.ok(false);
+    if (sfPacket.isErr()) {
+      this._applySnapshotIfCurrent(generation, { isAvailable: false });
+      return import_neverthrow5.ok(false);
+    }
+    const rdPacket = await conn.getRadioStatus();
+    if (generation !== this._refreshGeneration || this._disposed)
+      return import_neverthrow5.ok(false);
+    if (rdPacket.isErr()) {
+      this._applySnapshotIfCurrent(generation, { isAvailable: false });
+      return import_neverthrow5.ok(false);
+    }
+    const dsPacket = await conn.getDeviceStatus();
+    if (generation !== this._refreshGeneration || this._disposed)
+      return import_neverthrow5.ok(false);
+    if (dsPacket.isErr()) {
+      this._applySnapshotIfCurrent(generation, { isAvailable: false });
+      return import_neverthrow5.ok(false);
+    }
+    const snapshot = this._buildSnapshot(ssPacket.value, sfPacket.value, rdPacket.value, dsPacket.value);
+    return import_neverthrow5.ok(this._applySnapshotIfCurrent(generation, snapshot));
+  }
+  _buildSnapshot(ssPacket, sfPacket, rdPacket, dsPacket) {
+    const flags2 = ssPacket.sysflags[2];
+    const matchMode = (flags2 & 32) !== 0 ? "disabled" : (flags2 & 64) !== 0 ? "autonomous" : "driver";
+    const isFieldControllerConnected = (flags2 & 16) !== 0;
+    const flags4 = ssPacket.sysflags[4];
+    const usingLanguage = (flags4 & 240) >> 4;
+    const isWhiteTheme = (flags4 & 4) !== 0;
+    const isScreenReversed = (flags4 & 1) === 0;
+    const flags5 = sfPacket.flags;
+    const hasFlag = (bit) => (flags5 & 2 ** (32 - bit)) !== 0;
+    const isRadioData = hasFlag(12);
+    const isDoublePressed = hasFlag(14);
+    const isCharging = hasFlag(15);
+    const isPressed = hasFlag(17);
+    const isVexNet = hasFlag(18);
+    const controller1Available = hasFlag(19);
+    const radioConnected = hasFlag(22);
+    const radioAvailable = hasFlag(23);
+    const batteryPercent = sfPacket.battery ?? 0;
+    const controller0Available = radioConnected || sfPacket.controllerBatteryPercent !== undefined;
+    const controller0Battery = sfPacket.controllerBatteryPercent ?? 0;
+    const controller1Battery = sfPacket.partnerControllerBatteryPercent ?? 0;
+    const activeProgram = sfPacket.currentProgram;
+    const isAvailable = !this.isV5Controller || radioConnected;
+    const devices = dsPacket.devices.map((d) => ({ ...d }));
+    return {
+      isAvailable: true,
+      matchMode,
+      isFieldControllerConnected,
+      brain: {
+        ...this.state.brain,
+        activeProgram,
+        battery: { batteryPercent, isCharging },
+        button: { isPressed, isDoublePressed },
+        cpu0Version: ssPacket.cpu0Version,
+        cpu1Version: ssPacket.cpu1Version,
+        isAvailable,
+        settings: { isScreenReversed, isWhiteTheme, usingLanguage },
+        systemVersion: ssPacket.systemVersion,
+        uniqueId: ssPacket.uniqueId
+      },
+      controllers: [
+        {
+          battery: controller0Battery,
+          isAvailable: controller0Available,
+          isCharging: (flags2 & 128) !== 0
+        },
+        {
+          battery: controller1Battery,
+          isAvailable: controller1Available,
+          isCharging: (flags2 & 128) !== 0
+        }
+      ],
+      radio: {
+        channel: rdPacket.channel,
+        latency: rdPacket.timeslot,
+        signalQuality: rdPacket.quality,
+        signalStrength: rdPacket.strength,
+        isRadioData,
+        isVexNet,
+        isConnected: radioConnected,
+        isAvailable: radioAvailable
+      },
+      devices
+    };
+  }
+  _applySnapshotIfCurrent(generation, snapshot) {
+    if (this._disposed)
+      return false;
+    if (generation !== this._refreshGeneration)
+      return false;
+    if (snapshot.isAvailable === false) {
+      this.state.brain.isAvailable = false;
+      return false;
+    }
+    this.state.matchMode = snapshot.matchMode;
+    this.state.isFieldControllerConnected = snapshot.isFieldControllerConnected;
+    Object.assign(this.state.brain, snapshot.brain);
+    Object.assign(this.state.controllers[0], snapshot.controllers[0]);
+    Object.assign(this.state.controllers[1], snapshot.controllers[1]);
+    Object.assign(this.state.radio, snapshot.radio);
+    const next = [];
+    for (const device of snapshot.devices) {
+      if (device != null)
+        next[device.port] = device;
+    }
+    this.state.devices = next;
+    return true;
+  }
+}
+// src/VexIniConfig.ts
+class BaseIniBuilder {
+  str = "";
+  addLine(line) {
+    this.str += line + `
+`;
+  }
+  addComment(comment) {
+    this.addLine("; " + comment);
+    return this;
+  }
+  getContent() {
+    return this.str;
+  }
+}
+
+class IniSectionBuilder extends BaseIniBuilder {
+  name;
+  object;
+  keyTransform;
+  constructor(name, object, keyTransform = (k) => k.toString()) {
+    super();
+    this.name = name;
+    this.object = object;
+    this.keyTransform = keyTransform;
+  }
+  addSingleObjProperty(key, maxValueLength) {
+    const value = this.object[key];
+    if (value == null || value.toString().length === 0)
+      return;
+    const formattedKey = this.keyTransform(key).padEnd(12).slice(0, 12);
+    const trimmedVal = value.toString().slice(0, maxValueLength);
+    const escapedVal = trimmedVal.replace(/["\\\u0000-\u001f\u007f]/g, (character) => `\\x${character.charCodeAt(0).toString(16).padStart(2, "0")}`);
+    this.addLine(`${formattedKey} = "${escapedVal}"`);
+  }
+  addObjProperty(key, maxValueLength) {
+    for (const k of Array.isArray(key) ? key : [key]) {
+      this.addSingleObjProperty(k, maxValueLength);
+    }
+    return this;
+  }
+  addAllObjProps(maxValueLength) {
+    for (const k of Object.keys(this.object)) {
+      this.addSingleObjProperty(k, maxValueLength);
+    }
+    return this;
+  }
+}
+
+class IniFileBuilder extends BaseIniBuilder {
+  addSection(section) {
+    this.addLine(`[${section.name}]`);
+    this.str += section.getContent();
+    return this;
+  }
+}
+
+class ProgramIniConfig {
+  baseName = "slot_1";
+  autorun = false;
+  project = { version: "1", ide: "Unknown", file: "none" };
+  program = {
+    version: "1",
+    name: "program",
+    slot: 0,
+    icon: "default.bmp",
+    iconalt: "",
+    description: "",
+    date: "",
+    timezone: "0"
+  };
+  config = { 22: "adi" };
+  controller1 = {};
+  controller2 = {};
+  setProgramDate(date) {
+    this.program.date = date.toISOString();
+    const offset = Math.abs(date.getTimezoneOffset());
+    const hours = offset / 60 >>> 0;
+    const minutes = offset - hours * 60;
+    this.program.timezone = (date.getTimezoneOffset() > 0 ? "-" : "+") + this.dec2(hours) + ":" + this.dec2(minutes);
+  }
+  createIni() {
+    if (this.program.date.length === 0) {
+      this.setProgramDate(new Date);
+    }
+    return new IniFileBuilder().addComment("").addComment("VEX program ini file").addComment("Generated by Vex V5 Serial Protocol Library").addComment("").addSection(new IniSectionBuilder("project", this.project).addObjProperty("ide", 16)).addComment("").addSection(new IniSectionBuilder("program", this.program).addObjProperty("name", 32).addObjProperty("description", 256).addObjProperty("icon", 16).addObjProperty("iconalt", 16).addObjProperty("slot", 16)).addComment("").addSection(new IniSectionBuilder("config", this.config, (k) => "port_" + this.dec2(k)).addAllObjProps()).addComment("").addSection(new IniSectionBuilder("controller_1", this.controller1).addAllObjProps()).addComment("").addSection(new IniSectionBuilder("controller_2", this.controller2).addAllObjProps()).getContent();
+  }
+  dec2(value) {
+    return (value % 100).toString(10).padStart(2, "0").toUpperCase();
+  }
+}
+
+//# debugId=6C653363AF816C0D64756E2164756E21
+//# sourceMappingURL=index.cjs.map