mq-bridge 0.2.0 → 0.3.1

package/README.md

@@ -22,9 +22,9 @@ npm run example
 ## Handler shape
 
 ```ts
-import { Message, Route } from "@mq-bridge/node";
+import { Message, Route } from "mq-bridge";
 
-const route = Route.fromYamlStr(config, "orders");
+const route = Route.fromStr(config, "orders");
 
 route.withHandler(async (message) => {
   const data = message.json();
@@ -39,3 +39,83 @@ route.start();
 ```
 
 Middleware is configured through the normal mq-bridge route config.
+
+## Loading config
+
+The constructors mirror the Python bindings — the same capabilities are exposed
+in both, with Node using camelCase names where Python uses snake_case:
+
+- `Route.fromFile(path, name?)` loads from a YAML/JSON file
+- `Route.fromStr(text, name?)` loads from an in-memory YAML/JSON string
+- `Route.fromConfig(obj, name?)` loads from a JS object
+- `Publisher.fromFile` / `Publisher.fromStr` / `Publisher.fromConfig` build a publisher endpoint
+
+The `name` is optional: pass it to pick one entry out of a `routes:`/`publishers:`
+document, or omit it to treat the whole config as a single bare route/endpoint body.
+`fromYaml` / `fromYamlStr` remain as deprecated aliases for `fromFile` / `fromStr`.
+
+## Pull-based consumer
+
+`Route` is push-based. To pull messages on your own schedule, use `Consumer`,
+which wraps any input endpoint:
+
+```js
+import { Consumer } from "mq-bridge";
+
+const consumer = Consumer.fromConfig({ nats: { subject: "orders", url: "nats://localhost:4222" } });
+
+while (!consumer.exhausted) {
+  const batch = await consumer.poll(500, 1000); // [] on timeout
+  if (batch.length === 0) continue;
+  for (const message of batch) handle(message.json());
+  await consumer.commit(); // ack only after handling
+}
+```
+
+`poll(max?, timeoutMs?)` returns up to `max` messages (default 256) without
+acking, waiting up to `timeoutMs` milliseconds (omit it to block until a message
+arrives); `commit()` acks every batch returned since the last commit. Committing
+only after the downstream write succeeds gives at-least-once delivery. `exhausted`
+turns `true` once a bounded source (e.g. a file) is drained; streaming brokers
+never set it. `Consumer.fromFile` / `fromStr` accept a named entry under a
+`consumers:` section or a single bare endpoint body.
+
+`consumer.status()` resolves to a snapshot (`healthy`, `target`, `pending`,
+`capacity`, `error`, `details`). `pending` is the broker backlog/lag where the
+transport reports it (Kafka offset lag, AMQP queue depth, NATS JetStream
+`numPending`), so `pending === 0` is a precise "caught up" check; it's absent
+where the broker exposes no backlog (core NATS, MQTT). `consumer.close()`
+releases the connection — idempotent, and `poll()`/`status()` reject afterwards.
+Node is garbage-collected, so close explicitly rather than waiting for GC.
+
+> **You must call `commit()` — it is not optional.** It is the only thing that
+> tells the broker a batch is done. If you keep polling without committing, the
+> offset never advances (every message is **re-delivered** on the next run), most
+> brokers **stall** once their unacknowledged/prefetch window fills, and the
+> uncommitted batches are held in memory so the process **grows unbounded**.
+> Commit after each batch you have durably handled; to retry a failed batch,
+> simply don't commit it.
+
+## Analysis
+
+HTTP comparison benchmark, driven by a native load generator (`wrk`) so the
+client is never the bottleneck. It boots each server in its own process — the
+mq-bridge Node route plus raw Node `http`, uWebSockets.js, Fastify, and Express
+(all peers run only when installed) — and drives each with `wrk`:
+
+```bash
+cd node/mq-bridge-node
+npm run build                 # release addon (the bench is meaningless on a debug build)
+npm i -D fastify express      # optional Node HTTP peers
+npm i -D uNetworking/uWebSockets.js#v20.51.0   # the http-arena Node leader (native, from GitHub)
+npm run bench:http -- --connections 1,8,32 --duration 8
+```
+
+Requires `wrk` on `PATH` (`brew install wrk`). The `mqb` target needs the addon
+built with the `http` feature (`npm run build` or `npm run build:ci`). Each
+server echoes a tiny JSON body with `value` incremented; mq-bridge routes on the
+`kind` header while the framework peers post plain JSON.
+
+`uws` (uWebSockets.js) is the framework that tops public Node benchmarks like
+http-arena and TechEmpower — it bypasses Node's `http` stack with a C++ socket
+layer, so it is the most demanding yardstick here.

package/index.d.ts

@@ -22,19 +22,72 @@ export class Message {
 }
 
 export class Publisher {
-  static fromYaml(path: string, name: string): Publisher;
-  static fromYamlStr(text: string, name: string): Publisher;
-  static fromConfig(config: JsonValue, name: string): Publisher;
-  send(message: Message): void;
-  request(message: Message): Message;
-  sendJson(data: JsonValue, metadata?: Metadata | null, id?: string | null): void;
-  requestJson(data: JsonValue, metadata?: Metadata | null, id?: string | null): Message;
+  static fromFile(path: string, name?: string | null): Publisher;
+  static fromStr(text: string, name?: string | null): Publisher;
+  static fromConfig(config: JsonValue, name?: string | null): Publisher;
+  /** @deprecated Use {@link Publisher.fromFile} instead. */
+  static fromYaml(path: string, name?: string | null): Publisher;
+  /** @deprecated Use {@link Publisher.fromStr} instead. */
+  static fromYamlStr(text: string, name?: string | null): Publisher;
+  send(message: Message): Promise<void>;
+  request(message: Message): Promise<Message>;
+  sendJson(data: JsonValue, metadata?: Metadata | null, id?: string | null): Promise<void>;
+  requestJson(data: JsonValue, metadata?: Metadata | null, id?: string | null): Promise<Message>;
+}
+
+export interface ConsumerStatus {
+  healthy: boolean;
+  target: string;
+  /** Broker backlog/lag where the transport reports it; absent otherwise. */
+  pending?: number;
+  capacity?: number;
+  error?: string;
+  details: JsonValue;
+}
+
+export class Consumer {
+  static fromFile(path: string, name?: string | null): Consumer;
+  static fromStr(text: string, name?: string | null): Consumer;
+  static fromConfig(config: JsonValue, name?: string | null): Consumer;
+  /**
+   * Receive up to `max` messages (default 256) without acking. Resolves to an
+   * empty array if `timeoutMs` milliseconds elapse with nothing received, or the
+   * source is exhausted. Omit `timeoutMs` to block until a message arrives. The
+   * returned messages are acked by the next `commit()` call — which you must
+   * call (see {@link Consumer.commit}).
+   */
+  poll(max?: number | null, timeoutMs?: number | null): Promise<Message[]>;
+  /**
+   * Acknowledge every batch returned by `poll()` since the last `commit()`,
+   * advancing the consumer offset.
+   *
+   * Calling this is required, not optional. Without it the offset never advances
+   * (messages are re-delivered on the next run), most brokers stall once their
+   * unacknowledged/prefetch window fills, and uncommitted batches are held in
+   * memory so the process grows unbounded. To retry a failed batch, simply
+   * don't commit it — it will be redelivered.
+   */
+  commit(): Promise<void>;
+  /**
+   * Status snapshot for the underlying endpoint. `pending === 0` is a precise
+   * "caught up" signal on transports that report backlog (Kafka, AMQP, NATS
+   * JetStream); `pending` is absent where the broker exposes none.
+   */
+  status(): Promise<ConsumerStatus>;
+  /** Release the broker connection. Idempotent; `poll()`/`status()` reject after. */
+  close(): Promise<void>;
+  /** `true` once the source has signalled end-of-stream (e.g. a drained file). */
+  get exhausted(): boolean;
 }
 
 export class Route {
-  static fromYaml(path: string, name: string): Route;
-  static fromYamlStr(text: string, name: string): Route;
-  static fromConfig(config: JsonValue, name: string): Route;
+  static fromFile(path: string, name?: string | null): Route;
+  static fromStr(text: string, name?: string | null): Route;
+  static fromConfig(config: JsonValue, name?: string | null): Route;
+  /** @deprecated Use {@link Route.fromFile} instead. */
+  static fromYaml(path: string, name?: string | null): Route;
+  /** @deprecated Use {@link Route.fromStr} instead. */
+  static fromYamlStr(text: string, name?: string | null): Route;
   withHandler(handler: MessageHandler): void;
   addHandler(kind: string, handler: JsonHandler): void;
   start(): void;
@@ -42,4 +95,10 @@ export class Route {
   join(): void;
 }
 
+/**
+ * JSON Schema for the route/config mapping, generated from the compiled Rust
+ * models. Throws if the addon was built without the `schema` feature.
+ */
+export function configSchema(): JsonValue;
+
 export const version: string;

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const native = require("./mq_bridge_node.node");
+const native = require("./native.js");
 
 class Message {
   constructor(payload, metadata = null, id = null) {
@@ -57,32 +57,81 @@ class Publisher {
     this._native = nativePublisher;
   }
 
-  static fromYaml(path, name) {
-    return new Publisher(native.Publisher.fromYaml(path, name));
+  static fromFile(path, name) {
+    return new Publisher(native.Publisher.fromFile(path, name));
   }
 
-  static fromYamlStr(text, name) {
-    return new Publisher(native.Publisher.fromYamlStr(text, name));
+  static fromStr(text, name) {
+    return new Publisher(native.Publisher.fromStr(text, name));
   }
 
   static fromConfig(config, name) {
     return new Publisher(native.Publisher.fromConfig(config, name));
   }
 
+  /** @deprecated Use {@link Publisher.fromFile} instead. */
+  static fromYaml(path, name) {
+    return new Publisher(native.Publisher.fromFile(path, name));
+  }
+
+  /** @deprecated Use {@link Publisher.fromStr} instead. */
+  static fromYamlStr(text, name) {
+    return new Publisher(native.Publisher.fromStr(text, name));
+  }
+
   send(message) {
-    this._native.send(Message._toNative(message));
+    return this._native.send(Message._toNative(message));
   }
 
-  request(message) {
-    return Message._fromNative(this._native.request(Message._toNative(message)));
+  async request(message) {
+    return Message._fromNative(await this._native.request(Message._toNative(message)));
   }
 
   sendJson(data, metadata = null, id = null) {
-    this._native.sendJson(data, metadata, id);
+    return this._native.sendJson(data, metadata, id);
   }
 
-  requestJson(data, metadata = null, id = null) {
-    return Message._fromNative(this._native.requestJson(data, metadata, id));
+  async requestJson(data, metadata = null, id = null) {
+    return Message._fromNative(await this._native.requestJson(data, metadata, id));
+  }
+}
+
+class Consumer {
+  constructor(nativeConsumer) {
+    this._native = nativeConsumer;
+  }
+
+  static fromFile(path, name) {
+    return new Consumer(native.Consumer.fromFile(path, name));
+  }
+
+  static fromStr(text, name) {
+    return new Consumer(native.Consumer.fromStr(text, name));
+  }
+
+  static fromConfig(config, name) {
+    return new Consumer(native.Consumer.fromConfig(config, name));
+  }
+
+  async poll(max, timeoutMs) {
+    const messages = await this._native.poll(max, timeoutMs);
+    return messages.map((message) => Message._fromNative(message));
+  }
+
+  commit() {
+    return this._native.commit();
+  }
+
+  status() {
+    return this._native.status();
+  }
+
+  close() {
+    return this._native.close();
+  }
+
+  get exhausted() {
+    return this._native.exhausted;
   }
 }
 
@@ -91,18 +140,28 @@ class Route {
     this._native = nativeRoute;
   }
 
-  static fromYaml(path, name) {
-    return new Route(native.Route.fromYaml(path, name));
+  static fromFile(path, name) {
+    return new Route(native.Route.fromFile(path, name));
   }
 
-  static fromYamlStr(text, name) {
-    return new Route(native.Route.fromYamlStr(text, name));
+  static fromStr(text, name) {
+    return new Route(native.Route.fromStr(text, name));
   }
 
   static fromConfig(config, name) {
     return new Route(native.Route.fromConfig(config, name));
   }
 
+  /** @deprecated Use {@link Route.fromFile} instead. */
+  static fromYaml(path, name) {
+    return new Route(native.Route.fromFile(path, name));
+  }
+
+  /** @deprecated Use {@link Route.fromStr} instead. */
+  static fromYamlStr(text, name) {
+    return new Route(native.Route.fromStr(text, name));
+  }
+
   withHandler(handler) {
     this._native.withHandler(async (error, message) => {
       if (error) {
@@ -136,9 +195,20 @@ class Route {
   }
 }
 
+function configSchema() {
+  if (typeof native.configSchema !== "function") {
+    throw new Error(
+      "configSchema() is unavailable: this build was compiled without the 'schema' feature",
+    );
+  }
+  return native.configSchema();
+}
+
 module.exports = {
   Message,
   Publisher,
+  Consumer,
   Route,
-  version: native.version,
+  configSchema,
+  version: native.VERSION,
 };

package/native.d.ts

@@ -0,0 +1,157 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+/**
+ * A pull-based consumer over any mq-bridge input endpoint.
+ *
+ * `poll()` receives a batch of messages but does **not** acknowledge them;
+ * call `commit()` once they have been durably handled to ack every batch
+ * returned since the previous commit (advancing offsets / removing them from
+ * the source). This manual-commit model gives at-least-once delivery across a
+ * failed downstream load. The endpoint config decides durability (consumer vs
+ * subscriber mode), exactly as it does for a route input.
+ *
+ * Relationship to the Rust core: this is a boundary-friendly projection of the
+ * core `MessageConsumer::receive_batch`, which is the low-level primitive. Two
+ * differences are deliberate, both because a Rust commit closure cannot be
+ * handed across the FFI boundary for JS to call later:
+ *   - `receive_batch` returns the messages *and* their commit closure together;
+ *     `poll()` returns only the messages and keeps the closure on the Rust side,
+ *     so committing becomes the separate `commit()` call.
+ *   - that closure accepts a per-message disposition vector (ack/nack/reject);
+ *     `poll()` + `commit()` only ack the whole batch.
+ * `poll()` additionally layers a `timeoutMs` over `receive_batch` (which has no
+ * timeout of its own). Native Rust code should use `receive_batch` directly — it
+ * is strictly more expressive and needs no deferred-commit state.
+ */
+export declare class Consumer {
+  /**
+   * Build a consumer from a YAML or JSON config file. Accepts a `consumers:`
+   * document entry (with `name`) or a single bare endpoint body.
+   */
+  static fromFile(path: string, name?: string | undefined | null): Consumer
+  /** Build a consumer from an in-memory YAML or JSON string. */
+  static fromStr(text: string, name?: string | undefined | null): Consumer
+  /**
+   * Build a consumer from an in-memory mapping (e.g. a JS object). Omit `name`
+   * to treat the mapping as a single bare endpoint body.
+   */
+  static fromConfig(config: JsonValue, name?: string | undefined | null): Consumer
+  /**
+   * Receive up to `max` messages without acking. Resolves to an empty array
+   * if `timeoutMs` milliseconds elapse with nothing received, or the source is
+   * exhausted (see `exhausted`). Omit `timeoutMs` to block until a message
+   * arrives. Acked by the next `commit()`.
+   */
+  poll(max?: number | undefined | null, timeoutMs?: number | undefined | null): Promise<Array<NativeMessage>>
+  /**
+   * Acknowledge every batch returned by `poll()` since the last `commit()`,
+   * advancing the consumer offset.
+   *
+   * Calling this is required, not optional. Without it the offset never
+   * advances (messages are re-delivered on the next run), most brokers stall
+   * once their unacknowledged/prefetch window fills, and uncommitted batches
+   * are held in memory so the process grows unbounded. To retry a failed
+   * batch, simply don't commit it — it will be redelivered.
+   */
+  commit(): Promise<void>
+  /**
+   * `true` once the source has signalled end-of-stream (e.g. a fully drained
+   * file). Streaming brokers never set this.
+   */
+  get exhausted(): boolean
+  /**
+   * Resolve to a status snapshot for the underlying endpoint: `healthy`,
+   * `target`, optional `pending` (broker backlog/lag where the transport
+   * reports it — Kafka offset lag, AMQP queue depth, NATS JetStream
+   * `numPending`), optional `capacity`/`error`, and `details`. `pending === 0`
+   * is a precise "caught up" signal on those transports; it is absent where
+   * the broker exposes no backlog (core NATS, MQTT). Point-in-time snapshot.
+   */
+  status(): Promise<JsonValue>
+  /**
+   * Release the underlying consumer connection. Idempotent. After this,
+   * `poll()` and `status()` reject. GC'd JS has no deterministic drop, so
+   * closing explicitly is how the broker connection is freed promptly.
+   */
+  close(): Promise<void>
+}
+
+export declare class Publisher {
+  /**
+   * Build a publisher endpoint from a YAML or JSON config file. Omit `name`
+   * (or pass `""`) when the file is a single bare endpoint body.
+   */
+  static fromFile(path: string, name?: string | undefined | null): Publisher
+  /** Deprecated alias for `from_file`. */
+  static fromYaml(path: string, name?: string | undefined | null): Publisher
+  /**
+   * Build a publisher endpoint from an in-memory YAML or JSON string. Omit
+   * `name` (or pass `""`) when the string is a single bare endpoint body.
+   */
+  static fromStr(text: string, name?: string | undefined | null): Publisher
+  /** Deprecated alias for `from_str`. */
+  static fromYamlStr(text: string, name?: string | undefined | null): Publisher
+  /**
+   * Build a publisher endpoint from an in-memory mapping (e.g. a JS object).
+   * Omit `name` (or pass `""`) to treat the mapping as a single bare endpoint
+   * body.
+   */
+  static fromConfig(config: JsonValue, name?: string | undefined | null): Publisher
+  send(message: NativeMessage): Promise<void>
+  request(message: NativeMessage): Promise<NativeMessage>
+  sendJson(data: JsonValue, metadata?: Record<string, string> | undefined | null, id?: string | undefined | null): Promise<void>
+  requestJson(data: JsonValue, metadata?: Record<string, string> | undefined | null, id?: string | undefined | null): Promise<NativeMessage>
+}
+
+export declare class Route {
+  /**
+   * Build a route from a YAML or JSON config file. Accepts a `routes:`
+   * document, a bare `{name: route}` map, or a single route body. Omit
+   * `name` (or pass `""`) when the file is a single bare route body.
+   */
+  static fromFile(path: string, name?: string | undefined | null): Route
+  /** Deprecated alias for `from_file`. */
+  static fromYaml(path: string, name?: string | undefined | null): Route
+  /**
+   * Build a route from an in-memory YAML or JSON string. Accepts the same
+   * shapes as `from_file`. Omit `name` (or pass `""`) when the string is a
+   * single bare route body.
+   */
+  static fromStr(text: string, name?: string | undefined | null): Route
+  /** Deprecated alias for `from_str`. */
+  static fromYamlStr(text: string, name?: string | undefined | null): Route
+  /**
+   * Build a route from an in-memory mapping (e.g. a JS object). Accepts a
+   * `routes:` document, a bare `{name: route}` map, or a single route body.
+   * Omit `name` (or pass `""`) to treat the mapping as a single bare route
+   * body, in which case a name is generated automatically.
+   */
+  static fromConfig(config: JsonValue, name?: string | undefined | null): Route
+  withHandler(callback: ((err: Error | null, arg: NativeMessage) => Promise<NativeMessage | undefined | null>)): void
+  addHandler(kind: string, callback: ((err: Error | null, arg: JsonValue) => Promise<NativeMessage | undefined | null>)): void
+  start(): void
+  stop(): void
+  join(): void
+}
+
+/**
+ * JSON Schema for the route/config mapping, generated on demand from the
+ * compiled Rust models (no checked-in copy, so it cannot drift).
+ */
+export declare function configSchema(): JsonValue
+
+export declare function createMessage(payload: Buffer, metadata?: Record<string, string> | undefined | null, id?: string | undefined | null): NativeMessage
+
+export declare function messageFromJson(data: JsonValue, metadata?: Record<string, string> | undefined | null, id?: string | undefined | null): NativeMessage
+
+export declare function messageJson(message: NativeMessage): JsonValue
+
+export declare function messageText(message: NativeMessage): string
+
+export interface NativeMessage {
+  payload: Buffer
+  metadata?: Record<string, string>
+  id?: string
+}
+
+export const version: string

package/native.js

@@ -0,0 +1,599 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require('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 (process.report && 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('./mq_bridge_node.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-android-arm64')
+        const bindingPackageVersion = require('mq-bridge-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-android-arm-eabi')
+        const bindingPackageVersion = require('mq-bridge-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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 && process.config.variables && process.config.variables.shlib_suffix === 'dll.a') || (process.config && process.config.variables && process.config.variables.node_target_type === 'shared_library')) {
+        try {
+        return require('./mq_bridge_node.win32-x64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-win32-x64-gnu')
+        const bindingPackageVersion = require('mq-bridge-win32-x64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      } else {
+        try {
+        return require('./mq_bridge_node.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-win32-x64-msvc')
+        const bindingPackageVersion = require('mq-bridge-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-win32-ia32-msvc')
+        const bindingPackageVersion = require('mq-bridge-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-win32-arm64-msvc')
+        const bindingPackageVersion = require('mq-bridge-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('mq-bridge-darwin-universal')
+      const bindingPackageVersion = require('mq-bridge-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-darwin-x64')
+        const bindingPackageVersion = require('mq-bridge-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-darwin-arm64')
+        const bindingPackageVersion = require('mq-bridge-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-freebsd-x64')
+        const bindingPackageVersion = require('mq-bridge-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-freebsd-arm64')
+        const bindingPackageVersion = require('mq-bridge-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('mq-bridge-linux-x64-musl')
+          const bindingPackageVersion = require('mq-bridge-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.3.1' && 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.3.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./mq_bridge_node.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('mq-bridge-linux-x64-gnu')
+          const bindingPackageVersion = require('mq-bridge-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('mq-bridge-linux-arm64-musl')
+          const bindingPackageVersion = require('mq-bridge-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.3.1' && 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.3.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./mq_bridge_node.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('mq-bridge-linux-arm64-gnu')
+          const bindingPackageVersion = require('mq-bridge-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('mq-bridge-linux-arm-musleabihf')
+          const bindingPackageVersion = require('mq-bridge-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.3.1' && 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.3.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./mq_bridge_node.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('mq-bridge-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('mq-bridge-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('mq-bridge-linux-loong64-musl')
+          const bindingPackageVersion = require('mq-bridge-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.3.1' && 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.3.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./mq_bridge_node.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('mq-bridge-linux-loong64-gnu')
+          const bindingPackageVersion = require('mq-bridge-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('mq-bridge-linux-riscv64-musl')
+          const bindingPackageVersion = require('mq-bridge-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.3.1' && 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.3.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./mq_bridge_node.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('mq-bridge-linux-riscv64-gnu')
+          const bindingPackageVersion = require('mq-bridge-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-linux-ppc64-gnu')
+        const bindingPackageVersion = require('mq-bridge-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-linux-s390x-gnu')
+        const bindingPackageVersion = require('mq-bridge-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-openharmony-arm64')
+        const bindingPackageVersion = require('mq-bridge-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-openharmony-x64')
+        const bindingPackageVersion = require('mq-bridge-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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('./mq_bridge_node.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('mq-bridge-openharmony-arm')
+        const bindingPackageVersion = require('mq-bridge-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.3.1' && 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.3.1 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()
+
+// NAPI_RS_FORCE_WASI is a tri-state flag:
+//   unset / any other value → native binding preferred, WASI is only a fallback
+//   'true'                   → force WASI fallback even if native loaded
+//   'error'                  → force WASI and throw if no WASI binding is found
+// Treating any non-empty string as truthy (the historical behavior) meant
+// NAPI_RS_FORCE_WASI=false, NAPI_RS_FORCE_WASI=0, etc. inadvertently triggered
+// the WASI path, causing ENOENT for packages shipped without a .wasi.cjs file.
+const forceWasi =
+  process.env.NAPI_RS_FORCE_WASI === 'true' || process.env.NAPI_RS_FORCE_WASI === 'error'
+
+if (!nativeBinding || forceWasi) {
+  let wasiBinding = null
+  let wasiBindingError = null
+  try {
+    wasiBinding = require('./mq_bridge_node.wasi.cjs')
+    nativeBinding = wasiBinding
+  } catch (err) {
+    if (forceWasi) {
+      wasiBindingError = err
+    }
+  }
+  if (!nativeBinding || forceWasi) {
+    try {
+      wasiBinding = require('mq-bridge-wasm32-wasi')
+      nativeBinding = wasiBinding
+    } catch (err) {
+      if (forceWasi) {
+        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) {
+    const error = 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.',
+    )
+    // assign instead of the `new Error(message, { cause })` options form,
+    // which Node < 16.9 silently ignores
+    error.cause = loadErrors.reduce((err, cur) => {
+      cur.cause = err
+      return cur
+    })
+    throw error
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports = nativeBinding
+module.exports.Consumer = nativeBinding.Consumer
+module.exports.Publisher = nativeBinding.Publisher
+module.exports.Route = nativeBinding.Route
+module.exports.configSchema = nativeBinding.configSchema
+module.exports.createMessage = nativeBinding.createMessage
+module.exports.messageFromJson = nativeBinding.messageFromJson
+module.exports.messageJson = nativeBinding.messageJson
+module.exports.messageText = nativeBinding.messageText
+module.exports.version = nativeBinding.version
+module.exports.VERSION = nativeBinding.VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mq-bridge",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Node.js bindings for mq-bridge",
   "license": "MIT",
   "repository": {
@@ -13,20 +13,38 @@
   "files": [
     "index.js",
     "index.d.ts",
-    "*.node"
+    "native.js",
+    "native.d.ts"
   ],
   "napi": {
-    "binaryName": "mq_bridge_node"
+    "binaryName": "mq_bridge_node",
+    "targets": [
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-pc-windows-msvc"
+    ]
   },
   "scripts": {
-    "build": "napi build --release",
-    "build:basic": "napi build --release --no-default-features --features \"basic middleware\" --dts native.d.ts",
-    "build:ci": "napi build --no-default-features --features \"http middleware\" --dts native.d.ts",
-    "build:debug": "napi build",
+    "build": "napi build --platform --release --strip --js native.js --dts native.d.ts",
+    "build:basic": "napi build --platform --release --strip --no-default-features --features \"basic middleware\" --js native.js --dts native.d.ts",
+    "build:ci": "napi build --platform --no-default-features --features \"http middleware schema\" --js native.js --dts native.d.ts",
+    "build:debug": "napi build --platform --js native.js --dts native.d.ts",
     "example": "node examples/http-handler.js",
+    "bench:http": "node analysis/bench_http_native.js",
     "test": "node --test test/*.test.js",
+    "sync-version": "node scripts/sync-version.mjs",
+    "create-npm-dirs": "napi create-npm-dirs",
     "artifacts": "napi artifacts"
   },
+  "optionalDependencies": {
+    "mq-bridge-darwin-x64": "0.3.1",
+    "mq-bridge-darwin-arm64": "0.3.1",
+    "mq-bridge-linux-x64-gnu": "0.3.1",
+    "mq-bridge-linux-arm64-gnu": "0.3.1",
+    "mq-bridge-win32-x64-msvc": "0.3.1"
+  },
   "devDependencies": {
     "@napi-rs/cli": "^3.0.0"
   },