@v5x/cli 0.0.23 → 0.0.24

package/dist/index.js

@@ -1656,7 +1656,7 @@ var lib_default2 = (e, t2) => new o(e, t2);
 var package_default = {
   name: "@v5x/cli",
   description: "modern v5 tools",
-  version: "0.0.23",
+  version: "0.0.24",
   module: "dist/index.js",
   type: "module",
   sideEffects: true,
@@ -1681,6 +1681,7 @@ var package_default = {
     typecheck: "tsc --noEmit",
     lint: "oxlint src --type-aware",
     test: "bun test",
+    "benchmark:screenshot": "bun ./benchmarks/screenshot.ts",
     prepack: "bun run --cwd ../serial build && bun run build"
   },
   devDependencies: {
@@ -2209,325 +2210,13 @@ var source_default = chalk;
 import { basename, dirname, join as join2, resolve } from "path";
 import { stat } from "fs/promises";
 
-// ../serial/dist/index.js
-var __defProp2 = Object.defineProperty;
-var __returnValue2 = (v) => v;
-function __exportSetter2(name, newValue) {
-  this[name] = __returnValue2.bind(null, newValue);
-}
-var __export2 = (target, all) => {
-  for (var name in all)
-    __defProp2(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter2.bind(all, name)
-    });
-};
-var USER_PROG_CHUNK_SIZE = 4096;
-var USER_FLASH_USR_CODE_START = 58720256;
-var USER_FLASH_MAX_FILE_SIZE = 2097152;
-var FileVendor;
-((FileVendor2) => {
-  FileVendor2[FileVendor2["USER"] = 1] = "USER";
-  FileVendor2[FileVendor2["SYS"] = 15] = "SYS";
-  FileVendor2[FileVendor2["DEV1"] = 16] = "DEV1";
-  FileVendor2[FileVendor2["DEV2"] = 24] = "DEV2";
-  FileVendor2[FileVendor2["DEV3"] = 32] = "DEV3";
-  FileVendor2[FileVendor2["DEV4"] = 40] = "DEV4";
-  FileVendor2[FileVendor2["DEV5"] = 48] = "DEV5";
-  FileVendor2[FileVendor2["DEV6"] = 56] = "DEV6";
-  FileVendor2[FileVendor2["VEXVM"] = 64] = "VEXVM";
-  FileVendor2[FileVendor2["VEX"] = 240] = "VEX";
-  FileVendor2[FileVendor2["UNDEFINED"] = 241] = "UNDEFINED";
-})(FileVendor ||= {});
-var FileDownloadTarget;
-((FileDownloadTarget2) => {
-  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_DDR"] = 0] = "FILE_TARGET_DDR";
-  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_QSPI"] = 1] = "FILE_TARGET_QSPI";
-  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_CBUF"] = 2] = "FILE_TARGET_CBUF";
-  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_VBUF"] = 3] = "FILE_TARGET_VBUF";
-  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_DDRC"] = 4] = "FILE_TARGET_DDRC";
-  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_DDRE"] = 5] = "FILE_TARGET_DDRE";
-  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_FLASH"] = 6] = "FILE_TARGET_FLASH";
-  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_RADIO"] = 7] = "FILE_TARGET_RADIO";
-  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_A1"] = 13] = "FILE_TARGET_A1";
-  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_B1"] = 14] = "FILE_TARGET_B1";
-  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_B2"] = 15] = "FILE_TARGET_B2";
-})(FileDownloadTarget ||= {});
-var FileInitAction;
-((FileInitAction2) => {
-  FileInitAction2[FileInitAction2["WRITE"] = 1] = "WRITE";
-  FileInitAction2[FileInitAction2["READ"] = 2] = "READ";
-})(FileInitAction ||= {});
-var FileInitOption;
-((FileInitOption2) => {
-  FileInitOption2[FileInitOption2["NONE"] = 0] = "NONE";
-  FileInitOption2[FileInitOption2["OVERWRITE"] = 1] = "OVERWRITE";
-})(FileInitOption ||= {});
-var FileLoadAction;
-((FileLoadAction2) => {
-  FileLoadAction2[FileLoadAction2["RUN"] = 0] = "RUN";
-  FileLoadAction2[FileLoadAction2["STOP"] = 128] = "STOP";
-})(FileLoadAction ||= {});
-var FileExitAction;
-((FileExitAction2) => {
-  FileExitAction2[FileExitAction2["EXIT_NONE"] = 0] = "EXIT_NONE";
-  FileExitAction2[FileExitAction2["EXIT_RUN"] = 1] = "EXIT_RUN";
-  FileExitAction2[FileExitAction2["EXIT_HALT"] = 3] = "EXIT_HALT";
-})(FileExitAction ||= {});
-var RadioChannelType;
-((RadioChannelType2) => {
-  RadioChannelType2[RadioChannelType2["PIT"] = 0] = "PIT";
-  RadioChannelType2[RadioChannelType2["DOWNLOAD"] = 1] = "DOWNLOAD";
-})(RadioChannelType ||= {});
-var AckType;
-((AckType2) => {
-  AckType2[AckType2["CDC2_ACK"] = 118] = "CDC2_ACK";
-  AckType2[AckType2["CDC2_NACK"] = 255] = "CDC2_NACK";
-  AckType2[AckType2["CDC2_NACK_PACKET_CRC"] = 206] = "CDC2_NACK_PACKET_CRC";
-  AckType2[AckType2["CDC2_NACK_CMD_LENGTH"] = 208] = "CDC2_NACK_CMD_LENGTH";
-  AckType2[AckType2["CDC2_NACK_SIZE"] = 209] = "CDC2_NACK_SIZE";
-  AckType2[AckType2["CDC2_NACK_CRC"] = 210] = "CDC2_NACK_CRC";
-  AckType2[AckType2["CDC2_NACK_FILE"] = 211] = "CDC2_NACK_FILE";
-  AckType2[AckType2["CDC2_NACK_INIT"] = 212] = "CDC2_NACK_INIT";
-  AckType2[AckType2["CDC2_NACK_FUNC"] = 213] = "CDC2_NACK_FUNC";
-  AckType2[AckType2["CDC2_NACK_ALIGN"] = 214] = "CDC2_NACK_ALIGN";
-  AckType2[AckType2["CDC2_NACK_ADDR"] = 215] = "CDC2_NACK_ADDR";
-  AckType2[AckType2["CDC2_NACK_INCOMPLETE"] = 216] = "CDC2_NACK_INCOMPLETE";
-  AckType2[AckType2["CDC2_NACK_DIR_INDEX"] = 217] = "CDC2_NACK_DIR_INDEX";
-  AckType2[AckType2["CDC2_NACK_MAX_USER_FILES"] = 218] = "CDC2_NACK_MAX_USER_FILES";
-  AckType2[AckType2["CDC2_NACK_FILE_EXISTS"] = 219] = "CDC2_NACK_FILE_EXISTS";
-  AckType2[AckType2["CDC2_NACK_FILE_SYS_FULL"] = 220] = "CDC2_NACK_FILE_SYS_FULL";
-  AckType2[AckType2["TIMEOUT"] = 256] = "TIMEOUT";
-  AckType2[AckType2["WRITE_ERROR"] = 257] = "WRITE_ERROR";
-})(AckType ||= {});
-var SmartDeviceType;
-((SmartDeviceType2) => {
-  SmartDeviceType2[SmartDeviceType2["EMPTY"] = 0] = "EMPTY";
-  SmartDeviceType2[SmartDeviceType2["V5_POWER"] = 1] = "V5_POWER";
-  SmartDeviceType2[SmartDeviceType2["MOTOR"] = 2] = "MOTOR";
-  SmartDeviceType2[SmartDeviceType2["LED"] = 3] = "LED";
-  SmartDeviceType2[SmartDeviceType2["ABS_ENCODER_SENSOR"] = 4] = "ABS_ENCODER_SENSOR";
-  SmartDeviceType2[SmartDeviceType2["CR_MOTOR"] = 5] = "CR_MOTOR";
-  SmartDeviceType2[SmartDeviceType2["IMU_SENSOR"] = 6] = "IMU_SENSOR";
-  SmartDeviceType2[SmartDeviceType2["DISTANCE_SENSOR"] = 7] = "DISTANCE_SENSOR";
-  SmartDeviceType2[SmartDeviceType2["RADIO_SENSOR"] = 8] = "RADIO_SENSOR";
-  SmartDeviceType2[SmartDeviceType2["CONTROLLER"] = 9] = "CONTROLLER";
-  SmartDeviceType2[SmartDeviceType2["BRAIN"] = 10] = "BRAIN";
-  SmartDeviceType2[SmartDeviceType2["VISION_SENSOR"] = 11] = "VISION_SENSOR";
-  SmartDeviceType2[SmartDeviceType2["ADI"] = 12] = "ADI";
-  SmartDeviceType2[SmartDeviceType2["PARTNER_CONTROLLER"] = 13] = "PARTNER_CONTROLLER";
-  SmartDeviceType2[SmartDeviceType2["BATTERY"] = 14] = "BATTERY";
-  SmartDeviceType2[SmartDeviceType2["SOL"] = 15] = "SOL";
-  SmartDeviceType2[SmartDeviceType2["OPTICAL_SENSOR"] = 16] = "OPTICAL_SENSOR";
-  SmartDeviceType2[SmartDeviceType2["MAGNET"] = 17] = "MAGNET";
-  SmartDeviceType2[SmartDeviceType2["GPS_SENSOR"] = 20] = "GPS_SENSOR";
-  SmartDeviceType2[SmartDeviceType2["UNDEFINED_SENSOR"] = 255] = "UNDEFINED_SENSOR";
-})(SmartDeviceType ||= {});
-var SerialDeviceType;
-((SerialDeviceType2) => {
-  SerialDeviceType2[SerialDeviceType2["V5_BRAIN"] = 1281] = "V5_BRAIN";
-  SerialDeviceType2[SerialDeviceType2["V5_BRAIN_DFU"] = 1282] = "V5_BRAIN_DFU";
-  SerialDeviceType2[SerialDeviceType2["V5_CONTROLLER"] = 1283] = "V5_CONTROLLER";
-  SerialDeviceType2[SerialDeviceType2["XILINX"] = 256] = "XILINX";
-  SerialDeviceType2[SerialDeviceType2["IQ_BRAIN"] = 2] = "IQ_BRAIN";
-  SerialDeviceType2[SerialDeviceType2["IQ_BRAIN2"] = 3] = "IQ_BRAIN2";
-  SerialDeviceType2[SerialDeviceType2["IQ_BRAIN_DFU"] = 255] = "IQ_BRAIN_DFU";
-  SerialDeviceType2[SerialDeviceType2["IQ2_BRAIN"] = 512] = "IQ2_BRAIN";
-  SerialDeviceType2[SerialDeviceType2["IQ2_BRAIN_DFU"] = 527] = "IQ2_BRAIN_DFU";
-  SerialDeviceType2[SerialDeviceType2["IQ2_CONTROLLER"] = 528] = "IQ2_CONTROLLER";
-  SerialDeviceType2[SerialDeviceType2["IQ2_CONTROLLER_DFU"] = 543] = "IQ2_CONTROLLER_DFU";
-  SerialDeviceType2[SerialDeviceType2["EXP_BRAIN"] = 1536] = "EXP_BRAIN";
-  SerialDeviceType2[SerialDeviceType2["EXP_BRAIN_DFU"] = 1551] = "EXP_BRAIN_DFU";
-  SerialDeviceType2[SerialDeviceType2["EXP_CONTROLLER"] = 1552] = "EXP_CONTROLLER";
-  SerialDeviceType2[SerialDeviceType2["EXP_CONTROLLER_DFU"] = 1567] = "EXP_CONTROLLER_DFU";
-  SerialDeviceType2[SerialDeviceType2["PIXY"] = 61440] = "PIXY";
-  SerialDeviceType2[SerialDeviceType2["PIXY_DFU"] = 12] = "PIXY_DFU";
-  SerialDeviceType2[SerialDeviceType2["VEXCAM"] = 1287] = "VEXCAM";
-  SerialDeviceType2[SerialDeviceType2["VEXCAM_DFU"] = 1288] = "VEXCAM_DFU";
-  SerialDeviceType2[SerialDeviceType2["SENSOR_TEST"] = 1535] = "SENSOR_TEST";
-  SerialDeviceType2[SerialDeviceType2["CORTEX_PROGCBL"] = 10] = "CORTEX_PROGCBL";
-  SerialDeviceType2[SerialDeviceType2["CORTEX_BRAIN"] = 11] = "CORTEX_BRAIN";
-  SerialDeviceType2[SerialDeviceType2["CORTEX_JOYSTK"] = 12] = "CORTEX_JOYSTK";
-  SerialDeviceType2[SerialDeviceType2["VEXNET_KEY_20"] = 7] = "VEXNET_KEY_20";
-  SerialDeviceType2[SerialDeviceType2["VEXNET_KEY_10"] = 9587] = "VEXNET_KEY_10";
-  SerialDeviceType2[SerialDeviceType2["PROLIFIC"] = 8963] = "PROLIFIC";
-})(SerialDeviceType ||= {});
-var SelectDashScreen;
-((SelectDashScreen2) => {
-  SelectDashScreen2[SelectDashScreen2["HOME"] = 0] = "HOME";
-  SelectDashScreen2[SelectDashScreen2["BATTERY"] = 1] = "BATTERY";
-  SelectDashScreen2[SelectDashScreen2["LED"] = 3] = "LED";
-  SelectDashScreen2[SelectDashScreen2["MATCH_CONFIG"] = 4] = "MATCH_CONFIG";
-  SelectDashScreen2[SelectDashScreen2["MATCH_CONFIG_MORE"] = 5] = "MATCH_CONFIG_MORE";
-  SelectDashScreen2[SelectDashScreen2["WIRING"] = 6] = "WIRING";
-  SelectDashScreen2[SelectDashScreen2["RADIO"] = 8] = "RADIO";
-  SelectDashScreen2[SelectDashScreen2["BRAIN"] = 10] = "BRAIN";
-  SelectDashScreen2[SelectDashScreen2["RUN_PROGRAM"] = 13] = "RUN_PROGRAM";
-  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_LEFT_MAPPING"] = 14] = "DRIVE_PROGRAM_CONTROL_LEFT_MAPPING";
-  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_MENU"] = 15] = "DRIVE_PROGRAM_MENU";
-  SelectDashScreen2[SelectDashScreen2["DEVICES"] = 16] = "DEVICES";
-  SelectDashScreen2[SelectDashScreen2["USER_PROGRAM_FOLDER"] = 17] = "USER_PROGRAM_FOLDER";
-  SelectDashScreen2[SelectDashScreen2["VEX_PROGRAM_FOLDER"] = 18] = "VEX_PROGRAM_FOLDER";
-  SelectDashScreen2[SelectDashScreen2["SETTINGS"] = 19] = "SETTINGS";
-  SelectDashScreen2[SelectDashScreen2["SCARY_CONFIGURATION"] = 20] = "SCARY_CONFIGURATION";
-  SelectDashScreen2[SelectDashScreen2["LANGUAGE"] = 21] = "LANGUAGE";
-  SelectDashScreen2[SelectDashScreen2["DRIVE_MOTOR_CONFIG"] = 22] = "DRIVE_MOTOR_CONFIG";
-  SelectDashScreen2[SelectDashScreen2["PROGRAM_MENU"] = 24] = "PROGRAM_MENU";
-  SelectDashScreen2[SelectDashScreen2["SHUTDOWN"] = 25] = "SHUTDOWN";
-  SelectDashScreen2[SelectDashScreen2["CONTROLLER_2_MAPPING"] = 26] = "CONTROLLER_2_MAPPING";
-  SelectDashScreen2[SelectDashScreen2["SCARY_CONFIGURATION_MORE"] = 27] = "SCARY_CONFIGURATION_MORE";
-  SelectDashScreen2[SelectDashScreen2["CONFIRM_XX"] = 28] = "CONFIRM_XX";
-  SelectDashScreen2[SelectDashScreen2["CONTROLLER_1_MAPPING"] = 29] = "CONTROLLER_1_MAPPING";
-  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_DUAL_MAPPING"] = 30] = "DRIVE_PROGRAM_CONTROL_DUAL_MAPPING";
-  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_SPLIT_MAPPING"] = 31] = "DRIVE_PROGRAM_CONTROL_SPLIT_MAPPING";
-  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_RIGHT_MAPPING"] = 32] = "DRIVE_PROGRAM_CONTROL_RIGHT_MAPPING";
-  SelectDashScreen2[SelectDashScreen2["MATCH_2_4_PLAYERS"] = 33] = "MATCH_2_4_PLAYERS";
-  SelectDashScreen2[SelectDashScreen2["EVENT_LOG"] = 34] = "EVENT_LOG";
-  SelectDashScreen2[SelectDashScreen2["USER_PROGRAM_WIRING"] = 40] = "USER_PROGRAM_WIRING";
-  SelectDashScreen2[SelectDashScreen2["CLAWBOT_PROGRAM_MENU"] = 41] = "CLAWBOT_PROGRAM_MENU";
-  SelectDashScreen2[SelectDashScreen2["ABOUT"] = 42] = "ABOUT";
-  SelectDashScreen2[SelectDashScreen2["LANGUAGE_MORE"] = 43] = "LANGUAGE_MORE";
-  SelectDashScreen2[SelectDashScreen2["OBJECT_COLOR"] = 45] = "OBJECT_COLOR";
-  SelectDashScreen2[SelectDashScreen2["SIGNATURE_ID"] = 46] = "SIGNATURE_ID";
-  SelectDashScreen2[SelectDashScreen2["LOG_DATA"] = 47] = "LOG_DATA";
-})(SelectDashScreen ||= {});
-
-class VexSerialError extends Error {
-  kind;
-  ackType = undefined;
-  constructor(kind, message) {
-    super(message);
-    this.name = "VexSerialError";
-    this.kind = kind;
-  }
-}
-
-class VexNotConnectedError extends VexSerialError {
-  constructor(message = "no connection to a V5 device") {
-    super("not-connected", message);
-    this.name = "VexNotConnectedError";
-  }
-}
-
-class VexInvalidArgumentError extends VexSerialError {
-  constructor(message) {
-    super("invalid-argument", message);
-    this.name = "VexInvalidArgumentError";
-  }
-}
-
-class VexProtocolError extends VexSerialError {
-  ackType;
-  constructor(message, ackType) {
-    super("protocol", message);
-    this.name = "VexProtocolError";
-    this.ackType = ackType;
-  }
-}
-
-class VexTransferError extends VexSerialError {
-  constructor(message) {
-    super("transfer", message);
-    this.name = "VexTransferError";
-  }
-}
-
-class VexDownloadError extends VexSerialError {
-  constructor(message) {
-    super("download", message);
-    this.name = "VexDownloadError";
-  }
-}
-
-class VexFirmwareError extends VexSerialError {
-  constructor(message) {
-    super("firmware", message);
-    this.name = "VexFirmwareError";
-  }
-}
-
-class VexIoError extends VexSerialError {
-  constructor(message) {
-    super("io", message);
-    this.name = "VexIoError";
-  }
-}
-function toVexSerialError(error, fallback = "io") {
-  if (error instanceof VexSerialError)
-    return error;
-  const message = error instanceof Error ? error.message : String(error);
-  return new VexSerialError(fallback, message);
-}
-
-class VexEventEmitter {
-  handlerMap;
-  constructor() {
-    this.handlerMap = new Map;
-  }
-  on(eventName, listener) {
-    let listeners = this.handlerMap.get(eventName);
-    listeners ??= [];
-    listeners.push(listener);
-    this.handlerMap.set(eventName, listeners);
-  }
-  remove(eventName, listener) {
-    let listeners = this.handlerMap.get(eventName);
-    listeners ??= [];
-    const index = listeners.indexOf(listener);
-    if (index > -1) {
-      listeners.splice(index, 1);
-    }
-    this.handlerMap.set(eventName, listeners);
-  }
-  emit(eventName, data) {
-    const errors = [];
-    for (const callback of [...this.handlerMap.get(eventName) ?? []]) {
-      try {
-        callback(data);
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-    if (errors.length === 1)
-      throw errors[0];
-    if (errors.length > 1) {
-      throw new AggregateError(errors, `listeners for ${String(eventName)} failed`);
-    }
-  }
-  clearListeners() {
-    this.handlerMap.clear();
-  }
-}
-
-class VexEventTarget {
-  emitter;
-  constructor() {
-    this.emitter = new VexEventEmitter;
-  }
-  emit(eventName, data) {
-    this.emitter.emit(this.normalizeEventName(eventName), data);
-  }
-  on(eventName, listener) {
-    this.emitter.on(this.normalizeEventName(eventName), listener);
-  }
-  remove(eventName, listener) {
-    this.emitter.remove(this.normalizeEventName(eventName), listener);
-  }
-  clearListeners() {
-    this.emitter.clearListeners();
-  }
-  normalizeEventName(eventName) {
-    return String(eventName);
-  }
-}
+// ../../node_modules/.bun/neverthrow@8.2.0/node_modules/neverthrow/dist/index.es.js
 var defaultErrorConfig = {
   withStackTrace: false
 };
-var createNeverThrowError = (message, result, config2 = defaultErrorConfig) => {
+var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
   const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
-  const maybeStack = config2.withStackTrace ? new Error().stack : undefined;
+  const maybeStack = config.withStackTrace ? new Error().stack : undefined;
   return {
     data,
     message,
@@ -2655,7 +2344,6 @@ function __asyncValues(o2) {
     }, reject);
   }
 }
-
 class ResultAsync {
   constructor(res) {
     this._promise = res;
@@ -2767,7 +2455,7 @@ class ResultAsync {
     return this._promise.then(successCallback, failureCallback);
   }
   [Symbol.asyncIterator]() {
-    return __asyncGenerator(this, arguments, function* _a2() {
+    return __asyncGenerator(this, arguments, function* _a() {
       const result = yield __await(this._promise);
       if (result.isErr()) {
         yield yield __await(errAsync(result.error));
@@ -2837,7 +2525,6 @@ function ok(value) {
 function err(err2) {
   return new Err(err2);
 }
-
 class Ok {
   constructor(value) {
     this.value = value;
@@ -2896,83 +2583,388 @@ class Ok {
   _unsafeUnwrap(_) {
     return this.value;
   }
-  _unsafeUnwrapErr(config2) {
-    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config2);
+  _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();
+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;
+
+// ../serial/dist/index.js
+var USER_PROG_CHUNK_SIZE = 4096;
+var USER_FLASH_USR_CODE_START = 58720256;
+var USER_FLASH_MAX_FILE_SIZE = 2097152;
+var FileVendor;
+((FileVendor2) => {
+  FileVendor2[FileVendor2["USER"] = 1] = "USER";
+  FileVendor2[FileVendor2["SYS"] = 15] = "SYS";
+  FileVendor2[FileVendor2["DEV1"] = 16] = "DEV1";
+  FileVendor2[FileVendor2["DEV2"] = 24] = "DEV2";
+  FileVendor2[FileVendor2["DEV3"] = 32] = "DEV3";
+  FileVendor2[FileVendor2["DEV4"] = 40] = "DEV4";
+  FileVendor2[FileVendor2["DEV5"] = 48] = "DEV5";
+  FileVendor2[FileVendor2["DEV6"] = 56] = "DEV6";
+  FileVendor2[FileVendor2["VEXVM"] = 64] = "VEXVM";
+  FileVendor2[FileVendor2["VEX"] = 240] = "VEX";
+  FileVendor2[FileVendor2["UNDEFINED"] = 241] = "UNDEFINED";
+})(FileVendor ||= {});
+var FileDownloadTarget;
+((FileDownloadTarget2) => {
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_DDR"] = 0] = "FILE_TARGET_DDR";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_QSPI"] = 1] = "FILE_TARGET_QSPI";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_CBUF"] = 2] = "FILE_TARGET_CBUF";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_VBUF"] = 3] = "FILE_TARGET_VBUF";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_DDRC"] = 4] = "FILE_TARGET_DDRC";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_DDRE"] = 5] = "FILE_TARGET_DDRE";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_FLASH"] = 6] = "FILE_TARGET_FLASH";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_RADIO"] = 7] = "FILE_TARGET_RADIO";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_A1"] = 13] = "FILE_TARGET_A1";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_B1"] = 14] = "FILE_TARGET_B1";
+  FileDownloadTarget2[FileDownloadTarget2["FILE_TARGET_B2"] = 15] = "FILE_TARGET_B2";
+})(FileDownloadTarget ||= {});
+var FileInitAction;
+((FileInitAction2) => {
+  FileInitAction2[FileInitAction2["WRITE"] = 1] = "WRITE";
+  FileInitAction2[FileInitAction2["READ"] = 2] = "READ";
+})(FileInitAction ||= {});
+var FileInitOption;
+((FileInitOption2) => {
+  FileInitOption2[FileInitOption2["NONE"] = 0] = "NONE";
+  FileInitOption2[FileInitOption2["OVERWRITE"] = 1] = "OVERWRITE";
+})(FileInitOption ||= {});
+var FileLoadAction;
+((FileLoadAction2) => {
+  FileLoadAction2[FileLoadAction2["RUN"] = 0] = "RUN";
+  FileLoadAction2[FileLoadAction2["STOP"] = 128] = "STOP";
+})(FileLoadAction ||= {});
+var FileExitAction;
+((FileExitAction2) => {
+  FileExitAction2[FileExitAction2["EXIT_NONE"] = 0] = "EXIT_NONE";
+  FileExitAction2[FileExitAction2["EXIT_RUN"] = 1] = "EXIT_RUN";
+  FileExitAction2[FileExitAction2["EXIT_HALT"] = 3] = "EXIT_HALT";
+})(FileExitAction ||= {});
+var RadioChannelType;
+((RadioChannelType2) => {
+  RadioChannelType2[RadioChannelType2["PIT"] = 0] = "PIT";
+  RadioChannelType2[RadioChannelType2["DOWNLOAD"] = 1] = "DOWNLOAD";
+})(RadioChannelType ||= {});
+var AckType;
+((AckType2) => {
+  AckType2[AckType2["CDC2_ACK"] = 118] = "CDC2_ACK";
+  AckType2[AckType2["CDC2_NACK"] = 255] = "CDC2_NACK";
+  AckType2[AckType2["CDC2_NACK_PACKET_CRC"] = 206] = "CDC2_NACK_PACKET_CRC";
+  AckType2[AckType2["CDC2_NACK_CMD_LENGTH"] = 208] = "CDC2_NACK_CMD_LENGTH";
+  AckType2[AckType2["CDC2_NACK_SIZE"] = 209] = "CDC2_NACK_SIZE";
+  AckType2[AckType2["CDC2_NACK_CRC"] = 210] = "CDC2_NACK_CRC";
+  AckType2[AckType2["CDC2_NACK_FILE"] = 211] = "CDC2_NACK_FILE";
+  AckType2[AckType2["CDC2_NACK_INIT"] = 212] = "CDC2_NACK_INIT";
+  AckType2[AckType2["CDC2_NACK_FUNC"] = 213] = "CDC2_NACK_FUNC";
+  AckType2[AckType2["CDC2_NACK_ALIGN"] = 214] = "CDC2_NACK_ALIGN";
+  AckType2[AckType2["CDC2_NACK_ADDR"] = 215] = "CDC2_NACK_ADDR";
+  AckType2[AckType2["CDC2_NACK_INCOMPLETE"] = 216] = "CDC2_NACK_INCOMPLETE";
+  AckType2[AckType2["CDC2_NACK_DIR_INDEX"] = 217] = "CDC2_NACK_DIR_INDEX";
+  AckType2[AckType2["CDC2_NACK_MAX_USER_FILES"] = 218] = "CDC2_NACK_MAX_USER_FILES";
+  AckType2[AckType2["CDC2_NACK_FILE_EXISTS"] = 219] = "CDC2_NACK_FILE_EXISTS";
+  AckType2[AckType2["CDC2_NACK_FILE_SYS_FULL"] = 220] = "CDC2_NACK_FILE_SYS_FULL";
+  AckType2[AckType2["TIMEOUT"] = 256] = "TIMEOUT";
+  AckType2[AckType2["WRITE_ERROR"] = 257] = "WRITE_ERROR";
+  AckType2[AckType2["NOT_CONNECTED"] = 258] = "NOT_CONNECTED";
+})(AckType ||= {});
+var SmartDeviceType;
+((SmartDeviceType2) => {
+  SmartDeviceType2[SmartDeviceType2["EMPTY"] = 0] = "EMPTY";
+  SmartDeviceType2[SmartDeviceType2["V5_POWER"] = 1] = "V5_POWER";
+  SmartDeviceType2[SmartDeviceType2["MOTOR"] = 2] = "MOTOR";
+  SmartDeviceType2[SmartDeviceType2["LED"] = 3] = "LED";
+  SmartDeviceType2[SmartDeviceType2["ABS_ENCODER_SENSOR"] = 4] = "ABS_ENCODER_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["CR_MOTOR"] = 5] = "CR_MOTOR";
+  SmartDeviceType2[SmartDeviceType2["IMU_SENSOR"] = 6] = "IMU_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["DISTANCE_SENSOR"] = 7] = "DISTANCE_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["RADIO_SENSOR"] = 8] = "RADIO_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["CONTROLLER"] = 9] = "CONTROLLER";
+  SmartDeviceType2[SmartDeviceType2["BRAIN"] = 10] = "BRAIN";
+  SmartDeviceType2[SmartDeviceType2["VISION_SENSOR"] = 11] = "VISION_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["ADI"] = 12] = "ADI";
+  SmartDeviceType2[SmartDeviceType2["PARTNER_CONTROLLER"] = 13] = "PARTNER_CONTROLLER";
+  SmartDeviceType2[SmartDeviceType2["BATTERY"] = 14] = "BATTERY";
+  SmartDeviceType2[SmartDeviceType2["SOL"] = 15] = "SOL";
+  SmartDeviceType2[SmartDeviceType2["OPTICAL_SENSOR"] = 16] = "OPTICAL_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["MAGNET"] = 17] = "MAGNET";
+  SmartDeviceType2[SmartDeviceType2["GPS_SENSOR"] = 20] = "GPS_SENSOR";
+  SmartDeviceType2[SmartDeviceType2["UNDEFINED_SENSOR"] = 255] = "UNDEFINED_SENSOR";
+})(SmartDeviceType ||= {});
+var SerialDeviceType;
+((SerialDeviceType2) => {
+  SerialDeviceType2[SerialDeviceType2["V5_BRAIN"] = 1281] = "V5_BRAIN";
+  SerialDeviceType2[SerialDeviceType2["V5_BRAIN_DFU"] = 1282] = "V5_BRAIN_DFU";
+  SerialDeviceType2[SerialDeviceType2["V5_CONTROLLER"] = 1283] = "V5_CONTROLLER";
+  SerialDeviceType2[SerialDeviceType2["XILINX"] = 256] = "XILINX";
+  SerialDeviceType2[SerialDeviceType2["IQ_BRAIN"] = 2] = "IQ_BRAIN";
+  SerialDeviceType2[SerialDeviceType2["IQ_BRAIN2"] = 3] = "IQ_BRAIN2";
+  SerialDeviceType2[SerialDeviceType2["IQ_BRAIN_DFU"] = 255] = "IQ_BRAIN_DFU";
+  SerialDeviceType2[SerialDeviceType2["IQ2_BRAIN"] = 512] = "IQ2_BRAIN";
+  SerialDeviceType2[SerialDeviceType2["IQ2_BRAIN_DFU"] = 527] = "IQ2_BRAIN_DFU";
+  SerialDeviceType2[SerialDeviceType2["IQ2_CONTROLLER"] = 528] = "IQ2_CONTROLLER";
+  SerialDeviceType2[SerialDeviceType2["IQ2_CONTROLLER_DFU"] = 543] = "IQ2_CONTROLLER_DFU";
+  SerialDeviceType2[SerialDeviceType2["EXP_BRAIN"] = 1536] = "EXP_BRAIN";
+  SerialDeviceType2[SerialDeviceType2["EXP_BRAIN_DFU"] = 1551] = "EXP_BRAIN_DFU";
+  SerialDeviceType2[SerialDeviceType2["EXP_CONTROLLER"] = 1552] = "EXP_CONTROLLER";
+  SerialDeviceType2[SerialDeviceType2["EXP_CONTROLLER_DFU"] = 1567] = "EXP_CONTROLLER_DFU";
+  SerialDeviceType2[SerialDeviceType2["PIXY"] = 61440] = "PIXY";
+  SerialDeviceType2[SerialDeviceType2["PIXY_DFU"] = 12] = "PIXY_DFU";
+  SerialDeviceType2[SerialDeviceType2["VEXCAM"] = 1287] = "VEXCAM";
+  SerialDeviceType2[SerialDeviceType2["VEXCAM_DFU"] = 1288] = "VEXCAM_DFU";
+  SerialDeviceType2[SerialDeviceType2["SENSOR_TEST"] = 1535] = "SENSOR_TEST";
+  SerialDeviceType2[SerialDeviceType2["CORTEX_PROGCBL"] = 10] = "CORTEX_PROGCBL";
+  SerialDeviceType2[SerialDeviceType2["CORTEX_BRAIN"] = 11] = "CORTEX_BRAIN";
+  SerialDeviceType2[SerialDeviceType2["CORTEX_JOYSTK"] = 12] = "CORTEX_JOYSTK";
+  SerialDeviceType2[SerialDeviceType2["VEXNET_KEY_20"] = 7] = "VEXNET_KEY_20";
+  SerialDeviceType2[SerialDeviceType2["VEXNET_KEY_10"] = 9587] = "VEXNET_KEY_10";
+  SerialDeviceType2[SerialDeviceType2["PROLIFIC"] = 8963] = "PROLIFIC";
+})(SerialDeviceType ||= {});
+var SelectDashScreen;
+((SelectDashScreen2) => {
+  SelectDashScreen2[SelectDashScreen2["HOME"] = 0] = "HOME";
+  SelectDashScreen2[SelectDashScreen2["BATTERY"] = 1] = "BATTERY";
+  SelectDashScreen2[SelectDashScreen2["LED"] = 3] = "LED";
+  SelectDashScreen2[SelectDashScreen2["MATCH_CONFIG"] = 4] = "MATCH_CONFIG";
+  SelectDashScreen2[SelectDashScreen2["MATCH_CONFIG_MORE"] = 5] = "MATCH_CONFIG_MORE";
+  SelectDashScreen2[SelectDashScreen2["WIRING"] = 6] = "WIRING";
+  SelectDashScreen2[SelectDashScreen2["RADIO"] = 8] = "RADIO";
+  SelectDashScreen2[SelectDashScreen2["BRAIN"] = 10] = "BRAIN";
+  SelectDashScreen2[SelectDashScreen2["RUN_PROGRAM"] = 13] = "RUN_PROGRAM";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_LEFT_MAPPING"] = 14] = "DRIVE_PROGRAM_CONTROL_LEFT_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_MENU"] = 15] = "DRIVE_PROGRAM_MENU";
+  SelectDashScreen2[SelectDashScreen2["DEVICES"] = 16] = "DEVICES";
+  SelectDashScreen2[SelectDashScreen2["USER_PROGRAM_FOLDER"] = 17] = "USER_PROGRAM_FOLDER";
+  SelectDashScreen2[SelectDashScreen2["VEX_PROGRAM_FOLDER"] = 18] = "VEX_PROGRAM_FOLDER";
+  SelectDashScreen2[SelectDashScreen2["SETTINGS"] = 19] = "SETTINGS";
+  SelectDashScreen2[SelectDashScreen2["SCARY_CONFIGURATION"] = 20] = "SCARY_CONFIGURATION";
+  SelectDashScreen2[SelectDashScreen2["LANGUAGE"] = 21] = "LANGUAGE";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_MOTOR_CONFIG"] = 22] = "DRIVE_MOTOR_CONFIG";
+  SelectDashScreen2[SelectDashScreen2["PROGRAM_MENU"] = 24] = "PROGRAM_MENU";
+  SelectDashScreen2[SelectDashScreen2["SHUTDOWN"] = 25] = "SHUTDOWN";
+  SelectDashScreen2[SelectDashScreen2["CONTROLLER_2_MAPPING"] = 26] = "CONTROLLER_2_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["SCARY_CONFIGURATION_MORE"] = 27] = "SCARY_CONFIGURATION_MORE";
+  SelectDashScreen2[SelectDashScreen2["CONFIRM_XX"] = 28] = "CONFIRM_XX";
+  SelectDashScreen2[SelectDashScreen2["CONTROLLER_1_MAPPING"] = 29] = "CONTROLLER_1_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_DUAL_MAPPING"] = 30] = "DRIVE_PROGRAM_CONTROL_DUAL_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_SPLIT_MAPPING"] = 31] = "DRIVE_PROGRAM_CONTROL_SPLIT_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["DRIVE_PROGRAM_CONTROL_RIGHT_MAPPING"] = 32] = "DRIVE_PROGRAM_CONTROL_RIGHT_MAPPING";
+  SelectDashScreen2[SelectDashScreen2["MATCH_2_4_PLAYERS"] = 33] = "MATCH_2_4_PLAYERS";
+  SelectDashScreen2[SelectDashScreen2["EVENT_LOG"] = 34] = "EVENT_LOG";
+  SelectDashScreen2[SelectDashScreen2["USER_PROGRAM_WIRING"] = 40] = "USER_PROGRAM_WIRING";
+  SelectDashScreen2[SelectDashScreen2["CLAWBOT_PROGRAM_MENU"] = 41] = "CLAWBOT_PROGRAM_MENU";
+  SelectDashScreen2[SelectDashScreen2["ABOUT"] = 42] = "ABOUT";
+  SelectDashScreen2[SelectDashScreen2["LANGUAGE_MORE"] = 43] = "LANGUAGE_MORE";
+  SelectDashScreen2[SelectDashScreen2["OBJECT_COLOR"] = 45] = "OBJECT_COLOR";
+  SelectDashScreen2[SelectDashScreen2["SIGNATURE_ID"] = 46] = "SIGNATURE_ID";
+  SelectDashScreen2[SelectDashScreen2["LOG_DATA"] = 47] = "LOG_DATA";
+})(SelectDashScreen ||= {});
+
+class VexSerialError extends Error {
+  kind;
+  ackType = undefined;
+  constructor(kind, message) {
+    super(message);
+    this.name = "VexSerialError";
+    this.kind = kind;
+  }
+}
+
+class VexNotConnectedError extends VexSerialError {
+  constructor(message = "no connection to a V5 device") {
+    super("not-connected", message);
+    this.name = "VexNotConnectedError";
   }
-  map(_f) {
-    return err(this.error);
+}
+
+class VexInvalidArgumentError extends VexSerialError {
+  constructor(message) {
+    super("invalid-argument", message);
+    this.name = "VexInvalidArgumentError";
   }
-  mapErr(f) {
-    return err(f(this.error));
+}
+
+class VexProtocolError extends VexSerialError {
+  ackType;
+  constructor(message, ackType) {
+    super("protocol", message);
+    this.name = "VexProtocolError";
+    this.ackType = ackType;
   }
-  andThrough(_f) {
-    return err(this.error);
+}
+
+class VexTransferError extends VexSerialError {
+  constructor(message) {
+    super("transfer", message);
+    this.name = "VexTransferError";
   }
-  andTee(_f) {
-    return err(this.error);
+}
+
+class VexDownloadError extends VexSerialError {
+  constructor(message) {
+    super("download", message);
+    this.name = "VexDownloadError";
   }
-  orTee(f) {
-    try {
-      f(this.error);
-    } catch (e) {}
-    return err(this.error);
+}
+
+class VexFirmwareError extends VexSerialError {
+  constructor(message) {
+    super("firmware", message);
+    this.name = "VexFirmwareError";
   }
-  andThen(_f) {
-    return err(this.error);
+}
+
+class VexIoError extends VexSerialError {
+  constructor(message) {
+    super("io", message);
+    this.name = "VexIoError";
   }
-  orElse(f) {
-    return f(this.error);
+}
+function toVexSerialError(error, fallback = "io") {
+  if (error instanceof VexSerialError)
+    return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new VexSerialError(fallback, message);
+}
+
+class VexEventEmitter {
+  handlerMap;
+  constructor() {
+    this.handlerMap = new Map;
   }
-  asyncAndThen(_f) {
-    return errAsync(this.error);
+  on(eventName, listener) {
+    let listeners = this.handlerMap.get(eventName);
+    listeners ??= [];
+    listeners.push(listener);
+    this.handlerMap.set(eventName, listeners);
   }
-  asyncAndThrough(_f) {
-    return errAsync(this.error);
+  remove(eventName, listener) {
+    let listeners = this.handlerMap.get(eventName);
+    listeners ??= [];
+    const index = listeners.indexOf(listener);
+    if (index > -1) {
+      listeners.splice(index, 1);
+    }
+    this.handlerMap.set(eventName, listeners);
   }
-  asyncMap(_f) {
-    return errAsync(this.error);
+  emit(eventName, 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`);
+    }
   }
-  unwrapOr(v) {
-    return v;
+  clearListeners() {
+    this.handlerMap.clear();
   }
-  match(_ok, err2) {
-    return err2(this.error);
+}
+
+class VexEventTarget {
+  emitter;
+  constructor() {
+    this.emitter = new VexEventEmitter;
   }
-  safeUnwrap() {
-    const error = this.error;
-    return function* () {
-      yield err(error);
-      throw new Error("Do not use this generator out of `safeTry`");
-    }();
+  emit(eventName, data) {
+    this.emitter.emit(eventName, data);
   }
-  _unsafeUnwrap(config2) {
-    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config2);
+  on(eventName, listener) {
+    this.emitter.on(eventName, listener);
   }
-  _unsafeUnwrapErr(_) {
-    return this.error;
+  remove(eventName, listener) {
+    this.emitter.remove(eventName, listener);
   }
-  *[Symbol.iterator]() {
-    const self = this;
-    yield self;
-    return self;
+  clearListeners() {
+    this.emitter.clearListeners();
   }
 }
-var fromThrowable = Result.fromThrowable;
 var MATCH_STATUS_ALT_ACK = 167;
 
 class Packet {
@@ -3054,86 +3046,122 @@ class CrcGenerator {
     }
     return acc & 65535;
   }
-  crc32(buf, initValue) {
-    let acc = initValue;
-    for (let j = 0;j < buf.length; j++) {
-      acc = (acc << 8 ^ CRC32_TABLE[(acc >>> 24 ^ buf[j]) & 255]) >>> 0;
-    }
-    return acc >>> 0;
+  crc32(buf, initValue) {
+    let acc = initValue;
+    for (let j = 0;j < buf.length; j++) {
+      acc = (acc << 8 ^ CRC32_TABLE[(acc >>> 24 ^ buf[j]) & 255]) >>> 0;
+    }
+    return acc >>> 0;
+  }
+}
+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 crc2 = this.crcgen.crc16(h.subarray(0, h.length - 2), 0);
+    h[h.length - 2] = crc2 >>> 8;
+    h[h.length - 1] = crc2 & 255;
+  }
+  validateHeader(data) {
+    return data[0] === PacketEncoder.HEADER_TO_HOST[0] && data[1] === PacketEncoder.HEADER_TO_HOST[1];
+  }
+  validateMessageCdc(data) {
+    const crc2 = (data[data.byteLength - 2] << 8) + data[data.byteLength - 1];
+    return this.crcgen.crc16(data.subarray(0, data.byteLength - 2), 0) === crc2;
+  }
+  getPayloadSize(data) {
+    const a2 = data[3];
+    return (a2 & 128) === 0 ? a2 : ((a2 & 127) << 8) + data[4];
+  }
+  getHostHeaderLength(data) {
+    return (data[3] & 128) === 0 ? 4 : 5;
   }
 }
-var exports_VexPacketModels = {};
-__export2(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
-});
 
 class VexFirmwareVersion {
   major;
@@ -3201,7 +3229,7 @@ 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;
   }
@@ -3261,12 +3289,12 @@ class PacketView extends DataView {
     return result;
   }
 }
-var textEncoder = new TextEncoder;
+var textEncoder2 = new TextEncoder;
 function filePayload(a2, b, fileName) {
   const payload = new Uint8Array(26);
   payload[0] = a2;
   payload[1] = b;
-  payload.set(encodeFixedText(fileName, "Filename", 23), 2);
+  payload.set(encodeFixedText(fileName, "Filename", 24), 2);
   return payload;
 }
 var clamp100 = (value) => value !== undefined && value > 100 ? 100 : value;
@@ -3297,15 +3325,6 @@ class GetMatchStatusH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 88;
   static COMMAND_EXTENDED_ID = 194;
 }
-
-class GetRadioModeH2DPacket extends DeviceBoundPacket {
-  static COMMAND_ID = 88;
-  static COMMAND_EXTENDED_ID = 65;
-  constructor(mode) {
-    super(Uint8Array.of(mode));
-  }
-}
-
 class FileControlH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 16;
@@ -3334,7 +3353,7 @@ class InitFileTransferH2DPacket extends DeviceBoundPacket {
     const timestamp = (Date.now() / 1000 >>> 0) - PacketEncoder.J2000_EPOCH;
     view.setUint32(20, timestamp, true);
     payload.set(version.toUint8Array(), 24);
-    payload.set(encodeFixedText(name, "Filename", 23), 28);
+    payload.set(encodeFixedText(name, "Filename", 24), 28);
     super(payload);
   }
 }
@@ -3402,15 +3421,6 @@ class LoadFileActionH2DPacket extends DeviceBoundPacket {
     super(filePayload(vendor, actionId, fileName));
   }
 }
-
-class GetFileMetadataH2DPacket extends DeviceBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 25;
-  constructor(vendor, fileName, options) {
-    super(filePayload(vendor, options, fileName));
-  }
-}
-
 class EraseFileH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 27;
@@ -3434,15 +3444,6 @@ class FileClearUpH2DPacket extends DeviceBoundPacket {
     super(Uint8Array.of(vendor, 0));
   }
 }
-
-class FileFormatH2DPacket extends DeviceBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 31;
-  constructor() {
-    super(Uint8Array.of(68, 67, 66, 65));
-  }
-}
-
 class GetSystemFlagsH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 32;
@@ -3457,29 +3458,6 @@ class GetSystemStatusH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 34;
 }
-
-class GetFdtStatusH2DPacket extends DeviceBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 35;
-}
-
-class GetLogCountH2DPacket extends DeviceBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 36;
-}
-
-class ReadLogPageH2DPacket extends DeviceBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 37;
-  constructor(offset, count) {
-    const payload = new Uint8Array(8);
-    const view = new DataView(payload.buffer);
-    view.setUint32(0, offset, true);
-    view.setUint32(4, count, true);
-    super(payload);
-  }
-}
-
 class GetRadioStatusH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 38;
@@ -3529,7 +3507,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");
     }
@@ -3539,17 +3517,6 @@ class WriteKeyValueH2DPacket extends DeviceBoundPacket {
     super(payload);
   }
 }
-
-class GetSlot1to4InfoH2DPacket extends DeviceBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 49;
-}
-
-class GetSlot5to8InfoH2DPacket extends DeviceBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 50;
-}
-
 class FactoryStatusH2DPacket extends DeviceBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 241;
@@ -3692,7 +3659,7 @@ class ReadFileReplyD2HPacket extends HostBoundPacket {
     const view = PacketView.fromPacket(this);
     this.addr = view.nextUint32();
     this.length = this.payloadSize - 8;
-    this.buf = this.data.slice(view.position, view.position + this.length).buffer;
+    this.buf = this.data.subarray(view.position, view.position + this.length);
   }
 }
 
@@ -3737,28 +3704,6 @@ class LoadFileActionReplyD2HPacket extends HostBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 24;
 }
-
-class GetFileMetadataReplyD2HPacket extends HostBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 25;
-  file;
-  constructor(data) {
-    super(data);
-    if (this.payloadSize <= 4)
-      return;
-    const view = PacketView.fromPacket(this);
-    view.nextUint8();
-    this.file = {
-      size: view.nextUint32(),
-      loadAddress: view.nextUint32(),
-      crc32: view.nextUint32(),
-      type: view.nextString(4),
-      timestamp: view.nextUint32() + PacketEncoder.J2000_EPOCH,
-      version: view.nextVersion()
-    };
-  }
-}
-
 class EraseFileReplyD2HPacket extends HostBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 27;
@@ -3781,12 +3726,6 @@ class FileClearUpReplyD2HPacket extends HostBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 30;
 }
-
-class FileFormatReplyD2HPacket extends HostBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 31;
-}
-
 class GetSystemFlagsReplyD2HPacket extends HostBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 32;
@@ -3889,69 +3828,6 @@ class GetSystemStatusReplyD2HPacket extends HostBoundPacket {
     }
   }
 }
-
-class GetFdtStatusReplyD2HPacket extends HostBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 35;
-  count;
-  status;
-  constructor(data) {
-    super(data);
-    const view = PacketView.fromPacket(this);
-    this.count = view.nextUint8();
-    this.status = [];
-    for (let i2 = 0;i2 < this.count; i2++) {
-      this.status.push({
-        index: view.nextUint8(),
-        type: view.nextUint8(),
-        status: view.nextUint8(),
-        betaversion: view.nextUint8(),
-        version: view.nextUint16(),
-        bootversion: view.nextUint16()
-      });
-    }
-  }
-}
-
-class GetLogCountReplyD2HPacket extends HostBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 36;
-  count;
-  constructor(data) {
-    super(data);
-    const view = PacketView.fromPacket(this);
-    view.nextUint8();
-    this.count = view.nextUint32();
-  }
-}
-
-class ReadLogPageReplyD2HPacket extends HostBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 37;
-  offset;
-  count;
-  entries;
-  constructor(data) {
-    super(data);
-    const view = PacketView.fromPacket(this);
-    const size = view.nextUint8();
-    this.offset = view.nextUint32();
-    this.count = view.nextUint16();
-    this.entries = [];
-    let j = this.ackIndex + 8;
-    for (let i2 = 0;i2 < this.count; i2++) {
-      this.entries.push({
-        code: view.getUint8(j),
-        type: view.getUint8(j + 1),
-        desc: view.getUint8(j + 2),
-        spare: view.getUint8(j + 3),
-        time: view.getUint32(j + 4, true)
-      });
-      j += size;
-    }
-  }
-}
-
 class GetRadioStatusReplyD2HPacket extends HostBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 38;
@@ -4000,40 +3876,6 @@ class WriteKeyValueReplyD2HPacket extends HostBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 47;
 }
-
-class GetSlot1to4InfoReplyD2HPacket extends HostBoundPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 49;
-  slotFlags;
-  slots;
-  constructor(data, start = 1) {
-    super(data);
-    const view = PacketView.fromPacket(this);
-    this.slotFlags = view.nextUint8();
-    this.slots = [];
-    for (let i2 = 0;i2 < 4; i2++) {
-      if ((this.slotFlags & 1 << start - 1 + i2) === 0)
-        continue;
-      const icon = view.nextUint16();
-      const nameLen = view.nextUint8();
-      this.slots.push({
-        slot: start + i2,
-        icon,
-        name: view.nextString(nameLen)
-      });
-    }
-  }
-}
-
-class GetSlot5to8InfoReplyD2HPacket extends GetSlot1to4InfoReplyD2HPacket {
-  static COMMAND_ID = 86;
-  static COMMAND_EXTENDED_ID = 50;
-  slotStartIndex = 5;
-  constructor(data) {
-    super(data, 5);
-  }
-}
-
 class FactoryStatusReplyD2HPacket extends HostBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 241;
@@ -4051,122 +3893,32 @@ class FactoryEnableReplyD2HPacket extends HostBoundPacket {
   static COMMAND_ID = 86;
   static COMMAND_EXTENDED_ID = 255;
 }
-var textEncoder2 = new TextEncoder;
-var HEADER_TO_DEVICE = Uint8Array.of(201, 54, 184, 71);
-function encodeFixedText(value, field, maxBytes) {
-  const encoded = textEncoder2.encode(value);
-  if (encoded.byteLength > maxBytes) {
-    throw new RangeError(`${field} must be at most ${maxBytes} UTF-8 bytes`);
-  }
-  return encoded;
-}
-
-class PacketEncoder {
-  static HEADERS_LENGTH = 4;
-  static HEADER_TO_DEVICE = [201, 54, 184, 71];
-  static HEADER_TO_HOST = [170, 85];
-  static J2000_EPOCH = 946684800;
-  vexVersion = 0;
-  crcgen = new CrcGenerator;
-  allPacketsTable = new Map;
-  static getInstance() {
-    Packet.ENCODER ??= new PacketEncoder;
-    return Packet.ENCODER;
-  }
-  constructor() {
-    for (const packet of Object.values(exports_VexPacketModels)) {
-      if (typeof packet === "function" && packet.prototype instanceof HostBoundPacket) {
-        const type = packet;
-        let byExtendedId = this.allPacketsTable.get(type.COMMAND_ID);
-        if (byExtendedId === undefined) {
-          byExtendedId = new Map;
-          this.allPacketsTable.set(type.COMMAND_ID, byExtendedId);
-        }
-        byExtendedId.set(type.COMMAND_EXTENDED_ID, type);
-      }
-    }
-  }
-  getPacketType(commandId, commandExtendedId) {
-    if (commandId === undefined)
-      return;
-    return this.allPacketsTable.get(commandId)?.get(commandExtendedId);
-  }
-  createHeader(buf) {
-    if (buf === undefined || buf.byteLength < PacketEncoder.HEADERS_LENGTH) {
-      buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH);
-    }
-    const h = new Uint8Array(buf);
-    h.set(HEADER_TO_DEVICE);
-    return h;
-  }
-  cdcCommand(cmd) {
-    const h = new Uint8Array(5);
-    h.set(HEADER_TO_DEVICE);
-    h[4] = cmd;
-    return h;
-  }
-  cdcCommandWithData(cmd, data) {
-    const h = new Uint8Array(6 + data.length);
-    h.set(HEADER_TO_DEVICE);
-    h[4] = cmd;
-    h[5] = data.length;
-    h.set(data, 6);
-    return h;
-  }
-  cdc2Command(cmd, ext) {
-    const h = new Uint8Array(9);
-    h.set(HEADER_TO_DEVICE);
-    h[4] = cmd;
-    h[5] = ext;
-    h[6] = 0;
-    this.appendCrc16(h);
-    return h;
-  }
-  cdc2CommandBufferLength(data) {
-    return PacketEncoder.HEADERS_LENGTH + data.length + 5 + (data.length > 127 ? 1 : 0);
-  }
-  cdc2CommandWithData(cmd, ext, data) {
-    const h = new Uint8Array(this.cdc2CommandBufferLength(data));
-    h.set(HEADER_TO_DEVICE);
-    h[4] = cmd;
-    h[5] = ext;
-    if (data.length < 128) {
-      h[6] = data.length;
-      h.set(data, 7);
-    } else {
-      h[6] = data.length >>> 8 | 128;
-      h[7] = data.length & 255;
-      h.set(data, 8);
-    }
-    this.appendCrc16(h);
-    return h;
-  }
-  appendCrc16(h) {
-    const crc2 = this.crcgen.crc16(h.subarray(0, h.length - 2), 0);
-    h[h.length - 2] = crc2 >>> 8;
-    h[h.length - 1] = crc2 & 255;
-  }
-  validateHeader(data) {
-    return data[0] === PacketEncoder.HEADER_TO_HOST[0] && data[1] === PacketEncoder.HEADER_TO_HOST[1];
-  }
-  validateMessageCdc(data) {
-    const crc2 = (data[data.byteLength - 2] << 8) + data[data.byteLength - 1];
-    return this.crcgen.crc16(data.subarray(0, data.byteLength - 2), 0) === crc2;
-  }
-  getPayloadSize(data) {
-    const a2 = data[3];
-    return (a2 & 128) === 0 ? a2 : ((a2 & 127) << 8) + data[4];
-  }
-  getHostHeaderLength(data) {
-    return (data[3] & 128) === 0 ? 4 : 5;
-  }
-}
-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;
+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}`);
+  }
+  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;
+    }
+    source += (SCREEN_CAPTURE_MESSAGE_WIDTH - SCREEN_CAPTURE_WIDTH) * SCREEN_CAPTURE_MESSAGE_CHANNELS;
+  }
+  return pixels;
+}
+var thePacketEncoder = PacketEncoder.getInstance();
 
 class VexSerialConnection extends VexEventTarget {
   filters = [{ usbVendorId: 10376 }];
@@ -4174,12 +3926,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;
   }
@@ -4191,27 +3962,45 @@ class VexSerialConnection extends VexEventTarget {
     this.serial = serial;
   }
   reportWarning(message, details) {
-    this.emit("warning", { 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);
+      callback.callback(258);
     }
     const onDisconnect = this._onPortDisconnect;
     this._onPortDisconnect = null;
@@ -4260,11 +4049,22 @@ class VexSerialConnection extends VexEventTarget {
     }
     if (this._wasConnected) {
       this._wasConnected = false;
-      this.emit("disconnected", undefined);
+      this.emitSafely("disconnected", undefined);
     }
   }
   open(use = 0, askUser = true) {
-    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) {
     if (this._closePromise !== null)
@@ -4297,38 +4097,63 @@ class VexSerialConnection extends VexEventTarget {
       this.reader = this.port.readable.getReader();
       this.startReader();
       this._wasConnected = true;
-      this.emit("connected", undefined);
+      this.emitSafely("connected", undefined);
       return ok("opened");
     } catch (e) {
-      await this.close();
+      await this._doClose();
       return err(toVexSerialError(e, "io"));
     }
   }
   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);
+      if (this.writer === undefined || this._isClosing) {
+        resolve(258);
         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),
+        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);
       });
@@ -4339,6 +4164,9 @@ class VexSerialConnection extends VexEventTarget {
       const result = await this.writeDataAsync(packet, timeout);
       if (result instanceof ReplyType)
         return ok(result);
+      if (result === 258) {
+        return err(new VexNotConnectedError);
+      }
       return err(new VexProtocolError(expectedReplyMessage(packet, ReplyType, result), typeof result === "number" ? result : undefined));
     })());
   }
@@ -4349,56 +4177,48 @@ 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 n2 = thePacketEncoder.getHostHeaderLength(cache);
+        const payloadExpectedSize = thePacketEncoder.getPayloadSize(cache.bytes);
+        const n2 = thePacketEncoder.getHostHeaderLength(cache.bytes);
         const totalSize = n2 + 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[n2] : undefined;
-        const ack = cache[n2 + 1];
+        const cmdExId = hasExtId ? packet[n2] : undefined;
+        const ack = packet[n2 + 1];
         if (hasExtId) {
-          if (!thePacketEncoder.validateMessageCdc(cache))
-            throw new Error("Invalid message CDC");
-        }
-        let matchIdx = -1;
-        let untypedIdx = -1;
-        for (let i2 = 0;i2 < this.callbacksQueue.length; i2++) {
-          const candidate = this.callbacksQueue[i2];
-          if (candidate.wantedCommandId === undefined && candidate.wantedCommandExId === undefined) {
-            if (untypedIdx === -1)
-              untypedIdx = i2;
+          if (!thePacketEncoder.validateMessageCdc(packet)) {
+            this.reportWarning("discarding a reply with an invalid CDC CRC", {
+              commandId: cmdId,
+              commandExtendedId: cmdExId,
+              ack
+            });
             continue;
           }
-          if ((candidate.wantedCommandId === undefined || candidate.wantedCommandId === cmdId) && (candidate.wantedCommandExId === undefined || candidate.wantedCommandExId === cmdExId)) {
-            matchIdx = i2;
-            break;
-          }
         }
-        if (matchIdx === -1)
-          matchIdx = untypedIdx;
-        if (matchIdx === -1) {
+        const callbackInfo = this.shiftPendingCallback(cmdId, cmdExId) ?? this.shiftRawCallback();
+        if (callbackInfo === undefined) {
           this.reportWarning("received a reply with no matching request", {
             commandId: cmdId,
             commandExtendedId: cmdExId,
@@ -4406,38 +4226,117 @@ class VexSerialConnection extends VexEventTarget {
           });
           continue;
         }
-        const callbackInfo = this.callbacksQueue[matchIdx];
         const wantedCmdId = callbackInfo.wantedCommandId;
         const wantedCmdExId = callbackInfo.wantedCommandExId;
-        const data = cache.slice(0, sliceIdx);
         const PackageType = thePacketEncoder.getPacketType(wantedCmdId, wantedCmdExId);
         if (wantedCmdId === undefined || PackageType === undefined) {
           if (wantedCmdId !== undefined) {
             this.reportWarning("no packet class is registered for the wanted command", { commandId: wantedCmdId, commandExtendedId: wantedCmdExId });
           }
-          callbackInfo.callback(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
+          callbackInfo.callback(packet.buffer);
         } else {
-          if (!hasExtId || PackageType.isValidPacket(data, n2)) {
-            callbackInfo.callback(new PackageType(data));
+          if (PackageType.isValidPacket(packet, n2)) {
+            callbackInfo.callback(new PackageType(packet));
           } else {
             this.reportWarning("reply failed packet validation; delivering its ack instead", { commandId: cmdId, commandExtendedId: cmdExId, ack });
             callbackInfo.callback(ack);
           }
         }
         clearTimeout(callbackInfo.timeout);
-        this.callbacksQueue.splice(matchIdx, 1);
       } catch (e) {
         if (!(e instanceof Error && e.message === "No data")) {
           this.reportWarning("reader loop stopped by a read error", {
             error: e,
-            pendingBytes: cache
+            pendingBytes: cache.bytes
           });
         }
         await this.close();
         break;
       } finally {
-        cache = cache.slice(sliceIdx);
+        cache.discard(sliceIdx);
+      }
+  }
+  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);
@@ -4555,7 +4454,9 @@ class V5SerialConnection extends VexSerialConnection {
       let bufferOffset = 0;
       const fileBuf = new Uint8Array(fileSize);
       while (bufferOffset < fileSize) {
-        const requestedSize = Math.min(bufferChunkSize, fileSize - bufferOffset);
+        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;
@@ -4566,9 +4467,10 @@ class V5SerialConnection extends VexSerialConnection {
         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;
@@ -4723,7 +4625,7 @@ class V5SerialConnection extends VexSerialConnection {
       filename: "screen",
       vendor: 15,
       loadAddress: 0,
-      size: SCREEN_CAPTURE_MESSAGE_WIDTH * SCREEN_CAPTURE_HEIGHT * SCREEN_CAPTURE_MESSAGE_CHANNELS
+      size: SCREEN_CAPTURE_FRAMEBUFFER_SIZE
     }, 2, progressCallback);
     if (framebuffer.isErr())
       return err(framebuffer.error);
@@ -4748,34 +4650,60 @@ class V5SerialConnection extends VexSerialConnection {
     return this.request(new SelectDashH2DPacket(screen, port), SelectDashReplyD2HPacket);
   }
 }
-function binaryArrayJoin(left, right) {
-  const leftSize = left != null ? left.byteLength : 0;
-  const rightSize = right != null ? right.byteLength : 0;
-  const all = new Uint8Array(leftSize + rightSize);
-  if (all.length === 0)
-    return new Uint8Array;
-  if (left != null)
-    all.set(new Uint8Array(left), 0);
-  if (right != null)
-    all.set(new Uint8Array(right), leftSize);
-  return all;
+
+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 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 {
@@ -4945,7 +4873,7 @@ async function flashFactoryImage(conn, options, pcb) {
     autoRun: true,
     linkedFile: undefined
   };
-  const upload = await conn.uploadFileToDevice(writeRequest, (c, t2) => {
+  const upload = await conn.uploadFileToDeviceUnlocked(writeRequest, (c, t2) => {
     pcb(`UPLOAD ${label}`, c, t2);
   });
   if (upload.isErr())
@@ -5072,29 +5000,35 @@ async function runUploadFirmware(state, publicUrl, usingVersion, progressCallbac
   }
   pcb("UNZIP VEXOS", 1, 1);
   return state.withRefreshPaused(async () => {
-    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 bootFlash = await flashFactoryImage(conn, {
-      image: boot,
-      label: "BOOT",
-      downloadTarget: 14
-    }, pcb);
-    if (bootFlash.isErr())
-      return err(bootFlash.error);
-    const assetsFlash = await flashFactoryImage(conn, {
-      image: assertImage,
-      label: "ASSETS",
-      downloadTarget: 13
-    }, pcb);
-    if (assetsFlash.isErr())
-      return err(assetsFlash.error);
-    return ok(true);
+    try {
+      return await conn.withFileTransfer(async () => {
+        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 bootFlash = await flashFactoryImage(conn, {
+          image: boot,
+          label: "BOOT",
+          downloadTarget: 14
+        }, pcb);
+        if (bootFlash.isErr())
+          return err(bootFlash.error);
+        const assetsFlash = await flashFactoryImage(conn, {
+          image: assertImage,
+          label: "ASSETS",
+          downloadTarget: 13
+        }, pcb);
+        if (assetsFlash.isErr())
+          return err(assetsFlash.error);
+        return ok(true);
+      });
+    } catch (e) {
+      return err(toVexSerialError(e, "firmware"));
+    }
   });
 }
 function getValue(state, key) {
@@ -5634,6 +5568,11 @@ function unrefTimerIfPossible(timer) {
   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;
@@ -5643,8 +5582,11 @@ class V5SerialDevice extends VexSerialDevice {
   _refreshInterval;
   state = new V5SerialDeviceState(this);
   _disposed = false;
+  _lifecycleGeneration = 0;
+  _disconnectListener;
   _refreshGeneration = 0;
   _autoRefresh = false;
+  _refreshIntervalMs = 200;
   _isLastRefreshComplete = true;
   _brain = new V5Brain(this.state);
   _controllers = [
@@ -5653,8 +5595,15 @@ class V5SerialDevice extends VexSerialDevice {
   ];
   _radio = new V5Radio(this.state);
   _deviceFacades = [];
-  constructor(defaultSerial, autoRefresh = false) {
+  _emitSafely(eventName, data) {
+    try {
+      this.emit(eventName, data);
+    } catch {}
+  }
+  constructor(defaultSerial, options = false) {
     super(defaultSerial);
+    const autoRefresh = typeof options === "boolean" ? options : options.autoRefresh ?? false;
+    this.refreshIntervalMs = typeof options === "boolean" ? 200 : options.refreshIntervalMs ?? 200;
     this.autoRefresh = autoRefresh;
   }
   get autoRefresh() {
@@ -5670,6 +5619,21 @@ class V5SerialDevice extends VexSerialDevice {
       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;
@@ -5687,16 +5651,16 @@ class V5SerialDevice extends VexSerialDevice {
             try {
               const r2 = await this.refresh();
               if (r2.isErr())
-                this.emit("error", r2.error);
+                this._emitSafely("error", r2.error);
             } catch (error) {
-              this.emit("error", error);
+              this._emitSafely("error", error);
             } finally {
               this._isLastRefreshComplete = true;
             }
           })();
         }
       }
-    }, 200);
+    }, this._refreshIntervalMs);
     unrefTimerIfPossible(this._refreshInterval);
   }
   _stopRefreshInterval() {
@@ -5759,58 +5723,125 @@ class V5SerialDevice extends VexSerialDevice {
     })());
   }
   connect(conn) {
-    return new ResultAsync(this._connect(conn));
+    if (this._disposed) {
+      return new ResultAsync(Promise.resolve(this._staleLifecycleResult()));
+    }
+    if (this.isConnected)
+      return new ResultAsync(Promise.resolve(ok(undefined)));
+    const generation = ++this._lifecycleGeneration;
+    return new ResultAsync(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);
     if (conn != null) {
       if (!conn.isConnected) {
         const opened = await conn.open();
+        if (!this._isLifecycleCurrent(generation)) {
+          await conn.close();
+          return this._staleLifecycleResult();
+        }
         if (opened.isErr() || opened.value !== "opened") {
           return err(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);
       }
-      this.connection = conn;
+      if (!this._commitConnection(conn, generation)) {
+        await conn.close();
+        return this._staleLifecycleResult();
+      }
     } 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);
         }
         if (result.value === "no-port") {
-          return err(new VexNotConnectedError("no V5 device was found"));
+          const attempted = attemptedPortNames.length ? `; attempted ${attemptedPortNames.join(", ")}` : "";
+          return err(new VexNotConnectedError(`no responsive V5 device was found${attempted}`));
         }
         if (result.value === "busy") {
           await c.close();
-          continue;
+          return err(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 err(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)
+    const connection = this.connection;
+    if (!this._isLifecycleCurrent(generation) || connection == null) {
+      return this._staleLifecycleResult();
+    }
+    if (!connection.isConnected)
       return err(new VexNotConnectedError);
-    await this.doAfterConnect();
+    const initialized = await this.doAfterConnect(connection, generation);
+    if (initialized.isErr())
+      return initialized;
     return ok(undefined);
   }
   async disconnect() {
+    this._lifecycleGeneration++;
+    this._refreshGeneration++;
     this._isDisconnecting = true;
     const connection = this.connection;
     this.connection = undefined;
+    this._detachDisconnectListener();
     try {
       await connection?.close();
     } finally {
@@ -5824,9 +5855,21 @@ class V5SerialDevice extends VexSerialDevice {
     await this.disconnect();
   }
   reconnect(timeout = 0) {
-    return new ResultAsync(this._reconnect(timeout));
+    if (this._disposed) {
+      return new ResultAsync(Promise.resolve(this._staleLifecycleResult()));
+    }
+    if (timeout < 0) {
+      return new ResultAsync(Promise.resolve(err(new VexInvalidArgumentError("timeout must be non-negative"))));
+    }
+    if (this.isConnected)
+      return new ResultAsync(Promise.resolve(ok(undefined)));
+    const generation = this._isReconnecting ? this._lifecycleGeneration : ++this._lifecycleGeneration;
+    return new ResultAsync(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);
     if (timeout < 0) {
@@ -5842,6 +5885,9 @@ class V5SerialDevice extends VexSerialDevice {
           return err(new VexNotConnectedError);
         }
       }
+      if (!this._isLifecycleCurrent(generation)) {
+        return this._staleLifecycleResult();
+      }
       if (this.isConnected)
         return ok(undefined);
     }
@@ -5850,8 +5896,15 @@ class V5SerialDevice extends VexSerialDevice {
       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);
@@ -5863,6 +5916,10 @@ class V5SerialDevice extends VexSerialDevice {
             continue;
           }
           const status = await c.getSystemStatus(200);
+          if (!this._isLifecycleCurrent(generation)) {
+            await c.close();
+            return this._staleLifecycleResult();
+          }
           if (status.isErr()) {
             await c.close();
             continue;
@@ -5871,23 +5928,38 @@ 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));
     } finally {
       this._isReconnecting = false;
     }
-    if (!this.isConnected)
+    const connection = this.connection;
+    if (!this._isLifecycleCurrent(generation) || connection == null) {
+      return this._staleLifecycleResult();
+    }
+    if (!connection.isConnected)
       return err(new VexNotConnectedError);
-    await this.doAfterConnect();
+    const initialized = await this.doAfterConnect(connection, generation);
+    if (initialized.isErr())
+      return initialized;
     return ok(undefined);
   }
   async waitForReconnectToFinish() {
@@ -5897,18 +5969,69 @@ class V5SerialDevice extends VexSerialDevice {
         return;
     }
   }
-  async doAfterConnect() {
-    if (this.connection == null)
-      return;
-    this.connection.on("disconnected", (_data) => {
-      if (this._isDisconnecting)
+  createConnection() {
+    return new V5SerialConnection(this.defaultSerial);
+  }
+  _isLifecycleCurrent(generation) {
+    return generation === this._lifecycleGeneration && !this._disposed;
+  }
+  _staleLifecycleResult() {
+    return err(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;
-      this.emit("disconnected", undefined);
-      if (this.autoReconnect) {
-        this.reconnect().mapErr((e) => this.emit("error", e));
       }
-    });
-    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 err(refreshed.error);
+    }
+    if (!refreshed.value) {
+      await this._discardConnection(connection, generation);
+      return err(new VexNotConnectedError("initial device refresh did not produce a current snapshot"));
+    }
+    return ok(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());
@@ -5922,31 +6045,15 @@ class V5SerialDevice extends VexSerialDevice {
       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();
+    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()) {
+    if (ssPacket.isErr() || sfPacket.isErr() || rdPacket.isErr() || dsPacket.isErr()) {
       this._applySnapshotIfCurrent(generation, { isAvailable: false });
       return ok(false);
     }
@@ -6003,7 +6110,7 @@ class V5SerialDevice extends VexSerialDevice {
         {
           battery: controller1Battery,
           isAvailable: controller1Available,
-          isCharging: (flags2 & 128) !== 0
+          isCharging: undefined
         }
       ],
       radio: {
@@ -6030,7 +6137,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);
@@ -6039,10 +6165,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;
+  });
+}
 
 class BaseIniBuilder {
   str = "";
@@ -6051,7 +6185,7 @@ class BaseIniBuilder {
 `;
   }
   addComment(comment) {
-    this.addLine("; " + comment);
+    this.addLine(comment.length === 0 ? ";" : "; " + comment);
     return this;
   }
   getContent() {
@@ -6069,18 +6203,23 @@ class IniSectionBuilder extends BaseIniBuilder {
     this.object = object;
     this.keyTransform = keyTransform;
   }
-  addSingleObjProperty(key, maxValueLength) {
-    const value = this.object[key];
-    if (value == null || value.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 = value.toString().slice(0, maxValueLength);
-    const escapedVal = trimmedVal.replace(/["\\\u0000-\u001f\u007f]/g, (character) => `\\x${character.charCodeAt(0).toString(16).padStart(2, "0")}`);
-    this.addLine(`${formattedKey} = "${escapedVal}"`);
+    const trimmedValue = value.slice(0, maxValueLength);
+    this.addLine(`${formattedKey} = "${trimmedValue}"`);
   }
-  addObjProperty(key, maxValueLength) {
+  addObjProperty(key, maxValueLength, omitIfEmpty = false) {
     for (const k of Array.isArray(key) ? key : [key]) {
-      this.addSingleObjProperty(k, maxValueLength);
+      this.addSingleObjProperty(k, maxValueLength, omitIfEmpty);
     }
     return this;
   }
@@ -6098,6 +6237,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 {
@@ -6128,7 +6272,7 @@ class ProgramIniConfig {
     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) {
     return (value % 100).toString(10).padStart(2, "0").toUpperCase();
@@ -6138,6 +6282,60 @@ class ProgramIniConfig {
 // src/utils/detect.ts
 import { join } from "path";
 
+// src/errors.ts
+var CLI_EXIT_CODE = {
+  FAILURE: 1,
+  USAGE: 2,
+  NO_DEVICE: 3,
+  DEVICE: 4,
+  IO: 5
+};
+
+class CliError extends Error {
+  exitCode;
+  constructor(message, exitCode = CLI_EXIT_CODE.FAILURE, options) {
+    super(message, options);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+}
+function exitCodeForSerialError(kind) {
+  switch (kind) {
+    case "invalid-argument":
+      return CLI_EXIT_CODE.USAGE;
+    case "not-connected":
+      return CLI_EXIT_CODE.NO_DEVICE;
+    case "protocol":
+    case "transfer":
+    case "firmware":
+      return CLI_EXIT_CODE.DEVICE;
+    case "download":
+    case "io":
+      return CLI_EXIT_CODE.IO;
+  }
+}
+function isVerbose(argv = process.argv, environment = process.env) {
+  return argv.includes("--verbose") || environment.V5X_DEBUG === "1";
+}
+function isJsonOutput(argv = process.argv) {
+  return argv.includes("--json");
+}
+function formatCliJsonError(error) {
+  return JSON.stringify({
+    error: {
+      message: error instanceof Error ? error.message : String(error),
+      exitCode: cliExitCode(error)
+    }
+  });
+}
+function formatCliError(error, verbose) {
+  const detail = verbose && error instanceof Error && error.stack ? error.stack : error instanceof Error ? error.message : String(error);
+  return `${source_default.red("error:")} ${detail}`;
+}
+function cliExitCode(error) {
+  return error instanceof CliError ? error.exitCode : CLI_EXIT_CODE.FAILURE;
+}
+
 // src/utils/guards.ts
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -6145,6 +6343,12 @@ function isRecord(value) {
 function hasErrorCode(error, code) {
   return isRecord(error) && error.code === code;
 }
+function requireOptionValue(value, option) {
+  if (typeof value === "boolean") {
+    throw new CliError(`${option} requires a value`, CLI_EXIT_CODE.USAGE);
+  }
+  return value;
+}
 
 // src/utils/detect.ts
 function hasVexideDependency(manifest) {
@@ -6206,7 +6410,40 @@ ${stderr}` : message, stderr);
   }
 }
 
+// src/utils/concurrency.ts
+async function mapWithConcurrency(values, concurrency, mapper) {
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new Error("concurrency must be a positive integer");
+  }
+  if (values.length === 0)
+    return [];
+  const results = new Array(values.length);
+  let nextIndex = 0;
+  let failed = false;
+  async function worker() {
+    while (!failed) {
+      const index = nextIndex++;
+      if (index >= values.length)
+        return;
+      const value = values[index];
+      try {
+        results[index] = await mapper(value, index);
+      } catch (error) {
+        failed = true;
+        throw error;
+      }
+    }
+  }
+  const workers2 = Array.from({ length: Math.min(concurrency, values.length) }, () => worker());
+  const settled = await Promise.allSettled(workers2);
+  const rejection = settled.find((result) => result.status === "rejected");
+  if (rejection !== undefined)
+    throw rejection.reason;
+  return results;
+}
+
 // src/utils/project.ts
+var ARTIFACT_DISCOVERY_CONCURRENCY = 8;
 function stringAt(value, keys) {
   let current = value;
   for (const key of keys) {
@@ -6320,21 +6557,44 @@ async function existingFile(path) {
     return;
   }))?.isFile() ? path : undefined;
 }
-async function newestNamedBinary(root, name) {
-  if (!(await stat(root).catch(() => {
+var binaryDiscoveryOperations = {
+  stat,
+  scan(root, name) {
+    return new Bun.Glob(`**/${name}.bin`).scan({ cwd: root, onlyFiles: true });
+  }
+};
+function newestCandidate(candidates) {
+  return candidates.filter((candidate) => candidate !== undefined).sort((left, right) => right.modified - left.modified || (left.path < right.path ? -1 : left.path > right.path ? 1 : 0))[0]?.path;
+}
+async function newestNamedBinary(root, name, operations = binaryDiscoveryOperations) {
+  if (!(await operations.stat(root).catch(() => {
     return;
   }))?.isDirectory())
     return;
-  let newest;
-  const glob = new Bun.Glob(`**/${name}.bin`);
-  for await (const relativePath of glob.scan({ cwd: root, onlyFiles: true })) {
+  const conventionalPaths = [
+    resolve(root, "armv7a-vex-v5", "release", `${name}.bin`),
+    resolve(root, "release", `${name}.bin`)
+  ];
+  const conventional = await mapWithConcurrency(conventionalPaths, ARTIFACT_DISCOVERY_CONCURRENCY, async (path) => {
+    const info = await operations.stat(path).catch(() => {
+      return;
+    });
+    return info?.isFile() ? { path, modified: info.mtimeMs } : undefined;
+  });
+  const paths = [];
+  const conventionalPathSet = new Set(conventionalPaths);
+  for await (const relativePath of operations.scan(root, name)) {
     const path = resolve(root, relativePath);
-    const { mtimeMs } = await stat(path);
-    if (newest === undefined || mtimeMs > newest.modified) {
-      newest = { path, modified: mtimeMs };
-    }
+    if (!conventionalPathSet.has(path))
+      paths.push(path);
   }
-  return newest?.path;
+  const candidates = await mapWithConcurrency(paths, ARTIFACT_DISCOVERY_CONCURRENCY, async (path) => {
+    const info = await operations.stat(path).catch(() => {
+      return;
+    });
+    return info?.isFile() ? { path, modified: info.mtimeMs } : undefined;
+  });
+  return newestCandidate([...conventional, ...candidates]);
 }
 async function findProgramArtifact(project, explicitPath) {
   if (explicitPath !== undefined) {
@@ -6376,9 +6636,17 @@ async function validateProgramArtifact(path, role) {
   return { path, size: info.size };
 }
 async function validateProgramArtifacts(artifacts) {
+  const [hot, cold] = await Promise.allSettled([
+    validateProgramArtifact(artifacts.hot, "hot"),
+    artifacts.cold === undefined ? Promise.resolve(undefined) : validateProgramArtifact(artifacts.cold, "cold")
+  ]);
+  if (hot.status === "rejected")
+    throw hot.reason;
+  if (cold.status === "rejected")
+    throw cold.reason;
   return {
-    hot: await validateProgramArtifact(artifacts.hot, "hot"),
-    cold: artifacts.cold === undefined ? undefined : await validateProgramArtifact(artifacts.cold, "cold")
+    hot: hot.value,
+    cold: cold.value
   };
 }
 async function findProgramArtifacts(project, explicitPath) {
@@ -7768,8 +8036,9 @@ function formatSerialFailure(message, error) {
   return detail === "" ? `${message}: ${error.kind}` : `${message}: ${error.kind}: ${detail}`;
 }
 function unwrapSerial(result, message) {
-  if (result.isErr())
-    throw new Error(formatSerialFailure(message, result.error));
+  if (result.isErr()) {
+    throw new CliError(formatSerialFailure(message, result.error), exitCodeForSerialError(result.error.kind), { cause: result.error });
+  }
   return result.value;
 }
 
@@ -7845,6 +8114,13 @@ async function listPorts() {
   return (await Promise.resolve().then(() => (init_src(), exports_src))).list();
 }
 var readTextFile = (path) => Bun.file(path).text();
+var LINUX_DISCOVERY_CONCURRENCY = 8;
+var linuxDiscoveryOperations = {
+  readdir: readdir2,
+  realpath,
+  readlink: readlink2,
+  readUsbAttributes: readLinuxUsbDeviceAttributes
+};
 async function readLinuxUsbDeviceAttributes(device, readText = readTextFile) {
   let current = device;
   for (let i2 = 0;i2 < 5; i2++, current = join4(current, "..")) {
@@ -7873,6 +8149,9 @@ class WebSerialPortAdapter extends EventTarget {
   ondisconnect = () => {};
   port = null;
   controller = null;
+  dataListener = null;
+  errorListener = null;
+  nativePaused = false;
   _readable = null;
   _writable = null;
   constructor(path, info) {
@@ -7903,12 +8182,43 @@ class WebSerialPortAdapter extends EventTarget {
     this._readable = new ReadableStream({
       start: (controller) => {
         this.controller = controller;
-        port.on("data", (data) => controller.enqueue(data));
-        port.on("error", (error) => {
+        this.dataListener = (data) => {
+          if (this.port !== port || this.controller !== controller)
+            return;
+          if ((controller.desiredSize ?? 1) <= 0) {
+            const pause = port.pause;
+            if (typeof pause === "function" && !this.nativePaused) {
+              pause.call(port);
+              this.nativePaused = true;
+            } else {
+              this.failReadableBackpressure(port, controller);
+              return;
+            }
+          }
+          try {
+            controller.enqueue(data);
+          } catch {
+            return;
+          }
+          if ((controller.desiredSize ?? 1) <= 0 && !this.nativePaused) {
+            const pause = port.pause;
+            if (typeof pause === "function") {
+              pause.call(port);
+              this.nativePaused = true;
+            }
+          }
+        };
+        this.errorListener = (error) => {
+          if (this.port !== port || this.controller !== controller)
+            return;
           controller.error(error);
+          this.controller = null;
           this.close().catch(() => {});
-        });
+        };
+        port.on("data", this.dataListener);
+        port.on("error", this.errorListener);
       },
+      pull: () => this.resumeNativePort(port),
       cancel: () => void this.close()
     });
     this._writable = new WritableStream({
@@ -7925,6 +8235,7 @@ class WebSerialPortAdapter extends EventTarget {
     if (!port)
       return;
     this.port = null;
+    this.detachNativeListeners(port);
     try {
       this.controller?.close();
     } catch {}
@@ -7940,6 +8251,28 @@ class WebSerialPortAdapter extends EventTarget {
       this.dispatchEvent(new Event("disconnect"));
     }
   }
+  detachNativeListeners(port) {
+    if (this.dataListener !== null)
+      port.off("data", this.dataListener);
+    if (this.errorListener !== null)
+      port.off("error", this.errorListener);
+    this.dataListener = null;
+    this.errorListener = null;
+    this.nativePaused = false;
+  }
+  resumeNativePort(port) {
+    if (this.port !== port || !this.nativePaused)
+      return;
+    this.nativePaused = false;
+    port.resume?.();
+  }
+  failReadableBackpressure(port, controller) {
+    if (this.port !== port || this.controller !== controller)
+      return;
+    controller.error(new Error("serial input exceeded readable-stream capacity; the native backend cannot pause"));
+    this.controller = null;
+    this.close();
+  }
   async forget() {
     await this.close();
   }
@@ -7948,29 +8281,38 @@ class WebSerialPortAdapter extends EventTarget {
 class WebSerialAdapter extends EventTarget {
   os;
   list;
+  linux;
   onconnect = () => {};
   ondisconnect = () => {};
   ports = new Map;
-  constructor(os2 = platform4(), list2 = listPorts) {
+  constructor(os2 = platform4(), list2 = listPorts, linux = linuxDiscoveryOperations) {
     super();
     this.os = os2;
     this.list = list2;
+    this.linux = linux;
   }
   async listLinuxPorts() {
-    const ttys = await readdir2("/sys/class/tty").catch(() => []);
-    const ports = [];
-    for (const name of ttys) {
+    const ttys = await this.linux.readdir("/sys/class/tty").then((names) => names.toSorted()).catch(() => []);
+    const usbAttributes = new Map;
+    const ports = await mapWithConcurrency(ttys, LINUX_DISCOVERY_CONCURRENCY, async (name) => {
       try {
-        const device = await realpath(`/sys/class/tty/${name}/device`);
-        const subsystem = await readlink2(join4(device, "subsystem")).catch(() => "");
+        const device = await this.linux.realpath(`/sys/class/tty/${name}/device`);
+        const subsystem = await this.linux.readlink(join4(device, "subsystem")).catch(() => "");
         const info = { path: `/dev/${name}` };
         if (subsystem.includes("usb")) {
-          Object.assign(info, await readLinuxUsbDeviceAttributes(device));
+          let attributes = usbAttributes.get(device);
+          if (attributes === undefined) {
+            attributes = this.linux.readUsbAttributes(device);
+            usbAttributes.set(device, attributes);
+          }
+          Object.assign(info, await attributes);
         }
-        ports.push(info);
-      } catch {}
-    }
-    return ports;
+        return info;
+      } catch {
+        return;
+      }
+    });
+    return ports.filter((port) => port !== undefined);
   }
   async getPorts() {
     if (this.os === "win32") {
@@ -8020,7 +8362,7 @@ var serial = new WebSerialAdapter;
 // src/device.ts
 var V5X_PORT_ENV = "V5X_PORT";
 function normalizePortSelector(selector) {
-  const trimmed = selector?.trim();
+  const trimmed = requireOptionValue(selector, "--port")?.trim();
   return trimmed === "" ? undefined : trimmed;
 }
 function resolvePortSelector(options = {}, environment = process.env) {
@@ -8065,7 +8407,7 @@ class SelectedSerialAdapter extends EventTarget {
     });
     if (port)
       return port;
-    throw new Error(`No port found matching ${this.selector}`);
+    throw new CliError(`No port found matching ${this.selector}`, CLI_EXIT_CODE.NO_DEVICE);
   }
 }
 function selectSerialPort(baseSerial, selector) {
@@ -8079,7 +8421,7 @@ async function connectV5Device(device = createV5Device()) {
   try {
     const result = await device.connect();
     if (result.isErr()) {
-      throw new Error(`v5 device not connected: ${result.error.message ?? result.error.kind}`);
+      throw new CliError(`v5 device not connected: ${result.error.message ?? result.error.kind}`, CLI_EXIT_CODE.NO_DEVICE, { cause: result.error });
     }
     return device;
   } catch (error) {
@@ -8153,13 +8495,28 @@ function formatCatText(bytes) {
 `) ? text : `${text}
 `;
 }
+function toCatJson(file, bytes, output) {
+  return {
+    command: "cat",
+    file,
+    bytes: bytes.length,
+    ...output === undefined ? { encoding: "base64", data: Buffer.from(bytes).toString("base64") } : { output }
+  };
+}
 function registerCatCommand(program) {
-  program.command("cat <file>", "read a file from flash").option("-o, --output", "write the file bytes to a local path").option("--port", "serial port path or id, defaults to V5X_PORT").action(async (file, options) => {
+  program.command("cat <file>", "read a file from flash").option("-o, --output", "write the file bytes to a local path").option("--json", "print machine-readable JSON").option("--port", "serial port path or id, defaults to V5X_PORT").action(async (file, options) => {
+    const output = requireOptionValue(options.output, "--output");
     const handle = parseBrainFilePath(file);
     await withSelectedV5Device(options, async (device) => {
       const bytes = unwrapSerial(await device.brain.readFile(handle), `failed to read ${file}`);
-      if (options.output !== undefined) {
-        await Bun.write(options.output, bytes);
+      if (output !== undefined) {
+        await Bun.write(output, bytes);
+        if (options.json === true)
+          printJson(toCatJson(file, bytes, output));
+        return;
+      }
+      if (options.json === true) {
+        printJson(toCatJson(file, bytes));
         return;
       }
       if (process.stdout.isTTY === true)
@@ -8922,12 +9279,14 @@ function unzipSync(data, opts) {
 var FETCH_TIMEOUT_MS = 30000;
 var PROS_ARCHIVE_LIMIT = 64 * 1024 * 1024;
 var PROS_EXTRACTED_LIMIT = 256 * 1024 * 1024;
+var SCAFFOLD_WRITE_CONCURRENCY = 8;
 var DEFAULT_PROS_TEMPLATE = {
   tag: "4.2.2",
   archiveUrl: "https://github.com/purduesigbots/pros/releases/download/4.2.2/kernel%404.2.2.zip",
   sha256: "f019642af93dc3d164d1c3e67a2a7dc75c795ac6a4d550c9221c480e2e7f4899"
 };
 function parseToolchain(type) {
+  requireOptionValue(type, "--type");
   if (type === "pros" || type === "vexide")
     return type;
   if (type === undefined) {
@@ -9025,14 +9384,20 @@ async function fetchBytes(url, description, limit) {
   return Buffer.concat(chunks, length);
 }
 async function writeFiles(root, files) {
-  for (const [relativePath, content] of Object.entries(files)) {
+  const entries = Object.entries(files);
+  const paths = entries.map(([relativePath, content]) => {
     if (isAbsolute(relativePath) || relativePath.split(/[\\/]/).includes("..")) {
       throw new Error(`template contains an unsafe path: ${relativePath}`);
     }
-    const path = join5(root, relativePath);
-    await mkdir(dirname2(path), { recursive: true });
+    return { path: join5(root, relativePath), content };
+  });
+  const directories = [...new Set(paths.map(({ path }) => dirname2(path)))];
+  await mapWithConcurrency(directories, SCAFFOLD_WRITE_CONCURRENCY, async (directory) => {
+    await mkdir(directory, { recursive: true });
+  });
+  await mapWithConcurrency(paths, SCAFFOLD_WRITE_CONCURRENCY, async ({ path, content }) => {
     await Bun.write(path, content);
-  }
+  });
 }
 async function createProsProject(path, names, source) {
   const bytes = await fetchBytes(source.archiveUrl, `download PROS kernel ${source.tag}`, PROS_ARCHIVE_LIMIT);
@@ -9157,10 +9522,10 @@ async function createProject(inputPath, toolchain, nameOrOptions = basename3(res
     try {
       await rename(stagingPath, path);
     } catch (error) {
-      const destination = await stat2(path).catch(() => {
+      const destination = await stat2(path, { bigint: true }).catch(() => {
         return;
       });
-      if (destination?.isDirectory() && (await readdir3(path)).length === 0) {
+      if (reservation !== undefined && destination?.isDirectory() && destination.dev === reservation.device && destination.ino === reservation.inode && (await readdir3(path)).length === 0) {
         await rmdir(path);
         try {
           await rename(stagingPath, path);
@@ -9294,10 +9659,13 @@ function registerKvCommand(program) {
         console.log(value);
     });
   });
-  program.command("kv set <key> <value>", "set a system variable on a brain").option("--port", "serial port path or id, defaults to V5X_PORT").action(async (key, value, options) => {
+  program.command("kv set <key> <value>", "set a system variable on a brain").option("--json", "print machine-readable JSON").option("--port", "serial port path or id, defaults to V5X_PORT").action(async (key, value, options) => {
     await withSelectedV5Device(options, async (device) => {
       unwrapSerial(await device.brain.setValue(key, value), `failed to set ${key} to ${value}`);
-      console.log(`set ${key} to ${value}`);
+      if (options.json === true)
+        printJson({ command: "kv set", key, value, set: true });
+      else
+        console.log(`set ${key} to ${value}`);
     });
   });
 }
@@ -9312,8 +9680,9 @@ function assertProjectNameArgument(name) {
 function registerNewCommand(program) {
   program.command("new <name>", "create a new V5 program", { alias: "n" }).option("-t, --type", "project toolchain (required: pros or vexide)").option("-p, --path", "destination path").option("--json", "print machine-readable JSON").action(async (name, options) => {
     const toolchain = parseToolchain(options.type);
+    const destinationPath = requireOptionValue(options.path, "--path");
     assertProjectNameArgument(name);
-    const destination = options.path === undefined ? join6(process.cwd(), name) : resolve4(options.path);
+    const destination = destinationPath === undefined ? join6(process.cwd(), name) : resolve4(destinationPath);
     const path = await createProject(destination, toolchain, {
       displayName: name,
       cargoPackageName: toolchain === "vexide" ? name : basename5(destination),
@@ -9366,38 +9735,44 @@ function registerProgramsCommand(program) {
         console.log(renderTable(["slot", "requested", "name", "size", "timestamp", "file"], formatProgramRows(programs)));
     });
   });
-  program.command("start <slot>", "start a program slot on the V5 brain").option("--port", "serial port path or id, defaults to V5X_PORT").action(async (slot, options) => {
+  program.command("start <slot>", "start a program slot on the V5 brain").option("--json", "print machine-readable JSON").option("--port", "serial port path or id, defaults to V5X_PORT").action(async (slot, options) => {
     const slotNumber = parseSlotArgument(slot);
     await withSelectedV5Device(options, async (device) => {
       unwrapSerial(await device.brain.runProgram(slotNumber), `failed to start slot ${slot}`);
-      console.log(`started slot ${slot}`);
+      if (options.json === true)
+        printJson({ command: "start", slot: slotNumber, started: true });
+      else
+        console.log(`started slot ${slot}`);
     });
   });
-  program.command("stop", "stop the running program on the V5 brain").option("--port", "serial port path or id, defaults to V5X_PORT").action(async (options) => {
+  program.command("stop", "stop the running program on the V5 brain").option("--json", "print machine-readable JSON").option("--port", "serial port path or id, defaults to V5X_PORT").action(async (options) => {
     await withSelectedV5Device(options, async (device) => {
       unwrapSerial(await device.brain.stopProgram(), "failed to stop program");
-      console.log("stopped program");
+      if (options.json === true)
+        printJson({ command: "stop", stopped: true });
+      else
+        console.log("stopped program");
     });
   });
 }
 
 // src/commands/rm.ts
 function registerRmCommand(program) {
-  program.command("rm <file>", "erase a file from flash").option("--port", "serial port path or id, defaults to V5X_PORT").action(async (file, options) => {
+  program.command("rm <file>", "erase a file from flash").option("--json", "print machine-readable JSON").option("--port", "serial port path or id, defaults to V5X_PORT").action(async (file, options) => {
     const handle = parseBrainFilePath(file);
     await withSelectedV5Device(options, async (device) => {
       unwrapSerial(await device.brain.removeFile(handle), `failed to erase ${file}`);
-      console.log(`erased ${file}`);
+      if (options.json === true)
+        printJson({ command: "rm", file, erased: true });
+      else
+        console.log(`erased ${file}`);
     });
   });
 }
 
 // src/utils/upload.ts
 function resolveSlotOption(slot) {
-  if (typeof slot === "boolean") {
-    throw new Error("--slot requires a value (e.g. --slot 1); it cannot be passed as a bare flag");
-  }
-  return Number(slot);
+  return Number(requireOptionValue(slot, "--slot"));
 }
 function resolveBuildOption(build, file) {
   if (build !== undefined)
@@ -9405,14 +9780,18 @@ function resolveBuildOption(build, file) {
   return file === undefined;
 }
 async function uploadProgramFromCommand(path, options, runDefault) {
+  const name = requireOptionValue(options.name, "--name");
+  const description = requireOptionValue(options.description, "--description");
+  const icon = requireOptionValue(options.icon, "--icon");
+  const file = requireOptionValue(options.file, "--file");
   await uploadProgram2({
     path: path ?? process.cwd(),
     slot: resolveSlotOption(options.slot),
-    name: options.name,
-    description: options.description,
-    icon: options.icon,
-    artifact: options.file,
-    build: resolveBuildOption(options.build, options.file),
+    name,
+    description,
+    icon: icon ?? "default.bmp",
+    artifact: file,
+    build: resolveBuildOption(options.build, file),
     run: options.run ?? runDefault,
     port: options.port,
     command: runDefault ? "run" : "upload",
@@ -9458,11 +9837,17 @@ async function uploadProgram2(options) {
     run: options.run
   });
   const validated = await validateProgramArtifacts(artifacts);
-  const bytes = await Bun.file(validated.hot.path).bytes();
-  const coldBytes = validated.cold ? await Bun.file(validated.cold.path).bytes() : undefined;
+  const [bytes, coldBytes] = await Promise.allSettled([
+    Bun.file(validated.hot.path).bytes(),
+    validated.cold ? Bun.file(validated.cold.path).bytes() : Promise.resolve(undefined)
+  ]);
+  if (bytes.status === "rejected")
+    throw bytes.reason;
+  if (coldBytes.status === "rejected")
+    throw coldBytes.reason;
   await withSelectedV5Device(options, async (device) => {
     const progress = reportProgress();
-    const uploaded = await device.brain.uploadProgram(config2, bytes, coldBytes, progress);
+    const uploaded = await device.brain.uploadProgram(config2, bytes.value, coldBytes.value, progress);
     progress.finish();
     if (uploaded.isErr()) {
       throw new Error(formatSerialFailure("the brain rejected the program upload", uploaded.error));
@@ -9502,18 +9887,25 @@ import { deflateSync } from "zlib";
 var WIDTH = 480;
 var HEIGHT = 272;
 var ROW_BYTES = WIDTH * 3;
+var KITTY_CHUNK_BYTES = 4096;
+var KITTY_RAW_CHUNK_BYTES = KITTY_CHUNK_BYTES / 4 * 3;
+var PNG_CRC32_TABLE = new Uint32Array(256);
+for (let index = 0;index < PNG_CRC32_TABLE.length; index++) {
+  let value = index;
+  for (let bit = 0;bit < 8; bit++) {
+    value = value >>> 1 ^ (value & 1 ? 3988292384 : 0);
+  }
+  PNG_CRC32_TABLE[index] = value >>> 0;
+}
 function assertScreenshotSize(bytes) {
   if (bytes.length !== ROW_BYTES * HEIGHT) {
     throw new Error(`bad screenshot size: ${bytes.length}`);
   }
 }
-function crc32(bytes) {
+function pngCrc32(bytes) {
   let crc2 = 4294967295;
   for (const byte of bytes) {
-    crc2 ^= byte;
-    for (let bit = 0;bit < 8; bit++) {
-      crc2 = crc2 >>> 1 ^ (crc2 & 1 ? 3988292384 : 0);
-    }
+    crc2 = crc2 >>> 8 ^ PNG_CRC32_TABLE[(crc2 ^ byte) & 255];
   }
   return (crc2 ^ 4294967295) >>> 0;
 }
@@ -9522,7 +9914,7 @@ function pngChunk(type, data) {
   chunk.writeUInt32BE(data.length, 0);
   chunk.write(type, 4, "ascii");
   chunk.set(data, 8);
-  chunk.writeUInt32BE(crc32(chunk.subarray(4, 8 + data.length)), 8 + data.length);
+  chunk.writeUInt32BE(pngCrc32(chunk.subarray(4, 8 + data.length)), 8 + data.length);
   return chunk;
 }
 function encodeScreenshotPng(bytes) {
@@ -9554,6 +9946,7 @@ ${WIDTH} ${HEIGHT}
   ]);
 }
 function parseScreenshotFormat(format) {
+  requireOptionValue(format, "--format");
   if (format === undefined || format === "png" || format === "ppm") {
     return format ?? "png";
   }
@@ -9572,36 +9965,51 @@ function assertScreenshotOptions(options) {
   if (options.json === true && options.output === undefined)
     throw new Error("--json requires --output");
 }
-function shouldPrintKittyRgb() {
-  return process.stdout.isTTY === true;
+function shouldPrintKittyRgb(environment = process.env, isTTY = process.stdout.isTTY) {
+  if (isTTY !== true)
+    return false;
+  const term = environment.TERM?.toLowerCase();
+  const termProgram = environment.TERM_PROGRAM?.toLowerCase();
+  return environment.KITTY_WINDOW_ID !== undefined || environment.WEZTERM_PANE !== undefined || term === "xterm-kitty" || term?.includes("ghostty") === true || termProgram === "kitty" || termProgram === "ghostty" || termProgram === "wezterm";
 }
-function printKittyRgb(bytes) {
+function* iterateKittyRgb(bytes) {
   assertScreenshotSize(bytes);
-  const base64 = Buffer.from(bytes).toString("base64");
-  process.stdout.write(`\x1B_Ga=T,f=24,s=${WIDTH},v=${HEIGHT},c=40;${base64}\x1B\\
-`);
+  for (let offset = 0;offset < bytes.length; offset += KITTY_RAW_CHUNK_BYTES) {
+    const payload = Buffer.from(bytes.subarray(offset, offset + KITTY_RAW_CHUNK_BYTES)).toString("base64");
+    const more = offset + KITTY_RAW_CHUNK_BYTES < bytes.length;
+    const control = offset === 0 ? `a=T,f=24,s=${WIDTH},v=${HEIGHT},c=40,m=${more ? 1 : 0}` : `m=${more ? 1 : 0}`;
+    yield `\x1B_G${control};${payload}\x1B\\${more ? "" : `
+`}`;
+  }
+}
+function printKittyRgb(bytes) {
+  for (const chunk of iterateKittyRgb(bytes))
+    process.stdout.write(chunk);
 }
 function registerScreenshotCommand(program) {
   program.command("screenshot", "take a screen capture of the brain", {
     alias: "sc"
   }).option("-o, --output", "write the screenshot to a file").option("--format", "file format for --output: png or ppm", "png").option("--port", "serial port path or id, defaults to V5X_PORT").option("--json", "print machine-readable JSON").action(async (options) => {
+    const output = requireOptionValue(options.output, "--output");
     const format = parseScreenshotFormat(options.format);
-    assertScreenshotOptions(options);
+    assertScreenshotOptions({ output, json: options.json });
     await withSelectedV5Device(options, async (device) => {
       const frame = unwrapSerial(await device.brain.captureScreen(), "failed to capture screenshot");
-      if (options.output === undefined) {
+      if (output === undefined) {
         if (shouldPrintKittyRgb())
           printKittyRgb(frame);
-        else
+        else {
           console.error("use --output to write the screenshot to a file");
+          process.exitCode = 1;
+        }
         return;
       }
       const data = format === "png" ? encodeScreenshotPng(frame) : encodeScreenshotPpm(frame);
-      await Bun.write(options.output, data);
+      await Bun.write(output, data);
       if (options.json === true)
-        printJson(toScreenshotJson(options.output, format, data.length));
+        printJson(toScreenshotJson(output, format, data.length));
       else
-        console.log(`wrote ${options.output}`);
+        console.log(`wrote ${output}`);
     });
   });
 }
@@ -9614,7 +10022,7 @@ function registerUploadCommand(program) {
 }
 
 // src/index.ts
-var program = lib_default2("v5x").version(package_default.version).describe(package_default.description);
+var program = lib_default2("v5x").version(package_default.version).describe(package_default.description).option("--verbose", "print stack traces for errors");
 var commands = [
   registerBuildCommand,
   registerCleanCommand,
@@ -9637,9 +10045,9 @@ for (const register of commands)
 try {
   await program.parse(process.argv);
 } catch (error) {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exitCode = 1;
+  console.error(isJsonOutput() ? formatCliJsonError(error) : formatCliError(error, isVerbose()));
+  process.exitCode = cliExitCode(error);
 }
 
-//# debugId=06B01D0AC71C1A8C64756E2164756E21
+//# debugId=C77D76845A1AA6D564756E2164756E21
 //# sourceMappingURL=index.js.map