javonet-nodejs-sdk 2.6.10 → 2.6.11

package/dist/core/handler/Handler.cjs

@@ -131,31 +131,33 @@ const handlers = {
   [import_CommandType.CommandType.ValueForUpdate]: new import_ValueForUpdateHandler.ValueForUpdateHandler()
 };
 class Handler {
+  static _initialized = false;
   /**
-   * @param {import('../interpreter/Interpreter.js').Interpreter} interpreter
+   * Initializes the handlers map. This is called lazily on first use.
    */
-  constructor(interpreter) {
-    this.interpreter = interpreter;
-    if (!this.interpreter) {
-      throw new Error("interpreter is undefined in Handler constructor");
+  static _initialize() {
+    if (Handler._initialized) {
+      return;
     }
-    handlers[import_CommandType.CommandType.PassDelegate] = new import_PassDelegateHandler.PassDelegateHandler(this.interpreter);
+    handlers[import_CommandType.CommandType.PassDelegate] = new import_PassDelegateHandler.PassDelegateHandler();
     Object.keys(handlers).forEach((commandTypeHandler) => {
       handlers[commandTypeHandler].handlers = handlers;
     });
+    Handler._initialized = true;
   }
   /**
    * @param {Command} command
    * @returns {Promise<Command> | Command}
    */
-  handleCommand(command) {
+  static handleCommand(command) {
+    Handler._initialize();
     try {
       if (command.commandType === import_CommandType.CommandType.RetrieveArray) {
         const responseArray = handlers[import_CommandType.CommandType.Reference].handleCommand(command.payload[0]);
         return import_Command.Command.createArrayResponse(responseArray, command.runtimeName);
       }
       const response = handlers[command.commandType].handleCommand(command);
-      return this.parseCommand(response, command.runtimeName);
+      return Handler.parseCommand(response, command.runtimeName);
     } catch (e) {
       return Handler.resolveException(e, command);
     }
@@ -175,10 +177,10 @@ class Handler {
    * @param {RuntimeName} runtimeName
    * @returns {Promise<Command> | Command}
    */
-  parseCommand(response, runtimeName) {
+  static parseCommand(response, runtimeName) {
     if (response instanceof Promise) {
       return response.then((resolvedResponse) => {
-        return this.parseCommand(resolvedResponse, runtimeName);
+        return Handler.parseCommand(resolvedResponse, runtimeName);
       });
     }
     let responseCommand;

package/dist/core/handler/PassDelegateHandler.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var PassDelegateHandler_exports = {};
 __export(PassDelegateHandler_exports, {
@@ -26,12 +36,9 @@ var import_InMemoryConnectionData = require("../../utils/connectionData/InMemory
 var import_DelegatesCache = require("../delegatesCache/DelegatesCache.cjs");
 var import_AbstractHandler = require("./AbstractHandler.cjs");
 class PassDelegateHandler extends import_AbstractHandler.AbstractHandler {
-  /** @type {Interpreter | null | undefined} */
-  interpreter = null;
-  constructor(interpreter = null) {
+  constructor() {
     super();
     this.requiredParametersCount = 1;
-    this.interpreter = interpreter;
   }
   /**S
    * Processes the given command to create and compile a delegate.
@@ -113,7 +120,8 @@ class PassDelegateHandler extends import_AbstractHandler.AbstractHandler {
    * @returns {Promise<any>} The response object.
    */
   async createExecuteCall(command) {
-    return this.interpreter?.execute(command, new import_InMemoryConnectionData.InMemoryConnectionData());
+    const { Interpreter } = await import("../interpreter/Interpreter.js");
+    return Interpreter.execute(command, new import_InMemoryConnectionData.InMemoryConnectionData());
   }
   /**
    * Retrieves the response payload from the execution call.

package/dist/core/interpreter/Interpreter.cjs

@@ -35,24 +35,15 @@ let _Transmitter;
 let _TransmitterWebsocket = (0, import_Runtime.isNodejsRuntime)() ? import_TransmitterWebsocket.TransmitterWebsocket : import_TransmitterWebsocketBrowser.TransmitterWebsocketBrowser;
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class Interpreter {
-  /** @type {Handler | null} */
-  _handler = null;
-  /** @type {Handler} */
-  get handler() {
-    if (!this._handler) {
-      this._handler = new import_Handler.Handler(this);
-    }
-    return this._handler;
-  }
   /**
    *
    * @param {Command} command
    * @param {IConnectionData} connectionData
    * @returns {Promise<Command>}
    */
-  async execute(command, connectionData) {
+  static async execute(command, connectionData) {
     try {
-      let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
+      let messageByteArray = import_CommandSerializer.CommandSerializer.serialize(command, connectionData);
       if (!(messageByteArray instanceof Uint8Array)) {
         throw new Error("Serialized message is not Uint8Array");
       }
@@ -96,10 +87,10 @@ class Interpreter {
    * @param {Uint8Array} messageByteArray
    * @returns {Promise<Command> | Command}
    */
-  process(messageByteArray) {
+  static process(messageByteArray) {
     try {
       const receivedCommand = new import_CommandDeserializer.CommandDeserializer(messageByteArray).deserialize();
-      return this.handler?.handleCommand(receivedCommand);
+      return import_Handler.Handler.handleCommand(receivedCommand);
     } catch (error) {
       throw error;
     }

package/dist/core/protocol/CommandDeserializer.cjs

@@ -73,7 +73,7 @@ class CommandDeserializer {
       case "JAVONET_DOUBLE":
         return this.readDouble();
       case "JAVONET_UNSIGNED_LONG_LONG":
-        return this.readUllong;
+        return this.readUllong();
       case "JAVONET_UNSIGNED_INTEGER":
         return this.readUInt();
       case "JAVONET_NULL":

package/dist/core/protocol/CommandSerializer.cjs

@@ -35,7 +35,7 @@ class CommandSerializer {
    * @param {number} runtimeVersion
    * @returns {Uint8Array}
    */
-  serialize(rootCommand, connectionData, runtimeVersion = 0) {
+  static serialize(rootCommand, connectionData, runtimeVersion = 0) {
     const buffers = [];
     buffers.push(Uint8Array.of(rootCommand.runtimeName, runtimeVersion));
     if (connectionData) {
@@ -44,7 +44,7 @@ class CommandSerializer {
       buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0));
     }
     buffers.push(Uint8Array.of(import_RuntimeName.RuntimeName.Python, rootCommand.commandType));
-    this.serializeRecursively(rootCommand, buffers);
+    CommandSerializer.serializeRecursively(rootCommand, buffers);
     return concatenateUint8Arrays(buffers);
   }
   /**
@@ -52,18 +52,18 @@ class CommandSerializer {
    * @param {Command} command
    * @param {Array<Uint8Array>} buffers
    */
-  serializeRecursively(command, buffers) {
+  static serializeRecursively(command, buffers) {
     for (const item of command.payload) {
       if (item instanceof import_Command.Command) {
         buffers.push(import_TypeSerializer.TypeSerializer.serializeCommand(item));
-        this.serializeRecursively(item, buffers);
+        CommandSerializer.serializeRecursively(item, buffers);
       } else if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(item)) {
         buffers.push(import_TypeSerializer.TypeSerializer.serializePrimitive(item));
       } else {
         const cachedReference = import_ReferencesCache.ReferencesCache.getInstance().cacheReference(item);
         const refCommand = new import_Command.Command(import_RuntimeName.RuntimeName.Nodejs, import_CommandType.CommandType.Reference, cachedReference);
         buffers.push(import_TypeSerializer.TypeSerializer.serializeCommand(refCommand));
-        this.serializeRecursively(refCommand, buffers);
+        CommandSerializer.serializeRecursively(refCommand, buffers);
       }
     }
   }

package/dist/core/receiver/Receiver.cjs

@@ -21,19 +21,16 @@ __export(Receiver_exports, {
   Receiver: () => Receiver
 });
 module.exports = __toCommonJS(Receiver_exports);
-var import_Interpreter = require("../interpreter/Interpreter.cjs");
 var import_CommandSerializer = require("../protocol/CommandSerializer.cjs");
-var import_Runtime = require("../../utils/Runtime.cjs");
 var import_InMemoryConnectionData = require("../../utils/connectionData/InMemoryConnectionData.cjs");
 var import_ExceptionSerializer = require("../../utils/exception/ExceptionSerializer.cjs");
 var import_Command = require("../../utils/Command.cjs");
 var import_CommandType = require("../../utils/CommandType.cjs");
 var import_RuntimeName = require("../../utils/RuntimeName.cjs");
 var import_RuntimeLogger = require("../../utils/RuntimeLogger.cjs");
+var import_Interpreter = require("./../interpreter/Interpreter.cjs");
 class Receiver {
   static connectionData = new import_InMemoryConnectionData.InMemoryConnectionData();
-  Receiver() {
-  }
   static getRuntimeInfo() {
     return import_RuntimeLogger.RuntimeLogger.getRuntimeInfo();
   }
@@ -43,14 +40,14 @@ class Receiver {
    */
   static async sendCommand(messageByteArray) {
     try {
-      let command = await new import_Interpreter.Interpreter().process(messageByteArray);
-      return new import_CommandSerializer.CommandSerializer().serialize(command, this.connectionData);
+      let command = await import_Interpreter.Interpreter.process(messageByteArray);
+      return import_CommandSerializer.CommandSerializer.serialize(command, this.connectionData);
     } catch (error) {
       const exceptionCommand = import_ExceptionSerializer.ExceptionSerializer.serializeException(
         error,
         new import_Command.Command(import_RuntimeName.RuntimeName.Nodejs, import_CommandType.CommandType.Exception, [])
       );
-      return new import_CommandSerializer.CommandSerializer().serialize(exceptionCommand, this.connectionData);
+      return import_CommandSerializer.CommandSerializer.serialize(exceptionCommand, this.connectionData);
     }
   }
   /**

package/dist/sdk/InvocationContext.cjs

@@ -52,14 +52,13 @@ class InvocationContext {
   #responseCommand = null;
   /** @type {boolean} */
   #isExecuted = false;
-  /** @type {Interpreter | null} */
-  #interpreter = null;
   /** @type {string | null} */
   #guid = null;
   /** @type {AsyncLock} */
   #materializationLock = new AsyncLock();
   // Static map holding contexts waiting for materialization (guid -> InvocationContext)
   static _invocationContexts = /* @__PURE__ */ new Map();
+  //
   /**
    *
    * @param {RuntimeNameType} runtimeName
@@ -73,7 +72,6 @@ class InvocationContext {
     this.#currentCommand = command;
     this.#responseCommand = null;
     this.#isExecuted = isExecuted;
-    this.#interpreter = null;
     this.#guid = (0, import_uuid.v4)();
   }
   /**
@@ -134,9 +132,6 @@ class InvocationContext {
     if (this.#currentCommand === null) {
       throw new Error("currentCommand is undefined in Invocation Context execute method");
     }
-    if (!this.#interpreter) {
-      this.#interpreter = new import_Interpreter.Interpreter();
-    }
     const entries = Array.from(InvocationContext._invocationContexts.entries());
     entries.sort((a, b) => String(a[0]).localeCompare(String(b[0])));
     const releases = [];
@@ -145,7 +140,10 @@ class InvocationContext {
       releases.push(release);
     }
     try {
-      this.#responseCommand = await this.#interpreter.execute(this.#currentCommand, this.#connectionData);
+      this.#responseCommand = await import_Interpreter.Interpreter.execute(
+        this.#currentCommand,
+        this.#connectionData
+      );
       if (!this.#responseCommand) {
         throw new Error("responseCommand is undefined in Invocation Context execute method");
       }

package/dist/sdk/Javonet.cjs

@@ -23,6 +23,7 @@ __export(Javonet_exports, {
   ComplexTypeResolver: () => import_ComplexTypeResolver.ComplexTypeResolver,
   ConfigPriority: () => import_ConfigPriority.ConfigPriority,
   Javonet: () => Javonet,
+  RuntimeContext: () => import_RuntimeContext.RuntimeContext,
   TcpConnectionData: () => import_TcpConnectionData.TcpConnectionData,
   WsConnectionData: () => import_WsConnectionData.WsConnectionData
 });
@@ -129,7 +130,7 @@ class Javonet {
    */
   static initializeRc(configName) {
     const config = import_ConfigSourceResolver.ConfigSourceResolver.getConfig(configName);
-    return import_RuntimeFactory.RuntimeFactory.initializeRuntimeContext(config);
+    return import_RuntimeContext.RuntimeContext.initializeRuntimeContext(config);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -139,6 +140,7 @@ class Javonet {
   ComplexTypeResolver,
   ConfigPriority,
   Javonet,
+  RuntimeContext,
   TcpConnectionData,
   WsConnectionData
 });

package/dist/sdk/RuntimeContext.cjs

@@ -31,6 +31,7 @@ var import_Interpreter = require("../core/interpreter/Interpreter.cjs");
 var import_DelegatesCache = require("../core/delegatesCache/DelegatesCache.cjs");
 var import_TypesHandler = require("../utils/TypesHandler.cjs");
 var import_UtilsConst = require("../utils/UtilsConst.cjs");
+var import_Config = require("./configuration/Config.cjs");
 var import_Runtime = require("../utils/Runtime.cjs");
 const import_meta = {};
 let _Transmitter = null;
@@ -46,8 +47,6 @@ class RuntimeContext {
   #currentCommand = null;
   /** @type {Command | null} */
   #responseCommand = null;
-  /** @type {Interpreter | null} */
-  #interpreter = null;
   /**
    * @param {RuntimeNameType} runtimeName
    * @param {IConnectionData} connectionData
@@ -56,7 +55,6 @@ class RuntimeContext {
     this._isExecuted = false;
     this.runtimeName = runtimeName;
     this.connectionData = connectionData;
-    this.#interpreter = new import_Interpreter.Interpreter();
     if (this.connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
       return;
     }
@@ -69,6 +67,28 @@ class RuntimeContext {
     }
     _Transmitter?.activate(import_UtilsConst.UtilsConst.getLicenseKey());
   }
+  /**
+   * @param {Config} config
+   * @returns {RuntimeContext}
+   */
+  static initializeRuntimeContext(config) {
+    const rtmCtx = RuntimeContext.getInstance(config.runtime, config.connectionData);
+    if (config.connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
+      const modules = (config.modules || "").split(",").map((m) => m.trim()).filter((m) => m !== "");
+      let pathModule = null;
+      try {
+        const _require = typeof require !== "undefined" ? require : eval("require");
+        pathModule = _require("path");
+      } catch (e) {
+        pathModule = null;
+      }
+      modules.forEach((module2) => {
+        const fullPath = pathModule ? pathModule.resolve(module2) : module2;
+        rtmCtx.loadLibrary(fullPath);
+      });
+    }
+    return rtmCtx;
+  }
   /**
    * @param {RuntimeNameType} runtimeName
    * @param {IConnectionData} connectionData
@@ -140,7 +160,10 @@ class RuntimeContext {
    * @method
    */
   async execute() {
-    this.#responseCommand = await this.#interpreter?.execute(this.#currentCommand, this.connectionData);
+    if (!this.#currentCommand) {
+      throw new Error("currentCommand is undefined in Runtime Context execute method");
+    }
+    this.#responseCommand = await import_Interpreter.Interpreter.execute(this.#currentCommand, this.connectionData);
     this.#currentCommand = null;
     if (this.#responseCommand === void 0) {
       throw new Error("responseCommand is undefined in Runtime Context execute method");
@@ -225,7 +248,7 @@ class RuntimeContext {
    * After creating the reference, it can be used as an argument when invoking methods.
    * @param {...any} args - The value and optionally the type of the reference.
    * @returns {InvocationContext} InvocationContext instance that wraps the command to create a reference as out.
-   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-out-keyword |Passing Arguments by Reference with out Keyword Guide)
+   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-out-keyword |Passing Arguments by Reference with 'out' Keyword Guide)
    * @method
    */
   asOut(...args) {
@@ -234,7 +257,7 @@ class RuntimeContext {
     return new import_InvocationContext.InvocationContext(this.runtimeName, this.connectionData, this.#buildCommand(localCommand));
   }
   /**
-   * Retrieves the value of an global field from the target runtime.
+   * Retrieves the value of a global field from the target runtime.
    * @param {string} fieldName - The name of the field to get.
    * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the global field.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/fields-and-properties/getting-values-for-global-fields)
@@ -308,11 +331,6 @@ class RuntimeContext {
       );
     }
   }
-  healthCheck() {
-    let localCommand = new import_Command.Command(this.runtimeName, import_CommandType.CommandType.Value, ["health_check"]);
-    this.#currentCommand = this.#buildCommand(localCommand);
-    this.execute();
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/sdk/RuntimeFactory.cjs

@@ -23,7 +23,6 @@ __export(RuntimeFactory_exports, {
 module.exports = __toCommonJS(RuntimeFactory_exports);
 var import_RuntimeName = require("../utils/RuntimeName.cjs");
 var import_RuntimeContext = require("./RuntimeContext.cjs");
-var import_ConnectionType = require("../utils/ConnectionType.cjs");
 class RuntimeFactory {
   /**
    * @param {IConnectionData} connectionData
@@ -103,27 +102,6 @@ class RuntimeFactory {
   python27() {
     return import_RuntimeContext.RuntimeContext.getInstance(import_RuntimeName.RuntimeName.Python27, this.connectionData);
   }
-  /**
-   * @param {{ runtime: import("../types.js").RuntimeName; connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData; modules: string; }} config
-   */
-  static initializeRuntimeContext(config) {
-    const rtmCtx = import_RuntimeContext.RuntimeContext.getInstance(config.runtime, config.connectionData);
-    if (config.connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
-      const modules = (config.modules || "").split(",").map((m) => m.trim()).filter((m) => m !== "");
-      let pathModule = null;
-      try {
-        const _require = typeof require !== "undefined" ? require : eval("require");
-        pathModule = _require("path");
-      } catch (e) {
-        pathModule = null;
-      }
-      modules.forEach((module2) => {
-        const fullPath = pathModule ? pathModule.resolve(module2) : module2;
-        rtmCtx.loadLibrary(fullPath);
-      });
-    }
-    return rtmCtx;
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/types/core/handler/Handler.d.ts

@@ -1,28 +1,28 @@
 export type RuntimeName = import("../../types.d.ts").RuntimeName;
 export class Handler {
+    static _initialized: boolean;
     /**
-     * Prefer innerException (or cause) when available.
-     * @param {any} error
-     * @param {Command} command
-     * @returns {Command}
+     * Initializes the handlers map. This is called lazily on first use.
      */
-    static resolveException(error: any, command: Command): Command;
+    static _initialize(): void;
     /**
-     * @param {import('../interpreter/Interpreter.js').Interpreter} interpreter
+     * @param {Command} command
+     * @returns {Promise<Command> | Command}
      */
-    constructor(interpreter: import("../interpreter/Interpreter.js").Interpreter);
-    interpreter: import("../interpreter/Interpreter.js").Interpreter;
+    static handleCommand(command: Command): Promise<Command> | Command;
     /**
+     * Prefer innerException (or cause) when available.
+     * @param {any} error
      * @param {Command} command
-     * @returns {Promise<Command> | Command}
+     * @returns {Command}
      */
-    handleCommand(command: Command): Promise<Command> | Command;
+    static resolveException(error: any, command: Command): Command;
     /**
      * @param {any} response
      * @param {RuntimeName} runtimeName
      * @returns {Promise<Command> | Command}
      */
-    parseCommand(response: any, runtimeName: RuntimeName): Promise<Command> | Command;
+    static parseCommand(response: any, runtimeName: RuntimeName): Promise<Command> | Command;
 }
 /**
  * @typedef {import('../../types.d.ts').RuntimeName} RuntimeName

package/dist/types/core/handler/PassDelegateHandler.d.ts

@@ -1,16 +1,11 @@
 export type Command = import("../../utils/Command.js").Command;
-export type Interpreter = import("../interpreter/Interpreter.js").Interpreter;
 /**
  * @typedef {import('../../utils/Command.js').Command} Command
- * @typedef {import('../interpreter/Interpreter.js').Interpreter} Interpreter
  */
 /**
  * PassDelegateHandler class responsible for processing a command to create a delegate.
  */
 export class PassDelegateHandler extends AbstractHandler {
-    constructor(interpreter?: null);
-    /** @type {Interpreter | null | undefined} */
-    interpreter: Interpreter | null | undefined;
     /**
      * Minimum required parameters count for the command.
      * @type {number}

package/dist/types/core/interpreter/Interpreter.d.ts

@@ -1,23 +1,18 @@
 export class Interpreter {
-    /** @type {Handler | null} */
-    _handler: Handler | null;
-    /** @type {Handler} */
-    get handler(): Handler;
     /**
      *
      * @param {Command} command
      * @param {IConnectionData} connectionData
      * @returns {Promise<Command>}
      */
-    execute(command: Command, connectionData: IConnectionData): Promise<Command>;
+    static execute(command: Command, connectionData: IConnectionData): Promise<Command>;
     /**
      *
      * @param {Uint8Array} messageByteArray
      * @returns {Promise<Command> | Command}
      */
-    process(messageByteArray: Uint8Array): Promise<Command> | Command;
+    static process(messageByteArray: Uint8Array): Promise<Command> | Command;
 }
 export type IConnectionData = import("../../utils/connectionData/IConnectionData.js").IConnectionData;
 export type RuntimeNameType = typeof import("../../types.d.ts").RuntimeName;
 export type Command = import("../../utils/Command.js").Command;
-import { Handler } from '../handler/Handler.js';

package/dist/types/core/protocol/CommandSerializer.d.ts

@@ -10,12 +10,12 @@ export class CommandSerializer {
      * @param {number} runtimeVersion
      * @returns {Uint8Array}
      */
-    serialize(rootCommand: Command, connectionData: IConnectionData, runtimeVersion?: number): Uint8Array;
+    static serialize(rootCommand: Command, connectionData: IConnectionData, runtimeVersion?: number): Uint8Array;
     /**
      * Recursively serializes command payload.
      * @param {Command} command
      * @param {Array<Uint8Array>} buffers
      */
-    serializeRecursively(command: Command, buffers: Array<Uint8Array>): void;
+    static serializeRecursively(command: Command, buffers: Array<Uint8Array>): void;
 }
 import { Command } from '../../utils/Command.js';

package/dist/types/core/receiver/Receiver.d.ts

@@ -11,6 +11,5 @@ export class Receiver {
      * @returns {Promise<Uint8Array>}
      */
     static heartBeat(messageByteArray: Uint8Array): Promise<Uint8Array>;
-    Receiver(): void;
 }
 import { InMemoryConnectionData } from '../../utils/connectionData/InMemoryConnectionData.js';

package/dist/types/sdk/Javonet.d.ts

@@ -72,6 +72,7 @@ export class Javonet {
      */
     static initializeRc(configName: string): RuntimeContext;
 }
+import { RuntimeContext } from './RuntimeContext.js';
 import { TcpConnectionData } from '../utils/nodejs/connectionData/TcpConnectionData.js';
 import { WsConnectionData } from '../utils/connectionData/WsConnectionData.js';
 import { CommandSerializer } from '../core/protocol/CommandSerializer.js';
@@ -80,5 +81,4 @@ import { ConfigPriority } from './configuration/ConfigPriority.js';
 import { ComplexTypeResolver } from './tools/ComplexTypeResolver.js';
 import { RuntimeFactory } from './RuntimeFactory.js';
 import { ConfigRuntimeFactory } from './ConfigRuntimeFactory.js';
-import { RuntimeContext } from './RuntimeContext.js';
-export { TcpConnectionData, WsConnectionData, CommandSerializer, CommandDeserializer, ConfigPriority, ComplexTypeResolver };
+export { RuntimeContext, TcpConnectionData, WsConnectionData, CommandSerializer, CommandDeserializer, ConfigPriority, ComplexTypeResolver };

package/dist/types/sdk/RuntimeContext.d.ts

@@ -19,6 +19,11 @@ export class RuntimeContext {
     static networkRuntimeContexts: Map<string, RuntimeContext>;
     /** @type {Map<string, RuntimeContext>} */
     static webSocketRuntimeContexts: Map<string, RuntimeContext>;
+    /**
+     * @param {Config} config
+     * @returns {RuntimeContext}
+     */
+    static initializeRuntimeContext(config: Config): RuntimeContext;
     /**
      * @param {RuntimeNameType} runtimeName
      * @param {IConnectionData} connectionData
@@ -99,12 +104,12 @@ export class RuntimeContext {
      * After creating the reference, it can be used as an argument when invoking methods.
      * @param {...any} args - The value and optionally the type of the reference.
      * @returns {InvocationContext} InvocationContext instance that wraps the command to create a reference as out.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-out-keyword |Passing Arguments by Reference with out Keyword Guide)
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-out-keyword |Passing Arguments by Reference with 'out' Keyword Guide)
      * @method
      */
     asOut(...args: any[]): InvocationContext;
     /**
-     * Retrieves the value of an global field from the target runtime.
+     * Retrieves the value of a global field from the target runtime.
      * @param {string} fieldName - The name of the field to get.
      * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the global field.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/fields-and-properties/getting-values-for-global-fields)
@@ -122,7 +127,7 @@ export class RuntimeContext {
      * @method
      */
     invokeGlobalFunction(functionName: string, ...args: any[]): InvocationContext;
-    healthCheck(): void;
     #private;
 }
 import { InvocationContext } from './InvocationContext.js';
+import { Config } from "./configuration/Config.js";

package/dist/types/sdk/RuntimeFactory.d.ts

@@ -7,14 +7,6 @@
  * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
  */
 export class RuntimeFactory {
-    /**
-     * @param {{ runtime: import("../types.js").RuntimeName; connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData; modules: string; }} config
-     */
-    static initializeRuntimeContext(config: {
-        runtime: import("../types.js").RuntimeName;
-        connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData;
-        modules: string;
-    }): RuntimeContext;
     /**
      * @param {IConnectionData} connectionData
      */

package/lib/core/handler/Handler.js

@@ -119,31 +119,34 @@ const handlers = {
 }
 
 class Handler {
+    static _initialized = false
+
     /**
-     * @param {import('../interpreter/Interpreter.js').Interpreter} interpreter
+     * Initializes the handlers map. This is called lazily on first use.
      */
-    constructor(interpreter) {
-        this.interpreter = interpreter
-
-        if (!this.interpreter) {
-            throw new Error('interpreter is undefined in Handler constructor')
+    static _initialize() {
+        if (Handler._initialized) {
+            return
         }
 
-        // dynamically create pass delegate handler with interpreter
-        // @ts-expect-error
-        handlers[CommandType.PassDelegate] = new PassDelegateHandler(this.interpreter)
+        // dynamically create pass delegate handler
+        handlers[CommandType.PassDelegate] = new PassDelegateHandler()
 
         Object.keys(handlers).forEach((commandTypeHandler) => {
             // @ts-expect-error
             handlers[commandTypeHandler].handlers = handlers
         })
+
+        Handler._initialized = true
     }
 
     /**
      * @param {Command} command
      * @returns {Promise<Command> | Command}
      */
-    handleCommand(command) {
+    static handleCommand(command) {
+        Handler._initialize()
+        
         try {
             if (command.commandType === CommandType.RetrieveArray) {
                 /** @type {any} */
@@ -153,7 +156,7 @@ class Handler {
 
             /** @type {any} */
             const response = handlers[command.commandType].handleCommand(command)
-            return this.parseCommand(response, command.runtimeName)
+            return Handler.parseCommand(response, command.runtimeName)
         } catch (e) {
             return Handler.resolveException(e, command)
         }
@@ -175,10 +178,10 @@ class Handler {
      * @param {RuntimeName} runtimeName
      * @returns {Promise<Command> | Command}
      */
-    parseCommand(response, runtimeName) {
+    static parseCommand(response, runtimeName) {
         if (response instanceof Promise) {
             return response.then((resolvedResponse) => {
-                return this.parseCommand(resolvedResponse, runtimeName)
+                return Handler.parseCommand(resolvedResponse, runtimeName)
             })
         }
 

package/lib/core/handler/PassDelegateHandler.js

@@ -6,24 +6,19 @@ import { AbstractHandler } from './AbstractHandler.js'
 
 /**
  * @typedef {import('../../utils/Command.js').Command} Command
- * @typedef {import('../interpreter/Interpreter.js').Interpreter} Interpreter
  */
 
 /**
  * PassDelegateHandler class responsible for processing a command to create a delegate.
  */
 class PassDelegateHandler extends AbstractHandler {
-    /** @type {Interpreter | null | undefined} */
-    interpreter = null
-
-    constructor(interpreter = null) {
+    constructor() {
         super()
         /**
          * Minimum required parameters count for the command.
          * @type {number}
          */
         this.requiredParametersCount = 1
-        this.interpreter = interpreter
     }
 
     /**S
@@ -116,7 +111,8 @@ class PassDelegateHandler extends AbstractHandler {
      * @returns {Promise<any>} The response object.
      */
     async createExecuteCall(command) {
-        return this.interpreter?.execute(command, new InMemoryConnectionData())
+        const { Interpreter } = await import('../interpreter/Interpreter.js')
+        return Interpreter.execute(command, new InMemoryConnectionData())
     }
 
     /**

package/lib/core/interpreter/Interpreter.js

@@ -24,16 +24,6 @@ let _TransmitterWebsocket = isNodejsRuntime() ? TransmitterWebsocket : Transmitt
 const requireDynamic = getRequire(import.meta.url)
 
 export class Interpreter {
-    /** @type {Handler | null} */
-    _handler = null
-
-    /** @type {Handler} */
-    get handler() {
-        if (!this._handler) {
-            this._handler = new Handler(this)
-        }
-        return this._handler
-    }
 
     /**
      *
@@ -41,9 +31,9 @@ export class Interpreter {
      * @param {IConnectionData} connectionData
      * @returns {Promise<Command>}
      */
-    async execute(command, connectionData) {
+    static async execute(command, connectionData) {
         try {
-            let messageByteArray = new CommandSerializer().serialize(command, connectionData)
+            let messageByteArray = CommandSerializer.serialize(command, connectionData)
 
             if (!(messageByteArray instanceof Uint8Array)) {
                 throw new Error('Serialized message is not Uint8Array')
@@ -100,10 +90,10 @@ export class Interpreter {
      * @param {Uint8Array} messageByteArray
      * @returns {Promise<Command> | Command}
      */
-    process(messageByteArray) {
+    static process(messageByteArray) {
         try {
             const receivedCommand = new CommandDeserializer(messageByteArray).deserialize()
-            return this.handler?.handleCommand(receivedCommand)
+            return Handler.handleCommand(receivedCommand)
         } catch (error) {
             throw error
         }

package/lib/core/protocol/CommandDeserializer.js

@@ -55,7 +55,7 @@ export class CommandDeserializer {
             case 'JAVONET_DOUBLE':
                 return this.readDouble()
             case 'JAVONET_UNSIGNED_LONG_LONG':
-                return this.readUllong
+                return this.readUllong()
             case 'JAVONET_UNSIGNED_INTEGER':
                 return this.readUInt()
             case 'JAVONET_NULL':

package/lib/core/protocol/CommandSerializer.js

@@ -17,7 +17,7 @@ class CommandSerializer {
      * @param {number} runtimeVersion
      * @returns {Uint8Array}
      */
-    serialize(rootCommand, connectionData, runtimeVersion = 0) {
+    static serialize(rootCommand, connectionData, runtimeVersion = 0) {
         /** @type {Array<Uint8Array>} */
         const buffers = []
 
@@ -34,7 +34,7 @@ class CommandSerializer {
         buffers.push(Uint8Array.of(RuntimeName.Python, rootCommand.commandType))
 
         // Recursively serialize command and its payload
-        this.serializeRecursively(rootCommand, buffers)
+        CommandSerializer.serializeRecursively(rootCommand, buffers)
 
         return concatenateUint8Arrays(buffers)
     }
@@ -44,18 +44,18 @@ class CommandSerializer {
      * @param {Command} command
      * @param {Array<Uint8Array>} buffers
      */
-    serializeRecursively(command, buffers) {
+    static serializeRecursively(command, buffers) {
         for (const item of command.payload) {
             if (item instanceof Command) {
                 buffers.push(TypeSerializer.serializeCommand(item))
-                this.serializeRecursively(item, buffers)
+                CommandSerializer.serializeRecursively(item, buffers)
             } else if (TypesHandler.isPrimitiveOrNullOrUndefined(item)) {
                 buffers.push(TypeSerializer.serializePrimitive(item))
             } else {
                 const cachedReference = ReferencesCache.getInstance().cacheReference(item)
                 const refCommand = new Command(RuntimeName.Nodejs, CommandType.Reference, cachedReference)
                 buffers.push(TypeSerializer.serializeCommand(refCommand))
-                this.serializeRecursively(refCommand, buffers)
+                CommandSerializer.serializeRecursively(refCommand, buffers)
             }
         }
     }

package/lib/core/receiver/Receiver.js

@@ -1,17 +1,15 @@
 // @ts-check
-import { Interpreter } from '../interpreter/Interpreter.js'
 import { CommandSerializer } from '../protocol/CommandSerializer.js'
-import { getRequire } from '../../utils/Runtime.js'
 import { InMemoryConnectionData } from '../../utils/connectionData/InMemoryConnectionData.js'
 import { ExceptionSerializer } from '../../utils/exception/ExceptionSerializer.js'
 import { Command } from '../../utils/Command.js'
 import { CommandType } from '../../utils/CommandType.js'
 import { RuntimeName } from '../../utils/RuntimeName.js'
 import { RuntimeLogger } from '../../utils/RuntimeLogger.js'
+import { Interpreter } from './../interpreter/Interpreter.js'
 
 export class Receiver {
     static connectionData = new InMemoryConnectionData()
-    Receiver() {}
 
     static getRuntimeInfo() {
         return RuntimeLogger.getRuntimeInfo()
@@ -23,14 +21,14 @@ export class Receiver {
      */
     static async sendCommand(messageByteArray) {
         try {
-            let command = await new Interpreter().process(messageByteArray)
-            return new CommandSerializer().serialize(command, this.connectionData)
+            let command = await Interpreter.process(messageByteArray)
+            return CommandSerializer.serialize(command, this.connectionData)
         } catch (error) {
             const exceptionCommand = ExceptionSerializer.serializeException(
                 error,
                 new Command(RuntimeName.Nodejs, CommandType.Exception, [])
             )
-            return new CommandSerializer().serialize(exceptionCommand, this.connectionData)
+            return CommandSerializer.serialize(exceptionCommand, this.connectionData)
         }
     }
 

package/lib/sdk/InvocationContext.js

@@ -50,8 +50,6 @@ class InvocationContext {
     #responseCommand = null
     /** @type {boolean} */
     #isExecuted = false
-    /** @type {Interpreter | null} */
-    #interpreter = null
     /** @type {string | null} */
     #guid = null
     /** @type {AsyncLock} */
@@ -60,6 +58,8 @@ class InvocationContext {
     // Static map holding contexts waiting for materialization (guid -> InvocationContext)
     static _invocationContexts = new Map()
 
+    //
+
     /**
      *
      * @param {RuntimeNameType} runtimeName
@@ -73,7 +73,6 @@ class InvocationContext {
         this.#currentCommand = command
         this.#responseCommand = null
         this.#isExecuted = isExecuted
-        this.#interpreter = null
         this.#guid = uuidv4()
     }
 
@@ -142,11 +141,7 @@ class InvocationContext {
         if (this.#currentCommand === null) {
             throw new Error('currentCommand is undefined in Invocation Context execute method')
         }
-        if (!this.#interpreter) {
-            this.#interpreter = new Interpreter()
-        }
 
-        // Zablokuj wszystkie konteksty do materializacji w deterministycznej kolejności (po GUID)
         const entries = Array.from(InvocationContext._invocationContexts.entries())
         entries.sort((a, b) => String(a[0]).localeCompare(String(b[0])))
         const releases = []
@@ -158,7 +153,11 @@ class InvocationContext {
 
         try {
             // Execute command on interpreter
-            this.#responseCommand = await this.#interpreter.execute(this.#currentCommand, this.#connectionData)
+            this.#responseCommand = await Interpreter.execute(
+                this.#currentCommand,
+                this.#connectionData
+            )
+
 
             if (!this.#responseCommand) {
                 throw new Error('responseCommand is undefined in Invocation Context execute method')

package/lib/sdk/Javonet.js

@@ -122,12 +122,13 @@ class Javonet {
      */
     static initializeRc(configName) {
         const config = ConfigSourceResolver.getConfig(configName)
-        return RuntimeFactory.initializeRuntimeContext(config)
+        return RuntimeContext.initializeRuntimeContext(config)
     }
 }
 
 export {
     Javonet,
+    RuntimeContext,
     TcpConnectionData,
     WsConnectionData,
     CommandSerializer,

package/lib/sdk/RuntimeContext.js

@@ -9,8 +9,10 @@ import { Interpreter } from '../core/interpreter/Interpreter.js'
 import { delegatesCacheInstance } from '../core/delegatesCache/DelegatesCache.js'
 import { TypesHandler } from '../utils/TypesHandler.js'
 import { UtilsConst } from '../utils/UtilsConst.js'
+import { Config } from "./configuration/Config.js"
 import { getRequire, isNodejsRuntime } from '../utils/Runtime.js'
 
+
 /**
  * @typedef {import('../types.d.ts').RuntimeName} RuntimeNameType
  * @typedef {import('../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
@@ -45,8 +47,6 @@ class RuntimeContext {
     #currentCommand = null
     /** @type {Command | null} */
     #responseCommand = null
-    /** @type {Interpreter | null} */
-    #interpreter = null
 
     /**
      * @param {RuntimeNameType} runtimeName
@@ -56,7 +56,6 @@ class RuntimeContext {
         this._isExecuted = false
         this.runtimeName = runtimeName
         this.connectionData = connectionData
-        this.#interpreter = new Interpreter()
 
         if (this.connectionData.connectionType === ConnectionType.WEB_SOCKET) {
             return
@@ -75,6 +74,40 @@ class RuntimeContext {
         _Transmitter?.activate(UtilsConst.getLicenseKey())
     }
 
+    /**
+     * @param {Config} config
+     * @returns {RuntimeContext}
+     */
+    static initializeRuntimeContext(config) {
+        const rtmCtx = RuntimeContext.getInstance(config.runtime, config.connectionData)
+
+        if (config.connectionData.connectionType === ConnectionType.IN_MEMORY) {
+            const modules = (config.modules || '')
+                .split(',')
+                .map((m) => m.trim())
+                .filter((m) => m !== '')
+
+            // try to get Node's path module; if unavailable, fall back to simple checks
+            let pathModule = null
+            try {
+                // eslint-disable-next-line no-eval
+                const _require = typeof require !== 'undefined' ? require : eval('require')
+                pathModule = _require('path')
+            } catch (e) {
+                pathModule = null
+            }
+
+            modules.forEach((module) => {
+                const fullPath = pathModule
+                    ? pathModule.resolve(module)
+                    : module
+                rtmCtx.loadLibrary(fullPath)
+            })
+        }
+
+        return rtmCtx
+    }
+
     /**
      * @param {RuntimeNameType} runtimeName
      * @param {IConnectionData} connectionData
@@ -148,8 +181,10 @@ class RuntimeContext {
      * @method
      */
     async execute() {
-        // @ts-expect-error
-        this.#responseCommand = await this.#interpreter?.execute(this.#currentCommand, this.connectionData)
+        if (!this.#currentCommand) {
+            throw new Error('currentCommand is undefined in Runtime Context execute method')
+        }
+        this.#responseCommand = await Interpreter.execute(this.#currentCommand, this.connectionData)
         this.#currentCommand = null
         if (this.#responseCommand === undefined) {
             throw new Error('responseCommand is undefined in Runtime Context execute method')
@@ -240,7 +275,7 @@ class RuntimeContext {
      * After creating the reference, it can be used as an argument when invoking methods.
      * @param {...any} args - The value and optionally the type of the reference.
      * @returns {InvocationContext} InvocationContext instance that wraps the command to create a reference as out.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-out-keyword |Passing Arguments by Reference with out Keyword Guide)
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/methods-arguments/passing-arguments-by-reference-with-out-keyword |Passing Arguments by Reference with 'out' Keyword Guide)
      * @method
      */
     asOut(...args) {
@@ -250,7 +285,7 @@ class RuntimeContext {
     }
 
     /**
-     * Retrieves the value of an global field from the target runtime.
+     * Retrieves the value of a global field from the target runtime.
      * @param {string} fieldName - The name of the field to get.
      * @returns {InvocationContext} A new InvocationContext instance that wraps the command to get the global field.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/fields-and-properties/getting-values-for-global-fields)
@@ -331,12 +366,6 @@ class RuntimeContext {
             )
         }
     }
-
-    healthCheck() {
-        let localCommand = new Command(this.runtimeName, CommandType.Value, ['health_check'])
-        this.#currentCommand = this.#buildCommand(localCommand)
-        this.execute()
-    }
 }
 
 export { RuntimeContext }

package/lib/sdk/RuntimeFactory.js

@@ -1,7 +1,6 @@
 //@ts-check
 import { RuntimeName } from '../utils/RuntimeName.js'
 import { RuntimeContext } from './RuntimeContext.js'
-import { ConnectionType } from '../utils/ConnectionType.js'
 
 /**
  * @typedef {import('../utils/connectionData/IConnectionData.js').IConnectionData} IConnectionData
@@ -99,37 +98,4 @@ export class RuntimeFactory {
     python27() {
         return RuntimeContext.getInstance(RuntimeName.Python27, this.connectionData)
     }
-
-    /**
-     * @param {{ runtime: import("../types.js").RuntimeName; connectionData: import("../utils/connectionData/IConnectionData.js").IConnectionData; modules: string; }} config
-     */
-    static initializeRuntimeContext(config) {
-        const rtmCtx = RuntimeContext.getInstance(config.runtime, config.connectionData)
-
-        if (config.connectionData.connectionType === ConnectionType.IN_MEMORY) {
-            const modules = (config.modules || '')
-                .split(',')
-                .map((m) => m.trim())
-                .filter((m) => m !== '')
-
-            // try to get Node's path module; if unavailable, fall back to simple checks
-            let pathModule = null
-            try {
-                // eslint-disable-next-line no-eval
-                const _require = typeof require !== 'undefined' ? require : eval('require')
-                pathModule = _require('path')
-            } catch (e) {
-                pathModule = null
-            }
-
-            modules.forEach((module) => {
-                const fullPath = pathModule
-                    ? pathModule.resolve(module)
-                    : module
-                rtmCtx.loadLibrary(fullPath)
-            })
-        }
-
-        return rtmCtx
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "javonet-nodejs-sdk",
-    "version": "2.6.10",
+    "version": "2.6.11",
     "description": "Javonet allows you to reference and use modules or packages written in (Java/Kotlin/Groovy/Clojure, C#/VB.NET, Ruby, Perl, Python, JavaScript/TypeScript) like they were created in your technology. It works on Linux/Windows and MacOS for applications created in JVM, CLR/Netcore, Perl, Python, Ruby, NodeJS, C++ or GoLang and gives you unparalleled freedom and flexibility with native performance in building your mixed-technologies products. Let it be accessing best AI or cryptography libraries, devices SDKs, legacy client modules, internal custom packages or anything from public repositories available on NPM, Nuget, PyPI, Maven/Gradle, RubyGems or GitHub. Get free from programming languages barriers today! For more information check out our guides at https://www.javonet.com/guides/v2/",
     "keywords": [],
     "author": "SdNCenter Sp. z o. o.",