webserial-core 1.2.0 → 2.0.0-dev.1

package/dist/adapters/websocket/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @file index.ts
+ * WebSocket adapter — re-exports `createWebSocketProvider` as the public API
+ * for relaying serial communication over a WebSocket bridge server.
+ */
+export { createWebSocketProvider } from './WebSocketProvider.js';

package/dist/core/AbstractSerialDevice.d.ts

@@ -0,0 +1,108 @@
+import { SerialEventEmitter } from './SerialEventEmitter.js';
+import { SerialDeviceOptions, SerialPolyfillOptions, SerialProvider } from '../types/index.js';
+/**
+ * Abstract base class for all serial devices.
+ *
+ * @typeParam T - Type of parsed data emitted by `"serial:data"` events.
+ *   Use `string` with a delimiter parser, `Uint8Array` for raw/fixed-length,
+ *   or any custom type with a custom parser.
+ */
+export declare abstract class AbstractSerialDevice<T> extends SerialEventEmitter<T> {
+    /** The currently open serial port, or `null` when disconnected. */
+    protected port: SerialPort | null;
+    private reader;
+    private writer;
+    private queue;
+    private options;
+    private isConnecting;
+    private abortController;
+    private userInitiatedDisconnect;
+    private reconnectTimerId;
+    private isHandshaking;
+    /**
+     * Custom serial provider (e.g. a WebUSB polyfill).
+     * Falls back to `navigator.serial` when not set.
+     */
+    private static customProvider;
+    /**
+     * Options forwarded to the polyfill provider on every
+     * `requestPort()` / `getPorts()` call.
+     */
+    private static polyfillOptions;
+    constructor(options: SerialDeviceOptions<T>);
+    /**
+     * Override this method in your subclass to perform a handshake
+     * after the port is opened. Return `true` if the handshake
+     * succeeds (correct device), or `false` to reject the port.
+     *
+     * The method receives the opened port and should write/read
+     * directly to validate the device identity.
+     *
+     * If not overridden, all ports are accepted (no handshake).
+     */
+    protected handshake(): Promise<boolean>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * Internal cleanup: tears down the port, reader, writer without
+     * marking it as user-initiated. This allows auto-reconnect to trigger.
+     */
+    private cleanupPort;
+    forget(): Promise<void>;
+    send(data: string | Uint8Array): Promise<void>;
+    clearQueue(): void;
+    private writeToPort;
+    private readLoop;
+    /**
+     * Opens a port, locks it in the registry, starts reading, and runs the handshake.
+     * If handshake fails, tears down reader/queue, closes and unlocks the port.
+     */
+    private openAndHandshake;
+    /**
+     * Cleans up after a failed handshake attempt and restores the queue.
+     */
+    private teardownHandshake;
+    /**
+     * Cancels and releases the current reader.
+     */
+    private stopReader;
+    /**
+     * Wraps the handshake() in a timeout race.
+     */
+    private runHandshakeWithTimeout;
+    /**
+     * Iterates ALL previously-authorized ports matching filters.
+     * For each match, opens + handshake. Returns the first port that passes.
+     * If a port fails handshake, it is closed and the next one is tried.
+     */
+    private findAndValidatePort;
+    private startReconnecting;
+    stopReconnecting(): void;
+    private reconnect;
+    static getInstances(): AbstractSerialDevice<unknown>[];
+    static connectAll(): Promise<void>;
+    /**
+     * Sets a custom serial provider (e.g. a WebUSB polyfill for Android).
+     * Call this once before any `connect()` if the native Web Serial API
+     * is not available.
+     *
+     * @param provider  The provider object (`{ requestPort, getPorts }`).
+     * @param options   Polyfill options forwarded on every `requestPort` /
+     *                  `getPorts` call.  Use `usbControlInterfaceClass` to
+     *                  support devices that don't use the standard CDC class
+     *                  code (2). E.g. `{ usbControlInterfaceClass: 255 }`.
+     *
+     * @example
+     * ```ts
+     * import { serial as polyfill } from 'web-serial-polyfill';
+     * AbstractSerialDevice.setProvider(polyfill, {
+     *   usbControlInterfaceClass: 255,
+     * });
+     * ```
+     */
+    static setProvider(provider: SerialProvider, options?: SerialPolyfillOptions): void;
+    /**
+     * Returns the serial provider: instance provider > custom provider > navigator.serial > null.
+     */
+    private getSerial;
+}

package/dist/core/SerialEventEmitter.d.ts

@@ -0,0 +1,37 @@
+import { SerialEventMap } from '../types/index.js';
+/**
+ * Type-safe event emitter base class for serial device events.
+ *
+ * All event names and listener signatures are derived from the
+ * {@link SerialEventMap} generic type, providing full IDE autocomplete
+ * and compile-time safety.
+ *
+ * @typeParam T - The parsed data type, forwarded to `SerialEventMap<T>`.
+ */
+export declare class SerialEventEmitter<T> {
+    private listeners;
+    /**
+     * Registers a listener for the given event.
+     *
+     * @param event - The event name (constrained to `SerialEventMap` keys).
+     * @param listener - The callback to invoke when the event fires.
+     * @returns `this` for method chaining.
+     */
+    on<K extends keyof SerialEventMap<T>>(event: K, listener: SerialEventMap<T>[K]): this;
+    /**
+     * Removes a previously registered listener.
+     *
+     * @param event - The event name.
+     * @param listener - The exact listener reference to remove.
+     * @returns `this` for method chaining.
+     */
+    off<K extends keyof SerialEventMap<T>>(event: K, listener: SerialEventMap<T>[K]): this;
+    /**
+     * Emits an event, invoking all registered listeners synchronously.
+     *
+     * @param event - The event name.
+     * @param args - Arguments passed to each listener (type-inferred from `SerialEventMap`).
+     * @returns `true` if any listeners were invoked, `false` otherwise.
+     */
+    emit<K extends keyof SerialEventMap<T>>(event: K, ...args: Parameters<SerialEventMap<T>[K]>): boolean;
+}

package/dist/core/SerialRegistry.d.ts

@@ -0,0 +1,53 @@
+import { AbstractSerialDevice } from './AbstractSerialDevice.js';
+/**
+ * Global registry for serial device instances and port locks.
+ *
+ * Maintains:
+ * - A `Set` of all registered {@link AbstractSerialDevice} instances.
+ * - A `WeakMap` from `SerialPort` to the device instance that currently owns it.
+ *
+ * All methods are static; this class acts as a module-level singleton.
+ */
+export declare class SerialRegistry {
+    private static instances;
+    private static portInstanceMap;
+    /**
+     * Returns all currently registered device instances.
+     *
+     * @returns An array snapshot of all registered devices.
+     */
+    static getInstances(): AbstractSerialDevice<unknown>[];
+    /**
+     * Registers a device instance so it appears in `getInstances()`.
+     *
+     * @param instance - The device to register.
+     */
+    static register(instance: AbstractSerialDevice<unknown>): void;
+    /**
+     * Removes a device instance from the registry.
+     *
+     * @param instance - The device to unregister.
+     */
+    static unregister(instance: AbstractSerialDevice<unknown>): void;
+    /**
+     * Returns `true` if the port is held by a **different** device instance.
+     *
+     * @param port - The serial port to check.
+     * @param instance - The device requesting access.
+     * @returns `true` if the port is locked by another device.
+     */
+    static isPortInUse(port: SerialPort, instance: AbstractSerialDevice<unknown>): boolean;
+    /**
+     * Assigns exclusive ownership of a port to an instance.
+     *
+     * @param port - The port to lock.
+     * @param instance - The device claiming the port.
+     */
+    static lockPort(port: SerialPort, instance: AbstractSerialDevice<unknown>): void;
+    /**
+     * Releases the exclusive lock on a port.
+     *
+     * @param port - The port to unlock.
+     */
+    static unlockPort(port: SerialPort): void;
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @file errors/index.ts
+ *
+ * Custom error classes for `webserial-core`. All errors extend the native
+ * `Error` class and set a stable `name` property for `instanceof` checks
+ * across environments that may not preserve class names.
+ */
+/**
+ * Thrown when a port is requested while another device instance already
+ * holds an exclusive lock on it.
+ */
+export declare class SerialPortConflictError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when the user cancels the port-picker dialog or when the browser
+ * denies permission to access a serial port.
+ */
+export declare class SerialPermissionError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when a command in the queue does not receive a response before the
+ * configured `commandTimeout` elapses.
+ */
+export declare class SerialTimeoutError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when reading from an open serial port fails.
+ */
+export declare class SerialReadError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when writing to an open serial port fails.
+ */
+export declare class SerialWriteError extends Error {
+    constructor(message: string);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './core/AbstractSerialDevice.js';
+export * from './core/SerialEventEmitter.js';
+export * from './core/SerialRegistry.js';
+export * from './errors/index.js';
+export * from './parsers/index.js';
+export * from './queue/CommandQueue.js';
+export * from './types/index.js';
+export * from './adapters/web-usb/index.js';
+export * from './adapters/web-bluetooth/index.js';
+export * from './adapters/websocket/index.js';

package/dist/parsers/DelimiterParser.d.ts

@@ -0,0 +1,22 @@
+import { SerialParser } from '../types/index.js';
+/**
+ * Creates a delimiter-based parser that splits the byte stream into
+ * string messages separated by the given delimiter string.
+ *
+ * Commonly used with `'\n'` for Arduino `Serial.println()` output.
+ *
+ * @param char - The delimiter string (e.g. `'\n'`, `'\r\n'`, `';'`).
+ * @returns A {@link SerialParser} that emits `string` values.
+ *
+ * @example
+ * ```ts
+ * import { AbstractSerialDevice, delimiter } from 'webserial-core';
+ *
+ * class MyDevice extends AbstractSerialDevice<string> {
+ *   constructor() {
+ *     super({ baudRate: 9600, parser: delimiter('\n') });
+ *   }
+ * }
+ * ```
+ */
+export declare function delimiter(char: string): SerialParser<string>;

package/dist/parsers/FixedLengthParser.d.ts

@@ -0,0 +1,23 @@
+import { SerialParser } from '../types/index.js';
+/**
+ * Creates a fixed-length parser that buffers bytes and emits
+ * `Uint8Array` chunks of exactly `length` bytes.
+ *
+ * Excess bytes are retained in the internal buffer for the next emission.
+ *
+ * @param length - The exact number of bytes per emitted chunk. Must be > 0.
+ * @returns A {@link SerialParser} that emits `Uint8Array` values.
+ * @throws {Error} If `length` is not a positive integer.
+ *
+ * @example
+ * ```ts
+ * import { AbstractSerialDevice, fixedLength } from 'webserial-core';
+ *
+ * class SensorDevice extends AbstractSerialDevice<Uint8Array> {
+ *   constructor() {
+ *     super({ baudRate: 115200, parser: fixedLength(8) });
+ *   }
+ * }
+ * ```
+ */
+export declare function fixedLength(length: number): SerialParser<Uint8Array>;

package/dist/parsers/RawParser.d.ts

@@ -0,0 +1,22 @@
+import { SerialParser } from '../types/index.js';
+/**
+ * Creates a raw pass-through parser that emits each incoming byte chunk
+ * directly without any buffering or splitting.
+ *
+ * Use this when you want to handle framing yourself, or when the device
+ * sends infrequent, self-contained binary packets.
+ *
+ * @returns A {@link SerialParser} that emits raw `Uint8Array` chunks.
+ *
+ * @example
+ * ```ts
+ * import { AbstractSerialDevice, raw } from 'webserial-core';
+ *
+ * class RawDevice extends AbstractSerialDevice<Uint8Array> {
+ *   constructor() {
+ *     super({ baudRate: 115200, parser: raw() });
+ *   }
+ * }
+ * ```
+ */
+export declare function raw(): SerialParser<Uint8Array>;

package/dist/parsers/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file parsers/index.ts
+ * Re-exports all built-in parser factories.
+ */
+export * from './FixedLengthParser.js';
+export * from './DelimiterParser.js';
+export * from './RawParser.js';

package/dist/queue/CommandQueue.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @file CommandQueue.ts
+ *
+ * FIFO command queue for serial communication. Commands are sent one at a
+ * time; the next command is held until the caller invokes `advance()` (e.g.
+ * on receiving a response) or the per-command timeout elapses.
+ *
+ * Setting `commandTimeout` to `0` disables the timeout and sends commands
+ * back-to-back as fast as the port allows.
+ */
+/** Options for constructing a {@link CommandQueue}. */
+export interface CommandQueueOptions {
+    /**
+     * Maximum time in milliseconds to wait for a response before advancing.
+     * Set to `0` to disable per-command timeouts.
+     */
+    commandTimeout: number;
+    /**
+     * Called when the queue is ready to transmit the next command.
+     * Must write the bytes to the physical port.
+     *
+     * @param command - The raw bytes to send.
+     */
+    onSend: (command: Uint8Array) => Promise<void>;
+    /**
+     * Called when a command's timeout elapses before `advance()` is invoked.
+     *
+     * @param command - The command that timed out.
+     */
+    onTimeout: (command: Uint8Array) => void;
+}
+/**
+ * FIFO queue that serializes serial commands, optionally waiting for a
+ * response (or timeout) between each transmission.
+ */
+export declare class CommandQueue {
+    private queue;
+    /** `true` while the queue is waiting for a response to the current command. */
+    isProcessing: boolean;
+    private isPaused;
+    private timeoutId;
+    private readonly commandTimeout;
+    private readonly onSend;
+    private readonly onTimeout;
+    /**
+     * @param options - Queue configuration. See {@link CommandQueueOptions}.
+     */
+    constructor(options: CommandQueueOptions);
+    /**
+     * The number of commands currently waiting in the queue.
+     */
+    get queueSize(): number;
+    /**
+     * Adds a command to the end of the queue and triggers processing
+     * if the queue is running and idle.
+     *
+     * @param command - Raw bytes to enqueue.
+     */
+    enqueue(command: Uint8Array): void;
+    /**
+     * Signals that a response has been received (or processing is otherwise
+     * complete) and advances to the next command.
+     *
+     * Call this after each expected response to keep the queue moving.
+     */
+    advance(): void;
+    /**
+     * Pauses the queue. In-flight commands are not cancelled, but no new
+     * command will be dequeued until `resume()` is called.
+     */
+    pause(): void;
+    /**
+     * Resumes a paused queue and immediately processes the next command
+     * if one is available.
+     */
+    resume(): void;
+    /**
+     * Discards all pending commands and cancels any active timeout.
+     * Does not affect the paused/running state.
+     */
+    clear(): void;
+    /**
+     * Returns a shallow copy of the current queue contents, leaving the
+     * queue unchanged.
+     *
+     * @returns A snapshot array of pending commands.
+     */
+    snapshot(): Uint8Array[];
+    /**
+     * Prepends a previously saved snapshot to the current queue.
+     * Useful for restoring commands after a failed handshake.
+     *
+     * @param saved - Commands to prepend.
+     */
+    restore(saved: Uint8Array[]): void;
+    private tryProcessNext;
+    private clearCommandTimeout;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,124 @@
+import { AbstractSerialDevice } from '../core/AbstractSerialDevice.js';
+declare global {
+    interface SerialPortInfo {
+        usbVendorId?: number;
+        usbProductId?: number;
+    }
+    interface SerialPort {
+        readable: ReadableStream<Uint8Array> | null;
+        writable: WritableStream<Uint8Array> | null;
+        getInfo(): SerialPortInfo;
+        open(options: SerialOptions): Promise<void>;
+        close(): Promise<void>;
+        forget?(): Promise<void>;
+    }
+    interface SerialOptions {
+        baudRate: number;
+        dataBits?: number;
+        stopBits?: number;
+        parity?: "none" | "even" | "odd";
+        bufferSize?: number;
+        flowControl?: "none" | "hardware";
+    }
+    interface Navigator {
+        serial?: {
+            requestPort(options?: {
+                filters?: SerialPortFilter[];
+            }): Promise<SerialPort>;
+            getPorts(): Promise<SerialPort[]>;
+        };
+    }
+}
+export interface SerialPortFilter {
+    usbVendorId?: number;
+    usbProductId?: number;
+    bluetoothServiceClassId?: string;
+}
+/**
+ * Options forwarded to the WebUSB polyfill when using a custom serial
+ * provider.  These map directly to `SerialPolyfillOptions` in
+ * `web-serial-polyfill`.
+ */
+export interface SerialPolyfillOptions {
+    /** USB interface class for the CDC control interface.  Default: `2`.
+     *  Set to `255` (vendor-specific) for non-standard devices. */
+    usbControlInterfaceClass?: number;
+    /** USB interface class for the CDC data/transfer interface.  Default: `10`. */
+    usbTransferInterfaceClass?: number;
+    /**
+     * USB-to-serial protocol used for device initialization.
+     *
+     * - `'cdc_acm'` — Standard CDC ACM (class 2). Sends `SetLineCoding` +
+     *   `SetControlLineState`.
+     * - `'cp210x'` — Silicon Labs CP2102 / CP2104 vendor protocol. Sends
+     *   vendor-specific commands to enable UART, set baud rate, set line
+     *   control, and activate DTR/RTS.
+     * - `'none'` — Skip all initialization. The device is opened and interfaces
+     *   claimed, but no control transfers are sent.
+     *
+     * When omitted the provider auto-detects:
+     *   interface class 2 → `cdc_acm`,
+     *   vendorId `0x10c4` → `cp210x`,
+     *   otherwise → `none`.
+     */
+    protocol?: "cdc_acm" | "cp210x" | "none";
+}
+/**
+ * A serial provider that abstracts the browser's `navigator.serial` API.
+ * Pass a custom implementation (e.g. a WebUSB polyfill) via
+ * `AbstractSerialDevice.setProvider()` for platforms that don't
+ * support the native Web Serial API.
+ *
+ * The second argument on each method is **optional** and only used by
+ * polyfill providers — the native `navigator.serial` ignores it.
+ */
+export interface SerialProvider {
+    requestPort(options?: {
+        filters?: SerialPortFilter[];
+    }, polyfillOptions?: SerialPolyfillOptions): Promise<SerialPort>;
+    getPorts(polyfillOptions?: SerialPolyfillOptions): Promise<SerialPort[]>;
+}
+export interface SerialParser<T> {
+    /**
+     * Defines how to parse raw byte chunks into the target type T.
+     * Emit can be called multiple times if the chunk contains multiple complete frames.
+     */
+    parse(chunk: Uint8Array, emit: (parsed: T) => void): void;
+    /**
+     * Resets the internal state of the parser (e.g. discards partial buffers).
+     */
+    reset?(): void;
+}
+export interface SerialDeviceOptions<T> {
+    filters?: SerialPortFilter[];
+    baudRate: number;
+    dataBits?: 7 | 8;
+    stopBits?: 1 | 2;
+    parity?: "none" | "even" | "odd";
+    bufferSize?: number;
+    flowControl?: "none" | "hardware";
+    commandTimeout?: number;
+    parser?: SerialParser<T>;
+    /** Enable automatic reconnection when the device disconnects unexpectedly. */
+    autoReconnect?: boolean;
+    /** Polling interval in ms for scanning authorized ports during reconnection. Default: 1500 */
+    autoReconnectInterval?: number;
+    /** Timeout in ms for the handshake to complete. Default: 2000 */
+    handshakeTimeout?: number;
+    /** Optional custom serial provider (e.g. WebUsbProvider) for THIS specific device instance. Overrides the global static Provider. */
+    provider?: SerialProvider;
+    /** Options forwarded to the custom provider when requesting or getting ports for THIS instance. */
+    polyfillOptions?: SerialPolyfillOptions;
+}
+export interface SerialEventMap<T> {
+    "serial:connecting": (instance: AbstractSerialDevice<T>) => void;
+    "serial:connected": (instance: AbstractSerialDevice<T>) => void;
+    "serial:disconnected": (instance: AbstractSerialDevice<T>) => void;
+    "serial:reconnecting": (instance: AbstractSerialDevice<T>) => void;
+    "serial:data": (data: T, instance: AbstractSerialDevice<T>) => void;
+    "serial:sent": (data: Uint8Array, instance: AbstractSerialDevice<T>) => void;
+    "serial:error": (error: Error, instance: AbstractSerialDevice<T>) => void;
+    "serial:need-permission": (instance: AbstractSerialDevice<T>) => void;
+    "serial:queue-empty": (instance: AbstractSerialDevice<T>) => void;
+    "serial:timeout": (command: Uint8Array, instance: AbstractSerialDevice<T>) => void;
+}

package/dist/webserial-core.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=class{listeners={};on(e,t){return this.listeners[e]||(this.listeners[e]=new Set),this.listeners[e].add(t),this}off(e,t){return this.listeners[e]&&this.listeners[e].delete(t),this}emit(e,...t){let n=this.listeners[e];if(!n||n.size===0)return!1;for(let e of n)e(...t);return!0}},t=class{static instances=new Set;static portInstanceMap=new WeakMap;static getInstances(){return Array.from(this.instances)}static register(e){this.instances.add(e)}static unregister(e){this.instances.delete(e)}static isPortInUse(e,t){let n=this.portInstanceMap.get(e);return n!==void 0&&n!==t}static lockPort(e,t){this.portInstanceMap.set(e,t)}static unlockPort(e){this.portInstanceMap.delete(e)}},n=class{queue=[];isProcessing=!1;isPaused=!0;timeoutId=null;commandTimeout;onSend;onTimeout;constructor(e){this.commandTimeout=e.commandTimeout,this.onSend=e.onSend,this.onTimeout=e.onTimeout}get queueSize(){return this.queue.length}enqueue(e){this.queue.push(e),this.tryProcessNext()}advance(){this.clearCommandTimeout(),this.isProcessing=!1,this.tryProcessNext()}pause(){this.isPaused=!0,this.clearCommandTimeout(),this.isProcessing=!1}resume(){this.isPaused=!1,this.tryProcessNext()}clear(){this.queue=[],this.clearCommandTimeout(),this.isProcessing=!1}snapshot(){return[...this.queue]}restore(e){this.queue=[...e,...this.queue]}tryProcessNext(){if(this.isPaused||this.isProcessing||this.queue.length===0)return;this.isProcessing=!0;let e=this.queue.shift();this.commandTimeout>0&&(this.timeoutId=setTimeout(()=>{this.timeoutId=null,this.onTimeout(e),this.advance()},this.commandTimeout)),this.onSend(e).catch(()=>{this.advance()})}clearCommandTimeout(){this.timeoutId!==null&&(clearTimeout(this.timeoutId),this.timeoutId=null)}},r=class e extends Error{constructor(t){super(t),this.name=`SerialPortConflictError`,Object.setPrototypeOf(this,e.prototype)}},i=class e extends Error{constructor(t){super(t),this.name=`SerialPermissionError`,Object.setPrototypeOf(this,e.prototype)}},a=class e extends Error{constructor(t){super(t),this.name=`SerialTimeoutError`,Object.setPrototypeOf(this,e.prototype)}},o=class e extends Error{constructor(t){super(t),this.name=`SerialReadError`,Object.setPrototypeOf(this,e.prototype)}},s=class e extends Error{constructor(t){super(t),this.name=`SerialWriteError`,Object.setPrototypeOf(this,e.prototype)}},c=class r extends e{port=null;reader=null;writer=null;queue;options;isConnecting=!1;abortController=null;userInitiatedDisconnect=!1;reconnectTimerId=null;isHandshaking=!1;static customProvider=null;static polyfillOptions;constructor(e){super(),this.options={baudRate:e.baudRate,dataBits:e.dataBits??8,stopBits:e.stopBits??1,parity:e.parity??`none`,bufferSize:e.bufferSize??255,flowControl:e.flowControl??`none`,filters:e.filters??[],commandTimeout:e.commandTimeout??0,parser:e.parser,autoReconnect:e.autoReconnect??!1,autoReconnectInterval:e.autoReconnectInterval??1500,handshakeTimeout:e.handshakeTimeout??2e3,provider:e.provider,polyfillOptions:e.polyfillOptions},this.queue=new n({commandTimeout:this.options.commandTimeout,onSend:async e=>{await this.writeToPort(e),this.emit(`serial:sent`,e,this)},onTimeout:e=>{this.emit(`serial:timeout`,e,this)}}),this.on(`serial:data`,()=>{this.queue.advance()}),t.register(this)}async handshake(){return!0}async connect(){if(!this.isConnecting&&!this.port){this.isConnecting=!0,this.emit(`serial:connecting`,this);try{let e=this.getSerial();if(!e)throw Error(`Web Serial API is not supported in this browser. Use AbstractSerialDevice.setProvider() to set a WebUSB polyfill.`);if(this.port=await this.findAndValidatePort(),!this.port){let t;try{t=await e.requestPort({filters:this.options.filters},this.options.polyfillOptions??r.polyfillOptions)}catch(e){throw e instanceof DOMException&&(e.name===`NotFoundError`||e.name===`SecurityError`||e.name===`AbortError`)?new i(e instanceof Error?e.message:String(e)):e instanceof Error?e:Error(String(e))}if(!await this.openAndHandshake(t))throw Error(`Handshake failed: the selected device did not respond correctly.`);this.port=t}this.abortController=new AbortController,this.queue.resume(),this.emit(`serial:connected`,this)}catch(e){if(e instanceof i?this.emit(`serial:need-permission`,this):this.emit(`serial:error`,e instanceof Error?e:Error(String(e)),this),this.port){t.unlockPort(this.port);try{await this.port.close()}catch{}this.port=null}throw e}finally{this.isConnecting=!1}}}async disconnect(){this.port&&(this.userInitiatedDisconnect=!0,this.stopReconnecting(),await this.cleanupPort())}async cleanupPort(){if(this.port){this.queue.pause(),this.abortController?.abort(),this.abortController=null;try{let e=this.reader,t=this.writer;if(this.reader=null,this.writer=null,e){try{await e.cancel()}catch{}try{e.releaseLock()}catch{}}if(t){try{await t.close()}catch{}try{t.releaseLock()}catch{}}try{await this.port.close()}catch{}}catch(e){this.emit(`serial:error`,e instanceof Error?e:Error(String(e)),this)}finally{this.port&&t.unlockPort(this.port),this.port=null,this.options.parser?.reset?.(),this.emit(`serial:disconnected`,this),!this.userInitiatedDisconnect&&this.options.autoReconnect&&this.startReconnecting(),this.userInitiatedDisconnect=!1}}}async forget(){await this.disconnect(),this.port&&typeof this.port.forget==`function`&&await this.port.forget(),t.unregister(this)}async send(e){let t;t=typeof e==`string`?new TextEncoder().encode(e):e,t.length>0&&this.queue.enqueue(t)}clearQueue(){this.queue.clear(),this.emit(`serial:queue-empty`,this)}async writeToPort(e){if(!this.port||!this.port.writable)throw new s(`Port not writable.`);this.writer=this.port.writable.getWriter();try{await this.writer.write(e)}catch(e){throw new s(e instanceof Error?e.message:String(e))}finally{this.writer.releaseLock(),this.writer=null}}async readLoop(){if(!(!this.port||!this.port.readable)&&!this.reader){this.reader=this.port.readable.getReader();try{for(;;){let{value:e,done:t}=await this.reader.read();if(t)break;e&&(this.options.parser?this.options.parser.parse(e,e=>{this.emit(`serial:data`,e,this)}):this.emit(`serial:data`,e,this))}}catch(e){if(this.port)throw new o(e instanceof Error?e.message:String(e))}finally{if(this.reader){try{this.reader.releaseLock()}catch{}this.reader=null}}}}async openAndHandshake(e){let n=this;if(t.isPortInUse(e,n))return!1;t.lockPort(e,n);try{await e.open({baudRate:this.options.baudRate,dataBits:this.options.dataBits,stopBits:this.options.stopBits,parity:this.options.parity,bufferSize:this.options.bufferSize,flowControl:this.options.flowControl})}catch(n){throw t.unlockPort(e),n instanceof Error?n:Error(String(n))}this.port=e,this.abortController=new AbortController;let r=this.queue.snapshot();this.isHandshaking=!0,this.readLoop().catch(e=>{!this.isHandshaking&&this.port&&(this.emit(`serial:error`,e,this),this.cleanupPort())}),this.queue.resume();try{let t=await this.runHandshakeWithTimeout();return this.isHandshaking=!1,t?(this.queue.pause(),this.queue.clear(),this.queue.restore(r),this.options.parser?.reset?.(),!0):(await this.teardownHandshake(e,r),!1)}catch{return this.isHandshaking=!1,await this.teardownHandshake(e,r),!1}}async teardownHandshake(e,n){this.queue.pause(),this.queue.clear(),this.queue.restore(n),await this.stopReader(),this.port=null,this.abortController=null,this.options.parser?.reset?.();try{await e.close()}catch{}t.unlockPort(e)}async stopReader(){let e=this.reader;if(this.reader=null,e){try{await e.cancel()}catch{}try{e.releaseLock()}catch{}}}async runHandshakeWithTimeout(){let e=this.options.handshakeTimeout??2e3;return Promise.race([this.handshake(),new Promise(t=>setTimeout(()=>t(!1),e))])}async findAndValidatePort(){let e=this.getSerial();if(!e)return null;let n=await e.getPorts(this.options.polyfillOptions??r.polyfillOptions);if(n.length===0)return null;let i=this.options.filters??[],a=this;for(let e of n)if(!t.isPortInUse(e,a)){if(i.length>0){let t=e.getInfo();if(!i.some(e=>{let n=e.usbVendorId===void 0||e.usbVendorId===t.usbVendorId,r=e.usbProductId===void 0||e.usbProductId===t.usbProductId;return n&&r}))continue}try{if(await this.openAndHandshake(e))return e}catch{}}return null}startReconnecting(){this.reconnectTimerId||=(this.emit(`serial:reconnecting`,this),setInterval(async()=>{if(this.port||this.isConnecting){this.stopReconnecting();return}try{let e=await this.findAndValidatePort();e&&(this.stopReconnecting(),await this.reconnect(e))}catch{}},this.options.autoReconnectInterval))}stopReconnecting(){this.reconnectTimerId&&=(clearInterval(this.reconnectTimerId),null)}async reconnect(e){if(!(this.isConnecting||this.port)){this.isConnecting=!0,this.emit(`serial:connecting`,this);try{this.port=e,this.abortController=new AbortController,this.queue.resume(),this.emit(`serial:connected`,this)}catch(e){this.emit(`serial:error`,e instanceof Error?e:Error(String(e)),this),this.port&&=(t.unlockPort(this.port),null),this.options.autoReconnect&&this.startReconnecting()}finally{this.isConnecting=!1}}}static getInstances(){return t.getInstances()}static async connectAll(){let e=t.getInstances();for(let t of e)try{await t.connect()}catch{}}static setProvider(e,t){r.customProvider=e,r.polyfillOptions=t}getSerial(){return this.options.provider?this.options.provider:r.customProvider?r.customProvider:typeof navigator<`u`&&navigator.serial?navigator.serial:null}};function l(e){if(e<=0)throw Error(`FixedLengthParser: length must be greater than 0`);let t=new Uint8Array;return{parse(n,r){let i=new Uint8Array(t.length+n.length);for(i.set(t),i.set(n,t.length),t=i;t.length>=e;)r(t.slice(0,e)),t=t.slice(e)},reset(){t=new Uint8Array}}}function u(e){let t=``,n=new TextDecoder;return{parse(r,i){t+=n.decode(r,{stream:!0});let a;for(;(a=t.indexOf(e))!==-1;)i(t.slice(0,a)),t=t.slice(a+e.length)},reset(){t=``,n=new TextDecoder}}}function d(){return{parse(e,t){t(e)},reset(){}}}var f=32,p=34,m=0,h=30,g=3,_=7,v=1,y=0,b=771,x=768,S=255,C=8,w=`none`,T=1,E=[16,8,7,6,5],D=[1,2],O=[`none`,`even`,`odd`],k=[`none`,`odd`,`even`],A=[1,1.5,2],j={usbControlInterfaceClass:2,usbTransferInterfaceClass:10,protocol:void 0};function M(e,t){let n=e.configurations[0];if(!n)return null;for(let e of n.interfaces)if(e.alternates[0]?.interfaceClass===t)return e;return null}function N(e,t){let n=e.configurations[0];if(!n)return null;for(let e of n.interfaces){let n=e.alternates[0];if(!n||n.interfaceClass!==t)continue;let r=n.endpoints.some(e=>e.direction===`in`),i=n.endpoints.some(e=>e.direction===`out`);if(r&&i)return e}return null}function P(e,t){let n=e.alternates[0];if(n){for(let e of n.endpoints)if(e.direction===t)return e}throw TypeError(`Interface ${e.interfaceNumber} does not have an ${t} endpoint.`)}function F(e,t){return t===2?`cdc_acm`:e.vendorId===4292?`cp210x`:`none`}var I=class{device_;endpoint_;onError_;constructor(e,t,n){this.device_=e,this.endpoint_=t,this.onError_=n}pull(e){(async()=>{let t=this.endpoint_.packetSize;try{let n=await this.device_.transferIn(this.endpoint_.endpointNumber,t);if(n.status!==`ok`){e.error(`USB error: ${n.status}`),this.onError_();return}if(n.data?.buffer&&n.data.byteLength>0){let t=new Uint8Array(n.data.buffer,n.data.byteOffset,n.data.byteLength);t.length>0&&e.enqueue(t)}}catch(t){e.error(String(t)),this.onError_()}})()}},L=class{device_;endpoint_;onError_;constructor(e,t,n){this.device_=e,this.endpoint_=t,this.onError_=n}async write(e,t){try{let n=await this.device_.transferOut(this.endpoint_.endpointNumber,e.buffer);n.status!==`ok`&&(t.error(n.status),this.onError_())}catch(e){t.error(String(e)),this.onError_()}}},R=class{device_;protocol_;controlInterface_;transferInterface_;inEndpoint_;outEndpoint_;serialOptions_;readable_=null;writable_=null;cdcOutputSignals_={dataTerminalReady:!1,requestToSend:!1,break:!1};constructor(e,t){this.device_=e;let n={...j,...t};this.protocol_=n.protocol??F(e,n.usbControlInterfaceClass);let r=n.usbControlInterfaceClass,i=n.usbTransferInterfaceClass;if(r===i){let t=N(e,i);if(!t)throw TypeError(`Unable to find interface with class ${i} that has both IN and OUT endpoints.`);this.controlInterface_=t,this.transferInterface_=t}else{let t=M(e,r);if(!t)throw TypeError(`Unable to find control interface with class ${r}.`);let n=N(e,i)??M(e,i);if(!n)throw TypeError(`Unable to find transfer interface with class ${i}.`);this.controlInterface_=t,this.transferInterface_=n}this.inEndpoint_=P(this.transferInterface_,`in`),this.outEndpoint_=P(this.transferInterface_,`out`)}get readable(){return!this.readable_&&this.device_.opened&&(this.readable_=new ReadableStream(new I(this.device_,this.inEndpoint_,()=>{this.readable_=null}),{highWaterMark:this.serialOptions_?.bufferSize??S})),this.readable_}get writable(){return!this.writable_&&this.device_.opened&&(this.writable_=new WritableStream(new L(this.device_,this.outEndpoint_,()=>{this.writable_=null}),new ByteLengthQueuingStrategy({highWaterMark:this.serialOptions_?.bufferSize??S}))),this.writable_}async open(e){this.serialOptions_=e,this.validateOptions();try{switch(await this.device_.open(),this.device_.configuration===null&&await this.device_.selectConfiguration(1),await this.device_.claimInterface(this.controlInterface_.interfaceNumber),this.controlInterface_!==this.transferInterface_&&await this.device_.claimInterface(this.transferInterface_.interfaceNumber),this.protocol_){case`cdc_acm`:await this.cdcInit();break;case`cp210x`:await this.cp210xInit();break;case`none`:break}}catch(e){throw this.device_.opened&&await this.device_.close(),Error(`Error setting up device: `+(e instanceof Error?e.message:String(e)),{cause:e})}}async close(){let e=[];if(this.readable_&&e.push(this.readable_.cancel()),this.writable_&&e.push(this.writable_.abort()),await Promise.all(e),this.readable_=null,this.writable_=null,this.device_.opened){switch(this.protocol_){case`cdc_acm`:await this.cdcSetSignals({dataTerminalReady:!1,requestToSend:!1});break;case`cp210x`:await this.cp210xDeinit();break}await this.device_.close()}}async forget(){return this.device_.forget()}getInfo(){return{usbVendorId:this.device_.vendorId,usbProductId:this.device_.productId}}async cdcInit(){await this.cdcSetLineCoding(),await this.cdcSetSignals({dataTerminalReady:!0})}async cdcSetSignals(e){if(this.cdcOutputSignals_={...this.cdcOutputSignals_,...e},e.dataTerminalReady!==void 0||e.requestToSend!==void 0){let e=(this.cdcOutputSignals_.dataTerminalReady?1:0)|(this.cdcOutputSignals_.requestToSend?2:0);await this.device_.controlTransferOut({requestType:`class`,recipient:`interface`,request:p,value:e,index:this.controlInterface_.interfaceNumber})}}async cdcSetLineCoding(){let e=new ArrayBuffer(7),t=new DataView(e);if(t.setUint32(0,this.serialOptions_.baudRate,!0),t.setUint8(4,A.indexOf(this.serialOptions_.stopBits??T)),t.setUint8(5,k.indexOf(this.serialOptions_.parity??w)),t.setUint8(6,this.serialOptions_.dataBits??C),(await this.device_.controlTransferOut({requestType:`class`,recipient:`interface`,request:f,value:0,index:this.controlInterface_.interfaceNumber},e)).status!==`ok`)throw new DOMException(`Failed to set line coding.`,`NetworkError`)}async cp210xInit(){let e=this.controlInterface_.interfaceNumber;await this.device_.controlTransferOut({requestType:`vendor`,recipient:`interface`,request:m,value:v,index:e});let t=new ArrayBuffer(4);new DataView(t).setUint32(0,this.serialOptions_.baudRate,!0),await this.device_.controlTransferOut({requestType:`vendor`,recipient:`interface`,request:h,value:0,index:e},t);let n=this.serialOptions_.dataBits??C,r={none:0,odd:16,even:32}[this.serialOptions_.parity??w]??0,i=({1:0,2:2}[this.serialOptions_.stopBits??T]??0)<<8|r|n;await this.device_.controlTransferOut({requestType:`vendor`,recipient:`interface`,request:g,value:i,index:e}),await this.device_.controlTransferOut({requestType:`vendor`,recipient:`interface`,request:_,value:b,index:e})}async cp210xDeinit(){let e=this.controlInterface_.interfaceNumber;await this.device_.controlTransferOut({requestType:`vendor`,recipient:`interface`,request:_,value:x,index:e}),await this.device_.controlTransferOut({requestType:`vendor`,recipient:`interface`,request:m,value:y,index:e})}validateOptions(){if(this.serialOptions_.baudRate%1!=0)throw RangeError(`Invalid baud rate: ${this.serialOptions_.baudRate}`);if(this.serialOptions_.dataBits!==void 0&&!E.includes(this.serialOptions_.dataBits))throw RangeError(`Invalid dataBits: ${this.serialOptions_.dataBits}`);if(this.serialOptions_.stopBits!==void 0&&!D.includes(this.serialOptions_.stopBits))throw RangeError(`Invalid stopBits: ${this.serialOptions_.stopBits}`);if(this.serialOptions_.parity!==void 0&&!O.includes(this.serialOptions_.parity))throw RangeError(`Invalid parity: ${this.serialOptions_.parity}`)}},z=class{options_;constructor(e){this.options_={...j,...e}}async requestPort(e,t){let n={...this.options_,...t},r=[];if(e?.filters&&e.filters.length>0)for(let t of e.filters){let e={};t.usbVendorId!==void 0&&(e.vendorId=t.usbVendorId),t.usbProductId!==void 0&&(e.productId=t.usbProductId),n.usbControlInterfaceClass!==void 0&&n.usbControlInterfaceClass!==255?e.classCode=n.usbControlInterfaceClass:e.vendorId===void 0&&e.productId===void 0&&(e.classCode=n.usbControlInterfaceClass??2),r.push(e)}else r.push({classCode:n.usbControlInterfaceClass??2});return new R(await navigator.usb.requestDevice({filters:r}),n)}async getPorts(e){let t={...this.options_,...e},n=await navigator.usb.getDevices(),r=[];for(let e of n)try{let n=new R(e,t);r.push(n)}catch{}return r}},B=`6e400001-b5a3-f393-e0a9-e50e24dcca9e`,V=`6e400003-b5a3-f393-e0a9-e50e24dcca9e`,H=`6e400002-b5a3-f393-e0a9-e50e24dcca9e`,U=20,W=10;function G(e){let t=null,n=null,r=null;return{get readable(){return t},get writable(){return n},getInfo(){return{}},async open(){if(!e.gatt)throw Error(`GATT not available on this Bluetooth device.`);r=await e.gatt.connect();let i=await r.getPrimaryService(B),a=await i.getCharacteristic(V),o=await i.getCharacteristic(H);await a.startNotifications(),t=new ReadableStream({start(e){a.addEventListener(`characteristicvaluechanged`,t=>{let n=t.target.value.buffer;e.enqueue(new Uint8Array(n))})}}),n=new WritableStream({async write(e){for(let t=0;t<e.length;t+=U){let n=e.slice(t,t+U);await o.writeValueWithoutResponse(n),t+U<e.length&&await new Promise(e=>setTimeout(e,W))}}})},async close(){r?.connected&&r.disconnect(),t=null,n=null}}}function K(){return{async requestPort(){if(!navigator.bluetooth)throw Error(`Web Bluetooth API is not supported in this browser. Use Chrome on Android, macOS, or ChromeOS.`);return G(await navigator.bluetooth.requestDevice({filters:[{services:[B]}]}))},async getPorts(){return[]}}}function q(e){return new Promise((t,n)=>{e.addEventListener(`open`,()=>t(),{once:!0}),e.addEventListener(`error`,e=>n(e),{once:!0})})}function J(e,t){return new Promise(n=>{let r=i=>{let a=JSON.parse(i.data);a.type===t&&(e.removeEventListener(`message`,r),n(a.payload))};e.addEventListener(`message`,r)})}function Y(e,t){let n=null,r=null;return{get readable(){return n},get writable(){return r},getInfo(){return{usbVendorId:t.vendorId,usbProductId:t.productId}},async open(i){e.send(JSON.stringify({type:`open`,path:t.path,baudRate:i.baudRate,dataBits:i.dataBits,stopBits:i.stopBits,parity:i.parity,parser:{type:`delimiter`,value:`\\n`}})),await J(e,`opened`);let a=[],o=null,s=!1;function c(e){let t=JSON.parse(e.data);if(t.type===`data`&&t.bytes){let e=new Uint8Array(t.bytes);o?o.enqueue(e):a.push(e)}t.type===`closed`&&(s=!0,o&&o.close())}e.addEventListener(`message`,c),n=new ReadableStream({start(e){o=e;for(let t of a)e.enqueue(t);a.length=0,s&&e.close()},cancel(){e.removeEventListener(`message`,c),o=null}}),r=new WritableStream({write(t){e.send(JSON.stringify({type:`write`,bytes:Array.from(t)}))}})},async close(){e.send(JSON.stringify({type:`close`})),n=null,r=null,e.close()}}}function X(e){return{async requestPort(t){let n=new WebSocket(e);await q(n),n.send(JSON.stringify({type:`list-ports`,filters:t?.filters??[]}));let r=(await J(n,`port-list`))[0];if(!r)throw Error(`No ports available on the bridge server. Make sure the Node.js server is running and a device is connected.`);return Y(n,r)},async getPorts(){let t=new WebSocket(e);return await q(t),t.send(JSON.stringify({type:`list-ports`,filters:[]})),(await J(t,`port-list`)).map(e=>Y(t,e))}}}exports.AbstractSerialDevice=c,exports.CommandQueue=n,exports.SerialEventEmitter=e,exports.SerialPermissionError=i,exports.SerialPortConflictError=r,exports.SerialReadError=o,exports.SerialRegistry=t,exports.SerialTimeoutError=a,exports.SerialWriteError=s,exports.WebUsbProvider=z,exports.createBluetoothProvider=K,exports.createWebSocketProvider=X,exports.delimiter=u,exports.fixedLength=l,exports.raw=d;