@homaiohq/napi-quickfix 0.0.0-stage → 0.1.0

package/cpp/message_wrap.cpp

@@ -0,0 +1,195 @@
+#include "message_wrap.h"
+
+#include <algorithm>
+#include <string>
+
+#include "errors.h"
+#include "quickfix/FieldNumbers.h"
+
+namespace napi_quickfix {
+
+Napi::FunctionReference MessageWrap::constructor_;
+
+namespace {
+
+// Coerce a JS arg to a FIX field value string. Accepts string or number
+// (numbers are stringified without trailing ".0"). Throws TypeError otherwise.
+std::string CoerceValue(Napi::Env env, Napi::Value v) {
+  if (v.IsString()) {
+    return v.As<Napi::String>().Utf8Value();
+  }
+  if (v.IsNumber()) {
+    double d = v.As<Napi::Number>().DoubleValue();
+    // Integers -> plain integer string; otherwise a plain double string.
+    if (d == static_cast<double>(static_cast<long long>(d))) {
+      return std::to_string(static_cast<long long>(d));
+    }
+    return std::to_string(d);
+  }
+  throw Napi::TypeError::New(env, "field value must be a string or number");
+}
+
+int CoerceTag(Napi::Env env, Napi::Value v) {
+  if (!v.IsNumber()) {
+    throw Napi::TypeError::New(env, "field tag must be a number");
+  }
+  return v.As<Napi::Number>().Int32Value();
+}
+
+}  // namespace
+
+Napi::Object MessageWrap::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "Message",
+      {
+          InstanceMethod("getField", &MessageWrap::GetField),
+          InstanceMethod("setField", &MessageWrap::SetField),
+          InstanceMethod("getHeaderField", &MessageWrap::GetHeaderField),
+          InstanceMethod("setHeaderField", &MessageWrap::SetHeaderField),
+          InstanceMethod("getTrailerField", &MessageWrap::GetTrailerField),
+          InstanceMethod("setTrailerField", &MessageWrap::SetTrailerField),
+          InstanceMethod("toString", &MessageWrap::ToString),
+          InstanceMethod("toPretty", &MessageWrap::ToPretty),
+          InstanceMethod("getMsgType", &MessageWrap::GetMsgType),
+      });
+
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
+
+  exports.Set("MessageWrap", func);
+  return exports;
+}
+
+Napi::Object MessageWrap::NewInstance(Napi::Env env, const FIX::Message& msg) {
+  // Construct an empty MessageWrap then overwrite its FIX::Message with a copy.
+  Napi::Object obj = constructor_.New({});
+  MessageWrap* wrap = Napi::ObjectWrap<MessageWrap>::Unwrap(obj);
+  wrap->message_ = msg;
+  return obj;
+}
+
+MessageWrap* MessageWrap::UnwrapArg(Napi::Env env, Napi::Value value,
+                                 const char* argName) {
+  if (!value.IsObject() ||
+      !value.As<Napi::Object>().InstanceOf(constructor_.Value())) {
+    throw Napi::TypeError::New(
+        env, std::string(argName) + " must be a Message instance");
+  }
+  return Napi::ObjectWrap<MessageWrap>::Unwrap(value.As<Napi::Object>());
+}
+
+MessageWrap::MessageWrap(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<MessageWrap>(info) {
+  Napi::Env env = info.Env();
+  if (info.Length() == 0) {
+    // Empty message.
+    return;
+  }
+  if (!info[0].IsString()) {
+    throw Napi::TypeError::New(
+        env, "new Message(raw: string, validate?: boolean)");
+  }
+  const std::string raw = info[0].As<Napi::String>().Utf8Value();
+  bool validate = false;
+  if (info.Length() >= 2 && !info[1].IsUndefined() && !info[1].IsNull()) {
+    validate = info[1].ToBoolean().Value();
+  }
+  NQ_TRY(env) {
+    message_.setString(raw, validate);
+  } NQ_CATCH(env)
+}
+
+Napi::Value MessageWrap::GetField(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int tag = CoerceTag(env, info[0]);
+  NQ_TRY(env) {
+    // Auto-route standard header/trailer fields (MsgType, SenderCompID,
+    // CheckSum, ...) to the right section so callers don't have to know which
+    // section a well-known tag belongs to. Everything else is a body field.
+    const std::string& value =
+        FIX::Message::isHeaderField(tag)    ? message_.getHeader().getField(tag)
+        : FIX::Message::isTrailerField(tag) ? message_.getTrailer().getField(tag)
+                                            : message_.getField(tag);
+    return Napi::String::New(env, value);
+  } NQ_CATCH(env)
+}
+
+Napi::Value MessageWrap::SetField(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int tag = CoerceTag(env, info[0]);
+  std::string value = CoerceValue(env, info[1]);
+  NQ_TRY(env) {
+    if (FIX::Message::isHeaderField(tag)) {
+      message_.getHeader().setField(tag, value);
+    } else if (FIX::Message::isTrailerField(tag)) {
+      message_.getTrailer().setField(tag, value);
+    } else {
+      message_.setField(tag, value);
+    }
+  } NQ_CATCH(env)
+  return env.Undefined();
+}
+
+Napi::Value MessageWrap::GetHeaderField(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int tag = CoerceTag(env, info[0]);
+  NQ_TRY(env) {
+    const std::string& value = message_.getHeader().getField(tag);
+    return Napi::String::New(env, value);
+  } NQ_CATCH(env)
+}
+
+Napi::Value MessageWrap::SetHeaderField(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int tag = CoerceTag(env, info[0]);
+  std::string value = CoerceValue(env, info[1]);
+  NQ_TRY(env) {
+    message_.getHeader().setField(tag, value);
+  } NQ_CATCH(env)
+  return env.Undefined();
+}
+
+Napi::Value MessageWrap::GetTrailerField(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int tag = CoerceTag(env, info[0]);
+  NQ_TRY(env) {
+    const std::string& value = message_.getTrailer().getField(tag);
+    return Napi::String::New(env, value);
+  } NQ_CATCH(env)
+}
+
+Napi::Value MessageWrap::SetTrailerField(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  int tag = CoerceTag(env, info[0]);
+  std::string value = CoerceValue(env, info[1]);
+  NQ_TRY(env) {
+    message_.getTrailer().setField(tag, value);
+  } NQ_CATCH(env)
+  return env.Undefined();
+}
+
+Napi::Value MessageWrap::ToString(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    return Napi::String::New(env, message_.toString());
+  } NQ_CATCH(env)
+}
+
+Napi::Value MessageWrap::ToPretty(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    std::string s = message_.toString();
+    std::replace(s.begin(), s.end(), '\x01', '|');
+    return Napi::String::New(env, s);
+  } NQ_CATCH(env)
+}
+
+Napi::Value MessageWrap::GetMsgType(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    const std::string& msgType = message_.getHeader().getField(FIX::FIELD::MsgType);
+    return Napi::String::New(env, msgType);
+  } NQ_CATCH(env)
+}
+
+}  // namespace napi_quickfix

package/cpp/message_wrap.h

@@ -0,0 +1,53 @@
+#ifndef NAPI_QUICKFIX_MESSAGE_WRAP_H
+#define NAPI_QUICKFIX_MESSAGE_WRAP_H
+
+#include <napi.h>
+
+#include "quickfix/Message.h"
+
+namespace napi_quickfix {
+
+// Napi::ObjectWrap over FIX::Message.
+//
+//   new MessageWrap()
+//   new MessageWrap(raw: string, validate?: boolean = false)
+//
+// Methods: getField / setField / getHeaderField / setHeaderField /
+// getTrailerField / setTrailerField / toString / toPretty / getMsgType.
+class MessageWrap : public Napi::ObjectWrap<MessageWrap> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  // Build a JS MessageWrap wrapping a COPY of the given FIX::Message. Used by
+  // the ApplicationBridge trampoline to hand messages to JS handlers.
+  static Napi::Object NewInstance(Napi::Env env, const FIX::Message& msg);
+
+  explicit MessageWrap(const Napi::CallbackInfo& info);
+
+  // Internal accessor for other wrappers (validate, sendToTarget, bridge).
+  FIX::Message& Message() { return message_; }
+  const FIX::Message& Message() const { return message_; }
+
+  // Unwrap a JS value that must be a MessageWrap; throws Napi::TypeError if not.
+  static MessageWrap* UnwrapArg(Napi::Env env, Napi::Value value,
+                             const char* argName);
+
+ private:
+  static Napi::FunctionReference constructor_;
+
+  Napi::Value GetField(const Napi::CallbackInfo& info);
+  Napi::Value SetField(const Napi::CallbackInfo& info);
+  Napi::Value GetHeaderField(const Napi::CallbackInfo& info);
+  Napi::Value SetHeaderField(const Napi::CallbackInfo& info);
+  Napi::Value GetTrailerField(const Napi::CallbackInfo& info);
+  Napi::Value SetTrailerField(const Napi::CallbackInfo& info);
+  Napi::Value ToString(const Napi::CallbackInfo& info);
+  Napi::Value ToPretty(const Napi::CallbackInfo& info);
+  Napi::Value GetMsgType(const Napi::CallbackInfo& info);
+
+  FIX::Message message_;
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_MESSAGE_WRAP_H

package/cpp/session_id_wrap.cpp

@@ -0,0 +1,91 @@
+#include "session_id_wrap.h"
+
+#include <string>
+
+#include "errors.h"
+
+namespace napi_quickfix {
+
+Napi::FunctionReference SessionIDWrap::constructor_;
+
+Napi::Object SessionIDWrap::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "SessionID",
+      {
+          InstanceMethod("getBeginString", &SessionIDWrap::GetBeginString),
+          InstanceMethod("getSenderCompID", &SessionIDWrap::GetSenderCompID),
+          InstanceMethod("getTargetCompID", &SessionIDWrap::GetTargetCompID),
+          InstanceMethod("getSessionQualifier",
+                         &SessionIDWrap::GetSessionQualifier),
+          InstanceMethod("toString", &SessionIDWrap::ToString),
+      });
+
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
+
+  exports.Set("SessionIDWrap", func);
+  return exports;
+}
+
+Napi::Object SessionIDWrap::NewInstance(Napi::Env env,
+                                        const FIX::SessionID& id) {
+  Napi::Object obj = constructor_.New(
+      {Napi::String::New(env, id.getBeginString().getValue()),
+       Napi::String::New(env, id.getSenderCompID().getValue()),
+       Napi::String::New(env, id.getTargetCompID().getValue()),
+       Napi::String::New(env, id.getSessionQualifier())});
+  return obj;
+}
+
+SessionIDWrap* SessionIDWrap::UnwrapArg(Napi::Env env, Napi::Value value,
+                                     const char* argName) {
+  if (!value.IsObject() ||
+      !value.As<Napi::Object>().InstanceOf(constructor_.Value())) {
+    throw Napi::TypeError::New(
+        env, std::string(argName) + " must be a SessionID instance");
+  }
+  return Napi::ObjectWrap<SessionIDWrap>::Unwrap(value.As<Napi::Object>());
+}
+
+SessionIDWrap::SessionIDWrap(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<SessionIDWrap>(info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 3 || !info[0].IsString() || !info[1].IsString() ||
+      !info[2].IsString()) {
+    throw Napi::TypeError::New(
+        env,
+        "new SessionID(beginString, senderCompID, targetCompID, qualifier?)");
+  }
+  std::string begin = info[0].As<Napi::String>().Utf8Value();
+  std::string sender = info[1].As<Napi::String>().Utf8Value();
+  std::string target = info[2].As<Napi::String>().Utf8Value();
+  std::string qualifier;
+  if (info.Length() >= 4 && info[3].IsString()) {
+    qualifier = info[3].As<Napi::String>().Utf8Value();
+  }
+  session_id_ = FIX::SessionID(begin, sender, target, qualifier);
+}
+
+Napi::Value SessionIDWrap::GetBeginString(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(), session_id_.getBeginString().getValue());
+}
+
+Napi::Value SessionIDWrap::GetSenderCompID(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(),
+                           session_id_.getSenderCompID().getValue());
+}
+
+Napi::Value SessionIDWrap::GetTargetCompID(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(),
+                           session_id_.getTargetCompID().getValue());
+}
+
+Napi::Value SessionIDWrap::GetSessionQualifier(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(), session_id_.getSessionQualifier());
+}
+
+Napi::Value SessionIDWrap::ToString(const Napi::CallbackInfo& info) {
+  return Napi::String::New(info.Env(), session_id_.toString());
+}
+
+}  // namespace napi_quickfix

package/cpp/session_id_wrap.h

@@ -0,0 +1,46 @@
+#ifndef NAPI_QUICKFIX_SESSION_ID_WRAP_H
+#define NAPI_QUICKFIX_SESSION_ID_WRAP_H
+
+#include <napi.h>
+
+#include "quickfix/SessionID.h"
+
+namespace napi_quickfix {
+
+// Napi::ObjectWrap over FIX::SessionID.
+//
+//   new SessionID(beginString, senderCompID, targetCompID, qualifier?)
+//
+// Getters: getBeginString / getSenderCompID / getTargetCompID /
+// getSessionQualifier; plus toString.
+class SessionIDWrap : public Napi::ObjectWrap<SessionIDWrap> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  // Build a JS SessionID wrapping a copy of the given FIX::SessionID.
+  static Napi::Object NewInstance(Napi::Env env, const FIX::SessionID& id);
+
+  explicit SessionIDWrap(const Napi::CallbackInfo& info);
+
+  FIX::SessionID& SessionID() { return session_id_; }
+  const FIX::SessionID& SessionID() const { return session_id_; }
+
+  // Unwrap a JS value that must be a SessionID; throws Napi::TypeError if not.
+  static SessionIDWrap* UnwrapArg(Napi::Env env, Napi::Value value,
+                               const char* argName);
+
+ private:
+  static Napi::FunctionReference constructor_;
+
+  Napi::Value GetBeginString(const Napi::CallbackInfo& info);
+  Napi::Value GetSenderCompID(const Napi::CallbackInfo& info);
+  Napi::Value GetTargetCompID(const Napi::CallbackInfo& info);
+  Napi::Value GetSessionQualifier(const Napi::CallbackInfo& info);
+  Napi::Value ToString(const Napi::CallbackInfo& info);
+
+  FIX::SessionID session_id_;
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_SESSION_ID_WRAP_H

package/cpp/session_settings_wrap.cpp

@@ -0,0 +1,98 @@
+#include "session_settings_wrap.h"
+
+#include <set>
+#include <sstream>
+#include <string>
+
+#include "errors.h"
+#include "quickfix/SessionID.h"
+#include "session_id_wrap.h"
+
+namespace napi_quickfix {
+
+Napi::FunctionReference SessionSettingsWrap::constructor_;
+
+Napi::Object SessionSettingsWrap::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "SessionSettings",
+      {
+          StaticMethod("fromString", &SessionSettingsWrap::FromString),
+          StaticMethod("fromFile", &SessionSettingsWrap::FromFile),
+          InstanceMethod("getSessions", &SessionSettingsWrap::GetSessions),
+      });
+
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
+
+  exports.Set("SessionSettingsWrap", func);
+  return exports;
+}
+
+SessionSettingsWrap* SessionSettingsWrap::UnwrapArg(Napi::Env env,
+                                                 Napi::Value value,
+                                                 const char* argName) {
+  if (!value.IsObject() ||
+      !value.As<Napi::Object>().InstanceOf(constructor_.Value())) {
+    throw Napi::TypeError::New(
+        env, std::string(argName) + " must be a SessionSettings instance");
+  }
+  return Napi::ObjectWrap<SessionSettingsWrap>::Unwrap(
+      value.As<Napi::Object>());
+}
+
+// Constructor is internal: (kind: "string"|"file", payload: string).
+// Users go through the static fromString/fromFile factories.
+SessionSettingsWrap::SessionSettingsWrap(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<SessionSettingsWrap>(info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 2 || !info[0].IsString() || !info[1].IsString()) {
+    throw Napi::TypeError::New(
+        env,
+        "SessionSettings cannot be constructed directly; use "
+        "SessionSettings.fromString() or SessionSettings.fromFile()");
+  }
+  std::string kind = info[0].As<Napi::String>().Utf8Value();
+  std::string payload = info[1].As<Napi::String>().Utf8Value();
+
+  NQ_TRY(env) {
+    if (kind == "string") {
+      std::istringstream stream(payload);
+      settings_ = FIX::SessionSettings(stream);
+    } else {  // "file"
+      settings_ = FIX::SessionSettings(payload);
+    }
+  } NQ_CATCH(env)
+}
+
+Napi::Value SessionSettingsWrap::FromString(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsString()) {
+    throw Napi::TypeError::New(env, "fromString(text: string)");
+  }
+  return constructor_.New(
+      {Napi::String::New(env, "string"), info[0].As<Napi::String>()});
+}
+
+Napi::Value SessionSettingsWrap::FromFile(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsString()) {
+    throw Napi::TypeError::New(env, "fromFile(path: string)");
+  }
+  return constructor_.New(
+      {Napi::String::New(env, "file"), info[0].As<Napi::String>()});
+}
+
+Napi::Value SessionSettingsWrap::GetSessions(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    std::set<FIX::SessionID> sessions = settings_.getSessions();
+    Napi::Array arr = Napi::Array::New(env, sessions.size());
+    uint32_t i = 0;
+    for (const auto& id : sessions) {
+      arr.Set(i++, SessionIDWrap::NewInstance(env, id));
+    }
+    return arr;
+  } NQ_CATCH(env)
+}
+
+}  // namespace napi_quickfix

package/cpp/session_settings_wrap.h

@@ -0,0 +1,40 @@
+#ifndef NAPI_QUICKFIX_SESSION_SETTINGS_WRAP_H
+#define NAPI_QUICKFIX_SESSION_SETTINGS_WRAP_H
+
+#include <napi.h>
+
+#include "quickfix/SessionSettings.h"
+
+namespace napi_quickfix {
+
+// Napi::ObjectWrap over FIX::SessionSettings.
+//
+//   SessionSettings.fromString(text): SessionSettings
+//   SessionSettings.fromFile(path): SessionSettings
+//   settings.getSessions(): SessionID[]
+class SessionSettingsWrap : public Napi::ObjectWrap<SessionSettingsWrap> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  explicit SessionSettingsWrap(const Napi::CallbackInfo& info);
+
+  FIX::SessionSettings& Settings() { return settings_; }
+  const FIX::SessionSettings& Settings() const { return settings_; }
+
+  static SessionSettingsWrap* UnwrapArg(Napi::Env env, Napi::Value value,
+                                     const char* argName);
+
+ private:
+  static Napi::FunctionReference constructor_;
+
+  static Napi::Value FromString(const Napi::CallbackInfo& info);
+  static Napi::Value FromFile(const Napi::CallbackInfo& info);
+
+  Napi::Value GetSessions(const Napi::CallbackInfo& info);
+
+  FIX::SessionSettings settings_;
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_SESSION_SETTINGS_WRAP_H

package/cpp/session_static.cpp

@@ -0,0 +1,93 @@
+#include <napi.h>
+
+#include <utility>
+
+#include "errors.h"
+#include "message_wrap.h"
+#include "quickfix/Message.h"
+#include "quickfix/Session.h"
+#include "quickfix/SessionID.h"
+#include "session_id_wrap.h"
+
+namespace napi_quickfix {
+
+namespace {
+
+// AsyncWorker for FIX::Session::sendToTarget. Runs OFF the JS main thread so the
+// event loop stays free to service the ApplicationBridge TSFN BlockingCall(s)
+// that toApp/toAdmin trigger during the send. Running on the main thread would
+// deadlock (main blocked in sendToTarget -> toApp -> BlockingCall -> waits for
+// main to run CallJs, which it can't).
+//
+// The FIX::Message and FIX::SessionID are COPIED BY VALUE on the JS thread
+// before Queue()ing, so Execute() never touches any JS object. toApp may mutate
+// the worker's private copy during send — that's fine, it's QuickFIX's business.
+class SendToTargetWorker : public Napi::AsyncWorker {
+ public:
+  SendToTargetWorker(Napi::Env env, FIX::Message message, FIX::SessionID id)
+      : Napi::AsyncWorker(env),
+        deferred_(Napi::Promise::Deferred::New(env)),
+        message_(std::move(message)),
+        id_(std::move(id)) {}
+
+  Napi::Promise Promise() { return deferred_.Promise(); }
+
+  // Worker thread. NO Napi/JS access.
+  void Execute() override {
+    try {
+      result_ = FIX::Session::sendToTarget(message_, id_);
+    } catch (const std::exception& e) {
+      err_.Capture(e);
+    } catch (...) {
+      err_.has = true;
+      err_.message = "unknown native error";
+      err_.fixErrorName = "Error";
+    }
+  }
+
+  void OnOK() override {
+    Napi::Env env = Env();
+    Napi::HandleScope scope(env);
+    if (err_.has) {
+      deferred_.Reject(err_.ToError(env).Value());
+    } else {
+      deferred_.Resolve(Napi::Boolean::New(env, result_));
+    }
+  }
+
+  void OnError(const Napi::Error& e) override {
+    Napi::HandleScope scope(Env());
+    deferred_.Reject(e.Value());
+  }
+
+ private:
+  Napi::Promise::Deferred deferred_;
+  FIX::Message message_;
+  FIX::SessionID id_;
+  bool result_ = false;
+  CapturedError err_;
+};
+
+}  // namespace
+
+// sendToTarget(message: Message, sessionID: SessionID): Promise<boolean>
+static Napi::Value SendToTarget(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  MessageWrap* msg = MessageWrap::UnwrapArg(env, info[0], "message");
+  SessionIDWrap* id = SessionIDWrap::UnwrapArg(env, info[1], "sessionID");
+
+  // Copy the message and session id by value on the JS thread so the worker
+  // never touches JS-owned objects.
+  auto* worker =
+      new SendToTargetWorker(env, msg->Message(), id->SessionID());
+  Napi::Promise promise = worker->Promise();
+  worker->Queue();
+  return promise;
+}
+
+void RegisterSessionStatic(Napi::Env env, Napi::Object exports) {
+  exports.Set("sendToTarget",
+              Napi::Function::New(env, SendToTarget, "sendToTarget"));
+}
+
+}  // namespace napi_quickfix

package/dist/cjs/acceptor.d.ts

@@ -0,0 +1,30 @@
+import { Engine, type EngineOptions } from './engine.js';
+export type { EngineOptions } from './engine.js';
+/**
+ * A FIX session acceptor (wraps `FIX::SocketAcceptor`). Acceptors listen for
+ * inbound connections from initiators as configured in
+ * {@link EngineOptions.settings}.
+ *
+ * Extends {@link Engine} (an {@link import('node:events').EventEmitter}), so you
+ * can observe lifecycle/message events in addition to supplying `handlers`.
+ * Remember: only `handlers` may mutate outbound messages or reject inbound ones;
+ * events are observe-only.
+ *
+ * @example
+ * ```ts
+ * const acceptor = new Acceptor({
+ *   settings: SessionSettings.fromString(cfg),
+ *   handlers: {
+ *     fromApp: (msg, id) => { void sendToTarget(makeReply(msg), id); },
+ *   },
+ * });
+ * await acceptor.start();
+ * // ... later
+ * await acceptor.stop();
+ * ```
+ */
+export declare class Acceptor extends Engine {
+    /** @param options Engine options. */
+    constructor(options: EngineOptions);
+}
+//# sourceMappingURL=acceptor.d.ts.map

package/dist/cjs/acceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptor.d.ts","sourceRoot":"","sources":["../../src/acceptor.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAEzD,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,QAAS,SAAQ,MAAM;IAClC,qCAAqC;IACrC,YAAY,OAAO,EAAE,aAAa,EAEjC;CACF"}

package/dist/cjs/acceptor.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Acceptor = void 0;
+/**
+ * FIX session acceptor (server side — listens for initiators).
+ */
+const native_js_1 = require("./native.js");
+const engine_js_1 = require("./engine.js");
+/**
+ * A FIX session acceptor (wraps `FIX::SocketAcceptor`). Acceptors listen for
+ * inbound connections from initiators as configured in
+ * {@link EngineOptions.settings}.
+ *
+ * Extends {@link Engine} (an {@link import('node:events').EventEmitter}), so you
+ * can observe lifecycle/message events in addition to supplying `handlers`.
+ * Remember: only `handlers` may mutate outbound messages or reject inbound ones;
+ * events are observe-only.
+ *
+ * @example
+ * ```ts
+ * const acceptor = new Acceptor({
+ *   settings: SessionSettings.fromString(cfg),
+ *   handlers: {
+ *     fromApp: (msg, id) => { void sendToTarget(makeReply(msg), id); },
+ *   },
+ * });
+ * await acceptor.start();
+ * // ... later
+ * await acceptor.stop();
+ * ```
+ */
+class Acceptor extends engine_js_1.Engine {
+    /** @param options Engine options. */
+    constructor(options) {
+        super(native_js_1.native.AcceptorWrap, options);
+    }
+}
+exports.Acceptor = Acceptor;
+//# sourceMappingURL=acceptor.js.map