serial-core 0.2.4 → 0.3.0

package/dist/index.d.ts

@@ -1,13 +1,515 @@
+import { SerialPort } from "serialport";
+import { EventEmitter } from "events";
+/** Connection states emitted by `SerialService` through the `status` event. */
+export declare const SerialStatus: {
+  /** Initial state, manual stop, disabled recovery or exhausted retry budget. */
+  readonly DISCONNECTED: "DISCONNECTED";
+  /** Waiting for previous teardown or enumerating candidate devices. */
+  readonly SCANNING: "SCANNING";
+  /** Port reserved; opening or performing the optional handshake. */
+  readonly CONNECTING: "CONNECTING";
+  /** Port open and handshake, when configured, completed; `send()` is allowed. */
+  readonly CONNECTED: "CONNECTED";
+  /** A retry is scheduled; `send()` rejects during recovery. */
+  readonly RECONNECTING: "RECONNECTING";
+};
+/** Union of the string values in {@link SerialStatus}. */
+export type SerialStatus = (typeof SerialStatus)[keyof typeof SerialStatus];
 /**
- * @license GPL-3.0 serial-core
+ * Options for `SerialService`. `baudRate` and at least one device selector
+ * (`path`, `vendorId`, `productId`, `serialNumber`) are required.
  *
- * Created by (c) Danidoble.
+ * @remarks
+ * A fixed path takes precedence over discovery selectors. Timer values must be
+ * positive, finite and no greater than 2147483647 ms. Invalid configuration throws
+ * during construction. Specify optional properties only when overriding defaults.
  *
- * This source code is licensed under the GPL-3.0 license found in the
- * LICENSE file in the root directory of this source tree.
+ * @example Vendor-only autodiscovery; omit path so discovery is enabled.
+ * ```ts
+ * const config: SerialConfig = { baudRate: 9600, vendorId: '0403', autoConnect: true };
+ * ```
+ * @example Product-only autodiscovery, without a vendor selector.
+ * ```ts
+ * const config: SerialConfig = { baudRate: 115200, productId: '6001', autoConnect: true };
+ * ```
+ * @example Exact vendor/product combination with optional physical-unit identity.
+ * ```ts
+ * const config: SerialConfig = {
+ *   baudRate: 115200, vendorId: '0403', productId: '6001', serialNumber: 'UNIT-1'
+ * };
+ * ```
  */
-export { SerialService } from './SerialService.ts';
-export { SerialStatus } from './types.ts';
-export type { SerialConfig, SerialEvents } from './types.ts';
-export * from './utils/buffers.ts';
-export { PortScanner } from './core/PortScanner.ts';
+interface SerialConfig {
+  /** Required positive finite baud rate; there is no implicit baud-rate default. */
+  baudRate: number;
+  /** Fixed OS path, such as `COM3` or `/dev/ttyUSB0`; disables discovery when set. */
+  path?: string;
+  /** Exact USB vendor ID after hex normalization, e.g. `0403` or `0x0403`. Enables vendor-only autodiscovery when path is omitted; combine productId/serialNumber to narrow matches. */
+  vendorId?: string;
+  /** Exact USB product ID after hex normalization. Enables product-only autodiscovery without vendorId when path is omitted; combine vendorId to restrict the vendor. */
+  productId?: string;
+  /** Initial retry delay in milliseconds. @defaultValue 2000 */
+  reconnectInterval?: number;
+  /** Starts connection in a microtask after construction. @defaultValue false */
+  autoConnect?: boolean;
+  /** Enables retries after connection failures or unexpected closure. @defaultValue true */
+  autoReconnect?: boolean;
+  /** Finite retry-delay multiplier, at least 1. @defaultValue 1 */
+  reconnectBackoffFactor?: number;
+  /** Retry delay ceiling, at least reconnectInterval. @defaultValue Math.max(30000, reconnectInterval) */
+  maxReconnectInterval?: number;
+  /** Non-negative integer retry budget, excluding the initial attempt, or Infinity. @defaultValue Infinity */
+  maxReconnectAttempts?: number;
+  /** Exact serial-number selector; distinguishes units with identical VID/PID. */
+  serialNumber?: string;
+  /** Physical write and drain deadline in milliseconds, independent of send options. @defaultValue 5000 */
+  writeTimeout?: number;
+  /** Response deadline in milliseconds after a write completes. @defaultValue 5000 */
+  responseTimeout?: number;
+  /** Positive integer maximum of active plus pending commands. @defaultValue 1000 */
+  maxQueueSize?: number;
+  /** Reused parser, kept writable after disconnect. Mutually exclusive with parserFactory. */
+  parser?: NodeJS.ReadWriteStream;
+  /** Fresh parser for each connection; recommended to avoid stale frame buffers across sessions. */
+  parserFactory?: () => NodeJS.ReadWriteStream;
+  /** Optional verification before CONNECTED; failure triggers the configured recovery policy. */
+  handshake?: {
+    /** Command sent directly, bypassing the normal queue, after opening the port. */
+    command: string | Buffer;
+    /** Regex or regex source tested against accumulated input; required even when callback is supplied. */
+    pattern: string | RegExp;
+    /** Positive deadline in milliseconds, including handshake command transmission. */
+    timeout: number;
+    /** Tests lowercase hexadecimal input instead of UTF-8 text; ignored with callback. @defaultValue false */
+    hexPattern?: boolean;
+    /** Synchronous per-chunk/frame validator with priority over pattern; true accepts, exceptions fail verification. */
+    callback?: ((data: Buffer | string) => boolean) | null;
+    /** Positive integer accumulated-byte ceiling for pattern matching; not applied to callback. @defaultValue 65536 */
+    maxBufferSize?: number;
+  };
+}
+/** Per-command options for `SerialService.send()`; all fields are optional. */
+interface SendOptions {
+  /** Local response-context label, not sent to the device and not a protocol request ID. */
+  alias?: string;
+  /**
+   * Positive finite milliseconds, at most 2147483647. With waitResponse, starts
+   * after writing and overrides responseTimeout; otherwise limits the queue's write wait.
+   * The service-level writeTimeout independently limits physical write/drain.
+   */
+  timeout?: number;
+  /** Waits for a matching response as well as write/drain; otherwise resolves after drain. @defaultValue false */
+  waitResponse?: boolean;
+  /**
+   * Synchronous response predicate, used only with waitResponse. False ignores
+   * a frame; true accepts it; exceptions reject the command. Without a predicate,
+   * the next chunk/frame is accepted. Use a parser for complete protocol frames.
+   */
+  responseMatcher?: (data: Buffer | string) => boolean;
+}
+/**
+ * Metadata returned by serialport enumeration, passed through without modification.
+ * Includes path and potentially manufacturer, serialNumber, pnpId, locationId,
+ * vendorId and productId; optional field availability depends on OS/driver/device.
+ */
+type SerialPortInfo = Awaited<ReturnType<typeof import('serialport').SerialPort.list>>[number];
+/** Exact AND-combined discovery filters; an empty object lists every enumerated port. */
+interface PortFilter {
+  /** Exact OS path; enumeration still runs and the port is not opened. */
+  path?: string;
+  /** Exact USB VID after trimming, case folding and removal of 0x and leading zeros. */
+  vendorId?: string;
+  /** Exact USB PID using the same normalization as vendorId. */
+  productId?: string;
+  /** Exact, case-sensitive serial number. */
+  serialNumber?: string;
+  /** Exact, case-sensitive manufacturer name. */
+  manufacturer?: string;
+  /** Excludes reservations in this loaded library instance; does not probe other processes. @defaultValue false */
+  availableOnly?: boolean;
+}
+/**
+ * Typed service event listener signatures, not an EventEmitter tuple map.
+ * Listeners run synchronously and should not throw. Handle asynchronous listener
+ * rejections inside the listener; this service does not enable captureRejections.
+ */
+interface SerialEvents {
+  /** Emitted only when status changes. CONNECTED permits sending. */
+  status: (status: SerialStatus) => void;
+  /** Raw chunk or parsed frame, including handshake traffic; optional alias is local context, not guaranteed correlation. */
+  data: (data: Buffer | string, alias?: string) => void;
+  /** Operational error, emitted only when at least one error listener exists; missing listeners do not stop recovery. */
+  error: (err: Error) => void;
+  /** Readiness after opening, successful transmission and optional handshake. Emitted on each successful connection. */
+  connected: (info: {
+    /** Ready transport's actual OS path, which can change after USB rediscovery. */
+    path: string;
+    /** Configured connection speed in bits per second. */
+    baudRate: number;
+  }) => void;
+  /** Manual shutdown or unexpected loss; reasons currently emitted are Manual and Unexpected. */
+  disconnected: (reason: string) => void;
+  /** Scheduled retry: attempt is one-based and delay is milliseconds, not proof of an open attempt. */
+  reconnecting: (info: {
+    /** One-based scheduled retry number, excluding the initial connection attempt. */
+    attempt: number;
+    /** Capped delay in milliseconds before starting the scheduled retry. */
+    delay: number;
+  }) => void;
+  /** Retry budget exhausted; attempts excludes the initial connection attempt. Not emitted when autoReconnect is false. */
+  reconnectFailed: (info: {
+    /** Number of automatic retries consumed; excludes the initial attempt. */
+    attempts: number;
+  }) => void;
+}
+/**
+ * Internal bounded FIFO with response waiting and stale-callback isolation.
+ * Not exported from the package root; clients should use SerialService.send().
+ * The injected writer supplies physical-write deadlines; this class alone does
+ * not bound every write or validate its constructor options.
+ */
+declare class QueueManager {
+  private writeHandler;
+  private maxSize;
+  private responseTimeout;
+  private queue;
+  private active;
+  private _currentAlias?;
+  /**
+   * Creates the internal command queue.
+   * @param writeHandler - Writer that resolves after physical completion and rejects on failure.
+   * @param maxSize - Active plus pending command limit; defaults to 1000.
+   * @param responseTimeout - Default post-write response deadline in milliseconds; defaults to 5000.
+   * @remarks SerialService validates these constructor arguments before creating its queue.
+   */
+  constructor(writeHandler: (data: Buffer | string) => Promise<void>, maxSize?: number, responseTimeout?: number);
+  /**
+   * Enqueues and starts a FIFO command, copying Buffer payloads.
+   * @param data - UTF-8 text or binary command.
+   * @param options - Alias, write/response timeout and optional response predicate.
+   * @returns Resolves without response data; rejects on capacity, invalid timeout,
+   * writer error, response timeout, predicate error or clear().
+   * @remarks A timed-out write remains active until its writer settles, preventing overlap.
+   */
+  add(data: Buffer | string, options?: SendOptions): Promise<void>;
+  /** Active or most recently processed command alias; retained while idle and reset by clear(). */
+  get currentAlias(): string | undefined;
+  /**
+   * Rejects all unfinished commands, cancels their queue timers and resets alias/context.
+   * @param error - Shared rejection reason; defaults to Queue cleared due to disconnection.
+   * @remarks Does not cancel the injected writer. SerialService tears down the old transport;
+   * late writer callbacks cannot settle a new command. Reusing this queue directly requires
+   * ensuring the old physical writer cannot overlap a new session.
+   */
+  clear(error?: Error): void;
+  /**
+   * Offers a received chunk/frame to the active waitResponse command.
+   * @param data - Input for responseMatcher; optional only for unfiltered response notification.
+   * @remarks Ignores unrelated/no-active responses. A predicate exception rejects the command.
+   * A matching early response is retained until writing completes; no payload is returned.
+   */
+  notifyResponse(data?: Buffer | string): void;
+  /** Settles a still-current command and advances only after its writer has completed. */
+  private finish;
+  /** Starts at most one writer and installs the relevant queue/response deadline. */
+  private process;
+  /**
+   * Reports the absence of active and pending commands.
+   * @returns False for a timed-out command whose physical writer has not settled yet.
+   */
+  isIdle(): boolean;
+}
+/**
+ * Owns one serial connection, its FIFO command queue and automatic recovery.
+ *
+ * @remarks
+ * Import from `serial-core`. Connection failures are reported through events;
+ * `connect()` starts an attempt and does not wait for readiness. Register a
+ * `connected` listener before starting. Pending commands reject on disconnect
+ * and are never replayed. Inherited EventEmitter listeners run synchronously.
+ *
+ * @example
+ * ```ts
+ * const serial = new SerialService({ path: '/dev/ttyUSB0', baudRate: 9600 });
+ * serial.on('error', error => console.error(error.message));
+ * serial.on('connected', () => {
+ *   void serial.send('PING\n').catch(console.error);
+ * });
+ * await serial.connect();
+ * // Later: await serial.disconnect();
+ * ```
+ */
+export declare class SerialService extends EventEmitter<{ [K in keyof SerialEvents]: Parameters<SerialEvents[K]>; }> {
+  /** Current transport; null while discovering or after cleanup. An open port alone does not imply handshake readiness. */
+  protected port: SerialPort | null;
+  /** Per-service FIFO; cleared on every disconnect or connection failure. Internal extension state. */
+  protected queue: QueueManager;
+  /** Current lifecycle state. Use setStatus() so transitions emit the status event. */
+  protected _status: SerialStatus;
+  /** Configuration snapshot with defaults; do not mutate during an active connection. */
+  protected config: SerialConfig;
+  /** Manual-stop flag that suppresses retries and invalidates late open callbacks. */
+  protected intentionalDisconnect: boolean;
+  /** At most one scheduled retry timer, cleared on manual stop or a new attempt. */
+  protected reconnectTimer: NodeJS.Timeout | null;
+  private generation;
+  private attempts;
+  private lockedPath;
+  private opening;
+  private closing;
+  /** Transport retained until closure succeeds, preserving its process reservation. */
+  private retiring;
+  private closeInProgress;
+  private detach;
+  private cancelHandshake;
+  /**
+   * Creates a service and validates selectors, deadlines, queue capacity and retry settings.
+   * @param config - Required baud rate plus a fixed path or discovery selector.
+   * @throws Error for invalid configuration; SyntaxError for an invalid pattern regex when no callback is used.
+   * @remarks autoConnect defaults to false. When true, connection starts in a microtask so listeners can be attached first.
+   * @example Vendor-only autodiscovery, with automatic rediscovery after disconnect.
+   * ```ts
+   * const serial = new SerialService({ baudRate: 9600, vendorId: '0403', autoConnect: true });
+   * serial.on('connected', ({ path }) => console.log('Ready:', path));
+   * serial.on('error', error => console.error(error.message));
+   * ```
+   * @example Product-only autodiscovery; omit path and vendorId.
+   * ```ts
+   * const serial = new SerialService({ baudRate: 115200, productId: '6001', autoConnect: true });
+   * ```
+   * @example Restrict discovery to both USB IDs; omit path to enable discovery.
+   * ```ts
+   * const serial = new SerialService({ baudRate: 115200, vendorId: '0403', productId: '6001' });
+   * serial.on('connected', ({ path }) => console.log(path));
+   * await serial.connect(); // Initiates discovery; connected reports readiness.
+   * ```
+   */
+  constructor(config: SerialConfig);
+  /**
+   * Enumerates serial port metadata without opening any device.
+   * @param filter - Optional AND-combined selectors; defaults to all enumerated ports.
+   * @returns Matching metadata in driver enumeration order; an empty array means no match.
+   * @throws Rejects with the underlying OS/driver enumeration error.
+   * @remarks availableOnly checks this library's reservations, not OS-wide availability.
+   * @example `const ports = await SerialService.listPorts({ vendorId: '0403' });`
+   */
+  static listPorts(filter?: PortFilter): Promise<SerialPortInfo[]>;
+  /**
+   * Finds all matching ports; equivalent to the static listPorts(filter).
+   * @param filter - Optional exact selectors, combined with AND.
+   * @returns Matching metadata; rejects on enumeration failure.
+   * @example `const devices = await SerialService.findPorts({ serialNumber: 'UNIT-1' });`
+   */
+  static findPorts(filter?: PortFilter): Promise<SerialPortInfo[]>;
+  /**
+   * Instance convenience wrapper for SerialService.listPorts().
+   * @param filter - Enumeration filters; does not implicitly use this service's config.
+   * @returns Matching metadata; rejects on enumeration failure. Does not change connection state.
+   */
+  listPorts(filter?: PortFilter): Promise<SerialPortInfo[]>;
+  /**
+   * Instance convenience wrapper for SerialService.findPorts().
+   * @param filter - Enumeration filters; does not implicitly use this service's config.
+   * @returns Matching metadata; rejects on enumeration failure. Does not reserve devices.
+   */
+  findPorts(filter?: PortFilter): Promise<SerialPortInfo[]>;
+  /** Whether constructor-triggered connection was configured; does not report current connectivity. */
+  get autoConnect(): boolean;
+  /** Current lifecycle state; CONNECTED is required for send(), even when portIsOpen() returns true. */
+  get status(): SerialStatus;
+  /**
+   * Updates lifecycle state and emits status only when its value changes.
+   * @param status - New state; changing state alone does not open or close the transport.
+   * @remarks Protected extension hook; callers are responsible for preserving lifecycle invariants.
+   */
+  protected setStatus(status: SerialStatus): void;
+  /**
+   * Starts a connection attempt or returns immediately if already scanning, connecting or connected.
+   * @returns Resolves after teardown/discovery and initiation of opening, not after readiness.
+   * @remarks
+   * Register connected/error listeners first. Operational failures are reported by events,
+   * with retries controlled by autoReconnect. An explicit inactive/recovery call resets the
+   * retry budget. Without a fixed path, every attempt rediscovers an unreserved match.
+   * Concurrent calls do not create duplicate attempts; they do not share a readiness promise.
+   */
+  connect(): Promise<void>;
+  /** Runs one generation-guarded attempt without resetting the automatic retry budget. */
+  private startConnection;
+  /**
+   * Creates a transport, attaches owned listeners, opens it and starts optional verification.
+   * @param path - Already reserved OS path selected by connect().
+   * @remarks Protected implementation hook. Overrides must preserve ownership, cleanup,
+   * readiness events and late-callback guards; this is not a second public connection API.
+   */
+  protected openPort(path: string): void;
+  /** Marks verified readiness, resets retry count and emits connected for the current transport. */
+  private markConnected;
+  /**
+   * Stops automatic recovery, invalidates pending attempts and rejects unfinished commands.
+   * @returns Resolves after pending open/close callbacks and transport closure.
+   * @throws Rejects if closure fails and the transport remains open; call disconnect() again to retry.
+   * @remarks
+   * Status becomes DISCONNECTED before physical closure finishes. OS open/close callbacks
+   * have no service deadline, so await completion during shutdown. A failed close retains
+   * its reservation. This instance can be reused with connect(); user listeners remain attached.
+   */
+  disconnect(): Promise<void>;
+  /**
+   * Enqueues a command for FIFO transmission while CONNECTED.
+   * @param data - UTF-8 string or binary Buffer; Buffers are copied when enqueued.
+   * @param options - Alias, optional per-command timeout and response-wait settings.
+   * @returns Resolves with no payload after write/drain and, when requested, a matching response.
+   * Receive response payloads through the data event.
+   * @throws Rejects when not ready, over capacity, on invalid timeout, write/response failure,
+   * matcher exception or disconnection. A failed command may already have reached the device.
+   * @remarks No automatic replay. With waitResponse, timeout starts after write/drain;
+   * otherwise it limits writing. The physical writeTimeout always applies independently.
+   * @example `await serial.send('READ\n', { alias: 'read', waitResponse: true, timeout: 1000 });`
+   */
+  send(data: string | Buffer, options?: SendOptions): Promise<void>;
+  /**
+   * Writes directly and waits for the transport drain callback, bypassing the FIFO.
+   * @param data - Raw command, also used by the handshake implementation.
+   * @returns Resolves after drain; rejects on closed transport, error or writeTimeout.
+   * @remarks Protected hook. Overrides must bound writes and preserve serialization;
+   * direct calls can interleave protocol traffic and are not a client API.
+   */
+  protected performWrite(data: string | Buffer): Promise<void>;
+  /**
+   * Clears failed session resources, applies retry policy and reports an operational error.
+   * @param reason - Detail included in the emitted Connection failure error.
+   * @remarks Emits disconnected for an open/connected session; commands are rejected, not replayed.
+   */
+  protected handleConnectionFailure(reason: string): void;
+  /** Emits the special error event only when observed, preserving recovery without a listener. */
+  private reportError;
+  /**
+   * Schedules at most one retry using capped exponential backoff.
+   * @remarks Honors intentionalDisconnect, autoReconnect and the remaining retry budget.
+   * Emits reconnecting for scheduling or reconnectFailed when the budget is exhausted.
+   * Automatic retries do not reset their own counter.
+   */
+  protected scheduleReconnect(): void;
+  /**
+   * Cancels handshake, rejects the FIFO, detaches owned data listeners and starts teardown.
+   * @param error - Rejection reason for active/pending commands; defaults to a disconnection error.
+   * @remarks This void hook initiates asynchronous closure; disconnect() awaits the internal
+   * closing promise. It does not itself set status, schedule retries or remove client listeners.
+   */
+  protected cleanup(error?: Error): void;
+  /** Closes or observes an already-closing transport; releases its reservation only after closure succeeds. */
+  private closeRetiringPort;
+  /**
+   * Sends the configured verification command and validates incoming data before readiness.
+   * @remarks No-op without an open port and handshake config. Regex matching accumulates
+   * bounded bytes; a callback receives individual chunks/frames. Both a match and successful
+   * transmission are required. Failure cancels listeners/timers and invokes recovery.
+   */
+  protected performHandshake(): void;
+  /**
+   * Reports whether there are no active or pending commands.
+   * @returns True even when disconnected; this is not a connectivity or device-idle check.
+   * A rejected, still-draining write can keep the queue busy until transport completion.
+   */
+  queueIsIdle(): boolean;
+  /**
+   * Reports the currently tracked transport's isOpen flag.
+   * @returns False when no current port exists. May be true during handshake;
+   * use status === SerialStatus.CONNECTED to decide whether send() is allowed.
+   */
+  portIsOpen(): boolean;
+  /**
+   * Returns the currently tracked transport path, including during open/handshake.
+   * @returns The current path or null after cleanup/before creating a transport;
+   * does not return a configured or discovered path when no current transport exists.
+   */
+  getPortPath(): string | null;
+  /**
+   * Returns local context for the active or most recently processed command.
+   * @returns Alias or null if absent/cleared. An idle queue may retain its last alias;
+   * unsolicited data may inherit it. It is not a device acknowledgement or request ID.
+   */
+  getLastAlias(): string | null;
+}
+/**
+ * Optimized helpers for Buffer operations.
+ * Designed to minimize unnecessary copies and validations where possible.
+ */
+/**
+ * Efficiently converts various input types to Buffer.
+ * If input is already a Buffer, returns it as is (zero-copy).
+ * @param data - The data to convert (string, number array, Uint8Array, or Buffer)
+ * @returns The original Buffer, a shared-memory view for Uint8Array, or a new Buffer
+ * for strings and number arrays. Strings use UTF-8. Array conversion follows Buffer.from.
+ * @remarks Mutating a Buffer/Uint8Array view may mutate the original storage.
+ * Use Buffer.from(result) when an independent copy is required.
+ * @example `const command = toBuffer([0x01, 0x02, 0xff]);`
+ */
+export declare function toBuffer(data: string | number[] | Uint8Array | Buffer): Buffer;
+/**
+ * Converts a Buffer to Uint8Array.
+ * In Node.js, Buffers ARE Uint8Arrays, so this is ideally zero-copy.
+ * @param buf - The buffer to convert
+ * @returns The exact same object, typed as Uint8Array; this does not copy memory.
+ * @example `const bytes = toUint8Array(Buffer.from([1, 2]));`
+ */
+export declare function toUint8Array(buf: Buffer): Uint8Array;
+/**
+ * Converts a Buffer to string with optional encoding (default utf8).
+ * Wrapper alias for toString().
+ * @param buf - The buffer to convert
+ * @param encoding - The character encoding to use (default: 'utf8')
+ * @returns Decoded text using Node Buffer.toString semantics; decoding does not modify buf.
+ * @example `const hex = toString(Buffer.from([0xff, 0x01]), 'hex'); // 'ff01'`
+ */
+export declare function toString(buf: Buffer, encoding?: BufferEncoding): string;
+/**
+ * Converts a Buffer to ASCII string representation.
+ * @param buf - The buffer to convert
+ * @returns ASCII-decoded text using Buffer.toString('ascii'), which masks the high bit.
+ * @example `const text = toAscii(Buffer.from([0x4f, 0x4b])); // 'OK'`
+ */
+export declare function toAscii(buf: Buffer): string;
+/**
+ * Converts a Buffer to an array of byte values.
+ * Note: Using spread operator may be slow for very large buffers.
+ * @param buf - The buffer to convert
+ * @returns A new independent number array containing byte values 0 through 255.
+ * @example `const bytes = toArray(Buffer.from([0x00, 0xff])); // [0, 255]`
+ */
+export declare function toArray(buf: Buffer): number[];
+/**
+ * Stateless discovery API exported from `serial-core`.
+ * Enumeration never opens or reserves a device. Filters are exact and AND-combined;
+ * order and optional metadata come from the OS/driver and are not sorted here.
+ */
+export declare class PortScanner {
+  /**
+   * Lists port metadata matching optional selectors.
+   * @param filter - Defaults to all ports. VID/PID normalize case, whitespace, 0x and leading zeros.
+   * Other string fields are exact and case-sensitive; missing metadata cannot match a supplied selector.
+   * @returns Metadata in enumeration order, or an empty array if nothing matches.
+   * @throws Rejects on serialport.list() / OS / driver errors; does not swallow or log them.
+   * @remarks availableOnly filters this loaded library's reservations, not other applications' locks.
+   * @example `const ports = await PortScanner.listPorts({ availableOnly: true });`
+   */
+  static listPorts(filter?: PortFilter): Promise<SerialPortInfo[]>;
+  /**
+   * Finds all matching devices; equivalent to listPorts(filter).
+   * @param filter - Optional exact AND-combined metadata selectors.
+   * @returns Matching metadata; rejects on enumeration failure. Does not reserve the result.
+   * @example `const units = await PortScanner.findPorts({ vendorId: '0403', serialNumber: 'A' });`
+   */
+  static findPorts(filter?: PortFilter): Promise<SerialPortInfo[]>;
+  /**
+   * Convenience helper returning the first matching path instead of full metadata.
+   * @param vendorId - Optional vendor ID; required when productId is absent.
+   * @param productId - Optional product ID; may be supplied without vendorId.
+   * @returns First matching OS path or null for no match; ordering is driver-dependent.
+   * @throws Rejects if both IDs are absent/empty or enumeration fails.
+   * @remarks Does not exclude reserved ports. Use findPorts({ availableOnly: true }) for that.
+   * @example `const path = await PortScanner.findPort('0x0403', '6001');`
+   */
+  static findPort(vendorId?: string, productId?: string): Promise<string | null>;
+}
+export type { PortFilter, SendOptions, SerialConfig, SerialEvents, SerialPortInfo };

package/dist/index.js

@@ -1 +1,10 @@
-import{SerialPort as e}from"serialport";import{EventEmitter as t}from"events";const n={DISCONNECTED:`DISCONNECTED`,SCANNING:`SCANNING`,CONNECTING:`CONNECTING`,CONNECTED:`CONNECTED`,RECONNECTING:`RECONNECTING`};var r=class{queue=[];isProcessing=!1;_currentAlias=void 0;waitingForResponse=!1;currentTimeoutTimer=null;currentItem=null;writeHandler;constructor(e){this.writeHandler=e}add(e,t){return new Promise((n,r)=>{this.queue.push({data:e,resolve:n,reject:r,alias:t?.alias,timeout:t?.timeout,waitResponse:t?.waitResponse}),this.process()})}get currentAlias(){return this._currentAlias}clear(){this.queue.forEach(e=>e.reject(Error(`Queue cleared due to disconnection`))),this.queue=[],this.waitingForResponse&&this.currentItem&&(this.currentTimeoutTimer&&clearTimeout(this.currentTimeoutTimer),this.currentItem.reject(Error(`Queue cleared due to disconnection`))),this.isProcessing=!1,this.waitingForResponse=!1,this.currentItem=null,this.currentTimeoutTimer=null}notifyResponse(){this.waitingForResponse&&this.currentItem&&(this.currentTimeoutTimer&&clearTimeout(this.currentTimeoutTimer),this.waitingForResponse=!1,this.currentTimeoutTimer=null,this.currentItem.resolve(),this.currentItem=null,this.isProcessing=!1,this.process())}async process(){if(this.isProcessing||this.waitingForResponse||this.queue.length===0)return;this.isProcessing=!0;let e=this.queue.shift();if(!e){this.isProcessing=!1;return}this.currentItem=e,this._currentAlias=e.alias;let t=null,n=!1;try{if(!e.waitResponse&&e.timeout&&e.timeout>0&&(t=setTimeout(()=>{n=!0,e.reject(Error(`Write timeout after ${e.timeout}ms`)),this.isProcessing=!1,this.currentItem=null,this.process()},e.timeout)),await this.writeHandler(e.data),n)return;t&&clearTimeout(t),e.waitResponse?(this.waitingForResponse=!0,e.timeout&&e.timeout>0&&(this.currentTimeoutTimer=setTimeout(()=>{this.handleResponseTimeout(e)},e.timeout)),this.isProcessing=!1):(e.resolve(),this.currentItem=null,this.isProcessing=!1,this.process())}catch(r){n||(t&&clearTimeout(t),e.reject(r instanceof Error?r:Error(String(r))),this.waitingForResponse=!1,this.currentItem=null,this.isProcessing=!1,this.process())}}handleResponseTimeout(e){this.waitingForResponse=!1,this.currentTimeoutTimer=null,this.currentItem=null,e.reject(Error(`Response timeout after ${e.timeout}ms`)),this.process()}isIdle(){return this.queue.length===0&&!this.isProcessing&&!this.waitingForResponse}},i=class{static async findPort(t,n){if(!t&&!n)throw Error(`VendorID or ProductID is required for automatic scanning.`);try{let r=await e.list(),i=r.find(e=>{let r=e.vendorId?.toLowerCase()||``,i=e.productId?.toLowerCase()||``,a=(t||``).toLowerCase().replace(`0x`,``),o=(n||``).toLowerCase().replace(`0x`,``),s=t?r.includes(a):!0,c=n?i.includes(o):!0;return s&&c});return i?i.path:null}catch(e){return console.error(`Error scanning ports:`,e),null}}},a=class e{static instance;lockedPorts=new Set;constructor(){}static getInstance(){return e.instance||=new e,e.instance}register(e){return this.lockedPorts.has(e)?!1:(this.lockedPorts.add(e),!0)}unregister(e){this.lockedPorts.delete(e)}isLocked(e){return this.lockedPorts.has(e)}},o=class extends t{port=null;queue;_status=n.DISCONNECTED;config;intentionalDisconnect=!1;reconnectTimer=null;constructor(e){super(),this.config=e,this.queue=new r(async e=>this.performWrite(e)),this.config.autoConnect&&this.connect()}get autoConnect(){return this.config.autoConnect}get status(){return this._status}setStatus(e){this._status!==e&&(this._status=e,this.emit(`status`,e))}async connect(){if(this._status===n.CONNECTED||this._status===n.CONNECTING)return;this.intentionalDisconnect=!1,this.setStatus(n.SCANNING);let e=this.config.path;if(!e)try{let t=await i.findPort(this.config.vendorId,this.config.productId);if(t)e=t;else{this.handleConnectionFailure(`Device not found in scan`);return}}catch(e){this.handleConnectionFailure(`Error scanning: ${e}`);return}if(a.getInstance().isLocked(e)){this.handleConnectionFailure(`Port ${e} occupied by another internal instance`);return}if(!a.getInstance().register(e)){this.handleConnectionFailure(`Could not lock port ${e}`);return}this.setStatus(n.CONNECTING),this.openPort(e)}openPort(t){if(this.port=new e({path:t,baudRate:this.config.baudRate,autoOpen:!1}),this.port.open(e=>{if(e){this.handleConnectionFailure(e.message);return}this.config.handshake?this.performHandshake():(this.setStatus(n.CONNECTED),this.emit(`connected`,{path:t,baudRate:this.config.baudRate}))}),this.config.parser){let e=this.port.pipe(this.config.parser);e.on(`data`,e=>{this.queue.notifyResponse(),this.emit(`data`,e,this.queue.currentAlias)}),e.on(`error`,e=>this.emit(`error`,e))}else this.port.on(`data`,e=>{this.queue.notifyResponse(),this.emit(`data`,e,this.queue.currentAlias)});this.port.on(`error`,e=>{this.emit(`error`,e)}),this.port.on(`close`,()=>{this.cleanup(),this.emit(`disconnected`,this.intentionalDisconnect?`Manual`:`Unexpected`),this.intentionalDisconnect?this.setStatus(n.DISCONNECTED):(this.setStatus(n.RECONNECTING),this.scheduleReconnect())})}async disconnect(){if(this.intentionalDisconnect=!0,this.reconnectTimer&&clearTimeout(this.reconnectTimer),this.port&&this.port.isOpen)return new Promise(e=>{this.port?.close(()=>e())})}send(e,t){return this._status===n.CONNECTED?this.queue.add(e,t):Promise.reject(Error(`Port not connected`))}performWrite(e){return new Promise((t,n)=>{if(!this.port||!this.port.isOpen)return n(Error(`Port closed during write`));let r=!this.port.write(e,e=>{if(e)return n(e);r||t()});r&&this.port.once(`drain`,t)})}handleConnectionFailure(e){this.emit(`error`,Error(`Connection failure: ${e}`)),this.cleanup(),this.intentionalDisconnect||(this.setStatus(n.RECONNECTING),this.scheduleReconnect())}scheduleReconnect(){this.reconnectTimer&&clearTimeout(this.reconnectTimer),this.reconnectTimer=setTimeout(()=>{this.connect()},this.config.reconnectInterval)}cleanup(){this.port&&this.port.path&&a.getInstance().unregister(this.port.path),this.port&&(this.port.removeAllListeners(),this.port=null),this.config.parser&&this.config.parser.removeAllListeners(),this.intentionalDisconnect&&this.queue.clear()}performHandshake(){if(!this.port||!this.port.isOpen||!this.config.handshake)return;let{command:e,pattern:t,timeout:r,hexPattern:i,callback:a}=this.config.handshake,o,s=e=>{if(a){let t;t=Buffer.isBuffer(e)||typeof e==`string`?e:Buffer.from(String(e)),a(t)&&(c(),this.setStatus(n.CONNECTED),this.emit(`connected`,{path:this.port.path,baudRate:this.config.baudRate}));return}let r=``;if(Buffer.isBuffer(e))r=i?e.toString(`hex`):e.toString();else if(typeof e==`string`)r=i?Buffer.from(e).toString(`hex`):e;else{let t=Buffer.from(String(e));r=i?t.toString(`hex`):t.toString()}let o=typeof t==`string`?new RegExp(t):t;o.test(r)&&(c(),this.setStatus(n.CONNECTED),this.emit(`connected`,{path:this.port.path,baudRate:this.config.baudRate}))},c=()=>{clearTimeout(o),this.removeListener(`data`,l)},l=e=>s(e);this.on(`data`,l),o=setTimeout(()=>{c(),this.handleConnectionFailure(`Handshake timeout (pattern: ${t})`)},r),this.performWrite(e).catch(e=>{c(),this.handleConnectionFailure(`Error writing handshake: ${e.message}`)})}queueIsIdle(){return this.queue.isIdle()}portIsOpen(){return this.port?.isOpen??!1}getPortPath(){return this.port?.path??null}getLastAlias(){return this.queue.currentAlias??null}};function s(e){return Buffer.isBuffer(e)?e:e instanceof Uint8Array?Buffer.from(e.buffer,e.byteOffset,e.byteLength):(Array.isArray(e),Buffer.from(e))}function c(e){return e}function l(e,t=`utf8`){return e.toString(t)}function u(e){return e.toString(`ascii`)}function d(e){return[...e]}export{i as PortScanner,o as SerialService,n as SerialStatus,d as toArray,u as toAscii,s as toBuffer,l as toString,c as toUint8Array};
+import{SerialPort as e}from"serialport";import{EventEmitter as t}from"events";const n={DISCONNECTED:`DISCONNECTED`,SCANNING:`SCANNING`,CONNECTING:`CONNECTING`,CONNECTED:`CONNECTED`,RECONNECTING:`RECONNECTING`};var r=class{writeHandler;maxSize;responseTimeout;queue=[];active=null;_currentAlias;constructor(e,t=1e3,n=5e3){this.writeHandler=e,this.maxSize=t,this.responseTimeout=n}add(e,t={}){return t.timeout!==void 0&&(!Number.isFinite(t.timeout)||t.timeout<=0||t.timeout>2147483647)?Promise.reject(/* @__PURE__ */ Error(`timeout must be a positive finite number within the timer limit`)):this.queue.length+ +!!this.active>=this.maxSize?Promise.reject(/* @__PURE__ */ Error(`Serial queue capacity exceeded`)):new Promise((n,r)=>{this.queue.push({data:Buffer.isBuffer(e)?Buffer.from(e):e,...t,resolve:n,reject:r}),this.process()})}get currentAlias(){return this._currentAlias}clear(e=/* @__PURE__ */ Error(`Queue cleared due to disconnection`)){let t=this.queue.splice(0),n=this.active;this.active=null,this._currentAlias=void 0,n&&(clearTimeout(n.timer),n.settled||n.item.reject(e),n.settled=!0),t.forEach(t=>t.reject(e))}notifyResponse(e){let t=this.active;if(t&&t.item.waitResponse&&!t.settled)try{if(t.item.responseMatcher&&(e===void 0||!t.item.responseMatcher(e)))return;t.responded=!0,t.writing||this.finish(t)}catch(e){this.finish(t,e instanceof Error?e:Error(String(e)))}}finish(e,t){this.active!==e||e.settled||(clearTimeout(e.timer),e.settled=!0,t?e.item.reject(t):e.item.resolve(),e.writing||(this.active=null,this.process()))}process(){if(this.active||!this.queue.length)return;let e=this.queue.shift(),t={item:e,writing:!0,responded:!1,settled:!1};this.active=t,this._currentAlias=e.alias,!e.waitResponse&&e.timeout&&(t.timer=setTimeout(()=>this.finish(t,/* @__PURE__ */ Error(`Write timeout after ${e.timeout}ms`)),e.timeout)),(async()=>{try{if(await this.writeHandler(e.data),this.active!==t)return;if(t.writing=!1,t.settled)this.active=null,this.process();else if(!e.waitResponse||t.responded)this.finish(t);else{let n=e.timeout??this.responseTimeout;t.timer=setTimeout(()=>this.finish(t,/* @__PURE__ */ Error(`Response timeout after ${n}ms`)),n)}}catch(e){if(this.active!==t)return;t.writing=!1,t.settled?(this.active=null,this.process()):this.finish(t,e instanceof Error?e:Error(String(e)))}})()}isIdle(){return!this.active&&this.queue.length===0}},i=class e{static instance;lockedPorts=/* @__PURE__ */ new Set;constructor(){}static getInstance(){return e.instance||=new e,e.instance}register(e){return!this.lockedPorts.has(e)&&(this.lockedPorts.add(e),!0)}unregister(e){this.lockedPorts.delete(e)}isLocked(e){return this.lockedPorts.has(e)}};function a(e){return e.trim().toLowerCase().replace(/^0x/,``).replace(/^0+(?=.)/,``)}var o=class{static async listPorts(t={}){return(await e.list()).filter(e=>{for(let n of[`vendorId`,`productId`])if(t[n]!==void 0&&(e[n]===void 0||a(e[n])!==a(t[n])))return!1;for(let n of[`path`,`serialNumber`,`manufacturer`])if(t[n]!==void 0&&e[n]!==t[n])return!1;return!t.availableOnly||!i.getInstance().isLocked(e.path)})}static async findPorts(e={}){return this.listPorts(e)}static async findPort(e,t){if(!e&&!t)throw Error(`VendorID or ProductID is required for automatic scanning.`);return(await this.listPorts({vendorId:e,productId:t}))[0]?.path??null}};const s=e=>e instanceof Error?e:Error(String(e));var c=class a extends t{port=null;queue;_status=n.DISCONNECTED;config;intentionalDisconnect=!1;reconnectTimer=null;generation=0;attempts=0;lockedPath=null;opening=null;closing=Promise.resolve();retiring=null;closeInProgress=!1;detach=null;cancelHandshake=null;constructor(e){super(),this.config={autoConnect:!1,autoReconnect:!0,reconnectInterval:2e3,reconnectBackoffFactor:1,maxReconnectAttempts:1/0,writeTimeout:5e3,responseTimeout:5e3,maxQueueSize:1e3,...e,maxReconnectInterval:e.maxReconnectInterval??Math.max(3e4,e.reconnectInterval??2e3)};for(let e of[`baudRate`,`reconnectInterval`,`maxReconnectInterval`,`writeTimeout`,`responseTimeout`,`maxQueueSize`]){let t=this.config[e];if(!Number.isFinite(t)||t<=0)throw Error(`${e} must be a positive finite number`);if(e!==`baudRate`&&e!==`maxQueueSize`&&t>2147483647)throw Error(`${e} exceeds the timer limit`)}if(!Number.isInteger(this.config.maxQueueSize))throw Error(`maxQueueSize must be an integer`);let t=this.config.reconnectBackoffFactor;if(!Number.isFinite(t)||t<1)throw Error(`reconnectBackoffFactor must be at least 1`);let n=this.config.maxReconnectAttempts;if(n!==1/0&&(!Number.isInteger(n)||n<0))throw Error(`maxReconnectAttempts must be a non-negative integer or Infinity`);if(this.config.maxReconnectInterval<this.config.reconnectInterval)throw Error(`maxReconnectInterval must be >= reconnectInterval`);if(!e.path&&!e.vendorId&&!e.productId&&!e.serialNumber)throw Error(`A path, vendorId, productId or serialNumber is required`);if(e.parser&&e.parserFactory)throw Error(`Use parser or parserFactory, not both`);if(e.handshake){if(!Number.isFinite(e.handshake.timeout)||e.handshake.timeout<=0||e.handshake.timeout>2147483647)throw Error(`handshake.timeout must be positive, finite and within the timer limit`);if(e.handshake.maxBufferSize!==void 0&&(!Number.isInteger(e.handshake.maxBufferSize)||e.handshake.maxBufferSize<=0))throw Error(`handshake.maxBufferSize must be a positive integer`);e.handshake.callback||new RegExp(e.handshake.pattern)}this.queue=new r(e=>this.performWrite(e),this.config.maxQueueSize,this.config.responseTimeout),this.config.autoConnect&&queueMicrotask(()=>{this.intentionalDisconnect||this.connect()})}static listPorts(e={}){return o.listPorts(e)}static findPorts(e={}){return o.findPorts(e)}listPorts(e={}){return a.listPorts(e)}findPorts(e={}){return a.findPorts(e)}get autoConnect(){return this.config.autoConnect??!1}get status(){return this._status}setStatus(e){this._status!==e&&(this._status=e,this.emit(`status`,e))}async connect(){[n.SCANNING,n.CONNECTING,n.CONNECTED].some(e=>e===this._status)||(this.attempts=0),await this.startConnection()}async startConnection(){if([n.SCANNING,n.CONNECTING,n.CONNECTED].some(e=>e===this._status))return;this.intentionalDisconnect=!1,this.reconnectTimer&&clearTimeout(this.reconnectTimer),this.reconnectTimer=null;let e=++this.generation;if(this.setStatus(n.SCANNING),await this.closing,!(e!==this.generation||this.intentionalDisconnect))try{if(this.retiring){if(this.cleanup(),await this.closing,e!==this.generation||this.intentionalDisconnect)return;if(this.retiring)throw Error(`Previous serial port could not be closed`)}let t=this.config.path;if(!t){let n=await o.findPorts({vendorId:this.config.vendorId,productId:this.config.productId,serialNumber:this.config.serialNumber,availableOnly:!0});if(e!==this.generation||this.intentionalDisconnect)return;t=n[0]?.path}if(!t)throw Error(`Device not found in scan`);if(!i.getInstance().register(t))throw Error(`Port ${t} occupied by another internal instance`);if(this.lockedPath=t,this.setStatus(n.CONNECTING),e!==this.generation||this.intentionalDisconnect)return;this.openPort(t)}catch(t){e===this.generation&&!this.intentionalDisconnect&&this.handleConnectionFailure(s(t).message)}}openPort(t){let r=new e({path:t,baudRate:this.config.baudRate,autoOpen:!1});this.port=r;let a=this.config.parserFactory?.()??this.config.parser,o=a??r,c=e=>{if(this.port!==r)return;let t=this.queue.currentAlias;this.queue.notifyResponse(e),this.emit(`data`,e,t)},l=e=>{this.port===r&&this.handleConnectionFailure(e.message)},u=()=>{this.port===r&&(this.cleanup(),this.intentionalDisconnect?this.setStatus(n.DISCONNECTED):this.scheduleReconnect(),this.emit(`disconnected`,this.intentionalDisconnect?`Manual`:`Unexpected`))};o.on(`data`,c),a&&(a.on(`error`,l),r.pipe(a,{end:!1})),r.on(`error`,l),r.on(`close`,u),this.detach=()=>{o.removeListener(`data`,c),r.removeListener(`close`,u),a&&(r.unpipe(a),a.removeListener(`error`,l))};let d;this.opening=new Promise(e=>{d=e});let f=e=>{this.port!==r||this.intentionalDisconnect?!e&&r.isOpen?this.closeRetiringPort(r,t).then(d):(i.getInstance().unregister(t),d()):(this.opening=null,d(),e?this.handleConnectionFailure(e.message):this.config.handshake?this.performHandshake():this.markConnected())};try{r.open(f)}catch(e){f(s(e))}}markConnected(){this.port&&!this.intentionalDisconnect&&(this.attempts=0,this.setStatus(n.CONNECTED),this.port&&!this.intentionalDisconnect&&this.emit(`connected`,{path:this.port.path,baudRate:this.config.baudRate}))}async disconnect(){this.intentionalDisconnect=!0,++this.generation,this.attempts=0,this.reconnectTimer&&clearTimeout(this.reconnectTimer),this.reconnectTimer=null;let e=this.port!==null;if(this.cleanup(),this.setStatus(n.DISCONNECTED),await this.closing,this.retiring)throw Error(`Serial port could not be closed; call disconnect() again to retry`);e&&this.emit(`disconnected`,`Manual`)}send(e,t){return this._status===n.CONNECTED?this.queue.add(e,t):Promise.reject(/* @__PURE__ */ Error(`Port not connected`))}performWrite(e){let t=this.port;return t?.isOpen?new Promise((n,r)=>{let i=!1,a=(e,a=!1)=>{i||(i=!0,clearTimeout(l),t.removeListener(`close`,o),t.removeListener(`error`,c),e?r(e):n(),e&&a&&this.port===t&&this.handleConnectionFailure(e.message))},o=()=>a(/* @__PURE__ */ Error(`Port closed during write`)),c=e=>a(e),l=setTimeout(()=>{let e=/* @__PURE__ */ Error(`Write timeout after ${this.config.writeTimeout}ms`);a(e,!0)},this.config.writeTimeout);t.once(`close`,o),t.once(`error`,c);try{t.write(e,e=>{if(!i){if(e)a(e,!0);else try{t.drain(e=>a(e,!0))}catch(e){a(s(e),!0)}}})}catch(e){a(s(e),!0)}}):Promise.reject(/* @__PURE__ */ Error(`Port closed during write`))}handleConnectionFailure(e){let t=this.port?.isOpen||this._status===n.CONNECTED,r=/* @__PURE__ */ Error(`Connection failure: ${e}`);this.cleanup(r),this.intentionalDisconnect||this.scheduleReconnect(),t&&this.emit(`disconnected`,`Unexpected`),this.reportError(r)}reportError(e){this.listenerCount(`error`)&&this.emit(`error`,e)}scheduleReconnect(){if(this.intentionalDisconnect||this.reconnectTimer)return;if(!this.config.autoReconnect||this.attempts>=this.config.maxReconnectAttempts){this.setStatus(n.DISCONNECTED),this.config.autoReconnect&&this.emit(`reconnectFailed`,{attempts:this.attempts});return}let e=Math.min(this.config.maxReconnectInterval,this.config.reconnectInterval*this.config.reconnectBackoffFactor**this.attempts);++this.attempts,this.reconnectTimer=setTimeout(()=>{this.reconnectTimer=null,this.startConnection()},e),this.setStatus(n.RECONNECTING),this.intentionalDisconnect||this.emit(`reconnecting`,{attempt:this.attempts,delay:e})}cleanup(e){if(this.cancelHandshake?.(),this.cancelHandshake=null,this.queue.clear(e),this.detach?.(),this.detach=null,this.closeInProgress)return;let t=this.port??this.retiring?.port,n=this.lockedPath??this.retiring?.path;this.port=null,this.lockedPath=null,this.opening?(this.closing=this.opening,this.opening=null):t&&(t.isOpen||t.closing)?this.closing=this.closeRetiringPort(t,n??null):n&&(i.getInstance().unregister(n),this.retiring=null)}closeRetiringPort(e,t){return this.retiring={port:e,path:t},this.closeInProgress=!0,new Promise(n=>{let r=r=>{this.closeInProgress=!1,e.removeListener?.(`close`,a),e.removeListener?.(`error`,o),r&&e.isOpen||(t&&i.getInstance().unregister(t),this.retiring?.port===e&&(this.retiring=null)),n(),r&&this.reportError(r)},a=()=>r(),o=e=>r(e);try{e.closing?(e.once(`close`,a),e.once(`error`,o)):e.close(r)}catch(e){r(s(e))}})}performHandshake(){if(!this.port?.isOpen||!this.config.handshake)return;let e=this.port,{command:t,pattern:n,timeout:r,hexPattern:i,callback:a,maxBufferSize:o=65536}=this.config.handshake,c=a?null:new RegExp(n),l=Buffer.alloc(0),u=!0,d=!1,f=!1,p=()=>{u=!1,clearTimeout(_),this.removeListener(`data`,g),this.cancelHandshake=null},m=t=>{u&&(p(),this.port===e&&this.handleConnectionFailure(t))},h=()=>{u&&d&&f&&this.port===e&&(p(),this.markConnected())},g=t=>{if(u&&this.port===e)try{let e;if(a)e=a(t);else{let n=Buffer.isBuffer(t)?t:Buffer.from(t);if(l.length+n.length>o){m(`Handshake buffer limit exceeded`);return}l=Buffer.concat([l,n]),c.lastIndex=0,e=c.test(l.toString(i?`hex`:`utf8`))}e&&(f=!0,h())}catch(e){m(`Handshake validation failed: ${s(e).message}`)}},_=setTimeout(()=>m(`Handshake timeout (pattern: ${n})`),r);this.cancelHandshake=p,this.on(`data`,g),this.performWrite(t).then(()=>{d=!0,h()}).catch(e=>m(`Error writing handshake: ${s(e).message}`))}queueIsIdle(){return this.queue.isIdle()}portIsOpen(){return this.port?.isOpen??!1}getPortPath(){return this.port?.path??null}getLastAlias(){return this.queue.currentAlias??null}};function l(e){return Buffer.isBuffer(e)?e:e instanceof Uint8Array?Buffer.from(e.buffer,e.byteOffset,e.byteLength):Buffer.from(e)}function u(e){return e}function d(e,t=`utf8`){return e.toString(t)}function f(e){return e.toString(`ascii`)}function p(e){return[...e]}
+/**
+* @license GPL-3.0 serial-core
+*
+* Created by (c) Danidoble.
+*
+* This source code is licensed under the GPL-3.0 license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+export{o as PortScanner,c as SerialService,n as SerialStatus,p as toArray,f as toAscii,l as toBuffer,d as toString,u as toUint8Array};