javonet-nodejs-sdk 2.6.4 → 2.6.5

package/dist/core/handler/Handler.cjs

@@ -146,10 +146,16 @@ class Handler {
   handleCommand(command) {
     try {
       if (command.commandType === import_CommandType.CommandType.RetrieveArray) {
-        let responseArray = handlers[import_CommandType.CommandType.Reference].handleCommand(command.payload[0]);
-        return import_Command.Command.createArrayResponse(responseArray, command.runtimeName);
+        const responseArray = handlers[import_CommandType.CommandType.Reference].handleCommand(command.payload[0]);
+        if (responseArray instanceof Promise) {
+          return responseArray.then((resolvedResponseArray) => {
+            return import_Command.Command.createArrayResponse(resolvedResponseArray, command.runtimeName);
+          });
+        } else {
+          return import_Command.Command.createArrayResponse(responseArray, command.runtimeName);
+        }
       }
-      let response = handlers[command.commandType].handleCommand(command);
+      const response = handlers[command.commandType].handleCommand(command);
       return this.parseCommand(response, command.runtimeName);
     } catch (e) {
       return import_ExceptionSerializer.ExceptionSerializer.serializeException(e, command);
@@ -158,9 +164,14 @@ class Handler {
   /**
    * @param {any} response
    * @param {RuntimeName} runtimeName
-   * @returns {Command}
+   * @returns {Promise<Command> | Command}
    */
   parseCommand(response, runtimeName) {
+    if (response instanceof Promise) {
+      return response.then((resolvedResponse) => {
+        return this.parseCommand(resolvedResponse, runtimeName);
+      });
+    }
     if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(response)) {
       return import_Command.Command.createResponse(response, runtimeName);
     } else {

package/dist/core/handler/LoadLibraryHandler.cjs

@@ -23,6 +23,8 @@ __export(LoadLibraryHandler_exports, {
 module.exports = __toCommonJS(LoadLibraryHandler_exports);
 var import_Runtime = require("../../utils/Runtime.cjs");
 var import_AbstractHandler = require("./AbstractHandler.cjs");
+var import_fs = require("fs");
+var import_path = require("path");
 const import_meta = {};
 const dynamicImport = (0, import_Runtime.getRequire)(import_meta.url);
 class LoadLibraryHandler extends import_AbstractHandler.AbstractHandler {
@@ -41,6 +43,13 @@ class LoadLibraryHandler extends import_AbstractHandler.AbstractHandler {
     }
     let { payload } = command;
     let [lib] = payload;
+    if (!lib) {
+      throw new Error("Cannot load module: Library path is required but was not provided");
+    }
+    const absolutePath = (0, import_path.resolve)(lib);
+    if (!(0, import_fs.existsSync)(lib) && !(0, import_fs.existsSync)(absolutePath)) {
+      throw new Error(`Cannot load module: Library not found: ${lib}`);
+    }
     let pathArray = lib.split(/[/\\]/);
     let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0];
     libraryName = libraryName.replace(".js", "");
@@ -49,12 +58,7 @@ class LoadLibraryHandler extends import_AbstractHandler.AbstractHandler {
       moduleExports = dynamicImport(lib);
       LoadLibraryHandler.loadedLibraries.push(lib);
     } catch (error) {
-      try {
-        const modulePath = `${process.cwd()}/${lib}`;
-        moduleExports = dynamicImport(modulePath);
-      } catch (error2) {
-        throw this.process_stack_trace(error2, this.constructor.name);
-      }
+      throw Error("Cannot load module: " + lib + "\n" + error);
     }
     global[libraryName] = moduleExports;
     for (const [key, value] of Object.entries(moduleExports)) {

package/dist/core/interpreter/Interpreter.cjs

@@ -30,8 +30,8 @@ var import_TransmitterWebsocketBrowser = require("../transmitter/TransmitterWebs
 var import_TransmitterWebsocket = require("../transmitter/TransmitterWebsocket.cjs");
 var import_Handler = require("../handler/Handler.cjs");
 const import_meta = {};
-let _Receiver = null;
-let _Transmitter = null;
+let _Receiver;
+let _Transmitter;
 let _TransmitterWebsocket = null;
 if (!_TransmitterWebsocket) {
   _TransmitterWebsocket = (0, import_Runtime.isNodejsRuntime)() ? import_TransmitterWebsocket.TransmitterWebsocket : import_TransmitterWebsocketBrowser.TransmitterWebsocketBrowser;
@@ -58,7 +58,10 @@ class Interpreter {
       let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
       let responseByteArray = void 0;
       if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
-        const _response = await _TransmitterWebsocket?.sendCommand(messageByteArray, connectionData);
+        const _response = await _TransmitterWebsocket?.sendCommand(
+          await messageByteArray,
+          connectionData
+        );
         if (_response) {
           const command2 = new import_CommandDeserializer.CommandDeserializer(_response).deserialize();
           return command2;
@@ -74,13 +77,13 @@ class Interpreter {
             const { Receiver } = require("../receiver/Receiver.cjs");
             _Receiver = Receiver;
           }
-          responseByteArray = await _Receiver?.sendCommand(messageByteArray);
+          responseByteArray = await _Receiver?.sendCommand(await messageByteArray);
         } else {
           if (!_Transmitter) {
             const { Transmitter } = require("../transmitter/Transmitter.cjs");
             _Transmitter = Transmitter;
           }
-          responseByteArray = await _Transmitter?.sendCommand(messageByteArray);
+          responseByteArray = await _Transmitter?.sendCommand(await messageByteArray);
         }
       }
       if (!responseByteArray) {
@@ -103,37 +106,60 @@ class Interpreter {
       let responseByteArray = void 0;
       if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
         throw new Error("Not supported");
-      }
-      if (connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
+      } else {
         if (!(0, import_Runtime.isNodejsRuntime)()) {
           throw new Error("InMemory is only allowed in Nodejs runtime");
         }
-        if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs) {
+        if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
           if (!_Receiver) {
             const { Receiver } = require("../receiver/Receiver.cjs");
             _Receiver = Receiver;
           }
-          responseByteArray = _Receiver?.sendCommand(messageByteArray);
+          if (!_Receiver) {
+            throw new Error("Receiver is undefined");
+          }
+          if (messageByteArray instanceof Uint8Array) {
+            responseByteArray = _Receiver.sendCommand(messageByteArray);
+          } else {
+            responseByteArray = messageByteArray.then((resolvedMessage) => {
+              return _Receiver.sendCommand(resolvedMessage);
+            });
+          }
         } else {
           if (!_Transmitter) {
             const { Transmitter } = require("../transmitter/Transmitter.cjs");
             _Transmitter = Transmitter;
           }
-          responseByteArray = _Transmitter?.sendCommand(messageByteArray);
+          if (!_Transmitter) {
+            throw new Error("Transmitter is undefined");
+          }
+          if (messageByteArray instanceof Uint8Array) {
+            responseByteArray = _Transmitter.sendCommand(messageByteArray);
+          } else {
+            responseByteArray = messageByteArray.then((resolvedMessage) => {
+              return _Transmitter.sendCommand(resolvedMessage);
+            });
+          }
+        }
+        if (!responseByteArray) {
+          throw new Error("No response received from Transmitter");
+        }
+        if (responseByteArray instanceof Promise) {
+          return responseByteArray.then((resolvedResponse) => {
+            return new import_CommandDeserializer.CommandDeserializer(resolvedResponse).deserialize();
+          });
+        } else {
+          return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
         }
       }
-      if (!responseByteArray) {
-        throw new Error("No response received from Transmitter");
-      }
-      return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
     } catch (error) {
       throw error;
     }
   }
   /**
    *
-   * @param {Int8Array} messageByteArray
-   * @returns {Command}
+   * @param {Uint8Array} messageByteArray
+   * @returns {Promise<Command> | Command}
    */
   process(messageByteArray) {
     try {

package/dist/core/protocol/CommandDeserializer.cjs

@@ -26,11 +26,11 @@ var import_Type = require("../../utils/Type.cjs");
 var import_TypeDeserializer = require("./TypeDeserializer.cjs");
 class CommandDeserializer {
   /**
-   * @param {Int8Array} buffer
+   * @param {Uint8Array} byteArray
    */
-  constructor(buffer) {
-    this.buffer = buffer;
-    this.command = new import_Command.Command(buffer[0], buffer[10], []);
+  constructor(byteArray) {
+    this.buffer = byteArray;
+    this.command = new import_Command.Command(this.buffer[0], this.buffer[10], []);
     this.position = 11;
   }
   /**

package/dist/core/protocol/CommandSerializer.cjs

@@ -30,13 +30,18 @@ var import_TypesHandler = require("../../utils/TypesHandler.cjs");
 class CommandSerializer {
   /**
    * Serializes the root command with connection data and optional runtime version.
-   * @param {Command} rootCommand
+   * @param {Promise<Command> | Command} rootCommand
    * @param {IConnectionData} connectionData
    * @param {number} runtimeVersion
-   * @returns {Int8Array}
+   * @returns {Promise<Uint8Array> | Uint8Array}
    */
   serialize(rootCommand, connectionData, runtimeVersion = 0) {
     const buffers = [];
+    if (rootCommand instanceof Promise) {
+      return rootCommand.then((resolvedCommand) => {
+        return this.serialize(resolvedCommand, connectionData, runtimeVersion);
+      });
+    }
     buffers.push(Uint8Array.of(rootCommand.runtimeName, runtimeVersion));
     if (connectionData) {
       buffers.push(connectionData.serializeConnectionData());

package/dist/core/protocol/TypeDeserializer.cjs

@@ -26,7 +26,7 @@ var import_buffer = require("buffer");
 var import_StringEncodingMode = require("../../utils/StringEncodingMode.cjs");
 class TypeDeserializer {
   /**
-   * @param {Int8Array} encodedCommand
+   * @param {Uint8Array} encodedCommand
    * @returns {Command}
    */
   static deserializeCommand(encodedCommand) {
@@ -34,7 +34,7 @@ class TypeDeserializer {
   }
   /**
    * @param {number} stringEncodingMode
-   * @param {Int8Array} encodedString
+   * @param {Uint8Array} encodedString
    */
   static deserializeString(stringEncodingMode, encodedString) {
     switch (stringEncodingMode) {
@@ -62,55 +62,55 @@ class TypeDeserializer {
     }
   }
   /**
-   * @param {Int8Array} encodedInt
+   * @param {Uint8Array} encodedInt
    */
   static deserializeInt(encodedInt) {
     return encodedInt[0] & 255 | (encodedInt[1] & 255) << 8 | (encodedInt[2] & 255) << 16 | (encodedInt[3] & 255) << 24;
   }
   /**
-   * @param {Int8Array} encodedBool
+   * @param {Uint8Array} encodedBool
    */
   static deserializeBool(encodedBool) {
     return encodedBool[0] === 1;
   }
   /**
-   * @param {Int8Array} encodedFloat
+   * @param {Uint8Array} encodedFloat
    */
   static deserializeFloat(encodedFloat) {
     return import_buffer.Buffer.from(encodedFloat).readFloatLE();
   }
   /**
-   * @param {Int8Array} encodedByte
+   * @param {Uint8Array} encodedByte
    */
   static deserializeByte(encodedByte) {
     return import_buffer.Buffer.from(encodedByte).readUint8();
   }
   /**
-   * @param {Int8Array} encodedChar
+   * @param {Uint8Array} encodedChar
    */
   static deserializeChar(encodedChar) {
     return import_buffer.Buffer.from(encodedChar).readUint8();
   }
   /**
-   * @param {Int8Array} encodedLongLong
+   * @param {Uint8Array} encodedLongLong
    */
   static deserializeLongLong(encodedLongLong) {
     return import_buffer.Buffer.from(encodedLongLong).readBigInt64LE();
   }
   /**
-   * @param {Int8Array} encodedDouble
+   * @param {Uint8Array} encodedDouble
    */
   static deserializeDouble(encodedDouble) {
     return import_buffer.Buffer.from(encodedDouble).readDoubleLE();
   }
   /**
-   * @param {Int8Array} encodedULLong
+   * @param {Uint8Array} encodedULLong
    */
   static deserializeULLong(encodedULLong) {
     return import_buffer.Buffer.from(encodedULLong).readBigUInt64LE();
   }
   /**
-   * @param {Int8Array} encodedUInt
+   * @param {Uint8Array} encodedUInt
    */
   static deserializeUInt(encodedUInt) {
     return import_buffer.Buffer.from(encodedUInt).readUIntLE(0, 4);

package/dist/core/receiver/Receiver.cjs

@@ -38,14 +38,13 @@ class Receiver {
     return import_RuntimeLogger.RuntimeLogger.getRuntimeInfo();
   }
   /**
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
+   * @returns {Promise<Uint8Array> | Uint8Array}
    */
   static sendCommand(messageByteArray) {
     try {
-      return new import_CommandSerializer.CommandSerializer().serialize(
-        new import_Interpreter.Interpreter().process(messageByteArray),
-        this.connectionData
-      );
+      let command = new import_Interpreter.Interpreter().process(messageByteArray);
+      return new import_CommandSerializer.CommandSerializer().serialize(command, this.connectionData);
     } catch (error) {
       const exceptionCommand = import_ExceptionSerializer.ExceptionSerializer.serializeException(
         error,
@@ -55,11 +54,11 @@ class Receiver {
     }
   }
   /**
-   * @param {Int8Array} messageByteArray
-   * @returns {Int8Array}
+   * @param {Uint8Array} messageByteArray
+   * @returns {Promise<Uint8Array> | Uint8Array}
    */
   static heartBeat(messageByteArray) {
-    let response = new Int8Array(2);
+    let response = new Uint8Array(2);
     response[0] = messageByteArray[11];
     response[1] = messageByteArray[12] - 2;
     return response;

package/dist/core/receiver/ReceiverNative.cjs

@@ -24,13 +24,15 @@ module.exports = __toCommonJS(ReceiverNative_exports);
 var import_Receiver = require("./Receiver.cjs");
 class ReceiverNative {
   /**
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
+   * @returns {Promise<Uint8Array> | Uint8Array}
    */
   static sendCommand(messageByteArray) {
     return import_Receiver.Receiver.sendCommand(messageByteArray);
   }
   /**
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
+   * @returns {Uint8Array | Promise<Uint8Array>}
    */
   static heartBeat(messageByteArray) {
     return import_Receiver.Receiver.heartBeat(messageByteArray);

package/dist/core/transmitter/Transmitter.cjs

@@ -24,8 +24,8 @@ module.exports = __toCommonJS(Transmitter_exports);
 var import_TransmitterWrapper = require("./TransmitterWrapper.cjs");
 class Transmitter {
   /**
-   * @param {Int8Array} messageArray
-   * @returns {Int8Array}
+   * @param {Uint8Array} messageArray
+   * @returns {Uint8Array}
    */
   static sendCommand(messageArray) {
     return import_TransmitterWrapper.TransmitterWrapper.sendCommand(messageArray);

package/dist/core/transmitter/TransmitterWebsocket.cjs

@@ -40,9 +40,9 @@ class TransmitterWebsocket {
   }
   /**
    * @async
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
    * @param {IConnectionData} connectionData
-   * @returns {Promise<Int8Array>} responseByteArray
+   * @returns {Promise<Uint8Array>} responseByteArray
    */
   static sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;

package/dist/core/transmitter/TransmitterWebsocketBrowser.cjs

@@ -35,9 +35,9 @@ class TransmitterWebsocketBrowser {
   }
   /**
    * @async
-   * @param {Int8Array} messageByteArray
+   * @param {Uint8Array} messageByteArray
    * @param {IConnectionData} connectionData
-   * @returns {Promise<Int8Array>} responseByteArray
+   * @returns {Promise<Uint8Array>} responseByteArray
    */
   static async sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;

package/dist/core/transmitter/TransmitterWrapper.cjs

@@ -65,7 +65,8 @@ class TransmitterWrapper {
     return library.activate(licenseKey);
   }
   /**
-   * @param {Int8Array} messageArray
+   * @param {Uint8Array} messageArray
+   * @returns {Uint8Array}
    */
   static sendCommand(messageArray) {
     this.loadNativeLibrary();

package/dist/core/webSocketClient/WebSocketClient.cjs

@@ -62,8 +62,8 @@ class WebSocketClient {
   /**
    * Sends messageArray through websocket connection with guaranteed order preservation
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
@@ -104,8 +104,8 @@ class WebSocketClient {
    * Sends a single message through websocket connection
    * @private
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   _send(messageArray) {
     return new Promise((resolve, reject) => {

package/dist/core/webSocketClient/WebSocketClientBrowser.cjs

@@ -60,8 +60,8 @@ class WebSocketClientBrowser {
   /**
    * Sends messageArray through websocket connection with guaranteed order preservation
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
@@ -102,8 +102,8 @@ class WebSocketClientBrowser {
    * Sends a single message through websocket connection
    * @private
    * @async
-   * @param {Int8Array} messageArray
-   * @returns {Promise<Int8Array>}
+   * @param {Uint8Array} messageArray
+   * @returns {Promise<Uint8Array>}
    */
   _sendSingle(messageArray) {
     return new Promise((resolve, reject) => {
@@ -162,8 +162,8 @@ class WebSocketClientBrowser {
    * Sends the data to the WebSocket server and listens for a response.
    * @private
    * @param {WebSocket} client
-   * @param {Int8Array} data
-   * @param {(value: Int8Array) => void} resolve
+   * @param {Uint8Array} data
+   * @param {(value: Uint8Array) => void} resolve
    * @param {(reason?: any) => void} reject
    */
   _sendMessage(client, data, resolve, reject) {
@@ -174,7 +174,7 @@ class WebSocketClientBrowser {
         if (!message?.data) {
           return reject(new Error("Invalid message received"));
         }
-        const byteArray = new Int8Array(message?.data);
+        const byteArray = new Uint8Array(message?.data);
         resolve(byteArray);
         if (this.isDisconnectedAfterMessage) {
           this.disconnect();

package/dist/sdk/InvocationContext.cjs

@@ -37,12 +37,10 @@ class InvocationContext {
   #connectionData;
   /** @type {Command | null} */
   #currentCommand = null;
-  /** @type {Command | null} */
+  /** @type {Command | Promise<Command> | null} */
   #responseCommand = null;
   /** @type {boolean} */
   #isExecuted = false;
-  /** @type {any | null} */
-  #resultValue = null;
   /** @type {Interpreter | null} */
   #interpreter = null;
   /**
@@ -59,7 +57,6 @@ class InvocationContext {
     this.#responseCommand = null;
     this.#isExecuted = isExecuted;
     this.#interpreter = null;
-    this.#resultValue = null;
   }
   /**
    * @param {Command} localCommand
@@ -100,7 +97,18 @@ class InvocationContext {
       throw new Error("Object is not iterable");
     }
     let position = -1;
-    const arraySize = Number(this.getSize().execute().getValue());
+    let arraySize = 0;
+    const sizeCtx = (
+      /** @type {any} */
+      this.getSize().execute()
+    );
+    if (sizeCtx instanceof Promise) {
+      sizeCtx.then((ctx) => {
+        arraySize = Number(ctx.getValue());
+      });
+    } else {
+      arraySize = Number(sizeCtx.getValue());
+    }
     return {
       next: () => ({
         value: this.getIndex(++position),
@@ -115,7 +123,7 @@ class InvocationContext {
    * Commands are becoming nested through each invocation of methods on Invocation Context.
    * Each invocation triggers the creation of new Invocation Context instance wrapping the current command with new parent command valid for invoked method.
    * Developer can decide on any moment of the materialization for the context taking full control of the chunks of the expression being transferred and processed on target runtime.
-   * @returns {InvocationContext} the InvocationContext after executing the command.
+   * @returns {Promise<InvocationContext> | InvocationContext} the InvocationContext after executing the command.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
    * @method
    */
@@ -127,18 +135,25 @@ class InvocationContext {
       this.#interpreter = new import_Interpreter.Interpreter();
     }
     this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionData);
-    if (!this.#responseCommand) {
-      throw new Error("responseCommand is undefined in Invocation Context execute method");
-    }
-    if (this.#responseCommand?.commandType === import_CommandType.CommandType.Exception) {
-      throw import_ExceptionThrower.ExceptionThrower.throwException(this.#responseCommand);
-    }
-    if (this.#responseCommand?.commandType === import_CommandType.CommandType.CreateClassInstance) {
-      this.#currentCommand = this.#responseCommand;
-      this.#isExecuted = true;
-      return this;
+    const handleResponse = (resolvedResponse) => {
+      if (!resolvedResponse) {
+        throw new Error("responseCommand is undefined in Invocation Context execute method");
+      }
+      if (resolvedResponse.commandType === import_CommandType.CommandType.Exception) {
+        throw import_ExceptionThrower.ExceptionThrower.throwException(resolvedResponse);
+      }
+      if (resolvedResponse.commandType === import_CommandType.CommandType.CreateClassInstance) {
+        this.#currentCommand = resolvedResponse;
+        this.#isExecuted = true;
+        return this;
+      }
+      return new InvocationContext(this.#runtimeName, this.#connectionData, resolvedResponse, true);
+    };
+    if (this.#responseCommand instanceof Promise) {
+      return this.#responseCommand.then(handleResponse);
+    } else {
+      return handleResponse(this.#responseCommand);
     }
-    return new InvocationContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true);
   }
   /**
    * Invokes a static method on the target runtime.
@@ -375,7 +390,7 @@ class InvocationContext {
   }
   /**
    * Retrieves the type of the object from the target runtime.
-   * @returns {string} The type of the object.
+   * @returns {Promise<string> | string} The type of the object.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
    * @method
    */
@@ -386,7 +401,11 @@ class InvocationContext {
       this.#connectionData,
       this.#buildCommand(localCommand)
     );
-    const result = invocationContext.execute().getValue();
+    const execCtx = (
+      /** @type {any} */
+      invocationContext.execute()
+    );
+    const result = execCtx.getValue();
     return (
       /** @type {string} */
       result
@@ -403,36 +422,31 @@ class InvocationContext {
   }
   /**
    * Retrieves an array from the target runtime.
-   * @returns {InvocationContext} A new InvocationContext instance that wraps the command to retrieve the array.
-   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/arrays-and-collections/retrieve-array)
+   * @returns {Promise<any[]>}
    * @method
    */
   retrieveArray() {
-    let localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.RetrieveArray, []);
-    let localInvCtx = new InvocationContext(
+    const localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.RetrieveArray, []);
+    const localInvCtx = new InvocationContext(
       this.#runtimeName,
       this.#connectionData,
       this.#buildCommand(localCommand)
     );
     localInvCtx.execute();
-    if (localInvCtx.#responseCommand === null) {
-      throw new Error("responseCommand is undefined in Invocation Context execute method");
-    }
-    return localInvCtx.#responseCommand.payload;
+    const extract = (respCommand) => {
+      return respCommand.payload;
+    };
+    return localInvCtx.#responseCommand instanceof Promise ? localInvCtx.#responseCommand.then(extract) : localInvCtx.#responseCommand?.payload;
   }
   /**
    * Returns the primitive value from the target runtime. This could be any primitive type in JavaScript,
    * such as int, boolean, byte, char, long, double, float, etc.
-   * @returns {Command} The value of the current command.
+   * @returns {unknown} The value of the current command.
    * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
    * @method
    */
-  /**
-   * @returns {unknown}
-   */
   getValue() {
-    this.#resultValue = this.#currentCommand?.payload[0];
-    return this.#resultValue;
+    return this.#currentCommand?.payload[0];
   }
   /**
    * @param {Command} command
@@ -490,8 +504,6 @@ class InvocationWsContext extends InvocationContext {
   #interpreter;
   /** @type {boolean} */
   #isExecuted;
-  /** @type {any | null} */
-  #resultValue;
   /**
    * @param {RuntimeNameType} runtimeName
    * @param {IConnectionData} connectionData
@@ -506,7 +518,6 @@ class InvocationWsContext extends InvocationContext {
     this.#responseCommand = null;
     this.#isExecuted = isExecuted;
     this.#interpreter = null;
-    this.#resultValue = null;
   }
   /**
    * Executes the current command.
@@ -520,7 +531,6 @@ class InvocationWsContext extends InvocationContext {
    * @async
    * @method
    */
-  // @ts-expect-error
   async execute() {
     if (this.#currentCommand === null) {
       throw new Error("currentCommand is undefined in Invocation Context execute method");
@@ -552,7 +562,6 @@ class InvocationWsContext extends InvocationContext {
    * @async
    * @method
    */
-  // @ts-expect-error
   async getResultType() {
     const localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.GetResultType, []);
     const invocationContext = new InvocationWsContext(