@olane/o-node 0.7.12-alpha.39 → 0.7.12-alpha.40

package/dist/o-node/src/ui/ui-graph.manager.js

@@ -0,0 +1,274 @@
+import { oNodeTool } from '../o-node.tool';
+import { oRequest } from '../../../o-core/src';
+import { oAddress } from '../../../o-core/src';
+/**
+ * UIGraphManager manages the hierarchical graph of UI components
+ * Acts as a centralized registry for all UI elements in the application
+ */
+export class UIGraphManager extends oNodeTool {
+    constructor() {
+        super(...arguments);
+        this.componentRegistry = new Map();
+        this.methodHandlers = {};
+    }
+    /**
+     * Register a new UI component in the graph
+     */
+    async _tool_register_component(request) {
+        const { id, type, address, props = {}, state = {}, parentId = null, methods = [], metadata = {}, } = request.params;
+        this.logger.info(`Registering component: ${id} (${type})`);
+        // Check if component already exists
+        if (this.componentRegistry.has(id)) {
+            this.logger.warn(`Component ${id} already registered, updating instead`);
+            const updateRequest = new oRequest({
+                method: 'update_component',
+                params: { nodeId: id, props, state, metadata },
+                id: request.id,
+            });
+            await this._tool_update_component(updateRequest);
+            return {
+                success: true,
+                nodeId: id,
+                address: address,
+                message: 'Component already exists, updated instead',
+            };
+        }
+        const now = Date.now();
+        // Create component node
+        const componentNode = {
+            id,
+            type,
+            address: new oAddress(address),
+            props,
+            state,
+            parentId,
+            childIds: [],
+            methods,
+            registeredAt: now,
+            updatedAt: now,
+            metadata,
+        };
+        // Add to registry
+        this.componentRegistry.set(id, componentNode);
+        // If has parent, add as child to parent
+        if (parentId) {
+            const parent = this.componentRegistry.get(parentId);
+            if (parent) {
+                if (!parent.childIds.includes(id)) {
+                    parent.childIds.push(id);
+                    parent.updatedAt = now;
+                }
+            }
+            else {
+                this.logger.warn(`Parent ${parentId} not found for component ${id}, will register as orphan`);
+            }
+        }
+        this.logger.info(`Component ${id} registered successfully. Total components: ${this.componentRegistry.size}`);
+        return {
+            success: true,
+            nodeId: id,
+            address: componentNode.address.toString(),
+            message: 'Component registered successfully',
+        };
+    }
+    /**
+     * Unregister a UI component from the graph
+     */
+    async _tool_unregister_component(request) {
+        const { nodeId } = request.params;
+        this.logger.info(`Unregistering component: ${nodeId}`);
+        const component = this.componentRegistry.get(nodeId);
+        if (!component) {
+            this.logger.warn(`Component ${nodeId} not found`);
+            return {
+                success: false,
+                message: 'Component not found',
+            };
+        }
+        // Remove from parent's children
+        if (component.parentId) {
+            const parent = this.componentRegistry.get(component.parentId);
+            if (parent) {
+                parent.childIds = parent.childIds.filter((id) => id !== nodeId);
+                parent.updatedAt = Date.now();
+            }
+        }
+        // Recursively unregister all children
+        for (const childId of component.childIds) {
+            const childRequest = new oRequest({
+                method: 'unregister_component',
+                params: { nodeId: childId },
+                id: request.id,
+            });
+            await this._tool_unregister_component(childRequest);
+        }
+        // Remove method handlers
+        delete this.methodHandlers[nodeId];
+        // Remove from registry
+        this.componentRegistry.delete(nodeId);
+        this.logger.info(`Component ${nodeId} unregistered. Total components: ${this.componentRegistry.size}`);
+        return {
+            success: true,
+            message: 'Component unregistered successfully',
+        };
+    }
+    /**
+     * Update component props, state, or metadata
+     */
+    async _tool_update_component(request) {
+        const { nodeId, props, state, metadata } = request.params;
+        const component = this.componentRegistry.get(nodeId);
+        if (!component) {
+            this.logger.warn(`Component ${nodeId} not found for update`);
+            return {
+                success: false,
+                message: 'Component not found',
+            };
+        }
+        // Update props
+        if (props) {
+            component.props = { ...component.props, ...props };
+        }
+        // Update state
+        if (state) {
+            component.state = { ...component.state, ...state };
+        }
+        // Update metadata
+        if (metadata) {
+            component.metadata = { ...component.metadata, ...metadata };
+        }
+        component.updatedAt = Date.now();
+        this.logger.debug(`Component ${nodeId} updated`);
+        return {
+            success: true,
+            message: 'Component updated successfully',
+        };
+    }
+    /**
+     * Invoke a method on a component
+     */
+    async _tool_invoke_action(request) {
+        const { nodeId, method, params } = request.params;
+        this.logger.info(`Invoking ${method} on component ${nodeId}`);
+        const component = this.componentRegistry.get(nodeId);
+        if (!component) {
+            throw new Error(`Component ${nodeId} not found`);
+        }
+        if (!component.methods.includes(method)) {
+            throw new Error(`Method ${method} not available on component ${nodeId}`);
+        }
+        // Get method handler
+        const handler = this.methodHandlers[nodeId]?.[method];
+        if (!handler) {
+            throw new Error(`Method handler for ${method} not registered for component ${nodeId}`);
+        }
+        // Invoke handler
+        const result = await handler(params);
+        this.logger.debug(`Method ${method} invoked on ${nodeId}`);
+        return {
+            success: true,
+            result,
+        };
+    }
+    /**
+     * Query component hierarchy
+     */
+    async _tool_query_hierarchy(request) {
+        const { nodeId } = request.params;
+        const component = this.componentRegistry.get(nodeId);
+        if (!component) {
+            throw new Error(`Component ${nodeId} not found`);
+        }
+        // Get children
+        const children = component.childIds
+            .map((id) => this.componentRegistry.get(id))
+            .filter((c) => c !== undefined);
+        // Get parent
+        const parent = component.parentId
+            ? this.componentRegistry.get(component.parentId) || null
+            : null;
+        return {
+            node: component,
+            children,
+            parent,
+        };
+    }
+    /**
+     * Get all registered components (for debugging)
+     */
+    async _tool_list_components(request) {
+        const components = Array.from(this.componentRegistry.values());
+        return {
+            components,
+            count: components.length,
+        };
+    }
+    /**
+     * Get component tree structure
+     */
+    async _tool_get_tree(request) {
+        // Find root components (those without parents)
+        const roots = Array.from(this.componentRegistry.values()).filter((c) => !c.parentId);
+        const buildTree = (node) => {
+            const children = node.childIds
+                .map((id) => this.componentRegistry.get(id))
+                .filter((c) => c !== undefined)
+                .map((c) => buildTree(c));
+            return {
+                id: node.id,
+                type: node.type,
+                address: node.address.toString(),
+                props: node.props,
+                metadata: node.metadata,
+                children,
+            };
+        };
+        return {
+            roots: roots.map((r) => buildTree(r)),
+        };
+    }
+    /**
+     * Register a method handler for a component
+     * This is called from the client side to register callbacks
+     */
+    registerMethodHandler(nodeId, method, handler) {
+        if (!this.methodHandlers[nodeId]) {
+            this.methodHandlers[nodeId] = {};
+        }
+        this.methodHandlers[nodeId][method] = handler;
+        this.logger.debug(`Method handler ${method} registered for ${nodeId}`);
+    }
+    /**
+     * Unregister all method handlers for a component
+     */
+    unregisterMethodHandlers(nodeId) {
+        delete this.methodHandlers[nodeId];
+        this.logger.debug(`Method handlers unregistered for ${nodeId}`);
+    }
+    /**
+     * Get component by ID
+     */
+    getComponent(nodeId) {
+        return this.componentRegistry.get(nodeId);
+    }
+    /**
+     * Get all children of a component
+     */
+    getComponentChildren(nodeId) {
+        const component = this.componentRegistry.get(nodeId);
+        if (!component)
+            return [];
+        return component.childIds
+            .map((id) => this.componentRegistry.get(id))
+            .filter((c) => c !== undefined);
+    }
+    /**
+     * Get parent of a component
+     */
+    getParent(nodeId) {
+        const component = this.componentRegistry.get(nodeId);
+        if (!component || !component.parentId)
+            return null;
+        return this.componentRegistry.get(component.parentId) || null;
+    }
+}

package/dist/o-node/src/utils/index.d.ts

@@ -1,5 +1,3 @@
 export * from './stream.utils.js';
 export * from './network.utils.js';
-export * from './circuit-breaker.js';
-export * from './leader-request-wrapper.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/o-node/src/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}

package/dist/o-node/src/utils/index.js

@@ -1,4 +1,2 @@
 export * from './stream.utils.js';
 export * from './network.utils.js';
-export * from './circuit-breaker.js';
-export * from './leader-request-wrapper.js';

package/dist/o-node/src/utils/stream.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/stream.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAa,OAAO,EAAE,QAAQ,EAAa,MAAM,eAAe,CAAC;AAExE,qBAAa,WAAY,SAAQ,OAAO;WAClB,gBAAgB,CAClC,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,cAAc,CAAC,GAAG,CAAC,EAC9B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,GAAG,CAAC;CA8BhB"}
+{"version":3,"file":"stream.utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/stream.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAEL,OAAO,EACP,QAAQ,EAGT,MAAM,eAAe,CAAC;AAEvB,qBAAa,WAAY,SAAQ,OAAO;WAClB,gBAAgB,CAClC,OAAO,EAAE,QAAQ,EACjB,SAAS,EAAE,cAAc,CAAC,GAAG,CAAC,EAC9B,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,GAAG,CAAC;CA6BhB"}

package/dist/o-node/src/utils/stream.utils.js

@@ -1,27 +1,31 @@
-import { CoreUtils, oObject, oResponse } from '@olane/o-core';
+import { CoreUtils, oObject, ResponseBuilder, } from '@olane/o-core';
 export class StreamUtils extends oObject {
     static async processGenerator(request, generator, stream) {
         const utils = new StreamUtils();
-        for await (const result of generator) {
-            utils.logger.debug('Sending stream response: ', result);
-            await CoreUtils.sendStreamResponse(new oResponse({
-                id: request.id,
-                data: result,
-                _last: false,
-                _requestMethod: request.method,
-                _connectionId: request.params?._connectionId,
-            }), stream);
+        const responseBuilder = ResponseBuilder.create();
+        let aggregatedResult = '';
+        try {
+            // Send each chunk from the generator
+            // result should not be an oResponse, but rather a key value pair dict
+            for await (const result of generator) {
+                if (result.delta) {
+                    aggregatedResult += result.delta;
+                }
+                const chunkResponse = await responseBuilder.buildChunk(request, result);
+                await CoreUtils.sendStreamResponse(chunkResponse, stream);
+            }
+            return {
+                message: aggregatedResult,
+            };
+        }
+        catch (error) {
+            // If error occurs during streaming, send error response
+            const errorResponse = await responseBuilder.buildError(request, error, {
+                isStream: true,
+                isLast: true,
+            });
+            await CoreUtils.sendStreamResponse(errorResponse, stream);
+            throw error;
         }
-        await CoreUtils.sendStreamResponse(new oResponse({
-            id: request.id,
-            data: 'Stream completed',
-            _last: true,
-            _requestMethod: request.method,
-            _connectionId: request.params?._connectionId,
-        }), stream);
-        return Promise.resolve({
-            success: true,
-            response: 'Stream started',
-        });
     }
 }

package/dist/o-node/test/helpers/test-node.tool.d.ts

@@ -0,0 +1,15 @@
+import { oNodeTool } from '../../src/o-node.tool.js';
+/**
+ * Test-only extension of oNodeTool that adds streaming test methods.
+ * This class should only be used in test files and is not part of the production code.
+ */
+export declare class TestNodeTool extends oNodeTool {
+    /**
+     * Test method that emits chunks for 10 seconds at 100ms intervals.
+     * Used for testing streaming functionality across hierarchical networks.
+     *
+     * @returns AsyncGenerator that yields 100 chunks over 10 seconds
+     */
+    _tool_test_stream(): AsyncGenerator<any>;
+}
+//# sourceMappingURL=test-node.tool.d.ts.map

package/dist/o-node/test/helpers/test-node.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-node.tool.d.ts","sourceRoot":"","sources":["../../../../test/helpers/test-node.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD;;;GAGG;AACH,qBAAa,YAAa,SAAQ,SAAS;IACzC;;;;;OAKG;IACI,iBAAiB,IAAI,cAAc,CAAC,GAAG,CAAC;CAehD"}

package/dist/o-node/test/helpers/test-node.tool.js

@@ -0,0 +1,27 @@
+import { oNodeTool } from '../../src/o-node.tool.js';
+/**
+ * Test-only extension of oNodeTool that adds streaming test methods.
+ * This class should only be used in test files and is not part of the production code.
+ */
+export class TestNodeTool extends oNodeTool {
+    /**
+     * Test method that emits chunks for 10 seconds at 100ms intervals.
+     * Used for testing streaming functionality across hierarchical networks.
+     *
+     * @returns AsyncGenerator that yields 100 chunks over 10 seconds
+     */
+    async *_tool_test_stream() {
+        const totalDuration = 10000; // 10 seconds
+        const intervalMs = 100; // 100ms between chunks
+        const totalChunks = totalDuration / intervalMs; // 100 chunks
+        for (let i = 0; i < totalChunks; i++) {
+            yield {
+                chunk: i + 1,
+                timestamp: new Date().toISOString(),
+                nodeAddress: this.address.toString(),
+                message: `Chunk ${i + 1} of ${totalChunks}`,
+            };
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+    }
+}

package/dist/src/connection/o-node-connection.manager.d.ts

@@ -1,5 +1,5 @@
 import { oAddress, oConnectionConfig, oConnectionManager } from '@olane/o-core';
-import { oConnection } from '@olane/o-core';
+import { Connection } from '@olane/o-config';
 import { oNodeConnectionManagerConfig } from './interfaces/o-node-connection-manager.config.js';
 import { oNodeConnection } from './o-node-connection.js';
 export declare class oNodeConnectionManager extends oConnectionManager {
@@ -8,12 +8,22 @@ export declare class oNodeConnectionManager extends oConnectionManager {
     private defaultDrainTimeoutMs?;
     constructor(config: oNodeConnectionManagerConfig);
     /**
-     * Connect to a given address with exponential backoff retry
-     * @param address - The address to connect to
+     * Connect to a given address, reusing libp2p connections when possible
+     * @param config - Connection configuration
      * @returns The connection object
      */
     connect(config: oConnectionConfig): Promise<oNodeConnection>;
+    /**
+     * Check if libp2p has an active connection to the target peer
+     * @param address - The address to check
+     * @returns true if an active connection exists
+     */
     isCached(address: oAddress): boolean;
-    getCachedConnection(address: oAddress): oConnection | null;
+    /**
+     * Get an existing libp2p connection to the target peer
+     * @param address - The address to get a connection for
+     * @returns The libp2p Connection object or null if not found
+     */
+    getCachedLibp2pConnection(address: oAddress): Connection | null;
 }
 //# sourceMappingURL=o-node-connection.manager.d.ts.map

package/dist/src/connection/o-node-connection.manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node-connection.manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,oBAAoB,CAAC,CAAS;IACtC,OAAO,CAAC,qBAAqB,CAAC,CAAS;gBAE3B,MAAM,EAAE,4BAA4B;IAOhD;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IAmDlE,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IAIpC,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,WAAW,GAAG,IAAI;CAe3D"}
+{"version":3,"file":"o-node-connection.manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,EAAU,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,qBAAa,sBAAuB,SAAQ,kBAAkB;IAC5D,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,oBAAoB,CAAC,CAAS;IACtC,OAAO,CAAC,qBAAqB,CAAC,CAAS;gBAE3B,MAAM,EAAE,4BAA4B;IAOhD;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IA+ClE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IA2BpC;;;;OAIG;IACH,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI;CA2BhE"}

package/dist/src/connection/o-node-connection.manager.js

@@ -1,4 +1,5 @@
 import { oConnectionManager } from '@olane/o-core';
+import { peerIdFromString } from '@libp2p/peer-id';
 import { oNodeConnection } from './o-node-connection.js';
 export class oNodeConnectionManager extends oConnectionManager {
     constructor(config) {
@@ -8,28 +9,24 @@ export class oNodeConnectionManager extends oConnectionManager {
         this.defaultDrainTimeoutMs = config.defaultDrainTimeoutMs;
     }
     /**
-     * Connect to a given address with exponential backoff retry
-     * @param address - The address to connect to
+     * Connect to a given address, reusing libp2p connections when possible
+     * @param config - Connection configuration
      * @returns The connection object
      */
     async connect(config) {
         const { address, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, } = config;
-        // check if we already have a connection to this address
-        // TODO: how can we enable caching of connections & connection lifecycles
-        if (this.isCached(nextHopAddress)) {
-            const cachedConnection = this.getCachedConnection(nextHopAddress);
-            if (cachedConnection &&
-                cachedConnection.p2pConnection.status === 'open') {
-                this.logger.debug('Using cached connection for address: ' + address.toString());
-                return cachedConnection;
-            }
-            else {
-                // cached item is not valid, remove it
-                this.cache.delete(nextHopAddress.toString());
-            }
+        // Check if libp2p already has an active connection to this peer
+        const existingConnection = this.getCachedLibp2pConnection(nextHopAddress);
+        let p2pConnection;
+        if (existingConnection && existingConnection.status === 'open') {
+            this.logger.debug('Reusing existing libp2p connection for address: ' + address.toString());
+            p2pConnection = existingConnection;
+        }
+        else {
+            // No existing connection or connection is closed, dial a new one
+            this.logger.debug('Dialing new connection for address: ' + address.toString());
+            p2pConnection = await this.p2pNode.dial(nextHopAddress.libp2pTransports.map((ma) => ma.toMultiaddr()));
         }
-        // Retry configuration for handling transient connection failures
-        const p2pConnection = await this.p2pNode.dial(nextHopAddress.libp2pTransports.map((ma) => ma.toMultiaddr()));
         const connection = new oNodeConnection({
             nextHopAddress: nextHopAddress,
             address: address,
@@ -40,26 +37,61 @@ export class oNodeConnectionManager extends oConnectionManager {
             isStream: config.isStream ?? false,
             abortSignal: config.abortSignal,
         });
-        // this.cache.set(nextHopAddress.toString(), connection);
         return connection;
     }
+    /**
+     * Check if libp2p has an active connection to the target peer
+     * @param address - The address to check
+     * @returns true if an active connection exists
+     */
     isCached(address) {
-        return this.cache.has(address.toString());
+        try {
+            const nodeAddress = address;
+            if (!nodeAddress.libp2pTransports ||
+                nodeAddress.libp2pTransports.length === 0) {
+                return false;
+            }
+            // Extract peer ID from the first transport
+            const peerIdString = nodeAddress.libp2pTransports[0].toPeerId();
+            if (!peerIdString) {
+                return false;
+            }
+            const peerId = peerIdFromString(peerIdString);
+            const connections = this.p2pNode.getConnections(peerId);
+            // Check if we have at least one open connection
+            return connections.some((conn) => conn.status === 'open');
+        }
+        catch (error) {
+            this.logger.debug('Error checking cached connection:', error);
+            return false;
+        }
     }
-    getCachedConnection(address) {
-        const key = address.toString();
+    /**
+     * Get an existing libp2p connection to the target peer
+     * @param address - The address to get a connection for
+     * @returns The libp2p Connection object or null if not found
+     */
+    getCachedLibp2pConnection(address) {
         try {
-            const connection = this.cache.get(key);
-            if (!connection) {
-                throw new Error('Connection not found in cache');
+            const nodeAddress = address;
+            if (!nodeAddress.libp2pTransports ||
+                nodeAddress.libp2pTransports.length === 0) {
+                return null;
+            }
+            // Extract peer ID from the first transport
+            const peerIdString = nodeAddress.libp2pTransports[0].toPeerId();
+            if (!peerIdString) {
+                return null;
             }
-            connection.validate();
-            return connection;
+            const peerId = peerIdFromString(peerIdString);
+            const connections = this.p2pNode.getConnections(peerId);
+            // Return the first open connection, or null if none exist
+            const openConnection = connections.find((conn) => conn.status === 'open');
+            return openConnection || null;
         }
         catch (error) {
-            this.cache.delete(key);
-            this.logger.error('Error getting cached connection:', error);
+            this.logger.debug('Error getting cached connection:', error);
+            return null;
         }
-        return null;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.12-alpha.39",
+  "version": "0.7.12-alpha.40",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -54,12 +54,12 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.12-alpha.39",
-    "@olane/o-core": "0.7.12-alpha.39",
-    "@olane/o-protocol": "0.7.12-alpha.39",
-    "@olane/o-tool": "0.7.12-alpha.39",
+    "@olane/o-config": "0.7.12-alpha.40",
+    "@olane/o-core": "0.7.12-alpha.40",
+    "@olane/o-protocol": "0.7.12-alpha.40",
+    "@olane/o-tool": "0.7.12-alpha.40",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0"
   },
-  "gitHead": "794416f70451282e59b498e969c6597896abec29"
+  "gitHead": "c17794cf9be8ca5cdeec0cc5d6a3c680065b3b93"
 }