javonet-nodejs-sdk 2.6.7 → 2.6.9

package/lib/core/handler/LoadLibraryHandler.js

@@ -13,6 +13,7 @@ let _existsSync = null
 let _resolve = null
 
 const requireDynamic = getRequire(import.meta.url)
+
 class LoadLibraryHandler extends AbstractHandler {
     requiredParametersCount = 1
     /** @type {string[]} */
@@ -29,9 +30,9 @@ class LoadLibraryHandler extends AbstractHandler {
         if (command.payload.length < this.requiredParametersCount) {
             throw new Error('Load Library parameters mismatch')
         }
-        let { payload } = command
-        let [lib] = payload
 
+        const { payload } = command
+        const [lib] = payload
 
         if (!lib) {
             throw new Error('Cannot load module: Library path is required but was not provided')
@@ -46,33 +47,46 @@ class LoadLibraryHandler extends AbstractHandler {
             _resolve = resolve
         }
 
-          const absolutePath = _resolve?.(lib)
+        // Resolve and pick an existing path (relative or absolute)
+        const absolutePath = _resolve ? _resolve(lib) : lib
+        const candidatePaths = [lib, absolutePath]
+        const existingPath = candidatePaths.find(p => _existsSync && _existsSync(p))
 
-          if (!_existsSync?.(lib ?? '') && !_existsSync?.(absolutePath ?? '')) {
-              throw new Error(`Cannot load module: Library not found: ${lib}`)
-          }
+        if (!existingPath) {
+            throw new Error(`Cannot load module: Library not found: ${lib}`)
+        }
 
+        // Normalize to absolute path for deduplication
+        const normalizedPath = _resolve ? _resolve(existingPath) : existingPath
 
-        let pathArray = lib.split(/[/\\]/)
-        let libraryName = pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0]
-        libraryName = libraryName.replace('.js', '')
+        // ✅ Load only once per normalized absolute path
+        if (LoadLibraryHandler.loadedLibraries.includes(normalizedPath)) {
+            return 0
+        }
 
-        let moduleExports
+        // Derive global name from file name (using normalized path)
+        const pathArray = normalizedPath.split(/[/\\]/)
+        let libraryName =
+            pathArray.length > 1 ? pathArray[pathArray.length - 1] : pathArray[0]
+        libraryName = libraryName.replace(/\.js$/i, '')
 
+        let moduleExports
         try {
-            moduleExports = requireDynamic(lib)
-            LoadLibraryHandler.loadedLibraries.push(lib)
+            // Use the normalized path when requiring to keep behavior consistent
+            moduleExports = requireDynamic(normalizedPath)
+            LoadLibraryHandler.loadedLibraries.push(normalizedPath)
         } catch (error) {
-            throw Error('Cannot load module: ' + lib + '\n' + error)
+            throw new Error('Cannot load module: ' + normalizedPath + '\n' + error)
         }
+
         // @ts-expect-error
         global[libraryName] = moduleExports
 
         for (const [key, value] of Object.entries(moduleExports)) {
-            // Here, `key` is the name of the export, and `value` is the exported type itself.
             // @ts-expect-error
             global[key] = value
         }
+
         return 0
     }
 

package/lib/core/handler/PassDelegateHandler.js

@@ -113,9 +113,9 @@ class PassDelegateHandler extends AbstractHandler {
     /**
      * Creates a method call to execute the command.
      * @param {Command} command - The command object.
-     * @returns {any} The response object.
+     * @returns {Promise<any>} The response object.
      */
-    createExecuteCall(command) {
+    async createExecuteCall(command) {
         return this.interpreter?.execute(command, new InMemoryConnectionData())
     }
 

package/lib/core/interpreter/Interpreter.js

@@ -21,7 +21,6 @@ let _Transmitter
 /** @type {typeof import('../transmitter/TransmitterWebsocket.js').TransmitterWebsocket | typeof import('../transmitter/TransmitterWebsocketBrowser.js').TransmitterWebsocketBrowser} */
 let _TransmitterWebsocket = isNodejsRuntime() ? TransmitterWebsocket : TransmitterWebsocketBrowser
 
-
 const requireDynamic = getRequire(import.meta.url)
 
 export class Interpreter {
@@ -40,21 +39,23 @@ export class Interpreter {
      *
      * @param {Command} command
      * @param {IConnectionData} connectionData
-     * @returns {Command | Promise<Command>}
+     * @returns {Promise<Command>}
      */
-    execute(command, connectionData) {
+    async execute(command, connectionData) {
         try {
             let messageByteArray = new CommandSerializer().serialize(command, connectionData)
 
-            if (!(messageByteArray instanceof Uint8Array) && !(messageByteArray instanceof Promise)) {
-                throw new Error('Serialized message is neither Uint8Array nor Promise<Uint8Array>')
+            if (!(messageByteArray instanceof Uint8Array)) {
+                throw new Error('Serialized message is not Uint8Array')
             }
 
             /** @type {Promise<Uint8Array> | Uint8Array | undefined} */
             let responseByteArray = undefined
 
             if (!isNodejsRuntime() && connectionData.connectionType === ConnectionType.IN_MEMORY) {
-                throw new Error('Nodejs Core Error: inMemory is only allowed in Nodejs runtime, not in browser')
+                throw new Error(
+                    'Nodejs Core Error: inMemory is only allowed in Nodejs runtime, not in browser'
+                )
             }
 
             if (
@@ -68,13 +69,7 @@ export class Interpreter {
                 if (!_Receiver) {
                     throw new Error('Nodejs Core Error: Receiver is undefined')
                 }
-                if (messageByteArray instanceof Promise) {
-                    responseByteArray = messageByteArray.then((resolvedMessage) => {
-                        return _Receiver.sendCommand(resolvedMessage)
-                    })
-                } else if (messageByteArray instanceof Uint8Array) {
-                    responseByteArray = _Receiver.sendCommand(messageByteArray)
-                }
+                responseByteArray = await _Receiver.sendCommand(messageByteArray)
             } else if (
                 connectionData.connectionType === ConnectionType.IN_MEMORY ||
                 connectionData.connectionType === ConnectionType.TCP
@@ -86,34 +81,15 @@ export class Interpreter {
                 if (!_Transmitter) {
                     throw new Error('Nodejs Core Error: Transmitter is undefined')
                 }
-                if (messageByteArray instanceof Uint8Array) {
-                    responseByteArray = _Transmitter.sendCommand(messageByteArray)
-                } else {
-                    responseByteArray = messageByteArray.then((resolvedMessage) => {
-                        return _Transmitter.sendCommand(resolvedMessage)
-                    })
-                }
+                responseByteArray = await _Transmitter.sendCommand(messageByteArray)
             } else if (connectionData.connectionType === ConnectionType.WEB_SOCKET) {
-                if (messageByteArray instanceof Uint8Array) {
-                    responseByteArray = _TransmitterWebsocket.sendCommand(messageByteArray, connectionData)
-                } else {
-                    responseByteArray = messageByteArray.then((resolvedMessage) => {
-                        return _TransmitterWebsocket.sendCommand(resolvedMessage, connectionData)
-                    })
-                }
+                responseByteArray = await _TransmitterWebsocket.sendCommand(messageByteArray, connectionData)
             }
 
             if (!responseByteArray) {
                 throw new Error('No response received from Transmitter')
             }
-
-            if (responseByteArray instanceof Promise) {
-                return responseByteArray.then((resolvedResponse) => {
-                    return new CommandDeserializer(resolvedResponse).deserialize()
-                })
-            } else {
-                return new CommandDeserializer(responseByteArray).deserialize()
-            }
+            return new CommandDeserializer(responseByteArray).deserialize()
         } catch (error) {
             throw error
         }

package/lib/core/protocol/CommandSerializer.js

@@ -1,3 +1,4 @@
+// @ts-check
 import { TypeSerializer } from './TypeSerializer.js'
 import { ReferencesCache } from '../referenceCache/ReferencesCache.js'
 import { Command } from '../../utils/Command.js'
@@ -11,26 +12,20 @@ import { TypesHandler } from '../../utils/TypesHandler.js'
 class CommandSerializer {
     /**
      * Serializes the root command with connection data and optional runtime version.
-     * @param {Promise<Command> | Command} rootCommand
+     * @param {Command} rootCommand
      * @param {IConnectionData} connectionData
      * @param {number} runtimeVersion
-     * @returns {Promise<Uint8Array> | Uint8Array}
+     * @returns {Uint8Array}
      */
     serialize(rootCommand, connectionData, runtimeVersion = 0) {
+        /** @type {Array<Uint8Array>} */
         const buffers = []
 
-        // Write runtime name and version
-        if (rootCommand instanceof Promise) {
-            return rootCommand.then(resolvedCommand => {
-                return this.serialize(resolvedCommand, connectionData, runtimeVersion)
-            })
-        }
-
         buffers.push(Uint8Array.of(rootCommand.runtimeName, runtimeVersion))
 
         // Write connection data or default zeros
         if (connectionData) {
-            buffers.push(connectionData.serializeConnectionData())
+            buffers.push(Uint8Array.from(connectionData.serializeConnectionData()))
         } else {
             buffers.push(Uint8Array.of(0, 0, 0, 0, 0, 0, 0))
         }

package/lib/core/receiver/Receiver.js

@@ -19,11 +19,11 @@ export class Receiver {
 
     /**
      * @param {Uint8Array} messageByteArray
-     * @returns {Promise<Uint8Array> | Uint8Array}
+     * @returns {Promise<Uint8Array>}
      */
-    static sendCommand(messageByteArray) {
+    static async sendCommand(messageByteArray) {
         try {
-            let command = new Interpreter().process(messageByteArray)
+            let command = await new Interpreter().process(messageByteArray)
             return new CommandSerializer().serialize(command, this.connectionData)
         } catch (error) {
             const exceptionCommand = ExceptionSerializer.serializeException(
@@ -36,12 +36,12 @@ export class Receiver {
 
     /**
      * @param {Uint8Array} messageByteArray
-     * @returns {Promise<Uint8Array> | Uint8Array}
+     * @returns {Promise<Uint8Array>}
      */
-    static heartBeat(messageByteArray) {
+    static async heartBeat(messageByteArray) {
         let response = new Uint8Array(2)
         response[0] = messageByteArray[11]
         response[1] = messageByteArray[12] - 2
-        return response
+        return Promise.resolve(response)
     }
 }

package/lib/sdk/Activator.js

@@ -0,0 +1,22 @@
+/**
+ * Details for activating a type with constructor arguments
+ */
+class Activator {
+    /**
+     * Create a new instance of a type
+     * @param {Function} Type - The constructor function/class
+     * @param {any[] | any} args - The arguments to pass to the constructor
+     * @returns {any} The new instance
+     */
+    static createInstance(Type, args) {
+        if (args == null) {
+            args = []
+        }
+        if (!Array.isArray(args)) {
+            args = [args]
+        }
+        return new Type(...args)
+    }
+}
+
+export { Activator }

package/lib/sdk/ActivatorDetails.js

@@ -2,13 +2,28 @@
  * Details for activating a type with constructor arguments
  */
 class ActivatorDetails {
+    /** @type {Function} */
+    Type
+
+    /** @type {any[]} */
+    arguments
+
     /**
      * @param {Function} type - The constructor function/class
-     * @param {any[]} [args] - Arguments to pass to constructor
+     * @param {any[]|any} [args] - Arguments to pass to constructor (array or single value)
      */
     constructor(type, args = []) {
-        this.type = type
-        this.arguments = args
+        this.Type = type
+        // Normalize args: ensure it's always an array
+        // Handles: undefined, null, single value, or array
+        if (args == null) {
+            this.arguments = []
+        } else if (Array.isArray(args)) {
+            this.arguments = args
+        } else {
+            // Single value - wrap in array
+            this.arguments = [args]
+        }
     }
 }
 

package/lib/sdk/ConfigRuntimeFactory.js

@@ -102,6 +102,16 @@ export class ConfigRuntimeFactory {
         return this.#getRuntimeContext(RuntimeName.Nodejs, configName)
     }
 
+    /** 
+     * Creates RuntimeContext instance to interact with the Php runtime.
+     * @param {string} [configName="default"] - The name of the configuration to use (optional).
+     * @return {RuntimeContext} a RuntimeContext instance for the Php runtime
+     * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/foundations/runtime-context)
+     */
+    php(configName = 'default') {
+        return this.#getRuntimeContext(RuntimeName.Php, configName)
+    }
+
     /**
      * Creates RuntimeContext instance to interact with the Python 2.7 runtime.
      * @param {string} [configName="default"] - The name of the configuration to use (optional).

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
@@ -27,12 +27,17 @@ class InvocationContext {
     #connectionData
     /** @type {Command | null} */
     #currentCommand = null
-    /** @type {Command | Promise<Command> | null} */
+    /** @type {Command | null} */
     #responseCommand = null
     /** @type {boolean} */
     #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
     }
 
     /**
@@ -79,43 +93,31 @@ class InvocationContext {
     //        this.execute();
     //    }
     //}
-    [Symbol.iterator] = () => {
+    /**
+     * Async iterator for InvocationContext arrays
+     * Use: for await (const item of invocationContext) { ... }
+     * @returns {AsyncGenerator<InvocationContext, void, unknown>}
+     */
+    async *[Symbol.asyncIterator]() {
         if (this.#currentCommand?.commandType !== CommandType.Reference) {
             throw new Error('Object is not iterable')
         }
-        let position = -1
-        /** @type {number} */
-        let arraySize = 0
-        /** @type {InvocationContext | Promise<InvocationContext>} */
-        const sizeCtx = /** @type {any} */ (this.getSize().execute())
-        if (sizeCtx instanceof Promise) {
-            sizeCtx.then((ctx) => {
-                arraySize = Number(ctx.getValue())
-            })
-        } else {
-            arraySize = Number(sizeCtx.getValue())
-        }
 
-        return {
-            next: () => ({
-                value: this.getIndex(++position),
-                done: position >= arraySize,
-            }),
+        const sizeCtx = await this.getSize().execute()
+        const arraySize = Number(sizeCtx.getValue())
+
+        for (let position = 0; position < arraySize; position++) {
+            yield this.getIndex(position)
         }
     }
 
     /**
      * 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> | 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() {
+    async execute() {
         if (this.#currentCommand === null) {
             throw new Error('currentCommand is undefined in Invocation Context execute method')
         }
@@ -124,28 +126,25 @@ class InvocationContext {
             this.#interpreter = new Interpreter()
         }
 
-        this.#responseCommand = this.#interpreter.execute(this.#currentCommand, this.#connectionData)
+        // Execute command on interpreter
+        this.#responseCommand = await this.#interpreter.execute(this.#currentCommand, this.#connectionData)
 
-        const handleResponse = (/** @type {Command} */ resolvedResponse) => {
-            if (!resolvedResponse) {
-                throw new Error('responseCommand is undefined in Invocation Context execute method')
-            }
-            if (resolvedResponse.commandType === CommandType.Exception) {
-                throw ExceptionThrower.throwException(resolvedResponse)
-            }
-            if (resolvedResponse.commandType === CommandType.CreateClassInstance) {
-                this.#currentCommand = resolvedResponse
-                this.#isExecuted = true
-                return this
-            }
-            return new InvocationContext(this.#runtimeName, this.#connectionData, resolvedResponse, true)
+        if (!this.#responseCommand) {
+            throw new Error('responseCommand is undefined in Invocation Context execute method')
+        }
+        if (this.#responseCommand.commandType === CommandType.Exception) {
+            throw ExceptionThrower.throwException(this.#responseCommand)
         }
 
-        if (this.#responseCommand instanceof Promise) {
-            return this.#responseCommand.then(handleResponse)
-        } else {
-            return handleResponse(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
+            return this
         }
+        return new InvocationContext(this.#runtimeName, this.#connectionData, this.#responseCommand, true)
     }
 
     /**
@@ -191,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
     }
 
     /**
@@ -402,29 +417,19 @@ class InvocationContext {
 
     /**
      * Retrieves the type of the object from the target runtime.
-     * @returns {Promise<string> | string} The type of the object.
+     * @returns {Promise<string>} The type of the object.
      * @see [Javonet Guides](https://www.javonet.com/guides/v2/javascript/type-handling/getting-object-type)
      * @method
      */
-    getResultType() {
+    async getResultType() {
         const localCommand = new Command(this.#runtimeName, CommandType.GetResultType, [])
         const invocationContext = new InvocationContext(
             this.#runtimeName,
             this.#connectionData,
             this.#buildCommand(localCommand)
         )
-        /** @type {InvocationContext | Promise<InvocationContext>} */
-        const execCtx = invocationContext.execute()
-
-        /**
-         * @param {InvocationContext} invCtx
-         * @returns {string}
-         */
-        const extract = (invCtx) => String(invCtx.getValue())
-
-        console.log(execCtx)
-
-        return execCtx instanceof Promise ? execCtx.then(extract) : extract(execCtx)
+        const execCtx = await invocationContext.execute()
+        return String(execCtx.getValue())
     }
 
     /**
@@ -439,10 +444,11 @@ class InvocationContext {
 
     /**
      * Retrieves an array from the target runtime.
+     * @async
      * @returns {Promise<any[]>}
      * @method
      */
-    retrieveArray() {
+    async retrieveArray() {
         const localCommand = new Command(this.#runtimeName, CommandType.RetrieveArray, [])
         const localInvCtx = new InvocationContext(
             this.#runtimeName,
@@ -450,16 +456,27 @@ class InvocationContext {
             this.#buildCommand(localCommand)
         )
 
-        localInvCtx.execute() // Promise<InvocationContext> | InvocationContext
+        await localInvCtx.execute()
+
+        const resolve = (/** @type {any} */ item) => {
+            return item?.commandType === CommandType.Reference ?
+            new InvocationContext(
+                this.#runtimeName,
+                this.#connectionData,
+                item
+            ) : item
+        }
+
+        const respCommand = localInvCtx.#responseCommand
+        if (!respCommand) {
+            return []
+        }
 
-        const extract = (/** @type {Command} */ respCommand) => {
-            return respCommand.payload
+        if (respCommand.payload) {
+            return respCommand.payload.map((/** @type {any} */ item) => resolve(item))
         }
 
-        // Normalize to Promise
-        return localInvCtx.#responseCommand instanceof Promise
-            ? localInvCtx.#responseCommand.then(extract)
-            : localInvCtx.#responseCommand?.payload
+        return respCommand.payload || []
     }
 
     /**
@@ -506,9 +523,8 @@ class InvocationContext {
             for (let i = 0; i < newArray.length; i++) {
                 newArray[i] = typeof Object
             }
-            const args = [delegatesCacheInstance.addDelegate(payloadItem), RuntimeName.Nodejs].push(
-                ...newArray
-            )
+            const args = [delegatesCacheInstance.addDelegate(payloadItem), RuntimeName.Nodejs]
+            args.push(...newArray)
             return new Command(this.#runtimeName, CommandType.PassDelegate, args)
         } else if (TypesHandler.isPrimitiveOrNullOrUndefined(payloadItem)) {
             return new Command(this.#runtimeName, CommandType.Value, [payloadItem])
@@ -521,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/sdk/Javonet.js

@@ -12,6 +12,7 @@ import { WsConnectionData } from '../utils/connectionData/WsConnectionData.js'
 import { UtilsConst } from '../utils/UtilsConst.js'
 import { ConfigSourceResolver } from './configuration/ConfigSourceResolver.js'
 import { ConfigPriority } from './configuration/ConfigPriority.js'
+import { ComplexTypeResolver } from './tools/ComplexTypeResolver.js'
 
 /** @typedef {import('../types.d.ts').ConfigSource} ConfigSource */
 
@@ -132,4 +133,5 @@ export {
     CommandSerializer,
     CommandDeserializer,
     ConfigPriority,
+    ComplexTypeResolver,
 }