@homaiohq/napi-quickfix 0.1.0 → 0.3.0

package/cpp/session_wrap.h

@@ -0,0 +1,144 @@
+#ifndef NAPI_QUICKFIX_SESSION_WRAP_H
+#define NAPI_QUICKFIX_SESSION_WRAP_H
+
+#include <napi.h>
+
+#include <memory>
+
+#include "quickfix/Session.h"
+#include "quickfix/SessionID.h"
+#include "session_op_gate.h"
+
+namespace napi_quickfix {
+
+// Napi::ObjectWrap giving JS a handle on a live FIX::Session.
+//
+// Lifetime: FIX::Session objects are OWNED BY THE ENGINE (Initiator/Acceptor)
+// and FIX::Session::lookupSession returns a raw, non-owning pointer. This wrap
+// therefore never caches that pointer: it stores the FIX::SessionID by value
+// plus the SessionOpGate of the engine that owned the session when the handle
+// was created, and re-resolves on EVERY call, throwing a QuickFixError with
+// fixErrorName 'SessionNotFound' once the engine has been stopped (which
+// destroys its sessions). The gate is what ties the handle to ONE engine: the
+// process-wide registry lookupSession() reads is keyed by SessionID alone, so
+// after the owner is stopped a new engine may register the same id, and a
+// handle that only re-resolved the id would silently operate on the new
+// engine's session. Resolve() therefore also requires the registered owner of
+// the id (SessionOpGate::Lookup) to still be the gate captured at creation.
+//
+//   new SessionWrap(sessionID: SessionIDWrap)   -- internal; JS reaches a
+//   Session through lookupSession() / engine.getSession(), which bind the
+//   gate via NewInstance(). A handle built any other way has no gate and
+//   always throws SessionNotFound.
+//
+// Every member is synchronous and safe on the JS thread: none takes
+// FIX::Session::m_mutex, which QuickFIX holds across application callbacks.
+//   getSessionID, isLoggedOn, isEnabled, sentLogon, sentLogout, receivedLogon,
+//   isInitiator, isAcceptor, isSessionTime(nowMs?), isLogonTime(nowMs?),
+//   getExpectedSenderNum, getExpectedTargetNum, setNextSenderMsgSeqNum,
+//   setNextTargetMsgSeqNum, logon, logout(reason?), refresh, and the runtime
+//   option getters/setters.
+// FIX::Session::disconnect()/reset() are not exposed: they are only safe on
+// the engine's own network thread (see session_wrap.cpp).
+class SessionWrap : public Napi::ObjectWrap<SessionWrap> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+  // Build a JS Session bound to a copy of `id` and to `gate`, the
+  // SessionOpGate of the engine owning the session (SessionOpGate::Lookup(id)
+  // or the engine wrap's own gate_). Does NOT check that the session exists;
+  // callers (lookupSession / engine.getSession) do.
+  static Napi::Object NewInstance(Napi::Env env, const FIX::SessionID& id,
+                                  std::shared_ptr<SessionOpGate> gate);
+
+  explicit SessionWrap(const Napi::CallbackInfo& info);
+
+  const FIX::SessionID& SessionID() const { return id_; }
+
+ private:
+  static Napi::FunctionReference constructor_;
+
+  // Resolve the live FIX::Session of the engine this handle was created for,
+  // or throw FIX::SessionNotFound (session gone, or the id now belongs to a
+  // different engine). Must be called inside NQ_TRY so the exception maps to a
+  // QuickFixError.
+  FIX::Session& Resolve();
+
+  Napi::Value GetSessionID(const Napi::CallbackInfo& info);
+
+  Napi::Value IsLoggedOn(const Napi::CallbackInfo& info);
+  Napi::Value IsEnabled(const Napi::CallbackInfo& info);
+  Napi::Value SentLogon(const Napi::CallbackInfo& info);
+  Napi::Value SentLogout(const Napi::CallbackInfo& info);
+  Napi::Value ReceivedLogon(const Napi::CallbackInfo& info);
+  Napi::Value IsInitiator(const Napi::CallbackInfo& info);
+  Napi::Value IsAcceptor(const Napi::CallbackInfo& info);
+  Napi::Value IsSessionTime(const Napi::CallbackInfo& info);
+  Napi::Value IsLogonTime(const Napi::CallbackInfo& info);
+
+  Napi::Value GetExpectedSenderNum(const Napi::CallbackInfo& info);
+  Napi::Value GetExpectedTargetNum(const Napi::CallbackInfo& info);
+  Napi::Value SetNextSenderMsgSeqNum(const Napi::CallbackInfo& info);
+  Napi::Value SetNextTargetMsgSeqNum(const Napi::CallbackInfo& info);
+
+  // Runtime options (plain members on FIX::Session; no locking, no callbacks).
+  Napi::Value GetResetOnLogon(const Napi::CallbackInfo& info);
+  Napi::Value SetResetOnLogon(const Napi::CallbackInfo& info);
+  Napi::Value GetResetOnLogout(const Napi::CallbackInfo& info);
+  Napi::Value SetResetOnLogout(const Napi::CallbackInfo& info);
+  Napi::Value GetResetOnDisconnect(const Napi::CallbackInfo& info);
+  Napi::Value SetResetOnDisconnect(const Napi::CallbackInfo& info);
+  Napi::Value GetRefreshOnLogon(const Napi::CallbackInfo& info);
+  Napi::Value SetRefreshOnLogon(const Napi::CallbackInfo& info);
+  Napi::Value GetCheckCompId(const Napi::CallbackInfo& info);
+  Napi::Value SetCheckCompId(const Napi::CallbackInfo& info);
+  Napi::Value GetCheckLatency(const Napi::CallbackInfo& info);
+  Napi::Value SetCheckLatency(const Napi::CallbackInfo& info);
+  Napi::Value GetPersistMessages(const Napi::CallbackInfo& info);
+  Napi::Value SetPersistMessages(const Napi::CallbackInfo& info);
+  Napi::Value GetSendRedundantResendRequests(const Napi::CallbackInfo& info);
+  Napi::Value SetSendRedundantResendRequests(const Napi::CallbackInfo& info);
+  Napi::Value GetValidateLengthAndChecksum(const Napi::CallbackInfo& info);
+  Napi::Value SetValidateLengthAndChecksum(const Napi::CallbackInfo& info);
+  Napi::Value GetSendNextExpectedMsgSeqNum(const Napi::CallbackInfo& info);
+  Napi::Value SetSendNextExpectedMsgSeqNum(const Napi::CallbackInfo& info);
+  Napi::Value GetIsNonStopSession(const Napi::CallbackInfo& info);
+  Napi::Value SetIsNonStopSession(const Napi::CallbackInfo& info);
+  Napi::Value GetLogonTimeout(const Napi::CallbackInfo& info);
+  Napi::Value SetLogonTimeout(const Napi::CallbackInfo& info);
+  Napi::Value GetLogoutTimeout(const Napi::CallbackInfo& info);
+  Napi::Value SetLogoutTimeout(const Napi::CallbackInfo& info);
+  Napi::Value GetMaxLatency(const Napi::CallbackInfo& info);
+  Napi::Value SetMaxLatency(const Napi::CallbackInfo& info);
+  Napi::Value GetTimestampPrecision(const Napi::CallbackInfo& info);
+  Napi::Value SetTimestampPrecision(const Napi::CallbackInfo& info);
+
+  // Control. All sync: they only touch SessionState under its own mutex,
+  // which QuickFIX never holds across a callback.
+  Napi::Value Logon(const Napi::CallbackInfo& info);
+  Napi::Value Logout(const Napi::CallbackInfo& info);
+  Napi::Value Refresh(const Napi::CallbackInfo& info);
+
+  // Shared helpers for the one-liner getters/setters above.
+  template <typename Fn>
+  Napi::Value BoolGet(const Napi::CallbackInfo& info, Fn fn);
+  template <typename Fn>
+  Napi::Value IntGet(const Napi::CallbackInfo& info, Fn fn);
+  template <typename Fn>
+  Napi::Value BoolSet(const Napi::CallbackInfo& info, Fn fn, const char* name);
+  template <typename Fn>
+  Napi::Value IntSet(const Napi::CallbackInfo& info, Fn fn, const char* name);
+  Napi::Value TimeCheck(const Napi::CallbackInfo& info, bool logonTime);
+  Napi::Value SeqNumSet(const Napi::CallbackInfo& info, bool sender,
+                        const char* name);
+
+  FIX::SessionID id_;
+  // The owning engine's gate at creation; held by shared_ptr so the object
+  // stays alive (and its address unique) as long as the handle does. nullptr
+  // for a handle not created through NewInstance().
+  std::shared_ptr<SessionOpGate> gate_;
+};
+
+}  // namespace napi_quickfix
+
+#endif  // NAPI_QUICKFIX_SESSION_WRAP_H

package/dist/cjs/acceptor.d.ts

@@ -27,4 +27,3 @@ export declare class Acceptor extends Engine {
     /** @param options Engine options. */
     constructor(options: EngineOptions);
 }
-//# sourceMappingURL=acceptor.d.ts.map

package/dist/cjs/acceptor.js

@@ -36,4 +36,3 @@ class Acceptor extends engine_js_1.Engine {
     }
 }
 exports.Acceptor = Acceptor;
-//# sourceMappingURL=acceptor.js.map

package/dist/cjs/application.d.ts

@@ -113,4 +113,3 @@ export declare class FixReject extends Error {
  * ```
  */
 export declare function fixReject(kind: FixRejectKind, message?: string, detail?: string): FixReject;
-//# sourceMappingURL=application.d.ts.map

package/dist/cjs/application.js

@@ -60,4 +60,3 @@ exports.FixReject = FixReject;
 function fixReject(kind, message, detail) {
     return new FixReject(kind, message, detail);
 }
-//# sourceMappingURL=application.js.map

package/dist/cjs/data-dictionary.d.ts

@@ -13,6 +13,8 @@ import type { Message } from './message.js';
  * ```ts
  * const dd = DataDictionary.fromFile('./spec/FIX44.xml');
  * dd.validate(msg); // throws QuickFixError if invalid
+ * dd.getFieldName(35); // 'MsgType'
+ * Message.parse(raw, { dictionary: dd }); // structural parse (repeating groups)
  * ```
  */
 export declare class DataDictionary {
@@ -41,9 +43,25 @@ export declare class DataDictionary {
      * Validate a message against this dictionary.
      *
      * @param msg The message to validate.
+     * @param bodyOnly When `true`, validate only as the *application* dictionary
+     *   (QuickFIX's `validate(msg, true)`): the BeginString version check and the
+     *   tag/value validation of the header and trailer fields are skipped. It is
+     *   not a check of a draft body: `BeginString` and `MsgType` must be set, and
+     *   every field the dictionary requires, header and trailer included (e.g.
+     *   `BodyLength`, `CheckSum`), must be present. Defaults to `false`.
      * @throws A `QuickFixError` on any validation failure (e.g.
-     *   `fixError: 'InvalidMessage'` / `'FieldNotFound'` / `'IncorrectTagValue'`).
+     *   `fixErrorName: 'InvalidMessage'` / `'RequiredTagMissing'` /
+     *   `'IncorrectTagValue'` / `'UnsupportedVersion'`).
      */
-    validate(msg: Message): void;
+    validate(msg: Message, bodyOnly?: boolean): void;
+    /** The BeginString the spec declares (e.g. `'FIX.4.4'`), or `''` if it has none. */
+    getVersion(): string;
+    /** The name of a field tag (e.g. `35` → `'MsgType'`), or `undefined` if the spec does not define it. */
+    getFieldName(tag: number): string | undefined;
+    /** The tag of a field name (e.g. `'MsgType'` → `35`), or `undefined` if the spec does not define it. */
+    getFieldTag(name: string): number | undefined;
+    /** Whether the spec defines a field with this tag. */
+    isField(tag: number): boolean;
+    /** Whether the spec defines a message with this MsgType (e.g. `'D'`). */
+    isMsgType(msgType: string): boolean;
 }
-//# sourceMappingURL=data-dictionary.d.ts.map

package/dist/cjs/data-dictionary.js

@@ -15,6 +15,8 @@ const native_js_1 = require("./native.js");
  * ```ts
  * const dd = DataDictionary.fromFile('./spec/FIX44.xml');
  * dd.validate(msg); // throws QuickFixError if invalid
+ * dd.getFieldName(35); // 'MsgType'
+ * Message.parse(raw, { dictionary: dd }); // structural parse (repeating groups)
  * ```
  */
 class DataDictionary {
@@ -66,12 +68,38 @@ class DataDictionary {
      * Validate a message against this dictionary.
      *
      * @param msg The message to validate.
+     * @param bodyOnly When `true`, validate only as the *application* dictionary
+     *   (QuickFIX's `validate(msg, true)`): the BeginString version check and the
+     *   tag/value validation of the header and trailer fields are skipped. It is
+     *   not a check of a draft body: `BeginString` and `MsgType` must be set, and
+     *   every field the dictionary requires, header and trailer included (e.g.
+     *   `BodyLength`, `CheckSum`), must be present. Defaults to `false`.
      * @throws A `QuickFixError` on any validation failure (e.g.
-     *   `fixError: 'InvalidMessage'` / `'FieldNotFound'` / `'IncorrectTagValue'`).
+     *   `fixErrorName: 'InvalidMessage'` / `'RequiredTagMissing'` /
+     *   `'IncorrectTagValue'` / `'UnsupportedVersion'`).
      */
-    validate(msg) {
-        this.#native.validate(msg.nativeHandle);
+    validate(msg, bodyOnly = false) {
+        this.#native.validate(msg.nativeHandle, bodyOnly);
+    }
+    /** The BeginString the spec declares (e.g. `'FIX.4.4'`), or `''` if it has none. */
+    getVersion() {
+        return this.#native.getVersion();
+    }
+    /** The name of a field tag (e.g. `35` → `'MsgType'`), or `undefined` if the spec does not define it. */
+    getFieldName(tag) {
+        return this.#native.getFieldName(tag);
+    }
+    /** The tag of a field name (e.g. `'MsgType'` → `35`), or `undefined` if the spec does not define it. */
+    getFieldTag(name) {
+        return this.#native.getFieldTag(name);
+    }
+    /** Whether the spec defines a field with this tag. */
+    isField(tag) {
+        return this.#native.isField(tag);
+    }
+    /** Whether the spec defines a message with this MsgType (e.g. `'D'`). */
+    isMsgType(msgType) {
+        return this.#native.isMsgType(msgType);
     }
 }
 exports.DataDictionary = DataDictionary;
-//# sourceMappingURL=data-dictionary.js.map

package/dist/cjs/engine.d.ts

@@ -8,6 +8,7 @@ import { EventEmitter } from 'node:events';
 import { type NativeEngineConstructor } from './native.js';
 import { Message } from './message.js';
 import { SessionID } from './session-id.js';
+import { Session } from './session.js';
 import type { ApplicationHandlers } from './application.js';
 import type { SessionSettings } from './session-settings.js';
 /** Options for constructing an {@link Initiator} or {@link Acceptor}. */
@@ -73,7 +74,11 @@ export declare abstract class Engine extends EventEmitter {
      * Stop the engine.
      *
      * Runs off the main thread and resolves once shutdown completes, keeping the
-     * event loop free for any in-flight callbacks.
+     * event loop free for any in-flight callbacks. Once it settles the engine's
+     * sessions are destroyed. A `stop()` called while another is still in flight
+     * (even from a `'logout'` listener that stop fired) returns the same Promise,
+     * so it too settles only once the sessions are gone; the first call's
+     * `force` applies to both.
      *
      * @param force When `true`, aborts immediately instead of draining gracefully.
      *
@@ -83,8 +88,42 @@ export declare abstract class Engine extends EventEmitter {
      * ```
      */
     stop(force?: boolean): Promise<void>;
-    /** Whether any session is currently logged on. */
-    isLoggedOn(): boolean;
+    /**
+     * Whether a session is logged on.
+     *
+     * With no argument: `true` if **any** of this engine's sessions is logged on.
+     * With a {@link SessionID}: `true` only if that session belongs to this engine
+     * and is logged on (`false`, not an error, for a foreign id). Always `false`
+     * before {@link Engine.start} and once {@link Engine.stop} has settled; while
+     * a graceful stop is still in progress it reports the live state.
+     *
+     * @throws {TypeError} if `sessionID` is given but is not a {@link SessionID}
+     *   (it does not fall back to the engine-wide form).
+     */
+    isLoggedOn(sessionID?: SessionID): boolean;
+    /**
+     * The ids of the sessions this engine was configured with (every `[SESSION]`
+     * in its settings). Stable for the engine's lifetime, including after
+     * {@link Engine.stop}.
+     */
+    getSessions(): SessionID[];
+    /**
+     * A handle on one of this engine's sessions.
+     *
+     * @returns The {@link Session}, or `undefined` if `sessionID` is not one of
+     *   this engine's sessions or {@link Engine.stop} has settled (that destroys
+     *   its sessions). While a stop is still in progress the sessions are alive,
+     *   so a `'logout'` listener can still read e.g. the final sequence numbers.
+     *
+     * @example
+     * ```ts
+     * initiator.on('logon', (id) => {
+     *   const session = initiator.getSession(id)!;
+     *   console.log('next seq', session.getExpectedSenderNum());
+     * });
+     * ```
+     */
+    getSession(sessionID: SessionID): Session | undefined;
     /**
      * Keep the Node.js event loop alive while the engine is running (default once
      * started). Pair with {@link Engine.unref} to let a short script exit.
@@ -111,4 +150,3 @@ export interface Engine {
     /** List the listeners registered for an event. */
     listeners<E extends keyof EngineEvents>(event: E): Array<(...args: EngineEvents[E]) => void>;
 }
-//# sourceMappingURL=engine.d.ts.map

package/dist/cjs/engine.js

@@ -10,6 +10,7 @@ exports.Engine = void 0;
 const node_events_1 = require("node:events");
 const message_js_1 = require("./message.js");
 const session_id_js_1 = require("./session-id.js");
+const session_js_1 = require("./session.js");
 /**
  * Base class for the FIX session engines.
  *
@@ -106,7 +107,11 @@ class Engine extends node_events_1.EventEmitter {
      * Stop the engine.
      *
      * Runs off the main thread and resolves once shutdown completes, keeping the
-     * event loop free for any in-flight callbacks.
+     * event loop free for any in-flight callbacks. Once it settles the engine's
+     * sessions are destroyed. A `stop()` called while another is still in flight
+     * (even from a `'logout'` listener that stop fired) returns the same Promise,
+     * so it too settles only once the sessions are gone; the first call's
+     * `force` applies to both.
      *
      * @param force When `true`, aborts immediately instead of draining gracefully.
      *
@@ -118,9 +123,50 @@ class Engine extends node_events_1.EventEmitter {
     stop(force) {
         return this.#native.stop(force);
     }
-    /** Whether any session is currently logged on. */
-    isLoggedOn() {
-        return this.#native.isLoggedOn();
+    /**
+     * Whether a session is logged on.
+     *
+     * With no argument: `true` if **any** of this engine's sessions is logged on.
+     * With a {@link SessionID}: `true` only if that session belongs to this engine
+     * and is logged on (`false`, not an error, for a foreign id). Always `false`
+     * before {@link Engine.start} and once {@link Engine.stop} has settled; while
+     * a graceful stop is still in progress it reports the live state.
+     *
+     * @throws {TypeError} if `sessionID` is given but is not a {@link SessionID}
+     *   (it does not fall back to the engine-wide form).
+     */
+    isLoggedOn(sessionID) {
+        return sessionID === undefined
+            ? this.#native.isLoggedOn()
+            : this.#native.isLoggedOn((0, session_id_js_1.toNativeSessionID)(sessionID, 'sessionID'));
+    }
+    /**
+     * The ids of the sessions this engine was configured with (every `[SESSION]`
+     * in its settings). Stable for the engine's lifetime, including after
+     * {@link Engine.stop}.
+     */
+    getSessions() {
+        return this.#native.getSessions().map((h) => session_id_js_1.SessionID.fromNative(h));
+    }
+    /**
+     * A handle on one of this engine's sessions.
+     *
+     * @returns The {@link Session}, or `undefined` if `sessionID` is not one of
+     *   this engine's sessions or {@link Engine.stop} has settled (that destroys
+     *   its sessions). While a stop is still in progress the sessions are alive,
+     *   so a `'logout'` listener can still read e.g. the final sequence numbers.
+     *
+     * @example
+     * ```ts
+     * initiator.on('logon', (id) => {
+     *   const session = initiator.getSession(id)!;
+     *   console.log('next seq', session.getExpectedSenderNum());
+     * });
+     * ```
+     */
+    getSession(sessionID) {
+        const handle = this.#native.getSession((0, session_id_js_1.toNativeSessionID)(sessionID, 'sessionID'));
+        return handle ? session_js_1.Session.fromNative(handle) : undefined;
     }
     /**
      * Keep the Node.js event loop alive while the engine is running (default once
@@ -135,4 +181,3 @@ class Engine extends node_events_1.EventEmitter {
     }
 }
 exports.Engine = Engine;
-//# sourceMappingURL=engine.js.map

package/dist/cjs/enums.d.ts

@@ -1,22 +1,56 @@
+/**
+ * FIX constants.
+ *
+ * - {@link FIELD} — field-name → tag-number (e.g. `FIELD.MsgType === 35`).
+ *   Generated from QuickFIX's `FixFieldNumbers.h` (see `src/generated/fields.ts`),
+ *   so it carries every `FIX::FIELD::*` name the bundled engine knows.
+ * - value groups such as {@link MsgType} and {@link Side} (e.g.
+ *   `MsgType.Logon === 'A'`, `Side.Buy === '1'`) — one per field, generated from
+ *   QuickFIX's `FixValues.h` (see `src/generated/values.ts`), so every
+ *   `FIX::<Field>_<VALUE>` constant is here. {@link VALUES} holds all of them
+ *   keyed by field name, and each group is also importable from
+ *   `@homaiohq/napi-quickfix/values` without loading the native addon.
+ *
+ * Everything carries literal types and is frozen, so a misspelt name is a
+ * compile error and consumers cannot mutate the shared constant tables.
+ *
+ * @example
+ * ```ts
+ * import { FIELD, MsgType, enums } from '@homaiohq/napi-quickfix';
+ * msg.setField(FIELD.MsgType, MsgType.Logon);
+ * const side = enums.Side.Buy;
+ * ```
+ */
+import { FIELD } from './generated/fields.js';
+import { type ValueGroups } from './generated/values.js';
 export { FIELD, type FieldName } from './generated/fields.js';
-/** A single group of FIX constants (name → value). */
+export { VALUES, MsgType, Side, OrdType, TimeInForce, type ValueGroups, type ValueGroupName, } from './generated/values.js';
+/**
+ * A single group of FIX constants widened to a string-indexed map (name → value).
+ *
+ * Every value group and {@link FIELD} is assignable to it, so use it where a group
+ * is looked up by a `string` key the compiler cannot narrow (a name read from
+ * configuration, say) instead of the literally-typed group itself:
+ *
+ * @example
+ * ```ts
+ * const group: EnumGroup = enums[name as ValueGroupName];
+ * const code = group[valueName];
+ * ```
+ */
 export type EnumGroup = Readonly<Record<string, number | string>>;
-/** The full, frozen tree of FIX constants. */
-export type Enums = Readonly<Record<string, EnumGroup>>;
+/**
+ * The full, frozen tree of FIX constants: every value group of {@link ValueGroups}
+ * plus the {@link FIELD} tag table.
+ */
+export type Enums = ValueGroups & {
+    readonly FIELD: typeof FIELD;
+};
 /**
  * The complete tree of FIX constants (frozen), e.g. `enums.FIELD.MsgType`,
  * `enums.MsgType.Logon`, `enums.Side.Buy`.
  *
- * `enums.FIELD` is the same table as {@link FIELD}; the value groups come from
- * the native engine.
+ * `enums.FIELD` is the same table as {@link FIELD}; every other member is the
+ * same object as the corresponding {@link VALUES} group.
  */
 export declare const enums: Enums;
-/** A group of numeric FIX constants (name → number). */
-export type NumericEnumGroup = Readonly<Record<string, number>>;
-/** A group of string-valued FIX constants (name → string), e.g. {@link MsgType}. */
-export type StringEnumGroup = Readonly<Record<string, string>>;
-/** MsgType values (strings), e.g. `MsgType.Logon === 'A'`. */
-export declare const MsgType: StringEnumGroup;
-/** Side values (strings), e.g. `Side.Buy === '1'`. */
-export declare const Side: StringEnumGroup;
-//# sourceMappingURL=enums.d.ts.map

package/dist/cjs/enums.js

@@ -1,18 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Side = exports.MsgType = exports.enums = exports.FIELD = void 0;
+exports.enums = exports.TimeInForce = exports.OrdType = exports.Side = exports.MsgType = exports.VALUES = exports.FIELD = void 0;
 /**
  * FIX constants.
  *
  * - {@link FIELD} — field-name → tag-number (e.g. `FIELD.MsgType === 35`).
  *   Generated from QuickFIX's `FixFieldNumbers.h` (see `src/generated/fields.ts`),
- *   so it carries every `FIX::FIELD::*` name the bundled engine knows, with
- *   literal types.
- * - value groups exported by the native engine such as {@link MsgType} and
- *   {@link Side} (e.g. `MsgType.Logon === 'A'`, `Side.Buy === '1'`).
+ *   so it carries every `FIX::FIELD::*` name the bundled engine knows.
+ * - value groups such as {@link MsgType} and {@link Side} (e.g.
+ *   `MsgType.Logon === 'A'`, `Side.Buy === '1'`) — one per field, generated from
+ *   QuickFIX's `FixValues.h` (see `src/generated/values.ts`), so every
+ *   `FIX::<Field>_<VALUE>` constant is here. {@link VALUES} holds all of them
+ *   keyed by field name, and each group is also importable from
+ *   `@homaiohq/napi-quickfix/values` without loading the native addon.
  *
- * Everything is frozen at the TS layer so consumers cannot mutate the shared
- * constant tables.
+ * Everything carries literal types and is frozen, so a misspelt name is a
+ * compile error and consumers cannot mutate the shared constant tables.
  *
  * @example
  * ```ts
@@ -22,28 +25,20 @@ exports.Side = exports.MsgType = exports.enums = exports.FIELD = void 0;
  * ```
  */
 const fields_js_1 = require("./generated/fields.js");
-const native_js_1 = require("./native.js");
+const values_js_1 = require("./generated/values.js");
 var fields_js_2 = require("./generated/fields.js");
 Object.defineProperty(exports, "FIELD", { enumerable: true, get: function () { return fields_js_2.FIELD; } });
-function deepFreeze(source) {
-    const out = {};
-    for (const key of Object.keys(source)) {
-        out[key] = Object.freeze({ ...source[key] });
-    }
-    // FIELD is already frozen (generated); reuse it rather than copying 6000+ keys.
-    out.FIELD = fields_js_1.FIELD;
-    return Object.freeze(out);
-}
+var values_js_2 = require("./generated/values.js");
+Object.defineProperty(exports, "VALUES", { enumerable: true, get: function () { return values_js_2.VALUES; } });
+Object.defineProperty(exports, "MsgType", { enumerable: true, get: function () { return values_js_2.MsgType; } });
+Object.defineProperty(exports, "Side", { enumerable: true, get: function () { return values_js_2.Side; } });
+Object.defineProperty(exports, "OrdType", { enumerable: true, get: function () { return values_js_2.OrdType; } });
+Object.defineProperty(exports, "TimeInForce", { enumerable: true, get: function () { return values_js_2.TimeInForce; } });
 /**
  * The complete tree of FIX constants (frozen), e.g. `enums.FIELD.MsgType`,
  * `enums.MsgType.Logon`, `enums.Side.Buy`.
  *
- * `enums.FIELD` is the same table as {@link FIELD}; the value groups come from
- * the native engine.
+ * `enums.FIELD` is the same table as {@link FIELD}; every other member is the
+ * same object as the corresponding {@link VALUES} group.
  */
-exports.enums = deepFreeze((native_js_1.native.enums ?? {}));
-/** MsgType values (strings), e.g. `MsgType.Logon === 'A'`. */
-exports.MsgType = (exports.enums.MsgType ?? Object.freeze({}));
-/** Side values (strings), e.g. `Side.Buy === '1'`. */
-exports.Side = (exports.enums.Side ?? Object.freeze({}));
-//# sourceMappingURL=enums.js.map
+exports.enums = Object.freeze({ ...values_js_1.VALUES, FIELD: fields_js_1.FIELD });

package/dist/cjs/field-value.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wire formatting of the `string | number` field values `Message` and `Group`
+ * accept.
+ */
+/**
+ * A field value as FIX text. Strings pass through. A number keeps its shortest
+ * round-trip digits but is written without exponent notation, which FIX numeric
+ * fields do not allow (`1e-7` → `'0.0000001'`, `1e21` →
+ * `'1000000000000000000000'`, where `String` gives `'1e-7'` and `'1e+21'`).
+ * @throws `RangeError` for `NaN` and `±Infinity`, which have no FIX form.
+ */
+export declare function formatFieldValue(value: string | number): string;

package/dist/cjs/field-value.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Wire formatting of the `string | number` field values `Message` and `Group`
+ * accept.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFieldValue = formatFieldValue;
+/**
+ * A field value as FIX text. Strings pass through. A number keeps its shortest
+ * round-trip digits but is written without exponent notation, which FIX numeric
+ * fields do not allow (`1e-7` → `'0.0000001'`, `1e21` →
+ * `'1000000000000000000000'`, where `String` gives `'1e-7'` and `'1e+21'`).
+ * @throws `RangeError` for `NaN` and `±Infinity`, which have no FIX form.
+ */
+function formatFieldValue(value) {
+    if (typeof value !== 'number') {
+        return String(value);
+    }
+    if (!Number.isFinite(value)) {
+        throw new RangeError(`field value must be a finite number, got ${value}`);
+    }
+    const text = String(value);
+    const e = text.indexOf('e');
+    if (e === -1) {
+        return text;
+    }
+    // `[-]d[.ddd]e±n`: move the decimal point of the mantissa n places.
+    const sign = value < 0 ? '-' : '';
+    const mantissa = text.slice(sign.length, e);
+    const point = mantissa.indexOf('.');
+    const digits = mantissa.replace('.', '');
+    const at = (point === -1 ? mantissa.length : point) + Number(text.slice(e + 1));
+    if (at <= 0) {
+        return `${sign}0.${'0'.repeat(-at)}${digits}`;
+    }
+    if (at >= digits.length) {
+        return `${sign}${digits}${'0'.repeat(at - digits.length)}`;
+    }
+    return `${sign}${digits.slice(0, at)}.${digits.slice(at)}`;
+}

package/dist/cjs/generated/fields.d.ts

@@ -6120,4 +6120,3 @@ export declare const FIELD: Readonly<{
 }>;
 /** Every field name known to the bundled QuickFIX, e.g. `"MsgType"`. */
 export type FieldName = keyof typeof FIELD;
-//# sourceMappingURL=fields.d.ts.map

package/dist/cjs/generated/fields.js

@@ -6125,4 +6125,3 @@ exports.FIELD = Object.freeze({
     BatchTotalMessages: 50001,
     BatchProcessMode: 50002,
 });
-//# sourceMappingURL=fields.js.map