@homaiohq/napi-quickfix 0.1.0 → 0.3.0

package/dist/cjs/session-id.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionID = void 0;
+exports.toNativeSessionID = toNativeSessionID;
 /**
  * Ergonomic wrapper around the native `FIX::SessionID`.
  */
@@ -64,4 +65,23 @@ class SessionID {
     }
 }
 exports.SessionID = SessionID;
-//# sourceMappingURL=session-id.js.map
+/**
+ * @internal The native handle behind a {@link SessionID} argument.
+ *
+ * Duck-typed rather than `instanceof SessionID`: this package ships ESM and
+ * CJS builds, and a `SessionID` created by the other build is a different class
+ * with the same shape. Both builds load the same native addon, so its
+ * `SessionIDWrap` class is the one thing they share, and that is what the
+ * handle is checked against. Anything else -- `null`, `{}`, a `Session` -- is
+ * a `TypeError` naming the argument, rather than silently degrading to an
+ * `undefined` handle that the callee would read as "no session id given".
+ */
+function toNativeSessionID(value, name) {
+    const handle = typeof value === 'object' && value !== null
+        ? value.nativeHandle
+        : undefined;
+    if (!(handle instanceof native_js_1.native.SessionIDWrap)) {
+        throw new TypeError(`${name} must be a SessionID`);
+    }
+    return handle;
+}

package/dist/cjs/session-settings.d.ts

@@ -44,4 +44,3 @@ export declare class SessionSettings {
     /** The sessions declared by this configuration. */
     getSessions(): SessionID[];
 }
-//# sourceMappingURL=session-settings.d.ts.map

package/dist/cjs/session-settings.js

@@ -73,4 +73,3 @@ class SessionSettings {
     }
 }
 exports.SessionSettings = SessionSettings;
-//# sourceMappingURL=session-settings.js.map

package/dist/cjs/session.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Ergonomic wrapper around a live native `FIX::Session`.
+ */
+import { type NativeSession } from './native.js';
+import { SessionID } from './session-id.js';
+/**
+ * A handle on one live FIX session (wraps `FIX::Session`).
+ *
+ * Obtain one with {@link lookupSession} (any session in the process) or
+ * {@link Engine.getSession} (a session of a particular engine); sessions
+ * cannot be constructed directly.
+ *
+ * **Lifetime.** The underlying `FIX::Session` is owned by its engine. This
+ * handle stores only the {@link SessionID} and the identity of the engine it
+ * was obtained from, and re-resolves the session on every call, so it never
+ * dangles: once that engine has been stopped (which destroys its sessions)
+ * every method throws a {@link QuickFixError} whose `fixErrorName` is
+ * `'SessionNotFound'` -- also after a new engine has been created with the
+ * same id. A handle never crosses over to another engine's session; obtain a
+ * new one from the new engine.
+ *
+ * **Everything is synchronous.** State queries, sequence-number access, the
+ * runtime option getters/setters, {@link Session.logon}, {@link Session.logout}
+ * and {@link Session.refresh} never take the mutex QuickFIX holds while running
+ * your application handlers, so they cannot deadlock the main thread, and calls
+ * made in program order take effect in program order. ({@link Session.logon} /
+ * {@link Session.logout} flip a plain flag the engine's network thread reads
+ * without a lock, exactly as QuickFIX's own `Initiator::stop()` does; the
+ * engine picks the change up on its next pass.) QuickFIX's
+ * `Session::disconnect()` / `reset()` are deliberately not exposed: they are
+ * only safe on the engine's own network thread (see ARCHITECTURE.md §5). Use
+ * {@link Session.logout} to bring a session down, and the sequence-number
+ * setters to reset its numbering -- on a quiet session; see
+ * {@link Session.setNextSenderMsgSeqNum}.
+ *
+ * @example
+ * ```ts
+ * const session = initiator.getSession(sessionID)!;
+ * if (session.isLoggedOn()) {
+ *   console.log('next outbound seq', session.getExpectedSenderNum());
+ *   session.logout('maintenance');
+ * }
+ * ```
+ */
+export declare class Session {
+    #private;
+    /** @internal Use {@link lookupSession} / {@link Engine.getSession}. */
+    private constructor();
+    /** @internal Wrap an existing native session handle. */
+    static fromNative(handle: NativeSession): Session;
+    /** @internal The native handle backing this session. */
+    get nativeHandle(): NativeSession;
+    /** The id this handle refers to. Always available, even after the session is gone. */
+    get sessionID(): SessionID;
+    /** `true` once a Logon has been both sent and received. */
+    isLoggedOn(): boolean;
+    /**
+     * Whether the session is enabled. `false` after {@link Session.logout} until
+     * {@link Session.logon}; a disabled initiator session is not reconnected.
+     */
+    isEnabled(): boolean;
+    /** Whether this side has sent a Logon on the current connection. */
+    sentLogon(): boolean;
+    /** Whether this side has sent a Logout on the current connection. */
+    sentLogout(): boolean;
+    /** Whether a Logon has been received on the current connection. */
+    receivedLogon(): boolean;
+    /** `true` for a session owned by an {@link Initiator}. */
+    isInitiator(): boolean;
+    /** `true` for a session owned by an {@link Acceptor}. */
+    isAcceptor(): boolean;
+    /**
+     * Whether `now` (default: the current time) falls inside the session's
+     * configured `StartTime`/`EndTime` window. Throws `RangeError` for an
+     * invalid `Date`.
+     */
+    isSessionTime(now?: Date): boolean;
+    /**
+     * Whether `now` (default: the current time) falls inside the session's
+     * configured `LogonTime`/`LogoutTime` window. Throws `RangeError` for an
+     * invalid `Date`.
+     */
+    isLogonTime(now?: Date): boolean;
+    /** The MsgSeqNum (tag 34) the next outbound message will carry. */
+    getExpectedSenderNum(): number;
+    /** The MsgSeqNum (tag 34) expected on the next inbound message. */
+    getExpectedTargetNum(): number;
+    /**
+     * Set the MsgSeqNum the next outbound message will carry (writes to the
+     * message store; a file store may throw `IOException`).
+     *
+     * **Call it on a quiet session.** The setter is not serialised against a
+     * message the engine is sending or receiving on this session at the same
+     * time: QuickFIX reads the next number into the outbound header, runs your
+     * `toApp`/`toAdmin` handler, then increments from the store, all under a
+     * lock this call does not (and must not) take. A value set inside that
+     * window -- from a handler, or while a {@link sendToTarget} promise or a
+     * heartbeat is in flight on this session -- is overwritten by the increment,
+     * and the session ends up one off from its counterparty (a Resend Request or
+     * a "MsgSeqNum too low" Logout). Set it before {@link Engine.start}, from a
+     * `'logout'` event, or when you know nothing is in flight; never from a
+     * handler.
+     *
+     * @throws `RangeError` if `seqNum` is not a positive safe integer (MsgSeqNum is
+     * 1-based).
+     */
+    setNextSenderMsgSeqNum(seqNum: number): void;
+    /**
+     * Set the MsgSeqNum expected on the next inbound message (writes to the
+     * message store; a file store may throw `IOException`).
+     *
+     * **Call it on a quiet session.** Like {@link Session.setNextSenderMsgSeqNum},
+     * it is not serialised against a message the engine is processing on this
+     * session: QuickFIX checks the inbound number, runs your `fromApp`/`fromAdmin`
+     * handler, then increments the expected number from the store under a lock
+     * this call does not take, so a value set meanwhile is overwritten. Set it
+     * before {@link Engine.start}, from a `'logout'` event, or when you know
+     * nothing is in flight; never from a handler.
+     *
+     * @throws `RangeError` if `seqNum` is not a positive safe integer (MsgSeqNum is
+     * 1-based).
+     */
+    setNextTargetMsgSeqNum(seqNum: number): void;
+    /** `ResetOnLogon` */
+    getResetOnLogon(): boolean;
+    setResetOnLogon(value: boolean): void;
+    /** `ResetOnLogout` */
+    getResetOnLogout(): boolean;
+    setResetOnLogout(value: boolean): void;
+    /** `ResetOnDisconnect` */
+    getResetOnDisconnect(): boolean;
+    setResetOnDisconnect(value: boolean): void;
+    /** `RefreshOnLogon` */
+    getRefreshOnLogon(): boolean;
+    setRefreshOnLogon(value: boolean): void;
+    /** `CheckCompID` */
+    getCheckCompId(): boolean;
+    setCheckCompId(value: boolean): void;
+    /** `CheckLatency` */
+    getCheckLatency(): boolean;
+    setCheckLatency(value: boolean): void;
+    /** `PersistMessages` */
+    getPersistMessages(): boolean;
+    setPersistMessages(value: boolean): void;
+    /** `SendRedundantResendRequests` */
+    getSendRedundantResendRequests(): boolean;
+    setSendRedundantResendRequests(value: boolean): void;
+    /** `ValidateLengthAndChecksum` */
+    getValidateLengthAndChecksum(): boolean;
+    setValidateLengthAndChecksum(value: boolean): void;
+    /** `SendNextExpectedMsgSeqNum` */
+    getSendNextExpectedMsgSeqNum(): boolean;
+    setSendNextExpectedMsgSeqNum(value: boolean): void;
+    /** `NonStopSession` */
+    getIsNonStopSession(): boolean;
+    setIsNonStopSession(value: boolean): void;
+    /** `LogonTimeout`, in seconds. */
+    getLogonTimeout(): number;
+    /** @throws {RangeError} if `seconds` is not an integer in the int32 range. */
+    setLogonTimeout(seconds: number): void;
+    /** `LogoutTimeout`, in seconds. */
+    getLogoutTimeout(): number;
+    /** @throws {RangeError} if `seconds` is not an integer in the int32 range. */
+    setLogoutTimeout(seconds: number): void;
+    /** `MaxLatency`, in seconds. */
+    getMaxLatency(): number;
+    /** @throws {RangeError} if `seconds` is not an integer in the int32 range. */
+    setMaxLatency(seconds: number): void;
+    /** `TimestampPrecision` (number of sub-second digits, `0..9`). */
+    getTimestampPrecision(): number;
+    /** @throws `RangeError` unless `precision` is an integer in `0..9`. */
+    setTimestampPrecision(precision: number): void;
+    /**
+     * Enable the session. An initiator session reconnects and logs on at its
+     * next `ReconnectInterval`; an acceptor session accepts the next inbound
+     * Logon. Takes effect immediately ({@link Session.isEnabled} is `true` on
+     * return); observe the handshake through the engine's `'logon'` event.
+     */
+    logon(): void;
+    /**
+     * Disable the session and initiate a graceful Logout (sent with `reason` as
+     * tag 58 on the next engine tick). The session stays disabled — it will not
+     * reconnect — until {@link Session.logon}. Takes effect immediately
+     * ({@link Session.isEnabled} is `false` on return); observe completion
+     * through the engine's `'logout'` event.
+     */
+    logout(reason?: string): void;
+    /**
+     * Re-read the session state (sequence numbers etc.) from the message store.
+     *
+     * @throws {QuickFixError} `IOException` if the store cannot be read.
+     */
+    refresh(): void;
+}
+/**
+ * Look up a live session by id, across every engine in this process.
+ *
+ * @returns The {@link Session}, or `undefined` if no session with that id
+ *   exists (never created, or its engine has been stopped).
+ *
+ * @example
+ * ```ts
+ * const session = lookupSession(new SessionID('FIX.4.4', 'CLIENT', 'BROKER'));
+ * console.log(session?.isLoggedOn());
+ * ```
+ */
+export declare function lookupSession(sessionID: SessionID): Session | undefined;
+/** Whether a session with this id exists in this process. */
+export declare function doesSessionExist(sessionID: SessionID): boolean;
+/** The ids of every session in this process, across all engines. */
+export declare function getSessions(): SessionID[];
+/** The number of sessions in this process, across all engines. */
+export declare function numSessions(): number;

package/dist/cjs/session.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Session = void 0;
+exports.lookupSession = lookupSession;
+exports.doesSessionExist = doesSessionExist;
+exports.getSessions = getSessions;
+exports.numSessions = numSessions;
+/**
+ * Ergonomic wrapper around a live native `FIX::Session`.
+ */
+const native_js_1 = require("./native.js");
+const session_id_js_1 = require("./session-id.js");
+/**
+ * A handle on one live FIX session (wraps `FIX::Session`).
+ *
+ * Obtain one with {@link lookupSession} (any session in the process) or
+ * {@link Engine.getSession} (a session of a particular engine); sessions
+ * cannot be constructed directly.
+ *
+ * **Lifetime.** The underlying `FIX::Session` is owned by its engine. This
+ * handle stores only the {@link SessionID} and the identity of the engine it
+ * was obtained from, and re-resolves the session on every call, so it never
+ * dangles: once that engine has been stopped (which destroys its sessions)
+ * every method throws a {@link QuickFixError} whose `fixErrorName` is
+ * `'SessionNotFound'` -- also after a new engine has been created with the
+ * same id. A handle never crosses over to another engine's session; obtain a
+ * new one from the new engine.
+ *
+ * **Everything is synchronous.** State queries, sequence-number access, the
+ * runtime option getters/setters, {@link Session.logon}, {@link Session.logout}
+ * and {@link Session.refresh} never take the mutex QuickFIX holds while running
+ * your application handlers, so they cannot deadlock the main thread, and calls
+ * made in program order take effect in program order. ({@link Session.logon} /
+ * {@link Session.logout} flip a plain flag the engine's network thread reads
+ * without a lock, exactly as QuickFIX's own `Initiator::stop()` does; the
+ * engine picks the change up on its next pass.) QuickFIX's
+ * `Session::disconnect()` / `reset()` are deliberately not exposed: they are
+ * only safe on the engine's own network thread (see ARCHITECTURE.md §5). Use
+ * {@link Session.logout} to bring a session down, and the sequence-number
+ * setters to reset its numbering -- on a quiet session; see
+ * {@link Session.setNextSenderMsgSeqNum}.
+ *
+ * @example
+ * ```ts
+ * const session = initiator.getSession(sessionID)!;
+ * if (session.isLoggedOn()) {
+ *   console.log('next outbound seq', session.getExpectedSenderNum());
+ *   session.logout('maintenance');
+ * }
+ * ```
+ */
+class Session {
+    /** @internal Underlying native handle. */
+    #native;
+    /** @internal Use {@link lookupSession} / {@link Engine.getSession}. */
+    constructor(handle) {
+        this.#native = handle;
+    }
+    /** @internal Wrap an existing native session handle. */
+    static fromNative(handle) {
+        return new Session(handle);
+    }
+    /** @internal The native handle backing this session. */
+    get nativeHandle() {
+        return this.#native;
+    }
+    /** The id this handle refers to. Always available, even after the session is gone. */
+    get sessionID() {
+        return session_id_js_1.SessionID.fromNative(this.#native.getSessionID());
+    }
+    // --- state -----------------------------------------------------------------
+    /** `true` once a Logon has been both sent and received. */
+    isLoggedOn() {
+        return this.#native.isLoggedOn();
+    }
+    /**
+     * Whether the session is enabled. `false` after {@link Session.logout} until
+     * {@link Session.logon}; a disabled initiator session is not reconnected.
+     */
+    isEnabled() {
+        return this.#native.isEnabled();
+    }
+    /** Whether this side has sent a Logon on the current connection. */
+    sentLogon() {
+        return this.#native.sentLogon();
+    }
+    /** Whether this side has sent a Logout on the current connection. */
+    sentLogout() {
+        return this.#native.sentLogout();
+    }
+    /** Whether a Logon has been received on the current connection. */
+    receivedLogon() {
+        return this.#native.receivedLogon();
+    }
+    /** `true` for a session owned by an {@link Initiator}. */
+    isInitiator() {
+        return this.#native.isInitiator();
+    }
+    /** `true` for a session owned by an {@link Acceptor}. */
+    isAcceptor() {
+        return this.#native.isAcceptor();
+    }
+    /**
+     * Whether `now` (default: the current time) falls inside the session's
+     * configured `StartTime`/`EndTime` window. Throws `RangeError` for an
+     * invalid `Date`.
+     */
+    isSessionTime(now) {
+        return this.#native.isSessionTime(now?.getTime());
+    }
+    /**
+     * Whether `now` (default: the current time) falls inside the session's
+     * configured `LogonTime`/`LogoutTime` window. Throws `RangeError` for an
+     * invalid `Date`.
+     */
+    isLogonTime(now) {
+        return this.#native.isLogonTime(now?.getTime());
+    }
+    // --- sequence numbers --------------------------------------------------------
+    /** The MsgSeqNum (tag 34) the next outbound message will carry. */
+    getExpectedSenderNum() {
+        return this.#native.getExpectedSenderNum();
+    }
+    /** The MsgSeqNum (tag 34) expected on the next inbound message. */
+    getExpectedTargetNum() {
+        return this.#native.getExpectedTargetNum();
+    }
+    /**
+     * Set the MsgSeqNum the next outbound message will carry (writes to the
+     * message store; a file store may throw `IOException`).
+     *
+     * **Call it on a quiet session.** The setter is not serialised against a
+     * message the engine is sending or receiving on this session at the same
+     * time: QuickFIX reads the next number into the outbound header, runs your
+     * `toApp`/`toAdmin` handler, then increments from the store, all under a
+     * lock this call does not (and must not) take. A value set inside that
+     * window -- from a handler, or while a {@link sendToTarget} promise or a
+     * heartbeat is in flight on this session -- is overwritten by the increment,
+     * and the session ends up one off from its counterparty (a Resend Request or
+     * a "MsgSeqNum too low" Logout). Set it before {@link Engine.start}, from a
+     * `'logout'` event, or when you know nothing is in flight; never from a
+     * handler.
+     *
+     * @throws `RangeError` if `seqNum` is not a positive safe integer (MsgSeqNum is
+     * 1-based).
+     */
+    setNextSenderMsgSeqNum(seqNum) {
+        this.#native.setNextSenderMsgSeqNum(seqNum);
+    }
+    /**
+     * Set the MsgSeqNum expected on the next inbound message (writes to the
+     * message store; a file store may throw `IOException`).
+     *
+     * **Call it on a quiet session.** Like {@link Session.setNextSenderMsgSeqNum},
+     * it is not serialised against a message the engine is processing on this
+     * session: QuickFIX checks the inbound number, runs your `fromApp`/`fromAdmin`
+     * handler, then increments the expected number from the store under a lock
+     * this call does not take, so a value set meanwhile is overwritten. Set it
+     * before {@link Engine.start}, from a `'logout'` event, or when you know
+     * nothing is in flight; never from a handler.
+     *
+     * @throws `RangeError` if `seqNum` is not a positive safe integer (MsgSeqNum is
+     * 1-based).
+     */
+    setNextTargetMsgSeqNum(seqNum) {
+        this.#native.setNextTargetMsgSeqNum(seqNum);
+    }
+    // --- runtime options -----------------------------------------------------------
+    // Each pair mirrors a QuickFIX session setting; the setter changes the LIVE
+    // session only (the SessionSettings it was created from are not updated).
+    /** `ResetOnLogon` */
+    getResetOnLogon() {
+        return this.#native.getResetOnLogon();
+    }
+    setResetOnLogon(value) {
+        this.#native.setResetOnLogon(value);
+    }
+    /** `ResetOnLogout` */
+    getResetOnLogout() {
+        return this.#native.getResetOnLogout();
+    }
+    setResetOnLogout(value) {
+        this.#native.setResetOnLogout(value);
+    }
+    /** `ResetOnDisconnect` */
+    getResetOnDisconnect() {
+        return this.#native.getResetOnDisconnect();
+    }
+    setResetOnDisconnect(value) {
+        this.#native.setResetOnDisconnect(value);
+    }
+    /** `RefreshOnLogon` */
+    getRefreshOnLogon() {
+        return this.#native.getRefreshOnLogon();
+    }
+    setRefreshOnLogon(value) {
+        this.#native.setRefreshOnLogon(value);
+    }
+    /** `CheckCompID` */
+    getCheckCompId() {
+        return this.#native.getCheckCompId();
+    }
+    setCheckCompId(value) {
+        this.#native.setCheckCompId(value);
+    }
+    /** `CheckLatency` */
+    getCheckLatency() {
+        return this.#native.getCheckLatency();
+    }
+    setCheckLatency(value) {
+        this.#native.setCheckLatency(value);
+    }
+    /** `PersistMessages` */
+    getPersistMessages() {
+        return this.#native.getPersistMessages();
+    }
+    setPersistMessages(value) {
+        this.#native.setPersistMessages(value);
+    }
+    /** `SendRedundantResendRequests` */
+    getSendRedundantResendRequests() {
+        return this.#native.getSendRedundantResendRequests();
+    }
+    setSendRedundantResendRequests(value) {
+        this.#native.setSendRedundantResendRequests(value);
+    }
+    /** `ValidateLengthAndChecksum` */
+    getValidateLengthAndChecksum() {
+        return this.#native.getValidateLengthAndChecksum();
+    }
+    setValidateLengthAndChecksum(value) {
+        this.#native.setValidateLengthAndChecksum(value);
+    }
+    /** `SendNextExpectedMsgSeqNum` */
+    getSendNextExpectedMsgSeqNum() {
+        return this.#native.getSendNextExpectedMsgSeqNum();
+    }
+    setSendNextExpectedMsgSeqNum(value) {
+        this.#native.setSendNextExpectedMsgSeqNum(value);
+    }
+    /** `NonStopSession` */
+    getIsNonStopSession() {
+        return this.#native.getIsNonStopSession();
+    }
+    setIsNonStopSession(value) {
+        this.#native.setIsNonStopSession(value);
+    }
+    /** `LogonTimeout`, in seconds. */
+    getLogonTimeout() {
+        return this.#native.getLogonTimeout();
+    }
+    /** @throws {RangeError} if `seconds` is not an integer in the int32 range. */
+    setLogonTimeout(seconds) {
+        this.#native.setLogonTimeout(seconds);
+    }
+    /** `LogoutTimeout`, in seconds. */
+    getLogoutTimeout() {
+        return this.#native.getLogoutTimeout();
+    }
+    /** @throws {RangeError} if `seconds` is not an integer in the int32 range. */
+    setLogoutTimeout(seconds) {
+        this.#native.setLogoutTimeout(seconds);
+    }
+    /** `MaxLatency`, in seconds. */
+    getMaxLatency() {
+        return this.#native.getMaxLatency();
+    }
+    /** @throws {RangeError} if `seconds` is not an integer in the int32 range. */
+    setMaxLatency(seconds) {
+        this.#native.setMaxLatency(seconds);
+    }
+    /** `TimestampPrecision` (number of sub-second digits, `0..9`). */
+    getTimestampPrecision() {
+        return this.#native.getTimestampPrecision();
+    }
+    /** @throws `RangeError` unless `precision` is an integer in `0..9`. */
+    setTimestampPrecision(precision) {
+        this.#native.setTimestampPrecision(precision);
+    }
+    // --- control -----------------------------------------------------------------------
+    /**
+     * Enable the session. An initiator session reconnects and logs on at its
+     * next `ReconnectInterval`; an acceptor session accepts the next inbound
+     * Logon. Takes effect immediately ({@link Session.isEnabled} is `true` on
+     * return); observe the handshake through the engine's `'logon'` event.
+     */
+    logon() {
+        this.#native.logon();
+    }
+    /**
+     * Disable the session and initiate a graceful Logout (sent with `reason` as
+     * tag 58 on the next engine tick). The session stays disabled — it will not
+     * reconnect — until {@link Session.logon}. Takes effect immediately
+     * ({@link Session.isEnabled} is `false` on return); observe completion
+     * through the engine's `'logout'` event.
+     */
+    logout(reason) {
+        this.#native.logout(reason);
+    }
+    /**
+     * Re-read the session state (sequence numbers etc.) from the message store.
+     *
+     * @throws {QuickFixError} `IOException` if the store cannot be read.
+     */
+    refresh() {
+        this.#native.refresh();
+    }
+}
+exports.Session = Session;
+/**
+ * Look up a live session by id, across every engine in this process.
+ *
+ * @returns The {@link Session}, or `undefined` if no session with that id
+ *   exists (never created, or its engine has been stopped).
+ *
+ * @example
+ * ```ts
+ * const session = lookupSession(new SessionID('FIX.4.4', 'CLIENT', 'BROKER'));
+ * console.log(session?.isLoggedOn());
+ * ```
+ */
+function lookupSession(sessionID) {
+    const handle = native_js_1.native.lookupSession((0, session_id_js_1.toNativeSessionID)(sessionID, 'sessionID'));
+    return handle ? Session.fromNative(handle) : undefined;
+}
+/** Whether a session with this id exists in this process. */
+function doesSessionExist(sessionID) {
+    return native_js_1.native.doesSessionExist((0, session_id_js_1.toNativeSessionID)(sessionID, 'sessionID'));
+}
+/** The ids of every session in this process, across all engines. */
+function getSessions() {
+    return native_js_1.native.getSessions().map((h) => session_id_js_1.SessionID.fromNative(h));
+}
+/** The number of sessions in this process, across all engines. */
+function numSessions() {
+    return native_js_1.native.numSessions();
+}