@v5x/serial 0.5.5 → 0.5.7

package/dist/index.js

@@ -1,17 +1,3 @@
-var __defProp = Object.defineProperty;
-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)
-    });
-};
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -105,6 +91,7 @@ var AckType;
   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";
+  AckType2[AckType2["NOT_CONNECTED"] = 258] = "NOT_CONNECTED";
 })(AckType ||= {});
 var SmartDeviceType;
 ((SmartDeviceType2) => {
@@ -200,6 +187,7 @@ var SelectDashScreen;
 // src/VexError.ts
 class VexSerialError extends Error {
   kind;
+  ackType = undefined;
   constructor(kind, message) {
     super(message);
     this.name = "VexSerialError";
@@ -222,9 +210,11 @@ class VexInvalidArgumentError extends VexSerialError {
 }
 
 class VexProtocolError extends VexSerialError {
-  constructor(message) {
+  ackType;
+  constructor(message, ackType) {
     super("protocol", message);
     this.name = "VexProtocolError";
+    this.ackType = ackType;
   }
 }
 
@@ -284,9 +274,26 @@ class VexEventEmitter {
     this.handlerMap.set(eventName, listeners);
   }
   emit(eventName, data) {
-    (this.handlerMap.get(eventName) ?? []).forEach((callback) => {
-      callback(data);
-    });
+    const listeners = this.handlerMap.get(eventName);
+    if (listeners === undefined || listeners.length === 0)
+      return;
+    if (listeners.length === 1) {
+      listeners[0](data);
+      return;
+    }
+    const errors = [];
+    for (const callback of [...listeners]) {
+      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();
@@ -299,469 +306,21 @@ class VexEventTarget {
     this.emitter = new VexEventEmitter;
   }
   emit(eventName, data) {
-    this.emitter.emit(String(eventName), data);
+    this.emitter.emit(eventName, data);
   }
   on(eventName, listener) {
-    this.emitter.on(String(eventName), listener);
+    this.emitter.on(eventName, listener);
   }
   remove(eventName, listener) {
-    this.emitter.remove(String(eventName), listener);
+    this.emitter.remove(eventName, listener);
   }
   clearListeners() {
     this.emitter.clearListeners();
   }
 }
 
-// ../../node_modules/.bun/neverthrow@8.2.0/node_modules/neverthrow/dist/index.es.js
-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(ok, _err) {
-    return this._promise.then((res) => res.match(ok, _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 errAsync(err) {
-  return new ResultAsync(Promise.resolve(new Err(err)));
-}
-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);
-var Result;
-(function(Result2) {
-  function fromThrowable(fn, errorFn) {
-    return (...args) => {
-      try {
-        const result = fn(...args);
-        return ok(result);
-      } catch (e) {
-        return err(errorFn ? errorFn(e) : e);
-      }
-    };
-  }
-  Result2.fromThrowable = fromThrowable;
-  function combine(resultList) {
-    return combineResultList(resultList);
-  }
-  Result2.combine = combine;
-  function combineWithAllErrors(resultList) {
-    return combineResultListWithAllErrors(resultList);
-  }
-  Result2.combineWithAllErrors = combineWithAllErrors;
-})(Result || (Result = {}));
-function ok(value) {
-  return new Ok(value);
-}
-function err(err2) {
-  return new Err(err2);
-}
-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 = Result.fromThrowable;
+// src/VexConnection.ts
+import { err, ok, ResultAsync } from "neverthrow";
 
 // src/VexPacketBase.ts
 var MATCH_STATUS_ALT_ACK = 167;
@@ -775,42 +334,32 @@ class Packet {
 }
 
 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;
   }
-  static COMMAND_ID;
-  static COMMAND_EXTENDED_ID;
   constructor(payload) {
-    super(new Uint8Array);
-    const me = this.constructor;
-    if (me.COMMAND_EXTENDED_ID === undefined) {
-      if (payload === undefined) {
-        this.data = Packet.ENCODER.cdcCommand(me.COMMAND_ID);
-      } else {
-        this.data = Packet.ENCODER.cdcCommandWithData(me.COMMAND_ID, payload);
-      }
-    } else {
-      if (payload === undefined) {
-        this.data = Packet.ENCODER.cdc2Command(me.COMMAND_ID, me.COMMAND_EXTENDED_ID);
-      } else {
-        this.data = Packet.ENCODER.cdc2CommandWithData(me.COMMAND_ID, me.COMMAND_EXTENDED_ID, 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 {
-  ack = 255 /* CDC2_NACK */;
+  static COMMAND_ID;
+  static COMMAND_EXTENDED_ID;
+  ack;
   payloadSize;
   ackIndex;
   constructor(data) {
     super(data);
     this.payloadSize = Packet.ENCODER.getPayloadSize(this.data);
-    const n = Packet.ENCODER.getHostHeaderLength(this.data);
-    this.ack = this.data[this.ackIndex = n + 1];
+    this.ackIndex = Packet.ENCODER.getHostHeaderLength(this.data) + 1;
+    this.ack = this.data[this.ackIndex];
   }
   static isValidPacket(data, n) {
     const ack = data[n + 1];
@@ -819,385 +368,162 @@ class HostBoundPacket extends Packet {
 }
 
 // src/VexCRC.ts
-var CRC16TABLE = [
-  0,
-  4129,
-  8258,
-  12387,
-  16516,
-  20645,
-  24774,
-  28903,
-  33032,
-  37161,
-  41290,
-  45419,
-  49548,
-  53677,
-  57806,
-  61935,
-  4657,
-  528,
-  12915,
-  8786,
-  21173,
-  17044,
-  29431,
-  25302,
-  37689,
-  33560,
-  45947,
-  41818,
-  54205,
-  50076,
-  62463,
-  58334,
-  9314,
-  13379,
-  1056,
-  5121,
-  25830,
-  29895,
-  17572,
-  21637,
-  42346,
-  46411,
-  34088,
-  38153,
-  58862,
-  62927,
-  50604,
-  54669,
-  13907,
-  9842,
-  5649,
-  1584,
-  30423,
-  26358,
-  22165,
-  18100,
-  46939,
-  42874,
-  38681,
-  34616,
-  63455,
-  59390,
-  55197,
-  51132,
-  18628,
-  22757,
-  26758,
-  30887,
-  2112,
-  6241,
-  10242,
-  14371,
-  51660,
-  55789,
-  59790,
-  63919,
-  35144,
-  39273,
-  43274,
-  47403,
-  23285,
-  19156,
-  31415,
-  27286,
-  6769,
-  2640,
-  14899,
-  10770,
-  56317,
-  52188,
-  64447,
-  60318,
-  39801,
-  35672,
-  47931,
-  43802,
-  27814,
-  31879,
-  19684,
-  23749,
-  11298,
-  15363,
-  3168,
-  7233,
-  60846,
-  64911,
-  52716,
-  56781,
-  44330,
-  48395,
-  36200,
-  40265,
-  32407,
-  28342,
-  24277,
-  20212,
-  15891,
-  11826,
-  7761,
-  3696,
-  65439,
-  61374,
-  57309,
-  53244,
-  48923,
-  44858,
-  40793,
-  36728,
-  37256,
-  33193,
-  45514,
-  41451,
-  53516,
-  49453,
-  61774,
-  57711,
-  4224,
-  161,
-  12482,
-  8419,
-  20484,
-  16421,
-  28742,
-  24679,
-  33721,
-  37784,
-  41979,
-  46042,
-  49981,
-  54044,
-  58239,
-  62302,
-  689,
-  4752,
-  8947,
-  13010,
-  16949,
-  21012,
-  25207,
-  29270,
-  46570,
-  42443,
-  38312,
-  34185,
-  62830,
-  58703,
-  54572,
-  50445,
-  13538,
-  9411,
-  5280,
-  1153,
-  29798,
-  25671,
-  21540,
-  17413,
-  42971,
-  47098,
-  34713,
-  38840,
-  59231,
-  63358,
-  50973,
-  55100,
-  9939,
-  14066,
-  1681,
-  5808,
-  26199,
-  30326,
-  17941,
-  22068,
-  55628,
-  51565,
-  63758,
-  59695,
-  39368,
-  35305,
-  47498,
-  43435,
-  22596,
-  18533,
-  30726,
-  26663,
-  6336,
-  2273,
-  14466,
-  10403,
-  52093,
-  56156,
-  60223,
-  64286,
-  35833,
-  39896,
-  43963,
-  48026,
-  19061,
-  23124,
-  27191,
-  31254,
-  2801,
-  6864,
-  10931,
-  14994,
-  64814,
-  60687,
-  56684,
-  52557,
-  48554,
-  44427,
-  40424,
-  36297,
-  31782,
-  27655,
-  23652,
-  19525,
-  15522,
-  11395,
-  7392,
-  3265,
-  61215,
-  65342,
-  53085,
-  57212,
-  44955,
-  49082,
-  36825,
-  40952,
-  28183,
-  32310,
-  20053,
-  24180,
-  11923,
-  16050,
-  3793,
-  7920
-];
+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;
-  static POLYNOMIAL_CRC32 = 79764919;
-  static POLYNOMIAL_CRC16 = 4129;
-  constructor() {
-    this.crc32Table = new Uint32Array(256);
-    this.crc32GenTable();
-  }
+  crc32Table = CRC32_TABLE;
+  static POLYNOMIAL_CRC32 = POLYNOMIAL_CRC32;
+  static POLYNOMIAL_CRC16 = POLYNOMIAL_CRC16;
   crc16(buf, initValue) {
-    const numberOfBytes = buf.byteLength;
-    let accumulator = initValue;
-    let i;
-    let j;
-    for (j = 0;j < numberOfBytes; j++) {
-      i = (accumulator >>> 8 ^ buf[j]) & 255;
-      accumulator = (accumulator << 8 ^ CRC16TABLE[i]) >>> 0;
-    }
-    return (accumulator & 65535) >>> 0;
-  }
-  crc32GenTable() {
-    let i;
-    let j;
-    let crcAccumulator;
-    for (i = 0;i < 256; i++) {
-      crcAccumulator = i << 24;
-      for (j = 0;j < 8; j++) {
-        if ((crcAccumulator & 2147483648) !== 0)
-          crcAccumulator = crcAccumulator << 1 ^ CrcGenerator.POLYNOMIAL_CRC32;
-        else
-          crcAccumulator = crcAccumulator << 1;
-      }
-      this.crc32Table[i] = crcAccumulator;
+    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) {
-    const numberOfBytes = buf.byteLength;
-    let crcAccumulator = initValue;
-    let i;
-    let j;
-    for (j = 0;j < numberOfBytes; j++) {
-      i = (crcAccumulator >>> 24 ^ buf[j]) & 255;
-      crcAccumulator = (crcAccumulator << 8 ^ this.crc32Table[i]) >>> 0;
+    let acc = initValue;
+    for (let j = 0;j < buf.length; j++) {
+      acc = (acc << 8 ^ CRC32_TABLE[(acc >>> 24 ^ buf[j]) & 255]) >>> 0;
     }
-    return (crcAccumulator & 4294967295) >>> 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/VexPacketEncoder.ts
+var textEncoder = new TextEncoder;
+var HEADER_TO_DEVICE = Uint8Array.of(201, 54, 184, 71);
+function encodeFixedText(value, field, maxBytes) {
+  const encoded = textEncoder.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() {}
+  registerPacketTypes(types) {
+    for (const type of types) {
+      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/VexFirmwareVersion.ts
 class VexFirmwareVersion {
@@ -1213,9 +539,8 @@ class VexFirmwareVersion {
   }
   static fromString(version) {
     const parts = version.toLowerCase().replace(/b/g, "").split(".").map((x) => parseInt(x, 10));
-    while (parts.length < 4) {
+    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) {
@@ -1245,24 +570,23 @@ class VexFirmwareVersion {
     return `${this.toUserString()}.b${this.beta}`;
   }
   compare(that) {
-    const majorComp = this.major - that.major;
-    const minorComp = this.minor - that.minor;
-    const buildComp = this.build - that.build;
-    const betaComp = this.beta - that.beta;
-    if (majorComp !== 0) {
-      return majorComp;
-    } else if (minorComp !== 0) {
-      return minorComp;
-    } else if (buildComp !== 0) {
-      return buildComp;
-    } else if (betaComp !== 0) {
-      return betaComp;
+    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;
@@ -1270,19 +594,15 @@ class PacketView extends DataView {
     super(buffer, offset, length);
   }
   static fromPacket(packet) {
-    const view = new PacketView(packet.data.buffer, packet.data.byteOffset);
+    const view = new PacketView(packet.data.buffer, packet.data.byteOffset, packet.data.byteLength);
     view.position = packet.ackIndex + 1;
     return view;
   }
   nextInt8() {
-    const result = this.getInt8(this.position);
-    this.position += 1;
-    return result;
+    return this.getInt8(this.position++);
   }
   nextUint8() {
-    const result = this.getUint8(this.position);
-    this.position += 1;
-    return result;
+    return this.getUint8(this.position++);
   }
   nextInt16(littleEndian = this.littleEndianDefault) {
     const result = this.getInt16(this.position, littleEndian);
@@ -1305,37 +625,28 @@ class PacketView extends DataView {
     return result;
   }
   nextString(length) {
-    let result = "";
-    for (let i = 0;i < length; i++) {
-      result += String.fromCharCode(this.nextUint8());
-    }
+    const result = textDecoder.decode(new Uint8Array(this.buffer, this.byteOffset + this.position, length));
+    this.position += length;
     return result;
   }
   nextNTBS(length) {
-    let result = "";
-    const lastPosition = this.position;
-    for (let i = 0;i < length; i++) {
-      if (this.byteLength <= this.position)
-        break;
-      const g = this.nextUint8();
-      if (g === 0)
-        break;
-      result += String.fromCharCode(g);
-    }
-    this.position = lastPosition + length;
+    const start = this.position;
+    const result = this.nextVarNTBS(length);
+    this.position = start + length;
     return result;
   }
   nextVarNTBS(length) {
-    let result = "";
+    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;
-      result += String.fromCharCode(g);
+      byteLength++;
     }
-    return result;
+    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);
@@ -1345,43 +656,34 @@ class PacketView extends DataView {
 }
 
 // src/VexPacketModels.ts
-var textEncoder = new TextEncoder;
+var textEncoder2 = new TextEncoder;
+function filePayload(a, b, fileName) {
+  const payload = new Uint8Array(26);
+  payload[0] = a;
+  payload[1] = b;
+  payload.set(encodeFixedText(fileName, "Filename", 24), 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;
-  constructor() {
-    super(undefined);
-  }
 }
 
 class SystemVersionH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 164;
   static COMMAND_EXTENDED_ID = undefined;
-  constructor() {
-    super(undefined);
-  }
 }
 
 class UpdateMatchModeH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 88;
   static COMMAND_EXTENDED_ID = 193;
   constructor(mode, matchClock) {
-    let bit1;
-    switch (mode) {
-      case "autonomous":
-        bit1 = 10;
-        break;
-      case "driver":
-        bit1 = 8;
-        break;
-      case "disabled":
-        bit1 = 11;
-    }
+    const bit1 = mode === "autonomous" ? 10 : mode === "driver" ? 8 : 11;
     const payload = new Uint8Array(5);
-    const view = new DataView(payload.buffer);
-    payload[0] = (15 & bit1) >>> 0;
-    view.setUint32(1, matchClock, true);
+    payload[0] = bit1 & 15;
+    new DataView(payload.buffer).setUint32(1, matchClock, true);
     super(payload);
   }
 }
@@ -1389,18 +691,13 @@ class UpdateMatchModeH2DPacket extends DeviceBoundPacket {
 class GetMatchStatusH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 88;
   static COMMAND_EXTENDED_ID = 194;
-  constructor() {
-    super(undefined);
-  }
 }
 
 class GetRadioModeH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 88;
   static COMMAND_EXTENDED_ID = 65;
   constructor(mode) {
-    const payload = new Uint8Array(1);
-    payload[0] = mode;
-    super(payload);
+    super(Uint8Array.of(mode));
   }
 }
 
@@ -1408,9 +705,7 @@ class FileControlH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 16;
   constructor(a, b) {
-    const payload = new Uint8Array(2);
-    payload.set([a, b], 0);
-    super(payload);
+    super(Uint8Array.of(a, b));
   }
 }
 
@@ -1420,25 +715,21 @@ class InitFileTransferH2DPacket extends DeviceBoundPacket {
   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);
-    view.setUint8(0, operation);
-    view.setUint8(1, target);
-    view.setUint8(2, vendor);
-    view.setUint8(3, options);
+    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);
-    const re = /(?:\.([^.]+))?$/;
-    const reResult = re.exec(name);
-    let ext = reResult != null ? reResult[1] : undefined;
-    ext ??= "";
-    ext = ext === "gz" ? "bin" : ext;
+    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);
-    const nameEncoded = encodeFixedText(name, "Filename", 23);
-    payload.set(nameEncoded, 28);
-    view.setUint8(51, 0);
+    payload.set(encodeFixedText(name, "Filename", 24), 28);
     super(payload);
   }
 }
@@ -1447,9 +738,7 @@ class ExitFileTransferH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 18;
   constructor(action) {
-    const payload = new Uint8Array(1);
-    payload[0] = action;
-    super(payload);
+    super(Uint8Array.of(action));
   }
 }
 
@@ -1458,8 +747,7 @@ class WriteFileH2DPacket extends DeviceBoundPacket {
   static COMMAND_EXTENDED_ID = 19;
   constructor(addr, buf) {
     const payload = new Uint8Array(4 + buf.length);
-    const view = new DataView(payload.buffer);
-    view.setUint32(0, addr, true);
+    new DataView(payload.buffer).setUint32(0, addr, true);
     payload.set(buf, 4);
     super(payload);
   }
@@ -1481,11 +769,7 @@ class LinkFileH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 21;
   constructor(vendor, fileName, options) {
-    const str = encodeFixedText(fileName, "Filename", 23);
-    const payload = new Uint8Array(26);
-    payload.set([vendor, options], 0);
-    payload.set(str, 2);
-    super(payload);
+    super(filePayload(vendor, options, fileName));
   }
 }
 
@@ -1493,9 +777,7 @@ class GetDirectoryFileCountH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 22;
   constructor(vendor) {
-    const payload = new Uint8Array(2);
-    payload.set([vendor, 0], 0);
-    super(payload);
+    super(Uint8Array.of(vendor, 0));
   }
 }
 
@@ -1503,9 +785,7 @@ class GetDirectoryEntryH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 23;
   constructor(index) {
-    const payload = new Uint8Array(2);
-    payload.set([index, 0], 0);
-    super(payload);
+    super(Uint8Array.of(index, 0));
   }
 }
 
@@ -1513,17 +793,8 @@ class LoadFileActionH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 24;
   constructor(vendor, actionId, fileNameOrSlotNumber) {
-    let fileName;
-    if (typeof fileNameOrSlotNumber === "string") {
-      fileName = fileNameOrSlotNumber;
-    } else {
-      fileName = "___s_" + (fileNameOrSlotNumber - 1) + ".bin";
-    }
-    const encodedName = encodeFixedText(fileName, "Filename", 23);
-    const payload = new Uint8Array(26);
-    payload.set([vendor, actionId], 0);
-    payload.set(encodedName, 2);
-    super(payload);
+    const fileName = typeof fileNameOrSlotNumber === "string" ? fileNameOrSlotNumber : `___s_${fileNameOrSlotNumber - 1}.bin`;
+    super(filePayload(vendor, actionId, fileName));
   }
 }
 
@@ -1531,11 +802,7 @@ class GetFileMetadataH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 25;
   constructor(vendor, fileName, options) {
-    const encodedName = encodeFixedText(fileName, "Filename", 23);
-    const payload = new Uint8Array(26);
-    payload.set([vendor, options], 0);
-    payload.set(encodedName, 2);
-    super(payload);
+    super(filePayload(vendor, options, fileName));
   }
 }
 
@@ -1543,11 +810,7 @@ class EraseFileH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 27;
   constructor(vendor, fileName) {
-    const encodedName = encodeFixedText(fileName, "Filename", 23);
-    const payload = new Uint8Array(26);
-    payload.set([vendor, 128], 0);
-    payload.set(encodedName, 2);
-    super(payload);
+    super(filePayload(vendor, 128, fileName));
   }
 }
 
@@ -1555,11 +818,7 @@ class GetProgramSlotInfoH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 28;
   constructor(vendor, fileName) {
-    const encodedName = encodeFixedText(fileName, "Filename", 23);
-    const payload = new Uint8Array(26);
-    payload.set([vendor, 0], 0);
-    payload.set(encodedName, 2);
-    super(payload);
+    super(filePayload(vendor, 0, fileName));
   }
 }
 
@@ -1567,9 +826,7 @@ class FileClearUpH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 30;
   constructor(vendor) {
-    const payload = new Uint8Array(2);
-    payload.set([vendor, 0], 0);
-    super(payload);
+    super(Uint8Array.of(vendor, 0));
   }
 }
 
@@ -1577,9 +834,7 @@ class FileFormatH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 31;
   constructor() {
-    const payload = new Uint8Array(4);
-    payload.set([68, 67, 66, 65], 0);
-    super(payload);
+    super(Uint8Array.of(68, 67, 66, 65));
   }
 }
 
@@ -1591,33 +846,21 @@ class GetSystemFlagsH2DPacket extends DeviceBoundPacket {
 class GetDeviceStatusH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 33;
-  constructor() {
-    super(undefined);
-  }
 }
 
 class GetSystemStatusH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 34;
-  constructor() {
-    super(undefined);
-  }
 }
 
 class GetFdtStatusH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 35;
-  constructor() {
-    super(undefined);
-  }
 }
 
 class GetLogCountH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 36;
-  constructor() {
-    super(undefined);
-  }
 }
 
 class ReadLogPageH2DPacket extends DeviceBoundPacket {
@@ -1635,18 +878,13 @@ class ReadLogPageH2DPacket extends DeviceBoundPacket {
 class GetRadioStatusH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 38;
-  constructor() {
-    super(undefined);
-  }
 }
 
 class ScreenCaptureH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 40;
   constructor(e) {
-    const payload = new Uint8Array(1);
-    payload[0] = e;
-    super(payload);
+    super(Uint8Array.of(e));
   }
 }
 
@@ -1667,10 +905,7 @@ class SelectDashH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 43;
   constructor(screen, port) {
-    const payload = new Uint8Array(2);
-    payload[0] = screen;
-    payload[1] = port;
-    super(payload);
+    super(Uint8Array.of(screen, port));
   }
 }
 
@@ -1678,9 +913,8 @@ class ReadKeyValueH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 46;
   constructor(key) {
-    const encodedKey = encodeFixedText(key, "Key", 31);
     const payload = new Uint8Array(32);
-    payload.set(encodedKey, 0);
+    payload.set(encodeFixedText(key, "Key", 31), 0);
     super(payload);
   }
 }
@@ -1690,7 +924,7 @@ class WriteKeyValueH2DPacket extends DeviceBoundPacket {
   static COMMAND_EXTENDED_ID = 47;
   constructor(key, value) {
     const strk = encodeFixedText(key, "Key", 31);
-    const strv = textEncoder.encode(value);
+    const strv = textEncoder2.encode(value);
     if (strk.byteLength + strv.byteLength + 20 > 32767) {
       throw new RangeError("Key and value are too large for a protocol packet");
     }
@@ -1704,17 +938,11 @@ class WriteKeyValueH2DPacket extends DeviceBoundPacket {
 class GetSlot1to4InfoH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 49;
-  constructor() {
-    super(undefined);
-  }
 }
 
 class GetSlot5to8InfoH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 50;
-  constructor() {
-    super(undefined);
-  }
 }
 
 class FactoryStatusH2DPacket extends DeviceBoundPacket {
@@ -1726,9 +954,7 @@ class FactoryEnableH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 255;
   constructor() {
-    const payload = new Uint8Array(4);
-    payload.set([77, 76, 75, 74], 0);
-    super(payload);
+    super(Uint8Array.of(77, 76, 75, 74));
   }
 }
 
@@ -1770,8 +996,7 @@ class MatchModeReplyD2HPacket extends HostBoundPacket {
   modebit;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    this.modebit = dataView.nextUint8();
+    this.modebit = PacketView.fromPacket(this).nextUint8();
   }
 }
 
@@ -1797,31 +1022,27 @@ class MatchStatusReplyD2HPacket extends HostBoundPacket {
   rxSignalQuality;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
+    const view = PacketView.fromPacket(this);
     const n = this.ackIndex;
-    this.rssi = dataView.nextInt8();
-    this.systemStatusBits = dataView.nextUint16();
-    this.radioStatusBits = dataView.nextUint16();
-    this.fieldStatusBits = dataView.nextUint8();
-    this.matchClock = dataView.nextUint8();
-    this.brainBatteryPercent = dataView.nextUint8();
-    this.controllerBatteryPercent = dataView.nextUint8();
-    this.partnerControllerBatteryPercent = dataView.nextUint8();
-    this.pad = dataView.nextUint8();
-    this.buttons = dataView.nextUint16();
-    this.activeProgram = dataView.nextUint8();
-    this.radioType = dataView.nextUint8();
-    this.radioChannel = dataView.nextUint8();
-    this.radioSlot = dataView.nextUint8();
-    this.robotName = dataView.nextNTBS(10);
-    this.controllerFlags = dataView.getUint8(n + 28);
-    this.rxSignalQuality = dataView.getUint8(n + 29);
-    let rawStr = new TextDecoder("UTF-8").decode(data.slice(n + 18, n + this.payloadSize + 28));
-    const endIdx = rawStr.indexOf("\x00");
-    if (endIdx > -1) {
-      rawStr = rawStr.substr(0, endIdx);
-    }
-    this.robotName = rawStr;
+    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;
   }
 }
 
@@ -1838,10 +1059,10 @@ class InitFileTransferReplyD2HPacket extends HostBoundPacket {
   crc32;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    this.windowSize = dataView.nextUint16();
-    this.fileSize = dataView.nextUint32();
-    this.crc32 = dataView.nextUint32();
+    const view = PacketView.fromPacket(this);
+    this.windowSize = view.nextUint16();
+    this.fileSize = view.nextUint32();
+    this.crc32 = view.nextUint32();
   }
 }
 
@@ -1863,13 +1084,10 @@ class ReadFileReplyD2HPacket extends HostBoundPacket {
   buf;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    this.addr = dataView.nextUint32();
+    const view = PacketView.fromPacket(this);
+    this.addr = view.nextUint32();
     this.length = this.payloadSize - 8;
-    this.buf = this.data.slice(dataView.position, dataView.position + this.length).buffer;
-  }
-  static isValidPacket(data, n) {
-    return super.isValidPacket(data, n);
+    this.buf = this.data.subarray(view.position, view.position + this.length);
   }
 }
 
@@ -1884,8 +1102,7 @@ class GetDirectoryFileCountReplyD2HPacket extends HostBoundPacket {
   count;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    this.count = dataView.nextUint16();
+    this.count = PacketView.fromPacket(this).nextUint16();
   }
 }
 
@@ -1895,19 +1112,19 @@ class GetDirectoryEntryReplyD2HPacket extends HostBoundPacket {
   file;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    if (this.payloadSize > 4) {
-      this.file = {
-        index: dataView.nextUint8(),
-        size: dataView.nextUint32(),
-        loadAddress: dataView.nextUint32(),
-        crc32: dataView.nextUint32(),
-        type: dataView.nextString(4),
-        timestamp: dataView.nextUint32() + PacketEncoder.J2000_EPOCH,
-        version: dataView.nextVersion(),
-        filename: dataView.nextNTBS(32)
-      };
-    }
+    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)
+    };
   }
 }
 
@@ -1922,18 +1139,18 @@ class GetFileMetadataReplyD2HPacket extends HostBoundPacket {
   file;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    dataView.nextUint8();
-    if (this.payloadSize > 4) {
-      this.file = {
-        size: dataView.nextUint32(),
-        loadAddress: dataView.nextUint32(),
-        crc32: dataView.nextUint32(),
-        type: dataView.nextString(4),
-        timestamp: dataView.nextUint32() + PacketEncoder.J2000_EPOCH,
-        version: dataView.nextVersion()
-      };
-    }
+    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()
+    };
   }
 }
 
@@ -1949,9 +1166,9 @@ class GetProgramSlotInfoReplyD2HPacket extends HostBoundPacket {
   slot;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    this.slot = dataView.nextUint8();
-    this.requestedSlot = dataView.nextUint8();
+    const view = PacketView.fromPacket(this);
+    this.slot = view.nextUint8();
+    this.requestedSlot = view.nextUint8();
   }
 }
 
@@ -1969,40 +1186,32 @@ class GetSystemFlagsReplyD2HPacket extends HostBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 32;
   flags;
-  radioSearching;
+  radioSearching = false;
   radioQuality;
   controllerBatteryPercent;
   partnerControllerBatteryPercent;
   battery;
-  currentProgram;
+  currentProgram = 0;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    this.radioSearching = false;
-    this.currentProgram = 0;
-    this.flags = dataView.nextUint32();
+    const view = PacketView.fromPacket(this);
+    this.flags = view.nextUint32();
     const hasPartner = (8192 & this.flags) !== 0;
     const hasRadio = (1536 & this.flags) === 1536;
-    const byte1 = dataView.nextUint8();
-    const byte2 = dataView.nextUint8();
+    const byte1 = view.nextUint8();
+    const byte2 = view.nextUint8();
     if (this.payloadSize === 11) {
-      this.battery = 8 * (byte1 & 15);
-      if ((this.flags & 256) !== 0 || hasRadio)
-        this.controllerBatteryPercent = 8 * (byte1 >> 4 & 15);
+      this.battery = clamp100(8 * (byte1 & 15));
+      if ((this.flags & 256) !== 0 || hasRadio) {
+        this.controllerBatteryPercent = clamp100(8 * (byte1 >> 4 & 15));
+      }
       if (hasRadio)
-        this.radioQuality = 8 * (byte2 & 15);
+        this.radioQuality = clamp100(8 * (byte2 & 15));
       this.radioSearching = (this.flags & 1536) === 512;
-      if (hasPartner)
-        this.partnerControllerBatteryPercent = 8 * (byte2 >> 4 & 15);
-      this.currentProgram = dataView.nextUint8();
-      if (this.battery != null && this.battery > 100)
-        this.battery = 100;
-      if (this.controllerBatteryPercent != null && this.controllerBatteryPercent > 100)
-        this.controllerBatteryPercent = 100;
-      if (this.radioQuality != null && this.radioQuality > 100)
-        this.radioQuality = 100;
-      if (this.partnerControllerBatteryPercent != null && this.partnerControllerBatteryPercent > 100)
-        this.partnerControllerBatteryPercent = 100;
+      if (hasPartner) {
+        this.partnerControllerBatteryPercent = clamp100(8 * (byte2 >> 4 & 15));
+      }
+      this.currentProgram = view.nextUint8();
     }
   }
 }
@@ -2014,17 +1223,17 @@ class GetDeviceStatusReplyD2HPacket extends HostBoundPacket {
   devices;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    this.count = dataView.nextUint8();
+    const view = PacketView.fromPacket(this);
+    this.count = view.nextUint8();
     this.devices = [];
     for (let i = 0;i < this.count; i++) {
       this.devices.push({
-        port: dataView.nextUint8(),
-        type: dataView.nextUint8(),
-        status: dataView.nextUint8(),
-        betaversion: dataView.nextUint8(),
-        version: dataView.nextUint16(),
-        bootversion: dataView.nextUint16()
+        port: view.nextUint8(),
+        type: view.nextUint8(),
+        status: view.nextUint8(),
+        betaversion: view.nextUint8(),
+        version: view.nextUint16(),
+        bootversion: view.nextUint16()
       });
     }
   }
@@ -2036,48 +1245,42 @@ class GetSystemStatusReplyD2HPacket extends HostBoundPacket {
   systemVersion;
   cpu0Version;
   cpu1Version;
-  nxpVersion;
+  nxpVersion = VexFirmwareVersion.allZero();
   touchVersion;
-  uniqueId;
-  sysflags;
-  eventBrain;
-  romBootloaderActive;
-  ramBootloaderActive;
-  goldenVersion;
+  uniqueId = 1234;
+  sysflags = [0, 0, 0, 0, 0, 0, 0];
+  eventBrain = false;
+  romBootloaderActive = false;
+  ramBootloaderActive = false;
+  goldenVersion = VexFirmwareVersion.allZero();
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    dataView.nextUint8();
-    this.systemVersion = dataView.nextVersion();
-    this.cpu0Version = dataView.nextVersion();
-    this.cpu1Version = dataView.nextVersion();
-    this.touchVersion = dataView.nextVersion(true);
-    this.uniqueId = 1234;
-    this.sysflags = [0, 0, 0, 0, 0, 0, 0];
-    this.goldenVersion = VexFirmwareVersion.allZero();
-    this.nxpVersion = VexFirmwareVersion.allZero();
-    this.eventBrain = false;
-    this.romBootloaderActive = false;
-    this.ramBootloaderActive = false;
+    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 = dataView.nextUint32();
+      this.uniqueId = view.nextUint32();
       this.sysflags = [
-        dataView.nextUint8(),
-        dataView.nextUint8(),
-        dataView.nextUint8(),
-        dataView.nextUint8(),
-        dataView.nextUint8(),
+        view.nextUint8(),
+        view.nextUint8(),
+        view.nextUint8(),
+        view.nextUint8(),
+        view.nextUint8(),
         0,
-        dataView.nextUint8()
+        view.nextUint8()
       ];
-      this.eventBrain = (1 & this.sysflags[6]) !== 0;
-      this.romBootloaderActive = (2 & this.sysflags[6]) !== 0;
-      this.ramBootloaderActive = (4 & this.sysflags[6]) !== 0;
-      dataView.nextUint16();
-      this.goldenVersion = dataView.nextVersion();
+      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 = dataView.nextVersion();
+      this.nxpVersion = view.nextVersion();
     }
   }
 }
@@ -2089,17 +1292,17 @@ class GetFdtStatusReplyD2HPacket extends HostBoundPacket {
   status;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    this.count = dataView.nextUint8();
+    const view = PacketView.fromPacket(this);
+    this.count = view.nextUint8();
     this.status = [];
     for (let i = 0;i < this.count; i++) {
       this.status.push({
-        index: dataView.nextUint8(),
-        type: dataView.nextUint8(),
-        status: dataView.nextUint8(),
-        betaversion: dataView.nextUint8(),
-        version: dataView.nextUint16(),
-        bootversion: dataView.nextUint16()
+        index: view.nextUint8(),
+        type: view.nextUint8(),
+        status: view.nextUint8(),
+        betaversion: view.nextUint8(),
+        version: view.nextUint16(),
+        bootversion: view.nextUint16()
       });
     }
   }
@@ -2111,9 +1314,9 @@ class GetLogCountReplyD2HPacket extends HostBoundPacket {
   count;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    dataView.nextUint8();
-    this.count = dataView.nextUint32();
+    const view = PacketView.fromPacket(this);
+    view.nextUint8();
+    this.count = view.nextUint32();
   }
 }
 
@@ -2125,20 +1328,19 @@ class ReadLogPageReplyD2HPacket extends HostBoundPacket {
   entries;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    const n = this.ackIndex;
-    const size = dataView.nextUint8();
-    this.offset = dataView.nextUint32();
-    this.count = dataView.nextUint16();
+    const view = PacketView.fromPacket(this);
+    const size = view.nextUint8();
+    this.offset = view.nextUint32();
+    this.count = view.nextUint16();
     this.entries = [];
-    let j = n + 8;
+    let j = this.ackIndex + 8;
     for (let i = 0;i < this.count; i++) {
       this.entries.push({
-        code: dataView.getUint8(j),
-        type: dataView.getUint8(j + 1),
-        desc: dataView.getUint8(j + 2),
-        spare: dataView.getUint8(j + 3),
-        time: dataView.getUint32(j + 4, true)
+        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;
     }
@@ -2155,13 +1357,12 @@ class GetRadioStatusReplyD2HPacket extends HostBoundPacket {
   timeslot;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    const n = this.ackIndex;
-    this.device = dataView.nextUint8();
-    this.quality = dataView.nextUint16();
-    this.strength = dataView.nextInt16();
-    this.channel = this.data[n + 6];
-    this.timeslot = this.data[n + 7];
+    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];
   }
 }
 
@@ -2186,8 +1387,7 @@ class ReadKeyValueReplyD2HPacket extends HostBoundPacket {
   value;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    this.value = dataView.nextVarNTBS(255);
+    this.value = PacketView.fromPacket(this).nextVarNTBS(255);
   }
 }
 
@@ -2203,20 +1403,18 @@ class GetSlot1to4InfoReplyD2HPacket extends HostBoundPacket {
   slots;
   constructor(data, start = 1) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    this.slotFlags = dataView.nextUint8();
+    const view = PacketView.fromPacket(this);
+    this.slotFlags = view.nextUint8();
     this.slots = [];
     for (let i = 0;i < 4; i++) {
-      const hasData = (this.slotFlags & 2 ** (start - 1 + i)) !== 0;
-      if (!hasData)
+      if ((this.slotFlags & 1 << start - 1 + i) === 0)
         continue;
-      const iconNum = dataView.nextUint16();
-      const nameLen = dataView.nextUint8();
-      const name = dataView.nextString(nameLen);
+      const icon = view.nextUint16();
+      const nameLen = view.nextUint8();
       this.slots.push({
         slot: start + i,
-        icon: iconNum,
-        name
+        icon,
+        name: view.nextString(nameLen)
       });
     }
   }
@@ -2238,9 +1436,9 @@ class FactoryStatusReplyD2HPacket extends HostBoundPacket {
   percent;
   constructor(data) {
     super(data);
-    const dataView = PacketView.fromPacket(this);
-    this.status = dataView.nextUint8();
-    this.percent = dataView.nextUint8();
+    const view = PacketView.fromPacket(this);
+    this.status = view.nextUint8();
+    this.percent = view.nextUint8();
   }
 }
 
@@ -2249,120 +1447,35 @@ class FactoryEnableReplyD2HPacket extends HostBoundPacket {
   static COMMAND_EXTENDED_ID = 255;
 }
 
-// src/VexPacketEncoder.ts
-var textEncoder2 = new TextEncoder;
-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;
-  crcgen;
-  allPacketsTable = {};
-  static getInstance() {
-    if (Packet.ENCODER === undefined) {
-      Packet.ENCODER = new PacketEncoder;
-    }
-    return Packet.ENCODER;
-  }
-  constructor() {
-    this.vexVersion = 0;
-    this.crcgen = new CrcGenerator;
-    Object.values(exports_VexPacketModels).forEach((packet) => {
-      if (typeof packet === "function" && packet.prototype instanceof HostBoundPacket) {
-        const packetType = packet;
-        this.allPacketsTable[packetType.COMMAND_ID + " " + packetType.COMMAND_EXTENDED_ID] = packetType;
-      }
-    });
-  }
-  createHeader(buf) {
-    if (buf === undefined || buf.byteLength < PacketEncoder.HEADERS_LENGTH) {
-      buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH);
-    }
-    const h = new Uint8Array(buf);
-    h.set(PacketEncoder.HEADER_TO_DEVICE);
-    return h;
-  }
-  cdcCommand(cmd) {
-    const buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH + 1);
-    const h = this.createHeader(buf);
-    h.set([cmd], PacketEncoder.HEADERS_LENGTH);
-    return h;
-  }
-  cdcCommandWithData(cmd, data) {
-    const buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH + 2 + data.length);
-    const h = this.createHeader(buf);
-    h.set([cmd, data.length], PacketEncoder.HEADERS_LENGTH);
-    h.set(data, PacketEncoder.HEADERS_LENGTH + 2);
-    return h;
-  }
-  cdc2Command(cmd, ext) {
-    const buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH + 5);
-    const h = this.createHeader(buf);
-    h.set([cmd, ext, 0], PacketEncoder.HEADERS_LENGTH);
-    const crc = this.crcgen.crc16(h.subarray(0, buf.byteLength - 2), 0) >>> 0;
-    h.set([crc >>> 8, crc & 255], buf.byteLength - 2);
-    return h;
-  }
-  cdc2CommandBufferLength(data) {
-    let length = PacketEncoder.HEADERS_LENGTH + data.length + 3 + 2;
-    if (data.length > 127)
-      length += 1;
-    return length;
-  }
-  cdc2CommandWithData(cmd, ext, data) {
-    const buf = new ArrayBuffer(this.cdc2CommandBufferLength(data));
-    const h = this.createHeader(buf);
-    if (data.length < 128) {
-      h.set([cmd, ext, data.length], PacketEncoder.HEADERS_LENGTH);
-      h.set(data, PacketEncoder.HEADERS_LENGTH + 3);
-    } else {
-      const lengthMsb = (data.length >>> 8 | 128) >>> 0;
-      const lengthLsb = (data.length & 255) >>> 0;
-      h.set([cmd, ext, lengthMsb, lengthLsb], PacketEncoder.HEADERS_LENGTH);
-      h.set(data, PacketEncoder.HEADERS_LENGTH + 4);
-    }
-    const crc = this.crcgen.crc16(h.subarray(0, buf.byteLength - 2), 0);
-    h.set([crc >>> 8, crc & 255], buf.byteLength - 2);
-    return h;
-  }
-  validateHeader(data) {
-    return !(data[0] !== PacketEncoder.HEADER_TO_HOST[0] || data[1] !== PacketEncoder.HEADER_TO_HOST[1]);
-  }
-  validateMessageCdc(data) {
-    const message = data.subarray(0, data.byteLength - 2);
-    const lastTwoBytes = (data[data.byteLength - 2] << 8) + data[data.byteLength - 1];
-    return this.crcgen.crc16(message, 0) === lastTwoBytes;
+// src/VexScreenCapture.ts
+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;
+var SCREEN_CAPTURE_FRAMEBUFFER_SIZE = SCREEN_CAPTURE_MESSAGE_WIDTH * SCREEN_CAPTURE_HEIGHT * SCREEN_CAPTURE_MESSAGE_CHANNELS;
+function convertScreenCapture(framebuffer) {
+  if (framebuffer.length !== SCREEN_CAPTURE_FRAMEBUFFER_SIZE) {
+    throw new Error(`bad screen capture framebuffer size: ${framebuffer.length}; expected ${SCREEN_CAPTURE_FRAMEBUFFER_SIZE}`);
   }
-  getPayloadSize(data) {
-    let t = 0;
-    let a = data[3];
-    if ((128 & a) !== 0) {
-      t = 127 & a;
-      a = data[4];
+  const pixels = new Uint8Array(SCREEN_CAPTURE_WIDTH * SCREEN_CAPTURE_HEIGHT * SCREEN_CAPTURE_CHANNELS);
+  let source = 0;
+  let target = 0;
+  for (let row = 0;row < SCREEN_CAPTURE_HEIGHT; row++) {
+    for (let column = 0;column < SCREEN_CAPTURE_WIDTH; column++) {
+      pixels[target] = framebuffer[source + 2];
+      pixels[target + 1] = framebuffer[source + 1];
+      pixels[target + 2] = framebuffer[source];
+      source += SCREEN_CAPTURE_MESSAGE_CHANNELS;
+      target += SCREEN_CAPTURE_CHANNELS;
     }
-    return (t << 8) + a;
-  }
-  getHostHeaderLength(data) {
-    return (data[3] & 128) === 0 ? 4 : 5;
+    source += (SCREEN_CAPTURE_MESSAGE_WIDTH - SCREEN_CAPTURE_WIDTH) * SCREEN_CAPTURE_MESSAGE_CHANNELS;
   }
+  return pixels;
 }
 
 // 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 }];
@@ -2370,12 +1483,31 @@ class VexSerialConnection extends VexEventTarget {
   reader;
   port;
   serial;
-  callbacksQueue = [];
+  pendingCallbacks = new Map;
+  rawCallbacks = {
+    head: undefined,
+    tail: undefined
+  };
+  pendingCommandTails = new Map;
   _onPortDisconnect = null;
   _closePromise = null;
+  _openPromise = null;
+  _isClosing = false;
   _wasConnected = false;
   fileTransferTail = Promise.resolve();
   fileTransferDepth = 0;
+  get callbacksQueue() {
+    const callbacks = [];
+    for (const queue of this.pendingCallbacks.values()) {
+      for (let callback = queue.head;callback; callback = callback.next) {
+        callbacks.push(callback);
+      }
+    }
+    for (let callback = this.rawCallbacks.head;callback; callback = callback.next) {
+      callbacks.push(callback);
+    }
+    return callbacks;
+  }
   get isConnected() {
     return this.port !== undefined && this.reader !== undefined && this.writer !== undefined;
   }
@@ -2386,25 +1518,46 @@ class VexSerialConnection extends VexEventTarget {
     super();
     this.serial = serial;
   }
+  reportWarning(message, details) {
+    this.emitSafely("warning", {
+      message,
+      details
+    });
+  }
+  emitSafely(eventName, data) {
+    try {
+      this.emit(eventName, data);
+    } catch {}
+  }
   async close() {
     if (this._closePromise)
       return this._closePromise;
-    if (!this._hasOpenResources())
-      return;
-    this._closePromise = this._doClose();
+    this._isClosing = true;
+    const closing = this._closeAfterOpen();
+    this._closePromise = closing;
     try {
-      await this._closePromise;
+      await closing;
     } finally {
-      this._closePromise = null;
+      if (this._closePromise === closing)
+        this._closePromise = null;
+      this._isClosing = false;
     }
   }
+  async _closeAfterOpen() {
+    const opening = this._openPromise;
+    if (opening !== null)
+      await opening;
+    if (!this._hasOpenResources())
+      return;
+    await this._doClose();
+  }
   _hasOpenResources() {
-    return this.port !== undefined || this.reader !== undefined || this.writer !== undefined || this._onPortDisconnect !== null || this.callbacksQueue.length > 0;
+    return this.port !== undefined || this.reader !== undefined || this.writer !== undefined || this._onPortDisconnect !== null || this.hasPendingCallbacks();
   }
   async _doClose() {
-    for (const callback of this.callbacksQueue.splice(0)) {
+    for (const callback of this.drainPendingCallbacks()) {
       clearTimeout(callback.timeout);
-      callback.callback(255 /* CDC2_NACK */);
+      callback.callback(258 /* NOT_CONNECTED */);
     }
     const onDisconnect = this._onPortDisconnect;
     this._onPortDisconnect = null;
@@ -2448,38 +1601,48 @@ class VexSerialConnection extends VexEventTarget {
       try {
         await port.close();
       } catch (e) {
-        console.warn("Close port error.", e);
+        this.reportWarning("failed to close the serial port", e);
       }
     }
     if (this._wasConnected) {
       this._wasConnected = false;
-      this.emit("disconnected", undefined);
+      this.emitSafely("disconnected", undefined);
     }
   }
   open(use = 0, askUser = true) {
-    if (this.port !== undefined) {
-      return errAsyncVex(new VexIoError("Already connected."));
-    }
-    return new ResultAsync(this._open(use, askUser));
+    if (this._openPromise !== null)
+      return new ResultAsync(this._openPromise);
+    const opening = this._open(use, askUser);
+    this._openPromise = opening;
+    opening.then(() => {
+      if (this._openPromise === opening)
+        this._openPromise = null;
+    }, () => {
+      if (this._openPromise === opening)
+        this._openPromise = null;
+    });
+    return new ResultAsync(opening);
   }
   async _open(use, askUser) {
-    let port;
-    if (use !== undefined) {
-      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);
-      port = ports[use];
+    if (this._closePromise !== null)
+      await this._closePromise;
+    if (this.port !== undefined) {
+      return 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 ok(undefined);
+      return ok("no-port");
     if (port.readable != null)
-      return ok(false);
+      return ok("busy");
     try {
       this.port = port;
       await port.open({ baudRate: 115200 });
@@ -2491,46 +1654,79 @@ class VexSerialConnection extends VexEventTarget {
       this.reader = this.port.readable.getReader();
       this.startReader();
       this._wasConnected = true;
-      this.emit("connected", undefined);
-      return ok(true);
-    } catch {
-      await this.close();
-      return ok(false);
+      this.emitSafely("connected", undefined);
+      return ok("opened");
+    } catch (e) {
+      await this._doClose();
+      return err(toVexSerialError(e, "io"));
     }
   }
-  writeData(rawData, resolve, timeout = 1000) {
-    this.writeDataAsync(rawData, timeout).then(resolve);
-  }
   async writeDataAsync(rawData, timeout = 1000) {
+    if (rawData instanceof DeviceBoundPacket) {
+      return this.serializeCommand(rawData.commandId, rawData.commandExtendedId, () => this.writeDataAsyncUnserialized(rawData, timeout));
+    }
+    return this.writeDataAsyncUnserialized(rawData, timeout);
+  }
+  async serializeCommand(commandId, commandExtendedId, operation) {
+    const key = `${commandId}:${commandExtendedId ?? ""}`;
+    const previous = this.pendingCommandTails.get(key) ?? Promise.resolve();
+    let release = () => {};
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.pendingCommandTails.set(key, current);
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+      if (this.pendingCommandTails.get(key) === current) {
+        this.pendingCommandTails.delete(key);
+      }
+    }
+  }
+  async writeDataAsyncUnserialized(rawData, timeout) {
     return new Promise((resolve) => {
-      if (this.writer === undefined) {
-        resolve(255 /* CDC2_NACK */);
+      if (this.writer === undefined || this._isClosing) {
+        resolve(258 /* NOT_CONNECTED */);
         return;
       }
       const data = rawData instanceof DeviceBoundPacket ? rawData.data : rawData;
+      const queue = rawData instanceof DeviceBoundPacket ? this.getPendingQueue(rawData.commandId, rawData.commandExtendedId, true) : this.rawCallbacks;
       const cb = {
+        active: true,
         callback: resolve,
         timeout: setTimeout(() => {
-          const index = this.callbacksQueue.indexOf(cb);
-          if (index === -1)
+          if (!this.removePendingCallback(cb))
             return;
-          this.callbacksQueue.splice(index, 1);
           cb.callback(256 /* TIMEOUT */);
         }, timeout),
+        next: undefined,
+        previous: undefined,
+        queue,
         wantedCommandId: rawData instanceof DeviceBoundPacket ? rawData.commandId : undefined,
         wantedCommandExId: rawData instanceof DeviceBoundPacket ? rawData.commandExtendedId : undefined
       };
-      this.callbacksQueue.push(cb);
+      this.enqueuePendingCallback(cb);
       this.writer.write(data).catch(() => {
-        const index = this.callbacksQueue.indexOf(cb);
-        if (index === -1)
+        if (!this.removePendingCallback(cb))
           return;
-        this.callbacksQueue.splice(index, 1);
         clearTimeout(cb.timeout);
         resolve(257 /* WRITE_ERROR */);
       });
     });
   }
+  request(packet, ReplyType, timeout = 1000) {
+    return new ResultAsync((async () => {
+      const result = await this.writeDataAsync(packet, timeout);
+      if (result instanceof ReplyType)
+        return ok(result);
+      if (result === 258 /* NOT_CONNECTED */) {
+        return err(new VexNotConnectedError);
+      }
+      return 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");
@@ -2538,93 +1734,172 @@ class VexSerialConnection extends VexEventTarget {
       const { value: readData, done: isDone } = await this.reader.read();
       if (isDone)
         throw new Error("No data");
-      cache = binaryArrayJoin(cache, readData);
+      cache.append(readData);
     }
-    return cache;
   }
   async startReader() {
-    let cache = new Uint8Array([]);
+    const cache = new ReceiveBuffer;
     let sliceIdx = 0;
     for (;; )
       try {
-        cache = await this.readData(cache, 5);
+        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]);
+        while (!thePacketEncoder.validateHeader(cache.bytes)) {
+          const bytes = cache.bytes;
+          const nextHeader = bytes.findIndex((byte, index) => index > 0 && byte === PacketEncoder.HEADER_TO_HOST[0] && bytes[index + 1] === PacketEncoder.HEADER_TO_HOST[1]);
           if (nextHeader >= 0) {
-            cache = cache.slice(nextHeader);
+            cache.discard(nextHeader);
           } else {
-            cache = cache.slice(cache.at(-1) === PacketEncoder.HEADER_TO_HOST[0] ? -1 : cache.length);
+            cache.discard(bytes.at(-1) === PacketEncoder.HEADER_TO_HOST[0] ? -1 : bytes.length);
           }
-          cache = await this.readData(cache, 5);
+          await this.readData(cache, 5);
         }
-        const payloadExpectedSize = thePacketEncoder.getPayloadSize(cache);
-        const n = thePacketEncoder.getHostHeaderLength(cache);
+        const payloadExpectedSize = thePacketEncoder.getPayloadSize(cache.bytes);
+        const n = thePacketEncoder.getHostHeaderLength(cache.bytes);
         const totalSize = n + payloadExpectedSize;
-        cache = await this.readData(cache, totalSize);
+        await this.readData(cache, totalSize);
         sliceIdx = totalSize;
-        const cmdId = cache[2];
+        const packet = cache.copy(totalSize);
+        const cmdId = packet[2];
         const hasExtId = cmdId === 88 || cmdId === 86;
-        const cmdExId = hasExtId ? cache[n] : undefined;
-        const ack = cache[n + 1];
+        const cmdExId = hasExtId ? packet[n] : undefined;
+        const ack = packet[n + 1];
         if (hasExtId) {
-          if (!thePacketEncoder.validateMessageCdc(cache))
-            throw new Error("Invalid message CDC");
-        }
-        let callbackInfo;
-        let wantedCmdId;
-        let wantedCmdExId;
-        let tryIdx = 0;
-        while ((callbackInfo = this.callbacksQueue[tryIdx++]) !== undefined) {
-          wantedCmdId = callbackInfo?.wantedCommandId;
-          wantedCmdExId = callbackInfo?.wantedCommandExId;
-          if (wantedCmdId !== undefined && wantedCmdId !== cmdId || wantedCmdExId !== undefined && wantedCmdExId !== cmdExId) {
+          if (!thePacketEncoder.validateMessageCdc(packet)) {
+            this.reportWarning("discarding a reply with an invalid CDC CRC", {
+              commandId: cmdId,
+              commandExtendedId: cmdExId,
+              ack
+            });
             continue;
           }
-          break;
         }
+        const callbackInfo = this.shiftPendingCallback(cmdId, cmdExId) ?? this.shiftRawCallback();
         if (callbackInfo === undefined) {
-          console.warn("Unexpected command", cmdId, cmdExId, ack);
+          this.reportWarning("received a reply with no matching request", {
+            commandId: cmdId,
+            commandExtendedId: cmdExId,
+            ack
+          });
           continue;
         }
-        const data = cache.slice(0, sliceIdx);
-        const PackageType = thePacketEncoder.allPacketsTable[wantedCmdId + " " + wantedCmdExId];
-        if (wantedCmdId === undefined && wantedCmdExId === undefined || PackageType === undefined) {
-          callbackInfo.callback(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
+        const wantedCmdId = callbackInfo.wantedCommandId;
+        const wantedCmdExId = callbackInfo.wantedCommandExId;
+        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(packet.buffer);
         } else {
-          if (!hasExtId || PackageType.isValidPacket(data, n)) {
-            callbackInfo.callback(new PackageType(data));
+          if (PackageType.isValidPacket(packet, n)) {
+            callbackInfo.callback(new PackageType(packet));
           } else {
-            console.warn("ack", ack);
+            this.reportWarning("reply failed packet validation; delivering its ack instead", { commandId: cmdId, commandExtendedId: cmdExId, ack });
             callbackInfo.callback(ack);
           }
         }
         clearTimeout(callbackInfo.timeout);
-        this.callbacksQueue.splice(tryIdx - 1, 1);
       } catch (e) {
         if (!(e instanceof Error && e.message === "No data")) {
-          console.warn("Read error.", e, cache);
+          this.reportWarning("reader loop stopped by a read error", {
+            error: e,
+            pendingBytes: cache.bytes
+          });
         }
         await this.close();
         break;
       } finally {
-        cache = cache.slice(sliceIdx);
+        cache.discard(sliceIdx);
       }
   }
-  query1() {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new Query1H2DPacket, 100);
-      return result instanceof Query1ReplyD2HPacket ? ok(result) : err(new VexProtocolError("query1 was not acknowledged"));
-    })());
+  pendingKey(commandId, commandExtendedId) {
+    return `${commandId}:${commandExtendedId ?? ""}`;
+  }
+  getPendingQueue(commandId, commandExtendedId, create) {
+    const key = this.pendingKey(commandId, commandExtendedId);
+    let queue = this.pendingCallbacks.get(key);
+    if (queue === undefined && create) {
+      const created = { head: undefined, tail: undefined };
+      this.pendingCallbacks.set(key, created);
+      queue = created;
+    }
+    return queue ?? { head: undefined, tail: undefined };
+  }
+  enqueuePendingCallback(callback) {
+    const tail = callback.queue.tail;
+    callback.previous = tail;
+    if (tail === undefined)
+      callback.queue.head = callback;
+    else
+      tail.next = callback;
+    callback.queue.tail = callback;
+  }
+  removePendingCallback(callback) {
+    if (!callback.active)
+      return false;
+    callback.active = false;
+    const { queue, previous, next } = callback;
+    if (previous === undefined)
+      queue.head = next;
+    else
+      previous.next = next;
+    if (next === undefined)
+      queue.tail = previous;
+    else
+      next.previous = previous;
+    callback.previous = undefined;
+    callback.next = undefined;
+    if (queue !== this.rawCallbacks && queue.head === undefined && callback.wantedCommandId !== undefined) {
+      this.pendingCallbacks.delete(this.pendingKey(callback.wantedCommandId, callback.wantedCommandExId));
+    }
+    return true;
+  }
+  shiftPendingCallback(commandId, commandExtendedId) {
+    const queue = this.getPendingQueue(commandId, commandExtendedId, false);
+    const callback = queue.head;
+    if (callback !== undefined)
+      this.removePendingCallback(callback);
+    return callback;
+  }
+  shiftRawCallback() {
+    const callback = this.rawCallbacks.head;
+    if (callback !== undefined)
+      this.removePendingCallback(callback);
+    return callback;
+  }
+  hasPendingCallbacks() {
+    return this.pendingCallbacks.size > 0 || this.rawCallbacks.head !== undefined;
+  }
+  drainPendingCallbacks() {
+    const callbacks = [];
+    for (const queue of this.pendingCallbacks.values()) {
+      for (let callback = queue.head;callback; ) {
+        const next = callback.next;
+        callback.active = false;
+        callback.previous = undefined;
+        callback.next = undefined;
+        callbacks.push(callback);
+        callback = next;
+      }
+    }
+    for (let callback = this.rawCallbacks.head;callback; ) {
+      const next = callback.next;
+      callback.active = false;
+      callback.previous = undefined;
+      callback.next = undefined;
+      callbacks.push(callback);
+      callback = next;
+    }
+    this.pendingCallbacks.clear();
+    this.rawCallbacks = { head: undefined, tail: undefined };
+    return callbacks;
+  }
+  query1() {
+    return this.request(new Query1H2DPacket, Query1ReplyD2HPacket, 100);
   }
   getSystemVersion() {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new SystemVersionH2DPacket);
-      if (result instanceof SystemVersionReplyD2HPacket) {
-        return ok(result.version);
-      }
-      return err(new VexProtocolError("system version was not acknowledged"));
-    })());
+    return this.request(new SystemVersionH2DPacket, SystemVersionReplyD2HPacket).map((result) => result.version);
   }
 }
 
@@ -2651,34 +1926,19 @@ class V5SerialConnection extends VexSerialConnection {
     }
   }
   getDeviceStatus() {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new GetDeviceStatusH2DPacket);
-      return result instanceof GetDeviceStatusReplyD2HPacket ? ok(result) : err(new VexProtocolError("device status was not acknowledged"));
-    })());
+    return this.request(new GetDeviceStatusH2DPacket, GetDeviceStatusReplyD2HPacket);
   }
   getRadioStatus() {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new GetRadioStatusH2DPacket);
-      return result instanceof GetRadioStatusReplyD2HPacket ? ok(result) : err(new VexProtocolError("radio status was not acknowledged"));
-    })());
+    return this.request(new GetRadioStatusH2DPacket, GetRadioStatusReplyD2HPacket);
   }
   getSystemFlags() {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new GetSystemFlagsH2DPacket);
-      return result instanceof GetSystemFlagsReplyD2HPacket ? ok(result) : err(new VexProtocolError("system flags were not acknowledged"));
-    })());
+    return this.request(new GetSystemFlagsH2DPacket, GetSystemFlagsReplyD2HPacket);
   }
   getSystemStatus(timeout = 1000) {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new GetSystemStatusH2DPacket, timeout);
-      return result instanceof GetSystemStatusReplyD2HPacket ? ok(result) : err(new VexProtocolError("system status was not acknowledged"));
-    })());
+    return this.request(new GetSystemStatusH2DPacket, GetSystemStatusReplyD2HPacket, timeout);
   }
   getMatchStatus() {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new GetMatchStatusH2DPacket);
-      return result instanceof MatchStatusReplyD2HPacket ? ok(result) : err(new VexProtocolError("match status was not acknowledged"));
-    })());
+    return this.request(new GetMatchStatusH2DPacket, MatchStatusReplyD2HPacket);
   }
   uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback) {
     return wrapTransfer(this, () => this._uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback));
@@ -2739,32 +1999,35 @@ class V5SerialConnection extends VexSerialConnection {
   async _downloadFileToHostUnlocked(request, downloadTarget, progressCallback) {
     const { filename, vendor, loadAddress, size } = request;
     let nextAddress = loadAddress ?? USER_FLASH_USR_CODE_START;
-    const p1 = await this.writeDataAsync(new InitFileTransferH2DPacket(2 /* READ */, downloadTarget, vendor, 0 /* NONE */, new Uint8Array, nextAddress, filename, ""));
-    if (!(p1 instanceof InitFileTransferReplyD2HPacket)) {
-      return err(new VexTransferError("InitFileTransferH2DPacket failed"));
-    }
+    const p1Result = await this.request(new InitFileTransferH2DPacket(2 /* READ */, downloadTarget, vendor, 0 /* NONE */, new Uint8Array, nextAddress, filename, ""), InitFileTransferReplyD2HPacket);
+    if (p1Result.isErr())
+      return err(p1Result.error);
     let transferFailed = true;
     let result = 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 p2 = await this.writeDataAsync(new ReadFileH2DPacket(nextAddress, requestedSize), 3000);
-        if (!(p2 instanceof ReadFileReplyD2HPacket)) {
-          throw new VexTransferError("ReadFileReplyD2HPacket failed");
-        }
+        const remainingSize = fileSize - bufferOffset;
+        const chunkSize = Math.min(bufferChunkSize, remainingSize);
+        const requestedSize = chunkSize + 3 & ~3;
+        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;
+        const receivedSize = Math.min(p2.length, remainingSize);
+        fileBuf.set(p2.buf.subarray(0, receivedSize), bufferOffset);
+        bufferOffset += receivedSize;
+        nextAddress += receivedSize;
         progressCallback?.(bufferOffset, fileSize);
       }
       transferFailed = false;
@@ -2773,11 +2036,12 @@ class V5SerialConnection extends VexSerialConnection {
       result = err(e instanceof VexSerialError ? e : toVexSerialError(e, "transfer"));
     } finally {
       try {
-        await this.writeDataAsync(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */), 30000);
-      } catch (cleanupError) {
-        if (!transferFailed) {
-          result = err(toVexSerialError(cleanupError, "io"));
-        }
+        const exitResult = await this.request(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */), ExitFileTransferReplyD2HPacket, 30000);
+        if (!transferFailed && exitResult.isErr())
+          result = err(exitResult.error);
+      } catch (e) {
+        if (!transferFailed)
+          result = err(toVexSerialError(e, "io"));
       }
     }
     return result;
@@ -2802,22 +2066,20 @@ class V5SerialConnection extends VexSerialConnection {
     downloadTarget = downloadTarget ?? 1 /* FILE_TARGET_QSPI */;
     vendor = vendor ?? 1 /* USER */;
     let nextAddress = loadAddress ?? USER_FLASH_USR_CODE_START;
-    const p1 = await this.writeDataAsync(new InitFileTransferH2DPacket(1 /* WRITE */, downloadTarget, vendor, 1 /* OVERWRITE */, buf, nextAddress, filename, exttype));
-    if (!(p1 instanceof InitFileTransferReplyD2HPacket)) {
-      return err(new VexTransferError("InitFileTransferH2DPacket failed"));
-    }
+    const p1Result = await this.request(new InitFileTransferH2DPacket(1 /* WRITE */, downloadTarget, vendor, 1 /* OVERWRITE */, buf, nextAddress, filename, exttype), InitFileTransferReplyD2HPacket);
+    if (p1Result.isErr())
+      return err(p1Result.error);
+    const p1 = p1Result.value;
     const bufferChunkSize = getTransferChunkSize(p1.windowSize);
     let bufferOffset = 0;
     let lastBlock = false;
     let transferFailed = true;
-    let exitReply;
     let result = ok(false);
     try {
       if (linkedFile !== undefined) {
-        const p3 = await this.writeDataAsync(new LinkFileH2DPacket(linkedFile.vendor ?? 1 /* USER */, linkedFile.filename, 0), 1e4);
-        if (!(p3 instanceof LinkFileReplyD2HPacket)) {
-          throw new VexTransferError("LinkFileH2DPacket failed");
-        }
+        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;
@@ -2829,23 +2091,21 @@ class V5SerialConnection extends VexSerialConnection {
           tmpbuf.set(buf.subarray(bufferOffset, buf.byteLength));
           lastBlock = true;
         }
-        const p2 = await this.writeDataAsync(new WriteFileH2DPacket(nextAddress, tmpbuf), 3000);
-        if (!(p2 instanceof WriteFileReplyD2HPacket))
-          throw new VexTransferError("WriteFileReplyD2DPacket failed");
-        if (progressCallback != null)
-          progressCallback(bufferOffset, buf.byteLength);
+        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);
       }
-      progressCallback?.(buf.byteLength, buf.byteLength);
       transferFailed = false;
     } catch (e) {
       result = err(e instanceof VexSerialError ? e : toVexSerialError(e, "transfer"));
     } finally {
       try {
-        exitReply = await this.writeDataAsync(new ExitFileTransferH2DPacket(transferFailed ? 3 /* EXIT_HALT */ : autoRun ? 1 /* EXIT_RUN */ : 3 /* EXIT_HALT */), 30000);
+        const exitResult = await this.request(new ExitFileTransferH2DPacket(transferFailed ? 3 /* EXIT_HALT */ : autoRun ? 1 /* EXIT_RUN */ : 3 /* EXIT_HALT */), ExitFileTransferReplyD2HPacket, 30000);
         if (!transferFailed) {
-          result = ok(exitReply !== undefined && exitReply instanceof ExitFileTransferReplyD2HPacket);
+          result = exitResult.map(() => true);
         }
       } catch (cleanupError) {
         if (!transferFailed) {
@@ -2867,14 +2127,20 @@ class V5SerialConnection extends VexSerialConnection {
       }
       let result;
       try {
-        const ack = await this.writeDataAsync(new EraseFileH2DPacket(vendor, filename));
-        result = ack instanceof EraseFileReplyD2HPacket ? ok(undefined) : err(new VexProtocolError("removeFile was not acknowledged"));
+        const eraseResult = await this.request(new EraseFileH2DPacket(vendor, filename), EraseFileReplyD2HPacket);
+        result = eraseResult.map(() => {
+          return;
+        });
       } catch (e) {
         result = err(toVexSerialError(e, "io"));
-      } finally {
-        try {
-          await this.writeDataAsync(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */));
-        } catch {}
+      }
+      try {
+        const exitResult = await this.request(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */), ExitFileTransferReplyD2HPacket, 30000);
+        if (result.isOk() && exitResult.isErr())
+          result = err(exitResult.error);
+      } catch (e) {
+        if (result.isOk())
+          result = err(toVexSerialError(e, "io"));
       }
       return result;
     }));
@@ -2883,23 +2149,26 @@ class V5SerialConnection extends VexSerialConnection {
     return new ResultAsync(this.withFileTransfer(async () => {
       let result;
       try {
-        const ack = await this.writeDataAsync(new FileClearUpH2DPacket(1 /* USER */), 30000);
-        result = ack instanceof FileClearUpReplyD2HPacket ? ok(undefined) : err(new VexProtocolError("removeAllFiles was not acknowledged"));
+        const clearResult = await this.request(new FileClearUpH2DPacket(1 /* USER */), FileClearUpReplyD2HPacket, 30000);
+        result = clearResult.map(() => {
+          return;
+        });
       } catch (e) {
         result = err(toVexSerialError(e, "io"));
-      } finally {
-        try {
-          await this.writeDataAsync(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */));
-        } catch {}
+      }
+      try {
+        const exitResult = await this.request(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */), ExitFileTransferReplyD2HPacket, 30000);
+        if (result.isOk() && exitResult.isErr())
+          result = err(exitResult.error);
+      } catch (e) {
+        if (result.isOk())
+          result = err(toVexSerialError(e, "io"));
       }
       return result;
     }));
   }
   captureScreenSetup() {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new ScreenCaptureH2DPacket(0));
-      return result instanceof ScreenCaptureReplyD2HPacket ? ok(result) : err(new VexProtocolError("screen capture was rejected"));
-    })());
+    return this.request(new ScreenCaptureH2DPacket(0), ScreenCaptureReplyD2HPacket);
   }
   captureScreen(progressCallback) {
     return wrapTransfer(this, () => this._captureScreen(progressCallback));
@@ -2913,74 +2182,85 @@ class V5SerialConnection extends VexSerialConnection {
       filename: "screen",
       vendor: 15 /* SYS */,
       loadAddress: 0,
-      size: SCREEN_CAPTURE_MESSAGE_WIDTH * SCREEN_CAPTURE_HEIGHT * SCREEN_CAPTURE_MESSAGE_CHANNELS
+      size: SCREEN_CAPTURE_FRAMEBUFFER_SIZE
     }, 2 /* FILE_TARGET_CBUF */, progressCallback);
     if (framebuffer.isErr())
       return err(framebuffer.error);
     return ok(convertScreenCapture(framebuffer.value));
   }
   setMatchMode(mode) {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new UpdateMatchModeH2DPacket(mode, 0));
-      return result instanceof MatchModeReplyD2HPacket ? ok(result) : err(new VexProtocolError("setMatchMode was not acknowledged"));
-    })());
+    return this.request(new UpdateMatchModeH2DPacket(mode, 0), MatchModeReplyD2HPacket);
   }
   runProgram(value) {
     return this.loadProgram(value);
   }
   loadProgram(value) {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new LoadFileActionH2DPacket(1 /* USER */, 0 /* RUN */, value));
-      return result instanceof LoadFileActionReplyD2HPacket ? ok(result) : err(new VexProtocolError("loadProgram was not acknowledged"));
-    })());
+    return this.request(new LoadFileActionH2DPacket(1 /* USER */, 0 /* RUN */, value), LoadFileActionReplyD2HPacket);
   }
   stopProgram() {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new LoadFileActionH2DPacket(1 /* USER */, 128 /* STOP */, ""));
-      return result instanceof LoadFileActionReplyD2HPacket ? ok(result) : err(new VexProtocolError("stopProgram was not acknowledged"));
-    })());
+    return this.request(new LoadFileActionH2DPacket(1 /* USER */, 128 /* STOP */, ""), LoadFileActionReplyD2HPacket);
   }
   mockTouch(x, y, press) {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new SendDashTouchH2DPacket(x, y, press));
-      return result instanceof SendDashTouchReplyD2HPacket ? ok(result) : err(new VexProtocolError("mockTouch was not acknowledged"));
-    })());
+    return this.request(new SendDashTouchH2DPacket(x, y, press), SendDashTouchReplyD2HPacket);
   }
   openScreen(screen, port) {
-    return new ResultAsync((async () => {
-      const result = await this.writeDataAsync(new SelectDashH2DPacket(screen, port));
-      return result instanceof SelectDashReplyD2HPacket ? ok(result) : err(new VexProtocolError("openScreen was not acknowledged"));
-    })());
+    return this.request(new SelectDashH2DPacket(screen, port), SelectDashReplyD2HPacket);
+  }
+}
+
+class ReceiveBuffer {
+  storage = new Uint8Array(0);
+  start = 0;
+  end = 0;
+  get byteLength() {
+    return this.end - this.start;
+  }
+  get bytes() {
+    return this.storage.subarray(this.start, this.end);
+  }
+  append(chunk) {
+    this.reserve(chunk.byteLength);
+    this.storage.set(chunk, this.end);
+    this.end += chunk.byteLength;
+  }
+  copy(length) {
+    return this.bytes.slice(0, length);
+  }
+  discard(length) {
+    this.start += length < 0 ? this.byteLength + length : length;
+    if (this.start < 0)
+      this.start = 0;
+    if (this.start > this.end)
+      this.start = this.end;
+    if (this.start === this.end) {
+      this.start = 0;
+      this.end = 0;
+    } else if (this.start >= 4096 && this.start * 2 >= this.storage.length) {
+      this.storage.copyWithin(0, this.start, this.end);
+      this.end -= this.start;
+      this.start = 0;
+    }
+  }
+  reserve(additional) {
+    const required = this.byteLength + additional;
+    if (this.storage.length - this.end >= additional)
+      return;
+    if (this.storage.length >= required) {
+      this.storage.copyWithin(0, this.start, this.end);
+      this.end = this.byteLength;
+      this.start = 0;
+      return;
+    }
+    const storage = new Uint8Array(Math.max(required, Math.max(64, this.storage.length * 2)));
+    storage.set(this.bytes);
+    this.end = this.byteLength;
+    this.start = 0;
+    this.storage = storage;
   }
 }
-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 ResultAsync(conn.withFileTransfer(async () => {
     try {
@@ -2992,17 +2272,26 @@ function wrapTransfer(conn, operation) {
     }
   }));
 }
-function errAsyncVex(error) {
-  return new ResultAsync(Promise.resolve(err(error)));
+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
+import { err as err4, ok as ok4, ResultAsync as ResultAsync4 } from "neverthrow";
+
 // src/VexFirmware.ts
+import { err as err2, errAsync, ok as ok2, ResultAsync as ResultAsync2 } from "neverthrow";
 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 fromAsyncFn(fn) {
-  return new ResultAsync(fn());
-}
 function downloadFileFromInternet(link, options = {}) {
   const { maxBytes = Number.POSITIVE_INFINITY, timeout = 30000 } = options;
   if (maxBytes <= 0) {
@@ -3011,7 +2300,7 @@ function downloadFileFromInternet(link, options = {}) {
   if (timeout < 0) {
     return errAsync(new VexInvalidArgumentError("timeout must be non-negative"));
   }
-  return fromAsyncFn(() => runDownload(link, maxBytes, timeout));
+  return new ResultAsync2(runDownload(link, maxBytes, timeout));
 }
 async function runDownload(link, maxBytes, timeout) {
   const controller = new AbortController;
@@ -3021,20 +2310,20 @@ async function runDownload(link, maxBytes, timeout) {
     try {
       response = await fetch(link, { signal: controller.signal });
     } catch (e) {
-      return err(new VexDownloadError(`failed to download ${link} (${e instanceof Error ? e.message : String(e)})`));
+      return err2(new VexDownloadError(`failed to download ${link} (${e instanceof Error ? e.message : String(e)})`));
     }
     if (!response.ok) {
-      return err(new VexDownloadError(`failed to download ${link} (${response.status})`));
+      return err2(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 err(new VexDownloadError(`declared content length ${declared} exceeds limit ${maxBytes} for ${link}`));
+        return err2(new VexDownloadError(`declared content length ${declared} exceeds limit ${maxBytes} for ${link}`));
       }
     }
     if (response.body == null) {
-      return err(new VexDownloadError(`no response body for ${link}`));
+      return err2(new VexDownloadError(`no response body for ${link}`));
     }
     const reader = response.body.getReader();
     const chunks = [];
@@ -3051,7 +2340,7 @@ async function runDownload(link, maxBytes, timeout) {
           try {
             await reader.cancel();
           } catch {}
-          return err(new VexDownloadError(`downloaded body exceeds limit ${maxBytes} for ${link}`));
+          return err2(new VexDownloadError(`downloaded body exceeds limit ${maxBytes} for ${link}`));
         }
         chunks.push(value);
       }
@@ -3066,7 +2355,7 @@ async function runDownload(link, maxBytes, timeout) {
       result.set(chunk, offset);
       offset += chunk.byteLength;
     }
-    return ok(result.buffer);
+    return ok2(result.buffer);
   } finally {
     clearTimeout(timer);
   }
@@ -3078,23 +2367,23 @@ function sleepUntilAsync(f, timeout, interval = 20) {
   if (interval <= 0) {
     return errAsync(new VexInvalidArgumentError("interval must be positive"));
   }
-  return fromAsyncFn(() => runSleepUntilAsync(f, timeout, interval));
+  return new ResultAsync2(runSleepUntilAsync(f, timeout, interval));
 }
 async function runSleepUntilAsync(f, timeout, interval) {
   const deadline = Date.now() + timeout;
   while (Date.now() <= deadline) {
     try {
       if (await f())
-        return ok(true);
+        return ok2(true);
     } catch (e) {
-      return err(toVexSerialError(e, "io"));
+      return err2(toVexSerialError(e, "io"));
     }
     const remaining = deadline - Date.now();
     if (remaining <= 0)
       break;
     await sleepInner(Math.min(interval, remaining));
   }
-  return ok(false);
+  return ok2(false);
 }
 function sleepUntil(f, timeout, interval = 20) {
   if (timeout < 0) {
@@ -3103,33 +2392,86 @@ function sleepUntil(f, timeout, interval = 20) {
   if (interval <= 0) {
     return errAsync(new VexInvalidArgumentError("interval must be positive"));
   }
-  return fromAsyncFn(() => runSleepUntil(f, timeout, interval));
+  return new ResultAsync2(runSleepUntil(f, timeout, interval));
 }
 async function runSleepUntil(f, timeout, interval) {
   const deadline = Date.now() + timeout;
   while (Date.now() <= deadline) {
     try {
       if (f())
-        return ok(true);
+        return ok2(true);
     } catch (e) {
-      return err(toVexSerialError(e, "io"));
+      return err2(toVexSerialError(e, "io"));
     }
     const remaining = deadline - Date.now();
     if (remaining <= 0)
       break;
     await sleepInner(Math.min(interval, remaining));
   }
-  return ok(false);
+  return ok2(false);
 }
 function sleep(ms) {
   if (ms < 0) {
     return errAsync(new VexInvalidArgumentError("ms must be non-negative"));
   }
-  return ResultAsync.fromSafePromise(sleepInner(ms));
+  return ResultAsync2.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 err2(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.uploadFileToDeviceUnlocked(writeRequest, (c, t) => {
+    pcb(`UPLOAD ${label}`, c, t);
+  });
+  if (upload.isErr())
+    return err2(upload.error);
+  if (!upload.value) {
+    return err2(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 err2(statusReply.error);
+    reportFactoryStatus(label, statusReply.value, pcb);
+    if (statusReply.value.status === 0 && statusReply.value.percent === 100) {
+      return ok2(undefined);
+    }
+    await sleepInner(500);
+  }
+  return err2(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);
@@ -3177,13 +2519,13 @@ async function extractFirmwareImages(usingVersion, vexos) {
   return ordered;
 }
 function uploadFirmware(state, publicUrl = "https://content.vexrobotics.com/vexos/public/V5/", usingVersion, progressCallback) {
-  return fromAsyncFn(() => runUploadFirmware(state, publicUrl, usingVersion, progressCallback));
+  return new ResultAsync2(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 err(new VexNotConnectedError);
+    return err2(new VexNotConnectedError);
   }
   const pcb = progressCallback ?? (() => {});
   let version = usingVersion;
@@ -3193,20 +2535,20 @@ async function runUploadFirmware(state, publicUrl, usingVersion, progressCallbac
       maxBytes: MAX_CATALOG_BYTES
     });
     if (catalog.isErr())
-      return err(catalog.error);
+      return err2(catalog.error);
     version = new TextDecoder().decode(catalog.value).trim();
     pcb("FETCH CATALOG", 1, 1);
   }
   if (!/^[A-Za-z0-9._-]+$/.test(version)) {
-    return err(new VexFirmwareError(`invalid VEXos version: ${version}`));
+    return err2(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 err(vexosResult.error);
+    return err2(vexosResult.error);
   const vexos = vexosResult.value;
   if (vexos.byteLength === 0) {
-    return err(new VexFirmwareError("VEXos archive is empty"));
+    return err2(new VexFirmwareError("VEXos archive is empty"));
   }
   pcb("FETCH VEXOS", 1, 1);
   pcb("UNZIP VEXOS", 0, 1);
@@ -3215,189 +2557,104 @@ async function runUploadFirmware(state, publicUrl, usingVersion, progressCallbac
     images = await extractFirmwareImages(version, vexos);
   } catch (e) {
     if (e instanceof VexSerialError)
-      return err(e);
-    return err(toVexSerialError(e, "firmware"));
+      return err2(e);
+    return err2(toVexSerialError(e, "firmware"));
   }
   pcb("UNZIP VEXOS", 1, 1);
-  return state.withFileTransfer(async () => {
-    pcb("FACTORY ENB BOOT", 0, 0);
-    const result = await conn.writeDataAsync(new FactoryEnableH2DPacket);
-    if (!(result instanceof FactoryEnableReplyD2HPacket)) {
-      return err(new VexProtocolError("FactoryEnableH2DPacket failed"));
-    }
-    const boot = images.find((image) => image.name.endsWith("BOOT.bin"));
-    if (boot === undefined) {
-      return err(new VexFirmwareError("VEXos archive is missing BOOT.bin"));
-    }
-    const assertImage = images.find((image) => image.name.endsWith("assets.bin"));
-    if (assertImage === undefined) {
-      return err(new VexFirmwareError("VEXos archive is missing assets.bin"));
-    }
-    const bootWriteRequest = {
-      filename: "null.bin",
-      vendor: 1 /* USER */,
-      loadAddress: USER_FLASH_USR_CODE_START,
-      buf: boot.buf,
-      downloadTarget: 14 /* FILE_TARGET_B1 */,
-      exttype: "bin",
-      autoRun: true,
-      linkedFile: undefined
-    };
-    const bootUpload = await conn.uploadFileToDevice(bootWriteRequest, (c, t) => {
-      pcb("UPLOAD BOOT", c, t);
-    });
-    if (bootUpload.isErr())
-      return err(bootUpload.error);
-    if (!bootUpload.value)
-      return ok(false);
-    const bootDeadline = Date.now() + 120000;
-    let bootComplete = false;
-    while (Date.now() < bootDeadline) {
-      const result3 = await conn.writeDataAsync(new FactoryStatusH2DPacket, 1e4);
-      if (result3 instanceof FactoryStatusReplyD2HPacket) {
-        switch (result3.status) {
-          case 2:
-            pcb("ERASE BOOT", result3.percent, 100);
-            break;
-          case 3:
-            pcb("WRITE BOOT", result3.percent, 100);
-            break;
-          case 4:
-            pcb("VERIFY BOOT", result3.percent, 100);
-            break;
-          case 8:
-            pcb("FINISHING BOOT", result3.percent, 100);
-            break;
-        }
-        if (result3.status === 0 && result3.percent === 100) {
-          bootComplete = true;
-          break;
-        }
-      } else {
-        return ok(false);
-      }
-      await sleepInner(500);
-    }
-    if (!bootComplete)
-      return ok(false);
-    pcb("FACTORY ENB ASSERT", 0, 0);
-    const result5 = await conn.writeDataAsync(new FactoryEnableH2DPacket);
-    if (!(result5 instanceof FactoryEnableReplyD2HPacket)) {
-      return err(new VexProtocolError("FactoryEnableH2DPacket failed"));
-    }
-    const assertWriteRequest = {
-      filename: "null.bin",
-      vendor: 1 /* USER */,
-      loadAddress: USER_FLASH_USR_CODE_START,
-      buf: assertImage.buf,
-      downloadTarget: 13 /* FILE_TARGET_A1 */,
-      exttype: "bin",
-      autoRun: true,
-      linkedFile: undefined
-    };
-    const assertUpload = await conn.uploadFileToDevice(assertWriteRequest, (c, t) => {
-      pcb("UPLOAD ASSERT", c, t);
-    });
-    if (assertUpload.isErr())
-      return err(assertUpload.error);
-    if (!assertUpload.value)
-      return ok(false);
-    const assertDeadline = Date.now() + 120000;
-    let assertComplete = false;
-    while (Date.now() < assertDeadline) {
-      const result7 = await conn.writeDataAsync(new FactoryStatusH2DPacket, 1e4);
-      if (result7 instanceof FactoryStatusReplyD2HPacket) {
-        switch (result7.status) {
-          case 2:
-            pcb("ERASE ASSERT", result7.percent, 100);
-            break;
-          case 3:
-            pcb("WRITE ASSERT", result7.percent, 100);
-            break;
-          case 4:
-            pcb("VERIFY ASSERT", result7.percent, 100);
-            break;
-          case 8:
-            pcb("FINISHING ASSERT", result7.percent, 100);
-            break;
+  return state.withRefreshPaused(async () => {
+    try {
+      return await conn.withFileTransfer(async () => {
+        const boot = images.find((image) => image.name.endsWith("BOOT.bin"));
+        if (boot === undefined) {
+          return err2(new VexFirmwareError("VEXos archive is missing BOOT.bin"));
         }
-        if (result7.status === 0 && result7.percent === 100) {
-          assertComplete = true;
-          break;
+        const assertImage = images.find((image) => image.name.endsWith("assets.bin"));
+        if (assertImage === undefined) {
+          return err2(new VexFirmwareError("VEXos archive is missing assets.bin"));
         }
-      } else {
-        return ok(false);
-      }
-      await sleepInner(500);
+        const bootFlash = await flashFactoryImage(conn, {
+          image: boot,
+          label: "BOOT",
+          downloadTarget: 14 /* FILE_TARGET_B1 */
+        }, pcb);
+        if (bootFlash.isErr())
+          return err2(bootFlash.error);
+        const assetsFlash = await flashFactoryImage(conn, {
+          image: assertImage,
+          label: "ASSETS",
+          downloadTarget: 13 /* FILE_TARGET_A1 */
+        }, pcb);
+        if (assetsFlash.isErr())
+          return err2(assetsFlash.error);
+        return ok2(true);
+      });
+    } catch (e) {
+      return err2(toVexSerialError(e, "firmware"));
     }
-    if (!assertComplete)
-      return ok(false);
-    return ok(true);
   });
 }
 
 // src/VexTransfers.ts
+import { err as err3, ok as ok3, ResultAsync as ResultAsync3 } from "neverthrow";
 function getValue(state, key) {
-  return new ResultAsync((async () => {
+  return new ResultAsync3((async () => {
     const conn = state._instance.connection;
     if (conn == null || !conn.isConnected) {
-      return err(new VexNotConnectedError);
+      return err3(new VexNotConnectedError);
     }
-    const result = await conn.writeDataAsync(new ReadKeyValueH2DPacket(key));
-    return result instanceof ReadKeyValueReplyD2HPacket ? ok(result.value) : err(new VexProtocolError("getValue was not acknowledged"));
+    return conn.request(new ReadKeyValueH2DPacket(key), ReadKeyValueReplyD2HPacket).map((result) => result.value);
   })());
 }
 function setValue(state, key, value) {
-  return new ResultAsync((async () => {
+  return new ResultAsync3((async () => {
     const conn = state._instance.connection;
     if (conn == null || !conn.isConnected) {
-      return err(new VexNotConnectedError);
+      return err3(new VexNotConnectedError);
     }
-    const result = await conn.writeDataAsync(new WriteKeyValueH2DPacket(key, value));
-    return result instanceof WriteKeyValueReplyD2HPacket ? ok(undefined) : err(new VexProtocolError("setValue was not acknowledged"));
+    return conn.request(new WriteKeyValueH2DPacket(key, value), WriteKeyValueReplyD2HPacket).map(() => {
+      return;
+    });
   })());
 }
 function listFiles(state, vendor = 1 /* USER */) {
-  return new ResultAsync((async () => {
+  return new ResultAsync3((async () => {
     const conn = state._instance.connection;
     if (conn == null || !conn.isConnected) {
-      return err(new VexNotConnectedError);
-    }
-    const result = await conn.writeDataAsync(new GetDirectoryFileCountH2DPacket(vendor));
-    if (!(result instanceof GetDirectoryFileCountReplyD2HPacket)) {
-      return err(new VexProtocolError("directory file count was not acknowledged"));
+      return err3(new VexNotConnectedError);
     }
+    const countResult = await conn.request(new GetDirectoryFileCountH2DPacket(vendor), GetDirectoryFileCountReplyD2HPacket);
+    if (countResult.isErr())
+      return err3(countResult.error);
     const files = [];
-    for (let i = 0;i < result.count; i++) {
-      const result2 = await conn.writeDataAsync(new GetDirectoryEntryH2DPacket(i));
-      if (!(result2 instanceof GetDirectoryEntryReplyD2HPacket)) {
-        return err(new VexProtocolError("directory entry was not acknowledged"));
-      }
-      if (result2.file != null) {
+    for (let i = 0;i < countResult.value.count; i++) {
+      const entryResult = await conn.request(new GetDirectoryEntryH2DPacket(i), GetDirectoryEntryReplyD2HPacket);
+      if (entryResult.isErr())
+        return err3(entryResult.error);
+      if (entryResult.value.file != null) {
         files.push({
-          filename: result2.file.filename,
+          filename: entryResult.value.file.filename,
           vendor,
-          loadAddress: result2.file.loadAddress,
-          size: result2.file.size,
-          crc32: result2.file.crc32,
-          type: result2.file.type,
-          timestamp: result2.file.timestamp,
-          version: result2.file.version
+          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 ok(files);
+    return ok3(files);
   })());
 }
 function listProgram(state) {
-  return new ResultAsync((async () => {
+  return new ResultAsync3((async () => {
     const conn = state._instance.connection;
     if (conn == null || !conn.isConnected) {
-      return err(new VexNotConnectedError);
+      return err3(new VexNotConnectedError);
     }
     const files = await listFiles(state, 1 /* USER */);
     if (files.isErr())
-      return err(files.error);
+      return err3(files.error);
     const programList = [];
     const iniFiles = files.value.filter((file) => file.filename.endsWith(".ini"));
     for (let i = 0;i < iniFiles.length; i++) {
@@ -3418,21 +2675,21 @@ function listProgram(state) {
         time: n,
         requestedSlot: -1
       };
-      const result2 = await conn.writeDataAsync(new GetProgramSlotInfoH2DPacket(1 /* USER */, program.binfile));
-      if (result2 instanceof GetProgramSlotInfoReplyD2HPacket) {
-        program.slot = result2.slot;
-        program.requestedSlot = result2.requestedSlot;
+      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 ok(programList);
+    return ok3(programList);
   })());
 }
 function readFile(state, request, downloadTarget = 1 /* FILE_TARGET_QSPI */, progressCallback) {
-  return new ResultAsync((async () => {
+  return new ResultAsync3((async () => {
     const conn = state._instance.connection;
     if (conn == null || !conn.isConnected) {
-      return err(new VexNotConnectedError);
+      return err3(new VexNotConnectedError);
     }
     let handle;
     if (typeof request === "string") {
@@ -3440,83 +2697,83 @@ function readFile(state, request, downloadTarget = 1 /* FILE_TARGET_QSPI */, pro
     } else {
       handle = request;
     }
-    return state.withFileTransfer(() => conn.downloadFileToHost(handle, downloadTarget, progressCallback));
+    return state.withRefreshPaused(() => conn.downloadFileToHost(handle, downloadTarget, progressCallback));
   })());
 }
 function removeFile(state, request) {
-  return new ResultAsync((async () => {
+  return new ResultAsync3((async () => {
     const conn = state._instance.connection;
     if (conn == null || !conn.isConnected) {
-      return err(new VexNotConnectedError);
+      return err3(new VexNotConnectedError);
     }
-    return state.withFileTransfer(() => conn.removeFile(request));
+    return state.withRefreshPaused(() => conn.removeFile(request));
   })());
 }
 function removeAllFiles(state) {
-  return new ResultAsync((async () => {
+  return new ResultAsync3((async () => {
     const conn = state._instance.connection;
     if (conn == null || !conn.isConnected) {
-      return err(new VexNotConnectedError);
+      return err3(new VexNotConnectedError);
     }
-    return state.withFileTransfer(() => conn.removeAllFiles());
+    return state.withRefreshPaused(() => conn.removeAllFiles());
   })());
 }
 function uploadProgram(state, iniConfig, binFileBuf, coldFileBuf, progressCallback) {
-  return new ResultAsync(runUploadProgram(state, iniConfig, binFileBuf, coldFileBuf, progressCallback));
+  return new ResultAsync3(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 err(new VexNotConnectedError);
+    return err3(new VexNotConnectedError);
   }
   let switchedToDownload = false;
-  return state.withFileTransfer(async () => {
+  return state.withRefreshPaused(async () => {
     try {
       if (device.isV5Controller) {
         await sleep(250);
         const refreshed = await device.refresh();
         if (refreshed.isErr() || !refreshed.value) {
-          return err(new VexProtocolError("device is unavailable"));
+          return err3(new VexProtocolError("device is unavailable"));
         }
         progressCallback("CHANNEL", 0, 1);
         const p1 = await device.radio.changeChannel(1 /* DOWNLOAD */);
         if (p1.isErr())
-          return err(p1.error);
+          return err3(p1.error);
         switchedToDownload = true;
         await sleep(250);
         const transferred = await sleepUntilAsync(async () => (await conn?.getSystemStatus(150))?.isOk() ?? false, 1e4, 200);
         if (transferred.isErr())
-          return err(transferred.error);
+          return err3(transferred.error);
         if (!transferred.value) {
-          return err(new VexProtocolError("channel switch timed out"));
+          return err3(new VexProtocolError("channel switch timed out"));
         }
         progressCallback("CHANNEL", 1, 1);
       }
       const p2 = await conn.uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback);
       if (p2.isErr())
-        return err(p2.error);
+        return err3(p2.error);
       if (!p2.value)
-        return err(new VexProtocolError("program upload rejected"));
+        return err3(new VexProtocolError("program upload rejected"));
       if (device.isV5Controller) {
         if (!device.brain.isAvailable) {
-          return err(new VexProtocolError("brain unavailable after upload"));
+          return err3(new VexProtocolError("brain unavailable after upload"));
         }
         progressCallback("CHANNEL", 0, 1);
         const p3 = await device.radio.changeChannel(0 /* PIT */);
         if (p3.isErr())
-          return err(p3.error);
+          return err3(p3.error);
         switchedToDownload = false;
         await sleep(250);
         const transferred = await sleepUntilAsync(async () => (await conn?.getSystemStatus(150))?.isOk() ?? false, 1e4, 200);
         if (transferred.isErr())
-          return err(transferred.error);
+          return err3(transferred.error);
         if (!transferred.value) {
-          return err(new VexProtocolError("channel switch timed out"));
+          return err3(new VexProtocolError("channel switch timed out"));
         }
         progressCallback("CHANNEL", 1, 1);
       }
-      return ok(true);
+      return ok3(true);
     } finally {
       if (switchedToDownload) {
         await device.radio.changeChannel(0 /* PIT */);
@@ -3525,21 +2782,21 @@ async function runUploadProgram(state, iniConfig, binFileBuf, coldFileBuf, progr
   });
 }
 function writeFile(state, request, progressCallback) {
-  return new ResultAsync((async () => {
+  return new ResultAsync3((async () => {
     const conn = state._instance.connection;
     if (conn == null || !conn.isConnected) {
-      return err(new VexNotConnectedError);
+      return err3(new VexNotConnectedError);
     }
-    return state.withFileTransfer(() => conn.uploadFileToDevice(request, progressCallback));
+    return state.withRefreshPaused(() => conn.uploadFileToDevice(request, progressCallback));
   })());
 }
 function captureScreen(state, progressCallback) {
-  return new ResultAsync((async () => {
+  return new ResultAsync3((async () => {
     const conn = state._instance.connection;
     if (conn == null || !conn.isConnected) {
-      return err(new VexNotConnectedError);
+      return err3(new VexNotConnectedError);
     }
-    return state.withFileTransfer(() => conn.captureScreen(progressCallback));
+    return state.withRefreshPaused(() => conn.captureScreen(progressCallback));
   })());
 }
 
@@ -3562,10 +2819,13 @@ class VexSerialDevice extends VexEventTarget {
 class V5SerialDeviceState {
   _instance;
   refreshPauseDepth = 0;
-  get isFileTransferring() {
+  get isRefreshPaused() {
     return this.refreshPauseDepth > 0;
   }
-  async withFileTransfer(operation) {
+  get isFileTransferring() {
+    return this.isRefreshPaused;
+  }
+  async withRefreshPaused(operation) {
     this.refreshPauseDepth++;
     try {
       return await operation();
@@ -3573,6 +2833,9 @@ class V5SerialDeviceState {
       this.refreshPauseDepth--;
     }
   }
+  async withFileTransfer(operation) {
+    return this.withRefreshPaused(operation);
+  }
   brain = {
     activeProgram: 0,
     battery: {
@@ -3602,7 +2865,8 @@ class V5SerialDeviceState {
     },
     {
       battery: 0,
-      isAvailable: false
+      isAvailable: false,
+      isCharging: false
     }
   ];
   devices = [];
@@ -3625,8 +2889,14 @@ class V5SerialDeviceState {
 
 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;
@@ -3638,50 +2908,49 @@ class V5Brain {
     this.setActiveProgram(value).mapErr(() => {});
   }
   setActiveProgram(value) {
-    return new ResultAsync((async () => {
+    return new ResultAsync4((async () => {
       if (this.state.brain.activeProgram === value)
-        return ok(undefined);
+        return ok4(undefined);
       const conn = this.state._instance.connection;
       if (conn == null)
-        return err(new VexNotConnectedError);
+        return err4(new VexNotConnectedError);
       const result = value === 0 ? await conn.stopProgram() : await conn.loadProgram(value);
       if (result.isErr())
-        return err(result.error);
+        return err4(result.error);
       this.state.brain.activeProgram = value;
-      return ok(undefined);
+      return ok4(undefined);
     })());
   }
   runProgram(slot) {
-    return new ResultAsync((async () => {
+    return new ResultAsync4((async () => {
       const conn = this.state._instance.connection;
       if (conn == null)
-        return err(new VexNotConnectedError);
+        return err4(new VexNotConnectedError);
       const reply = await conn.runProgram(slot);
       if (reply.isErr())
-        return err(reply.error);
-      const slotNumber = typeof slot === "string" ? Number.parseInt(slot, 10) : slot;
-      if (Number.isFinite(slotNumber))
-        this.state.brain.activeProgram = slotNumber;
-      return ok(undefined);
+        return err4(reply.error);
+      if (typeof slot === "number")
+        this.state.brain.activeProgram = slot;
+      return ok4(undefined);
     })());
   }
   stopProgram() {
-    return new ResultAsync((async () => {
+    return new ResultAsync4((async () => {
       const conn = this.state._instance.connection;
       if (conn == null)
-        return err(new VexNotConnectedError);
+        return err4(new VexNotConnectedError);
       const reply = await conn.stopProgram();
       if (reply.isErr())
-        return err(reply.error);
+        return err4(reply.error);
       this.state.brain.activeProgram = 0;
-      return ok(undefined);
+      return ok4(undefined);
     })());
   }
   get battery() {
-    return new V5Battery(this.state);
+    return this.batteryFacade;
   }
   get button() {
-    return new V5BrainButton(this.state);
+    return this.buttonFacade;
   }
   get cpu0Version() {
     return this.state.brain.cpu0Version;
@@ -3693,7 +2962,7 @@ class V5Brain {
     return this.state.brain.isAvailable;
   }
   get settings() {
-    return new V5BrainSettings(this.state);
+    return this.settingsFacade;
   }
   get systemVersion() {
     return this.state.brain.systemVersion;
@@ -3847,66 +3116,145 @@ class V5Radio {
     return this.state.radio.latency;
   }
   changeChannel(channel) {
-    return new ResultAsync((async () => {
-      const result = await this.state._instance.connection?.writeDataAsync(new FileControlH2DPacket(1, channel));
-      return result instanceof FileControlReplyD2HPacket ? ok(undefined) : err(new VexProtocolError("changeChannel was not acknowledged"));
+    return new ResultAsync4((async () => {
+      const conn = this.state._instance.connection;
+      if (conn == null || !conn.isConnected) {
+        return err4(new VexNotConnectedError);
+      }
+      return conn.request(new FileControlH2DPacket(1, channel), FileControlReplyD2HPacket).map(() => {
+        return;
+      });
     })());
   }
 }
 
 // src/VexDevice.ts
+import { err as err5, ok as ok5, ResultAsync as ResultAsync5 } from "neverthrow";
+function unrefTimerIfPossible(timer) {
+  if (typeof timer !== "object" || timer === null || !("unref" in timer))
+    return;
+  const unref = timer.unref;
+  if (typeof unref === "function")
+    unref.call(timer);
+}
+function describePort(port) {
+  const info = port.getInfo();
+  const identifier = info.path ?? info.id ?? info.serialNumber;
+  return typeof identifier === "string" ? identifier : undefined;
+}
+
 class V5SerialDevice extends VexSerialDevice {
   autoReconnect = true;
-  autoRefresh = true;
   pauseRefreshOnFileTransfer = true;
   _isReconnecting = false;
   _isDisconnecting = false;
   _refreshInterval;
   state = new V5SerialDeviceState(this);
   _disposed = false;
+  _lifecycleGeneration = 0;
+  _disconnectListener;
   _refreshGeneration = 0;
-  constructor(defaultSerial) {
+  _autoRefresh = false;
+  _refreshIntervalMs = 200;
+  _isLastRefreshComplete = true;
+  _brain = new V5Brain(this.state);
+  _controllers = [
+    new V5Controller(this.state, 0),
+    new V5Controller(this.state, 1)
+  ];
+  _radio = new V5Radio(this.state);
+  _deviceFacades = [];
+  _emitSafely(eventName, data) {
+    try {
+      this.emit(eventName, data);
+    } catch {}
+  }
+  constructor(defaultSerial, options = false) {
     super(defaultSerial);
-    let isLastRefreshComplete = true;
+    const autoRefresh = typeof options === "boolean" ? options : options.autoRefresh ?? false;
+    this.refreshIntervalMs = typeof options === "boolean" ? 200 : options.refreshIntervalMs ?? 200;
+    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();
+    }
+  }
+  get refreshIntervalMs() {
+    return this._refreshIntervalMs;
+  }
+  set refreshIntervalMs(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new VexInvalidArgumentError("refreshIntervalMs must be a positive finite number");
+    }
+    if (this._refreshIntervalMs === value)
+      return;
+    this._refreshIntervalMs = value;
+    if (this._refreshInterval !== undefined) {
+      this._stopRefreshInterval();
+      this._startRefreshInterval();
+    }
+  }
+  _startRefreshInterval() {
+    if (this._refreshInterval !== undefined || this._disposed)
+      return;
     this._refreshInterval = setInterval(() => {
       if (this._disposed)
         return;
-      if (this.autoRefresh && isLastRefreshComplete) {
+      if (this._autoRefresh && this._isLastRefreshComplete) {
         if (!this.isConnected) {
           this.state.brain.isAvailable = false;
           return;
         }
-        if (!this.pauseRefreshOnFileTransfer || !this.state.isFileTransferring) {
-          isLastRefreshComplete = false;
+        if (!this.pauseRefreshOnFileTransfer || !this.state.isRefreshPaused) {
+          this._isLastRefreshComplete = false;
           (async () => {
             try {
               const r = await this.refresh();
               if (r.isErr())
-                this.emit("error", r.error);
+                this._emitSafely("error", r.error);
             } catch (error) {
-              this.emit("error", error);
+              this._emitSafely("error", error);
             } finally {
-              isLastRefreshComplete = true;
+              this._isLastRefreshComplete = true;
             }
           })();
         }
       }
-    }, 200);
+    }, this._refreshIntervalMs);
+    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 new V5Brain(this.state);
+    return this._brain;
   }
   get controllers() {
-    return [new V5Controller(this.state, 0), new V5Controller(this.state, 1)];
+    return this._controllers;
   }
   get devices() {
     const rtn = [];
-    for (let i = 1;i <= this.state.devices.length; i++) {
-      if (this.state.devices[i] != null)
-        rtn.push(new V5SmartDevice(this.state, i));
+    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;
   }
@@ -3920,82 +3268,149 @@ class V5SerialDevice extends VexSerialDevice {
     this.setMatchMode(value).mapErr(() => {});
   }
   setMatchMode(mode) {
-    return new ResultAsync((async () => {
+    return new ResultAsync5((async () => {
       const reply = await this.connection?.setMatchMode(mode);
       if (reply === undefined)
-        return err(new VexNotConnectedError);
+        return err5(new VexNotConnectedError);
       if (reply.isErr())
-        return err(reply.error);
+        return err5(reply.error);
       this.state.matchMode = mode;
-      return ok(undefined);
+      return ok5(undefined);
     })());
   }
   get radio() {
-    return new V5Radio(this.state);
+    return this._radio;
   }
   mockTouch(x, y, press) {
-    return new ResultAsync((async () => {
+    return new ResultAsync5((async () => {
       const reply = await this.connection?.mockTouch(x, y, press);
       if (reply === undefined)
-        return err(new VexNotConnectedError);
+        return err5(new VexNotConnectedError);
       if (reply.isErr())
-        return err(reply.error);
-      return ok(undefined);
+        return err5(reply.error);
+      return ok5(undefined);
     })());
   }
   connect(conn) {
-    return new ResultAsync(this._connect(conn));
+    if (this._disposed) {
+      return new ResultAsync5(Promise.resolve(this._staleLifecycleResult()));
+    }
+    if (this.isConnected)
+      return new ResultAsync5(Promise.resolve(ok5(undefined)));
+    const generation = ++this._lifecycleGeneration;
+    return new ResultAsync5(this._connect(conn, generation));
   }
-  async _connect(conn) {
+  async _connect(conn, generation = this._lifecycleGeneration) {
+    if (!this._isLifecycleCurrent(generation)) {
+      return this._staleLifecycleResult();
+    }
     if (this.isConnected)
-      return ok(undefined);
+      return ok5(undefined);
     if (conn != null) {
       if (!conn.isConnected) {
         const opened = await conn.open();
-        if (opened.isErr() || opened.value !== true) {
-          return err(new VexIoError("failed to open the supplied connection"));
+        if (!this._isLifecycleCurrent(generation)) {
+          await conn.close();
+          return this._staleLifecycleResult();
+        }
+        if (opened.isErr() || opened.value !== "opened") {
+          return err5(new VexIoError("failed to open the supplied connection"));
         }
       }
       const q = await conn.query1();
+      if (!this._isLifecycleCurrent(generation)) {
+        await conn.close();
+        return this._staleLifecycleResult();
+      }
       if (q.isErr()) {
         await conn.close();
-        return err(q.error);
+        return err5(q.error);
+      }
+      if (!this._commitConnection(conn, generation)) {
+        await conn.close();
+        return this._staleLifecycleResult();
       }
-      this.connection = conn;
     } else {
       let tryIdx = 0;
+      let canRequestPort = true;
+      const attemptedPorts = new Set;
+      const attemptedPortNames = [];
       while (true) {
-        const c = new V5SerialConnection(this.defaultSerial);
-        const result = await c.open(tryIdx++, true);
+        if (!this._isLifecycleCurrent(generation)) {
+          return this._staleLifecycleResult();
+        }
+        const c = this.createConnection();
+        let result = await c.open(tryIdx++, false);
+        if (!this._isLifecycleCurrent(generation)) {
+          await c.close();
+          return this._staleLifecycleResult();
+        }
+        if (result.isOk() && result.value === "no-port" && canRequestPort) {
+          canRequestPort = false;
+          result = await c.open(tryIdx, true);
+          if (!this._isLifecycleCurrent(generation)) {
+            await c.close();
+            return this._staleLifecycleResult();
+          }
+        }
         if (result.isErr()) {
           await c.close();
-          return err(result.error);
+          return err5(result.error);
         }
-        if (result.value === undefined) {
-          return err(new VexNotConnectedError("no V5 device was found"));
+        if (result.value === "no-port") {
+          const attempted = attemptedPortNames.length ? `; attempted ${attemptedPortNames.join(", ")}` : "";
+          return err5(new VexNotConnectedError(`no responsive V5 device was found${attempted}`));
         }
-        if (!result.value) {
+        if (result.value === "busy") {
           await c.close();
-          continue;
+          return err5(new VexNotConnectedError("the selected V5 serial port is busy"));
+        }
+        const port = c.port;
+        if (port !== undefined && attemptedPorts.has(port)) {
+          await c.close();
+          const portName = describePort(port);
+          return err5(new VexNotConnectedError(portName === undefined ? "the selected serial port did not respond as a V5 device" : `serial port ${portName} did not respond as a V5 device`));
+        }
+        if (port !== undefined) {
+          attemptedPorts.add(port);
+          const portName = describePort(port);
+          if (portName !== undefined)
+            attemptedPortNames.push(portName);
         }
         const q = await c.query1();
+        if (!this._isLifecycleCurrent(generation)) {
+          await c.close();
+          return this._staleLifecycleResult();
+        }
         if (q.isErr()) {
           await c.close();
           continue;
         }
-        this.connection = c;
+        if (!this._commitConnection(c, generation)) {
+          await c.close();
+          return this._staleLifecycleResult();
+        }
         break;
       }
     }
-    if (!this.isConnected)
-      return err(new VexNotConnectedError);
-    await this.doAfterConnect();
-    return ok(undefined);
+    const connection = this.connection;
+    if (!this._isLifecycleCurrent(generation) || connection == null) {
+      return this._staleLifecycleResult();
+    }
+    if (!connection.isConnected)
+      return err5(new VexNotConnectedError);
+    const initialized = await this.doAfterConnect(connection, generation);
+    if (initialized.isErr())
+      return initialized;
+    return ok5(undefined);
   }
   async disconnect() {
+    this._lifecycleGeneration++;
+    this._refreshGeneration++;
     this._isDisconnecting = true;
     const connection = this.connection;
     this.connection = undefined;
+    this._detachDisconnectListener();
     try {
       await connection?.close();
     } finally {
@@ -4006,20 +3421,28 @@ class V5SerialDevice extends VexSerialDevice {
     this.autoReconnect = false;
     this.autoRefresh = false;
     this._disposed = true;
-    if (this._refreshInterval !== undefined) {
-      clearInterval(this._refreshInterval);
-      this._refreshInterval = undefined;
-    }
     await this.disconnect();
   }
   reconnect(timeout = 0) {
-    return new ResultAsync(this._reconnect(timeout));
+    if (this._disposed) {
+      return new ResultAsync5(Promise.resolve(this._staleLifecycleResult()));
+    }
+    if (timeout < 0) {
+      return new ResultAsync5(Promise.resolve(err5(new VexInvalidArgumentError("timeout must be non-negative"))));
+    }
+    if (this.isConnected)
+      return new ResultAsync5(Promise.resolve(ok5(undefined)));
+    const generation = this._isReconnecting ? this._lifecycleGeneration : ++this._lifecycleGeneration;
+    return new ResultAsync5(this._reconnect(timeout, generation));
   }
-  async _reconnect(timeout) {
+  async _reconnect(timeout, generation = this._lifecycleGeneration) {
+    if (!this._isLifecycleCurrent(generation)) {
+      return this._staleLifecycleResult();
+    }
     if (this.isConnected)
-      return ok(undefined);
+      return ok5(undefined);
     if (timeout < 0) {
-      return err(new VexInvalidArgumentError("timeout must be non-negative"));
+      return err5(new VexInvalidArgumentError("timeout must be non-negative"));
     }
     const endTime = Date.now() + timeout;
     if (this._isReconnecting) {
@@ -4028,30 +3451,44 @@ class V5SerialDevice extends VexSerialDevice {
       } else {
         const waited = await sleepUntil(() => !this._isReconnecting, timeout);
         if (waited.isErr() || !waited.value) {
-          return err(new VexNotConnectedError);
+          return err5(new VexNotConnectedError);
         }
       }
+      if (!this._isLifecycleCurrent(generation)) {
+        return this._staleLifecycleResult();
+      }
       if (this.isConnected)
-        return ok(undefined);
+        return ok5(undefined);
     }
     this._isReconnecting = true;
     try {
       while (timeout === 0 || Date.now() < endTime) {
         let tryIdx = 0;
         while (true) {
-          const c = new V5SerialConnection(this.defaultSerial);
+          if (!this._isLifecycleCurrent(generation)) {
+            return this._staleLifecycleResult();
+          }
+          const c = this.createConnection();
           const result = await c.open(tryIdx++, false);
+          if (!this._isLifecycleCurrent(generation)) {
+            await c.close();
+            return this._staleLifecycleResult();
+          }
           if (result.isErr()) {
             await c.close();
-            return err(result.error);
+            return err5(result.error);
           }
-          if (result.value === undefined)
+          if (result.value === "no-port")
             break;
-          if (!result.value) {
+          if (result.value === "busy") {
             await c.close();
             continue;
           }
           const status = await c.getSystemStatus(200);
+          if (!this._isLifecycleCurrent(generation)) {
+            await c.close();
+            return this._staleLifecycleResult();
+          }
           if (status.isErr()) {
             await c.close();
             continue;
@@ -4060,24 +3497,39 @@ class V5SerialDevice extends VexSerialDevice {
             await c.close();
             continue;
           }
-          this.connection = c;
+          if (!this._commitConnection(c, generation)) {
+            await c.close();
+            return this._staleLifecycleResult();
+          }
           break;
         }
         if (this.isConnected)
           break;
         const getPortCount = async () => (await this.defaultSerial.getPorts()).length;
         const portsCount = await getPortCount();
+        if (!this._isLifecycleCurrent(generation)) {
+          return this._staleLifecycleResult();
+        }
         await sleepUntilAsync(async () => await getPortCount() !== portsCount, 1000);
+        if (!this._isLifecycleCurrent(generation)) {
+          return this._staleLifecycleResult();
+        }
       }
     } catch (e) {
-      return err(toVexSerialError(e));
+      return err5(toVexSerialError(e));
     } finally {
       this._isReconnecting = false;
     }
-    if (!this.isConnected)
-      return err(new VexNotConnectedError);
-    await this.doAfterConnect();
-    return ok(undefined);
+    const connection = this.connection;
+    if (!this._isLifecycleCurrent(generation) || connection == null) {
+      return this._staleLifecycleResult();
+    }
+    if (!connection.isConnected)
+      return err5(new VexNotConnectedError);
+    const initialized = await this.doAfterConnect(connection, generation);
+    if (initialized.isErr())
+      return initialized;
+    return ok5(undefined);
   }
   async waitForReconnectToFinish() {
     while (this._isReconnecting) {
@@ -4086,58 +3538,96 @@ class V5SerialDevice extends VexSerialDevice {
         return;
     }
   }
-  async doAfterConnect() {
-    if (this.connection == null)
-      return;
-    this.connection.on("disconnected", (_data) => {
-      if (this.autoReconnect && !this._isDisconnecting) {
-        this.reconnect().mapErr((e) => this.emit("error", e));
+  createConnection() {
+    return new V5SerialConnection(this.defaultSerial);
+  }
+  _isLifecycleCurrent(generation) {
+    return generation === this._lifecycleGeneration && !this._disposed;
+  }
+  _staleLifecycleResult() {
+    return err5(new VexNotConnectedError("connection attempt was superseded"));
+  }
+  _commitConnection(connection, generation) {
+    if (!this._isLifecycleCurrent(generation))
+      return false;
+    this._detachDisconnectListener();
+    this.connection = connection;
+    return true;
+  }
+  _detachDisconnectListener() {
+    const subscription = this._disconnectListener;
+    this._disconnectListener = undefined;
+    subscription?.connection.remove("disconnected", subscription.listener);
+  }
+  async doAfterConnect(connection, generation) {
+    if (!this._isLifecycleCurrent(generation) || this.connection !== connection) {
+      return this._staleLifecycleResult();
+    }
+    const listener = () => {
+      if (this._isDisconnecting || !this._isLifecycleCurrent(generation) || this.connection !== connection) {
+        return;
       }
-    });
-    await this.refresh();
+      this._lifecycleGeneration++;
+      this._refreshGeneration++;
+      this.connection = undefined;
+      this._detachDisconnectListener();
+      this._emitSafely("disconnected", undefined);
+      if (this.autoReconnect && !this._disposed) {
+        this.reconnect().mapErr((error) => this._emitSafely("error", error));
+      }
+    };
+    connection.on("disconnected", listener);
+    this._disconnectListener = { connection, listener };
+    const refreshed = await this.refresh();
+    if (!this._isLifecycleCurrent(generation) || this.connection !== connection || !connection.isConnected) {
+      return this._staleLifecycleResult();
+    }
+    if (refreshed.isErr()) {
+      await this._discardConnection(connection, generation);
+      return err5(refreshed.error);
+    }
+    if (!refreshed.value) {
+      await this._discardConnection(connection, generation);
+      return err5(new VexNotConnectedError("initial device refresh did not produce a current snapshot"));
+    }
+    return ok5(undefined);
+  }
+  async _discardConnection(connection, generation) {
+    if (!this._isLifecycleCurrent(generation) || this.connection !== connection) {
+      return;
+    }
+    this._lifecycleGeneration++;
+    this._refreshGeneration++;
+    this.connection = undefined;
+    this._detachDisconnectListener();
+    await connection.close();
   }
   refresh() {
-    return new ResultAsync(this._refresh());
+    return new ResultAsync5(this._refresh());
   }
   async _refresh() {
     if (this._disposed)
-      return ok(false);
+      return ok5(false);
     const generation = ++this._refreshGeneration;
     const conn = this.connection;
     if (conn == null || !conn.isConnected) {
       this._applySnapshotIfCurrent(generation, { isAvailable: false });
-      return ok(false);
-    }
-    const ssPacket = await conn.getSystemStatus();
-    if (generation !== this._refreshGeneration || this._disposed)
-      return ok(false);
-    if (ssPacket.isErr()) {
-      this._applySnapshotIfCurrent(generation, { isAvailable: false });
-      return ok(false);
-    }
-    const sfPacket = await conn.getSystemFlags();
-    if (generation !== this._refreshGeneration || this._disposed)
-      return ok(false);
-    if (sfPacket.isErr()) {
-      this._applySnapshotIfCurrent(generation, { isAvailable: false });
-      return ok(false);
-    }
-    const rdPacket = await conn.getRadioStatus();
-    if (generation !== this._refreshGeneration || this._disposed)
-      return ok(false);
-    if (rdPacket.isErr()) {
-      this._applySnapshotIfCurrent(generation, { isAvailable: false });
-      return ok(false);
-    }
-    const dsPacket = await conn.getDeviceStatus();
+      return ok5(false);
+    }
+    const [ssPacket, sfPacket, rdPacket, dsPacket] = await Promise.all([
+      conn.getSystemStatus(),
+      conn.getSystemFlags(),
+      conn.getRadioStatus(),
+      conn.getDeviceStatus()
+    ]);
     if (generation !== this._refreshGeneration || this._disposed)
-      return ok(false);
-    if (dsPacket.isErr()) {
+      return ok5(false);
+    if (ssPacket.isErr() || sfPacket.isErr() || rdPacket.isErr() || dsPacket.isErr()) {
       this._applySnapshotIfCurrent(generation, { isAvailable: false });
-      return ok(false);
+      return ok5(false);
     }
     const snapshot = this._buildSnapshot(ssPacket.value, sfPacket.value, rdPacket.value, dsPacket.value);
-    return ok(this._applySnapshotIfCurrent(generation, snapshot));
+    return ok5(this._applySnapshotIfCurrent(generation, snapshot));
   }
   _buildSnapshot(ssPacket, sfPacket, rdPacket, dsPacket) {
     const flags2 = ssPacket.sysflags[2];
@@ -4188,7 +3678,8 @@ class V5SerialDevice extends VexSerialDevice {
         },
         {
           battery: controller1Battery,
-          isAvailable: controller1Available
+          isAvailable: controller1Available,
+          isCharging: undefined
         }
       ],
       radio: {
@@ -4215,7 +3706,26 @@ class V5SerialDevice extends VexSerialDevice {
     }
     this.state.matchMode = snapshot.matchMode;
     this.state.isFieldControllerConnected = snapshot.isFieldControllerConnected;
-    Object.assign(this.state.brain, snapshot.brain);
+    const brain = this.state.brain;
+    brain.activeProgram = snapshot.brain.activeProgram;
+    brain.battery.batteryPercent = snapshot.brain.battery.batteryPercent;
+    brain.battery.isCharging = snapshot.brain.battery.isCharging;
+    brain.button.isPressed = snapshot.brain.button.isPressed;
+    brain.button.isDoublePressed = snapshot.brain.button.isDoublePressed;
+    if (brain.cpu0Version.compare(snapshot.brain.cpu0Version) !== 0) {
+      brain.cpu0Version = snapshot.brain.cpu0Version;
+    }
+    if (brain.cpu1Version.compare(snapshot.brain.cpu1Version) !== 0) {
+      brain.cpu1Version = snapshot.brain.cpu1Version;
+    }
+    brain.isAvailable = snapshot.brain.isAvailable;
+    brain.settings.isScreenReversed = snapshot.brain.settings.isScreenReversed;
+    brain.settings.isWhiteTheme = snapshot.brain.settings.isWhiteTheme;
+    brain.settings.usingLanguage = snapshot.brain.settings.usingLanguage;
+    if (brain.systemVersion.compare(snapshot.brain.systemVersion) !== 0) {
+      brain.systemVersion = snapshot.brain.systemVersion;
+    }
+    brain.uniqueId = snapshot.brain.uniqueId;
     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);
@@ -4224,10 +3734,18 @@ class V5SerialDevice extends VexSerialDevice {
       if (device != null)
         next[device.port] = device;
     }
-    this.state.devices = next;
+    if (!sameSmartDeviceSlots(this.state.devices, next)) {
+      this.state.devices = next;
+    }
     return true;
   }
 }
+function sameSmartDeviceSlots(left, right) {
+  return left.length === right.length && left.every((device, index) => {
+    const next = right[index];
+    return device === next || device !== undefined && next !== undefined && device.port === next.port && device.type === next.type && device.status === next.status && device.betaversion === next.betaversion && device.version === next.version && device.bootversion === next.bootversion;
+  });
+}
 // src/VexIniConfig.ts
 class BaseIniBuilder {
   str = "";
@@ -4236,7 +3754,7 @@ class BaseIniBuilder {
 `;
   }
   addComment(comment) {
-    this.addLine("; " + comment);
+    this.addLine(comment.length === 0 ? ";" : "; " + comment);
     return this;
   }
   getContent() {
@@ -4254,24 +3772,28 @@ class IniSectionBuilder extends BaseIniBuilder {
     this.object = object;
     this.keyTransform = keyTransform;
   }
-  addSingleObjProperty(key, maxValueLength) {
-    if (this.object[key] == null || this.object[key].toString().length === 0)
+  addSingleObjProperty(key, maxValueLength, omitIfEmpty = false) {
+    const rawValue = this.object[key];
+    if (rawValue == null)
+      return;
+    const value = rawValue.toString();
+    if (omitIfEmpty && value.length === 0)
       return;
+    if (/["\u0000-\u001f\u007f]/.test(value)) {
+      throw new Error(`INI value for ${this.name}.${String(key)} contains an unsupported character`);
+    }
     const formattedKey = this.keyTransform(key).padEnd(12).slice(0, 12);
-    const trimmedVal = this.object[key].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}"`);
+    const trimmedValue = value.slice(0, maxValueLength);
+    this.addLine(`${formattedKey} = "${trimmedValue}"`);
   }
-  addObjProperty(key, maxValueLength) {
-    const keys = Array.isArray(key) ? key : [key];
-    for (const k of keys) {
-      this.addSingleObjProperty(k, maxValueLength);
+  addObjProperty(key, maxValueLength, omitIfEmpty = false) {
+    for (const k of Array.isArray(key) ? key : [key]) {
+      this.addSingleObjProperty(k, maxValueLength, omitIfEmpty);
     }
     return this;
   }
   addAllObjProps(maxValueLength) {
-    const keys = Object.keys(this.object);
-    for (const k of keys) {
+    for (const k of Object.keys(this.object)) {
       this.addSingleObjProperty(k, maxValueLength);
     }
     return this;
@@ -4284,6 +3806,11 @@ class IniFileBuilder extends BaseIniBuilder {
     this.str += section.getContent();
     return this;
   }
+  addOptionalSection(section) {
+    if (section.getContent().length === 0)
+      return this;
+    return this.addComment("").addSection(section);
+  }
 }
 
 class ProgramIniConfig {
@@ -4300,31 +3827,24 @@ class ProgramIniConfig {
     date: "",
     timezone: "0"
   };
-  config = {};
+  config = { 22: "adi" };
   controller1 = {};
   controller2 = {};
-  constructor() {
-    this.config = {
-      22: "adi"
-    };
-  }
   setProgramDate(date) {
-    const d = date;
-    this.program.date = d.toISOString();
-    const tzo = Math.abs(d.getTimezoneOffset());
-    const tzh = tzo / 60 >>> 0;
-    const tzm = tzo - tzh * 60;
-    this.program.timezone = (d.getTimezoneOffset() > 0 ? "-" : "+") + this.dec2(tzh) + ":" + this.dec2(tzm);
+    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();
+    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("version").addObjProperty("ide", 16).addObjProperty("file")).addComment("").addSection(new IniSectionBuilder("program", this.program).addObjProperty("version").addObjProperty("name", 32).addObjProperty("slot").addObjProperty("icon", 16).addObjProperty("iconalt", 16, true).addObjProperty("description", 256).addObjProperty("date").addObjProperty("timezone")).addComment("").addSection(new IniSectionBuilder("config", this.config, (k) => "port_" + this.dec2(k)).addAllObjProps()).addOptionalSection(new IniSectionBuilder("controller_1", this.controller1).addAllObjProps()).addOptionalSection(new IniSectionBuilder("controller_2", this.controller2).addAllObjProps()).getContent();
   }
   dec2(value) {
-    const str = ("00" + value.toString(10)).substr(-2, 2);
-    return str.toUpperCase();
+    return (value % 100).toString(10).padStart(2, "0").toUpperCase();
   }
 }
 export {
@@ -4456,5 +3976,5 @@ export {
   AckType
 };
 
-//# debugId=AEA86FF140C3172464756E2164756E21
+//# debugId=048E789F43ADDE3C64756E2164756E21
 //# sourceMappingURL=index.js.map