@v5x/serial 0.5.5 → 0.5.6

package/README.md

@@ -4,9 +4,8 @@ TypeScript implementation of the VEX V5 serial protocol.
 
 See the [serial library documentation](https://docs.v5x.dev/serial/overview) for browser setup, guides, and high-level API reference.
 
-This package provides helpers for connecting to V5 devices over the Web Serial
-API, reading device state, transferring files, and working with protocol
-packets.
+It covers connecting to V5 devices over the Web Serial API, reading device
+state, transferring files, and working with protocol packets.
 
 ## Install
 
@@ -47,7 +46,7 @@ can open.
 The package ships ESM, CommonJS, and TypeScript declarations. Packet and version
 utilities work in Bun or Node.js, but direct browser device connections require
 the Web Serial API. The `@v5x/cli` package is separate and currently supports
-Linux only.
+Linux and macOS. Windows requires a different CLI serial backend.
 
 ## Common Exports
 
@@ -64,10 +63,9 @@ Linux only.
 
 ## Result-returning async APIs
 
-All public async methods return `ResultAsync<T, VexSerialError>` (or
-`ResultAsync<T, VexSerialError>`-yielding helpers) so failures are explicit in
-the type system rather than thrown. State-changing operations are awaitable and
-report errors through the result channel:
+All public async methods return `ResultAsync<T, VexSerialError>`, so failures
+are explicit in the type system rather than thrown. State-changing operations
+are awaitable and report errors through the result channel:
 
 ```ts
 const r = await device.setMatchMode("disabled");
@@ -97,7 +95,7 @@ transfer is active by default.
 Protocol requests default to a 1,000 ms response timeout. Individual transfer
 phases use longer timeouts where erase, write, or exit operations need them.
 `reconnect(0)` waits indefinitely, while a positive reconnect timeout is a total
-deadline in milliseconds. A timeout or NACK is reported as a `VexProtocolError`
+deadline in milliseconds. A timeout or NACK surfaces as a `VexProtocolError`
 (or a related `VexSerialError` subclass) through the `Result` error channel; it
 does not cancel work already running on the device.
 

package/dist/VexCRC.d.ts

@@ -2,17 +2,6 @@ export declare class CrcGenerator {
     crc32Table: Uint32Array;
     static POLYNOMIAL_CRC32: number;
     static POLYNOMIAL_CRC16: number;
-    constructor();
-    /**
-     * Calculate CRC16 for buffer
-     */
     crc16(buf: Uint8Array, initValue: number): number;
-    /**
-     * Generate CRC32 reverse table
-     */
-    crc32GenTable(): void;
-    /**
-     * Calculate CRC32 for buffer
-     */
     crc32(buf: Uint8Array, initValue: number): number;
 }

package/dist/VexConnection.d.ts

@@ -5,11 +5,30 @@ import { type ProgramIniConfig } from "./VexIniConfig.js";
 import { Result, ResultAsync } from "neverthrow";
 import { MatchStatusReplyD2HPacket, DeviceBoundPacket, MatchModeReplyD2HPacket, GetSystemStatusReplyD2HPacket, type HostBoundPacket, Query1ReplyD2HPacket, LoadFileActionReplyD2HPacket, GetSystemFlagsReplyD2HPacket, GetRadioStatusReplyD2HPacket, GetDeviceStatusReplyD2HPacket, SendDashTouchReplyD2HPacket, SelectDashReplyD2HPacket, ScreenCaptureReplyD2HPacket } from "./VexPacket.js";
 import { type VexFirmwareVersion } from "./VexFirmwareVersion.js";
+type HostBoundPacketType<T extends HostBoundPacket> = {
+    new (data: ArrayBuffer | Uint8Array): T;
+    name: string;
+};
+/** Outcome of {@link VexSerialConnection.open}. */
+export type OpenResult = "opened" | "busy" | "no-port";
+/**
+ * Payload of the `warning` event: a non-fatal condition the library
+ * recovered from, surfaced so embedders can log or ignore it.
+ */
+export interface ConnectionWarning {
+    message: string;
+    details?: unknown;
+}
+export interface VexSerialConnectionEvents {
+    connected: undefined;
+    disconnected: undefined;
+    warning: ConnectionWarning;
+}
 /**
  * A connection to a V5 device.
- * Emit events: connected, disconnected
+ * Emit events: connected, disconnected, warning
  */
-export declare class VexSerialConnection extends VexEventTarget {
+export declare class VexSerialConnection extends VexEventTarget<VexSerialConnectionEvents> {
     filters: SerialPortFilter[];
     writer: WritableStreamDefaultWriter<unknown> | undefined;
     reader: ReadableStreamDefaultReader<unknown> | undefined;
@@ -24,19 +43,21 @@ export declare class VexSerialConnection extends VexEventTarget {
     get isConnected(): boolean;
     get isFileTransferring(): boolean;
     constructor(serial: Serial);
+    protected reportWarning(message: string, details?: unknown): void;
     close(): Promise<void>;
     private _hasOpenResources;
     private _doClose;
     /**
-     * Open a port. The result is `Err` only when a connection is already
-     * open (programmer error); otherwise the underlying `boolean |
-     * undefined` semantics are preserved: `true` = opened, `false` =
-     * the port was busy, `undefined` = no matching port was selected.
+     * Open a port. Resolves `"opened"` when a connection is established,
+     * `"busy"` when the matching port is already held elsewhere, and
+     * `"no-port"` when no matching port was selected. The result is `Err`
+     * when a connection is already open (programmer error) or when the
+     * port fails to open (permissions, dead device, ...).
      */
-    open(use?: number | undefined, askUser?: boolean): ResultAsync<boolean | undefined, VexSerialError>;
+    open(use?: number, askUser?: boolean): ResultAsync<OpenResult, VexSerialError>;
     private _open;
-    writeData(rawData: DeviceBoundPacket | Uint8Array, resolve: (data: HostBoundPacket | ArrayBuffer | AckType) => void, timeout?: number): void;
     writeDataAsync(rawData: DeviceBoundPacket | Uint8Array, timeout?: number): Promise<HostBoundPacket | ArrayBuffer | AckType>;
+    request<T extends HostBoundPacket>(packet: DeviceBoundPacket, ReplyType: HostBoundPacketType<T>, timeout?: number): ResultAsync<T, VexSerialError>;
     protected readData(cache: Uint8Array, expectedSize: number): Promise<Uint8Array>;
     protected startReader(): Promise<void>;
     query1(): ResultAsync<Query1ReplyD2HPacket, VexSerialError>;
@@ -101,3 +122,4 @@ export declare class V5SerialConnection extends VexSerialConnection {
     mockTouch(x: number, y: number, press: boolean): ResultAsync<SendDashTouchReplyD2HPacket, VexSerialError>;
     openScreen(screen: number | SelectDashScreen, port: number): ResultAsync<SelectDashReplyD2HPacket, VexSerialError>;
 }
+export {};

package/dist/VexDevice.d.ts

@@ -7,7 +7,6 @@ export { VexSerialDevice, V5Brain, V5Battery, V5BrainButton, V5BrainSettings, V5
 export { sleep, sleepUntil, sleepUntilAsync, downloadFileFromInternet, uploadFirmware, } from "./VexFirmware.js";
 export declare class V5SerialDevice extends VexSerialDevice {
     autoReconnect: boolean;
-    autoRefresh: boolean;
     pauseRefreshOnFileTransfer: boolean;
     protected _isReconnecting: boolean;
     private _isDisconnecting;
@@ -15,7 +14,17 @@ export declare class V5SerialDevice extends VexSerialDevice {
     state: V5SerialDeviceState;
     private _disposed;
     private _refreshGeneration;
-    constructor(defaultSerial: Serial);
+    private _autoRefresh;
+    private _isLastRefreshComplete;
+    private readonly _brain;
+    private readonly _controllers;
+    private readonly _radio;
+    private readonly _deviceFacades;
+    constructor(defaultSerial: Serial, autoRefresh?: boolean);
+    get autoRefresh(): boolean;
+    set autoRefresh(value: boolean);
+    private _startRefreshInterval;
+    private _stopRefreshInterval;
     get isV5Controller(): boolean;
     get brain(): V5Brain;
     get controllers(): [V5Controller, V5Controller];

package/dist/VexDeviceState.d.ts

@@ -6,7 +6,11 @@ import { type ProgramIniConfig } from "./VexIniConfig.js";
 import { VexSerialError } from "./VexError.js";
 import { ResultAsync } from "neverthrow";
 import type { V5SerialDevice } from "./VexDevice.js";
-export declare abstract class VexSerialDevice extends VexEventTarget {
+export interface VexSerialDeviceEvents {
+    disconnected: undefined;
+    error: unknown;
+}
+export declare abstract class VexSerialDevice extends VexEventTarget<VexSerialDeviceEvents> {
     connection: V5SerialConnection | undefined;
     defaultSerial: Serial;
     get isConnected(): boolean;
@@ -19,18 +23,24 @@ export declare class V5SerialDeviceState {
     _instance: V5SerialDevice;
     /**
      * Counter used only to pause automatic refresh while a file transfer
-     * is in flight. This is not a mutex: serialisation of transfer
-     * operations lives on the {@link V5SerialConnection} transaction
-     * queue. The counter is exposed via {@link isFileTransferring} so the
-     * refresh loop can skip work during transfers.
+     * is in flight. This is not a mutex: serialization of transfer
+     * operations lives on the {@link V5SerialConnection} transaction queue.
      */
     private refreshPauseDepth;
+    get isRefreshPaused(): boolean;
+    /**
+     * @deprecated Use {@link isRefreshPaused}. This flag only means that
+     * automatic refresh is paused, not that transfer operations are locked.
+     */
     get isFileTransferring(): boolean;
     /**
      * Increment the refresh-pause depth, run the operation, and decrement
-     * the depth again. The actual transfer mutex lives on the connection,
-     * so this method does not serialise anything; it only signals the
-     * device that a transfer is in progress so refresh polling is paused.
+     * the depth again. The actual transfer mutex lives on the connection.
+     */
+    withRefreshPaused<T>(operation: () => PromiseLike<T>): Promise<T>;
+    /**
+     * @deprecated Use {@link withRefreshPaused}. This only pauses automatic
+     * refresh and does not lock file transfers.
      */
     withFileTransfer<T>(operation: () => PromiseLike<T>): Promise<T>;
     brain: {
@@ -54,15 +64,11 @@ export declare class V5SerialDeviceState {
         systemVersion: VexFirmwareVersion;
         uniqueId: number;
     };
-    controllers: ({
+    controllers: {
         battery: number;
         isAvailable: boolean;
         isCharging: boolean;
-    } | {
-        battery: number;
-        isAvailable: boolean;
-        isCharging?: undefined;
-    })[];
+    }[];
     devices: Array<ISmartDeviceInfo | undefined>;
     isFieldControllerConnected: boolean;
     matchMode: MatchMode;
@@ -80,6 +86,9 @@ export declare class V5SerialDeviceState {
 }
 export declare class V5Brain {
     private readonly state;
+    private readonly batteryFacade;
+    private readonly buttonFacade;
+    private readonly settingsFacade;
     constructor(state: V5SerialDeviceState);
     get isRunningProgram(): boolean;
     get activeProgram(): number;

package/dist/VexError.d.ts

@@ -1,3 +1,4 @@
+import { type AckType } from "./Vex.js";
 /**
  * Typed error hierarchy for the serial protocol package.
  *
@@ -10,6 +11,7 @@ export type VexSerialErrorKind = "not-connected" | "invalid-argument" | "protoco
 /** Base class for every failure surfaced by the serial package. */
 export declare class VexSerialError extends Error {
     readonly kind: VexSerialErrorKind;
+    readonly ackType: AckType | undefined;
     constructor(kind: VexSerialErrorKind, message: string);
 }
 /** No connection is currently open to a device. */
@@ -22,7 +24,8 @@ export declare class VexInvalidArgumentError extends VexSerialError {
 }
 /** The device refused, timed out, or replied unexpectedly to a command. */
 export declare class VexProtocolError extends VexSerialError {
-    constructor(message: string);
+    readonly ackType: AckType | undefined;
+    constructor(message: string, ackType?: AckType);
 }
 /** A file-transfer handshake, read, write, or exit failed. */
 export declare class VexTransferError extends VexSerialError {

package/dist/VexEvent.d.ts

@@ -1,16 +1,21 @@
-export declare class VexEventEmitter {
-    handlerMap: Map<string | symbol, Array<(...args: unknown[]) => void>>;
+type EventName = string | symbol;
+type EventMapKey<TEvents> = Extract<keyof TEvents, EventName>;
+type EventListener<TValue> = (data: TValue) => void;
+export declare class VexEventEmitter<TEvents extends object = Record<EventName, unknown>> {
+    handlerMap: Map<EventName, Array<EventListener<unknown>>>;
     constructor();
-    on(eventName: string | symbol, listener: (...args: unknown[]) => void): void;
-    remove(eventName: string | symbol, listener: (...args: unknown[]) => void): void;
-    emit(eventName: string | symbol, data: unknown): void;
+    on<K extends EventMapKey<TEvents>>(eventName: K, listener: EventListener<TEvents[K]>): void;
+    remove<K extends EventMapKey<TEvents>>(eventName: K, listener: EventListener<TEvents[K]>): void;
+    emit<K extends EventMapKey<TEvents>>(eventName: K, data: TEvents[K]): void;
     clearListeners(): void;
 }
-export declare class VexEventTarget {
-    emitter: VexEventEmitter;
+export declare class VexEventTarget<TEvents extends object = Record<EventName, unknown>> {
+    emitter: VexEventEmitter<TEvents>;
     constructor();
-    emit(eventName: string | symbol, data: unknown): void;
-    on(eventName: string | symbol, listener: (...args: unknown[]) => void): void;
-    remove(eventName: string | symbol, listener: (...args: unknown[]) => void): void;
+    emit<K extends EventMapKey<TEvents>>(eventName: K, data: TEvents[K]): void;
+    on<K extends EventMapKey<TEvents>>(eventName: K, listener: EventListener<TEvents[K]>): void;
+    remove<K extends EventMapKey<TEvents>>(eventName: K, listener: EventListener<TEvents[K]>): void;
     clearListeners(): void;
+    private normalizeEventName;
 }
+export {};

package/dist/VexFirmware.d.ts

@@ -36,10 +36,12 @@ export declare function sleepUntil(f: () => boolean, timeout: number, interval?:
  * when `ms` is negative.
  */
 export declare function sleep(ms: number): ResultAsync<void, VexSerialError>;
+type FirmwareProgressCallback = (state: string, current: number, total: number) => void;
 /**
  * Upload a VEXos firmware archive to a connected brain. Network and
  * archive validation failures are returned as {@link VexSerialError}
  * values rather than thrown; a device that refuses a step or a missing
- * connection surfaces as {@link VexProtocolError} / {@link VexNotConnectedError}.
+ * connection surfaces as {@link VexFirmwareError} / {@link VexNotConnectedError}.
  */
-export declare function uploadFirmware(state: V5SerialDeviceState, publicUrl?: string, usingVersion?: string, progressCallback?: (state: string, current: number, total: number) => void): ResultAsync<boolean, VexSerialError>;
+export declare function uploadFirmware(state: V5SerialDeviceState, publicUrl?: string, usingVersion?: string, progressCallback?: FirmwareProgressCallback): ResultAsync<boolean, VexSerialError>;
+export {};

package/dist/VexFirmwareVersion.d.ts

@@ -1,55 +1,16 @@
-/**
- * This is a class to make it easier to handle passing the VEXos version
- * information around in the application. This provides ways to get any
- * form of the string representation and quickly compare versions.
- */
 export declare class VexFirmwareVersion {
-    major: number;
-    minor: number;
-    build: number;
-    beta: number;
+    readonly major: number;
+    readonly minor: number;
+    readonly build: number;
+    readonly beta: number;
     constructor(major: number, minor: number, build: number, beta: number);
-    /**
-     * Take a a string of MAJOR.MINOR.BUILD.bBETA and converts it to a
-     * VexFirmwareVersion instance
-     * @param version the string to process
-     * @returns a VexFirmwareVersion representing the provided string
-     */
     static fromString(version: string): VexFirmwareVersion;
-    /**
-     * Take a a Uint8Array and converts it to a VexFirmwareVersion instance
-     * @param data the array to process
-     * @param offset the offset to start at
-     * @returns a VexFirmwareVersion representing the provided string
-     */
     static fromUint8Array(data: Uint8Array, offset?: number, reverse?: boolean): VexFirmwareVersion;
     static allZero(): VexFirmwareVersion;
-    /**
-     * Take a a string of MAJOR_MINOR_BUILD_BETA and converts it to a
-     * VexFirmwareVersion instance
-     * @param version the string to process
-     * @returns a VexFirmwareVersion representing the provided string
-     */
     static fromCatalogString(version: string): VexFirmwareVersion;
     isBeta(): boolean;
-    /**
-     * returns version as Uint Array
-     */
     toUint8Array(reverse?: boolean): Uint8Array;
-    /**
-     * returns version as major.minor.build
-     */
     toUserString(): string;
-    /**
-     * returns version as ${major}.${minor}.{build}.b${beta}
-     */
     toInternalString(): string;
-    /**
-     * compares this version to the provided version.
-     * * if this < b: negative
-     * * if this = b: 0
-     * * if this > b: positive
-     * @param that the version to compare again
-     */
     compare(that: VexFirmwareVersion): number;
 }

package/dist/VexIniConfig.d.ts

@@ -20,7 +20,6 @@ export declare class ProgramIniConfig {
     config: Record<number, string>;
     controller1: Record<string, string>;
     controller2: Record<string, string>;
-    constructor();
     setProgramDate(date: Date): void;
     createIni(): string;
     dec2(value: number): string;

package/dist/VexPacketBase.d.ts

@@ -1,18 +1,21 @@
 import { AckType, type DataArray } from "./Vex.js";
 import type { PacketEncoder } from "./VexPacketEncoder.js";
 export declare abstract class Packet {
+    /** Raw bytes sent to or received from the device. */
     data: Uint8Array;
     static ENCODER: PacketEncoder;
     constructor(rawData: DataArray);
 }
 export declare class DeviceBoundPacket extends Packet {
-    get commandId(): number;
-    get commandExtendedId(): number | undefined;
     static COMMAND_ID: number;
     static COMMAND_EXTENDED_ID: number | undefined;
+    get commandId(): number;
+    get commandExtendedId(): number | undefined;
     constructor(payload?: Uint8Array);
 }
 export declare class HostBoundPacket extends Packet {
+    static COMMAND_ID: number;
+    static COMMAND_EXTENDED_ID: number | undefined;
     ack: AckType;
     payloadSize: number;
     ackIndex: number;

package/dist/VexPacketEncoder.d.ts

@@ -8,46 +8,27 @@ export declare class PacketEncoder {
     static J2000_EPOCH: number;
     vexVersion: number;
     crcgen: CrcGenerator;
-    allPacketsTable: Record<string, typeof HostBoundPacket>;
+    allPacketsTable: Map<number, Map<number | undefined, typeof HostBoundPacket>>;
     static getInstance(): PacketEncoder;
     private constructor();
-    /**
-     * Create the vex CDC header
-     * @param buf the bytes to send
-     */
+    /** Look up the reply class registered for a command ID pair. */
+    getPacketType(commandId: number | undefined, commandExtendedId: number | undefined): typeof HostBoundPacket | undefined;
+    /** Create the vex CDC header. */
     createHeader(buf: ArrayBuffer | undefined): Uint8Array;
-    /**
-     * Create the vex CDC simple message
-     * @param cmd the CDC command byte
-     */
+    /** Create a simple CDC message. */
     cdcCommand(cmd: number): Uint8Array;
-    /**
-     * Create the vex CDC simple message
-     * @param cmd the CDC command byte
-     * @param data the data to send
-     */
+    /** Create a simple CDC message carrying data. */
     cdcCommandWithData(cmd: number, data: Uint8Array): Uint8Array;
-    /**
-     * Create the vex CDC extended message
-     * @param cmd the CDC command byte
-     * @param ext the CDC extended command byte
-     * @return a message
-     */
+    /** Create a CDC2 (extended) message with no payload. */
     cdc2Command(cmd: number, ext: number): Uint8Array;
     /**
-     * Calculate buffer length for new CDC extended command
-     * @param data the CDC extended command payload
-     * @returns the required buffer length of the command message
+     * Buffer length for a CDC2 command: header + command byte + function
+     * byte + length byte (two bytes when payload > 127) + payload + CRC16.
      */
     cdc2CommandBufferLength(data: Uint8Array): number;
-    /**
-     * Create the vex CDC extended message with some data
-     * @param cmd the CDC command byte
-     * @param ext the CDC extended command byte
-     * @param data the CDC extended command payload
-     * @return a message
-     */
+    /** Create a CDC2 (extended) message carrying a payload. */
     cdc2CommandWithData(cmd: number, ext: number, data: Uint8Array): Uint8Array;
+    private appendCrc16;
     validateHeader(data: Uint8Array): boolean;
     validateMessageCdc(data: Uint8Array): boolean;
     getPayloadSize(data: Uint8Array): number;

package/dist/VexPacketModels.d.ts

@@ -4,12 +4,10 @@ import { DeviceBoundPacket, HostBoundPacket } from "./VexPacketBase.js";
 export declare class Query1H2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
     static COMMAND_EXTENDED_ID: undefined;
-    constructor();
 }
 export declare class SystemVersionH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
     static COMMAND_EXTENDED_ID: undefined;
-    constructor();
 }
 export declare class UpdateMatchModeH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
@@ -19,7 +17,6 @@ export declare class UpdateMatchModeH2DPacket extends DeviceBoundPacket {
 export declare class GetMatchStatusH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
     static COMMAND_EXTENDED_ID: number;
-    constructor();
 }
 export declare class GetRadioModeH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
@@ -103,22 +100,18 @@ export declare class GetSystemFlagsH2DPacket extends DeviceBoundPacket {
 export declare class GetDeviceStatusH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
     static COMMAND_EXTENDED_ID: number;
-    constructor();
 }
 export declare class GetSystemStatusH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
     static COMMAND_EXTENDED_ID: number;
-    constructor();
 }
 export declare class GetFdtStatusH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
     static COMMAND_EXTENDED_ID: number;
-    constructor();
 }
 export declare class GetLogCountH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
     static COMMAND_EXTENDED_ID: number;
-    constructor();
 }
 export declare class ReadLogPageH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
@@ -128,7 +121,6 @@ export declare class ReadLogPageH2DPacket extends DeviceBoundPacket {
 export declare class GetRadioStatusH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
     static COMMAND_EXTENDED_ID: number;
-    constructor();
 }
 export declare class ScreenCaptureH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
@@ -158,12 +150,10 @@ export declare class WriteKeyValueH2DPacket extends DeviceBoundPacket {
 export declare class GetSlot1to4InfoH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
     static COMMAND_EXTENDED_ID: number;
-    constructor();
 }
 export declare class GetSlot5to8InfoH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
     static COMMAND_EXTENDED_ID: number;
-    constructor();
 }
 export declare class FactoryStatusH2DPacket extends DeviceBoundPacket {
     static COMMAND_ID: number;
@@ -247,7 +237,6 @@ export declare class ReadFileReplyD2HPacket extends HostBoundPacket {
     length: number;
     buf: ArrayBuffer;
     constructor(data: DataArray);
-    static isValidPacket(data: Uint8Array, n: number): boolean;
 }
 export declare class LinkFileReplyD2HPacket extends HostBoundPacket {
     static COMMAND_ID: number;

package/dist/VexPacketView.d.ts

@@ -12,7 +12,9 @@ export declare class PacketView extends DataView<ArrayBuffer> {
     nextInt32(littleEndian?: boolean): number;
     nextUint32(littleEndian?: boolean): number;
     nextString(length: number): string;
+    /** Read a null-terminated string from a fixed-width `length`-byte field. */
     nextNTBS(length: number): string;
+    /** Read a null-terminated string of at most `length` bytes. */
     nextVarNTBS(length: number): string;
     nextVersion(reverse?: boolean): VexFirmwareVersion;
 }