javonet-ruby-sdk 2.5.16 → 2.5.18

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/handler/ValueHandler.cjs

@@ -26,6 +26,10 @@ class ValueHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
   }
+  /**
+   * @param {Command} command
+   * @returns {unknown}
+   */
   process(command) {
     const { payload } = command;
     return payload[0];

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/interpreter/Interpreter.cjs

@@ -3,7 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,13 +16,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var Interpreter_exports = {};
 __export(Interpreter_exports, {
   Interpreter: () => Interpreter
 });
 module.exports = __toCommonJS(Interpreter_exports);
-const import_meta = {};
 var import_ConnectionType = require("../../utils/ConnectionType.cjs");
 var import_Runtime = require("../../utils/Runtime.cjs");
 var import_RuntimeName = require("../../utils/RuntimeName.cjs");
@@ -32,6 +29,7 @@ var import_CommandSerializer = require("../protocol/CommandSerializer.cjs");
 var import_TransmitterWebsocketBrowser = require("../transmitter/TransmitterWebsocketBrowser.cjs");
 var import_TransmitterWebsocket = require("../transmitter/TransmitterWebsocket.cjs");
 var import_Handler = require("../handler/Handler.cjs");
+const import_meta = {};
 let _Receiver = null;
 let _Transmitter = null;
 let _TransmitterWebsocket = null;
@@ -40,9 +38,8 @@ if (!_TransmitterWebsocket) {
 }
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class Interpreter {
-  constructor() {
-    __publicField(this, "handler");
-  }
+  /** @type {Handler | null} */
+  handler = null;
   /**
    *
    * @param {Command} command
@@ -51,21 +48,24 @@ class Interpreter {
    */
   async executeAsync(command, connectionData) {
     try {
+      if (!this.handler) {
+        this.handler = new import_Handler.Handler(this);
+      }
       let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
-      let responseByteArray;
+      let responseByteArray = void 0;
       if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
         if ((0, import_Runtime.isNodejsRuntime)()) {
           if (!_Receiver) {
             const { Receiver } = require("../receiver/Receiver.cjs");
             _Receiver = Receiver;
           }
-          responseByteArray = _Receiver.sendCommand(messageByteArray);
+          responseByteArray = _Receiver?.sendCommand(messageByteArray);
         } else {
           throw new Error("Node.js runtime not found");
         }
       } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
         try {
-          const _response = await _TransmitterWebsocket.sendCommand(
+          const _response = await _TransmitterWebsocket?.sendCommand(
             messageByteArray,
             connectionData
           );
@@ -84,11 +84,14 @@ class Interpreter {
             const { Transmitter } = require("../transmitter/Transmitter.cjs");
             _Transmitter = Transmitter;
           }
-          responseByteArray = await _Transmitter.sendCommand(messageByteArray);
+          responseByteArray = await _Transmitter?.sendCommand(messageByteArray);
         } else {
           throw new Error("Allowed only to run in nodejs runtime");
         }
       }
+      if (!responseByteArray) {
+        throw new Error("No response received from Transmitter");
+      }
       return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
     } catch (error) {
       throw error;
@@ -97,23 +100,29 @@ class Interpreter {
   /**
    *
    * @param {Command} command
-   * @param {WsConnectionData} connectionData
-   * @returns {Promise<Command>}
+   * @param {IConnectionData} connectionData
+   * @returns {Command | Promise<Command>}
    */
   execute(command, connectionData) {
     try {
+      if (!this.handler) {
+        this.handler = new import_Handler.Handler(this);
+      }
       let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
-      let responseByteArray;
+      let responseByteArray = void 0;
       if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
         if ((0, import_Runtime.isNodejsRuntime)()) {
           if (!_Receiver) {
             const { Receiver } = require("../receiver/Receiver.cjs");
             _Receiver = Receiver;
           }
-          responseByteArray = _Receiver.sendCommand(messageByteArray);
+          responseByteArray = _Receiver?.sendCommand(messageByteArray);
         }
       } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
-        const promise = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData);
+        const promise = _TransmitterWebsocket?.sendCommand(messageByteArray, connectionData);
+        if (!promise) {
+          throw new Error("TransmitterWebsocket not found");
+        }
         return promise.then((_response) => {
           if (_response) {
             const command2 = new import_CommandDeserializer.CommandDeserializer(_response).deserialize();
@@ -130,11 +139,14 @@ class Interpreter {
             const { Transmitter } = require("../transmitter/Transmitter.cjs");
             _Transmitter = Transmitter;
           }
-          responseByteArray = _Transmitter.sendCommand(messageByteArray);
+          responseByteArray = _Transmitter?.sendCommand(messageByteArray);
         } else {
           throw new Error("Allowed only to run in nodejs runtime");
         }
       }
+      if (!responseByteArray) {
+        throw new Error("No response received from Transmitter");
+      }
       return new import_CommandDeserializer.CommandDeserializer(responseByteArray).deserialize();
     } catch (error) {
       throw error;
@@ -142,7 +154,7 @@ class Interpreter {
   }
   /**
    *
-   * @param {number[]} messageByteArray
+   * @param {Int8Array} messageByteArray
    * @returns {Command}
    */
   process(messageByteArray) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/namespaceCache/NamespaceCache.cjs

@@ -3,7 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,26 +16,38 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var NamespaceCache_exports = {};
 __export(NamespaceCache_exports, {
   NamespaceCache: () => NamespaceCache
 });
 module.exports = __toCommonJS(NamespaceCache_exports);
-const _NamespaceCache = class _NamespaceCache {
+class NamespaceCache {
+  /** @type {NamespaceCache | null} */
+  static _instance = null;
+  /** @type {string[]} */
+  namespaceCache = [];
   constructor() {
-    __publicField(this, "namespaceCache", []);
-    if (_NamespaceCache._instance === null) {
-      _NamespaceCache._instance = this;
+    if (NamespaceCache._instance === null) {
+      NamespaceCache._instance = this;
     }
-    return _NamespaceCache._instance;
+    return NamespaceCache._instance;
   }
+  /**
+   * @param {string} namespaceRegex
+   */
   cacheNamespace(namespaceRegex) {
     this.namespaceCache.push(namespaceRegex);
   }
+  /**
+   * @returns {boolean}
+   */
   isNamespaceCacheEmpty() {
     return this.namespaceCache.length === 0;
   }
+  /**
+   * @param {string} typeToCheck
+   * @returns {boolean}
+   */
   isTypeAllowed(typeToCheck) {
     for (let pattern of this.namespaceCache) {
       if (new RegExp(pattern).test(typeToCheck.constructor.name)) {
@@ -52,9 +63,7 @@ const _NamespaceCache = class _NamespaceCache {
     this.namespaceCache = [];
     return 0;
   }
-};
-__publicField(_NamespaceCache, "_instance", null);
-let NamespaceCache = _NamespaceCache;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   NamespaceCache

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

@@ -22,10 +22,12 @@ __export(CommandDeserializer_exports, {
 });
 module.exports = __toCommonJS(CommandDeserializer_exports);
 var import_Command = require("../../utils/Command.cjs");
-var import_CommandType = require("../../utils/CommandType.cjs");
 var import_Type = require("../../utils/Type.cjs");
 var import_TypeDeserializer = require("./TypeDeserializer.cjs");
 class CommandDeserializer {
+  /**
+   * @param {Int8Array} buffer
+   */
   constructor(buffer) {
     this.buffer = buffer;
     this.command = new import_Command.Command(buffer[0], buffer[10], []);
@@ -43,8 +45,14 @@ class CommandDeserializer {
   isAtEnd() {
     return this.position === this.buffer.length;
   }
+  /**
+   * @param {number} typeNum
+   * @returns {any}
+   */
   readObject(typeNum) {
-    const type = Object.entries(import_Type.Type).find((entry) => entry[1] === typeNum)[0];
+    const entry = Object.entries(import_Type.Type).find((entry2) => entry2[1] === typeNum);
+    if (!entry) throw new Error("Unknown type number: " + typeNum);
+    const type = entry[0];
     switch (type) {
       case "JAVONET_COMMAND":
         return this.readCommand();

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

@@ -22,28 +22,48 @@ __export(CommandSerializer_exports, {
 });
 module.exports = __toCommonJS(CommandSerializer_exports);
 var import_TypeSerializer = require("./TypeSerializer.cjs");
+var import_ReferencesCache = require("../referenceCache/ReferencesCache.cjs");
 var import_Command = require("../../utils/Command.cjs");
+var import_CommandType = require("../../utils/CommandType.cjs");
 var import_RuntimeName = require("../../utils/RuntimeName.cjs");
+var import_TypesHandler = require("../../utils/TypesHandler.cjs");
 class CommandSerializer {
-  serialize(rootCommand, connectionData) {
+  /**
+   * Serializes the root command with connection data and optional runtime version.
+   * @param {Command} rootCommand
+   * @param {IConnectionData} connectionData
+   * @param {number} runtimeVersion
+   * @returns {Int8Array}
+   */
+  serialize(rootCommand, connectionData, runtimeVersion = 0) {
     const buffers = [];
-    buffers.push(Uint8Array.of(rootCommand.runtimeName, 0));
+    buffers.push(Uint8Array.of(rootCommand.runtimeName, runtimeVersion));
     if (connectionData) {
       buffers.push(connectionData.serializeConnectionData());
     } else {
       buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0));
     }
-    buffers.push(Uint8Array.of(import_RuntimeName.RuntimeName.Nodejs, rootCommand.commandType));
+    buffers.push(Uint8Array.of(import_RuntimeName.RuntimeName.Python, rootCommand.commandType));
     this.serializeRecursively(rootCommand, buffers);
     return concatenateUint8Arrays(buffers);
   }
+  /**
+   * Recursively serializes command payload.
+   * @param {Command} command
+   * @param {Array<Uint8Array>} buffers
+   */
   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);
-      } else {
+      } 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);
       }
     }
   }

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

@@ -25,9 +25,17 @@ var import_Command = require("../../utils/Command.cjs");
 var import_buffer = require("buffer");
 var import_StringEncodingMode = require("../../utils/StringEncodingMode.cjs");
 class TypeDeserializer {
+  /**
+   * @param {Int8Array} encodedCommand
+   * @returns {Command}
+   */
   static deserializeCommand(encodedCommand) {
     return new import_Command.Command(encodedCommand[0], encodedCommand[1], []);
   }
+  /**
+   * @param {number} stringEncodingMode
+   * @param {Int8Array} encodedString
+   */
   static deserializeString(stringEncodingMode, encodedString) {
     switch (stringEncodingMode) {
       case import_StringEncodingMode.StringEncodingMode.ASCII:
@@ -53,30 +61,57 @@ class TypeDeserializer {
         throw "Unknown string encoding - not supported in JavaScript";
     }
   }
+  /**
+   * @param {Int8Array} encodedInt
+   */
   static deserializeInt(encodedInt) {
     return encodedInt[0] & 255 | (encodedInt[1] & 255) << 8 | (encodedInt[2] & 255) << 16 | (encodedInt[3] & 255) << 24;
   }
+  /**
+   * @param {Int8Array} encodedBool
+   */
   static deserializeBool(encodedBool) {
     return encodedBool[0] === 1;
   }
+  /**
+   * @param {Int8Array} encodedFloat
+   */
   static deserializeFloat(encodedFloat) {
     return import_buffer.Buffer.from(encodedFloat).readFloatLE();
   }
+  /**
+   * @param {Int8Array} encodedByte
+   */
   static deserializeByte(encodedByte) {
     return import_buffer.Buffer.from(encodedByte).readUint8();
   }
+  /**
+   * @param {Int8Array} encodedChar
+   */
   static deserializeChar(encodedChar) {
     return import_buffer.Buffer.from(encodedChar).readUint8();
   }
+  /**
+   * @param {Int8Array} encodedLongLong
+   */
   static deserializeLongLong(encodedLongLong) {
     return import_buffer.Buffer.from(encodedLongLong).readBigInt64LE();
   }
+  /**
+   * @param {Int8Array} encodedDouble
+   */
   static deserializeDouble(encodedDouble) {
     return import_buffer.Buffer.from(encodedDouble).readDoubleLE();
   }
+  /**
+   * @param {Int8Array} encodedULLong
+   */
   static deserializeULLong(encodedULLong) {
     return import_buffer.Buffer.from(encodedULLong).readBigUInt64LE();
   }
+  /**
+   * @param {Int8Array} encodedUInt
+   */
   static deserializeUInt(encodedUInt) {
     return import_buffer.Buffer.from(encodedUInt).readUIntLE(0, 4);
   }

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

@@ -3,7 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,20 +16,20 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var Receiver_exports = {};
 __export(Receiver_exports, {
   Receiver: () => Receiver
 });
 module.exports = __toCommonJS(Receiver_exports);
-const import_meta = {};
 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");
+const import_meta = {};
 let _RuntimeLogger = null;
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class Receiver {
+  static connectionData = new import_InMemoryConnectionData.InMemoryConnectionData();
   Receiver() {
     if (!_RuntimeLogger) {
       const { RuntimeLogger } = require("../../utils/RuntimeLogger.cjs");
@@ -39,7 +38,7 @@ class Receiver {
     _RuntimeLogger?.printRuntimeInfo();
   }
   /**
-   * @param {number[]} messageByteArray
+   * @param {Int8Array} messageByteArray
    */
   static sendCommand(messageByteArray) {
     return new import_CommandSerializer.CommandSerializer().serialize(
@@ -58,7 +57,6 @@ class Receiver {
     return response;
   }
 }
-__publicField(Receiver, "connectionData", new import_InMemoryConnectionData.InMemoryConnectionData());
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Receiver

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

@@ -3,7 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,7 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var Transmitter_exports = {};
 __export(Transmitter_exports, {
   Transmitter: () => Transmitter
@@ -25,19 +23,35 @@ __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);
   }
+  /**
+   * @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);
   }
 }
-__publicField(Transmitter, "activate", function(licenseKey) {
-  return import_TransmitterWrapper.TransmitterWrapper.activate(licenseKey);
-});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Transmitter

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: