@v5x/cli 0.0.1 → 0.0.3

package/dist/index.js

@@ -31,6 +31,19 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
 
 // ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS((exports, module) => {
@@ -104,7 +117,7 @@ var require_picocolors = __commonJS((exports, module) => {
 // package.json
 var package_default = {
   name: "@v5x/cli",
-  version: "0.0.1",
+  version: "0.0.3",
   description: "Command line interface for v5x.",
   license: "MIT",
   type: "module",
@@ -141,11 +154,4236 @@ var package_default = {
     "@types/bun": "^1.3.1"
   },
   dependencies: {
+    "@v5x/serial": "workspace:*",
+    "bun-serialport": "^0.1.1",
     picocolors: "^1.1.1"
   }
 };
 
 // src/index.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
-console.log(import_picocolors.default.redBright(`v5x ${package_default.version}`));
-console.log("modern cli for v5 development");
+
+// ../../node_modules/.bun/bun-serialport@0.1.1/node_modules/bun-serialport/src/serialport.js
+import { EventEmitter } from "events";
+
+// ../../node_modules/.bun/bun-serialport@0.1.1/node_modules/bun-serialport/src/bindings/posix.js
+import { dlopen, FFIType, ptr, toArrayBuffer, CString } from "bun:ffi";
+
+// ../../node_modules/.bun/bun-serialport@0.1.1/node_modules/bun-serialport/src/bindings/constants.js
+import { platform } from "os";
+var IS_LINUX = platform() === "linux";
+var IS_DARWIN = platform() === "darwin";
+if (!IS_LINUX && !IS_DARWIN) {
+  throw new Error(`bun-serialport: unsupported platform "${platform()}"`);
+}
+var O_RDWR = 2;
+var O_NOCTTY = IS_LINUX ? 256 : 131072;
+var O_NONBLOCK = IS_LINUX ? 2048 : 4;
+var TCSADRAIN = 1;
+var TCSAFLUSH = 2;
+var TCIOFLUSH = IS_LINUX ? 2 : 3;
+var CSIZE = IS_LINUX ? 48 : 768;
+var CS5 = IS_LINUX ? 0 : 0;
+var CS6 = IS_LINUX ? 16 : 256;
+var CS7 = IS_LINUX ? 32 : 512;
+var CS8 = IS_LINUX ? 48 : 768;
+var CSTOPB = IS_LINUX ? 64 : 1024;
+var CREAD = IS_LINUX ? 128 : 2048;
+var PARENB = IS_LINUX ? 256 : 4096;
+var PARODD = IS_LINUX ? 512 : 8192;
+var CLOCAL = IS_LINUX ? 2048 : 32768;
+var CRTSCTS = IS_LINUX ? 2147483648 : 196608;
+var INPCK = IS_LINUX ? 16 : 16;
+var IXON = IS_LINUX ? 1024 : 512;
+var IXOFF = IS_LINUX ? 4096 : 1024;
+var VMIN = IS_LINUX ? 6 : 16;
+var VTIME = IS_LINUX ? 5 : 17;
+var NCCS = IS_LINUX ? 32 : 20;
+var TIOCMGET = IS_LINUX ? 21525 : 1074033770;
+var TIOCMBIS = IS_LINUX ? 21526 : 2147775596;
+var TIOCMBIC = IS_LINUX ? 21527 : 2147775595;
+var TIOCM_DTR = 2;
+var TIOCM_RTS = 4;
+var TIOCM_CTS = 32;
+var TIOCM_DSR = 256;
+var TIOCM_CD = 64;
+var TIOCM_RI = 128;
+var TERMIOS_SIZE = IS_LINUX ? 60 : 72;
+var TCFLAG_SIZE = IS_LINUX ? 4 : 8;
+var TERMIOS_OFFSETS = IS_LINUX ? { c_iflag: 0, c_oflag: 4, c_cflag: 8, c_lflag: 12, c_line: 16, c_cc: 17, c_ispeed: 52, c_ospeed: 56 } : { c_iflag: 0, c_oflag: 8, c_cflag: 16, c_lflag: 24, c_cc: 32, c_ispeed: 56, c_ospeed: 64 };
+var LINUX_BAUD_MAP = {
+  0: 0,
+  110: 3,
+  300: 7,
+  600: 8,
+  1200: 9,
+  2400: 11,
+  4800: 12,
+  9600: 13,
+  19200: 14,
+  38400: 15,
+  57600: 4097,
+  115200: 4098,
+  230400: 4099,
+  460800: 4100,
+  500000: 4101,
+  576000: 4102,
+  921600: 4103,
+  1e6: 4104,
+  1152000: 4105,
+  1500000: 4106,
+  2000000: 4107,
+  2500000: 4108,
+  3000000: 4109,
+  3500000: 4110,
+  4000000: 4111
+};
+function encodeBaudRate(rate) {
+  if (IS_DARWIN)
+    return rate;
+  const encoded = LINUX_BAUD_MAP[rate];
+  if (encoded === undefined)
+    throw new Error(`Unsupported baud rate: ${rate}`);
+  return encoded;
+}
+function dataBitsFlag(bits) {
+  switch (bits) {
+    case 5:
+      return CS5;
+    case 6:
+      return CS6;
+    case 7:
+      return CS7;
+    case 8:
+      return CS8;
+    default:
+      throw new Error(`Invalid data bits: ${bits}`);
+  }
+}
+
+// ../../node_modules/.bun/bun-serialport@0.1.1/node_modules/bun-serialport/src/bindings/posix.js
+import { platform as platform2 } from "os";
+var IS_LINUX2 = platform2() === "linux";
+var IS_DARWIN2 = platform2() === "darwin";
+var LIBC_PATH = IS_LINUX2 ? "libc.so.6" : "libSystem.B.dylib";
+var libc = dlopen(LIBC_PATH, {
+  open: { args: [FFIType.cstring, FFIType.i32], returns: FFIType.i32 },
+  close: { args: [FFIType.i32], returns: FFIType.i32 },
+  read: { args: [FFIType.i32, FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+  write: { args: [FFIType.i32, FFIType.ptr, FFIType.u64], returns: FFIType.i64 },
+  tcgetattr: { args: [FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
+  tcsetattr: { args: [FFIType.i32, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
+  tcflush: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+  tcdrain: { args: [FFIType.i32], returns: FFIType.i32 },
+  cfsetispeed: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
+  cfsetospeed: { args: [FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
+  fcntl: { args: [FFIType.i32, FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+  ioctl: { args: [FFIType.i32, FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+  strerror: { args: [FFIType.i32], returns: FFIType.ptr }
+});
+var errnoLib = dlopen(LIBC_PATH, IS_LINUX2 ? { __errno_location: { args: [], returns: FFIType.ptr } } : { __error: { args: [], returns: FFIType.ptr } });
+function getErrno() {
+  const errPtr = IS_LINUX2 ? errnoLib.symbols.__errno_location() : errnoLib.symbols.__error();
+  const view = new DataView(toArrayBuffer(errPtr, 0, 4));
+  return view.getInt32(0, true);
+}
+function errnoError(syscall) {
+  const code = getErrno();
+  const msgPtr = libc.symbols.strerror(code);
+  const msg = msgPtr ? new CString(msgPtr) : `errno ${code}`;
+  const err = new Error(`${syscall}: ${msg}`);
+  err.code = code;
+  err.syscall = syscall;
+  return err;
+}
+function readFlag(buf, offset) {
+  if (TCFLAG_SIZE === 4) {
+    return buf.getUint32(offset, true);
+  }
+  return Number(buf.getBigUint64(offset, true));
+}
+function writeFlag(buf, offset, value) {
+  if (TCFLAG_SIZE === 4) {
+    buf.setUint32(offset, value >>> 0, true);
+  } else {
+    buf.setBigUint64(offset, BigInt(value >>> 0), true);
+  }
+}
+function writeSpeed(buf, offset, value) {
+  if (TCFLAG_SIZE === 4) {
+    buf.setUint32(offset, value >>> 0, true);
+  } else {
+    buf.setBigUint64(offset, BigInt(value), true);
+  }
+}
+function openPort(path, options) {
+  const {
+    baudRate = 9600,
+    dataBits = 8,
+    stopBits = 1,
+    parity = "none",
+    rtscts = false,
+    xon = false,
+    xoff = false
+  } = options;
+  const pathBuf = Buffer.from(path + "\x00", "utf-8");
+  const fd = libc.symbols.open(ptr(pathBuf), O_RDWR | O_NOCTTY | O_NONBLOCK);
+  if (fd < 0)
+    throw errnoError("open");
+  const termiosBuf = new ArrayBuffer(TERMIOS_SIZE);
+  const termiosBytes = new Uint8Array(termiosBuf);
+  const termiosView = new DataView(termiosBuf);
+  const termiosPtr = ptr(termiosBytes);
+  if (libc.symbols.tcgetattr(fd, termiosPtr) < 0) {
+    libc.symbols.close(fd);
+    throw errnoError("tcgetattr");
+  }
+  const off = TERMIOS_OFFSETS;
+  let cflag = readFlag(termiosView, off.c_cflag);
+  cflag &= ~CSIZE;
+  cflag |= dataBitsFlag(dataBits);
+  cflag |= CREAD | CLOCAL;
+  if (stopBits === 2)
+    cflag |= CSTOPB;
+  else
+    cflag &= ~CSTOPB;
+  if (parity === "none") {
+    cflag &= ~(PARENB | PARODD);
+  } else if (parity === "even") {
+    cflag |= PARENB;
+    cflag &= ~PARODD;
+  } else if (parity === "odd") {
+    cflag |= PARENB | PARODD;
+  }
+  if (rtscts)
+    cflag |= CRTSCTS;
+  else
+    cflag &= ~CRTSCTS;
+  writeFlag(termiosView, off.c_cflag, cflag);
+  let iflag = 0;
+  if (parity !== "none")
+    iflag |= INPCK;
+  if (xon)
+    iflag |= IXON;
+  if (xoff)
+    iflag |= IXOFF;
+  writeFlag(termiosView, off.c_iflag, iflag);
+  writeFlag(termiosView, off.c_oflag, 0);
+  writeFlag(termiosView, off.c_lflag, 0);
+  const ccOffset = off.c_cc;
+  for (let i = 0;i < NCCS; i++)
+    termiosBytes[ccOffset + i] = 0;
+  termiosBytes[ccOffset + VMIN] = 1;
+  termiosBytes[ccOffset + VTIME] = 0;
+  const baudCode = encodeBaudRate(baudRate);
+  if (IS_LINUX2) {
+    writeSpeed(termiosView, off.c_ispeed, baudCode);
+    writeSpeed(termiosView, off.c_ospeed, baudCode);
+  }
+  if (libc.symbols.cfsetispeed(termiosPtr, baudCode) < 0) {
+    libc.symbols.close(fd);
+    throw errnoError("cfsetispeed");
+  }
+  if (libc.symbols.cfsetospeed(termiosPtr, baudCode) < 0) {
+    libc.symbols.close(fd);
+    throw errnoError("cfsetospeed");
+  }
+  if (libc.symbols.tcsetattr(fd, TCSAFLUSH, termiosPtr) < 0) {
+    libc.symbols.close(fd);
+    throw errnoError("tcsetattr");
+  }
+  libc.symbols.tcflush(fd, TCIOFLUSH);
+  return fd;
+}
+function closePort(fd) {
+  if (libc.symbols.close(fd) < 0)
+    throw errnoError("close");
+}
+var MAX_EAGAIN_RETRIES = 1000;
+function writePort(fd, data) {
+  const buf = data instanceof Uint8Array ? data : Buffer.from(data, "utf-8");
+  let offset = 0;
+  let eagainCount = 0;
+  while (offset < buf.length) {
+    const slice = buf.subarray(offset);
+    const written = Number(libc.symbols.write(fd, ptr(slice), BigInt(slice.length)));
+    if (written < 0) {
+      const code = getErrno();
+      if (code === 11 || code === 35) {
+        if (++eagainCount > MAX_EAGAIN_RETRIES) {
+          throw new Error("write: device not accepting data (EAGAIN limit exceeded)");
+        }
+        continue;
+      }
+      throw errnoError("write");
+    }
+    eagainCount = 0;
+    offset += written;
+  }
+  return offset;
+}
+function readPort(fd, buffer) {
+  const n = Number(libc.symbols.read(fd, ptr(buffer), BigInt(buffer.length)));
+  if (n < 0) {
+    const code = getErrno();
+    if (code === 11 || code === 35)
+      return 0;
+    throw errnoError("read");
+  }
+  return n;
+}
+function updateBaudRate(fd, baudRate) {
+  const termiosBuf = new ArrayBuffer(TERMIOS_SIZE);
+  const termiosPtr = ptr(new Uint8Array(termiosBuf));
+  if (libc.symbols.tcgetattr(fd, termiosPtr) < 0)
+    throw errnoError("tcgetattr");
+  const baudCode = encodeBaudRate(baudRate);
+  if (libc.symbols.cfsetispeed(termiosPtr, baudCode) < 0)
+    throw errnoError("cfsetispeed");
+  if (libc.symbols.cfsetospeed(termiosPtr, baudCode) < 0)
+    throw errnoError("cfsetospeed");
+  if (IS_LINUX2) {
+    const view = new DataView(termiosBuf);
+    writeSpeed(view, TERMIOS_OFFSETS.c_ispeed, baudCode);
+    writeSpeed(view, TERMIOS_OFFSETS.c_ospeed, baudCode);
+  }
+  if (libc.symbols.tcsetattr(fd, TCSADRAIN, termiosPtr) < 0)
+    throw errnoError("tcsetattr");
+}
+function setModemLines(fd, flags) {
+  const { dtr, rts, brk } = flags;
+  const intBuf = new ArrayBuffer(4);
+  const intView = new DataView(intBuf);
+  const intPtr = ptr(new Uint8Array(intBuf));
+  let bitsToSet = 0;
+  let bitsToClear = 0;
+  if (dtr === true)
+    bitsToSet |= TIOCM_DTR;
+  if (dtr === false)
+    bitsToClear |= TIOCM_DTR;
+  if (rts === true)
+    bitsToSet |= TIOCM_RTS;
+  if (rts === false)
+    bitsToClear |= TIOCM_RTS;
+  if (bitsToSet) {
+    intView.setInt32(0, bitsToSet, true);
+    if (libc.symbols.ioctl(fd, TIOCMBIS, intPtr) < 0)
+      throw errnoError("ioctl TIOCMBIS");
+  }
+  if (bitsToClear) {
+    intView.setInt32(0, bitsToClear, true);
+    if (libc.symbols.ioctl(fd, TIOCMBIC, intPtr) < 0)
+      throw errnoError("ioctl TIOCMBIC");
+  }
+}
+function getModemLines(fd) {
+  const intBuf = new ArrayBuffer(4);
+  const intView = new DataView(intBuf);
+  const intPtr = ptr(new Uint8Array(intBuf));
+  if (libc.symbols.ioctl(fd, TIOCMGET, intPtr) < 0)
+    throw errnoError("ioctl TIOCMGET");
+  const bits = intView.getInt32(0, true);
+  return {
+    cts: !!(bits & TIOCM_CTS),
+    dsr: !!(bits & TIOCM_DSR),
+    dcd: !!(bits & TIOCM_CD),
+    ri: !!(bits & TIOCM_RI)
+  };
+}
+function flushPort(fd) {
+  if (libc.symbols.tcflush(fd, TCIOFLUSH) < 0)
+    throw errnoError("tcflush");
+}
+function drainPort(fd) {
+  if (libc.symbols.tcdrain(fd) < 0)
+    throw errnoError("tcdrain");
+}
+
+// ../../node_modules/.bun/bun-serialport@0.1.1/node_modules/bun-serialport/src/serialport.js
+var DEFAULT_READ_BUFFER_SIZE = 65536;
+var DEFAULT_READ_INTERVAL_MS = 1;
+
+class SerialPort extends EventEmitter {
+  #fd = -1;
+  #path;
+  #baudRate;
+  #options;
+  #isOpen = false;
+  #isClosing = false;
+  #readBuf;
+  #readInterval;
+  #readTimer = null;
+  constructor(options) {
+    super();
+    if (!options || !options.path)
+      throw new Error("options.path is required");
+    if (!options.baudRate)
+      throw new Error("options.baudRate is required");
+    this.#path = options.path;
+    this.#baudRate = options.baudRate;
+    this.#options = { ...options };
+    this.#readBuf = new Uint8Array(options.readBufferSize || DEFAULT_READ_BUFFER_SIZE);
+    this.#readInterval = options.readInterval || DEFAULT_READ_INTERVAL_MS;
+    if (options.autoOpen !== false) {
+      queueMicrotask(() => this.open().catch((err) => this.emit("error", err)));
+    }
+  }
+  get path() {
+    return this.#path;
+  }
+  get baudRate() {
+    return this.#baudRate;
+  }
+  get isOpen() {
+    return this.#isOpen && !this.#isClosing;
+  }
+  async open() {
+    if (this.#isOpen)
+      throw new Error("Port is already open");
+    try {
+      this.#fd = openPort(this.#path, this.#options);
+      this.#isOpen = true;
+      this.#isClosing = false;
+      this.#startReading();
+      this.emit("open");
+    } catch (err) {
+      this.#isOpen = false;
+      throw err;
+    }
+  }
+  async close() {
+    if (!this.#isOpen)
+      throw new Error("Port is not open");
+    if (this.#isClosing)
+      return;
+    this.#isClosing = true;
+    this.#stopReading();
+    try {
+      closePort(this.#fd);
+    } catch (err) {
+      this.#isClosing = false;
+      throw err;
+    }
+    this.#fd = -1;
+    this.#isOpen = false;
+    this.#isClosing = false;
+    this.emit("close");
+  }
+  async write(data) {
+    if (!this.#isOpen || this.#isClosing) {
+      throw new Error("Port is not open");
+    }
+    const buf = typeof data === "string" ? Buffer.from(data, "utf-8") : data;
+    return writePort(this.#fd, buf);
+  }
+  async update(options) {
+    if (!this.#isOpen)
+      throw new Error("Port is not open");
+    if (options.baudRate !== undefined) {
+      updateBaudRate(this.#fd, options.baudRate);
+      this.#baudRate = options.baudRate;
+    }
+  }
+  async set(flags) {
+    if (!this.#isOpen)
+      throw new Error("Port is not open");
+    setModemLines(this.#fd, flags);
+  }
+  async get() {
+    if (!this.#isOpen)
+      throw new Error("Port is not open");
+    return getModemLines(this.#fd);
+  }
+  async flush() {
+    if (!this.#isOpen)
+      throw new Error("Port is not open");
+    flushPort(this.#fd);
+  }
+  async drain() {
+    if (!this.#isOpen)
+      throw new Error("Port is not open");
+    drainPort(this.#fd);
+  }
+  pipe(parser) {
+    const handler = (chunk) => parser.push(chunk);
+    this.on("data", handler);
+    parser._unpipe = () => this.off("data", handler);
+    return parser;
+  }
+  unpipe(parser) {
+    if (parser && typeof parser._unpipe === "function") {
+      parser._unpipe();
+      parser._unpipe = undefined;
+    }
+  }
+  #startReading() {
+    this.#readTimer = setInterval(() => {
+      if (!this.#isOpen || this.#isClosing)
+        return;
+      try {
+        const n = readPort(this.#fd, this.#readBuf);
+        if (n > 0) {
+          const data = this.#readBuf.slice(0, n);
+          this.emit("data", data);
+        }
+      } catch (err) {
+        err.disconnected = true;
+        this.emit("error", err);
+        this.close().catch(() => {});
+      }
+    }, this.#readInterval);
+  }
+  #stopReading() {
+    if (this.#readTimer !== null) {
+      clearInterval(this.#readTimer);
+      this.#readTimer = null;
+    }
+  }
+}
+// ../../node_modules/.bun/bun-serialport@0.1.1/node_modules/bun-serialport/src/list.js
+import { platform as platform3 } from "os";
+import { readdir, readlink, access } from "fs/promises";
+import { join } from "path";
+var IS_LINUX3 = platform3() === "linux";
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readFileQuiet(path) {
+  try {
+    return (await Bun.file(path).text()).trim();
+  } catch {
+    return "";
+  }
+}
+async function listLinux() {
+  const ttys = await readdir("/sys/class/tty").catch(() => []);
+  const checks = ttys.map(async (name) => {
+    const sysPath = `/sys/class/tty/${name}`;
+    const devicePath = join(sysPath, "device");
+    if (!await exists(devicePath))
+      return null;
+    const devPath = `/dev/${name}`;
+    if (!await exists(devPath))
+      return null;
+    return { name, devPath, devicePath };
+  });
+  const valid = (await Promise.all(checks)).filter(Boolean);
+  const ports = await Promise.all(valid.map(async ({ devPath, devicePath }) => {
+    const info = { path: devPath };
+    const subsystem = await readlink(join(devicePath, "subsystem")).catch(() => "");
+    if (subsystem.includes("usb-serial") || subsystem.includes("usb")) {
+      const usbDevice = await findUsbParent(devicePath);
+      if (usbDevice) {
+        const [manufacturer, serialNumber, vendorId, productId, product] = await Promise.all([
+          readFileQuiet(join(usbDevice, "manufacturer")),
+          readFileQuiet(join(usbDevice, "serial")),
+          readFileQuiet(join(usbDevice, "idVendor")),
+          readFileQuiet(join(usbDevice, "idProduct")),
+          readFileQuiet(join(usbDevice, "product"))
+        ]);
+        info.manufacturer = manufacturer;
+        info.serialNumber = serialNumber;
+        info.vendorId = vendorId;
+        info.productId = productId;
+        info.product = product;
+      }
+    }
+    return info;
+  }));
+  return ports;
+}
+async function findUsbParent(devicePath) {
+  let current = devicePath;
+  for (let i = 0;i < 10; i++) {
+    current = join(current, "..");
+    if (await exists(join(current, "idVendor")))
+      return current;
+  }
+  return null;
+}
+async function listDarwin() {
+  const devFiles = await readdir("/dev").catch(() => []);
+  const seen = new Map;
+  for (const name of devFiles) {
+    if (!name.startsWith("cu.") && !name.startsWith("tty."))
+      continue;
+    if (name === "tty")
+      continue;
+    const isCu = name.startsWith("cu.");
+    const suffix = name.slice(isCu ? 3 : 4);
+    if (seen.has(suffix) && !isCu)
+      continue;
+    seen.set(suffix, { path: `/dev/${name}` });
+  }
+  return [...seen.values()];
+}
+async function list() {
+  return IS_LINUX3 ? listLinux() : listDarwin();
+}
+// src/adapter.ts
+import { readdir as readdir2, realpath, readlink as readlink2 } from "fs/promises";
+import { join as join2 } from "path";
+import { platform as platform4 } from "os";
+
+class WebSerialPortAdapter extends EventTarget {
+  _port = null;
+  _path;
+  _info;
+  _readable = null;
+  _writable = null;
+  _readerController = null;
+  constructor(path, info) {
+    super();
+    this._path = path;
+    this._info = info;
+  }
+  get readable() {
+    return this._readable;
+  }
+  get writable() {
+    return this._writable;
+  }
+  getInfo() {
+    return this._info;
+  }
+  async open(options) {
+    if (this._port)
+      throw new Error("Port already open");
+    this._port = new SerialPort({
+      path: this._path,
+      baudRate: options.baudRate,
+      autoOpen: false
+    });
+    await this._port.open();
+    this._readable = new ReadableStream({
+      start: (controller) => {
+        this._readerController = controller;
+        this._port?.on("data", (data) => {
+          controller.enqueue(data);
+        });
+        this._port?.on("error", (err) => {
+          controller.error(err);
+          this.close().catch(() => {});
+        });
+      },
+      cancel: () => {
+        this.close();
+      }
+    });
+    this._writable = new WritableStream({
+      write: async (chunk) => {
+        if (!this._port)
+          throw new Error("Port closed");
+        await this._port.write(chunk);
+      },
+      close: async () => {
+        await this.close();
+      }
+    });
+  }
+  async close() {
+    if (!this._port)
+      return;
+    const port = this._port;
+    this._port = null;
+    if (this._readerController) {
+      try {
+        this._readerController.close();
+      } catch (e) {}
+      this._readerController = null;
+    }
+    await port.close();
+    try {
+      port.removeAllListeners?.();
+    } catch (e) {}
+    this._readable = null;
+    this._writable = null;
+    this.dispatchEvent(new Event("disconnect"));
+  }
+}
+
+class WebSerialAdapter {
+  async _listPortsLinux() {
+    const ttys = await readdir2("/sys/class/tty").catch(() => []);
+    const ports = [];
+    for (const name of ttys) {
+      const sysPath = `/sys/class/tty/${name}`;
+      const devicePath = join2(sysPath, "device");
+      try {
+        const realDevicePath = await realpath(devicePath);
+        const subsystem = await readlink2(join2(realDevicePath, "subsystem")).catch(() => "");
+        const info = { path: `/dev/${name}` };
+        if (subsystem.includes("usb")) {
+          let current = realDevicePath;
+          for (let i = 0;i < 5; i++) {
+            try {
+              const vendorId = await Bun.file(join2(current, "idVendor")).text().then((t) => t.trim());
+              const productId = await Bun.file(join2(current, "idProduct")).text().then((t) => t.trim());
+              info.vendorId = vendorId;
+              info.productId = productId;
+              break;
+            } catch (e) {
+              current = join2(current, "..");
+            }
+          }
+        }
+        ports.push(info);
+      } catch (e) {}
+    }
+    return ports;
+  }
+  async getPorts() {
+    const ports = platform4() === "linux" ? await this._listPortsLinux() : await list();
+    return ports.map((p) => new WebSerialPortAdapter(p.path, {
+      usbVendorId: p.vendorId ? parseInt(p.vendorId, 16) : undefined,
+      usbProductId: p.productId ? parseInt(p.productId, 16) : undefined
+    }));
+  }
+  async requestPort(options) {
+    const ports = await this.getPorts();
+    if (options?.filters && options.filters.length > 0) {
+      const filtered = ports.filter((p) => {
+        const info = p.getInfo();
+        return options.filters?.some((f) => (f.usbVendorId === undefined || f.usbVendorId === info.usbVendorId) && (f.usbProductId === undefined || f.usbProductId === info.usbProductId));
+      });
+      if (filtered.length > 0)
+        return filtered[0];
+      throw new Error("No port found matching filters");
+    }
+    if (ports.length > 0)
+      return ports[0];
+    throw new Error("No port found");
+  }
+}
+var serial = new WebSerialAdapter;
+
+// ../serial/src/vex.ts
+var USER_PROG_CHUNK_SIZE = 4096;
+var USER_FLASH_USR_CODE_START = 58720256;
+// ../serial/src/vex-event.ts
+class VexEventEmitter {
+  handlers;
+  constructor() {
+    this.handlers = {};
+  }
+  on(eventName, listener) {
+    this.handlers[eventName] = this.handlers[eventName] || [];
+    this.handlers[eventName].push(listener);
+  }
+  remove(eventName, listener) {
+    this.handlers[eventName] = this.handlers[eventName] || [];
+    let index = this.handlers[eventName].indexOf(listener);
+    if (index > -1) {
+      this.handlers[eventName].splice(index, 1);
+    }
+  }
+  emit(eventName, data) {
+    (this.handlers[eventName] || []).forEach((callback) => {
+      callback(data);
+    });
+  }
+  clearListeners() {
+    Object.keys(this.handlers).forEach((e) => {
+      delete this.handlers[e];
+    });
+  }
+}
+
+class VexEventTarget {
+  emitter;
+  constructor() {
+    this.emitter = new VexEventEmitter;
+  }
+  emit(eventName, data) {
+    this.emitter.emit(String(eventName), data);
+  }
+  on(eventName, listener) {
+    this.emitter.on(String(eventName), listener);
+  }
+  remove(eventName, listener) {
+    this.emitter.remove(String(eventName), listener);
+  }
+  clearListeners() {
+    this.emitter.clearListeners();
+  }
+}
+
+// ../serial/src/vex-packet.ts
+var exports_vex_packet = {};
+__export(exports_vex_packet, {
+  WriteKeyValueReplyD2HPacket: () => WriteKeyValueReplyD2HPacket,
+  WriteKeyValueH2DPacket: () => WriteKeyValueH2DPacket,
+  WriteFileReplyD2HPacket: () => WriteFileReplyD2HPacket,
+  WriteFileH2DPacket: () => WriteFileH2DPacket,
+  UpdateMatchModeH2DPacket: () => UpdateMatchModeH2DPacket,
+  SystemVersionReplyD2HPacket: () => SystemVersionReplyD2HPacket,
+  SystemVersionH2DPacket: () => SystemVersionH2DPacket,
+  SetFileMetadataReplyD2HPacket: () => SetFileMetadataReplyD2HPacket,
+  SetFileMetadataH2DPacket: () => SetFileMetadataH2DPacket,
+  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,
+  PacketEncoder: () => PacketEncoder,
+  Packet: () => Packet,
+  MatchStatusReplyD2HPacket: () => MatchStatusReplyD2HPacket,
+  MatchModeReplyD2HPacket: () => MatchModeReplyD2HPacket,
+  LoadFileActionReplyD2HPacket: () => LoadFileActionReplyD2HPacket,
+  LoadFileActionH2DPacket: () => LoadFileActionH2DPacket,
+  LinkFileReplyD2HPacket: () => LinkFileReplyD2HPacket,
+  LinkFileH2DPacket: () => LinkFileH2DPacket,
+  InitFileTransferReplyD2HPacket: () => InitFileTransferReplyD2HPacket,
+  InitFileTransferH2DPacket: () => InitFileTransferH2DPacket,
+  HostBoundPacket: () => HostBoundPacket,
+  GetUserDataReplyD2HPacket: () => GetUserDataReplyD2HPacket,
+  GetUserDataH2DPacket: () => GetUserDataH2DPacket,
+  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,
+  EnableDeshReplyD2HPacket: () => EnableDeshReplyD2HPacket,
+  EnableDashH2DPacket: () => EnableDashH2DPacket,
+  DisableDeshReplyD2HPacket: () => DisableDeshReplyD2HPacket,
+  DisableDashH2DPacket: () => DisableDashH2DPacket,
+  DeviceBoundPacket: () => DeviceBoundPacket
+});
+
+// ../serial/src/vex-firmware-version.ts
+class VexFirmwareVersion {
+  major;
+  minor;
+  build;
+  beta;
+  constructor(major, minor, build, beta) {
+    this.major = major;
+    this.minor = minor;
+    this.build = build;
+    this.beta = beta;
+  }
+  static fromString(version) {
+    const parts = version.toLowerCase().replace(/b/g, "").split(".").map((x) => parseInt(x, 10));
+    while (parts.length < 4) {
+      parts.push(0);
+    }
+    return new VexFirmwareVersion(parts[0], parts[1], parts[2], parts[3]);
+  }
+  static fromUint8Array(data, offset = 0, reverse = false) {
+    return new VexFirmwareVersion(data[offset + (reverse ? 3 : 0)], data[offset + (reverse ? 2 : 1)], data[offset + (reverse ? 1 : 2)], data[offset + (reverse ? 0 : 3)]);
+  }
+  static allZero() {
+    return new VexFirmwareVersion(0, 0, 0, 0);
+  }
+  static fromCatalogString(version) {
+    return VexFirmwareVersion.fromString(version.replace(/_/g, "."));
+  }
+  isBeta() {
+    return this.beta !== 0;
+  }
+  toUint8Array(reverse = false) {
+    const data = new Uint8Array(4);
+    data[reverse ? 3 : 0] = this.major;
+    data[reverse ? 2 : 1] = this.minor;
+    data[reverse ? 1 : 2] = this.build;
+    data[reverse ? 0 : 3] = this.beta;
+    return data;
+  }
+  toUserString() {
+    return `${this.major}.${this.minor}.${this.build}`;
+  }
+  toInternalString() {
+    return `${this.toUserString()}.b${this.beta}`;
+  }
+  compare(that) {
+    const majorComp = this.major - that.major;
+    const minorComp = this.minor - that.minor;
+    const buildComp = this.build - that.build;
+    const betaComp = this.beta - that.beta;
+    if (majorComp !== 0) {
+      return majorComp;
+    } else if (minorComp !== 0) {
+      return minorComp;
+    } else if (buildComp !== 0) {
+      return buildComp;
+    } else if (betaComp !== 0) {
+      return betaComp;
+    }
+    return 0;
+  }
+}
+
+// ../serial/src/vex-packet-view.ts
+class PacketView {
+  view;
+  position = 0;
+  littleEndianDefault = true;
+  constructor(buffer, offset = 0, length = buffer.byteLength - offset) {
+    this.view = new DataView(buffer, offset, length);
+  }
+  static fromPacket(packet) {
+    let view = new PacketView(packet.data.buffer, packet.data.byteOffset);
+    view.position = packet.ackIndex + 1;
+    return view;
+  }
+  get byteLength() {
+    return this.view.byteLength;
+  }
+  get buffer() {
+    return this.view.buffer;
+  }
+  getInt8(byteOffset) {
+    return this.view.getInt8(byteOffset);
+  }
+  getUint8(byteOffset) {
+    return this.view.getUint8(byteOffset);
+  }
+  getInt16(byteOffset, littleEndian) {
+    return this.view.getInt16(byteOffset, littleEndian);
+  }
+  getUint16(byteOffset, littleEndian) {
+    return this.view.getUint16(byteOffset, littleEndian);
+  }
+  getInt32(byteOffset, littleEndian) {
+    return this.view.getInt32(byteOffset, littleEndian);
+  }
+  getUint32(byteOffset, littleEndian) {
+    return this.view.getUint32(byteOffset, littleEndian);
+  }
+  nextInt8() {
+    let result = this.getInt8(this.position);
+    this.position += 1;
+    return result;
+  }
+  nextUint8() {
+    let result = this.getUint8(this.position);
+    this.position += 1;
+    return result;
+  }
+  nextInt16(littleEndian = this.littleEndianDefault) {
+    let result = this.getInt16(this.position, littleEndian);
+    this.position += 2;
+    return result;
+  }
+  nextUint16(littleEndian = this.littleEndianDefault) {
+    let result = this.getUint16(this.position, littleEndian);
+    this.position += 2;
+    return result;
+  }
+  nextInt32(littleEndian = this.littleEndianDefault) {
+    let result = this.getInt32(this.position, littleEndian);
+    this.position += 4;
+    return result;
+  }
+  nextUint32(littleEndian = this.littleEndianDefault) {
+    let result = this.getUint32(this.position, littleEndian);
+    this.position += 4;
+    return result;
+  }
+  nextString(length) {
+    let result = "";
+    for (let i = 0;i < length; i++) {
+      result += String.fromCharCode(this.nextUint8());
+    }
+    return result;
+  }
+  nextNTBS(length) {
+    let result = "";
+    let lastPosition = this.position;
+    for (let i = 0;i < length; i++) {
+      if (this.byteLength <= this.position)
+        break;
+      let g = this.nextUint8();
+      if (g === 0)
+        break;
+      result += String.fromCharCode(g);
+    }
+    this.position = lastPosition + length;
+    return result;
+  }
+  nextVarNTBS(length) {
+    let result = "";
+    for (let i = 0;i < length; i++) {
+      if (this.byteLength <= this.position)
+        break;
+      let g = this.nextUint8();
+      if (g === 0)
+        break;
+      result += String.fromCharCode(g);
+    }
+    return result;
+  }
+  nextVersion(reverse = false) {
+    let result = VexFirmwareVersion.fromUint8Array(new Uint8Array(this.buffer), this.position, reverse);
+    this.position += 4;
+    return result;
+  }
+}
+
+// ../serial/src/vex-crc.ts
+var CRC16TABLE = [
+  0,
+  4129,
+  8258,
+  12387,
+  16516,
+  20645,
+  24774,
+  28903,
+  33032,
+  37161,
+  41290,
+  45419,
+  49548,
+  53677,
+  57806,
+  61935,
+  4657,
+  528,
+  12915,
+  8786,
+  21173,
+  17044,
+  29431,
+  25302,
+  37689,
+  33560,
+  45947,
+  41818,
+  54205,
+  50076,
+  62463,
+  58334,
+  9314,
+  13379,
+  1056,
+  5121,
+  25830,
+  29895,
+  17572,
+  21637,
+  42346,
+  46411,
+  34088,
+  38153,
+  58862,
+  62927,
+  50604,
+  54669,
+  13907,
+  9842,
+  5649,
+  1584,
+  30423,
+  26358,
+  22165,
+  18100,
+  46939,
+  42874,
+  38681,
+  34616,
+  63455,
+  59390,
+  55197,
+  51132,
+  18628,
+  22757,
+  26758,
+  30887,
+  2112,
+  6241,
+  10242,
+  14371,
+  51660,
+  55789,
+  59790,
+  63919,
+  35144,
+  39273,
+  43274,
+  47403,
+  23285,
+  19156,
+  31415,
+  27286,
+  6769,
+  2640,
+  14899,
+  10770,
+  56317,
+  52188,
+  64447,
+  60318,
+  39801,
+  35672,
+  47931,
+  43802,
+  27814,
+  31879,
+  19684,
+  23749,
+  11298,
+  15363,
+  3168,
+  7233,
+  60846,
+  64911,
+  52716,
+  56781,
+  44330,
+  48395,
+  36200,
+  40265,
+  32407,
+  28342,
+  24277,
+  20212,
+  15891,
+  11826,
+  7761,
+  3696,
+  65439,
+  61374,
+  57309,
+  53244,
+  48923,
+  44858,
+  40793,
+  36728,
+  37256,
+  33193,
+  45514,
+  41451,
+  53516,
+  49453,
+  61774,
+  57711,
+  4224,
+  161,
+  12482,
+  8419,
+  20484,
+  16421,
+  28742,
+  24679,
+  33721,
+  37784,
+  41979,
+  46042,
+  49981,
+  54044,
+  58239,
+  62302,
+  689,
+  4752,
+  8947,
+  13010,
+  16949,
+  21012,
+  25207,
+  29270,
+  46570,
+  42443,
+  38312,
+  34185,
+  62830,
+  58703,
+  54572,
+  50445,
+  13538,
+  9411,
+  5280,
+  1153,
+  29798,
+  25671,
+  21540,
+  17413,
+  42971,
+  47098,
+  34713,
+  38840,
+  59231,
+  63358,
+  50973,
+  55100,
+  9939,
+  14066,
+  1681,
+  5808,
+  26199,
+  30326,
+  17941,
+  22068,
+  55628,
+  51565,
+  63758,
+  59695,
+  39368,
+  35305,
+  47498,
+  43435,
+  22596,
+  18533,
+  30726,
+  26663,
+  6336,
+  2273,
+  14466,
+  10403,
+  52093,
+  56156,
+  60223,
+  64286,
+  35833,
+  39896,
+  43963,
+  48026,
+  19061,
+  23124,
+  27191,
+  31254,
+  2801,
+  6864,
+  10931,
+  14994,
+  64814,
+  60687,
+  56684,
+  52557,
+  48554,
+  44427,
+  40424,
+  36297,
+  31782,
+  27655,
+  23652,
+  19525,
+  15522,
+  11395,
+  7392,
+  3265,
+  61215,
+  65342,
+  53085,
+  57212,
+  44955,
+  49082,
+  36825,
+  40952,
+  28183,
+  32310,
+  20053,
+  24180,
+  11923,
+  16050,
+  3793,
+  7920
+];
+
+class CrcGenerator {
+  crc32Table;
+  static POLYNOMIAL_CRC32 = 79764919;
+  static POLYNOMIAL_CRC16 = 4129;
+  constructor() {
+    this.crc32Table = new Uint32Array(256);
+    this.crc32GenTable();
+  }
+  crc16(buf, initValue) {
+    const numberOfBytes = buf.byteLength;
+    let accumulator = initValue;
+    let i;
+    let j;
+    for (j = 0;j < numberOfBytes; j++) {
+      i = (accumulator >>> 8 ^ buf[j]) & 255;
+      accumulator = (accumulator << 8 ^ CRC16TABLE[i]) >>> 0;
+    }
+    return (accumulator & 65535) >>> 0;
+  }
+  crc32GenTable() {
+    var i;
+    var j;
+    var crc_accumulator;
+    for (i = 0;i < 256; i++) {
+      crc_accumulator = i << 24;
+      for (j = 0;j < 8; j++) {
+        if (crc_accumulator & 2147483648)
+          crc_accumulator = crc_accumulator << 1 ^ CrcGenerator.POLYNOMIAL_CRC32;
+        else
+          crc_accumulator = crc_accumulator << 1;
+      }
+      this.crc32Table[i] = crc_accumulator;
+    }
+  }
+  crc32(buf, initValue) {
+    const numberOfBytes = buf.byteLength;
+    let crc_accumulator = initValue;
+    let i;
+    let j;
+    for (j = 0;j < numberOfBytes; j++) {
+      i = (crc_accumulator >>> 24 ^ buf[j]) & 255;
+      crc_accumulator = (crc_accumulator << 8 ^ this.crc32Table[i]) >>> 0;
+    }
+    return (crc_accumulator & 4294967295) >>> 0;
+  }
+}
+
+// ../serial/src/vex-packet.ts
+class PacketEncoder {
+  static HEADERS_LENGTH = 4;
+  static HEADER_TO_DEVICE = [201, 54, 184, 71];
+  static HEADER_TO_HOST = [170, 85];
+  static J2000_EPOCH = 946684800;
+  vexVersion;
+  crcgen;
+  allPacketsTable = {};
+  static getInstance() {
+    if (Packet.ENCODER === undefined) {
+      Packet.ENCODER = new PacketEncoder;
+    }
+    return Packet.ENCODER;
+  }
+  constructor() {
+    this.vexVersion = 0;
+    this.crcgen = new CrcGenerator;
+    Object.values(exports_vex_packet).forEach((packet) => {
+      if (packet.prototype instanceof HostBoundPacket) {
+        this.allPacketsTable[packet.COMMAND_ID + " " + packet.COMMAND_EXTENDED_ID] = packet;
+      }
+    });
+  }
+  createHeader(buf) {
+    if (buf === undefined || buf.byteLength < PacketEncoder.HEADERS_LENGTH) {
+      buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH);
+    }
+    const h = new Uint8Array(buf);
+    h.set(PacketEncoder.HEADER_TO_DEVICE);
+    return h;
+  }
+  cdcCommand(cmd) {
+    const buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH + 1);
+    const h = this.createHeader(buf);
+    h.set([cmd], PacketEncoder.HEADERS_LENGTH);
+    return h;
+  }
+  cdcCommandWithData(cmd, data) {
+    const buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH + 2 + data.length);
+    const h = this.createHeader(buf);
+    h.set([cmd, data.length], PacketEncoder.HEADERS_LENGTH);
+    h.set(data, PacketEncoder.HEADERS_LENGTH + 2);
+    return h;
+  }
+  cdc2Command(cmd, ext) {
+    const buf = new ArrayBuffer(PacketEncoder.HEADERS_LENGTH + 5);
+    const h = this.createHeader(buf);
+    h.set([cmd, ext, 0], PacketEncoder.HEADERS_LENGTH);
+    const crc = this.crcgen.crc16(h.subarray(0, buf.byteLength - 2), 0) >>> 0;
+    h.set([crc >>> 8, crc & 255], buf.byteLength - 2);
+    return h;
+  }
+  cdc2CommandBufferLength(data) {
+    let length = PacketEncoder.HEADERS_LENGTH + data.length + 3 + 2;
+    if (data.length > 127)
+      length += 1;
+    return length;
+  }
+  cdc2CommandWithData(cmd, ext, data) {
+    const buf = new ArrayBuffer(this.cdc2CommandBufferLength(data));
+    const h = this.createHeader(buf);
+    if (data.length < 128) {
+      h.set([cmd, ext, data.length], PacketEncoder.HEADERS_LENGTH);
+      h.set(data, PacketEncoder.HEADERS_LENGTH + 3);
+    } else {
+      const length_msb = (data.length >>> 8 | 128) >>> 0;
+      const length_lsb = (data.length & 255) >>> 0;
+      h.set([cmd, ext, length_msb, length_lsb], PacketEncoder.HEADERS_LENGTH);
+      h.set(data, PacketEncoder.HEADERS_LENGTH + 4);
+    }
+    const crc = this.crcgen.crc16(h.subarray(0, buf.byteLength - 2), 0);
+    h.set([crc >>> 8, crc & 255], buf.byteLength - 2);
+    return h;
+  }
+  validateHeader(data) {
+    return !(data[0] !== PacketEncoder.HEADER_TO_HOST[0] || data[1] !== PacketEncoder.HEADER_TO_HOST[1]);
+  }
+  validateMessageCdc(data) {
+    let message = data.subarray(0, data.byteLength - 2);
+    let lastTwoBytes = (data[data.byteLength - 2] << 8) + data[data.byteLength - 1];
+    return this.crcgen.crc16(message, 0) === lastTwoBytes;
+  }
+  getPayloadSize(data) {
+    let t = 0, a = data[3];
+    if (128 & a) {
+      t = 127 & a;
+      a = data[4];
+    }
+    return (t << 8) + a;
+  }
+}
+
+class Packet {
+  data;
+  static ENCODER;
+  constructor(rawData) {
+    this.data = rawData instanceof ArrayBuffer ? new Uint8Array(rawData) : rawData;
+  }
+}
+
+class DeviceBoundPacket extends Packet {
+  constructor(payload) {
+    super(new Uint8Array);
+    let me = this.__proto__.constructor;
+    if (me.COMMAND_EXTENDED_ID === undefined) {
+      if (payload === undefined) {
+        this.data = Packet.ENCODER.cdcCommand(me.COMMAND_ID);
+      } else {
+        this.data = Packet.ENCODER.cdcCommandWithData(me.COMMAND_ID, payload);
+      }
+    } else {
+      if (payload === undefined) {
+        this.data = Packet.ENCODER.cdc2Command(me.COMMAND_ID, me.COMMAND_EXTENDED_ID);
+      } else {
+        this.data = Packet.ENCODER.cdc2CommandWithData(me.COMMAND_ID, me.COMMAND_EXTENDED_ID, payload);
+      }
+    }
+  }
+}
+
+class Query1H2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 33;
+  static COMMAND_EXTENDED_ID = undefined;
+  constructor() {
+    super(undefined);
+  }
+}
+
+class SystemVersionH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 164;
+  static COMMAND_EXTENDED_ID = undefined;
+  constructor() {
+    super(undefined);
+  }
+}
+
+class UpdateMatchModeH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 88;
+  static COMMAND_EXTENDED_ID = 193;
+  constructor(mode, matchClock) {
+    let bit1;
+    switch (mode) {
+      case "autonomous":
+        bit1 = 10;
+        break;
+      case "driver":
+        bit1 = 8;
+        break;
+      case "disabled":
+        bit1 = 11;
+    }
+    const payload = new Uint8Array(5), view = new DataView(payload.buffer);
+    payload[0] = (15 & bit1) >>> 0;
+    view.setUint32(1, matchClock, true);
+    super(payload);
+  }
+}
+
+class GetMatchStatusH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 88;
+  static COMMAND_EXTENDED_ID = 194;
+  constructor() {
+    super(undefined);
+  }
+}
+
+class GetRadioModeH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 88;
+  static COMMAND_EXTENDED_ID = 65;
+  constructor(mode) {
+    const payload = new Uint8Array(1);
+    payload[0] = mode;
+    super(payload);
+  }
+}
+
+class FileControlH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 16;
+  constructor(a, b) {
+    const payload = new Uint8Array(2);
+    payload.set([a, b], 0);
+    super(payload);
+  }
+}
+
+class InitFileTransferH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 17;
+  constructor(operation, target, vendor, options, binary, addr, name, type, version = new VexFirmwareVersion(1, 0, 0, 0)) {
+    const payload = new Uint8Array(52);
+    const view = new DataView(payload.buffer);
+    view.setUint8(0, operation);
+    view.setUint8(1, target);
+    view.setUint8(2, vendor);
+    view.setUint8(3, options);
+    view.setUint32(4, binary.length, true);
+    view.setUint32(8, addr, true);
+    view.setUint32(12, operation === 1 /* WRITE */ ? Packet.ENCODER.crcgen.crc32(binary, 0) : 0, true);
+    const re = /(?:\.([^.]+))?$/;
+    const reResult = re.exec(name);
+    let ext = reResult ? reResult[1] : undefined;
+    ext = ext === undefined ? "" : ext;
+    ext = ext === "gz" ? "bin" : ext;
+    payload.set(new TextEncoder().encode(type ?? ext), 16);
+    const timestamp = (Date.now() / 1000 >>> 0) - PacketEncoder.J2000_EPOCH;
+    view.setUint32(20, timestamp, true);
+    payload.set(version.toUint8Array(), 24);
+    const nameEncoded = new TextEncoder().encode(name);
+    let offset = nameEncoded.length - 23;
+    if (offset < 0)
+      offset = 0;
+    payload.set(nameEncoded.subarray(offset, offset + 23), 28);
+    view.setUint8(51, 0);
+    super(payload);
+  }
+}
+
+class ExitFileTransferH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 18;
+  constructor(action) {
+    let payload = new Uint8Array(1);
+    payload[0] = action;
+    super(payload);
+  }
+}
+
+class WriteFileH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 19;
+  constructor(addr, buf) {
+    const payload = new Uint8Array(4 + buf.length);
+    const view = new DataView(payload.buffer);
+    view.setUint32(0, addr, true);
+    payload.set(buf, 4);
+    super(payload);
+  }
+}
+
+class ReadFileH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 20;
+  constructor(addr, size) {
+    const payload = new Uint8Array(6);
+    const view = new DataView(payload.buffer);
+    view.setUint32(0, addr, true);
+    view.setUint16(4, size, true);
+    super(payload);
+  }
+}
+
+class LinkFileH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 21;
+  constructor(vendor, fileName, options) {
+    const str = new TextEncoder().encode(fileName);
+    let payload = new Uint8Array(26);
+    payload.set([vendor, options], 0);
+    payload.set(str.subarray(0, 23), 2);
+    super(payload);
+  }
+}
+
+class GetDirectoryFileCountH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 22;
+  constructor(vendor) {
+    let payload = new Uint8Array(2);
+    payload.set([vendor, 0], 0);
+    super(payload);
+  }
+}
+
+class GetDirectoryEntryH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 23;
+  constructor(index) {
+    let payload = new Uint8Array(2);
+    payload.set([index, 0], 0);
+    super(payload);
+  }
+}
+
+class LoadFileActionH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 24;
+  constructor(vendor, actionId, fileNameOrSlotNumber) {
+    let fileName;
+    if (typeof fileNameOrSlotNumber === "string") {
+      fileName = fileNameOrSlotNumber;
+    } else {
+      fileName = "___s_" + (fileNameOrSlotNumber - 1) + ".bin";
+    }
+    let encodedName = new TextEncoder().encode(fileName), payload = new Uint8Array(26);
+    payload.set([vendor, actionId], 0);
+    payload.set(encodedName.subarray(0, 23), 2);
+    super(payload);
+  }
+}
+
+class GetFileMetadataH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 25;
+  constructor(vendor, fileName, options) {
+    let encodedName = new TextEncoder().encode(fileName);
+    let payload = new Uint8Array(26);
+    payload.set([vendor, options], 0);
+    payload.set(encodedName.subarray(0, 23), 2);
+    super(payload);
+  }
+}
+
+class SetFileMetadataH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 26;
+  constructor(vendor, fileName, fileInfo, options) {
+    let encodedName = new TextEncoder().encode(fileName);
+    let encodedType = new TextEncoder().encode(fileInfo.type);
+    let payload = new Uint8Array(42);
+    let view = new DataView(payload.buffer);
+    view.setUint8(0, vendor);
+    view.setUint8(1, options);
+    view.setUint32(2, fileInfo.loadAddress, true);
+    payload.set(encodedType.subarray(0, 4), 6);
+    let timestamp = fileInfo.timestamp - PacketEncoder.J2000_EPOCH + 100;
+    view.setUint32(10, timestamp, true);
+    payload.set(fileInfo.version.toUint8Array(), 14);
+    payload.set(encodedName.subarray(0, 23), 18);
+    super(payload);
+  }
+}
+
+class EraseFileH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 27;
+  constructor(vendor, fileName) {
+    let encodedName = new TextEncoder().encode(fileName);
+    let payload = new Uint8Array(26);
+    payload.set([vendor, 128], 0);
+    payload.set(encodedName.subarray(0, 23), 2);
+    super(payload);
+  }
+}
+
+class GetProgramSlotInfoH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 28;
+  constructor(vendor, fileName) {
+    let encodedName = new TextEncoder().encode(fileName);
+    let payload = new Uint8Array(26);
+    payload.set([vendor, 0], 0);
+    payload.set(encodedName.subarray(0, 23), 2);
+    super(payload);
+  }
+}
+
+class FileClearUpH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 30;
+  constructor(vendor) {
+    let payload = new Uint8Array(2);
+    payload.set([vendor, 0], 0);
+    super(payload);
+  }
+}
+
+class FileFormatH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 31;
+  constructor() {
+    let payload = new Uint8Array(4);
+    payload.set([68, 67, 66, 65], 0);
+    super(payload);
+  }
+}
+
+class GetSystemFlagsH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 32;
+}
+
+class GetDeviceStatusH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 33;
+  constructor() {
+    super(undefined);
+  }
+}
+
+class GetSystemStatusH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 34;
+  constructor() {
+    super(undefined);
+  }
+}
+
+class GetFdtStatusH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 35;
+  constructor() {
+    super(undefined);
+  }
+}
+
+class GetLogCountH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 36;
+  constructor() {
+    super(undefined);
+  }
+}
+
+class ReadLogPageH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 37;
+  constructor(offset, count) {
+    let payload = new Uint8Array(8);
+    let 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;
+  constructor() {
+    super(undefined);
+  }
+}
+
+class GetUserDataH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 39;
+  constructor(e) {
+    let len = e?.length || 0;
+    if (len > 244)
+      len = 244;
+    let payload = new Uint8Array(2 + len);
+    payload[0] = 1;
+    payload[1] = len;
+    payload.set(e || new Uint8Array(0), 2);
+    super(payload);
+  }
+}
+
+class ScreenCaptureH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 40;
+  constructor(e) {
+    let payload = new Uint8Array(1);
+    payload[0] = e;
+    super(payload);
+  }
+}
+
+class SendDashTouchH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 42;
+  constructor(x, y, press) {
+    let payload = new Uint8Array(6);
+    let view = new DataView(payload.buffer);
+    view.setUint16(0, x, true);
+    view.setUint16(2, y, true);
+    view.setUint16(4, press ? 1 : 0, true);
+    super(payload);
+  }
+}
+
+class SelectDashH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 43;
+  constructor(screen, port) {
+    let payload = new Uint8Array(2);
+    payload[0] = screen;
+    payload[1] = port;
+    super(payload);
+  }
+}
+
+class EnableDashH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 44;
+  constructor(unknown1) {
+    if (unknown1 === undefined) {
+      super(undefined);
+    } else {
+      let payload = new Uint8Array(1);
+      payload[0] = unknown1;
+      super(payload);
+    }
+  }
+}
+
+class DisableDashH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 45;
+  constructor() {
+    super(undefined);
+  }
+}
+
+class ReadKeyValueH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 46;
+  constructor(key) {
+    let payload = new Uint8Array(32);
+    payload.set(new TextEncoder().encode(key), 0);
+    super(payload);
+  }
+}
+
+class WriteKeyValueH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 47;
+  constructor(key, value) {
+    let strk = new TextEncoder().encode(key);
+    const strv = new TextEncoder().encode(value);
+    if (strk.byteLength > 31)
+      strk = strk.subarray(0, 31);
+    let payload = new Uint8Array(strk.length + strv.length + 20);
+    payload.set(strk, 0);
+    payload.set(strv, strk.length + 1);
+    super(payload);
+  }
+}
+
+class GetSlot1to4InfoH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 49;
+  constructor() {
+    super(undefined);
+  }
+}
+
+class GetSlot5to8InfoH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 50;
+  constructor() {
+    super(undefined);
+  }
+}
+
+class FactoryStatusH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 241;
+}
+
+class FactoryEnableH2DPacket extends DeviceBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 255;
+  constructor() {
+    let payload = new Uint8Array(4);
+    payload.set([77, 76, 75, 74], 0);
+    super(payload);
+  }
+}
+
+class HostBoundPacket extends Packet {
+  ack = 255 /* CDC2_NACK */;
+  payloadSize;
+  ackIndex;
+  constructor(data) {
+    super(data);
+    this.payloadSize = Packet.ENCODER.getPayloadSize(this.data);
+    const n = this.payloadSize > 128 ? 5 : 4;
+    this.ack = this.data[this.ackIndex = n + 1];
+  }
+  static isValidPacket(data, n) {
+    const ack = data[n + 1];
+    return ack === 118 /* CDC2_ACK */ || ack === 167;
+  }
+}
+
+class Query1ReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 33;
+  static COMMAND_EXTENDED_ID = undefined;
+  joystickFlag1;
+  joystickFlag2;
+  brainFlag1;
+  brainFlag2;
+  bootloadFlag1;
+  bootloadFlag2;
+  constructor(data) {
+    super(data);
+    this.joystickFlag1 = this.data[4];
+    this.joystickFlag2 = this.data[5];
+    this.brainFlag1 = this.data[6];
+    this.brainFlag2 = this.data[7];
+    this.bootloadFlag1 = this.data[10];
+    this.bootloadFlag2 = this.data[11];
+  }
+}
+
+class SystemVersionReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 164;
+  static COMMAND_EXTENDED_ID = undefined;
+  version;
+  hardware;
+  constructor(data) {
+    super(data);
+    this.version = new VexFirmwareVersion(this.data[4], this.data[5], this.data[6], this.data[8]);
+    this.hardware = this.data[7];
+  }
+}
+
+class MatchModeReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 88;
+  static COMMAND_EXTENDED_ID = 193;
+  modebit;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    this.modebit = dataView.nextUint8();
+  }
+}
+
+class MatchStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 88;
+  static COMMAND_EXTENDED_ID = 194;
+  rssi;
+  systemStatusBits;
+  radioStatusBits;
+  fieldStatusBits;
+  matchClock;
+  brainBatteryPercent;
+  controllerBatteryPercent;
+  partnerControllerBatteryPercent;
+  pad;
+  buttons;
+  activeProgram;
+  radioType;
+  radioChannel;
+  radioSlot;
+  robotName;
+  controllerFlags;
+  rxSignalQuality;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    let n = this.ackIndex;
+    this.rssi = dataView.nextInt8();
+    this.systemStatusBits = dataView.nextUint16();
+    this.radioStatusBits = dataView.nextUint16();
+    this.fieldStatusBits = dataView.nextUint8();
+    this.matchClock = dataView.nextUint8();
+    this.brainBatteryPercent = dataView.nextUint8();
+    this.controllerBatteryPercent = dataView.nextUint8();
+    this.partnerControllerBatteryPercent = dataView.nextUint8();
+    this.pad = dataView.nextUint8();
+    this.buttons = dataView.nextUint16();
+    this.activeProgram = dataView.nextUint8();
+    this.radioType = dataView.nextUint8();
+    this.radioChannel = dataView.nextUint8();
+    this.radioSlot = dataView.nextUint8();
+    this.robotName = dataView.nextNTBS(10);
+    this.controllerFlags = dataView.getUint8(n + 28);
+    this.rxSignalQuality = dataView.getUint8(n + 29);
+    let rawStr = new TextDecoder("UTF-8").decode(data.slice(n + 18, n + this.payloadSize + 28));
+    const endIdx = rawStr.indexOf("\x00");
+    if (endIdx > -1) {
+      rawStr = rawStr.substr(0, endIdx);
+    }
+    this.robotName = rawStr;
+  }
+}
+
+class FileControlReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 16;
+}
+
+class InitFileTransferReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 17;
+  windowSize;
+  fileSize;
+  crc32;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    this.windowSize = dataView.nextUint16();
+    this.fileSize = dataView.nextUint32();
+    this.crc32 = dataView.nextUint32();
+  }
+}
+
+class ExitFileTransferReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 18;
+}
+
+class WriteFileReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 19;
+}
+
+class ReadFileReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 20;
+  addr;
+  length;
+  buf;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    let n = this.ackIndex;
+    this.addr = dataView.getUint32(n, true);
+    this.length = this.payloadSize - 7;
+    this.buf = this.data.slice(n + 4, n + 4 + this.length);
+  }
+  static isValidPacket(data, n) {
+    return data[4] === 4 ? data[n + 1] === 118 /* CDC2_ACK */ : true;
+  }
+}
+
+class LinkFileReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 21;
+}
+
+class GetDirectoryFileCountReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 22;
+  count;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    this.count = dataView.nextUint16();
+  }
+}
+
+class GetDirectoryEntryReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 23;
+  file;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    if (this.payloadSize > 4) {
+      this.file = {
+        index: dataView.nextUint8(),
+        size: dataView.nextUint32(),
+        loadAddress: dataView.nextUint32(),
+        crc32: dataView.nextUint32(),
+        type: dataView.nextString(4),
+        timestamp: dataView.nextUint32() + PacketEncoder.J2000_EPOCH,
+        version: dataView.nextVersion(),
+        filename: dataView.nextNTBS(32)
+      };
+    }
+  }
+}
+
+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);
+    const dataView = PacketView.fromPacket(this);
+    dataView.nextUint8();
+    if (this.payloadSize > 4) {
+      this.file = {
+        size: dataView.nextUint32(),
+        loadAddress: dataView.nextUint32(),
+        crc32: dataView.nextUint32(),
+        type: dataView.nextString(4),
+        timestamp: dataView.nextUint32() + PacketEncoder.J2000_EPOCH,
+        version: dataView.nextVersion()
+      };
+    }
+  }
+}
+
+class SetFileMetadataReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 26;
+}
+
+class EraseFileReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 27;
+}
+
+class GetProgramSlotInfoReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 28;
+  requestedSlot;
+  slot;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    this.slot = dataView.nextUint8();
+    this.requestedSlot = dataView.nextUint8();
+  }
+}
+
+class FileClearUpReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 30;
+}
+
+class FileFormatReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 31;
+}
+
+class GetSystemFlagsReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 32;
+  flags;
+  radioSearching;
+  radioQuality;
+  controllerBatteryPercent;
+  partnerControllerBatteryPercent;
+  battery;
+  currentProgram;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    this.radioSearching = false;
+    this.currentProgram = 0;
+    this.flags = dataView.nextUint32();
+    let hasPartner = (8192 & this.flags) !== 0;
+    let hasRadio = (1536 & this.flags) === 1536;
+    let byte1 = dataView.nextUint8(), byte2 = dataView.nextUint8();
+    if (this.payloadSize === 11) {
+      this.battery = 8 * (byte1 & 15);
+      if ((this.flags & 256) !== 0 || hasRadio)
+        this.controllerBatteryPercent = 8 * (byte1 >> 4 & 15);
+      if (hasRadio)
+        this.radioQuality = 8 * (byte2 & 15);
+      this.radioSearching = (this.flags & 1536) === 512;
+      if (hasPartner)
+        this.partnerControllerBatteryPercent = 8 * (byte2 >> 4 & 15);
+      this.currentProgram = dataView.nextUint8();
+      if (this.battery && this.battery > 100)
+        this.battery = 100;
+      if (this.controllerBatteryPercent && this.controllerBatteryPercent > 100)
+        this.controllerBatteryPercent = 100;
+      if (this.radioQuality && this.radioQuality > 100)
+        this.radioQuality = 100;
+      if (this.partnerControllerBatteryPercent && this.partnerControllerBatteryPercent > 100)
+        this.partnerControllerBatteryPercent = 100;
+    }
+  }
+}
+
+class GetDeviceStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 33;
+  count;
+  devices;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    this.count = dataView.nextUint8();
+    this.devices = [];
+    for (let i = 0;i < this.count; i++) {
+      this.devices.push({
+        port: dataView.nextUint8(),
+        type: dataView.nextUint8(),
+        status: dataView.nextUint8(),
+        betaversion: dataView.nextUint8(),
+        version: dataView.nextUint16(),
+        bootversion: dataView.nextUint16()
+      });
+    }
+  }
+}
+
+class GetSystemStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 34;
+  systemVersion;
+  cpu0Version;
+  cpu1Version;
+  nxpVersion;
+  touchVersion;
+  uniqueId;
+  sysflags;
+  eventBrain;
+  romBootloaderActive;
+  ramBootloaderActive;
+  goldenVersion;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    dataView.nextUint8();
+    this.systemVersion = dataView.nextVersion();
+    this.cpu0Version = dataView.nextVersion();
+    this.cpu1Version = dataView.nextVersion();
+    this.touchVersion = dataView.nextVersion(true);
+    this.uniqueId = 1234;
+    this.sysflags = [0, 0, 0, 0, 0, 0, 0];
+    this.goldenVersion = VexFirmwareVersion.allZero();
+    this.nxpVersion = VexFirmwareVersion.allZero();
+    this.eventBrain = false;
+    this.romBootloaderActive = false;
+    this.ramBootloaderActive = false;
+    if (this.payloadSize > 25) {
+      this.uniqueId = dataView.nextUint32();
+      this.sysflags = [
+        dataView.nextUint8(),
+        dataView.nextUint8(),
+        dataView.nextUint8(),
+        dataView.nextUint8(),
+        dataView.nextUint8(),
+        0,
+        dataView.nextUint8()
+      ];
+      this.eventBrain = (1 & this.sysflags[6]) !== 0;
+      this.romBootloaderActive = (2 & this.sysflags[6]) !== 0;
+      this.ramBootloaderActive = (4 & this.sysflags[6]) !== 0;
+      dataView.nextUint16();
+      this.goldenVersion = dataView.nextVersion();
+    }
+    if (this.payloadSize > 37) {
+      this.nxpVersion = dataView.nextVersion();
+    }
+  }
+}
+
+class GetFdtStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 35;
+  count;
+  status;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    this.count = dataView.nextUint8();
+    this.status = [];
+    for (let i = 0;i < this.count; i++) {
+      this.status.push({
+        index: dataView.nextUint8(),
+        type: dataView.nextUint8(),
+        status: dataView.nextUint8(),
+        betaversion: dataView.nextUint8(),
+        version: dataView.nextUint16(),
+        bootversion: dataView.nextUint16()
+      });
+    }
+  }
+}
+
+class GetLogCountReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 36;
+  count;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    dataView.nextUint8();
+    this.count = dataView.nextUint32();
+  }
+}
+
+class ReadLogPageReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 37;
+  offset;
+  count;
+  entries;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    let n = this.ackIndex;
+    let size = dataView.nextUint8();
+    this.offset = dataView.nextUint32();
+    this.count = dataView.nextUint16();
+    this.entries = [];
+    let j = n + 8;
+    for (let i = 0;i < this.count; i++) {
+      this.entries.push({
+        code: dataView.getUint8(j),
+        type: dataView.getUint8(j + 1),
+        desc: dataView.getUint8(j + 2),
+        spare: dataView.getUint8(j + 3),
+        time: dataView.getUint32(j + 4, true)
+      });
+      j += size;
+    }
+  }
+}
+
+class GetRadioStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 38;
+  device;
+  quality;
+  strength;
+  channel;
+  timeslot;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    let n = this.ackIndex;
+    this.device = dataView.nextUint8();
+    this.quality = dataView.nextUint16();
+    this.strength = dataView.nextInt16();
+    this.channel = this.data[n + 6];
+    this.timeslot = this.data[n + 7];
+  }
+}
+
+class GetUserDataReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 39;
+}
+
+class ScreenCaptureReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 40;
+}
+
+class SendDashTouchReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 42;
+}
+
+class SelectDashReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 43;
+}
+
+class EnableDeshReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 44;
+}
+
+class DisableDeshReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 45;
+}
+
+class ReadKeyValueReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 46;
+  value;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    this.value = dataView.nextVarNTBS(255);
+  }
+}
+
+class WriteKeyValueReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 47;
+}
+
+class GetSlot1to4InfoReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 49;
+  slotFlags;
+  slots;
+  constructor(data, start = 1) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    this.slotFlags = dataView.nextUint8();
+    this.slots = [];
+    for (let i = 0;i < 4; i++) {
+      let hasData = (this.slotFlags & Math.pow(2, start - 1 + i)) !== 0;
+      if (!hasData)
+        continue;
+      let iconNum = dataView.nextUint16();
+      let nameLen = dataView.nextUint8();
+      let name = dataView.nextString(nameLen);
+      this.slots.push({
+        slot: start + i,
+        icon: iconNum,
+        name
+      });
+    }
+  }
+}
+
+class GetSlot5to8InfoReplyD2HPacket extends GetSlot1to4InfoReplyD2HPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 50;
+  slotStartIndex = 5;
+  constructor(data) {
+    super(data, 5);
+  }
+}
+
+class FactoryStatusReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 241;
+  status;
+  percent;
+  constructor(data) {
+    super(data);
+    const dataView = PacketView.fromPacket(this);
+    this.status = dataView.nextUint8();
+    this.percent = dataView.nextUint8();
+  }
+}
+
+class FactoryEnableReplyD2HPacket extends HostBoundPacket {
+  static COMMAND_ID = 86;
+  static COMMAND_EXTENDED_ID = 255;
+}
+
+// ../serial/src/vex-connection.ts
+var thePacketEncoder = PacketEncoder.getInstance();
+
+class VexSerialConnection extends VexEventTarget {
+  filters = [{ usbVendorId: 10376 }];
+  writer;
+  reader;
+  port;
+  serial;
+  isClosing = false;
+  callbacksQueue = [];
+  get isConnected() {
+    return this.port && this.reader && this.writer ? true : false;
+  }
+  constructor(serial2) {
+    super();
+    this.serial = serial2;
+  }
+  async close() {
+    if (this.isClosing)
+      return;
+    if (!this.isConnected)
+      return;
+    this.isClosing = true;
+    for (const callbackInfo of this.callbacksQueue) {
+      clearTimeout(callbackInfo.timeout);
+    }
+    this.callbacksQueue = [];
+    try {
+      await this.writer?.close();
+      this.writer = undefined;
+    } catch (e) {}
+    try {
+      await this.reader?.cancel();
+      try {
+        while (this.reader) {
+          const { value, done } = await this.reader.read();
+          if (done)
+            break;
+        }
+      } catch (e) {}
+      this.reader = undefined;
+    } catch (e) {}
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 1));
+      await this.port?.close();
+      this.port = undefined;
+    } catch (e) {
+      console.warn("Close port error.", e);
+    } finally {
+      this.isClosing = false;
+      this.emit("disconnected", undefined);
+    }
+  }
+  async open(use = 0, askUser = true) {
+    if (this.port)
+      throw new Error("Already connected.");
+    let port;
+    if (use !== undefined) {
+      let ports = (await this.serial.getPorts()).filter((p) => {
+        let info = p.getInfo();
+        return this.filters.find((f) => (f.usbVendorId === undefined || f.usbVendorId === info.usbVendorId) && (f.usbProductId === undefined || f.usbProductId === info.usbProductId));
+      }).filter((e) => !e.readable);
+      port = ports[use];
+    }
+    if (!port && askUser) {
+      try {
+        port = await this.serial.requestPort({ filters: this.filters });
+      } catch (e) {
+        throw new Error("No valid port selected.");
+      }
+    }
+    if (!port)
+      return;
+    if (port.readable)
+      return false;
+    try {
+      await port.open({ baudRate: 115200 });
+      this.port = port;
+      this.port.addEventListener("disconnect", async () => {
+        await this.close();
+      });
+      this.emit("connected", undefined);
+      this.writer = this.port.writable.getWriter();
+      this.reader = this.port.readable.getReader();
+      this.startReader();
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  writeData(rawData, resolve, timeout = 1000) {
+    this.writeDataAsync(rawData, timeout).then(resolve);
+  }
+  writeDataAsync(rawData, timeout = 1000) {
+    return new Promise(async (done) => {
+      if (this.writer === undefined) {
+        done(255 /* CDC2_NACK */);
+        return;
+      }
+      let data = rawData instanceof DeviceBoundPacket ? rawData.data : rawData;
+      let cb = {
+        callback: done,
+        timeout: setTimeout(() => {
+          this.callbacksQueue.shift()?.callback(256 /* TIMEOUT */);
+        }, timeout),
+        wantedCommandId: rawData instanceof DeviceBoundPacket ? rawData.constructor.COMMAND_ID : undefined,
+        wantedCommandExId: rawData instanceof DeviceBoundPacket ? rawData.constructor.COMMAND_EXTENDED_ID : undefined
+      };
+      this.callbacksQueue.push(cb);
+      try {
+        this.writer.write(data).then(() => {
+          logData(data, 100);
+        });
+      } catch (error) {
+        this.callbacksQueue.splice(this.callbacksQueue.indexOf(cb), 1);
+        done(257 /* WRITE_ERROR */);
+        return;
+      }
+    });
+  }
+  async readData(cache, expectedSize) {
+    if (!this.reader)
+      throw new Error("No reader");
+    while (cache.byteLength < expectedSize) {
+      const { value: readData, done: isDone } = await this.reader.read();
+      if (isDone)
+        throw new Error("No data");
+      cache = binaryArrayJoin(cache, readData);
+    }
+    return cache;
+  }
+  async startReader() {
+    let cache = new Uint8Array([]), sliceIdx = 0;
+    for (;; )
+      try {
+        cache = await this.readData(cache, 5);
+        sliceIdx = 0;
+        if (!thePacketEncoder.validateHeader(cache))
+          throw new Error("Invalid header");
+        const payloadExpectedSize = thePacketEncoder.getPayloadSize(cache);
+        const n = payloadExpectedSize > 128 ? 5 : 4;
+        const totalSize = n + payloadExpectedSize;
+        cache = await this.readData(cache, totalSize);
+        sliceIdx = totalSize + 1;
+        const cmdId = cache[2];
+        const hasExtId = cmdId == 88 || cmdId == 86;
+        const cmdExId = hasExtId ? cache[n] : undefined;
+        const ack = cache[n + 1];
+        if (hasExtId) {
+          if (!thePacketEncoder.validateMessageCdc(cache))
+            throw new Error("Invalid message CDC");
+        }
+        let callbackInfo;
+        let wantedCmdId;
+        let wantedCmdExId;
+        let tryIdx = 0;
+        while (callbackInfo = this.callbacksQueue[tryIdx++]) {
+          wantedCmdId = callbackInfo?.wantedCommandId;
+          wantedCmdExId = callbackInfo?.wantedCommandExId;
+          if (wantedCmdId !== undefined && wantedCmdId !== cmdId || wantedCmdExId !== undefined && wantedCmdExId !== cmdExId) {
+            continue;
+          }
+          break;
+        }
+        if (callbackInfo === undefined) {
+          console.warn("Unexpected command", cmdId, cmdExId, ack);
+          continue;
+        }
+        let data = cache.slice(0, sliceIdx);
+        let packageType = thePacketEncoder.allPacketsTable[wantedCmdId + " " + wantedCmdExId];
+        if (wantedCmdId === undefined && wantedCmdExId === undefined || packageType === undefined) {
+          callbackInfo.callback(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
+        } else {
+          if (!hasExtId || packageType.isValidPacket(data, n)) {
+            callbackInfo.callback(new packageType(data));
+          } else {
+            console.warn("ack", ack);
+            callbackInfo.callback(ack);
+          }
+        }
+        clearTimeout(callbackInfo.timeout);
+        this.callbacksQueue.splice(tryIdx - 1, 1);
+      } catch (e) {
+        if (this.isClosing)
+          break;
+        console.warn("Read error.", e, cache);
+        await this.close();
+        break;
+      } finally {
+        cache = cache.slice(sliceIdx);
+      }
+  }
+  async query1() {
+    let result = await this.writeDataAsync(new Query1H2DPacket, 100);
+    return result instanceof Query1ReplyD2HPacket ? result : null;
+  }
+  async getSystemVersion() {
+    let result = await this.writeDataAsync(new SystemVersionH2DPacket);
+    return result instanceof SystemVersionReplyD2HPacket ? result.version : null;
+  }
+}
+
+class V5SerialConnection extends VexSerialConnection {
+  filters = [
+    { usbVendorId: 10376, usbProductId: 1281 /* V5_BRAIN */ },
+    { usbVendorId: 10376, usbProductId: 1282 /* V5_BRAIN_DFU */ },
+    { usbVendorId: 10376, usbProductId: 1283 /* V5_CONTROLLER */ }
+  ];
+  async getDeviceStatus() {
+    let result = await this.writeDataAsync(new GetDeviceStatusH2DPacket);
+    return result instanceof GetDeviceStatusReplyD2HPacket ? result : null;
+  }
+  async getRadioStatus() {
+    let result = await this.writeDataAsync(new GetRadioStatusH2DPacket);
+    return result instanceof GetRadioStatusReplyD2HPacket ? result : null;
+  }
+  async getSystemFlags() {
+    let result = await this.writeDataAsync(new GetSystemFlagsH2DPacket);
+    return result instanceof GetSystemFlagsReplyD2HPacket ? result : null;
+  }
+  async getSystemStatus(timeout = 1000) {
+    let result = await this.writeDataAsync(new GetSystemStatusH2DPacket, timeout);
+    return result instanceof GetSystemStatusReplyD2HPacket ? result : null;
+  }
+  async getMatchStatus() {
+    let result = await this.writeDataAsync(new GetMatchStatusH2DPacket);
+    return result instanceof MatchStatusReplyD2HPacket ? result : null;
+  }
+  async uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback) {
+    let iniFileBuffer = new TextEncoder().encode(iniConfig.createIni());
+    let basename = iniConfig.baseName;
+    let iniRequest = {
+      filename: basename + ".ini",
+      buf: iniFileBuffer,
+      downloadTarget: 1 /* FILE_TARGET_QSPI */,
+      vid: 1 /* USER */,
+      autoRun: false
+    };
+    let r1 = await this.uploadFileToDevice(iniRequest, (current, total) => progressCallback("INI", current, total));
+    if (!r1)
+      return false;
+    let coldRequest = coldFileBuf !== undefined ? {
+      filename: basename + "_lib.bin",
+      buf: coldFileBuf,
+      downloadTarget: 1 /* FILE_TARGET_QSPI */,
+      vid: 24,
+      autoRun: false
+    } : undefined;
+    if (coldRequest) {
+      let r2 = await this.uploadFileToDevice(coldRequest, (current, total) => progressCallback("COLD", current, total));
+      if (!r2)
+        return;
+    }
+    let binRequest = {
+      filename: basename + ".bin",
+      buf: binFileBuf,
+      downloadTarget: 1 /* FILE_TARGET_QSPI */,
+      vid: 1 /* USER */,
+      loadAddress: coldFileBuf ? 125829120 : undefined,
+      autoRun: iniConfig.autorun,
+      linkedFile: coldRequest
+    };
+    let r3 = await this.uploadFileToDevice(binRequest, (current, total) => progressCallback("BIN", current, total));
+    return r3;
+  }
+  async downloadFileToHost(request, downloadTarget = 1 /* FILE_TARGET_QSPI */, progressCallback) {
+    let { filename, vendor, loadAddress, size } = request;
+    let nextAddress = loadAddress ?? USER_FLASH_USR_CODE_START;
+    let p1 = await this.writeDataAsync(new InitFileTransferH2DPacket(2 /* READ */, downloadTarget, vendor, 0 /* NONE */, new Uint8Array, nextAddress, filename, ""));
+    if (!(p1 instanceof InitFileTransferReplyD2HPacket))
+      throw new Error("InitFileTransferH2DPacket failed");
+    let fileSize = size ?? p1.fileSize;
+    let bufferChunkSize = p1.windowSize > 0 && p1.windowSize <= USER_PROG_CHUNK_SIZE ? p1.windowSize : USER_PROG_CHUNK_SIZE;
+    let bufferOffset = 0;
+    let fileBuf = new Uint8Array(fileSize + bufferChunkSize);
+    let lastBlock = false;
+    while (!lastBlock) {
+      if (fileSize <= bufferOffset + bufferChunkSize) {
+        lastBlock = true;
+      }
+      let p2 = await this.writeDataAsync(new ReadFileH2DPacket(nextAddress, bufferChunkSize), 3000);
+      if (!(p2 instanceof ReadFileReplyD2HPacket))
+        throw new Error("ReadFileReplyD2HPacket failed");
+      fileBuf.set(new Uint8Array(p2.buf), bufferOffset);
+      if (progressCallback)
+        progressCallback(bufferOffset, fileSize);
+      bufferOffset += bufferChunkSize;
+      nextAddress += bufferChunkSize;
+    }
+    let p3 = await this.writeDataAsync(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */), 30000);
+    fileBuf = fileBuf.slice(0, fileSize);
+    return fileBuf;
+  }
+  async uploadFileToDevice(request, progressCallback) {
+    let {
+      filename,
+      buf,
+      downloadTarget,
+      vendor,
+      loadAddress,
+      exttype,
+      autoRun,
+      linkedFile
+    } = request;
+    if (buf === undefined) {
+      return false;
+    }
+    downloadTarget = downloadTarget ?? 1 /* FILE_TARGET_QSPI */;
+    vendor = vendor ?? 1 /* USER */;
+    let nextAddress = loadAddress ?? USER_FLASH_USR_CODE_START;
+    console.log("init file transfer", filename);
+    let p1 = await this.writeDataAsync(new InitFileTransferH2DPacket(1 /* WRITE */, downloadTarget, vendor, 1 /* OVERWRITE */, buf, nextAddress, filename, exttype));
+    if (!(p1 instanceof InitFileTransferReplyD2HPacket))
+      throw new Error("InitFileTransferH2DPacket failed");
+    console.log(p1);
+    if (linkedFile !== undefined) {
+      let p3 = await this.writeDataAsync(new LinkFileH2DPacket(linkedFile.vendor ?? 1 /* USER */, linkedFile.filename, 0), 1e4);
+      if (!(p3 instanceof LinkFileReplyD2HPacket))
+        throw new Error("LinkFileH2DPacket failed");
+    }
+    let bufferChunkSize = p1.windowSize > 0 && p1.windowSize <= USER_PROG_CHUNK_SIZE ? p1.windowSize : USER_PROG_CHUNK_SIZE;
+    let bufferOffset = 0;
+    let lastBlock = false;
+    while (!lastBlock) {
+      var tmpbuf;
+      if (buf.byteLength - bufferOffset > bufferChunkSize) {
+        tmpbuf = buf.subarray(bufferOffset, bufferOffset + bufferChunkSize);
+      } else {
+        let length = (buf.byteLength - bufferOffset + 3) / 4 >>> 0;
+        tmpbuf = new Uint8Array(length * 4);
+        tmpbuf.set(buf.subarray(bufferOffset, buf.byteLength));
+        lastBlock = true;
+      }
+      let p2 = await this.writeDataAsync(new WriteFileH2DPacket(nextAddress, tmpbuf), 3000);
+      if (!(p2 instanceof WriteFileReplyD2HPacket))
+        throw new Error("WriteFileReplyD2HPacket failed");
+      if (progressCallback)
+        progressCallback(bufferOffset, buf.byteLength);
+      bufferOffset += bufferChunkSize;
+      nextAddress += bufferChunkSize;
+    }
+    let p4 = await this.writeDataAsync(new ExitFileTransferH2DPacket(autoRun ? 1 /* EXIT_RUN */ : 3 /* EXIT_HALT */), 30000);
+    return p4 instanceof ExitFileTransferReplyD2HPacket;
+  }
+  async setMatchMode(mode) {
+    let result = await this.writeDataAsync(new UpdateMatchModeH2DPacket(mode, 0));
+    return result instanceof MatchModeReplyD2HPacket ? result : null;
+  }
+  async loadProgram(value) {
+    let result = await this.writeDataAsync(new LoadFileActionH2DPacket(1 /* USER */, 0 /* RUN */, value));
+    return result instanceof LoadFileActionReplyD2HPacket ? result : null;
+  }
+  async stopProgram() {
+    let result = await this.writeDataAsync(new LoadFileActionH2DPacket(1 /* USER */, 128 /* STOP */, ""));
+    return result instanceof LoadFileActionReplyD2HPacket ? result : null;
+  }
+  async mockTouch(x, y, press) {
+    let result = await this.writeDataAsync(new SendDashTouchH2DPacket(x, y, press));
+    return result instanceof SendDashTouchReplyD2HPacket ? result : null;
+  }
+}
+function logData(data, limitedSize) {
+  if (data === undefined)
+    return;
+  limitedSize || (limitedSize = data.length);
+  let a = "";
+  for (let n = 0;n < data.length && n < limitedSize; n++)
+    a += ("00" + data[n].toString(16)).substr(-2, 2) + " ";
+  limitedSize < data.length && (a += " ... ");
+}
+function binaryArrayJoin(left, right) {
+  const leftSize = left ? left.byteLength : 0;
+  const rightSize = right ? right.byteLength : 0;
+  const all = new Uint8Array(leftSize + rightSize);
+  return all.length === 0 ? new Uint8Array : (left && all.set(left instanceof Uint8Array ? left : new Uint8Array(left), 0), right && all.set(right instanceof Uint8Array ? right : new Uint8Array(right), leftSize), all);
+}
+// ../../node_modules/.bun/unzipit@2.0.1/node_modules/unzipit/dist/unzipit.module.js
+var _a;
+var _b;
+function readBlobAsArrayBuffer(blob) {
+  if (blob.arrayBuffer) {
+    return blob.arrayBuffer();
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader;
+    reader.addEventListener("loadend", () => {
+      resolve(reader.result);
+    });
+    reader.addEventListener("error", reject);
+    reader.readAsArrayBuffer(blob);
+  });
+}
+async function readBlobAsUint8Array(blob) {
+  const arrayBuffer = await readBlobAsArrayBuffer(blob);
+  return new Uint8Array(arrayBuffer);
+}
+function isBlob(v) {
+  return typeof Blob !== "undefined" && v instanceof Blob;
+}
+function isSharedArrayBuffer(b) {
+  return typeof SharedArrayBuffer !== "undefined" && b instanceof SharedArrayBuffer;
+}
+var isNode = typeof process !== "undefined" && !!(process === null || process === undefined ? undefined : process.versions) && typeof ((_a = process === null || process === undefined ? undefined : process.versions) === null || _a === undefined ? undefined : _a.node) !== "undefined" && typeof ((_b = process === null || process === undefined ? undefined : process.versions) === null || _b === undefined ? undefined : _b.electron) === "undefined";
+function isTypedArraySameAsArrayBuffer(typedArray) {
+  return typedArray.byteOffset === 0 && typedArray.byteLength === typedArray.buffer.byteLength;
+}
+
+class ArrayBufferReader {
+  constructor(arrayBufferOrView) {
+    this.typedArray = arrayBufferOrView instanceof ArrayBuffer || isSharedArrayBuffer(arrayBufferOrView) ? new Uint8Array(arrayBufferOrView) : new Uint8Array(arrayBufferOrView.buffer, arrayBufferOrView.byteOffset, arrayBufferOrView.byteLength);
+  }
+  async getLength() {
+    return this.typedArray.byteLength;
+  }
+  async read(offset, length) {
+    return new Uint8Array(this.typedArray.buffer, this.typedArray.byteOffset + offset, length);
+  }
+}
+
+class BlobReader {
+  constructor(blob) {
+    this.blob = blob;
+  }
+  async getLength() {
+    return this.blob.size;
+  }
+  async read(offset, length) {
+    const blob = this.blob.slice(offset, offset + length);
+    const arrayBuffer = await readBlobAsArrayBuffer(blob);
+    return new Uint8Array(arrayBuffer);
+  }
+  async sliceAsBlob(offset, length, type = "") {
+    return this.blob.slice(offset, offset + length, type);
+  }
+}
+var config = {
+  numWorkers: 1,
+  workerURL: "",
+  useWorkers: false
+};
+var nextId = 0;
+var numWorkers = 0;
+var canUseWorkers = true;
+var workers = [];
+var availableWorkers = [];
+var waitingForWorkerQueue = [];
+var currentlyProcessingIdToRequestMap = new Map;
+function handleResult(e) {
+  makeWorkerAvailable(e.target);
+  const { id, error, data } = e.data;
+  const request = currentlyProcessingIdToRequestMap.get(id);
+  currentlyProcessingIdToRequestMap.delete(id);
+  if (error) {
+    request.reject(error);
+  } else {
+    request.resolve(data);
+  }
+}
+function startWorker(url) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(url);
+    worker.onmessage = (e) => {
+      if (e.data === "start") {
+        worker.onerror = null;
+        worker.onmessage = null;
+        resolve(worker);
+      } else {
+        reject(new Error(`unexpected message: ${e.data}`));
+      }
+    };
+    worker.onerror = reject;
+  });
+}
+var workerHelper = function() {
+  if (isNode) {
+    return {
+      async createWorker(url) {
+        const moduleId = "node:worker_threads";
+        const { Worker: Worker2 } = await import(moduleId);
+        return new Worker2(url);
+      },
+      addEventListener(worker, fn) {
+        worker.on("message", (data) => {
+          fn({ target: worker, data });
+        });
+      },
+      async terminate(worker) {
+        await worker.terminate();
+      }
+    };
+  } else {
+    return {
+      async createWorker(url) {
+        try {
+          const worker = await startWorker(url);
+          return worker;
+        } catch (_e) {
+          console.warn("could not load worker:", url);
+        }
+        let text;
+        try {
+          const req = await fetch(url, { mode: "cors" });
+          if (!req.ok) {
+            throw new Error(`could not load: ${url}`);
+          }
+          text = await req.text();
+          url = URL.createObjectURL(new Blob([text], { type: "application/javascript" }));
+          const worker = await startWorker(url);
+          config.workerURL = url;
+          return worker;
+        } catch (_e) {
+          console.warn("could not load worker via fetch:", url);
+        }
+        if (text !== undefined) {
+          try {
+            url = `data:application/javascript;base64,${btoa(text)}`;
+            const worker = await startWorker(url);
+            config.workerURL = url;
+            return worker;
+          } catch (_e) {
+            console.warn("could not load worker via dataURI");
+          }
+        }
+        console.warn("workers will not be used");
+        throw new Error("can not start workers");
+      },
+      addEventListener(worker, fn) {
+        worker.addEventListener("message", fn);
+      },
+      async terminate(worker) {
+        worker.terminate();
+      }
+    };
+  }
+}();
+function makeWorkerAvailable(worker) {
+  availableWorkers.push(worker);
+  processWaitingForWorkerQueue();
+}
+async function getAvailableWorker() {
+  if (availableWorkers.length === 0 && numWorkers < config.numWorkers) {
+    ++numWorkers;
+    try {
+      const worker = await workerHelper.createWorker(config.workerURL);
+      workers.push(worker);
+      availableWorkers.push(worker);
+      workerHelper.addEventListener(worker, handleResult);
+    } catch (_e) {
+      canUseWorkers = false;
+    }
+  }
+  return availableWorkers.pop();
+}
+async function decompressRaw(src) {
+  const ds = new DecompressionStream("deflate-raw");
+  const writer = ds.writable.getWriter();
+  writer.write(src).then(() => writer.close()).catch(() => {});
+  const chunks = [];
+  const reader = ds.readable.getReader();
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    chunks.push(value);
+  }
+  const size = chunks.reduce((s, c) => s + c.byteLength, 0);
+  const result = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+async function inflateRawLocal(src, type, resolve, reject) {
+  try {
+    const dst = await decompressRaw(src);
+    resolve(type ? new Blob([dst], { type }) : dst.buffer);
+  } catch (e) {
+    reject(e);
+  }
+}
+async function processWaitingForWorkerQueue() {
+  if (waitingForWorkerQueue.length === 0) {
+    return;
+  }
+  if (config.useWorkers && canUseWorkers) {
+    const worker = await getAvailableWorker();
+    if (canUseWorkers) {
+      if (worker) {
+        if (waitingForWorkerQueue.length === 0) {
+          makeWorkerAvailable(worker);
+          return;
+        }
+        const { id, src, uncompressedSize, type, resolve, reject } = waitingForWorkerQueue.shift();
+        currentlyProcessingIdToRequestMap.set(id, { id, src, uncompressedSize, type, resolve, reject });
+        const transferables = [];
+        worker.postMessage({
+          type: "inflate",
+          data: {
+            id,
+            type,
+            src,
+            uncompressedSize
+          }
+        }, transferables);
+      }
+      return;
+    }
+  }
+  while (waitingForWorkerQueue.length) {
+    const { src, type, resolve, reject } = waitingForWorkerQueue.shift();
+    const data = isBlob(src) ? await readBlobAsUint8Array(src) : src;
+    inflateRawLocal(data, type, resolve, reject);
+  }
+}
+function inflateRawAsync(src, uncompressedSize, type) {
+  return new Promise((resolve, reject) => {
+    waitingForWorkerQueue.push({ src, uncompressedSize, type, resolve, reject, id: nextId++ });
+    processWaitingForWorkerQueue();
+  });
+}
+function dosDateTimeToDate(date, time) {
+  const day = date & 31;
+  const month = (date >> 5 & 15) - 1;
+  const year = (date >> 9 & 127) + 1980;
+  const millisecond = 0;
+  const second = (time & 31) * 2;
+  const minute = time >> 5 & 63;
+  const hour = time >> 11 & 31;
+  return new Date(year, month, day, hour, minute, second, millisecond);
+}
+
+class ZipEntry {
+  constructor(reader, rawEntry) {
+    this._reader = reader;
+    this._rawEntry = rawEntry;
+    this.name = rawEntry.name;
+    this.nameBytes = rawEntry.nameBytes;
+    this.size = rawEntry.uncompressedSize;
+    this.compressedSize = rawEntry.compressedSize;
+    this.comment = rawEntry.comment;
+    this.commentBytes = rawEntry.commentBytes;
+    this.compressionMethod = rawEntry.compressionMethod;
+    this.lastModDate = dosDateTimeToDate(rawEntry.lastModFileDate, rawEntry.lastModFileTime);
+    this.isDirectory = rawEntry.uncompressedSize === 0 && rawEntry.name.endsWith("/");
+    this.encrypted = !!(rawEntry.generalPurposeBitFlag & 1);
+    this.externalFileAttributes = rawEntry.externalFileAttributes;
+    this.versionMadeBy = rawEntry.versionMadeBy;
+  }
+  async blob(type = "application/octet-stream") {
+    return await readEntryDataAsBlob(this._reader, this._rawEntry, type);
+  }
+  async arrayBuffer() {
+    return await readEntryDataAsArrayBuffer(this._reader, this._rawEntry);
+  }
+  async text() {
+    const buffer = await this.arrayBuffer();
+    return decodeBuffer(new Uint8Array(buffer));
+  }
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+}
+var EOCDR_WITHOUT_COMMENT_SIZE = 22;
+var MAX_COMMENT_SIZE = 65535;
+var EOCDR_SIGNATURE = 101010256;
+var ZIP64_EOCDR_SIGNATURE = 101075792;
+async function readAs(reader, offset, length) {
+  return await reader.read(offset, length);
+}
+async function readAsBlobOrTypedArray(reader, offset, length, type) {
+  if (reader.sliceAsBlob) {
+    return await reader.sliceAsBlob(offset, length, type);
+  }
+  return await reader.read(offset, length);
+}
+var crc = {
+  unsigned() {
+    return 0;
+  }
+};
+function getUint16LE(uint8View, offset) {
+  return uint8View[offset] + uint8View[offset + 1] * 256;
+}
+function getUint32LE(uint8View, offset) {
+  return uint8View[offset] + uint8View[offset + 1] * 256 + uint8View[offset + 2] * 65536 + uint8View[offset + 3] * 16777216;
+}
+function getUint64LE(uint8View, offset) {
+  return getUint32LE(uint8View, offset) + getUint32LE(uint8View, offset + 4) * 4294967296;
+}
+var utf8Decoder = new TextDecoder;
+function decodeBuffer(uint8View, _isUTF8) {
+  if (isSharedArrayBuffer(uint8View.buffer)) {
+    uint8View = new Uint8Array(uint8View);
+  }
+  return utf8Decoder.decode(uint8View);
+}
+async function findEndOfCentralDirector(reader, totalLength) {
+  const size = Math.min(EOCDR_WITHOUT_COMMENT_SIZE + MAX_COMMENT_SIZE, totalLength);
+  const readStart = totalLength - size;
+  const data = await readAs(reader, readStart, size);
+  for (let i = size - EOCDR_WITHOUT_COMMENT_SIZE;i >= 0; --i) {
+    if (getUint32LE(data, i) !== EOCDR_SIGNATURE) {
+      continue;
+    }
+    const eocdr = new Uint8Array(data.buffer, data.byteOffset + i, data.byteLength - i);
+    const diskNumber = getUint16LE(eocdr, 4);
+    if (diskNumber !== 0) {
+      throw new Error(`multi-volume zip files are not supported. This is volume: ${diskNumber}`);
+    }
+    const entryCount = getUint16LE(eocdr, 10);
+    const centralDirectorySize = getUint32LE(eocdr, 12);
+    const centralDirectoryOffset = getUint32LE(eocdr, 16);
+    const commentLength = getUint16LE(eocdr, 20);
+    const expectedCommentLength = eocdr.length - EOCDR_WITHOUT_COMMENT_SIZE;
+    if (commentLength !== expectedCommentLength) {
+      throw new Error(`invalid comment length. expected: ${expectedCommentLength}, actual: ${commentLength}`);
+    }
+    const commentBytes = new Uint8Array(eocdr.buffer, eocdr.byteOffset + 22, commentLength);
+    const comment = decodeBuffer(commentBytes);
+    if (entryCount === 65535 || centralDirectoryOffset === 4294967295) {
+      return await readZip64CentralDirectory(reader, readStart + i, comment, commentBytes);
+    } else {
+      return await readEntries(reader, centralDirectoryOffset, centralDirectorySize, entryCount, comment, commentBytes);
+    }
+  }
+  throw new Error("could not find end of central directory. maybe not zip file");
+}
+var END_OF_CENTRAL_DIRECTORY_LOCATOR_SIGNATURE = 117853008;
+async function readZip64CentralDirectory(reader, offset, comment, commentBytes) {
+  const zip64EocdlOffset = offset - 20;
+  const eocdl = await readAs(reader, zip64EocdlOffset, 20);
+  if (getUint32LE(eocdl, 0) !== END_OF_CENTRAL_DIRECTORY_LOCATOR_SIGNATURE) {
+    throw new Error("invalid zip64 end of central directory locator signature");
+  }
+  const zip64EocdrOffset = getUint64LE(eocdl, 8);
+  const zip64Eocdr = await readAs(reader, zip64EocdrOffset, 56);
+  if (getUint32LE(zip64Eocdr, 0) !== ZIP64_EOCDR_SIGNATURE) {
+    throw new Error("invalid zip64 end of central directory record signature");
+  }
+  const entryCount = getUint64LE(zip64Eocdr, 32);
+  const centralDirectorySize = getUint64LE(zip64Eocdr, 40);
+  const centralDirectoryOffset = getUint64LE(zip64Eocdr, 48);
+  return readEntries(reader, centralDirectoryOffset, centralDirectorySize, entryCount, comment, commentBytes);
+}
+var CENTRAL_DIRECTORY_FILE_HEADER_SIGNATURE = 33639248;
+async function readEntries(reader, centralDirectoryOffset, centralDirectorySize, rawEntryCount, comment, commentBytes) {
+  let readEntryCursor = 0;
+  const allEntriesBuffer = await readAs(reader, centralDirectoryOffset, centralDirectorySize);
+  const rawEntries = [];
+  for (let e = 0;e < rawEntryCount; ++e) {
+    const buffer = allEntriesBuffer.subarray(readEntryCursor, readEntryCursor + 46);
+    const signature = getUint32LE(buffer, 0);
+    if (signature !== CENTRAL_DIRECTORY_FILE_HEADER_SIGNATURE) {
+      throw new Error(`invalid central directory file header signature: 0x${signature.toString(16)}`);
+    }
+    const rawEntry = {
+      versionMadeBy: getUint16LE(buffer, 4),
+      versionNeededToExtract: getUint16LE(buffer, 6),
+      generalPurposeBitFlag: getUint16LE(buffer, 8),
+      compressionMethod: getUint16LE(buffer, 10),
+      lastModFileTime: getUint16LE(buffer, 12),
+      lastModFileDate: getUint16LE(buffer, 14),
+      crc32: getUint32LE(buffer, 16),
+      compressedSize: getUint32LE(buffer, 20),
+      uncompressedSize: getUint32LE(buffer, 24),
+      fileNameLength: getUint16LE(buffer, 28),
+      extraFieldLength: getUint16LE(buffer, 30),
+      fileCommentLength: getUint16LE(buffer, 32),
+      internalFileAttributes: getUint16LE(buffer, 36),
+      externalFileAttributes: getUint32LE(buffer, 38),
+      relativeOffsetOfLocalHeader: getUint32LE(buffer, 42)
+    };
+    if (rawEntry.generalPurposeBitFlag & 64) {
+      throw new Error("strong encryption is not supported");
+    }
+    readEntryCursor += 46;
+    const data = allEntriesBuffer.subarray(readEntryCursor, readEntryCursor + rawEntry.fileNameLength + rawEntry.extraFieldLength + rawEntry.fileCommentLength);
+    rawEntry.generalPurposeBitFlag & 2048;
+    rawEntry.nameBytes = data.slice(0, rawEntry.fileNameLength);
+    rawEntry.name = decodeBuffer(rawEntry.nameBytes);
+    const fileCommentStart = rawEntry.fileNameLength + rawEntry.extraFieldLength;
+    const extraFieldBuffer = data.slice(rawEntry.fileNameLength, fileCommentStart);
+    rawEntry.extraFields = [];
+    let i = 0;
+    while (i < extraFieldBuffer.length - 3) {
+      const headerId = getUint16LE(extraFieldBuffer, i + 0);
+      const dataSize = getUint16LE(extraFieldBuffer, i + 2);
+      const dataStart = i + 4;
+      const dataEnd = dataStart + dataSize;
+      if (dataEnd > extraFieldBuffer.length) {
+        throw new Error("extra field length exceeds extra field buffer size");
+      }
+      rawEntry.extraFields.push({
+        id: headerId,
+        data: extraFieldBuffer.slice(dataStart, dataEnd)
+      });
+      i = dataEnd;
+    }
+    rawEntry.commentBytes = data.slice(fileCommentStart, fileCommentStart + rawEntry.fileCommentLength);
+    rawEntry.comment = decodeBuffer(rawEntry.commentBytes);
+    readEntryCursor += data.length;
+    if (rawEntry.uncompressedSize === 4294967295 || rawEntry.compressedSize === 4294967295 || rawEntry.relativeOffsetOfLocalHeader === 4294967295) {
+      const zip64ExtraField = rawEntry.extraFields.find((e2) => e2.id === 1);
+      if (!zip64ExtraField) {
+        throw new Error("expected zip64 extended information extra field");
+      }
+      const zip64EiefBuffer = zip64ExtraField.data;
+      let index = 0;
+      if (rawEntry.uncompressedSize === 4294967295) {
+        if (index + 8 > zip64EiefBuffer.length) {
+          throw new Error("zip64 extended information extra field does not include uncompressed size");
+        }
+        rawEntry.uncompressedSize = getUint64LE(zip64EiefBuffer, index);
+        index += 8;
+      }
+      if (rawEntry.compressedSize === 4294967295) {
+        if (index + 8 > zip64EiefBuffer.length) {
+          throw new Error("zip64 extended information extra field does not include compressed size");
+        }
+        rawEntry.compressedSize = getUint64LE(zip64EiefBuffer, index);
+        index += 8;
+      }
+      if (rawEntry.relativeOffsetOfLocalHeader === 4294967295) {
+        if (index + 8 > zip64EiefBuffer.length) {
+          throw new Error("zip64 extended information extra field does not include relative header offset");
+        }
+        rawEntry.relativeOffsetOfLocalHeader = getUint64LE(zip64EiefBuffer, index);
+        index += 8;
+      }
+    }
+    const nameField = rawEntry.extraFields.find((e2) => e2.id === 28789 && e2.data.length >= 6 && e2.data[0] === 1 && getUint32LE(e2.data, 1), crc.unsigned());
+    if (nameField) {
+      rawEntry.fileName = decodeBuffer(nameField.data.slice(5));
+    }
+    if (rawEntry.compressionMethod === 0) {
+      let expectedCompressedSize = rawEntry.uncompressedSize;
+      if ((rawEntry.generalPurposeBitFlag & 1) !== 0) {
+        expectedCompressedSize += 12;
+      }
+      if (rawEntry.compressedSize !== expectedCompressedSize) {
+        throw new Error(`compressed size mismatch for stored file: ${rawEntry.compressedSize} != ${expectedCompressedSize}`);
+      }
+    }
+    rawEntries.push(rawEntry);
+  }
+  const zip = {
+    comment,
+    commentBytes
+  };
+  return {
+    zip,
+    entries: rawEntries.map((e) => new ZipEntry(reader, e))
+  };
+}
+async function readEntryDataHeader(reader, rawEntry) {
+  if (rawEntry.generalPurposeBitFlag & 1) {
+    throw new Error("encrypted entries not supported");
+  }
+  const buffer = await readAs(reader, rawEntry.relativeOffsetOfLocalHeader, 30);
+  const totalLength = await reader.getLength();
+  const signature = getUint32LE(buffer, 0);
+  if (signature !== 67324752) {
+    throw new Error(`invalid local file header signature: 0x${signature.toString(16)}`);
+  }
+  const fileNameLength = getUint16LE(buffer, 26);
+  const extraFieldLength = getUint16LE(buffer, 28);
+  const localFileHeaderEnd = rawEntry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
+  let decompress;
+  if (rawEntry.compressionMethod === 0) {
+    decompress = false;
+  } else if (rawEntry.compressionMethod === 8) {
+    decompress = true;
+  } else {
+    throw new Error(`unsupported compression method: ${rawEntry.compressionMethod}`);
+  }
+  const fileDataStart = localFileHeaderEnd;
+  const fileDataEnd = fileDataStart + rawEntry.compressedSize;
+  if (rawEntry.compressedSize !== 0) {
+    if (fileDataEnd > totalLength) {
+      throw new Error(`file data overflows file bounds: ${fileDataStart} +  ${rawEntry.compressedSize}  > ${totalLength}`);
+    }
+  }
+  return {
+    decompress,
+    fileDataStart
+  };
+}
+async function readEntryDataAsArrayBuffer(reader, rawEntry) {
+  const { decompress, fileDataStart } = await readEntryDataHeader(reader, rawEntry);
+  if (!decompress) {
+    const dataView = await readAs(reader, fileDataStart, rawEntry.compressedSize);
+    return isTypedArraySameAsArrayBuffer(dataView) ? dataView.buffer : dataView.slice().buffer;
+  }
+  const typedArrayOrBlob = await readAsBlobOrTypedArray(reader, fileDataStart, rawEntry.compressedSize);
+  const result = await inflateRawAsync(typedArrayOrBlob instanceof Uint8Array ? typedArrayOrBlob : typedArrayOrBlob, rawEntry.uncompressedSize);
+  return result;
+}
+async function readEntryDataAsBlob(reader, rawEntry, type) {
+  const { decompress, fileDataStart } = await readEntryDataHeader(reader, rawEntry);
+  if (!decompress) {
+    const typedArrayOrBlob2 = await readAsBlobOrTypedArray(reader, fileDataStart, rawEntry.compressedSize, type);
+    if (isBlob(typedArrayOrBlob2)) {
+      return typedArrayOrBlob2;
+    }
+    return new Blob([typedArrayOrBlob2], { type });
+  }
+  const typedArrayOrBlob = await readAsBlobOrTypedArray(reader, fileDataStart, rawEntry.compressedSize);
+  const result = await inflateRawAsync(typedArrayOrBlob instanceof Uint8Array ? typedArrayOrBlob : typedArrayOrBlob, rawEntry.uncompressedSize, type);
+  return result;
+}
+async function unzipRaw(source) {
+  let reader;
+  if (typeof Blob !== "undefined" && source instanceof Blob) {
+    reader = new BlobReader(source);
+  } else if (source instanceof ArrayBuffer || source && source.buffer && source.buffer instanceof ArrayBuffer) {
+    reader = new ArrayBufferReader(source);
+  } else if (isSharedArrayBuffer(source) || isSharedArrayBuffer(source.buffer)) {
+    reader = new ArrayBufferReader(source);
+  } else if (typeof source === "string") {
+    const req = await fetch(source);
+    if (!req.ok) {
+      throw new Error(`failed http request ${source}, status: ${req.status}: ${req.statusText}`);
+    }
+    const blob = await req.blob();
+    reader = new BlobReader(blob);
+  } else if (typeof source.getLength === "function" && typeof source.read === "function") {
+    reader = source;
+  } else {
+    throw new Error("unsupported source type");
+  }
+  const totalLength = await reader.getLength();
+  if (totalLength > Number.MAX_SAFE_INTEGER) {
+    throw new Error(`file too large. size: ${totalLength}. Only file sizes up 4503599627370496 bytes are supported`);
+  }
+  return await findEndOfCentralDirector(reader, totalLength);
+}
+async function unzip(source) {
+  const { zip, entries } = await unzipRaw(source);
+  return {
+    zip,
+    entries: Object.fromEntries(entries.map((v) => [v.name, v]))
+  };
+}
+
+// ../serial/src/vex-device.ts
+function downloadFileFromInternet(link) {
+  return new Promise((resolve, reject) => {
+    var oReq = new XMLHttpRequest;
+    oReq.open("GET", link, true);
+    oReq.responseType = "arraybuffer";
+    oReq.onload = function(_oEvent) {
+      var arrayBuffer = oReq.response;
+      resolve(arrayBuffer);
+    };
+    oReq.onerror = function(oEvent) {
+      reject(oEvent);
+    };
+    oReq.send(null);
+  });
+}
+function sleepUntil(f, timeout, interval = 20) {
+  return new Promise((resolve) => {
+    const timeWas = new Date().getTime();
+    const wait = setInterval(async function() {
+      if (await f()) {
+        clearInterval(wait);
+        resolve(true);
+      } else if (new Date().getTime() - timeWas > timeout) {
+        clearInterval(wait);
+        resolve(false);
+      }
+    }, interval);
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shallowEqual(object1, object2) {
+  const keys1 = Object.keys(object1);
+  const keys2 = Object.keys(object2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (let key of keys1) {
+    if (object1[key] !== object2[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+class VexSerialDevice extends VexEventTarget {
+  connection;
+  defaultSerial;
+  get isConnected() {
+    return this.connection ? this.connection.isConnected : false;
+  }
+  get deviceType() {
+    return this.isConnected ? this.connection?.port?.getInfo().usbProductId : undefined;
+  }
+  constructor(defaultSerial) {
+    super();
+    this.defaultSerial = defaultSerial;
+  }
+}
+
+class V5SerialDeviceProxyHandler {
+  device;
+  parent;
+  rootkey;
+  constructor(device, parent, rootkey) {
+    this.device = device;
+    this.parent = parent;
+    this.rootkey = rootkey;
+  }
+  get(target, key) {
+    if (typeof target[key] === "object" && target[key] !== null && (typeof key !== "string" ? true : !key.startsWith("_"))) {
+      return new Proxy(target[key], new V5SerialDeviceProxyHandler(this.device, this, key));
+    } else {
+      return target[key];
+    }
+  }
+  set(target, key, value) {
+    let oldValue = target[key];
+    if (oldValue === value) {
+      return true;
+    } else if (typeof oldValue === "object" && typeof value === "object" && oldValue !== null && value !== null) {
+      if (shallowEqual(oldValue, value))
+        return true;
+    }
+    target[key] = value;
+    this.parent?.childSet(this.rootkey, key, value);
+    return true;
+  }
+  childSet(rootkey, subkey, value) {
+    if (this.parent)
+      this.parent.childSet(this.rootkey, rootkey + "." + subkey, value);
+  }
+}
+
+class V5SerialDeviceState {
+  _instance;
+  _isFileTransferring = false;
+  brain = {
+    activeProgram: 0,
+    battery: {
+      batteryPercent: 0,
+      isCharging: false
+    },
+    button: {
+      isPressed: false,
+      isDoublePressed: false
+    },
+    cpu0Version: VexFirmwareVersion.allZero(),
+    cpu1Version: VexFirmwareVersion.allZero(),
+    isAvailable: false,
+    settings: {
+      isScreenReversed: false,
+      isWhiteTheme: false,
+      usingLanguage: 0
+    },
+    systemVersion: VexFirmwareVersion.allZero(),
+    uniqueId: 0
+  };
+  controllers = [
+    {
+      battery: 0,
+      isAvailable: false,
+      isCharging: false
+    },
+    {
+      battery: 0,
+      isAvailable: false
+    }
+  ];
+  devices = [];
+  isFieldControllerConnected = false;
+  matchMode = "disabled";
+  radio = {
+    channel: 0,
+    isAvailable: false,
+    isConnected: false,
+    isVexNet: false,
+    isRadioData: false,
+    latency: 0,
+    signalQuality: 0,
+    signalStrength: 0
+  };
+  constructor(instance) {
+    this._instance = instance;
+  }
+}
+
+class V5Brain {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  get isRunningProgram() {
+    return this.activeProgram !== 0;
+  }
+  get activeProgram() {
+    return this.state.brain.activeProgram;
+  }
+  set activeProgram(value) {
+    (async () => {
+      if (this.state.brain.activeProgram === value)
+        return;
+      let conn = this.state._instance.connection;
+      if (!conn)
+        return;
+      let fn = value === 0 ? await conn.stopProgram() : await conn.loadProgram(value);
+      if (fn)
+        this.state.brain.activeProgram = value;
+    })();
+  }
+  get battery() {
+    return new V5Battery(this.state);
+  }
+  get button() {
+    return new V5BrainButton(this.state);
+  }
+  get cpu0Version() {
+    return this.state.brain.cpu0Version;
+  }
+  get cpu1Version() {
+    return this.state.brain.cpu1Version;
+  }
+  get isAvailable() {
+    return this.state.brain.isAvailable;
+  }
+  get settings() {
+    return new V5BrainSettings(this.state);
+  }
+  get systemVersion() {
+    return this.state.brain.systemVersion;
+  }
+  get uniqueId() {
+    return this.state.brain.uniqueId;
+  }
+  async getValue(key) {
+    let result = await this.state._instance.connection?.writeDataAsync(new ReadKeyValueH2DPacket(key));
+    return result instanceof ReadKeyValueReplyD2HPacket ? result.value : undefined;
+  }
+  async setValue(key, value) {
+    let result = await this.state._instance.connection?.writeDataAsync(new WriteKeyValueH2DPacket(key, value));
+    return result instanceof WriteKeyValueReplyD2HPacket ? true : false;
+  }
+  async listFiles(vendor = 1 /* USER */) {
+    let conn = this.state._instance.connection;
+    if (!conn)
+      return;
+    let result = await conn.writeDataAsync(new GetDirectoryFileCountH2DPacket(vendor));
+    if (!(result instanceof GetDirectoryFileCountReplyD2HPacket))
+      return;
+    let files = [];
+    for (let i = 0;i < result.count; i++) {
+      let result2 = await conn.writeDataAsync(new GetDirectoryEntryH2DPacket(i));
+      if (!(result2 instanceof GetDirectoryEntryReplyD2HPacket))
+        return;
+      if (result2.file) {
+        files.push({
+          filename: result2.file.filename,
+          vendor,
+          loadAddress: result2.file.loadAddress,
+          size: result2.file.size,
+          crc32: result2.file.crc32,
+          type: result2.file.type,
+          timestamp: result2.file.timestamp,
+          version: result2.file.version
+        });
+      }
+    }
+    return files;
+  }
+  async listProgram() {
+    let conn = this.state._instance.connection;
+    if (!conn?.isConnected)
+      return;
+    let files = await this.listFiles(1 /* USER */);
+    if (files === undefined)
+      return;
+    let programList = [];
+    let iniFiles = files.filter((file) => file && file.filename.search(/.ini$/) > 0);
+    for (let i = 0;i < iniFiles.length; i++) {
+      let ini = iniFiles[i];
+      if (!ini.size)
+        continue;
+      let programName = (/(.+?)(\.[^.]*$|$)/.exec(ini.filename) || "")[1];
+      let bin = files.filter((e) => e && e.filename === programName + ".bin")[0];
+      if (!bin || !bin.timestamp || !bin.size)
+        continue;
+      let n = new Date;
+      n.setTime(1000 * bin.timestamp);
+      let program = {
+        name: programName,
+        binfile: bin.filename,
+        size: ini.size + bin.size,
+        slot: -1,
+        time: n,
+        requestedSlot: -1
+      };
+      let result2 = await conn.writeDataAsync(new GetProgramSlotInfoH2DPacket(1 /* USER */, program.binfile));
+      if (result2 instanceof GetProgramSlotInfoReplyD2HPacket) {
+        program.slot = result2.slot;
+        program.requestedSlot = result2.requestedSlot;
+      }
+      programList.push(program);
+    }
+    return programList;
+  }
+  async readFile(request, downloadTarget = 1 /* FILE_TARGET_QSPI */, progressCallback) {
+    let conn = this.state._instance.connection;
+    if (!conn?.isConnected)
+      return;
+    this.state._isFileTransferring = true;
+    let handle;
+    if (typeof request === "string") {
+      handle = { filename: request, vendor: 1 /* USER */ };
+    } else {
+      handle = request;
+    }
+    try {
+      return conn.downloadFileToHost(handle, downloadTarget, progressCallback);
+    } catch (e) {
+      throw e;
+    } finally {
+      this.state._isFileTransferring = false;
+    }
+  }
+  async removeFile(request) {
+    let conn = this.state._instance.connection;
+    if (!conn?.isConnected)
+      return;
+    let vendor, filename;
+    if (typeof request === "string") {
+      vendor = 1 /* USER */;
+      filename = request;
+    } else {
+      vendor = request.vendor;
+      filename = request.filename;
+    }
+    let result = await conn.writeDataAsync(new EraseFileH2DPacket(vendor, filename));
+    let result2 = await conn.writeDataAsync(new ExitFileTransferH2DPacket(3 /* EXIT_HALT */));
+    if (!(result instanceof EraseFileReplyD2HPacket))
+      return false;
+    if (!(result2 instanceof ExitFileTransferReplyD2HPacket))
+      return false;
+    return true;
+  }
+  async removeAllFiles() {
+    let conn = this.state._instance.connection;
+    if (!conn?.isConnected)
+      return;
+    let result = await conn.writeDataAsync(new FileClearUpH2DPacket(1 /* USER */), 30000);
+    return result instanceof FileClearUpReplyD2HPacket ? true : false;
+  }
+  async uploadFirmware(publicUrl = "https://content.vexrobotics.com/vexos/public/V5/", usingVersion, progressCallback) {
+    let device = this.state._instance;
+    let conn = device.connection;
+    if (!conn?.isConnected)
+      return;
+    const pcb = progressCallback ?? (() => {});
+    let vexos, bootBin, assertBin;
+    try {
+      if (usingVersion === undefined) {
+        pcb("FETCH CATALOG", 0, 1);
+        const catalog = await downloadFileFromInternet(publicUrl + "catalog.txt");
+        let latestVersion = new TextDecoder().decode(catalog);
+        usingVersion = latestVersion;
+        pcb("FETCH CATALOG", 1, 1);
+        console.log("fetched catalog.txt", latestVersion);
+      }
+      pcb("FETCH VEXOS", 0, 1);
+      vexos = await downloadFileFromInternet(publicUrl + usingVersion + ".vexos");
+      pcb("FETCH VEXOS", 1, 1);
+      pcb("UNZIP VEXOS", 0, 1);
+      let { entries } = await unzip(vexos);
+      bootBin = await entries[usingVersion + "/BOOT.bin"].arrayBuffer();
+      assertBin = await entries[usingVersion + "/assets.bin"].arrayBuffer();
+      pcb("UNZIP VEXOS", 1, 1);
+    } catch (e) {
+      return;
+    }
+    try {
+      this.state._isFileTransferring = true;
+      pcb("FACTORY ENB BOOT", 0, 0);
+      let result = await conn.writeDataAsync(new FactoryEnableH2DPacket);
+      if (!(result instanceof FactoryEnableReplyD2HPacket))
+        return false;
+      let bootWriteRequest = {
+        filename: "null.bin",
+        vendor: 1 /* USER */,
+        loadAddress: USER_FLASH_USR_CODE_START,
+        buf: new Uint8Array(bootBin),
+        downloadTarget: 14 /* FILE_TARGET_B1 */,
+        exttype: "bin",
+        autoRun: true,
+        linkedFile: undefined
+      };
+      let result2 = await conn.uploadFileToDevice(bootWriteRequest, (c, t) => pcb("UPLOAD BOOT", c, t));
+      if (!result2)
+        return false;
+      while (true) {
+        let result3 = await conn.writeDataAsync(new FactoryStatusH2DPacket, 1e4);
+        if (result3 instanceof FactoryStatusReplyD2HPacket) {
+          switch (result3.status) {
+            case 2:
+              pcb("ERASE BOOT", result3.percent, 100);
+              break;
+            case 3:
+              pcb("WRITE BOOT", result3.percent, 100);
+              break;
+            case 4:
+              pcb("VERIFY BOOT", result3.percent, 100);
+              break;
+            case 8:
+              pcb("FINISHING BOOT", result3.percent, 100);
+              break;
+          }
+          if (result3.status === 0 && result3.percent === 100)
+            break;
+        } else {
+          return false;
+        }
+        await sleep(500);
+      }
+      pcb("FACTORY ENB ASSERT", 0, 0);
+      let result5 = await conn.writeDataAsync(new FactoryEnableH2DPacket);
+      if (!(result5 instanceof FactoryEnableReplyD2HPacket))
+        return false;
+      let assertWriteRequest = {
+        filename: "null.bin",
+        vendor: 1 /* USER */,
+        loadAddress: USER_FLASH_USR_CODE_START,
+        buf: new Uint8Array(assertBin),
+        downloadTarget: 13 /* FILE_TARGET_A1 */,
+        exttype: "bin",
+        autoRun: true,
+        linkedFile: undefined
+      };
+      let result6 = await conn.uploadFileToDevice(assertWriteRequest, (c, t) => pcb("UPLOAD ASSERT", c, t));
+      if (!result6)
+        return false;
+      while (true) {
+        let result7 = await conn.writeDataAsync(new FactoryStatusH2DPacket, 1e4);
+        if (result7 instanceof FactoryStatusReplyD2HPacket) {
+          switch (result7.status) {
+            case 2:
+              pcb("ERASE ASSERT", result7.percent, 100);
+              break;
+            case 3:
+              pcb("WRITE ASSERT", result7.percent, 100);
+              break;
+            case 4:
+              pcb("VERIFY ASSERT", result7.percent, 100);
+              break;
+            case 8:
+              pcb("FINISHING ASSERT", result7.percent, 100);
+              break;
+          }
+          if (result7.status === 0 && result7.percent === 100)
+            break;
+        } else {
+          return false;
+        }
+        await sleep(500);
+      }
+    } catch (e) {
+      throw e;
+    } finally {
+      this.state._isFileTransferring = false;
+    }
+    return true;
+  }
+  async uploadProgram(iniConfig, binFileBuf, coldFileBuf, progressCallback) {
+    let device = this.state._instance;
+    let conn = device.connection;
+    if (!conn?.isConnected)
+      return;
+    this.state._isFileTransferring = true;
+    try {
+      if (device.isV5Controller) {
+        await sleep(250);
+        if (!device.refresh())
+          return;
+        console.log("Transferring to download channel");
+        let p1 = await device.radio.changeChannel(1 /* DOWNLOAD */);
+        if (!p1)
+          return false;
+        await sleep(250);
+        await sleepUntil(async () => await conn?.getSystemStatus(150), 1e4, 200);
+        console.log("Transferred to download channel");
+      }
+      let p2 = await conn.uploadProgramToDevice(iniConfig, binFileBuf, coldFileBuf, progressCallback);
+      if (!p2)
+        return false;
+      if (device.isV5Controller) {
+        if (!device.brain.isAvailable)
+          return false;
+        console.log("Transferring back to pit channel");
+        let p3 = await device.radio.changeChannel(0 /* PIT */);
+        if (!p3)
+          return false;
+        await sleep(250);
+        await sleepUntil(async () => await conn?.getSystemStatus(150), 1e4, 200);
+        console.log("All done");
+      }
+      return true;
+    } catch (e) {
+      throw e;
+    } finally {
+      this.state._isFileTransferring = false;
+    }
+  }
+  async writeFile(request, progressCallback) {
+    this.state._isFileTransferring = true;
+    let conn = this.state._instance.connection;
+    if (!conn?.isConnected)
+      return;
+    try {
+      return conn.uploadFileToDevice(request, progressCallback);
+    } catch (e) {
+      throw e;
+    } finally {
+      this.state._isFileTransferring = false;
+    }
+  }
+}
+
+class V5Battery {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  get batteryPercent() {
+    return this.state.brain.battery.batteryPercent;
+  }
+  get isCharging() {
+    return this.state.brain.battery.isCharging;
+  }
+}
+
+class V5BrainButton {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  get isPressed() {
+    return this.state.brain.button.isPressed;
+  }
+  get isDoublePressed() {
+    return this.state.brain.button.isDoublePressed;
+  }
+}
+
+class V5BrainSettings {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  get isScreenReversed() {
+    return this.state.brain.settings.isScreenReversed;
+  }
+  get isWhiteTheme() {
+    return this.state.brain.settings.isWhiteTheme;
+  }
+  get usingLanguage() {
+    return this.state.brain.settings.usingLanguage;
+  }
+}
+
+class V5Controller {
+  state;
+  controllerIndex;
+  constructor(state, controllerIndex) {
+    this.state = state;
+    this.controllerIndex = controllerIndex;
+  }
+  get batteryPercent() {
+    return this.state.controllers[this.controllerIndex].battery;
+  }
+  get isMasterController() {
+    return this.controllerIndex === 0;
+  }
+  get isAvailable() {
+    return this.state.controllers[this.controllerIndex].isAvailable;
+  }
+  get isCharging() {
+    return this.state.controllers[this.controllerIndex].isCharging;
+  }
+}
+
+class V5SmartDevice {
+  state;
+  deviceIndex;
+  constructor(state, index) {
+    this.state = state;
+    this.deviceIndex = index;
+  }
+  get isAvailable() {
+    return this.state.devices[this.deviceIndex] !== undefined;
+  }
+  get port() {
+    return this.deviceIndex;
+  }
+  get type() {
+    return this.isAvailable ? this.state.devices[this.deviceIndex].type : 0 /* EMPTY */;
+  }
+  get version() {
+    return this.isAvailable ? this.state.devices[this.deviceIndex].version : 0;
+  }
+}
+
+class V5Radio {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  get channel() {
+    return this.state.radio.channel;
+  }
+  get isAvailable() {
+    return this.state.radio.isAvailable;
+  }
+  get isConnected() {
+    return this.state.radio.isConnected;
+  }
+  get isVexNet() {
+    return this.state.radio.isVexNet;
+  }
+  get isRadioData() {
+    return this.state.radio.isRadioData;
+  }
+  get latency() {
+    return this.state.radio.latency;
+  }
+  async changeChannel(channel) {
+    let result = await this.state._instance.connection?.writeDataAsync(new FileControlH2DPacket(1, channel));
+    return result instanceof FileControlReplyD2HPacket ? true : false;
+  }
+}
+
+class V5SerialDevice extends VexSerialDevice {
+  autoReconnect = true;
+  autoRefresh = true;
+  pauseRefreshOnFileTransfer = true;
+  _isDisconnecting = false;
+  _isReconnecting = false;
+  _refreshInterval;
+  proxy = new V5SerialDeviceProxyHandler(this);
+  state = new Proxy(new V5SerialDeviceState(this), this.proxy);
+  constructor(defaultSerial) {
+    super(defaultSerial);
+    this.startAutoRefresh();
+  }
+  startAutoRefresh() {
+    if (this._refreshInterval)
+      return;
+    this._refreshInterval = setInterval(() => {
+      if (this.autoRefresh) {
+        if (!this.isConnected) {
+          this.state.brain.isAvailable = false;
+          return;
+        }
+        if (this.pauseRefreshOnFileTransfer && !this.state._isFileTransferring) {
+          this.refresh();
+        }
+      }
+    }, 200);
+    this._refreshInterval.unref?.();
+  }
+  stopAutoRefresh() {
+    if (!this._refreshInterval)
+      return;
+    clearInterval(this._refreshInterval);
+    this._refreshInterval = undefined;
+  }
+  get isV5Controller() {
+    return this.deviceType === 1283 /* V5_CONTROLLER */;
+  }
+  get brain() {
+    return new V5Brain(this.state);
+  }
+  get controllers() {
+    return [new V5Controller(this.state, 0), new V5Controller(this.state, 1)];
+  }
+  get devices() {
+    let rtn = [];
+    for (let i = 1;i <= this.state.devices.length; i++) {
+      if (this.state.devices[i])
+        rtn.push(new V5SmartDevice(this.state, i));
+    }
+    return rtn;
+  }
+  get isFieldControllerConnected() {
+    return this.state.isFieldControllerConnected;
+  }
+  get matchMode() {
+    return this.state.matchMode;
+  }
+  set matchMode(value) {
+    (async () => {
+      if (await this.connection?.setMatchMode(value))
+        this.state.matchMode = value;
+    })();
+  }
+  get radio() {
+    return new V5Radio(this.state);
+  }
+  async mockTouch(x, y, press) {
+    return await this.connection?.mockTouch(x, y, press) ? true : false;
+  }
+  async connect(conn) {
+    if (this.isConnected)
+      return true;
+    this.startAutoRefresh();
+    if (conn?.isConnected) {
+      if (await conn.query1() === null)
+        return false;
+      this.connection = conn;
+    } else {
+      let tryIdx = 0;
+      while (true) {
+        let c = new V5SerialConnection(this.defaultSerial);
+        let result = await c.open(tryIdx++, true);
+        if (result === undefined)
+          return false;
+        if (result === false) {
+          await c.close();
+          continue;
+        }
+        if (await c.query1() === null) {
+          await c.close();
+          continue;
+        }
+        this.connection = c;
+        break;
+      }
+    }
+    if (!this.isConnected)
+      return false;
+    await this.doAfterConnect();
+    return true;
+  }
+  async disconnect() {
+    this._isDisconnecting = true;
+    this.stopAutoRefresh();
+    try {
+      await this.connection?.close();
+      this.connection = undefined;
+    } finally {
+      this._isDisconnecting = false;
+    }
+  }
+  async reconnect(timeout = 0) {
+    if (this.isConnected)
+      return true;
+    if (timeout < 0)
+      return false;
+    let endTime = new Date().getTime() + timeout;
+    if (this._isReconnecting) {
+      let successB4Timeout;
+      do {
+        successB4Timeout = await sleepUntil(() => !this._isReconnecting, timeout || 1000);
+      } while (timeout === 0 && !successB4Timeout);
+      if (this.isConnected)
+        return true;
+      if (!successB4Timeout)
+        return false;
+    }
+    this._isReconnecting = true;
+    while (timeout === 0 || new Date().getTime() > endTime) {
+      let tryIdx = 0;
+      while (true) {
+        let c = new V5SerialConnection(this.defaultSerial);
+        let result = await c.open(tryIdx++, false);
+        if (result === undefined)
+          break;
+        if (result === false) {
+          await c.close();
+          continue;
+        }
+        let result2 = await c.getSystemStatus(200);
+        if (result2 === null) {
+          await c.close();
+          continue;
+        }
+        if (this.brain.uniqueId !== 0 && result2.uniqueId !== this.brain.uniqueId) {
+          await c.close();
+          continue;
+        }
+        this.connection = c;
+        break;
+      }
+      if (this.isConnected)
+        break;
+      let getPortCount = async () => (await this.defaultSerial.getPorts()).length;
+      let portsCount = await getPortCount();
+      await sleepUntil(async () => await getPortCount() !== portsCount, 1000);
+    }
+    this._isReconnecting = false;
+    if (!this.isConnected)
+      return false;
+    this.doAfterConnect();
+    return true;
+  }
+  async doAfterConnect() {
+    if (!this.connection)
+      return;
+    this.connection.on("disconnected", (_data) => {
+      if (this.autoReconnect && !this._isDisconnecting)
+        this.reconnect();
+    });
+    await this.refresh();
+  }
+  async refresh() {
+    let ssPacket = await this.connection?.getSystemStatus();
+    if (!ssPacket) {
+      this.state.brain.isAvailable = false;
+      return false;
+    }
+    this.state.brain.cpu0Version = ssPacket.cpu0Version;
+    this.state.brain.cpu1Version = ssPacket.cpu1Version;
+    this.state.brain.systemVersion = ssPacket.systemVersion;
+    let flags2 = ssPacket.sysflags[2];
+    this.state.controllers[0].isCharging = (flags2 & 128) !== 0;
+    this.state.matchMode = flags2 & 32 ? "disabled" : flags2 & 64 ? "autonomous" : "driver";
+    this.state.isFieldControllerConnected = (flags2 & 16) !== 0;
+    let flags4 = ssPacket.sysflags[4];
+    this.state.brain.settings.usingLanguage = (flags4 & 240) >> 4;
+    this.state.brain.settings.isWhiteTheme = (flags4 & 4) !== 0;
+    this.state.brain.settings.isScreenReversed = (flags4 & 1) === 0;
+    this.state.brain.uniqueId = ssPacket.uniqueId;
+    let sfPacket = await this.connection?.getSystemFlags();
+    if (!sfPacket)
+      return false;
+    let flags5 = sfPacket.flags;
+    this.state.radio.isRadioData = (flags5 & Math.pow(2, 32 - 12)) !== 0;
+    this.state.brain.button.isDoublePressed = (flags5 & Math.pow(2, 32 - 14)) !== 0;
+    this.state.brain.battery.isCharging = (flags5 & Math.pow(2, 32 - 15)) !== 0;
+    this.state.brain.button.isPressed = (flags5 & Math.pow(2, 32 - 17)) !== 0;
+    this.state.radio.isVexNet = (flags5 & Math.pow(2, 32 - 18)) !== 0;
+    this.state.controllers[1].isAvailable = (flags5 & Math.pow(2, 32 - 19)) !== 0;
+    this.state.radio.isConnected = (flags5 & Math.pow(2, 32 - 22)) !== 0;
+    this.state.radio.isAvailable = (flags5 & Math.pow(2, 32 - 23)) !== 0;
+    this.state.brain.battery.batteryPercent = sfPacket.battery || 0;
+    this.state.controllers[0].isAvailable = this.state.radio.isConnected || this.state.controllers[0].isCharging;
+    this.state.controllers[0].battery = sfPacket.controllerBatteryPercent || 0;
+    this.state.controllers[1].battery = sfPacket.partnerControllerBatteryPercent || 0;
+    this.state.brain.activeProgram = sfPacket.currentProgram;
+    this.state.brain.isAvailable = !this.isV5Controller || this.state.radio.isConnected;
+    let rdPacket = await this.connection?.getRadioStatus();
+    if (!rdPacket)
+      return false;
+    this.state.radio.channel = rdPacket.channel;
+    this.state.radio.latency = rdPacket.timeslot;
+    this.state.radio.signalQuality = rdPacket.quality;
+    this.state.radio.signalStrength = rdPacket.strength;
+    let dsPacket = await this.connection?.getDeviceStatus();
+    if (!dsPacket)
+      return false;
+    let missingPorts = this.state.devices.map((d) => d?.port).filter((p) => p !== undefined);
+    for (let i = 0;i < dsPacket.devices.length; i++) {
+      let device = dsPacket.devices[i];
+      this.state.devices[device.port] = device;
+      missingPorts = missingPorts.filter((p) => p !== device.port);
+    }
+    missingPorts.forEach((port) => delete this.state.devices[port]);
+    return true;
+  }
+}
+// src/index.ts
+console.log(import_picocolors.default.redBright(`v5x ${package_default.version}`));
+console.log("modern cli for v5 development");
+async function main() {
+  const device = new V5SerialDevice(serial);
+  try {
+    await device.connect();
+  } catch {
+    console.warn(import_picocolors.default.yellow("v5 device not found"));
+  }
+  if (device.isConnected) {
+    console.log("os:", device.brain.systemVersion.toUserString());
+    console.log("name:", await device.brain.getValue("robotname"));
+    console.log("team:", await device.brain.getValue("teamnumber"));
+    console.log("id:", device.brain.uniqueId.toString());
+    await device.disconnect();
+  }
+}
+main();