javonet-nodejs-sdk 2.5.20 → 2.6.0

package/dist/core/handler/Handler.cjs

@@ -107,8 +107,8 @@ class Handler {
       }
       let response = handlers[command.commandType].handleCommand(command);
       return this.parseCommand(response, command.runtimeName);
-    } catch (error) {
-      return import_ExceptionSerializer.ExceptionSerializer.serializeException(error, command);
+    } catch (e) {
+      return import_ExceptionSerializer.ExceptionSerializer.serializeException(e, command);
     }
   }
   /**

package/dist/core/handler/ResolveReferenceHandler.cjs

@@ -23,6 +23,9 @@ __export(ResolveReferenceHandler_exports, {
 module.exports = __toCommonJS(ResolveReferenceHandler_exports);
 var import_ReferencesCache = require("../referenceCache/ReferencesCache.cjs");
 var import_AbstractHandler = require("./AbstractHandler.cjs");
+var import_CommandType = require("../../utils/CommandType.cjs");
+var import_RuntimeName = require("../../utils/RuntimeName.cjs");
+var import_Command = require("../../utils/Command.cjs");
 class ResolveReferenceHandler extends import_AbstractHandler.AbstractHandler {
   constructor() {
     super();
@@ -32,7 +35,11 @@ class ResolveReferenceHandler extends import_AbstractHandler.AbstractHandler {
    * @returns {any}
    */
   process(command) {
-    return import_ReferencesCache.ReferencesCache.getInstance().resolveReference(command.payload[0]);
+    if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs) {
+      return import_ReferencesCache.ReferencesCache.getInstance().resolveReference(command.payload[0]);
+    } else {
+      return new import_Command.Command(command.runtimeName, import_CommandType.CommandType.Reference, command.payload[0]);
+    }
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/core/interpreter/Interpreter.cjs

@@ -39,7 +39,14 @@ if (!_TransmitterWebsocket) {
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class Interpreter {
   /** @type {Handler | null} */
-  handler = null;
+  _handler = null;
+  /** @type {Handler} */
+  get handler() {
+    if (!this._handler) {
+      this._handler = new import_Handler.Handler(this);
+    }
+    return this._handler;
+  }
   /**
    *
    * @param {Command} command
@@ -48,45 +55,32 @@ 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 = void 0;
-      if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
-        if ((0, import_Runtime.isNodejsRuntime)()) {
+      if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
+        const _response = await _TransmitterWebsocket?.sendCommand(messageByteArray, connectionData);
+        if (_response) {
+          const command2 = new import_CommandDeserializer.CommandDeserializer(_response).deserialize();
+          return command2;
+        } else {
+          throw new Error("Response not received from TransmitterWebsocket");
+        }
+      } else {
+        if (!(0, import_Runtime.isNodejsRuntime)()) {
+          throw new Error("InMemory is only allowed in Nodejs runtime");
+        }
+        if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs) {
           if (!_Receiver) {
             const { Receiver } = require("../receiver/Receiver.cjs");
             _Receiver = Receiver;
           }
-          responseByteArray = _Receiver?.sendCommand(messageByteArray);
+          responseByteArray = await _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(
-            messageByteArray,
-            connectionData
-          );
-          if (_response) {
-            const command2 = new import_CommandDeserializer.CommandDeserializer(_response).deserialize();
-            return command2;
-          } else {
-            throw new Error("Response not received from TransmitterWebsocket");
-          }
-        } catch (error) {
-          throw error;
-        }
-      } else {
-        if ((0, import_Runtime.isNodejsRuntime)()) {
           if (!_Transmitter) {
             const { Transmitter } = require("../transmitter/Transmitter.cjs");
             _Transmitter = Transmitter;
           }
           responseByteArray = await _Transmitter?.sendCommand(messageByteArray);
-        } else {
-          throw new Error("Allowed only to run in nodejs runtime");
         }
       }
       if (!responseByteArray) {
@@ -105,43 +99,27 @@ class Interpreter {
    */
   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 = void 0;
-      if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs && connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
-        if ((0, import_Runtime.isNodejsRuntime)()) {
+      if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
+        throw new Error("Not supported");
+      }
+      if (connectionData.connectionType === import_ConnectionType.ConnectionType.IN_MEMORY) {
+        if (!(0, import_Runtime.isNodejsRuntime)()) {
+          throw new Error("InMemory is only allowed in Nodejs runtime");
+        }
+        if (command.runtimeName === import_RuntimeName.RuntimeName.Nodejs) {
           if (!_Receiver) {
             const { Receiver } = require("../receiver/Receiver.cjs");
             _Receiver = Receiver;
           }
           responseByteArray = _Receiver?.sendCommand(messageByteArray);
-        }
-      } else if (connectionData.connectionType === import_ConnectionType.ConnectionType.WEB_SOCKET) {
-        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();
-            return command2;
-          } else {
-            throw new Error("Response not received from TransmitterWebsocket");
-          }
-        }).catch((error) => {
-          throw error;
-        });
-      } else {
-        if ((0, import_Runtime.isNodejsRuntime)()) {
+        } else {
           if (!_Transmitter) {
             const { Transmitter } = require("../transmitter/Transmitter.cjs");
             _Transmitter = Transmitter;
           }
           responseByteArray = _Transmitter?.sendCommand(messageByteArray);
-        } else {
-          throw new Error("Allowed only to run in nodejs runtime");
         }
       }
       if (!responseByteArray) {
@@ -159,9 +137,6 @@ class Interpreter {
    */
   process(messageByteArray) {
     try {
-      if (!this.handler) {
-        this.handler = new import_Handler.Handler(this);
-      }
       const receivedCommand = new import_CommandDeserializer.CommandDeserializer(messageByteArray).deserialize();
       return this.handler?.handleCommand(receivedCommand);
     } catch (error) {

package/dist/core/receiver/Receiver.cjs

@@ -25,26 +25,34 @@ 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);
+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");
 class Receiver {
   static connectionData = new import_InMemoryConnectionData.InMemoryConnectionData();
   Receiver() {
-    if (!_RuntimeLogger) {
-      const { RuntimeLogger } = require("../../utils/RuntimeLogger.cjs");
-      _RuntimeLogger = RuntimeLogger;
-    }
-    _RuntimeLogger?.printRuntimeInfo();
+  }
+  static getRuntimeInfo() {
+    return import_RuntimeLogger.RuntimeLogger.getRuntimeInfo();
   }
   /**
    * @param {Int8Array} messageByteArray
    */
   static sendCommand(messageByteArray) {
-    return new import_CommandSerializer.CommandSerializer().serialize(
-      new import_Interpreter.Interpreter().process(messageByteArray),
-      this.connectionData
-    );
+    try {
+      return new import_CommandSerializer.CommandSerializer().serialize(
+        new import_Interpreter.Interpreter().process(messageByteArray),
+        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);
+    }
   }
   /**
    * @param {Int8Array} messageByteArray

package/dist/sdk/InvocationContext.cjs

@@ -123,7 +123,9 @@ class InvocationContext {
     if (this.#currentCommand === null) {
       throw new Error("currentCommand is undefined in Invocation Context execute method");
     }
-    this.#interpreter = new import_Interpreter.Interpreter();
+    if (!this.#interpreter) {
+      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");
@@ -495,7 +497,9 @@ class InvocationWsContext extends InvocationContext {
     if (this.#currentCommand === null) {
       throw new Error("currentCommand is undefined in Invocation Context execute method");
     }
-    this.#interpreter = new import_Interpreter.Interpreter();
+    if (!this.#interpreter) {
+      this.#interpreter = new import_Interpreter.Interpreter();
+    }
     this.#responseCommand = await this.#interpreter.executeAsync(
       this.#currentCommand,
       this.#connectionData

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

@@ -1,7 +1,3 @@
-export type Command = import("../../utils/Command.js").Command;
-/**
- * @typedef {import('../../utils/Command.js').Command} Command
- */
 export class ResolveReferenceHandler extends AbstractHandler {
     /**
      * @param {Command} command
@@ -10,3 +6,4 @@ export class ResolveReferenceHandler extends AbstractHandler {
     process(command: Command): any;
 }
 import { AbstractHandler } from './AbstractHandler.js';
+import { Command } from '../../utils/Command.js';

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

@@ -1,6 +1,8 @@
 export class Interpreter {
     /** @type {Handler | null} */
-    handler: Handler | null;
+    _handler: Handler | null;
+    /** @type {Handler} */
+    get handler(): Handler;
     /**
      *
      * @param {Command} command

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

@@ -1,5 +1,6 @@
 export class Receiver {
     static connectionData: InMemoryConnectionData;
+    static getRuntimeInfo(): string;
     /**
      * @param {Int8Array} messageByteArray
      */

package/dist/types/utils/CommandType.d.ts

@@ -41,4 +41,7 @@ export namespace CommandType {
     let PassDelegate: 39;
     let InvokeDelegate: 40;
     let ConvertType: 41;
+    let AddEventListener: 42;
+    let PluginWrapper: 43;
+    let GetAsyncOperationResult: 44;
 }

package/dist/utils/CommandType.cjs

@@ -65,7 +65,10 @@ const CommandType = (
     GetInstanceMethodAsDelegate: 38,
     PassDelegate: 39,
     InvokeDelegate: 40,
-    ConvertType: 41
+    ConvertType: 41,
+    AddEventListener: 42,
+    PluginWrapper: 43,
+    GetAsyncOperationResult: 44
   }
 );
 // Annotate the CommonJS export names for ESM import in node:

package/dist/utils/exception/ExceptionSerializer.cjs

@@ -28,19 +28,31 @@ var import_ExceptionType = require("../ExceptionType.cjs");
 class ExceptionSerializer {
   static serializeException(exception, command) {
     let exceptionCommand = new import_Command.Command(import_RuntimeName.RuntimeName.Nodejs, import_CommandType.CommandType.Exception, []);
-    exceptionCommand = exceptionCommand.addArgToPayload(this.getExceptionCode(exception));
-    exceptionCommand = exceptionCommand.addArgToPayload(command.toString());
-    exceptionCommand = exceptionCommand.addArgToPayload(exception.name);
-    exceptionCommand = exceptionCommand.addArgToPayload(exception.message);
     let stackClasses = [];
     let stackMethods = [];
     let stackLines = [];
     let stackFiles = [];
-    this.serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles);
-    exceptionCommand = exceptionCommand.addArgToPayload(stackClasses.join("|"));
-    exceptionCommand = exceptionCommand.addArgToPayload(stackMethods.join("|"));
-    exceptionCommand = exceptionCommand.addArgToPayload(stackLines.join("|"));
-    exceptionCommand = exceptionCommand.addArgToPayload(stackFiles.join("|"));
+    try {
+      this.serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles);
+      exceptionCommand = exceptionCommand.addArgToPayload(this.getExceptionCode(exception));
+      exceptionCommand = exceptionCommand.addArgToPayload(command ? command.toString() : "Command is null");
+      exceptionCommand = exceptionCommand.addArgToPayload(exception.name);
+      exceptionCommand = exceptionCommand.addArgToPayload(exception.message);
+      exceptionCommand = exceptionCommand.addArgToPayload(stackClasses.join("|"));
+      exceptionCommand = exceptionCommand.addArgToPayload(stackMethods.join("|"));
+      exceptionCommand = exceptionCommand.addArgToPayload(stackLines.join("|"));
+      exceptionCommand = exceptionCommand.addArgToPayload(stackFiles.join("|"));
+    } catch (e) {
+      exceptionCommand = new import_Command.Command(import_RuntimeName.RuntimeName.Nodejs, import_CommandType.CommandType.Exception, []);
+      exceptionCommand = exceptionCommand.addArgToPayload(this.getExceptionCode(e));
+      exceptionCommand = exceptionCommand.addArgToPayload(command ? command.toString() : "Command is null");
+      exceptionCommand = exceptionCommand.addArgToPayload("Node.js Exception Serialization Error");
+      exceptionCommand = exceptionCommand.addArgToPayload(e.message);
+      exceptionCommand = exceptionCommand.addArgToPayload("ExceptionSerializer");
+      exceptionCommand = exceptionCommand.addArgToPayload("serializeException");
+      exceptionCommand = exceptionCommand.addArgToPayload("unknown");
+      exceptionCommand = exceptionCommand.addArgToPayload("ExceptionSerializer.js");
+    }
     return exceptionCommand;
   }
   static getExceptionCode(exception) {
@@ -56,22 +68,35 @@ class ExceptionSerializer {
     }
   }
   static serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles) {
+    if (!exception || typeof exception.stack !== "string") {
+      return;
+    }
     const stackTrace = exception.stack.split("\n").slice(1);
-    for (let i = 0; i < stackTrace.length; i++) {
-      const parts = stackTrace[i].trim().match(/at\s(.*)\s\((.*):(\d+):(\d+)\)/);
+    for (const line of stackTrace) {
+      const trimmedLine = line.trim();
+      if (trimmedLine.includes("Javonet.Node.js")) {
+        continue;
+      }
+      let parts = trimmedLine.match(/at\s+(.*?)\s+\((.*?):(\d+):\d+\)/);
       if (parts) {
-        stackClasses.push(parts[1]);
-        stackMethods.push("unknown");
-        stackLines.push(parts[3]);
-        stackFiles.push(parts[2]);
-      } else {
-        const parts2 = stackTrace[i].trim().match(/at\s(.*):(\d+):(\d+)/);
-        if (parts2) {
+        const classAndMethod = parts[1].split(".");
+        if (classAndMethod.length > 1) {
+          stackClasses.push(classAndMethod[0]);
+          stackMethods.push(classAndMethod.slice(1).join("."));
+        } else {
           stackClasses.push("unknown");
-          stackMethods.push("unknown");
-          stackLines.push(parts2[2]);
-          stackFiles.push(parts2[1]);
+          stackMethods.push(parts[1]);
         }
+        stackFiles.push(parts[2]);
+        stackLines.push(parts[3]);
+        continue;
+      }
+      parts = trimmedLine.match(/at\s+(.*?):(\d+):\d+/);
+      if (parts) {
+        stackClasses.push("unknown");
+        stackMethods.push("unknown");
+        stackFiles.push(parts[1]);
+        stackLines.push(parts[2]);
       }
     }
   }

package/lib/core/handler/Handler.js

@@ -100,8 +100,8 @@ class Handler {
             }
             let response = handlers[command.commandType].handleCommand(command)
             return this.parseCommand(response, command.runtimeName)
-        } catch (error) {
-            return ExceptionSerializer.serializeException(error, command)
+        } catch (e) {
+            return ExceptionSerializer.serializeException(e, command)
         }
     }
 

package/lib/core/handler/ResolveReferenceHandler.js

@@ -1,10 +1,10 @@
 // @ts-check
 import { ReferencesCache } from '../referenceCache/ReferencesCache.js'
 import { AbstractHandler } from './AbstractHandler.js'
+import { CommandType } from '../../utils/CommandType.js'
+import { RuntimeName } from '../../utils/RuntimeName.js'
+import { Command } from '../../utils/Command.js'
 
-/**
- * @typedef {import('../../utils/Command.js').Command} Command
- */
 
 class ResolveReferenceHandler extends AbstractHandler {
     constructor() {
@@ -16,7 +16,12 @@ class ResolveReferenceHandler extends AbstractHandler {
      * @returns {any}
      */
     process(command) {
-        return ReferencesCache.getInstance().resolveReference(command.payload[0])
+        if (command.runtimeName === RuntimeName.Nodejs) {
+            return ReferencesCache.getInstance().resolveReference(command.payload[0])
+        }
+        else {
+            return new Command(command.runtimeName, CommandType.Reference, command.payload[0])
+        }
     }
 }
 

package/lib/core/interpreter/Interpreter.js

@@ -29,7 +29,16 @@ const requireDynamic = getRequire(import.meta.url)
 
 export class Interpreter {
     /** @type {Handler | null} */
-    handler = null
+    _handler = null
+
+    /** @type {Handler} */
+    get handler() {
+        if (!this._handler) {
+            this._handler = new Handler(this)
+        }
+        return this._handler
+    }
+
     /**
      *
      * @param {Command} command
@@ -38,57 +47,42 @@ export class Interpreter {
      */
     async executeAsync(command, connectionData) {
         try {
-            if (!this.handler) {
-                this.handler = new Handler(this)
-            }
             let messageByteArray = new CommandSerializer().serialize(command, connectionData)
             /** @type {Int8Array | undefined} */
             let responseByteArray = undefined
 
-            if (
-                command.runtimeName === RuntimeName.Nodejs &&
-                connectionData.connectionType === ConnectionType.IN_MEMORY
-            ) {
-                if (isNodejsRuntime()) {
-                    // lazy receiver loading
+            if (connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+                const _response = await _TransmitterWebsocket?.sendCommand(messageByteArray, connectionData)
+                if (_response) {
+                    const command = new CommandDeserializer(_response).deserialize()
+                    return command
+                } else {
+                    throw new Error('Response not received from TransmitterWebsocket')
+                }
+            } else {
+                if (!isNodejsRuntime()) {
+                    throw new Error('InMemory is only allowed in Nodejs runtime')
+                }
+
+                if (command.runtimeName === RuntimeName.Nodejs) {
                     if (!_Receiver) {
                         const { Receiver } = requireDynamic('../receiver/Receiver.js')
                         _Receiver = Receiver
                     }
-                    responseByteArray = _Receiver?.sendCommand(messageByteArray)
+                    responseByteArray = await _Receiver?.sendCommand(messageByteArray)
                 } else {
-                    throw new Error('Node.js runtime not found')
-                }
-            } else if (connectionData.connectionType === ConnectionType.WEB_SOCKET) {
-                try {
-                    const _response = await _TransmitterWebsocket?.sendCommand(
-                        messageByteArray,
-                        connectionData
-                    )
-                    if (_response) {
-                        const command = new CommandDeserializer(_response).deserialize()
-                        return command
-                    } else {
-                        throw new Error('Response not received from TransmitterWebsocket')
-                    }
-                } catch (error) {
-                    throw error
-                }
-            } else {
-                if (isNodejsRuntime()) {
-                    // lazy transmitter loading
                     if (!_Transmitter) {
                         const { Transmitter } = requireDynamic('../transmitter/Transmitter.js')
                         _Transmitter = Transmitter
                     }
                     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 CommandDeserializer(responseByteArray).deserialize()
         } catch (error) {
             throw error
@@ -103,60 +97,37 @@ export class Interpreter {
      */
     execute(command, connectionData) {
         try {
-            if (!this.handler) {
-                this.handler = new Handler(this)
-            }
             let messageByteArray = new CommandSerializer().serialize(command, connectionData)
             /** @type {Int8Array | undefined} */
             let responseByteArray = undefined
 
-            if (
-                command.runtimeName === RuntimeName.Nodejs &&
-                connectionData.connectionType === ConnectionType.IN_MEMORY
-            ) {
-                if (isNodejsRuntime()) {
-                    // lazy receiver loading
+            if (connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+                throw new Error('Not supported')
+            }
+            if (connectionData.connectionType === ConnectionType.IN_MEMORY) {
+                if (!isNodejsRuntime()) {
+                    throw new Error('InMemory is only allowed in Nodejs runtime')
+                }
+
+                if (command.runtimeName === RuntimeName.Nodejs) {
                     if (!_Receiver) {
                         const { Receiver } = requireDynamic('../receiver/Receiver.js')
                         _Receiver = Receiver
                     }
                     responseByteArray = _Receiver?.sendCommand(messageByteArray)
-                }
-            } else if (connectionData.connectionType === ConnectionType.WEB_SOCKET) {
-                // lazy transmitter websocket loading
-                const promise = _TransmitterWebsocket?.sendCommand(messageByteArray, connectionData)
-
-                if (!promise) {
-                    throw new Error('TransmitterWebsocket not found')
-                }
-
-                return promise
-                    .then((_response) => {
-                        if (_response) {
-                            const command = new CommandDeserializer(_response).deserialize()
-                            return command
-                        } else {
-                            throw new Error('Response not received from TransmitterWebsocket')
-                        }
-                    })
-                    .catch((error) => {
-                        throw error
-                    })
-            } else {
-                if (isNodejsRuntime()) {
+                } else {
                     if (!_Transmitter) {
                         const { Transmitter } = requireDynamic('../transmitter/Transmitter.js')
                         _Transmitter = Transmitter
                     }
-
                     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 CommandDeserializer(responseByteArray).deserialize()
         } catch (error) {
             throw error
@@ -170,9 +141,6 @@ export class Interpreter {
      */
     process(messageByteArray) {
         try {
-            if (!this.handler) {
-                this.handler = new Handler(this)
-            }
             const receivedCommand = new CommandDeserializer(messageByteArray).deserialize()
             return this.handler?.handleCommand(receivedCommand)
         } catch (error) {

package/lib/core/receiver/Receiver.js

@@ -3,30 +3,38 @@ 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'
-
-/** @type {typeof import('../../utils/RuntimeLogger.js').RuntimeLogger | null} */
-let _RuntimeLogger = null
-
-const requireDynamic = getRequire(import.meta.url)
+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'
 
 export class Receiver {
     static connectionData = new InMemoryConnectionData()
     Receiver() {
-        if (!_RuntimeLogger) {
-            const { RuntimeLogger } = requireDynamic('../../utils/RuntimeLogger.js')
-            _RuntimeLogger = RuntimeLogger
-        }
-        _RuntimeLogger?.printRuntimeInfo()
+
+    }
+
+    static getRuntimeInfo() {
+        return RuntimeLogger.getRuntimeInfo()
     }
 
     /**
      * @param {Int8Array} messageByteArray
      */
     static sendCommand(messageByteArray) {
-        return new CommandSerializer().serialize(
-            new Interpreter().process(messageByteArray),
-            this.connectionData
-        )
+        try {
+            return new CommandSerializer().serialize(
+              new Interpreter().process(messageByteArray),
+              this.connectionData
+            )
+        } catch (error) {
+            const exceptionCommand = ExceptionSerializer.serializeException(
+              error,
+              new Command(RuntimeName.Nodejs, CommandType.Exception, [])
+            )
+            return new CommandSerializer().serialize(exceptionCommand, this.connectionData)
+        }
     }
 
     /**

package/lib/sdk/InvocationContext.js

@@ -122,7 +122,9 @@ class InvocationContext {
             throw new Error('currentCommand is undefined in Invocation Context execute method')
         }
 
-        this.#interpreter = new Interpreter()
+        if (!this.#interpreter) {
+            this.#interpreter = new Interpreter()
+        }
         //@ts-expect-error
         this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionData)
 
@@ -137,6 +139,7 @@ class InvocationContext {
             this.#isExecuted = true
             return this
         }
+
         return new InvocationContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true)
     }
 
@@ -531,7 +534,9 @@ class InvocationWsContext extends InvocationContext {
             throw new Error('currentCommand is undefined in Invocation Context execute method')
         }
 
-        this.#interpreter = new Interpreter()
+        if (!this.#interpreter) {
+            this.#interpreter = new Interpreter()
+        }
         this.#responseCommand = await this.#interpreter.executeAsync(
             this.#currentCommand,
             this.#connectionData
@@ -548,6 +553,7 @@ class InvocationWsContext extends InvocationContext {
             this.#isExecuted = true
             return this
         }
+
         return new InvocationWsContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true)
     }
 }

package/lib/utils/CommandType.js

@@ -42,4 +42,7 @@ export const CommandType = /** @type {const} */ ({
     PassDelegate: 39,
     InvokeDelegate: 40,
     ConvertType: 41,
+    AddEventListener: 42,
+    PluginWrapper: 43,
+    GetAsyncOperationResult: 44,
 })

package/lib/utils/exception/ExceptionSerializer.js

@@ -6,21 +6,34 @@ import { ExceptionType } from '../ExceptionType.js'
 class ExceptionSerializer {
     static serializeException(exception, command) {
         let exceptionCommand = new Command(RuntimeName.Nodejs, CommandType.Exception, [])
-        exceptionCommand = exceptionCommand.addArgToPayload(this.getExceptionCode(exception))
-        exceptionCommand = exceptionCommand.addArgToPayload(command.toString())
-        exceptionCommand = exceptionCommand.addArgToPayload(exception.name)
-        exceptionCommand = exceptionCommand.addArgToPayload(exception.message)
 
         let stackClasses = []
         let stackMethods = []
         let stackLines = []
         let stackFiles = []
 
-        this.serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles)
-        exceptionCommand = exceptionCommand.addArgToPayload(stackClasses.join('|'))
-        exceptionCommand = exceptionCommand.addArgToPayload(stackMethods.join('|'))
-        exceptionCommand = exceptionCommand.addArgToPayload(stackLines.join('|'))
-        exceptionCommand = exceptionCommand.addArgToPayload(stackFiles.join('|'))
+        try {
+            this.serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles)
+
+            exceptionCommand = exceptionCommand.addArgToPayload(this.getExceptionCode(exception))
+            exceptionCommand = exceptionCommand.addArgToPayload(command ? command.toString() : 'Command is null')
+            exceptionCommand = exceptionCommand.addArgToPayload(exception.name)
+            exceptionCommand = exceptionCommand.addArgToPayload(exception.message)
+            exceptionCommand = exceptionCommand.addArgToPayload(stackClasses.join('|'))
+            exceptionCommand = exceptionCommand.addArgToPayload(stackMethods.join('|'))
+            exceptionCommand = exceptionCommand.addArgToPayload(stackLines.join('|'))
+            exceptionCommand = exceptionCommand.addArgToPayload(stackFiles.join('|'))
+        } catch (e) {
+            exceptionCommand = new Command(RuntimeName.Nodejs, CommandType.Exception, [])
+            exceptionCommand = exceptionCommand.addArgToPayload(this.getExceptionCode(e))
+            exceptionCommand = exceptionCommand.addArgToPayload(command ? command.toString() : 'Command is null')
+            exceptionCommand = exceptionCommand.addArgToPayload('Node.js Exception Serialization Error')
+            exceptionCommand = exceptionCommand.addArgToPayload(e.message)
+            exceptionCommand = exceptionCommand.addArgToPayload('ExceptionSerializer')
+            exceptionCommand = exceptionCommand.addArgToPayload('serializeException')
+            exceptionCommand = exceptionCommand.addArgToPayload('unknown')
+            exceptionCommand = exceptionCommand.addArgToPayload('ExceptionSerializer.js')
+        }
 
         return exceptionCommand
     }
@@ -39,23 +52,40 @@ class ExceptionSerializer {
     }
 
     static serializeStackTrace(exception, stackClasses, stackMethods, stackLines, stackFiles) {
+        if (!exception || typeof exception.stack !== 'string') {
+            return
+        }
         const stackTrace = exception.stack.split('\n').slice(1)
 
-        for (let i = 0; i < stackTrace.length; i++) {
-            const parts = stackTrace[i].trim().match(/at\s(.*)\s\((.*):(\d+):(\d+)\)/)
+        for (const line of stackTrace) {
+            const trimmedLine = line.trim()
+            if (trimmedLine.includes('Javonet.Node.js')) {
+                continue
+            }
+
+            // Pattern for: at Class.method (file:line:column) or at functionName (file:line:column)
+            let parts = trimmedLine.match(/at\s+(.*?)\s+\((.*?):(\d+):\d+\)/)
             if (parts) {
-                stackClasses.push(parts[1])
-                stackMethods.push('unknown')
-                stackLines.push(parts[3])
-                stackFiles.push(parts[2])
-            } else {
-                const parts = stackTrace[i].trim().match(/at\s(.*):(\d+):(\d+)/)
-                if (parts) {
+                const classAndMethod = parts[1].split('.')
+                if (classAndMethod.length > 1) {
+                    stackClasses.push(classAndMethod[0])
+                    stackMethods.push(classAndMethod.slice(1).join('.'))
+                } else {
                     stackClasses.push('unknown')
-                    stackMethods.push('unknown')
-                    stackLines.push(parts[2])
-                    stackFiles.push(parts[1])
+                    stackMethods.push(parts[1])
                 }
+                stackFiles.push(parts[2])
+                stackLines.push(parts[3])
+                continue
+            }
+
+            // Pattern for: at file:line:column (often for anonymous functions or top-level scripts)
+            parts = trimmedLine.match(/at\s+(.*?):(\d+):\d+/)
+            if (parts) {
+                stackClasses.push('unknown')
+                stackMethods.push('unknown')
+                stackFiles.push(parts[1])
+                stackLines.push(parts[2])
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "javonet-nodejs-sdk",
-    "version": "2.5.20",
+    "version": "2.6.0",
     "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.",
@@ -70,6 +70,7 @@
         "eslint-config-prettier": "^9.1.0",
         "eslint-plugin-jest": "^28.9.0",
         "eslint-plugin-prettier": "^5.2.1",
+        "fs-extra": "^11.3.0",
         "husky": "^8.0.0",
         "ignore": "^6.0.2",
         "jest": "^29.7.0",
@@ -87,7 +88,6 @@
     "peerDependencies": {
         "crypto": "^1.0.1",
         "dns": "^0.2.2",
-        "fs-extra": "^11.2.0",
         "ws": "^8.0.0"
     },
     "peerDependenciesMeta": {