@homaiohq/napi-quickfix 0.1.0 → 0.3.0

package/cpp/session_static.cpp

@@ -1,13 +1,20 @@
 #include <napi.h>
 
+#include <memory>
+#include <set>
+#include <string>
 #include <utility>
 
 #include "errors.h"
+#include "field_map_ops.h"
 #include "message_wrap.h"
+#include "quickfix/Exceptions.h"
 #include "quickfix/Message.h"
 #include "quickfix/Session.h"
 #include "quickfix/SessionID.h"
 #include "session_id_wrap.h"
+#include "session_op_gate.h"
+#include "session_wrap.h"
 
 namespace napi_quickfix {
 
@@ -19,22 +26,46 @@ namespace {
 // 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.
+// The FIX::Message (a fieldmap::CloneMessage, nested group entries kept
+// typed) and FIX::SessionID are COPIED 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.
+//
+// Two upstream overloads are supported: by explicit SessionID, or by qualifier
+// (QuickFIX then resolves the session from the message's own header fields:
+// BeginString / SenderCompID / TargetCompID).
+//
+// Session::sendToTarget looks the session up in the process-wide registry and
+// uses the raw pointer, so Execute() runs under the owning engine's
+// SessionOpGate::OpScope to keep that engine alive until the send has returned.
+// That gate is resolved by SendToTarget() on the JS thread, before the worker
+// is queued (for the qualifier form after deriving the SessionID from the
+// message header, exactly as the upstream overload does): the send is thereby
+// bound to the engine that owned the session when it was called, and can
+// never run through an engine registered for the same id afterwards -- not
+// even if it sat in the libuv queue across the owner's stop() and that
+// engine's construction. Execute() only re-checks that the gate is still the
+// owner once the scope is held (see session_op_gate.h).
 class SendToTargetWorker : public Napi::AsyncWorker {
  public:
-  SendToTargetWorker(Napi::Env env, FIX::Message message, FIX::SessionID id)
+  SendToTargetWorker(Napi::Env env, FIX::Message message, FIX::SessionID id,
+                     std::shared_ptr<SessionOpGate> gate)
       : Napi::AsyncWorker(env),
         deferred_(Napi::Promise::Deferred::New(env)),
         message_(std::move(message)),
-        id_(std::move(id)) {}
+        id_(std::move(id)),
+        gate_(std::move(gate)) {}
 
   Napi::Promise Promise() { return deferred_.Promise(); }
 
   // Worker thread. NO Napi/JS access.
   void Execute() override {
     try {
+      std::unique_ptr<SessionOpGate::OpScope> inflight =
+          SessionOpGate::Acquire(gate_, id_);
+      if (!inflight) {
+        throw FIX::SessionNotFound(id_.toString());
+      }
       result_ = FIX::Session::sendToTarget(message_, id_);
     } catch (const std::exception& e) {
       err_.Capture(e);
@@ -64,30 +95,126 @@ class SendToTargetWorker : public Napi::AsyncWorker {
   Napi::Promise::Deferred deferred_;
   FIX::Message message_;
   FIX::SessionID id_;
+  std::shared_ptr<SessionOpGate> gate_;
   bool result_ = false;
   CapturedError err_;
 };
 
-}  // namespace
-
 // sendToTarget(message: Message, sessionID: SessionID): Promise<boolean>
-static Napi::Value SendToTarget(const Napi::CallbackInfo& info) {
+// sendToTarget(message: Message, qualifier?: string): Promise<boolean>
+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
+  // 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());
+  FIX::Message message = fieldmap::CloneMessage(msg->Message());
+  const bool byQualifier = info.Length() < 2 || info[1].IsUndefined() ||
+                           info[1].IsString();
+  FIX::SessionID id;
+  if (!byQualifier) {
+    id = SessionIDWrap::UnwrapArg(env, info[1], "sessionID")->SessionID();
+  }
+
+  // Resolve the owning engine HERE, on the JS thread (see the worker's
+  // comment): a session that no engine owns is refused right away, with the
+  // same error the worker reports when the engine goes away under it.
+  std::shared_ptr<SessionOpGate> gate;
+  try {
+    if (byQualifier) {
+      // Mirrors FIX::Session::sendToTarget(Message&, const std::string&):
+      // a header missing tag 8/49/56 is a SessionNotFound.
+      const std::string qualifier =
+          info[1].IsString() ? info[1].As<Napi::String>().Utf8Value()
+                             : std::string();
+      try {
+        id = message.getSessionID(qualifier);
+      } catch (const FIX::FieldNotFound&) {
+        throw FIX::SessionNotFound();
+      }
+    }
+    gate = SessionOpGate::Lookup(id);
+    if (!gate) {
+      throw FIX::SessionNotFound(id.toString());
+    }
+  } catch (const FIX::Exception& e) {
+    CapturedError err;
+    err.Capture(e);
+    auto deferred = Napi::Promise::Deferred::New(env);
+    deferred.Reject(err.ToError(env).Value());
+    return deferred.Promise();
+  }
+
+  auto* worker = new SendToTargetWorker(env, std::move(message), std::move(id),
+                                        std::move(gate));
   Napi::Promise promise = worker->Promise();
   worker->Queue();
   return promise;
 }
 
+// lookupSession(sessionID: SessionID): Session | undefined
+Napi::Value LookupSession(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  SessionIDWrap* id = SessionIDWrap::UnwrapArg(env, info[0], "sessionID");
+  NQ_TRY(env) {
+    // The gate of the engine owning the id; registered by every wrap
+    // constructor right after it created its sessions, unregistered right
+    // before they are destroyed, so (both on the JS thread) a session that
+    // exists has exactly one. No gate means no session.
+    std::shared_ptr<SessionOpGate> gate = SessionOpGate::Lookup(id->SessionID());
+    if (!gate || !FIX::Session::doesSessionExist(id->SessionID())) {
+      return env.Undefined();
+    }
+    return SessionWrap::NewInstance(env, id->SessionID(), std::move(gate));
+  } NQ_CATCH(env)
+}
+
+// doesSessionExist(sessionID: SessionID): boolean
+Napi::Value DoesSessionExist(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  SessionIDWrap* id = SessionIDWrap::UnwrapArg(env, info[0], "sessionID");
+  NQ_TRY(env) {
+    return Napi::Boolean::New(env,
+                              FIX::Session::doesSessionExist(id->SessionID()));
+  } NQ_CATCH(env)
+}
+
+// getSessions(): SessionID[]  -- every session registered in this process.
+Napi::Value GetSessions(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    const std::set<FIX::SessionID> ids = FIX::Session::getSessions();
+    Napi::Array out = Napi::Array::New(env, ids.size());
+    uint32_t i = 0;
+    for (const FIX::SessionID& id : ids) {
+      out.Set(i++, SessionIDWrap::NewInstance(env, id));
+    }
+    return out;
+  } NQ_CATCH(env)
+}
+
+// numSessions(): number
+Napi::Value NumSessions(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    return Napi::Number::New(env,
+                             static_cast<double>(FIX::Session::numSessions()));
+  } NQ_CATCH(env)
+}
+
+}  // namespace
+
 void RegisterSessionStatic(Napi::Env env, Napi::Object exports) {
   exports.Set("sendToTarget",
               Napi::Function::New(env, SendToTarget, "sendToTarget"));
+  exports.Set("lookupSession",
+              Napi::Function::New(env, LookupSession, "lookupSession"));
+  exports.Set("doesSessionExist",
+              Napi::Function::New(env, DoesSessionExist, "doesSessionExist"));
+  exports.Set("getSessions",
+              Napi::Function::New(env, GetSessions, "getSessions"));
+  exports.Set("numSessions",
+              Napi::Function::New(env, NumSessions, "numSessions"));
 }
 
 }  // namespace napi_quickfix

package/cpp/session_wrap.cpp

@@ -0,0 +1,438 @@
+#include "session_wrap.h"
+
+#include <cmath>
+#include <ctime>
+#include <limits>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "errors.h"
+#include "quickfix/Exceptions.h"
+#include "quickfix/FieldTypes.h"
+#include "session_id_wrap.h"
+
+namespace napi_quickfix {
+
+Napi::FunctionReference SessionWrap::constructor_;
+
+Napi::Object SessionWrap::Init(Napi::Env env, Napi::Object exports) {
+  Napi::Function func = DefineClass(
+      env, "Session",
+      {
+          InstanceMethod("getSessionID", &SessionWrap::GetSessionID),
+
+          InstanceMethod("isLoggedOn", &SessionWrap::IsLoggedOn),
+          InstanceMethod("isEnabled", &SessionWrap::IsEnabled),
+          InstanceMethod("sentLogon", &SessionWrap::SentLogon),
+          InstanceMethod("sentLogout", &SessionWrap::SentLogout),
+          InstanceMethod("receivedLogon", &SessionWrap::ReceivedLogon),
+          InstanceMethod("isInitiator", &SessionWrap::IsInitiator),
+          InstanceMethod("isAcceptor", &SessionWrap::IsAcceptor),
+          InstanceMethod("isSessionTime", &SessionWrap::IsSessionTime),
+          InstanceMethod("isLogonTime", &SessionWrap::IsLogonTime),
+
+          InstanceMethod("getExpectedSenderNum",
+                         &SessionWrap::GetExpectedSenderNum),
+          InstanceMethod("getExpectedTargetNum",
+                         &SessionWrap::GetExpectedTargetNum),
+          InstanceMethod("setNextSenderMsgSeqNum",
+                         &SessionWrap::SetNextSenderMsgSeqNum),
+          InstanceMethod("setNextTargetMsgSeqNum",
+                         &SessionWrap::SetNextTargetMsgSeqNum),
+
+          InstanceMethod("getResetOnLogon", &SessionWrap::GetResetOnLogon),
+          InstanceMethod("setResetOnLogon", &SessionWrap::SetResetOnLogon),
+          InstanceMethod("getResetOnLogout", &SessionWrap::GetResetOnLogout),
+          InstanceMethod("setResetOnLogout", &SessionWrap::SetResetOnLogout),
+          InstanceMethod("getResetOnDisconnect",
+                         &SessionWrap::GetResetOnDisconnect),
+          InstanceMethod("setResetOnDisconnect",
+                         &SessionWrap::SetResetOnDisconnect),
+          InstanceMethod("getRefreshOnLogon", &SessionWrap::GetRefreshOnLogon),
+          InstanceMethod("setRefreshOnLogon", &SessionWrap::SetRefreshOnLogon),
+          InstanceMethod("getCheckCompId", &SessionWrap::GetCheckCompId),
+          InstanceMethod("setCheckCompId", &SessionWrap::SetCheckCompId),
+          InstanceMethod("getCheckLatency", &SessionWrap::GetCheckLatency),
+          InstanceMethod("setCheckLatency", &SessionWrap::SetCheckLatency),
+          InstanceMethod("getPersistMessages",
+                         &SessionWrap::GetPersistMessages),
+          InstanceMethod("setPersistMessages",
+                         &SessionWrap::SetPersistMessages),
+          InstanceMethod("getSendRedundantResendRequests",
+                         &SessionWrap::GetSendRedundantResendRequests),
+          InstanceMethod("setSendRedundantResendRequests",
+                         &SessionWrap::SetSendRedundantResendRequests),
+          InstanceMethod("getValidateLengthAndChecksum",
+                         &SessionWrap::GetValidateLengthAndChecksum),
+          InstanceMethod("setValidateLengthAndChecksum",
+                         &SessionWrap::SetValidateLengthAndChecksum),
+          InstanceMethod("getSendNextExpectedMsgSeqNum",
+                         &SessionWrap::GetSendNextExpectedMsgSeqNum),
+          InstanceMethod("setSendNextExpectedMsgSeqNum",
+                         &SessionWrap::SetSendNextExpectedMsgSeqNum),
+          InstanceMethod("getIsNonStopSession",
+                         &SessionWrap::GetIsNonStopSession),
+          InstanceMethod("setIsNonStopSession",
+                         &SessionWrap::SetIsNonStopSession),
+          InstanceMethod("getLogonTimeout", &SessionWrap::GetLogonTimeout),
+          InstanceMethod("setLogonTimeout", &SessionWrap::SetLogonTimeout),
+          InstanceMethod("getLogoutTimeout", &SessionWrap::GetLogoutTimeout),
+          InstanceMethod("setLogoutTimeout", &SessionWrap::SetLogoutTimeout),
+          InstanceMethod("getMaxLatency", &SessionWrap::GetMaxLatency),
+          InstanceMethod("setMaxLatency", &SessionWrap::SetMaxLatency),
+          InstanceMethod("getTimestampPrecision",
+                         &SessionWrap::GetTimestampPrecision),
+          InstanceMethod("setTimestampPrecision",
+                         &SessionWrap::SetTimestampPrecision),
+
+          InstanceMethod("logon", &SessionWrap::Logon),
+          InstanceMethod("logout", &SessionWrap::Logout),
+          InstanceMethod("refresh", &SessionWrap::Refresh),
+      });
+
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
+
+  exports.Set("SessionWrap", func);
+  return exports;
+}
+
+Napi::Object SessionWrap::NewInstance(Napi::Env env, const FIX::SessionID& id,
+                                      std::shared_ptr<SessionOpGate> gate) {
+  Napi::Object obj = constructor_.New({SessionIDWrap::NewInstance(env, id)});
+  Unwrap(obj)->gate_ = std::move(gate);
+  return obj;
+}
+
+SessionWrap::SessionWrap(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<SessionWrap>(info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1) {
+    throw Napi::TypeError::New(
+        env,
+        "Session cannot be constructed directly; use lookupSession() or "
+        "engine.getSession()");
+  }
+  // Copy by value: the wrap must outlive any SessionID JS object.
+  id_ = SessionIDWrap::UnwrapArg(env, info[0], "sessionID")->SessionID();
+}
+
+// Engines are created and destroyed on the JS thread only, and so is this
+// call, so the owner check and the lookup cannot interleave with an engine
+// stop. During a graceful stop() the gate stays registered until the engine is
+// destroyed (Freeze() -> Unregister() -> delete, all before stop() settles), so
+// a 'logout' listener fired by the stop still resolves the session.
+FIX::Session& SessionWrap::Resolve() {
+  if (!gate_ || SessionOpGate::Lookup(id_) != gate_) {
+    throw FIX::SessionNotFound(id_.toString());
+  }
+  FIX::Session* session = FIX::Session::lookupSession(id_);
+  if (session == nullptr) {
+    throw FIX::SessionNotFound(id_.toString());
+  }
+  return *session;
+}
+
+Napi::Value SessionWrap::GetSessionID(const Napi::CallbackInfo& info) {
+  return SessionIDWrap::NewInstance(info.Env(), id_);
+}
+
+// --- generic helpers ---------------------------------------------------------
+
+template <typename Fn>
+Napi::Value SessionWrap::BoolGet(const Napi::CallbackInfo& info, Fn fn) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    return Napi::Boolean::New(env, (Resolve().*fn)());
+  } NQ_CATCH(env)
+}
+
+template <typename Fn>
+Napi::Value SessionWrap::IntGet(const Napi::CallbackInfo& info, Fn fn) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    return Napi::Number::New(env, static_cast<double>((Resolve().*fn)()));
+  } NQ_CATCH(env)
+}
+
+template <typename Fn>
+Napi::Value SessionWrap::BoolSet(const Napi::CallbackInfo& info, Fn fn,
+                                 const char* name) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsBoolean()) {
+    throw Napi::TypeError::New(env, std::string(name) + "(value: boolean)");
+  }
+  const bool value = info[0].As<Napi::Boolean>().Value();
+  NQ_TRY(env) {
+    (Resolve().*fn)(value);
+    return env.Undefined();
+  } NQ_CATCH(env)
+}
+
+// The FIX::Session setters take a plain `int`; a double outside its range is
+// undefined behaviour to cast (and on x86-64 lands on INT_MIN, which would e.g.
+// make a MaxLatency reject every inbound message). Bound it here and report
+// a RangeError, matching SeqNumSet / SetTimestampPrecision.
+template <typename Fn>
+Napi::Value SessionWrap::IntSet(const Napi::CallbackInfo& info, Fn fn,
+                                const char* name) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsNumber()) {
+    throw Napi::TypeError::New(env, std::string(name) + "(value: number)");
+  }
+  const double raw = info[0].As<Napi::Number>().DoubleValue();
+  constexpr double kIntMin = static_cast<double>(std::numeric_limits<int>::min());
+  constexpr double kIntMax = static_cast<double>(std::numeric_limits<int>::max());
+  if (!std::isfinite(raw) || std::floor(raw) != raw || raw < kIntMin ||
+      raw > kIntMax) {
+    throw Napi::RangeError::New(
+        env, std::string(name) + ": value must be an integer in the int32 range");
+  }
+  NQ_TRY(env) {
+    (Resolve().*fn)(static_cast<int>(raw));
+    return env.Undefined();
+  } NQ_CATCH(env)
+}
+
+// isSessionTime(nowMs?) / isLogonTime(nowMs?): `nowMs` is an epoch-millisecond
+// number (Date.getTime()); omitted => the engine's current UTC clock.
+Napi::Value SessionWrap::TimeCheck(const Napi::CallbackInfo& info,
+                                   bool logonTime) {
+  Napi::Env env = info.Env();
+  bool hasNow = info.Length() >= 1 && !info[0].IsUndefined();
+  double nowMs = 0;
+  if (hasNow) {
+    if (!info[0].IsNumber()) {
+      throw Napi::TypeError::New(
+          env, logonTime ? "isLogonTime(nowMs?: number)"
+                         : "isSessionTime(nowMs?: number)");
+    }
+    nowMs = info[0].As<Napi::Number>().DoubleValue();
+    // Bound to the range a JS Date can hold (+/- 100M days around the epoch)
+    // before the floating-to-integer cast below: converting a finite double
+    // that does not fit in time_t is undefined behaviour, not a saturation.
+    constexpr double kMaxDateMs = 8.64e15;
+    if (!std::isfinite(nowMs) || std::fabs(nowMs) > kMaxDateMs) {
+      throw Napi::RangeError::New(
+          env, "nowMs must be an epoch-millisecond number in the Date range");
+    }
+  }
+  NQ_TRY(env) {
+    FIX::Session& session = Resolve();
+    FIX::UtcTimeStamp now = FIX::UtcTimeStamp::now();
+    if (hasNow) {
+      const double secs = std::floor(nowMs / 1000.0);
+      const int millis = static_cast<int>(nowMs - secs * 1000.0);
+      now = FIX::UtcTimeStamp(static_cast<time_t>(secs), millis);
+    }
+    return Napi::Boolean::New(env, logonTime ? session.isLogonTime(now)
+                                             : session.isSessionTime(now));
+  } NQ_CATCH(env)
+}
+
+// Sequence numbers are FIX::SEQNUM (uint64_t). JS numbers are exact up to
+// 2^53, which is far beyond any practical MsgSeqNum; reject anything that is
+// not a positive safe integer. MsgSeqNum (tag 34) is 1-based: QuickFIX's own
+// SessionState::reset() and MemoryStore start at 1, and a peer answers 34=0
+// with a Logout ("MsgSeqNum too low").
+Napi::Value SessionWrap::SeqNumSet(const Napi::CallbackInfo& info, bool sender,
+                                   const char* name) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsNumber()) {
+    throw Napi::TypeError::New(env, std::string(name) + "(seqNum: number)");
+  }
+  const double raw = info[0].As<Napi::Number>().DoubleValue();
+  constexpr double kMaxSafe = 9007199254740991.0;  // Number.MAX_SAFE_INTEGER
+  if (!std::isfinite(raw) || std::floor(raw) != raw || raw < 1 ||
+      raw > kMaxSafe) {
+    throw Napi::RangeError::New(
+        env, std::string(name) + ": seqNum must be a positive safe integer");
+  }
+  const FIX::SEQNUM num = static_cast<FIX::SEQNUM>(raw);
+  NQ_TRY(env) {
+    // These touch the MessageStore (may throw IOException) but take only the
+    // SessionState mutex, which QuickFIX never holds across a callback -- that
+    // is what makes them safe to run here. It also means they are NOT
+    // serialised against the engine: Session::sendRaw holds m_mutex across
+    // fill() (reads the next sender num into the header), toApp/toAdmin and
+    // persist() (incrNextSenderMsgSeqNum from the store), and Session::next()
+    // likewise across the target-num verification, fromApp/fromAdmin and
+    // incrNextTargetMsgSeqNum. A setter landing inside that window -- from a
+    // handler, or while a sendToTarget() / heartbeat is in flight on this
+    // session -- is overwritten by the increment that follows, and the wire
+    // is left one off from the peer. The setters are meant for a quiescent
+    // session (before start(), from a 'logout' event, or when the caller
+    // knows nothing is in flight); documented on the JS API, not fixable here
+    // (m_mutex is private and must not be taken from the JS thread anyway).
+    if (sender) {
+      Resolve().setNextSenderMsgSeqNum(num);
+    } else {
+      Resolve().setNextTargetMsgSeqNum(num);
+    }
+    return env.Undefined();
+  } NQ_CATCH(env)
+}
+
+// --- state getters -----------------------------------------------------------
+
+Napi::Value SessionWrap::IsLoggedOn(const Napi::CallbackInfo& info) {
+  return BoolGet(info, &FIX::Session::isLoggedOn);
+}
+Napi::Value SessionWrap::IsEnabled(const Napi::CallbackInfo& info) {
+  return BoolGet(info, &FIX::Session::isEnabled);
+}
+Napi::Value SessionWrap::SentLogon(const Napi::CallbackInfo& info) {
+  return BoolGet(info, &FIX::Session::sentLogon);
+}
+Napi::Value SessionWrap::SentLogout(const Napi::CallbackInfo& info) {
+  return BoolGet(info, &FIX::Session::sentLogout);
+}
+Napi::Value SessionWrap::ReceivedLogon(const Napi::CallbackInfo& info) {
+  return BoolGet(info, &FIX::Session::receivedLogon);
+}
+Napi::Value SessionWrap::IsInitiator(const Napi::CallbackInfo& info) {
+  return BoolGet(info, &FIX::Session::isInitiator);
+}
+Napi::Value SessionWrap::IsAcceptor(const Napi::CallbackInfo& info) {
+  return BoolGet(info, &FIX::Session::isAcceptor);
+}
+Napi::Value SessionWrap::IsSessionTime(const Napi::CallbackInfo& info) {
+  return TimeCheck(info, /*logonTime=*/false);
+}
+Napi::Value SessionWrap::IsLogonTime(const Napi::CallbackInfo& info) {
+  return TimeCheck(info, /*logonTime=*/true);
+}
+
+// --- sequence numbers --------------------------------------------------------
+
+Napi::Value SessionWrap::GetExpectedSenderNum(const Napi::CallbackInfo& info) {
+  return IntGet(info, &FIX::Session::getExpectedSenderNum);
+}
+Napi::Value SessionWrap::GetExpectedTargetNum(const Napi::CallbackInfo& info) {
+  return IntGet(info, &FIX::Session::getExpectedTargetNum);
+}
+Napi::Value SessionWrap::SetNextSenderMsgSeqNum(
+    const Napi::CallbackInfo& info) {
+  return SeqNumSet(info, /*sender=*/true, "setNextSenderMsgSeqNum");
+}
+Napi::Value SessionWrap::SetNextTargetMsgSeqNum(
+    const Napi::CallbackInfo& info) {
+  return SeqNumSet(info, /*sender=*/false, "setNextTargetMsgSeqNum");
+}
+
+// --- runtime options ---------------------------------------------------------
+
+#define NQ_BOOL_OPTION(Name)                                                   \
+  Napi::Value SessionWrap::Get##Name(const Napi::CallbackInfo& info) {         \
+    return BoolGet(info, &FIX::Session::get##Name);                            \
+  }                                                                            \
+  Napi::Value SessionWrap::Set##Name(const Napi::CallbackInfo& info) {         \
+    return BoolSet(info, &FIX::Session::set##Name, "set" #Name);               \
+  }
+
+#define NQ_INT_OPTION(Name)                                                    \
+  Napi::Value SessionWrap::Get##Name(const Napi::CallbackInfo& info) {         \
+    return IntGet(info, &FIX::Session::get##Name);                             \
+  }                                                                            \
+  Napi::Value SessionWrap::Set##Name(const Napi::CallbackInfo& info) {         \
+    return IntSet(info, &FIX::Session::set##Name, "set" #Name);                \
+  }
+
+NQ_BOOL_OPTION(ResetOnLogon)
+NQ_BOOL_OPTION(ResetOnLogout)
+NQ_BOOL_OPTION(ResetOnDisconnect)
+NQ_BOOL_OPTION(RefreshOnLogon)
+NQ_BOOL_OPTION(CheckCompId)
+NQ_BOOL_OPTION(CheckLatency)
+NQ_BOOL_OPTION(PersistMessages)
+NQ_BOOL_OPTION(SendRedundantResendRequests)
+NQ_BOOL_OPTION(ValidateLengthAndChecksum)
+NQ_BOOL_OPTION(SendNextExpectedMsgSeqNum)
+NQ_BOOL_OPTION(IsNonStopSession)
+NQ_INT_OPTION(LogonTimeout)
+NQ_INT_OPTION(LogoutTimeout)
+NQ_INT_OPTION(MaxLatency)
+
+#undef NQ_BOOL_OPTION
+#undef NQ_INT_OPTION
+
+Napi::Value SessionWrap::GetTimestampPrecision(const Napi::CallbackInfo& info) {
+  return IntGet(info, &FIX::Session::getTimestampPrecision);
+}
+
+// FIX::Session::setTimestampPrecision silently ignores values outside 0..9;
+// surface that as a RangeError instead of a no-op.
+Napi::Value SessionWrap::SetTimestampPrecision(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsNumber()) {
+    throw Napi::TypeError::New(env, "setTimestampPrecision(precision: number)");
+  }
+  const double raw = info[0].As<Napi::Number>().DoubleValue();
+  if (!std::isfinite(raw) || std::floor(raw) != raw || raw < 0 || raw > 9) {
+    throw Napi::RangeError::New(
+        env, "setTimestampPrecision: precision must be an integer in 0..9");
+  }
+  NQ_TRY(env) {
+    Resolve().setTimestampPrecision(static_cast<int>(raw));
+    return env.Undefined();
+  } NQ_CATCH(env)
+}
+
+// --- control ------------------------------------------------------------------
+// FIX::Session::logon()/logout() only flip SessionState's `enabled` flag and
+// `logoutReason` (the latter under SessionState's own mutex), and refresh()
+// re-reads the store under that same mutex; none of them take
+// FIX::Session::m_mutex or fire a callback, so they cannot deadlock the JS
+// thread against a QuickFIX thread blocked in a handler. That is the property
+// that lets them run here. What they are NOT is race-free: `enabled` is a
+// plain bool that SessionState::enabled(bool) stores with no lock and that
+// the engine's network thread reads in Session::next() under Session::m_mutex
+// -- formally a data race (ThreadSanitizer reports it), the same one
+// FIX::Initiator::stop() makes when it calls logout()/logon() on every session
+// from the stopping thread. In practice the network thread observes the flag
+// on its next pass; this binding does not patch QuickFIX to make it atomic.
+// Keeping them synchronous also keeps them ORDERED: as AsyncWorkers,
+// `logout(); logon();` could have run on two pool threads in either order.
+//
+// FIX::Session::disconnect() and reset() are deliberately NOT exposed. Through
+// the session's responder they reach FIX::SocketMonitor::drop(), which mutates
+// the monitor's socket sets with no lock while the engine's network thread
+// iterates them in SocketMonitor::block(); QuickFIX only ever calls them from
+// that thread itself (upstream issue #346, closed "not planned"). Any thread
+// this binding could run them on -- JS or libuv -- races it. logout() is the
+// supported way to bring a session down from the application.
+
+Napi::Value SessionWrap::Logon(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    Resolve().logon();
+    return env.Undefined();
+  } NQ_CATCH(env)
+}
+
+Napi::Value SessionWrap::Logout(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  std::string reason;
+  if (info.Length() >= 1 && !info[0].IsUndefined()) {
+    if (!info[0].IsString()) {
+      throw Napi::TypeError::New(env, "logout(reason?: string)");
+    }
+    reason = info[0].As<Napi::String>().Utf8Value();
+  }
+  NQ_TRY(env) {
+    Resolve().logout(reason);
+    return env.Undefined();
+  } NQ_CATCH(env)
+}
+
+// May throw IOException from the message store (mapped to QuickFixError).
+Napi::Value SessionWrap::Refresh(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  NQ_TRY(env) {
+    Resolve().refresh();
+    return env.Undefined();
+  } NQ_CATCH(env)
+}
+
+}  // namespace napi_quickfix