javonet-ruby-sdk 2.6.8 → 2.6.11

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

@@ -22,6 +22,11 @@ __export(Handler_exports, {
   handlers: () => handlers
 });
 module.exports = __toCommonJS(Handler_exports);
+var import_CommandType = require("../../utils/CommandType.cjs");
+var import_Command = require("../../utils/Command.cjs");
+var import_TypesHandler = require("../../utils/TypesHandler.cjs");
+var import_ExceptionSerializer = require("../../utils/exception/ExceptionSerializer.cjs");
+var import_AbstractHandler = require("./AbstractHandler.cjs");
 var import_ReferencesCache = require("../referenceCache/ReferencesCache.cjs");
 var import_ValueHandler = require("./ValueHandler.cjs");
 var import_LoadLibraryHandler = require("./LoadLibraryHandler.cjs");
@@ -71,11 +76,8 @@ var import_GetAsyncOperationResultHandler = require("./GetAsyncOperationResultHa
 var import_AsKwargsHandler = require("./AsKwargsHandler.cjs");
 var import_GetResultTypeHandler = require("./GetResultTypeHandler.cjs");
 var import_GetGlobalFieldHandler = require("./GetGlobalFieldHandler.cjs");
-var import_CommandType = require("../../utils/CommandType.cjs");
-var import_Command = require("../../utils/Command.cjs");
-var import_TypesHandler = require("../../utils/TypesHandler.cjs");
-var import_ExceptionSerializer = require("../../utils/exception/ExceptionSerializer.cjs");
-var import_AbstractHandler = require("./AbstractHandler.cjs");
+var import_RegisterForUpdateHandler = require("./RegisterForUpdateHandler.cjs");
+var import_ValueForUpdateHandler = require("./ValueForUpdateHandler.cjs");
 const handlers = {
   [import_CommandType.CommandType.Value]: new import_ValueHandler.ValueHandler(),
   [import_CommandType.CommandType.LoadLibrary]: new import_LoadLibraryHandler.LoadLibraryHandler(),
@@ -124,56 +126,94 @@ const handlers = {
   [import_CommandType.CommandType.GetAsyncOperationResult]: new import_GetAsyncOperationResultHandler.GetAsyncOperationResultHandler(),
   [import_CommandType.CommandType.AsKwargs]: new import_AsKwargsHandler.AsKwargsHandler(),
   [import_CommandType.CommandType.GetResultType]: new import_GetResultTypeHandler.GetResultTypeHandler(),
-  [import_CommandType.CommandType.GetGlobalField]: new import_GetGlobalFieldHandler.GetGlobalFieldHandler()
+  [import_CommandType.CommandType.GetGlobalField]: new import_GetGlobalFieldHandler.GetGlobalFieldHandler(),
+  [import_CommandType.CommandType.RegisterForUpdate]: new import_RegisterForUpdateHandler.RegisterForUpdateHandler(),
+  [import_CommandType.CommandType.ValueForUpdate]: new import_ValueForUpdateHandler.ValueForUpdateHandler()
 };
 class Handler {
+  static _initialized = false;
   /**
-   * @param {import('../interpreter/Interpreter.js').Interpreter} interpreter
+   * Initializes the handlers map. This is called lazily on first use.
    */
-  constructor(interpreter) {
-    this.interpreter = interpreter;
-    if (!this.interpreter) {
-      throw new Error("interpreter is undefined in Handler constructor");
+  static _initialize() {
+    if (Handler._initialized) {
+      return;
     }
-    handlers[import_CommandType.CommandType.PassDelegate] = new import_PassDelegateHandler.PassDelegateHandler(this.interpreter);
+    handlers[import_CommandType.CommandType.PassDelegate] = new import_PassDelegateHandler.PassDelegateHandler();
     Object.keys(handlers).forEach((commandTypeHandler) => {
       handlers[commandTypeHandler].handlers = handlers;
     });
+    Handler._initialized = true;
   }
   /**
    * @param {Command} command
    * @returns {Promise<Command> | Command}
    */
-  handleCommand(command) {
+  static handleCommand(command) {
+    Handler._initialize();
     try {
       if (command.commandType === import_CommandType.CommandType.RetrieveArray) {
         const responseArray = handlers[import_CommandType.CommandType.Reference].handleCommand(command.payload[0]);
         return import_Command.Command.createArrayResponse(responseArray, command.runtimeName);
       }
       const response = handlers[command.commandType].handleCommand(command);
-      return this.parseCommand(response, command.runtimeName);
+      return Handler.parseCommand(response, command.runtimeName);
     } catch (e) {
-      return import_ExceptionSerializer.ExceptionSerializer.serializeException(e, command);
+      return Handler.resolveException(e, command);
     }
   }
+  /**
+   * Prefer innerException (or cause) when available.
+   * @param {any} error
+   * @param {Command} command
+   * @returns {Command}
+   */
+  static resolveException(error, command) {
+    const inner = error?.cause;
+    return import_ExceptionSerializer.ExceptionSerializer.serializeException(inner ?? error, command);
+  }
   /**
    * @param {any} response
    * @param {RuntimeName} runtimeName
    * @returns {Promise<Command> | Command}
    */
-  parseCommand(response, runtimeName) {
+  static parseCommand(response, runtimeName) {
     if (response instanceof Promise) {
       return response.then((resolvedResponse) => {
-        return this.parseCommand(resolvedResponse, runtimeName);
+        return Handler.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);
+      const refCache = import_ReferencesCache.ReferencesCache.getInstance();
+      const uuid = refCache.cacheReference(response);
+      responseCommand = import_Command.Command.createReference(uuid, runtimeName);
+    }
+    const invocationContexts = import_RegisterForUpdateHandler.RegisterForUpdateHandler._invocationContexts.Value;
+    if (invocationContexts && 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.ValueForUpdate,
+          [
+            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:

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

@@ -44,7 +44,7 @@ class InvokeInstanceMethodHandler extends import_AbstractHandler.AbstractHandler
         let methods = Object.getOwnPropertyNames(instance.__proto__).filter(function(property) {
           return typeof instance.__proto__[property] === "function";
         });
-        let message = `Method ${methodName} not found in object. Available methods:
+        let message = `Method ${methodName} not found in object ${instance.constructor.name}. Available methods:
 `;
         methods.forEach((methodIter) => {
           message += `${methodIter}

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

@@ -44,7 +44,7 @@ class InvokeStaticMethodHandler extends import_AbstractHandler.AbstractHandler {
         let methods = Object.getOwnPropertyNames(type).filter(function(property) {
           return typeof type[property] === "function";
         });
-        let message = `Method ${methodName} not found in class. Available methods:
+        let message = `Method ${methodName} not found in class ${type.name}. Available methods:
 `;
         methods.forEach((methodIter) => {
           message += `${methodIter}

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

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var PassDelegateHandler_exports = {};
 __export(PassDelegateHandler_exports, {
@@ -26,12 +36,9 @@ var import_InMemoryConnectionData = require("../../utils/connectionData/InMemory
 var import_DelegatesCache = require("../delegatesCache/DelegatesCache.cjs");
 var import_AbstractHandler = require("./AbstractHandler.cjs");
 class PassDelegateHandler extends import_AbstractHandler.AbstractHandler {
-  /** @type {Interpreter | null | undefined} */
-  interpreter = null;
-  constructor(interpreter = null) {
+  constructor() {
     super();
     this.requiredParametersCount = 1;
-    this.interpreter = interpreter;
   }
   /**S
    * Processes the given command to create and compile a delegate.
@@ -113,7 +120,8 @@ class PassDelegateHandler extends import_AbstractHandler.AbstractHandler {
    * @returns {Promise<any>} The response object.
    */
   async createExecuteCall(command) {
-    return this.interpreter?.execute(command, new import_InMemoryConnectionData.InMemoryConnectionData());
+    const { Interpreter } = await import("../interpreter/Interpreter.js");
+    return Interpreter.execute(command, new import_InMemoryConnectionData.InMemoryConnectionData());
   }
   /**
    * Retrieves the response payload from the execution call.

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

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RegisterForUpdateHandler_exports = {};
+__export(RegisterForUpdateHandler_exports, {
+  RegisterForUpdateHandler: () => RegisterForUpdateHandler
+});
+module.exports = __toCommonJS(RegisterForUpdateHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class RegisterForUpdateHandler extends import_AbstractHandler.AbstractHandler {
+  requiredParametersCount = 2;
+  /* type {Map<string, any>} */
+  static _invocationContexts = { Value: /* @__PURE__ */ new Map() };
+  /**
+   * Ensure context map exists and return it.
+   * @returns {Map<string, any>}
+   */
+  static getOrCreateContextMap() {
+    const container = RegisterForUpdateHandler._invocationContexts;
+    if (!container.Value) {
+      container.Value = /* @__PURE__ */ new Map();
+    }
+    return container.Value;
+  }
+  /**
+   * @param {any} command
+   * @returns {any}
+   */
+  process(command) {
+    if (command.payload.length < this.requiredParametersCount) {
+      throw new Error("RegisterForUpdateHandler parameters mismatch");
+    }
+    const objectToRegister = command.payload[0];
+    const guidToRegister = command.payload.length > 1 && typeof command.payload[1] === "string" ? command.payload[1] : "";
+    const contextMap = RegisterForUpdateHandler.getOrCreateContextMap();
+    if (!contextMap.has(guidToRegister)) {
+      contextMap.set(guidToRegister, objectToRegister);
+    }
+    return objectToRegister;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RegisterForUpdateHandler
+});

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

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ValueForUpdateHandler_exports = {};
+__export(ValueForUpdateHandler_exports, {
+  ValueForUpdateHandler: () => ValueForUpdateHandler
+});
+module.exports = __toCommonJS(ValueForUpdateHandler_exports);
+var import_AbstractHandler = require("./AbstractHandler.cjs");
+class ValueForUpdateHandler extends import_AbstractHandler.AbstractHandler {
+  /**
+   * @param {any} command
+   */
+  process(command) {
+    throw new Error(`${this.constructor.name} is not implemented in Node.js`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ValueForUpdateHandler
+});

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

@@ -35,24 +35,15 @@ let _Transmitter;
 let _TransmitterWebsocket = (0, import_Runtime.isNodejsRuntime)() ? import_TransmitterWebsocket.TransmitterWebsocket : import_TransmitterWebsocketBrowser.TransmitterWebsocketBrowser;
 const requireDynamic = (0, import_Runtime.getRequire)(import_meta.url);
 class Interpreter {
-  /** @type {Handler | null} */
-  _handler = null;
-  /** @type {Handler} */
-  get handler() {
-    if (!this._handler) {
-      this._handler = new import_Handler.Handler(this);
-    }
-    return this._handler;
-  }
   /**
    *
    * @param {Command} command
    * @param {IConnectionData} connectionData
    * @returns {Promise<Command>}
    */
-  async execute(command, connectionData) {
+  static async execute(command, connectionData) {
     try {
-      let messageByteArray = new import_CommandSerializer.CommandSerializer().serialize(command, connectionData);
+      let messageByteArray = import_CommandSerializer.CommandSerializer.serialize(command, connectionData);
       if (!(messageByteArray instanceof Uint8Array)) {
         throw new Error("Serialized message is not Uint8Array");
       }
@@ -96,10 +87,10 @@ class Interpreter {
    * @param {Uint8Array} messageByteArray
    * @returns {Promise<Command> | Command}
    */
-  process(messageByteArray) {
+  static process(messageByteArray) {
     try {
       const receivedCommand = new import_CommandDeserializer.CommandDeserializer(messageByteArray).deserialize();
-      return this.handler?.handleCommand(receivedCommand);
+      return import_Handler.Handler.handleCommand(receivedCommand);
     } catch (error) {
       throw error;
     }

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

@@ -73,7 +73,7 @@ class CommandDeserializer {
       case "JAVONET_DOUBLE":
         return this.readDouble();
       case "JAVONET_UNSIGNED_LONG_LONG":
-        return this.readUllong;
+        return this.readUllong();
       case "JAVONET_UNSIGNED_INTEGER":
         return this.readUInt();
       case "JAVONET_NULL":

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

@@ -35,7 +35,7 @@ class CommandSerializer {
    * @param {number} runtimeVersion
    * @returns {Uint8Array}
    */
-  serialize(rootCommand, connectionData, runtimeVersion = 0) {
+  static serialize(rootCommand, connectionData, runtimeVersion = 0) {
     const buffers = [];
     buffers.push(Uint8Array.of(rootCommand.runtimeName, runtimeVersion));
     if (connectionData) {
@@ -44,7 +44,7 @@ class CommandSerializer {
       buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0));
     }
     buffers.push(Uint8Array.of(import_RuntimeName.RuntimeName.Python, rootCommand.commandType));
-    this.serializeRecursively(rootCommand, buffers);
+    CommandSerializer.serializeRecursively(rootCommand, buffers);
     return concatenateUint8Arrays(buffers);
   }
   /**
@@ -52,18 +52,18 @@ class CommandSerializer {
    * @param {Command} command
    * @param {Array<Uint8Array>} buffers
    */
-  serializeRecursively(command, buffers) {
+  static 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);
+        CommandSerializer.serializeRecursively(item, buffers);
       } 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);
+        CommandSerializer.serializeRecursively(refCommand, buffers);
       }
     }
   }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/core/receiver/Receiver.cjs

@@ -21,19 +21,16 @@ __export(Receiver_exports, {
   Receiver: () => Receiver
 });
 module.exports = __toCommonJS(Receiver_exports);
-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");
 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");
+var import_Interpreter = require("./../interpreter/Interpreter.cjs");
 class Receiver {
   static connectionData = new import_InMemoryConnectionData.InMemoryConnectionData();
-  Receiver() {
-  }
   static getRuntimeInfo() {
     return import_RuntimeLogger.RuntimeLogger.getRuntimeInfo();
   }
@@ -43,14 +40,14 @@ class Receiver {
    */
   static async sendCommand(messageByteArray) {
     try {
-      let command = await new import_Interpreter.Interpreter().process(messageByteArray);
-      return new import_CommandSerializer.CommandSerializer().serialize(command, this.connectionData);
+      let command = await import_Interpreter.Interpreter.process(messageByteArray);
+      return import_CommandSerializer.CommandSerializer.serialize(command, 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);
+      return import_CommandSerializer.CommandSerializer.serialize(exceptionCommand, this.connectionData);
     }
   }
   /**

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/InvocationContext.cjs

@@ -25,10 +25,22 @@ 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 AsyncLock {
+  constructor() {
+    this._tail = Promise.resolve();
+  }
+  async lock() {
+    let release;
+    const prev = this._tail;
+    this._tail = new Promise((res) => release = res);
+    await prev;
+    return () => release(void 0);
+  }
+}
 class InvocationContext {
   /** @type {RuntimeNameType} */
   #runtimeName;
@@ -40,8 +52,13 @@ class InvocationContext {
   #responseCommand = null;
   /** @type {boolean} */
   #isExecuted = false;
-  /** @type {Interpreter | null} */
-  #interpreter = null;
+  /** @type {string | null} */
+  #guid = null;
+  /** @type {AsyncLock} */
+  #materializationLock = new AsyncLock();
+  // Static map holding contexts waiting for materialization (guid -> InvocationContext)
+  static _invocationContexts = /* @__PURE__ */ new Map();
+  //
   /**
    *
    * @param {RuntimeNameType} runtimeName
@@ -55,7 +72,13 @@ class InvocationContext {
     this.#currentCommand = command;
     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
@@ -71,7 +94,7 @@ class InvocationContext {
   /**
    * @returns {Command|null}
    */
-  get_current_command() {
+  getCurrentCommand() {
     return this.#currentCommand;
   }
   //destructor() {
@@ -101,35 +124,84 @@ 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() {
     if (this.#currentCommand === null) {
       throw new Error("currentCommand is undefined in Invocation Context execute method");
     }
-    if (!this.#interpreter) {
-      this.#interpreter = new import_Interpreter.Interpreter();
+    const entries = Array.from(InvocationContext._invocationContexts.entries());
+    entries.sort((a, b) => String(a[0]).localeCompare(String(b[0])));
+    const releases = [];
+    for (const [, ic] of entries) {
+      const release = await ic.#materializationLock.lock();
+      releases.push(release);
     }
-    this.#responseCommand = await this.#interpreter.execute(this.#currentCommand, this.#connectionData);
-    if (!this.#responseCommand) {
-      throw new Error("responseCommand is undefined in Invocation Context execute method");
+    try {
+      this.#responseCommand = await import_Interpreter.Interpreter.execute(
+        this.#currentCommand,
+        this.#connectionData
+      );
+      if (!this.#responseCommand) {
+        throw new Error("responseCommand is undefined in Invocation Context execute method");
+      }
+      if (this.#responseCommand.commandType === import_CommandType.CommandType.Exception) {
+        throw import_ExceptionThrower.ExceptionThrower.throwException(this.#responseCommand);
+      }
+      this.#responseCommand = this.#processUpdateInvocationContextCommands(this.#responseCommand);
+      if (this.#responseCommand.commandType === import_CommandType.CommandType.CreateClassInstance) {
+        this.#currentCommand = this.#responseCommand;
+        this.#isExecuted = true;
+        return this;
+      }
+      return new InvocationContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true);
+    } finally {
+      for (let i = releases.length - 1; i >= 0; i--) {
+        try {
+          releases[i]();
+        } catch {
+        }
+      }
     }
-    if (this.#responseCommand.commandType === import_CommandType.CommandType.Exception) {
-      throw import_ExceptionThrower.ExceptionThrower.throwException(this.#responseCommand);
+  }
+  /**
+   * Process UpdateInvocationContext commands in the provided responseCommand payload.
+   * For each ValueForUpdate command, set the referenced InvocationContext's currentCommand to a Reference command,
+   * remove that InvocationContext from the static map and remove ValueForUpdate items from response payload.
+   * @param {Command} responseCommand
+   * @returns {Command}
+   */
+  #processUpdateInvocationContextCommands(responseCommand) {
+    if (!responseCommand?.payload || responseCommand.payload.length === 0) {
+      return responseCommand;
+    }
+    const commandsToUpdate = [];
+    for (const item of responseCommand.payload) {
+      if (item instanceof import_Command.Command && item.commandType === import_CommandType.CommandType.ValueForUpdate) {
+        commandsToUpdate.push(item);
+      }
+    }
+    if (commandsToUpdate.length === 0) {
+      return responseCommand;
     }
-    if (this.#responseCommand.commandType === import_CommandType.CommandType.CreateClassInstance) {
-      this.#currentCommand = this.#responseCommand;
-      this.#isExecuted = true;
-      return this;
+    const updatedPayload = Array.from(responseCommand.payload);
+    for (const cmd of commandsToUpdate) {
+      const cmdPayload = cmd.payload;
+      if (cmdPayload && cmdPayload.length >= 2) {
+        const contextGuid = String(cmdPayload[0]);
+        const instanceGuid = String(cmdPayload[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);
+        }
+      }
+      const idx = updatedPayload.indexOf(cmd);
+      if (idx >= 0) updatedPayload.splice(idx, 1);
     }
-    return new InvocationContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true);
+    return new import_Command.Command(responseCommand.runtimeName, responseCommand.commandType, updatedPayload);
   }
   /**
    * Invokes a static method on the target runtime.
@@ -171,14 +243,25 @@ 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 localCommand = new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.CreateClassInstance, [...args]);
+    const createInstanceInvCtx = this.#createInstanceContext(localCommand);
+    return createInstanceInvCtx.#registerForUpdate();
+  }
+  /**
+   * Registers the current InvocationContext for updates.
+   * @returns {InvocationContext}
+   */
+  #registerForUpdate() {
+    this.#currentCommand = this.#buildCommand(new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.RegisterForUpdate, [this.getGuid()]));
+    InvocationContext._invocationContexts.set(this.getGuid(), this);
+    return this;
   }
   /**
    * Retrieves the value of an instance field from the target runtime.
@@ -450,7 +533,7 @@ class InvocationContext {
       }
       return payloadItem;
     } else if (payloadItem instanceof InvocationContext) {
-      return payloadItem.get_current_command();
+      return payloadItem.getCurrentCommand();
     } else if (payloadItem instanceof Array) {
       const copiedArray = payloadItem.map((item) => this.#encapsulatePayloadItem(item));
       return new import_Command.Command(this.#runtimeName, import_CommandType.CommandType.Array, copiedArray);

data/lib/javonet-ruby-sdk/Binaries/Nodejs/dist/sdk/Javonet.cjs

@@ -23,6 +23,7 @@ __export(Javonet_exports, {
   ComplexTypeResolver: () => import_ComplexTypeResolver.ComplexTypeResolver,
   ConfigPriority: () => import_ConfigPriority.ConfigPriority,
   Javonet: () => Javonet,
+  RuntimeContext: () => import_RuntimeContext.RuntimeContext,
   TcpConnectionData: () => import_TcpConnectionData.TcpConnectionData,
   WsConnectionData: () => import_WsConnectionData.WsConnectionData
 });
@@ -129,7 +130,7 @@ class Javonet {
    */
   static initializeRc(configName) {
     const config = import_ConfigSourceResolver.ConfigSourceResolver.getConfig(configName);
-    return import_RuntimeFactory.RuntimeFactory.initializeRuntimeContext(config);
+    return import_RuntimeContext.RuntimeContext.initializeRuntimeContext(config);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -139,6 +140,7 @@ class Javonet {
   ComplexTypeResolver,
   ConfigPriority,
   Javonet,
+  RuntimeContext,
   TcpConnectionData,
   WsConnectionData
 });