javonet-nodejs-sdk 2.5.19 → 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/core/transmitter/TransmitterWebsocket.cjs

@@ -47,7 +47,7 @@ class TransmitterWebsocket {
   static sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;
     const options = {
-      isDisconnectedAfterMessage: true
+      isDisconnectedAfterMessage: false
     };
     return new import_WebSocketClient.WebSocketClient(hostname, options).send(messageByteArray);
   }

package/dist/core/transmitter/TransmitterWebsocketBrowser.cjs

@@ -41,8 +41,7 @@ class TransmitterWebsocketBrowser {
    */
   static async sendCommand(messageByteArray, connectionData) {
     const { hostname } = connectionData;
-    const response = new import_WebSocketClientBrowser.WebSocketClientBrowser(hostname).send(messageByteArray);
-    return response;
+    return new import_WebSocketClientBrowser.WebSocketClientBrowser(hostname).send(messageByteArray);
   }
   /**
    * @async

package/dist/core/webSocketClient/WebSocketClient.cjs

@@ -18,18 +18,27 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var WebSocketClient_exports = {};
 __export(WebSocketClient_exports, {
-  WebSocketClient: () => WebSocketClient
+  WebSocketClient: () => WebSocketClient,
+  clients: () => clients
 });
 module.exports = __toCommonJS(WebSocketClient_exports);
 var import_Runtime = require("../../utils/Runtime.cjs");
 const import_meta = {};
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 const WebSocketStateEnum = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+};
+const WebSocketStateEvent = {
   OPEN: "open",
   CLOSE: "close",
-  ERROR: "error"
+  ERROR: "error",
+  MESSAGE: "message"
 };
 let WebSocket = null;
+const clients = {};
 class WebSocketClient {
   /**
    * @param {string} url
@@ -37,45 +46,14 @@ class WebSocketClient {
    */
   constructor(url, options) {
     this.url = url;
-    this.instance = null;
-    this.isConnected = false;
-    this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? true;
+    this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? false;
   }
-  /**
-   * Connects to the WebSocket server.
-   * @async
-   * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
-   */
-  async connect() {
-    if (!WebSocket) {
-      if ((0, import_Runtime.isNodejsRuntime)()) {
-        try {
-          WebSocket = requireDynamic("ws");
-        } catch (error) {
-          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;
-        }
-      }
-    }
-    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;
-        resolve(client);
-      });
-      client.on(WebSocketStateEnum.ERROR, (error) => {
-        reject(error);
-      });
-      client.on(WebSocketStateEnum.CLOSE, () => {
-        reject(new Error("Connection closed before receiving message"));
-      });
-    });
+  /** @type {wsClient | null} */
+  get instance() {
+    return clients[this.url] || null;
+  }
+  get isConnected() {
+    return this.instance ? this.instance?.readyState === WebSocketStateEnum.OPEN : false;
   }
   /**
    * Sends messageArray through websocket connection
@@ -85,21 +63,36 @@ class WebSocketClient {
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
-      ;
-      (this.instance ? Promise.resolve(this.instance) : this._connect()).then((client) => {
+      const client = this.instance;
+      if (client) {
         client.send(
           /** @type {any} */
           messageArray
         );
-        client.on("message", (message) => {
+        const messageHandler = (message) => {
           resolve(message);
           if (this.isDisconnectedAfterMessage) {
             this.disconnect();
           }
-        });
-      }).catch((error) => {
-        reject(error);
-      });
+          client.removeListener(WebSocketStateEvent.MESSAGE, messageHandler);
+        };
+        client.on(WebSocketStateEvent.MESSAGE, messageHandler);
+      } else {
+        this._connect().then((ws) => {
+          ws.send(
+            /** @type {any} */
+            messageArray
+          );
+          const messageHandler = (message) => {
+            resolve(message);
+            if (this.isDisconnectedAfterMessage) {
+              this.disconnect();
+            }
+            ws.removeListener(WebSocketStateEvent.MESSAGE, messageHandler);
+          };
+          ws.on(WebSocketStateEvent.MESSAGE, messageHandler);
+        }).catch(reject);
+      }
     });
   }
   /**
@@ -108,9 +101,8 @@ class WebSocketClient {
   disconnect() {
     if (this.instance) {
       this.instance.close();
-      this.instance = null;
+      delete clients[this.url];
     }
-    this.isConnected = false;
   }
   /**
    * Connects to the WebSocket server.
@@ -119,36 +111,31 @@ class WebSocketClient {
    * @returns {Promise<wsClient>} - A promise that resolves when the connection is established.
    */
   _connect() {
-    if (!WebSocket) {
-      if ((0, import_Runtime.isNodejsRuntime)()) {
-        try {
-          WebSocket = requireDynamic("ws");
-        } catch (error) {
-          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;
+    if (!WebSocket && (0, import_Runtime.isNodejsRuntime)()) {
+      try {
+        WebSocket = requireDynamic("ws");
+      } catch (error) {
+        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;
       }
     }
     return new Promise((resolve, reject) => {
       if (!WebSocket) {
-        reject(new Error("ws client is null"));
-        return;
+        return reject(new Error("ws client is null"));
       }
-      const client = new WebSocket(this.url);
-      client.on(WebSocketStateEnum.OPEN, () => {
-        this.isConnected = true;
-        this.instance = client;
-        resolve(client);
-      });
-      client.on(WebSocketStateEnum.ERROR, (error) => {
-        reject(error);
-      });
-      client.on(WebSocketStateEnum.CLOSE, () => {
+      let client = clients[this.url];
+      if (!client) {
+        client = new WebSocket(this.url);
+        clients[this.url] = client;
+      }
+      client.on(WebSocketStateEvent.OPEN, () => resolve(client));
+      client.on(WebSocketStateEvent.ERROR, (error) => reject(error));
+      client.on(WebSocketStateEvent.CLOSE, () => {
         reject(new Error("Connection closed before receiving message"));
       });
     });
@@ -156,5 +143,6 @@ class WebSocketClient {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  WebSocketClient
+  WebSocketClient,
+  clients
 });

package/dist/core/webSocketClient/WebSocketClientBrowser.cjs

@@ -18,7 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var WebSocketClientBrowser_exports = {};
 __export(WebSocketClientBrowser_exports, {
-  WebSocketClientBrowser: () => WebSocketClientBrowser
+  WebSocketClientBrowser: () => WebSocketClientBrowser,
+  clients: () => clients
 });
 module.exports = __toCommonJS(WebSocketClientBrowser_exports);
 var import_Runtime = require("../../utils/Runtime.cjs");
@@ -35,6 +36,7 @@ let WsClient = null;
 if ((0, import_Runtime.isBrowserRuntime)()) {
   WsClient = WebSocket;
 }
+const clients = {};
 class WebSocketClientBrowser {
   /**
    * @param {string} url
@@ -42,10 +44,15 @@ class WebSocketClientBrowser {
    */
   constructor(url, options) {
     this.url = url;
-    this.instance = null;
-    this.isConnected = false;
     this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? false;
   }
+  /** @type {WebSocket | null} */
+  get instance() {
+    return clients[this.url] || null;
+  }
+  get isConnected() {
+    return this.instance ? this.instance.readyState === WebSocket.OPEN : false;
+  }
   /**
    * Sends messageArray through websocket connection
    * @async
@@ -54,94 +61,81 @@ class WebSocketClientBrowser {
    */
   send(messageArray) {
     return new Promise((resolve, reject) => {
-      try {
-        if (this.isConnected) {
-          this._sendMessage(messageArray, resolve, reject);
-        } else {
-          this._connect().then(() => {
-            this._sendMessage(messageArray, resolve, reject);
-          });
-        }
-      } catch (error) {
-        reject(error);
+      const client = this.instance;
+      if (client && this.isConnected) {
+        this._sendMessage(client, messageArray, resolve, reject);
+      } else {
+        this._connect().then((ws) => {
+          this._sendMessage(ws, messageArray, resolve, reject);
+        }).catch(reject);
       }
     });
   }
   /**
    * Disconnects the WebSocket by terminating the connection.
-   * @returns {void}
-   *
    */
   disconnect() {
-    if (this.instance) {
-      this.instance.close();
+    const client = this.instance;
+    if (client) {
+      client.close();
+      delete clients[this.url];
     }
-    this.isConnected = false;
   }
   /**
    * Connects to the WebSocket server.
    * @private
    * @async
-   * @returns {Promise<void>} - A promise that resolves when the connection is established.
+   * @returns {Promise<WebSocket>}
    */
   _connect() {
     return new Promise((resolve, reject) => {
-      if (WsClient === null) {
+      if (!WsClient) {
         return reject(new Error("missing WebSocket client"));
       }
-      this.instance = new WsClient(this.url);
-      this.instance.binaryType = "arraybuffer";
-      this.instance.addEventListener(WebSocketState.OPEN, () => {
-        this.isConnected = true;
-        resolve();
-      });
-      this.instance.addEventListener(WebSocketState.ERROR, (error) => {
-        reject(error);
-      });
-      this.instance.addEventListener(WebSocketState.CLOSE, () => {
-        this.isConnected = false;
+      let client = clients[this.url];
+      if (!client) {
+        client = new WsClient(this.url);
+        client.binaryType = "arraybuffer";
+        clients[this.url] = client;
+      }
+      client.addEventListener(WebSocketState.OPEN, () => resolve(client));
+      client.addEventListener(WebSocketState.ERROR, reject);
+      client.addEventListener(WebSocketState.CLOSE, () => {
+        reject(new Error("Connection closed before receiving message"));
       });
     });
   }
   /**
    * Sends the data to the WebSocket server and listens for a response.
    * @private
-   * @async
-   * @param {Int8Array} data - The data to send.
-   * @param {Function} resolve - The resolve function for the Promise.
-   * @param {Function} reject - The reject function for the Promise.
-   * @returns {void}
+   * @param {WebSocket} client
+   * @param {Int8Array} data
+   * @param {(value: Int8Array) => void} resolve
+   * @param {(reason?: any) => void} reject
    */
-  _sendMessage(data, resolve, reject) {
+  _sendMessage(client, data, resolve, reject) {
     try {
-      if (this.instance === null || !this.instance) {
-        throw new Error("error websocket not connected");
-      }
       const arrayBuffer = data.buffer;
-      this.instance.send(arrayBuffer);
-      const handleMessage = (msg) => {
-        if (this.instance === null || !this.instance) {
-          throw new Error("error websocket not connected");
+      client.send(arrayBuffer);
+      const handleMessage = (message) => {
+        if (!message?.data) {
+          return reject(new Error("Invalid message received"));
         }
-        const byteArray = new Int8Array(msg.data);
+        const byteArray = new Int8Array(message?.data);
         resolve(byteArray);
         if (this.isDisconnectedAfterMessage) {
           this.disconnect();
         }
-        this.instance.removeEventListener(WebSocketState.MESSAGE, handleMessage);
-        this.instance.removeEventListener(WebSocketState.ERROR, handleError);
+        client.removeEventListener(WebSocketState.MESSAGE, handleMessage);
+        client.removeEventListener(WebSocketState.ERROR, handleError);
       };
       const handleError = (error) => {
         reject(error);
-        if (this.instance) {
-          this.instance.removeEventListener(WebSocketState.MESSAGE, handleMessage);
-          this.instance.removeEventListener(WebSocketState.ERROR, handleError);
-        }
+        client.removeEventListener(WebSocketState.MESSAGE, handleMessage);
+        client.removeEventListener(WebSocketState.ERROR, handleError);
       };
-      if (this.instance) {
-        this.instance.addEventListener(WebSocketState.MESSAGE, handleMessage);
-        this.instance.addEventListener(WebSocketState.ERROR, handleError);
-      }
+      client.addEventListener(WebSocketState.MESSAGE, handleMessage);
+      client.addEventListener(WebSocketState.ERROR, handleError);
     } catch (err) {
       reject(err);
     }
@@ -149,5 +143,6 @@ class WebSocketClientBrowser {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  WebSocketClientBrowser
+  WebSocketClientBrowser,
+  clients
 });

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