javonet-ruby-sdk 2.5.17 → 2.5.18

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/protocol/TypeSerializer.cjs

@@ -28,40 +28,54 @@ var import_buffer = require("buffer");
 var import_CustomError = require("../../utils/CustomError.cjs");
 const encoder = new TextEncoder();
 class TypeSerializer {
+  /**
+   * @param {unknown} payload_item
+   */
   static serializePrimitive(payload_item) {
     if (payload_item === null) {
       return TypeSerializer.serializeNull();
     }
     if (payload_item instanceof import_Command.Command) {
       return TypeSerializer.serializeCommand(payload_item);
-    } else if (typeof payload_item === "number" || payload_item instanceof Number) {
+    } else if (typeof payload_item === "number") {
       if (Number.isInteger(payload_item)) {
         return TypeSerializer.serializeInt(payload_item);
       } else {
         return TypeSerializer.serializeDouble(payload_item);
       }
-    } else if (typeof payload_item === "string" || payload_item instanceof String) {
+    } else if (typeof payload_item === "string") {
       return TypeSerializer.serializeString(payload_item);
-    } else if (typeof payload_item === "boolean" || payload_item instanceof Boolean) {
+    } else if (typeof payload_item === "boolean") {
       return TypeSerializer.serializeBool(payload_item);
     } else {
       if (payload_item instanceof Promise) {
-        throw new import_CustomError.CustomError("Type not supported - Promise", JSON.stringify(payload_item));
+        const message = "Unsupported payload item type: " + (payload_item?.constructor?.name || typeof payload_item) + " for payload item: " + payload_item;
+        throw new import_CustomError.CustomError(message, "JAVONET_PROMISE");
       }
       if (payload_item === void 0) {
-        throw "Type not supported - undefined";
+        throw Error(
+          "Unsupported payload item type: " + typeof payload_item + " for payload item: " + payload_item
+        );
       }
-      throw "Unknown type - not supported in JavaScript";
+      throw Error(
+        "Unsupported payload item type: " + (payload_item?.constructor?.name || typeof payload_item) + " for payload item: " + payload_item
+      );
     }
   }
+  /**
+   * @param {Command} command
+   */
   static serializeCommand(command) {
     const buffer = import_buffer.Buffer.alloc(7);
     buffer.writeUInt8(import_Type.Type.JAVONET_COMMAND, 0);
     buffer.fill(import_buffer.Buffer.from(this.serializeIntValue(command.payload.length)), 1, 5);
-    buffer.writeUInt8(command.runtime, 5);
+    buffer.writeUInt8(command.runtimeName, 5);
     buffer.writeUInt8(command.commandType, 6);
     return buffer;
   }
+  /**
+   * @param {string} string_value
+   */
   static serializeString(string_value) {
     let bytes = encoder.encode(string_value);
     const buffer = import_buffer.Buffer.alloc(6 + bytes.length);
@@ -71,6 +85,9 @@ class TypeSerializer {
     buffer.fill(import_buffer.Buffer.from(bytes), 6, 6 + bytes.length);
     return buffer;
   }
+  /**
+   * @param {number} int_value
+   */
   static serializeInt(int_value) {
     const buffer = import_buffer.Buffer.alloc(6);
     buffer.writeUInt8(import_Type.Type.JAVONET_INTEGER, 0);
@@ -78,6 +95,9 @@ class TypeSerializer {
     buffer.writeInt32LE(int_value, 2);
     return buffer;
   }
+  /**
+   * @param {boolean} bool_value
+   */
   static serializeBool(bool_value) {
     const buffer = import_buffer.Buffer.alloc(3);
     buffer.writeUInt8(import_Type.Type.JAVONET_BOOLEAN, 0);
@@ -85,6 +105,9 @@ class TypeSerializer {
     buffer.writeUInt8(bool_value ? 1 : 0, 2);
     return buffer;
   }
+  /**
+   * @param {number} float_value
+   */
   static serializeFloat(float_value) {
     const buffer = import_buffer.Buffer.alloc(6);
     buffer.writeUInt8(import_Type.Type.JAVONET_FLOAT, 0);
@@ -92,6 +115,9 @@ class TypeSerializer {
     buffer.writeFloatLE(float_value, 2);
     return buffer;
   }
+  /**
+   * @param {number} byte_value
+   */
   static serializeByte(byte_value) {
     const buffer = import_buffer.Buffer.alloc(3);
     buffer.writeUInt8(import_Type.Type.JAVONET_BYTE, 0);
@@ -99,6 +125,9 @@ class TypeSerializer {
     buffer.writeUInt8(byte_value, 2);
     return buffer;
   }
+  /**
+   * @param {number} char_value
+   */
   static serializeChar(char_value) {
     const buffer = import_buffer.Buffer.alloc(3);
     buffer.writeUInt8(import_Type.Type.JAVONET_CHAR, 0);
@@ -106,6 +135,9 @@ class TypeSerializer {
     buffer.writeUInt8(char_value, 2);
     return buffer;
   }
+  /**
+   * @param {number} longlong_value
+   */
   static serializeLongLong(longlong_value) {
     const buffer = import_buffer.Buffer.alloc(10);
     buffer.writeUInt8(import_Type.Type.JAVONET_LONG_LONG, 0);
@@ -113,6 +145,9 @@ class TypeSerializer {
     buffer.writeBigInt64LE(BigInt(longlong_value), 2);
     return buffer;
   }
+  /**
+   * @param {number} double_value
+   */
   static serializeDouble(double_value) {
     const buffer = import_buffer.Buffer.alloc(10);
     buffer.writeUInt8(import_Type.Type.JAVONET_DOUBLE, 0);
@@ -120,6 +155,9 @@ class TypeSerializer {
     buffer.writeDoubleLE(double_value, 2);
     return buffer;
   }
+  /**
+   * @param {bigint} ullong_value
+   */
   static serializeULLong(ullong_value) {
     const buffer = import_buffer.Buffer.alloc(10);
     buffer.writeUInt8(import_Type.Type.JAVONET_UNSIGNED_LONG_LONG, 0);
@@ -127,6 +165,9 @@ class TypeSerializer {
     buffer.writeBigUInt64LE(ullong_value, 2);
     return buffer;
   }
+  /**
+   * @param {number} uint_value
+   */
   static serializeUInt(uint_value) {
     const buffer = import_buffer.Buffer.alloc(6);
     buffer.writeUInt8(import_Type.Type.JAVONET_UNSIGNED_INTEGER, 0);
@@ -141,6 +182,9 @@ class TypeSerializer {
     buffer.writeUInt8(0, 2);
     return buffer;
   }
+  /**
+   * @param {number} int_value
+   */
   static serializeIntValue(int_value) {
     const buffer = import_buffer.Buffer.alloc(4);
     buffer.writeInt32LE(int_value, 0);

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/receiver/Receiver.cjs

@@ -38,7 +38,7 @@ class Receiver {
     _RuntimeLogger?.printRuntimeInfo();
   }
   /**
-   * @param {number[]} messageByteArray
+   * @param {Int8Array} messageByteArray
    */
   static sendCommand(messageByteArray) {
     return new import_CommandSerializer.CommandSerializer().serialize(

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/receiver/ReceiverNative.cjs

@@ -23,9 +23,15 @@ __export(ReceiverNative_exports, {
 module.exports = __toCommonJS(ReceiverNative_exports);
 var import_Receiver = require("./Receiver.cjs");
 class ReceiverNative {
+  /**
+   * @param {Int8Array} messageByteArray
+   */
   static sendCommand(messageByteArray) {
     return import_Receiver.Receiver.sendCommand(messageByteArray);
   }
+  /**
+   * @param {Int8Array} messageByteArray
+   */
   static heartBeat(messageByteArray) {
     return import_Receiver.Receiver.heartBeat(messageByteArray);
   }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/Transmitter.cjs

@@ -23,15 +23,31 @@ __export(Transmitter_exports, {
 module.exports = __toCommonJS(Transmitter_exports);
 var import_TransmitterWrapper = require("./TransmitterWrapper.cjs");
 class Transmitter {
+  /**
+   * @param {Int8Array} messageArray
+   * @returns {Int8Array}
+   */
   static sendCommand(messageArray) {
     return import_TransmitterWrapper.TransmitterWrapper.sendCommand(messageArray);
   }
-  static activate = function(licenseKey) {
+  /**
+   * @param {string} licenseKey 
+   * @returns {void}
+   */
+  static activate(licenseKey) {
     return import_TransmitterWrapper.TransmitterWrapper.activate(licenseKey);
-  };
+  }
+  /**
+   * @param {string} configSource
+   * @returns {void}
+  */
   static setConfigSource(configSource) {
     return import_TransmitterWrapper.TransmitterWrapper.setConfigSource(configSource);
   }
+  /**
+   * @param {string} workingDirectory 
+   * @returns 
+   */
   static setJavonetWorkingDirectory(workingDirectory) {
     return import_TransmitterWrapper.TransmitterWrapper.setJavonetWorkingDirectory(workingDirectory);
   }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/TransmitterWebsocket.cjs

@@ -40,13 +40,16 @@ class TransmitterWebsocket {
   }
   /**
    * @async
-   * @param {number[]} messageByteArray
-   * @param {WsConnectionData} connectionData
-   * @returns {Promise<number[]>} responseByteArray
+   * @param {Int8Array} messageByteArray
+   * @param {IConnectionData} connectionData
+   * @returns {Promise<Int8Array>} responseByteArray
    */
-  static async sendCommand(messageByteArray, connectionData) {
+  static sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;
-    return new import_WebSocketClient.WebSocketClient(hostname).send(messageByteArray);
+    const options = {
+      isDisconnectedAfterMessage: true
+    };
+    return new import_WebSocketClient.WebSocketClient(hostname, options).send(messageByteArray);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/TransmitterWebsocketBrowser.cjs

@@ -36,7 +36,7 @@ class TransmitterWebsocketBrowser {
   /**
    * @async
    * @param {Int8Array} messageByteArray
-   * @param {ConnectionData} connectionData
+   * @param {IConnectionData} connectionData
    * @returns {Promise<Int8Array>} responseByteArray
    */
   static async sendCommand(messageByteArray, connectionData) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/transmitter/TransmitterWrapper.cjs

@@ -24,11 +24,12 @@ module.exports = __toCommonJS(TransmitterWrapper_exports);
 var import_Runtime = require("../../utils/Runtime.cjs");
 var import_ReceiverNative = require("../receiver/ReceiverNative.cjs");
 const import_meta = {};
-let library;
+let library = null;
+let path = null;
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class TransmitterWrapper {
   static isNativeLibraryLoaded() {
-    return library !== void 0;
+    return Boolean(library);
   }
   static loadNativeLibrary() {
     if (!(0, import_Runtime.isNodejsRuntime)()) {
@@ -38,35 +39,51 @@ class TransmitterWrapper {
       return;
     }
     try {
-      const path = requireDynamic("path");
+      if (!path) {
+        path = requireDynamic("path");
+      }
       const packagePath = (0, import_Runtime.getDependency)("javonet-binaries", import_meta.url);
       const binariesRootPath = path.dirname(packagePath);
-      const nativeAddonPath = path.join(binariesRootPath, "build", "Release", "JavonetNodejsRuntimeAddon.node");
+      const nativeAddonPath = path.join(
+        binariesRootPath,
+        "build",
+        "Release",
+        "JavonetNodejsRuntimeAddon.node"
+      );
       library = requireDynamic(nativeAddonPath);
       library.initializeTransmitter(binariesRootPath);
-      library.setReceiverNative(global.ReceiverNative);
+      library.setReceiverNative(global?.ReceiverNative);
     } catch (error) {
       throw error;
     }
   }
   /**
-   * @param {string} licenseKey 
+   * @param {string} licenseKey
    */
   static activate(licenseKey) {
     this.loadNativeLibrary();
     return library.activate(licenseKey);
   }
+  /**
+   * @param {Int8Array} messageArray
+   */
   static sendCommand(messageArray) {
     this.loadNativeLibrary();
     return library.sendCommand(messageArray);
   }
+  /**
+   * @param {string} configSource
+   */
   static setConfigSource(configSource) {
     this.loadNativeLibrary();
     return library.setConfigSource(configSource);
   }
-  static setJavonetWorkingDirectory(path) {
+  /**
+   * @param {string} path
+   */
+  static setJavonetWorkingDirectory(path2) {
     this.loadNativeLibrary();
-    library.setJavonetWorkingDirectory(path);
+    library.setJavonetWorkingDirectory(path2);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/typeCache/TypeCache.cjs

@@ -22,7 +22,9 @@ __export(TypeCache_exports, {
 });
 module.exports = __toCommonJS(TypeCache_exports);
 class TypeCache {
+  /** @type {TypeCache | null} */
   static _instance = null;
+  /** @type {string[]} */
   typeCache = [];
   constructor() {
     if (TypeCache._instance === null) {
@@ -30,12 +32,18 @@ class TypeCache {
     }
     return TypeCache._instance;
   }
+  /**
+   * @param {string} typRegex
+   */
   cacheType(typRegex) {
     this.typeCache.push(typRegex);
   }
   isTypeCacheEmpty() {
     return this.typeCache.length === 0;
   }
+  /**
+   * @param {{ name: string }} typeToCheck
+   */
   isTypeAllowed(typeToCheck) {
     for (let pattern of this.typeCache) {
       if (new RegExp(pattern).test(typeToCheck.name)) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/webSocketClient/WebSocketClient.cjs

@@ -33,7 +33,7 @@ let WebSocket = null;
 class WebSocketClient {
   /**
    * @param {string} url
-   * @param {object} options
+   * @param {{ isDisconnectedAfterMessage: boolean }} options
    */
   constructor(url, options) {
     this.url = url;
@@ -44,7 +44,7 @@ class WebSocketClient {
   /**
    * Connects to the WebSocket server.
    * @async
-   * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+   * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
    */
   async connect() {
     if (!WebSocket) {
@@ -52,7 +52,7 @@ class WebSocketClient {
         try {
           WebSocket = requireDynamic("ws");
         } catch (error) {
-          if (error.code === "MODULE_NOT_FOUND") {
+          if (typeof error === "object" && error && "code" in error && error.code === "MODULE_NOT_FOUND") {
             throw new Error("ws module not found. Please install it using npm install ws");
           }
           throw error;
@@ -60,6 +60,10 @@ class WebSocketClient {
       }
     }
     return new Promise((resolve, reject) => {
+      if (!WebSocket) {
+        reject(new Error("ws client is null"));
+        return;
+      }
       const client = new WebSocket(this.url);
       client.on(WebSocketStateEnum.OPEN, () => {
         this.instance = client;
@@ -76,18 +80,17 @@ class WebSocketClient {
   /**
    * Sends messageArray through websocket connection
    * @async
-   * @param {Buffer|ArrayBuffer|Buffer[]} messageArray
-   * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
+   * @param {Int8Array} messageArray
+   * @returns {Promise<Int8Array>}
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
       ;
       (this.instance ? Promise.resolve(this.instance) : this._connect()).then((client) => {
-        client.send(messageArray, (err) => {
-          if (err) {
-            reject(err);
-          }
-        });
+        client.send(
+          /** @type {any} */
+          messageArray
+        );
         client.on("message", (message) => {
           resolve(message);
           if (this.isDisconnectedAfterMessage) {
@@ -113,7 +116,7 @@ class WebSocketClient {
    * Connects to the WebSocket server.
    * @private
    * @async
-   * @returns {Promise<WebSocket>} - A promise that resolves when the connection is established.
+   * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
    */
   _connect() {
     if (!WebSocket) {
@@ -121,7 +124,10 @@ class WebSocketClient {
         try {
           WebSocket = requireDynamic("ws");
         } catch (error) {
-          if (error.code === "MODULE_NOT_FOUND") {
+          if (
+            /** @type {{ code?: string }} */
+            error.code === "MODULE_NOT_FOUND"
+          ) {
             throw new Error("ws module not found. Please install it using npm install ws");
           }
           throw error;
@@ -129,6 +135,10 @@ class WebSocketClient {
       }
     }
     return new Promise((resolve, reject) => {
+      if (!WebSocket) {
+        reject(new Error("ws client is null"));
+        return;
+      }
       const client = new WebSocket(this.url);
       client.on(WebSocketStateEnum.OPEN, () => {
         this.isConnected = true;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/webSocketClient/WebSocketClientBrowser.cjs

@@ -86,8 +86,8 @@ class WebSocketClientBrowser {
    */
   _connect() {
     return new Promise((resolve, reject) => {
-      if (!WsClient || WsClient === null) {
-        reject(new Error("missing WebSocket client"));
+      if (WsClient === null) {
+        return reject(new Error("missing WebSocket client"));
       }
       this.instance = new WsClient(this.url);
       this.instance.binaryType = "arraybuffer";

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/ConfigRuntimeFactory.cjs

@@ -26,25 +26,18 @@ var import_TcpConnectionData = require("../utils/nodejs/connectionData/TcpConnec
 var import_RuntimeName = require("../utils/RuntimeName.cjs");
 var import_RuntimeNameHandler = require("../utils/RuntimeNameHandler.cjs");
 var import_RuntimeContext = require("./RuntimeContext.cjs");
-var import_ConfigSourceResolver = require("./tools/browser/ConfigSourceResolver.cjs");
 var import_Runtime = require("../utils/Runtime.cjs");
-var import_JsonFileResolver = require("./tools/nodejs/JsonFileResolver.cjs");
 var import_InMemoryConnectionData = require("../utils/connectionData/InMemoryConnectionData.cjs");
+var import_JsonResolver = require("./tools/JsonResolver.cjs");
+var import_UtilsConst = require("../utils/UtilsConst.cjs");
 const import_meta = {};
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class ConfigRuntimeFactory {
-  /** @type {import('../core/transmitter/Transmitter.js') | null} */
-  transmitter = null;
   /**
-   * @param {object | string} configSource
-   * @param {import('../core/transmitter/Transmitter.js') | null} transmitter
+   * @param {ConfigSource | string} configSource
    */
-  constructor(configSource, transmitter = null) {
+  constructor(configSource) {
     this.configSource = configSource;
-    this.transmitter = transmitter;
-    if ((0, import_Runtime.isNodejsRuntime)()) {
-      this.transmitter?.setConfigSource(configSource);
-    }
   }
   /**
    * Creates RuntimeContext instance to interact with the .NET Framework runtime.
@@ -119,71 +112,83 @@ class ConfigRuntimeFactory {
     return this.#getRuntimeContext(import_RuntimeName.RuntimeName.Python27, configName);
   }
   /**
-   * @param {number} runtime
+   * @param {RuntimeNameType} runtime
    * @param {string} configName
-   * @returns
+   * @returns {RuntimeContext}
    */
   #getRuntimeContext(runtime, configName = "default") {
+    const jsonResolver = new import_JsonResolver.JsonResolver(this.configSource);
+    import_UtilsConst.UtilsConst.setLicenseKey(jsonResolver.getLicenseKey());
+    if (jsonResolver.getWorkingDirectory()) {
+      import_UtilsConst.UtilsConst.setJavonetWorkingDirectory(jsonResolver.getWorkingDirectory());
+    }
     if ((0, import_Runtime.isBrowserRuntime)()) {
-      const jfr = new import_ConfigSourceResolver.ConfigSourceResolver(this.configSource);
-      const connType = jfr.getChannelType(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName);
-      let connData = null;
-      if (connType === "webSocket") {
-        connData = new import_WsConnectionData.WsConnectionData(
-          jfr.getChannelHost(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName)
+      const channelType = jsonResolver.getChannelType(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName);
+      let connectionData = null;
+      if (channelType === "webSocket") {
+        connectionData = new import_WsConnectionData.WsConnectionData(
+          jsonResolver.getChannelHost(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName)
         );
       } else {
-        throw new Error("Unsupported connection type: " + connType);
+        throw new Error("Unsupported connection type: " + channelType);
       }
-      const rtmCtx = import_RuntimeContext.RuntimeContext.getInstance(runtime, connData);
-      this.#loadModules(runtime, configName, jfr, rtmCtx);
+      const rtmCtx = import_RuntimeContext.RuntimeContext.getInstance(runtime, connectionData);
+      this.#loadModules(runtime, configName, jsonResolver, rtmCtx);
       return rtmCtx;
     }
     if ((0, import_Runtime.isNodejsRuntime)()) {
-      let jfr = new import_JsonFileResolver.JsonFileResolver(this.configSource);
       try {
-        const licenseKey = jfr.getLicenseKey();
-        this.transmitter?.activate(licenseKey);
+        const channelType = jsonResolver.getChannelType(
+          import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime),
+          configName
+        );
+        const licenseKey = jsonResolver.getLicenseKey();
+        let connectionData = null;
+        if (channelType === "inMemory") {
+          connectionData = new import_InMemoryConnectionData.InMemoryConnectionData();
+        } else if (channelType === "tcp") {
+          connectionData = new import_TcpConnectionData.TcpConnectionData(
+            jsonResolver.getChannelHost(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName),
+            /** @type {number} */
+            jsonResolver.getChannelPort(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName)
+          );
+        } else if (channelType === "webSocket") {
+          connectionData = new import_WsConnectionData.WsConnectionData(
+            jsonResolver.getChannelHost(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName)
+          );
+        } else {
+          throw new Error("Unsupported connection type: " + channelType);
+        }
+        const rtmCtx = import_RuntimeContext.RuntimeContext.getInstance(runtime, connectionData);
+        this.#loadModules(runtime, configName, jsonResolver, rtmCtx);
+        return rtmCtx;
       } catch (error) {
         throw error;
       }
-      let rtmCtx = null;
-      let connData = null;
-      let connType = jfr.getChannelType(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName);
-      if (connType === "inMemory") {
-        connData = new import_InMemoryConnectionData.InMemoryConnectionData();
-      } else if (connType === "tcp") {
-        connData = new import_TcpConnectionData.TcpConnectionData(
-          jfr.getChannelHost(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName),
-          jfr.getChannelPort(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName)
-        );
-      } else if (connType === "webSocket") {
-        connData = new import_WsConnectionData.WsConnectionData(
-          jfr.getChannelHost(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName)
-        );
-      } else {
-        throw new Error("Unsupported connection type: " + connType);
-      }
-      rtmCtx = import_RuntimeContext.RuntimeContext.getInstance(runtime, connData);
-      this.#loadModules(runtime, configName, jfr, rtmCtx);
-      return rtmCtx;
     }
+    throw new Error("Unsupported runtime environment");
   }
-  // @ts-ignore
-  #loadModules(runtime, configName, jfr, rtmCtx) {
+  /**
+   * @param {number} runtime
+   * @param {string} configName
+   * @param {JsonResolver} jsonResolver
+   * @param {RuntimeContext} rtmCtx
+   */
+  #loadModules(runtime, configName, jsonResolver, rtmCtx) {
     try {
-      const modules = jfr.getModules(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName).split(",").filter((module2) => module2.trim() !== "");
+      const modules = jsonResolver.getModules(import_RuntimeNameHandler.RuntimeNameHandler.getName(runtime), configName).split(",").filter((module2) => module2.trim() !== "");
       if ((0, import_Runtime.isNodejsRuntime)()) {
-        if (typeof this.configSource !== "string") {
-          throw new Error("configSource is not a string");
-        }
-        const path = requireDynamic("path");
-        const configDirectoryAbsolutePath = path?.dirname(this.configSource);
+        const path = (
+          /** @type {import('path').PlatformPath} */
+          /** @type {unknown} */
+          requireDynamic("path")
+        );
+        const configDirectoryAbsolutePath = process.cwd();
         modules.forEach((module2) => {
-          if (path?.isAbsolute(module2)) {
+          if (path.isAbsolute(module2)) {
             rtmCtx.loadLibrary(module2);
           } else {
-            rtmCtx.loadLibrary(path?.join(configDirectoryAbsolutePath, module2));
+            rtmCtx.loadLibrary(path.join(configDirectoryAbsolutePath, module2));
           }
         });
       }