modbus-rs 0.9.0

package/LICENSE

@@ -0,0 +1,6 @@
+## License
+
+This crate is dual-licensed under GPLv3 and a commercial license. If you require a commercial license to use this crate in a proprietary project, please contact [ch.raghava44@gmail.com](mailto:ch.raghava44@gmail.com) to purchase a license.
+
+
+This project is licensed under the **GNU General Public License v3.0 (GPLv3)** — see [GPL v3.0](https://www.gnu.org/licenses/gpl-3.0.html).

package/README.md

@@ -0,0 +1,239 @@
+# modbus-rs
+
+High-performance Modbus TCP/RTU/ASCII client, server, and gateway for Node.js, powered by Rust.
+
+## Features
+
+- **Async/Promise-based API** - All operations return Promises
+- **TCP Client** - Full Modbus TCP/IP client implementation
+- **Serial Client** - Modbus RTU and ASCII over serial port
+- **TCP Server** - Build Modbus TCP servers with JavaScript handlers
+- **TCP Gateway** - Route requests to multiple downstream servers based on unit ID
+- **High Performance** - Native Rust core with napi-rs bindings
+- **Type Safe** - Full TypeScript definitions included
+- **Cross Platform** - Pre-built binaries for Linux, macOS, and Windows
+
+## Installation
+
+```bash
+npm install modbus-rs
+```
+
+## Quick Start
+
+### TCP Client
+
+```javascript
+const { AsyncTcpModbusClient } = require('modbus-rs');
+
+async function main() {
+  const client = await AsyncTcpModbusClient.connect({
+    host: '127.0.0.1',
+    port: 502,
+    unitId: 1,
+    timeoutMs: 5000,
+  });
+
+  try {
+    // Read holding registers (FC03)
+    const registers = await client.readHoldingRegisters({
+      address: 0,
+      quantity: 10,
+    });
+    console.log('Registers:', registers);
+
+    // Write single register (FC06)
+    await client.writeSingleRegister({
+      address: 0,
+      value: 12345,
+    });
+  } finally {
+    await client.close();
+  }
+}
+
+main().catch(console.error);
+```
+
+### Serial RTU Client
+
+```javascript
+const { AsyncSerialModbusClient } = require('modbus-rs');
+
+async function main() {
+  const client = await AsyncSerialModbusClient.connectRtu({
+    portPath: '/dev/ttyUSB0',
+    unitId: 1,
+    baudRate: 19200,
+    dataBits: 8,
+    stopBits: 1,
+    parity: 'even',
+  });
+
+  try {
+    const registers = await client.readHoldingRegisters({
+      address: 0,
+      quantity: 10,
+    });
+    console.log('Registers:', registers);
+  } finally {
+    await client.close();
+  }
+}
+
+main().catch(console.error);
+```
+
+### TCP Server
+
+```javascript
+const { AsyncTcpModbusServer } = require('modbus-rs');
+
+const holdingRegisters = new Array(1000).fill(0);
+
+async function main() {
+  const server = await AsyncTcpModbusServer.bind(
+    { host: '0.0.0.0', port: 502 },
+    {
+      onReadHoldingRegisters: (req) => {
+        return holdingRegisters.slice(req.address, req.address + req.count);
+      },
+      onWriteSingleRegister: (req) => {
+        holdingRegisters[req.address] = req.value;
+        return true;
+      },
+    }
+  );
+
+  console.log('Server listening on port 502');
+  
+  process.on('SIGINT', async () => {
+    await server.shutdown();
+    process.exit(0);
+  });
+}
+
+main().catch(console.error);
+```
+
+### TCP Gateway
+
+```javascript
+const { AsyncTcpGateway } = require('modbus-rs');
+
+async function main() {
+  const gateway = await AsyncTcpGateway.bind(
+    { host: '0.0.0.0', port: 502 },
+    {
+      downstreams: [
+        { host: '192.168.1.10', port: 502 },
+        { host: '192.168.1.11', port: 502 },
+      ],
+      routes: [
+        { unitId: 1, channel: 0 },
+        { unitId: 2, channel: 1 },
+      ],
+    }
+  );
+
+  console.log('Gateway listening on port 502');
+  
+  process.on('SIGINT', async () => {
+    await gateway.shutdown();
+    process.exit(0);
+  });
+}
+
+main().catch(console.error);
+```
+
+## API Reference
+
+### AsyncTcpModbusClient
+
+- `connect(opts: TcpClientOptions)` - Connect to a Modbus TCP server
+- `close()` - Close the connection
+- `readCoils(opts)` - FC01: Read Coils
+- `readDiscreteInputs(opts)` - FC02: Read Discrete Inputs
+- `readHoldingRegisters(opts)` - FC03: Read Holding Registers
+- `readInputRegisters(opts)` - FC04: Read Input Registers
+- `writeSingleCoil(opts)` - FC05: Write Single Coil
+- `writeSingleRegister(opts)` - FC06: Write Single Register
+- `writeMultipleCoils(opts)` - FC15: Write Multiple Coils
+- `writeMultipleRegisters(opts)` - FC16: Write Multiple Registers
+- `readWriteMultipleRegisters(opts)` - FC23: Read/Write Multiple Registers
+- `readFileRecord(opts)` - FC20: Read File Record
+- `writeFileRecord(opts)` - FC21: Write File Record
+- `readFifoQueue(opts)` - FC24: Read FIFO Queue
+- `readExceptionStatus()` - FC07: Read Exception Status
+- `diagnostics(opts)` - FC08: Diagnostics
+- `readDeviceIdentification(opts)` - FC43/14: Read Device Identification
+
+### AsyncSerialModbusClient
+
+Same methods as `AsyncTcpModbusClient`, with different connection options:
+
+- `connectRtu(opts: SerialClientOptions)` - Connect using Modbus RTU
+- `connectAscii(opts: SerialClientOptions)` - Connect using Modbus ASCII
+
+### AsyncTcpModbusServer
+
+- `bind(opts, handlers)` - Create and start a TCP server
+- `shutdown()` - Stop the server
+
+### AsyncTcpGateway
+
+- `bind(opts, config)` - Create and start a gateway
+- `shutdown()` - Stop the gateway
+
+## Error Handling
+
+All errors are thrown as JavaScript Error objects with descriptive messages:
+
+```javascript
+try {
+  await client.readHoldingRegisters({ address: 0, count: 10 });
+} catch (err) {
+  if (err.message.includes('MODBUS_EXCEPTION')) {
+    console.error('Modbus exception:', err.message);
+  } else if (err.message.includes('MODBUS_TIMEOUT')) {
+    console.error('Request timed out');
+  } else {
+    console.error('Error:', err.message);
+  }
+}
+```
+
+## Status & known limitations (v0.8)
+
+The Node.js bindings are an **early release**. The following work is planned
+for v0.9 and beyond:
+
+* **Server JS handler dispatch** — `AsyncTcpModbusServer.bind()` accepts a
+  handlers object today, but only the lifecycle (`bind` / `shutdown`) and
+  write-request echo are wired up. JS handler callbacks for read requests
+  are not yet invoked; the server returns `IllegalFunction` for reads. The
+  client API is fully functional — use it against any third-party Modbus
+  server today.
+* **`AsyncSerialModbusServer`** — not yet exposed in the JS API. Use the
+  Rust `mbus-async` crate directly for serial servers.
+* **`AbortSignal`** support on per-request methods. Use `timeoutMs` at
+  connect time as a workaround.
+* A separate **browser/WASM npm package** built on the existing `wasm`
+  feature.
+
+## Supported platforms
+
+Pre-built binaries are published for:
+
+- Linux x64 (glibc), Linux arm64 (glibc)
+- macOS x64, macOS arm64
+- Windows x64 (MSVC)
+
+Other targets can be built locally via `cargo build -p mbus-ffi --features nodejs,full`
+followed by `npm run build`.
+
+## License
+
+GPL-3.0-only — see [LICENSE](./LICENSE). A commercial license is available
+for proprietary use; contact ch.raghava44@gmail.com.

package/index.d.ts

@@ -0,0 +1,440 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+/** Async Modbus Serial client supporting RTU and ASCII transports. */
+export declare class AsyncSerialModbusClient {
+  /** Creates and connects a new Serial RTU client. */
+  static connectRtu(opts: SerialClientOptions): Promise<AsyncSerialModbusClient>
+  /** Creates and connects a new Serial ASCII client. */
+  static connectAscii(opts: SerialClientOptions): Promise<AsyncSerialModbusClient>
+  /** Sets the per-request timeout in milliseconds. */
+  setRequestTimeout(timeoutMs: number): void
+  /** Clears the per-request timeout. */
+  clearRequestTimeout(): void
+  /** Returns whether there are pending requests. */
+  get pendingRequests(): boolean
+  /** Closes the client connection. */
+  close(): Promise<void>
+  /** Reconnects the client after a disconnect. */
+  reconnect(): Promise<void>
+  /** Reads holding registers (FC03). */
+  readHoldingRegisters(opts: ReadRegistersOptions): Promise<Array<number>>
+  /** Reads input registers (FC04). */
+  readInputRegisters(opts: ReadRegistersOptions): Promise<Array<number>>
+  /** Writes a single register (FC06). */
+  writeSingleRegister(opts: WriteSingleRegisterOptions): Promise<void>
+  /** Writes multiple registers (FC16). */
+  writeMultipleRegisters(opts: WriteMultipleRegistersOptions): Promise<void>
+  /** Reads and writes multiple registers atomically (FC23). */
+  readWriteMultipleRegisters(opts: ReadWriteMultipleRegistersOptions): Promise<Array<number>>
+  /** Reads coils (FC01). */
+  readCoils(opts: ReadBitsOptions): Promise<Array<boolean>>
+  /** Writes a single coil (FC05). */
+  writeSingleCoil(opts: WriteSingleCoilOptions): Promise<void>
+  /** Writes multiple coils (FC15). */
+  writeMultipleCoils(opts: WriteMultipleCoilsOptions): Promise<void>
+  /** Reads discrete inputs (FC02). */
+  readDiscreteInputs(opts: ReadBitsOptions): Promise<Array<boolean>>
+  /** Reads FIFO queue (FC24). */
+  readFifoQueue(opts: ReadFifoQueueOptions): Promise<FifoQueueResponse>
+  /** Reads file records (FC20). */
+  readFileRecord(opts: ReadFileRecordOptions): Promise<Array<Array<number>>>
+  /** Writes file records (FC21). */
+  writeFileRecord(opts: WriteFileRecordOptions): Promise<void>
+  /** Reads exception status (FC07). */
+  readExceptionStatus(): Promise<number>
+  /** Sends a diagnostics request (FC08). */
+  diagnostics(opts: DiagnosticsOptions): Promise<DiagnosticsResponse>
+  /** Reads device identification (FC43/MEI14). */
+  readDeviceIdentification(opts: ReadDeviceIdentificationOptions): Promise<DeviceIdentificationResponse>
+}
+
+/**
+ * Async Modbus TCP gateway.
+ *
+ * Forwards incoming Modbus requests to downstream servers based on unit ID routing.
+ */
+export declare class AsyncTcpGateway {
+  /**
+   * Creates and starts a new TCP gateway.
+   *
+   * @param opts - Gateway bind options.
+   * @param config - Gateway configuration including downstreams and routes.
+   * @returns A running gateway instance.
+   */
+  static bind(opts: GatewayBindOptions, config: GatewayConfig): Promise<AsyncTcpGateway>
+  /** Stops the gateway. */
+  shutdown(): Promise<void>
+}
+
+/**
+ * Async Modbus TCP client.
+ *
+ * All methods are async and return Promises. The client must be connected
+ * before issuing Modbus requests.
+ */
+export declare class AsyncTcpModbusClient {
+  /**
+   * Creates and connects a new TCP client.
+   *
+   * @param opts - Connection options including host, port, unitId, and optional timeout.
+   * @returns A connected client instance.
+   */
+  static connect(opts: TcpClientOptions): Promise<AsyncTcpModbusClient>
+  /** Sets the per-request timeout in milliseconds. */
+  setRequestTimeout(timeoutMs: number): void
+  /** Clears the per-request timeout. */
+  clearRequestTimeout(): void
+  /** Returns whether there are pending requests. */
+  get pendingRequests(): boolean
+  /** Closes the client connection. */
+  close(): Promise<void>
+  /** Reconnects the client after a disconnect. */
+  reconnect(): Promise<void>
+  /** Reads holding registers (FC03). */
+  readHoldingRegisters(opts: ReadRegistersOptions): Promise<Array<number>>
+  /** Reads input registers (FC04). */
+  readInputRegisters(opts: ReadRegistersOptions): Promise<Array<number>>
+  /** Writes a single register (FC06). */
+  writeSingleRegister(opts: WriteSingleRegisterOptions): Promise<void>
+  /** Writes multiple registers (FC16). */
+  writeMultipleRegisters(opts: WriteMultipleRegistersOptions): Promise<void>
+  /** Reads and writes multiple registers atomically (FC23). */
+  readWriteMultipleRegisters(opts: ReadWriteMultipleRegistersOptions): Promise<Array<number>>
+  /** Reads coils (FC01). */
+  readCoils(opts: ReadBitsOptions): Promise<Array<boolean>>
+  /** Writes a single coil (FC05). */
+  writeSingleCoil(opts: WriteSingleCoilOptions): Promise<void>
+  /** Writes multiple coils (FC15). */
+  writeMultipleCoils(opts: WriteMultipleCoilsOptions): Promise<void>
+  /** Reads discrete inputs (FC02). */
+  readDiscreteInputs(opts: ReadBitsOptions): Promise<Array<boolean>>
+  /** Reads FIFO queue (FC24). */
+  readFifoQueue(opts: ReadFifoQueueOptions): Promise<FifoQueueResponse>
+  /** Reads file records (FC20). */
+  readFileRecord(opts: ReadFileRecordOptions): Promise<Array<Array<number>>>
+  /** Writes file records (FC21). */
+  writeFileRecord(opts: WriteFileRecordOptions): Promise<void>
+  /** Reads exception status (FC07). */
+  readExceptionStatus(): Promise<number>
+  /** Sends a diagnostics request (FC08). */
+  diagnostics(opts: DiagnosticsOptions): Promise<DiagnosticsResponse>
+  /** Reads device identification (FC43/MEI14). */
+  readDeviceIdentification(opts: ReadDeviceIdentificationOptions): Promise<DeviceIdentificationResponse>
+}
+
+/**
+ * Async Modbus TCP server.
+ *
+ * Binds to a TCP port and handles incoming Modbus requests using JS callbacks.
+ */
+export declare class AsyncTcpModbusServer {
+  /**
+   * Creates and starts a new TCP server.
+   *
+   * @param opts - Server bind options.
+   * @param handlers - Object containing handler functions for each Modbus operation.
+   * @returns A running server instance.
+   */
+  static bind(opts: TcpServerOptions, handlers: object): AsyncTcpModbusServer
+  /** Stops the server. */
+  shutdown(): Promise<void>
+}
+
+/** Device identification object. */
+export interface DeviceIdentificationObject {
+  /** Object ID. */
+  id: number
+  /** Object value as string. */
+  value: string
+}
+
+/** Response from device identification request. */
+export interface DeviceIdentificationResponse {
+  /** Conformity level. */
+  conformityLevel: number
+  /** Whether more objects follow. */
+  moreFollows: boolean
+  /** Next object ID if more follows. */
+  nextObjectId: number
+  /** Retrieved objects. */
+  objects: Array<DeviceIdentificationObject>
+}
+
+/** Options for diagnostics request. */
+export interface DiagnosticsOptions {
+  /** Diagnostic sub-function code. */
+  subFunction: number
+  /** Data words for the request. */
+  data: Array<number>
+}
+
+/** Handler request for diagnostics. */
+export interface DiagnosticsRequest {
+  unitId: number
+  subFunction: number
+  data: Array<number>
+}
+
+/** Response from diagnostics request. */
+export interface DiagnosticsResponse {
+  /** Echoed sub-function code. */
+  subFunction: number
+  /** Response data words. */
+  data: Array<number>
+}
+
+/** Downstream server configuration. */
+export interface DownstreamConfig {
+  /** Downstream server host. */
+  host: string
+  /** Downstream server port. */
+  port: number
+}
+
+/** Response from reading FIFO queue. */
+export interface FifoQueueResponse {
+  /** Number of values in the queue. */
+  count: number
+  /** Queue values. */
+  values: Array<number>
+}
+
+/** A single file record read sub-request. */
+export interface FileRecordReadRequest {
+  /** File number (1-65535). */
+  fileNumber: number
+  /** Starting record number. */
+  recordNumber: number
+  /** Number of records to read. */
+  recordLength: number
+}
+
+/** A single file record write sub-request. */
+export interface FileRecordWriteRequest {
+  /** File number (1-65535). */
+  fileNumber: number
+  /** Starting record number. */
+  recordNumber: number
+  /** Record data to write. */
+  recordData: Array<number>
+}
+
+/** Gateway bind options. */
+export interface GatewayBindOptions {
+  /** Bind host address (e.g., "0.0.0.0"). */
+  host: string
+  /** Bind port. */
+  port: number
+}
+
+/** Gateway configuration. */
+export interface GatewayConfig {
+  /** List of downstream servers. */
+  downstreams: Array<DownstreamConfig>
+  /** Routing table mapping unit IDs to downstream channels. */
+  routes: Array<RouteEntry>
+}
+
+/** Options for reading coils or discrete inputs. */
+export interface ReadBitsOptions {
+  /** Starting address. */
+  address: number
+  /** Number of bits to read. */
+  quantity: number
+}
+
+/** Handler request for reading coils. */
+export interface ReadCoilsRequest {
+  unitId: number
+  address: number
+  quantity: number
+}
+
+/** Options for device identification. */
+export interface ReadDeviceIdentificationOptions {
+  /** Read device ID code (1=basic, 2=regular, 3=extended, 4=individual). */
+  readDeviceIdCode: number
+  /** Starting object ID. */
+  objectId: number
+}
+
+/** Handler request for reading discrete inputs. */
+export interface ReadDiscreteInputsRequest {
+  unitId: number
+  address: number
+  quantity: number
+}
+
+/** Options for reading FIFO queue. */
+export interface ReadFifoQueueOptions {
+  /** FIFO pointer address. */
+  address: number
+}
+
+/** Handler request for reading FIFO queue. */
+export interface ReadFifoQueueRequest {
+  unitId: number
+  address: number
+}
+
+/** Options for reading file records. */
+export interface ReadFileRecordOptions {
+  /** Array of sub-requests. */
+  requests: Array<FileRecordReadRequest>
+}
+
+/** Handler request for reading holding registers. */
+export interface ReadHoldingRegistersRequest {
+  unitId: number
+  address: number
+  quantity: number
+}
+
+/** Handler request for reading input registers. */
+export interface ReadInputRegistersRequest {
+  unitId: number
+  address: number
+  quantity: number
+}
+
+/** Options for reading registers. */
+export interface ReadRegistersOptions {
+  /** Starting register address. */
+  address: number
+  /** Number of registers to read. */
+  quantity: number
+}
+
+/** Options for read/write multiple registers (FC23). */
+export interface ReadWriteMultipleRegistersOptions {
+  /** Starting address for read operation. */
+  readAddress: number
+  /** Number of registers to read. */
+  readQuantity: number
+  /** Starting address for write operation. */
+  writeAddress: number
+  /** Values to write. */
+  writeValues: Array<number>
+}
+
+/** Route entry mapping unit ID to a downstream channel. */
+export interface RouteEntry {
+  /** Modbus unit ID (1-247). */
+  unitId: number
+  /** Index into the downstreams array. */
+  channel: number
+}
+
+/** Connection options for the serial client. */
+export interface SerialClientOptions {
+  /** Serial port path (e.g., "/dev/ttyUSB0", "COM3"). */
+  portPath: string
+  /** Baud rate (e.g., 9600, 19200, 38400, 57600, 115200). */
+  baudRate: number
+  /** Data bits (5, 6, 7, or 8). */
+  dataBits?: number
+  /** Parity ("none", "even", "odd"). */
+  parity?: string
+  /** Stop bits (1 or 2). */
+  stopBits?: number
+  /** Modbus unit ID (1-247). */
+  unitId: number
+  /** Response timeout in milliseconds. */
+  responseTimeoutMs?: number
+  /** Per-request timeout in milliseconds. */
+  requestTimeoutMs?: number
+}
+
+/** Response that may include an exception code. */
+export interface ServerExceptionResponse {
+  /** Modbus exception code if this is an error response. */
+  exception?: number
+}
+
+/** Connection options for the TCP client. */
+export interface TcpClientOptions {
+  /** Target host address (IP or hostname). */
+  host: string
+  /** Target TCP port (typically 502). */
+  port: number
+  /** Modbus unit ID (1-247). */
+  unitId: number
+  /** Per-request timeout in milliseconds (optional). */
+  timeoutMs?: number
+}
+
+/** Server bind options. */
+export interface TcpServerOptions {
+  /** Bind host address (e.g., "0.0.0.0"). */
+  host: string
+  /** Bind port. */
+  port: number
+  /** Modbus unit ID to respond to. */
+  unitId: number
+}
+
+/** Options for writing file records. */
+export interface WriteFileRecordOptions {
+  /** Array of sub-requests. */
+  requests: Array<FileRecordWriteRequest>
+}
+
+/** Options for writing multiple coils. */
+export interface WriteMultipleCoilsOptions {
+  /** Starting coil address. */
+  address: number
+  /** Values to write. */
+  values: Array<boolean>
+}
+
+/** Handler request for writing multiple coils. */
+export interface WriteMultipleCoilsRequest {
+  unitId: number
+  address: number
+  values: Array<boolean>
+}
+
+/** Options for writing multiple registers. */
+export interface WriteMultipleRegistersOptions {
+  /** Starting register address. */
+  address: number
+  /** Values to write. */
+  values: Array<number>
+}
+
+/** Handler request for writing multiple registers. */
+export interface WriteMultipleRegistersRequest {
+  unitId: number
+  address: number
+  values: Array<number>
+}
+
+/** Options for writing a single coil. */
+export interface WriteSingleCoilOptions {
+  /** Coil address. */
+  address: number
+  /** Value to write. */
+  value: boolean
+}
+
+/** Handler request for writing a single coil. */
+export interface WriteSingleCoilRequest {
+  unitId: number
+  address: number
+  value: boolean
+}
+
+/** Options for writing a single register. */
+export interface WriteSingleRegisterOptions {
+  /** Register address. */
+  address: number
+  /** Value to write. */
+  value: number
+}
+
+/** Handler request for writing a single register. */
+export interface WriteSingleRegisterRequest {
+  unitId: number
+  address: number
+  value: number
+}

package/index.js

@@ -0,0 +1,582 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require('node:fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./modbus-rs.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-android-arm64')
+        const bindingPackageVersion = require('modbus-rs-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./modbus-rs.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-android-arm-eabi')
+        const bindingPackageVersion = require('modbus-rs-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      if (process.config?.variables?.shlib_suffix === 'dll.a' || process.config?.variables?.node_target_type === 'shared_library') {
+        try {
+        return require('./modbus-rs.win32-x64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-win32-x64-gnu')
+        const bindingPackageVersion = require('modbus-rs-win32-x64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      } else {
+        try {
+        return require('./modbus-rs.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-win32-x64-msvc')
+        const bindingPackageVersion = require('modbus-rs-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./modbus-rs.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-win32-ia32-msvc')
+        const bindingPackageVersion = require('modbus-rs-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./modbus-rs.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-win32-arm64-msvc')
+        const bindingPackageVersion = require('modbus-rs-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./modbus-rs.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('modbus-rs-darwin-universal')
+      const bindingPackageVersion = require('modbus-rs-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./modbus-rs.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-darwin-x64')
+        const bindingPackageVersion = require('modbus-rs-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./modbus-rs.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-darwin-arm64')
+        const bindingPackageVersion = require('modbus-rs-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./modbus-rs.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-freebsd-x64')
+        const bindingPackageVersion = require('modbus-rs-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./modbus-rs.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-freebsd-arm64')
+        const bindingPackageVersion = require('modbus-rs-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./modbus-rs.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('modbus-rs-linux-x64-musl')
+          const bindingPackageVersion = require('modbus-rs-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./modbus-rs.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('modbus-rs-linux-x64-gnu')
+          const bindingPackageVersion = require('modbus-rs-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./modbus-rs.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('modbus-rs-linux-arm64-musl')
+          const bindingPackageVersion = require('modbus-rs-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./modbus-rs.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('modbus-rs-linux-arm64-gnu')
+          const bindingPackageVersion = require('modbus-rs-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./modbus-rs.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('modbus-rs-linux-arm-musleabihf')
+          const bindingPackageVersion = require('modbus-rs-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./modbus-rs.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('modbus-rs-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('modbus-rs-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'loong64') {
+      if (isMusl()) {
+        try {
+          return require('./modbus-rs.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('modbus-rs-linux-loong64-musl')
+          const bindingPackageVersion = require('modbus-rs-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./modbus-rs.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('modbus-rs-linux-loong64-gnu')
+          const bindingPackageVersion = require('modbus-rs-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./modbus-rs.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('modbus-rs-linux-riscv64-musl')
+          const bindingPackageVersion = require('modbus-rs-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./modbus-rs.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('modbus-rs-linux-riscv64-gnu')
+          const bindingPackageVersion = require('modbus-rs-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./modbus-rs.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-linux-ppc64-gnu')
+        const bindingPackageVersion = require('modbus-rs-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./modbus-rs.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-linux-s390x-gnu')
+        const bindingPackageVersion = require('modbus-rs-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./modbus-rs.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-openharmony-arm64')
+        const bindingPackageVersion = require('modbus-rs-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./modbus-rs.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-openharmony-x64')
+        const bindingPackageVersion = require('modbus-rs-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./modbus-rs.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('modbus-rs-openharmony-arm')
+        const bindingPackageVersion = require('modbus-rs-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.9.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.9.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  let wasiBinding = null
+  let wasiBindingError = null
+  try {
+    wasiBinding = require('./modbus-rs.wasi.cjs')
+    nativeBinding = wasiBinding
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      wasiBindingError = err
+    }
+  }
+  if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+    try {
+      wasiBinding = require('modbus-rs-wasm32-wasi')
+      nativeBinding = wasiBinding
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        if (!wasiBindingError) {
+          wasiBindingError = err
+        } else {
+          wasiBindingError.cause = err
+        }
+        loadErrors.push(err)
+      }
+    }
+  }
+  if (process.env.NAPI_RS_FORCE_WASI === 'error' && !wasiBinding) {
+    const error = new Error('WASI binding not found and NAPI_RS_FORCE_WASI is set to error')
+    error.cause = wasiBindingError
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    throw new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+      {
+        cause: loadErrors.reduce((err, cur) => {
+          cur.cause = err
+          return cur
+        }),
+      },
+    )
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports = nativeBinding
+module.exports.AsyncSerialModbusClient = nativeBinding.AsyncSerialModbusClient
+module.exports.AsyncTcpGateway = nativeBinding.AsyncTcpGateway
+module.exports.AsyncTcpModbusClient = nativeBinding.AsyncTcpModbusClient
+module.exports.AsyncTcpModbusServer = nativeBinding.AsyncTcpModbusServer

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "modbus-rs",
+  "version": "0.9.0",
+  "description": "High-performance Modbus TCP/RTU/ASCII client, server and gateway for Node.js, powered by Rust",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "napi build --platform --release --features nodejs,full --js index.js --dts index.d.ts --output-dir . --manifest-path ../Cargo.toml",
+    "build:debug": "napi build --platform --features nodejs,full --js index.js --dts index.d.ts --output-dir . --manifest-path ../Cargo.toml",
+    "test": "node --test __test__/",
+    "prepublishOnly": "napi prepublish -t npm",
+    "artifacts": "napi artifacts",
+    "universal": "napi universal",
+    "version": "napi version"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Raghava-Ch/modbus-rs.git"
+  },
+  "keywords": [
+    "modbus",
+    "modbus-tcp",
+    "modbus-rtu",
+    "modbus-ascii",
+    "scada",
+    "plc",
+    "industrial",
+    "automation",
+    "napi-rs",
+    "rust"
+  ],
+  "author": "Raghava-Ch",
+  "license": "GPL-3.0-only",
+  "bugs": {
+    "url": "https://github.com/Raghava-Ch/modbus-rs/issues"
+  },
+  "homepage": "https://github.com/Raghava-Ch/modbus-rs#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "napi": {
+    "binaryName": "modbus-rs",
+    "targets": [
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-linux-gnu",
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "aarch64-unknown-linux-gnu"
+    ]
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^3.6.2",
+    "@types/node": "^25.6.0",
+    "typescript": "^6.0.3"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {},
+  "optionalDependencies": {
+    "modbus-rs-win32-x64-msvc": "0.9.0",
+    "modbus-rs-linux-x64-gnu": "0.9.0",
+    "modbus-rs-darwin-x64": "0.9.0",
+    "modbus-rs-darwin-arm64": "0.9.0",
+    "modbus-rs-linux-arm64-gnu": "0.9.0"
+  }
+}