javonet-nodejs-sdk 2.6.8 → 2.6.9

package/dist/core/handler/CreateClassInstanceHandler.cjs

@@ -24,9 +24,23 @@ module.exports = __toCommonJS(CreateClassInstanceHandler_exports);
 var import_AbstractHandler = require("./AbstractHandler.cjs");
 class CreateClassInstanceHandler extends import_AbstractHandler.AbstractHandler {
   requiredParametersCount = 1;
+  // Add a simple invocation contexts store (Map GUID -> object)
+  static _invocationContexts = /* @__PURE__ */ new Map();
+  static getOrCreateContextDictionary() {
+    return CreateClassInstanceHandler._invocationContexts;
+  }
   constructor() {
     super();
   }
+  // Helper to detect GUID in payload (standard format)
+  /**
+   * @param {{ toString: () => any; } | null} value
+   */
+  static isGuid(value) {
+    if (value == null) return false;
+    const s = value.toString();
+    return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(s);
+  }
   /**
    * @param {Command} command
    */
@@ -36,7 +50,23 @@ class CreateClassInstanceHandler extends import_AbstractHandler.AbstractHandler
         throw new Error("Create Class Instance parameters mismatch");
       }
       let clazz = command.payload[0];
-      let constructorArguments = command.payload.slice(1);
+      let payloadLength = command.payload.length;
+      let contextGuid = null;
+      let constructorArguments = [];
+      if (payloadLength > 1 && CreateClassInstanceHandler.isGuid(command.payload[1])) {
+        contextGuid = command.payload[1].toString();
+        if (payloadLength > 2) {
+          constructorArguments = command.payload.slice(2);
+        } else {
+          constructorArguments = [];
+        }
+      } else {
+        if (payloadLength > 1) {
+          constructorArguments = command.payload.slice(1);
+        } else {
+          constructorArguments = [];
+        }
+      }
       let instance = new clazz(...constructorArguments);
       if (typeof instance === "undefined") {
         let methods = Object.getOwnPropertyNames(clazz).filter(function(property) {
@@ -50,6 +80,10 @@ class CreateClassInstanceHandler extends import_AbstractHandler.AbstractHandler
         });
         throw new Error(message);
       } else {
+        if (contextGuid) {
+          const contextDict = CreateClassInstanceHandler.getOrCreateContextDictionary();
+          contextDict.set(contextGuid, instance);
+        }
         return instance;
       }
     } catch (error) {

package/dist/core/handler/Handler.cjs

@@ -167,13 +167,37 @@ class Handler {
         return this.parseCommand(resolvedResponse, runtimeName);
       });
     }
+    let responseCommand;
     if (import_TypesHandler.TypesHandler.isPrimitiveOrNullOrUndefined(response)) {
-      return import_Command.Command.createResponse(response, runtimeName);
+      responseCommand = import_Command.Command.createResponse(response, runtimeName);
     } else {
       let cache = import_ReferencesCache.ReferencesCache.getInstance();
       let uuid = cache.cacheReference(response);
-      return import_Command.Command.createReference(uuid, runtimeName);
+      responseCommand = import_Command.Command.createReference(uuid, runtimeName);
     }
+    const invocationContexts = import_CreateClassInstanceHandler.CreateClassInstanceHandler._invocationContexts;
+    if (invocationContexts && typeof invocationContexts.size === "number" && invocationContexts.size > 0) {
+      const refCache = import_ReferencesCache.ReferencesCache.getInstance();
+      for (const [contextKey, instance] of invocationContexts.entries()) {
+        const instanceGuid = refCache.cacheReference(instance);
+        const updateContextCommand = new import_Command.Command(
+          runtimeName,
+          import_CommandType.CommandType.UpdateInvocationContext,
+          [
+            contextKey.toString(),
+            instanceGuid
+          ]
+        );
+        if (typeof responseCommand.addArgToPayload === "function") {
+          responseCommand = responseCommand.addArgToPayload(updateContextCommand);
+        } else {
+          responseCommand.payload = responseCommand.payload || [];
+          responseCommand.payload.push(updateContextCommand);
+        }
+      }
+      invocationContexts.clear();
+    }
+    return responseCommand;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/sdk/InvocationContext.cjs

@@ -25,10 +25,10 @@ var import_DelegatesCache = require("../core/delegatesCache/DelegatesCache.cjs")
 var import_Interpreter = require("../core/interpreter/Interpreter.cjs");
 var import_Command = require("../utils/Command.cjs");
 var import_CommandType = require("../utils/CommandType.cjs");
-var import_ConnectionType = require("../utils/ConnectionType.cjs");
 var import_ExceptionThrower = require("../utils/exception/ExceptionThrower.cjs");
 var import_RuntimeName = require("../utils/RuntimeName.cjs");
 var import_TypesHandler = require("../utils/TypesHandler.cjs");
+var import_uuid = require("uuid");
 class InvocationContext {
   /** @type {RuntimeNameType} */
   #runtimeName;
@@ -42,6 +42,10 @@ class InvocationContext {
   #isExecuted = false;
   /** @type {Interpreter | null} */
   #interpreter = null;
+  /** @type {string | null} */
+  #guid = null;
+  // Static map holding contexts waiting for materialization (guid -> InvocationContext)
+  static _invocationContexts = /* @__PURE__ */ new Map();
   /**
    *
    * @param {RuntimeNameType} runtimeName
@@ -56,6 +60,13 @@ class InvocationContext {
     this.#responseCommand = null;
     this.#isExecuted = isExecuted;
     this.#interpreter = null;
+    this.#guid = (0, import_uuid.v4)();
+  }
+  /**
+   * @returns {string} guid of this InvocationContext
+   */
+  getGuid() {
+    return this.#guid;
   }
   /**
    * @param {Command} localCommand
@@ -101,13 +112,8 @@ class InvocationContext {
   }
   /**
    * Executes the current command.
-   * Because invocation context is building the intent of executing particular expression on target environment, we call the initial state of invocation context as non-materialized.
-   * The non-materialized context wraps either single command or chain of recursively nested commands.
-   * 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 {Promise<InvocationContext>} the InvocationContext after executing the command.
-   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+   * Returns the InvocationContext after executing the command.
+   * @returns {Promise<InvocationContext>}
    * @method
    */
   async execute() {
@@ -124,6 +130,7 @@ class InvocationContext {
     if (this.#responseCommand.commandType === import_CommandType.CommandType.Exception) {
       throw import_ExceptionThrower.ExceptionThrower.throwException(this.#responseCommand);
     }
+    this.#responseCommand = this.#processUpdateInvocationContextCommands(this.#responseCommand);
     if (this.#responseCommand.commandType === import_CommandType.CommandType.CreateClassInstance) {
       this.#currentCommand = this.#responseCommand;
       this.#isExecuted = true;
@@ -171,14 +178,24 @@ class InvocationContext {
   }
   /**
    * Creates a new instance of a class in the target runtime.
+   * Adds the newly created context to the static invocation contexts map and
+   * includes the context GUID as the first argument of CreateClassInstance command payload.
    * @param {...any} args - The arguments to pass to the class constructor
    * @returns {InvocationContext} A new InvocationContext instance that wraps the command to create the instance.
-   * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/calling-methods/creating-instance-and-calling-instance-methods)
    * @method
    */
   createInstance(...args) {
-    let localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.CreateClassInstance, args);
-    return this.#createInstanceContext(localCommand);
+    const dummyCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.CreateClassInstance, [
+      ...args
+    ]);
+    const createInstanceContext = new InvocationContext(this.#runtimeName, this.#connectionData, dummyCommand);
+    let localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.CreateClassInstance, [
+      createInstanceContext.getGuid(),
+      ...args
+    ]);
+    createInstanceContext.#currentCommand = this.#buildCommand(localCommand);
+    InvocationContext._invocationContexts.set(createInstanceContext.getGuid(), createInstanceContext);
+    return createInstanceContext;
   }
   /**
    * Retrieves the value of an instance field from the target runtime.
@@ -470,6 +487,42 @@ class InvocationContext {
       );
     }
   }
+  /**
+   * Process UpdateInvocationContext commands in the provided responseCommand payload.
+   * For each UpdateInvocationContext command, set the referenced InvocationContext's currentCommand to a Reference command,
+   * remove that InvocationContext from the static map and remove UpdateInvocationContext items from response payload.
+   * @param {Command} responseCommand
+   * @returns {Command}
+   */
+  #processUpdateInvocationContextCommands(responseCommand) {
+    if (!responseCommand?.payload?.length) {
+      return responseCommand;
+    }
+    const commandsToUpdate = responseCommand.payload.filter(
+      (item) => item instanceof import_Command.Command && item.commandType === import_CommandType.CommandType.UpdateInvocationContext
+    );
+    if (commandsToUpdate.length === 0) {
+      return responseCommand;
+    }
+    const updatedPayload = new Set(responseCommand.payload);
+    for (const cmd of commandsToUpdate) {
+      if (cmd.payload?.length >= 2) {
+        const contextGuid = String(cmd.payload[0]);
+        const instanceGuid = cmd.payload[1];
+        const invCtx = InvocationContext._invocationContexts.get(contextGuid);
+        if (invCtx) {
+          invCtx.#currentCommand = new import_Command.Command(invCtx.#runtimeName, import_CommandType.CommandType.Reference, [instanceGuid]);
+          InvocationContext._invocationContexts.delete(contextGuid);
+        }
+      }
+      updatedPayload.delete(cmd);
+    }
+    return new import_Command.Command(
+      responseCommand.runtimeName,
+      responseCommand.commandType,
+      Array.from(updatedPayload)
+    );
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -3,6 +3,14 @@ export type Command = import("../../utils/Command.js").Command;
  * @typedef {import('../../utils/Command.js').Command} Command
  */
 export class CreateClassInstanceHandler extends AbstractHandler {
+    static _invocationContexts: Map<any, any>;
+    static getOrCreateContextDictionary(): Map<any, any>;
+    /**
+     * @param {{ toString: () => any; } | null} value
+     */
+    static isGuid(value: {
+        toString: () => any;
+    } | null): boolean;
     requiredParametersCount: number;
     /**
      * @param {Command} command

package/dist/types/sdk/InvocationContext.d.ts

@@ -12,6 +12,7 @@ export type IConnectionData = import("../utils/connectionData/IConnectionData.js
  * @class
  */
 export class InvocationContext {
+    static _invocationContexts: Map<any, any>;
     /**
      *
      * @param {RuntimeNameType} runtimeName
@@ -20,19 +21,18 @@ export class InvocationContext {
      * @param {boolean} isExecuted
      */
     constructor(runtimeName: RuntimeNameType, connectionData: IConnectionData, command: Command, isExecuted?: boolean);
+    /**
+     * @returns {string} guid of this InvocationContext
+     */
+    getGuid(): string;
     /**
      * @returns {Command|null}
      */
     get_current_command(): Command | null;
     /**
      * Executes the current command.
-     * Because invocation context is building the intent of executing particular expression on target environment, we call the initial state of invocation context as non-materialized.
-     * The non-materialized context wraps either single command or chain of recursively nested commands.
-     * 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 {Promise<InvocationContext>} the InvocationContext after executing the command.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+     * Returns the InvocationContext after executing the command.
+     * @returns {Promise<InvocationContext>}
      * @method
      */
     execute(): Promise<InvocationContext>;
@@ -64,9 +64,10 @@ export class InvocationContext {
     setStaticField(fieldName: string, value: any): InvocationContext;
     /**
      * Creates a new instance of a class in the target runtime.
+     * Adds the newly created context to the static invocation contexts map and
+     * includes the context GUID as the first argument of CreateClassInstance command payload.
      * @param {...any} args - The arguments to pass to the class constructor
      * @returns {InvocationContext} A new InvocationContext instance that wraps the command to create the instance.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/calling-methods/creating-instance-and-calling-instance-methods)
      * @method
      */
     createInstance(...args: any[]): InvocationContext;

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

@@ -47,4 +47,5 @@ export namespace CommandType {
     let AsKwargs: 45;
     let GetResultType: 46;
     let GetGlobalField: 47;
+    let UpdateInvocationContext: 48;
 }

package/dist/utils/CommandType.cjs

@@ -71,7 +71,8 @@ const CommandType = (
     GetAsyncOperationResult: 44,
     AsKwargs: 45,
     GetResultType: 46,
-    GetGlobalField: 47
+    GetGlobalField: 47,
+    UpdateInvocationContext: 48
   }
 );
 // Annotate the CommonJS export names for ESM import in node:

package/lib/core/handler/CreateClassInstanceHandler.js

@@ -8,10 +8,28 @@ import { AbstractHandler } from './AbstractHandler.js'
 class CreateClassInstanceHandler extends AbstractHandler {
     requiredParametersCount = 1
 
+    // Add a simple invocation contexts store (Map GUID -> object)
+    static _invocationContexts = new Map()
+
+    static getOrCreateContextDictionary() {
+        // In a simple approach we keep a single map for the process.
+        return CreateClassInstanceHandler._invocationContexts
+    }
+
     constructor() {
         super()
     }
 
+    // Helper to detect GUID in payload (standard format)
+    /**
+     * @param {{ toString: () => any; } | null} value
+     */
+    static isGuid(value) {
+        if (value == null) return false
+        const s = value.toString()
+        return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(s)
+    }
+
     /**
      * @param {Command} command
      */
@@ -20,8 +38,29 @@ class CreateClassInstanceHandler extends AbstractHandler {
             if (command.payload.length < this.requiredParametersCount) {
                 throw new Error('Create Class Instance parameters mismatch')
             }
+
             let clazz = command.payload[0]
-            let constructorArguments = command.payload.slice(1)
+
+            // Extract optional GUID and constructor arguments
+            let payloadLength = command.payload.length
+            let contextGuid = null
+            let constructorArguments = []
+
+            if (payloadLength > 1 && CreateClassInstanceHandler.isGuid(command.payload[1])) {
+                contextGuid = command.payload[1].toString()
+                if (payloadLength > 2) {
+                    constructorArguments = command.payload.slice(2)
+                } else {
+                    constructorArguments = []
+                }
+            } else {
+                if (payloadLength > 1) {
+                    constructorArguments = command.payload.slice(1)
+                } else {
+                    constructorArguments = []
+                }
+            }
+
             let instance = new clazz(...constructorArguments)
             if (typeof instance === 'undefined') {
                 let methods = Object.getOwnPropertyNames(clazz).filter(function (property) {
@@ -33,6 +72,12 @@ class CreateClassInstanceHandler extends AbstractHandler {
                 })
                 throw new Error(message)
             } else {
+                // If GUID provided, store instance in context dictionary
+                if (contextGuid) {
+                    const contextDict = CreateClassInstanceHandler.getOrCreateContextDictionary()
+                    // Overwrite or add entry
+                    contextDict.set(contextGuid, instance)
+                }
                 return instance
             }
         } catch (error) {

package/lib/core/handler/Handler.js

@@ -164,13 +164,43 @@ class Handler {
             })
         }
 
+        // Create base responseCommand (either primitive response or a reference)
+        let responseCommand
         if (TypesHandler.isPrimitiveOrNullOrUndefined(response)) {
-            return Command.createResponse(response, runtimeName)
+            responseCommand = Command.createResponse(response, runtimeName)
         } else {
             let cache = ReferencesCache.getInstance()
             let uuid = cache.cacheReference(response)
-            return Command.createReference(uuid, runtimeName)
+            responseCommand = Command.createReference(uuid, runtimeName)
         }
+
+        // If any invocation contexts were created during instance creation, attach UpdateInvocationContext commands
+        const invocationContexts = CreateClassInstanceHandler._invocationContexts
+        if (invocationContexts && typeof invocationContexts.size === 'number' && invocationContexts.size > 0) {
+            const refCache = ReferencesCache.getInstance()
+            for (const [contextKey, instance] of invocationContexts.entries()) {
+                const instanceGuid = refCache.cacheReference(instance)
+                const updateContextCommand = new Command(
+                    runtimeName,
+                    CommandType.UpdateInvocationContext,
+                    [contextKey.toString(),
+                    instanceGuid]
+                )
+
+                // Prefer using addArgToPayload if available, otherwise push into payload array
+                if (typeof responseCommand.addArgToPayload === 'function') {
+                    responseCommand = responseCommand.addArgToPayload(updateContextCommand)
+                } else {
+                    responseCommand.payload = responseCommand.payload || []
+                    responseCommand.payload.push(updateContextCommand)
+                }
+            }
+
+            // Clear contexts after attaching them to the response
+            invocationContexts.clear()
+        }
+
+        return responseCommand
     }
 }
 

package/lib/sdk/InvocationContext.js

@@ -3,10 +3,10 @@ import { delegatesCacheInstance } from '../core/delegatesCache/DelegatesCache.js
 import { Interpreter } from '../core/interpreter/Interpreter.js'
 import { Command } from '../utils/Command.js'
 import { CommandType } from '../utils/CommandType.js'
-import { ConnectionType } from '../utils/ConnectionType.js'
 import { ExceptionThrower } from '../utils/exception/ExceptionThrower.js'
 import { RuntimeName } from '../utils/RuntimeName.js'
 import { TypesHandler } from '../utils/TypesHandler.js'
+import { v4 as uuidv4 } from 'uuid' // add lightweight uuid generation
 
 /**
  * @typedef {import('../types.d.ts').RuntimeName} RuntimeNameType
@@ -33,6 +33,11 @@ class InvocationContext {
     #isExecuted = false
     /** @type {Interpreter | null} */
     #interpreter = null
+    /** @type {string | null} */
+    #guid = null
+
+    // Static map holding contexts waiting for materialization (guid -> InvocationContext)
+    static _invocationContexts = new Map()
 
     /**
      *
@@ -48,6 +53,15 @@ class InvocationContext {
         this.#responseCommand = null
         this.#isExecuted = isExecuted
         this.#interpreter = null
+        this.#guid = uuidv4()
+    }
+
+    /**
+     * @returns {string} guid of this InvocationContext
+     */
+    getGuid() {
+        // @ts-ignore
+        return this.#guid
     }
 
     /**
@@ -99,13 +113,8 @@ class InvocationContext {
 
     /**
      * Executes the current command.
-     * Because invocation context is building the intent of executing particular expression on target environment, we call the initial state of invocation context as non-materialized.
-     * The non-materialized context wraps either single command or chain of recursively nested commands.
-     * 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 {Promise<InvocationContext>} the InvocationContext after executing the command.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/execute-method)
+     * Returns the InvocationContext after executing the command.
+     * @returns {Promise<InvocationContext>}
      * @method
      */
     async execute() {
@@ -117,6 +126,7 @@ class InvocationContext {
             this.#interpreter = new Interpreter()
         }
 
+        // Execute command on interpreter
         this.#responseCommand = await this.#interpreter.execute(this.#currentCommand, this.#connectionData)
 
         if (!this.#responseCommand) {
@@ -125,6 +135,10 @@ class InvocationContext {
         if (this.#responseCommand.commandType === CommandType.Exception) {
             throw ExceptionThrower.throwException(this.#responseCommand)
         }
+
+        // Process UpdateInvocationContext commands (if any) coming from runtime
+        this.#responseCommand = this.#processUpdateInvocationContextCommands(this.#responseCommand)
+
         if (this.#responseCommand.commandType === CommandType.CreateClassInstance) {
             this.#currentCommand = this.#responseCommand
             this.#isExecuted = true
@@ -176,14 +190,30 @@ class InvocationContext {
 
     /**
      * Creates a new instance of a class in the target runtime.
+     * Adds the newly created context to the static invocation contexts map and
+     * includes the context GUID as the first argument of CreateClassInstance command payload.
      * @param {...any} args - The arguments to pass to the class constructor
      * @returns {InvocationContext} A new InvocationContext instance that wraps the command to create the instance.
-     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/calling-methods/creating-instance-and-calling-instance-methods)
      * @method
      */
     createInstance(...args) {
-        let localCommand = new Command(this.#runtimeName, CommandType.CreateClassInstance, args)
-        return this.#createInstanceContext(localCommand)
+        const dummyCommand = new Command(this.#runtimeName, CommandType.CreateClassInstance, [
+            ...args,
+        ])
+        const createInstanceContext = new InvocationContext(this.#runtimeName, this.#connectionData, dummyCommand)
+        // include guid as first payload element followed by constructor args
+        let localCommand = new Command(this.#runtimeName, CommandType.CreateClassInstance, [
+            createInstanceContext.getGuid(),
+            ...args,
+        ])
+
+        // set current command for the new context
+        createInstanceContext.#currentCommand = this.#buildCommand(localCommand)
+
+        // register context for materialization
+        InvocationContext._invocationContexts.set(createInstanceContext.getGuid(), createInstanceContext)
+
+        return createInstanceContext
     }
 
     /**
@@ -429,7 +459,7 @@ class InvocationContext {
         await localInvCtx.execute()
 
         const resolve = (/** @type {any} */ item) => {
-            return item?.commandType === CommandType.Reference ? 
+            return item?.commandType === CommandType.Reference ?
             new InvocationContext(
                 this.#runtimeName,
                 this.#connectionData,
@@ -441,11 +471,11 @@ class InvocationContext {
         if (!respCommand) {
             return []
         }
-        
+
         if (respCommand.payload) {
             return respCommand.payload.map((/** @type {any} */ item) => resolve(item))
         }
-        
+
         return respCommand.payload || []
     }
 
@@ -507,6 +537,49 @@ class InvocationContext {
             )
         }
     }
+
+    /**
+     * Process UpdateInvocationContext commands in the provided responseCommand payload.
+     * For each UpdateInvocationContext command, set the referenced InvocationContext's currentCommand to a Reference command,
+     * remove that InvocationContext from the static map and remove UpdateInvocationContext items from response payload.
+     * @param {Command} responseCommand
+     * @returns {Command}
+     */
+    #processUpdateInvocationContextCommands(responseCommand) {
+        if (!responseCommand?.payload?.length) {
+            return responseCommand
+        }
+
+        const commandsToUpdate = responseCommand.payload.filter(
+            (/** @type {unknown} */ item) => item instanceof Command && item.commandType === CommandType.UpdateInvocationContext
+        )
+
+        if (commandsToUpdate.length === 0) {
+            return responseCommand
+        }
+
+        const updatedPayload = new Set(responseCommand.payload)
+
+        for (const cmd of commandsToUpdate) {
+            if (cmd.payload?.length >= 2) {
+                const contextGuid = String(cmd.payload[0])
+                const instanceGuid = cmd.payload[1]
+                const invCtx = InvocationContext._invocationContexts.get(contextGuid)
+
+                if (invCtx) {
+                    invCtx.#currentCommand = new Command(invCtx.#runtimeName, CommandType.Reference, [instanceGuid])
+                    InvocationContext._invocationContexts.delete(contextGuid)
+                }
+            }
+            updatedPayload.delete(cmd)
+        }
+
+        return new Command(
+            responseCommand.runtimeName,
+            responseCommand.commandType,
+            Array.from(updatedPayload)
+        )
+    }
 }
 
 export { InvocationContext }

package/lib/utils/CommandType.js

@@ -48,4 +48,5 @@ export const CommandType = /** @type {const} */ ({
     AsKwargs: 45,
     GetResultType: 46,
     GetGlobalField: 47,
+    UpdateInvocationContext: 48,
 })

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "javonet-nodejs-sdk",
-    "version": "2.6.8",
+    "version": "2.6.9",
     "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.",
@@ -40,12 +40,13 @@
         "format": "prettier --write ."
     },
     "dependencies": {
+        "@types/uuid": "^10.0.0",
         "@types/ws": "^8.18.1",
         "buffer": "^6.0.3",
         "glob": "^10.4.5",
         "js-yaml": "^4.1.0",
         "uuid": "^10.0.0",
-        "ws": "^8.13.0"
+        "ws": "^8.18.1"
     },
     "devDependencies": {
         "@babel/cli": "^7.25.9",
@@ -58,7 +59,7 @@
         "@types/js-yaml": "^4.0.9",
         "babel-loader": "^9.2.1",
         "cross-env": "^7.0.3",
-        "esbuild": "^0.24.0",
+        "esbuild": "^0.27.0",
         "eslint": "^9.15.0",
         "eslint-config-prettier": "^9.1.0",
         "eslint-plugin-jest": "^28.9.0",