@olane/o-node 0.7.12-alpha.9 → 0.7.13-alpha.0

package/dist/src/managers/o-connection-heartbeat.manager.js

@@ -1,39 +1,38 @@
-import { oObject, ChildLeftEvent, ParentDisconnectedEvent, LeaderDisconnectedEvent, ConnectionDegradedEvent, ConnectionRecoveredEvent, } from '@olane/o-core';
+import { oObject, ChildLeftEvent, ParentDisconnectedEvent, LeaderDisconnectedEvent, ConnectionDegradedEvent, ConnectionRecoveredEvent, oAddress, } from '@olane/o-core';
 /**
- * Connection Heartbeat Manager
+ * Connection Health Monitor
  *
- * Uses libp2p's native ping service to detect dead connections early.
- * Continuously pings parent and children to ensure they're alive.
+ * Monitors connection health by checking libp2p's connection state directly.
+ * Continuously checks parent and children connections to detect failures early.
  *
  * How it works:
- * - Every `intervalMs`, pings all tracked connections
- * - If ping fails, increments failure counter
+ * - Every `intervalMs`, checks connection status of all tracked connections
+ * - Uses libp2p's connection state (no network overhead from pings)
+ * - If connection is not open, increments failure counter
  * - After `failureThreshold` failures, marks connection as dead
  * - Emits events for degraded/recovered/dead connections
  * - Automatically removes dead children from hierarchy
  * - Emits ParentDisconnectedEvent when parent dies (triggers reconnection)
  */
 export class oConnectionHeartbeatManager extends oObject {
-    constructor(p2pNode, hierarchyManager, notificationManager, address, config) {
+    constructor(node, config) {
         super();
-        this.p2pNode = p2pNode;
-        this.hierarchyManager = hierarchyManager;
-        this.notificationManager = notificationManager;
-        this.address = address;
+        this.node = node;
         this.config = config;
         this.healthMap = new Map();
+        this.isRunning = false;
     }
     async start() {
         if (!this.config.enabled) {
-            this.logger.debug('Connection heartbeat disabled');
+            this.logger.debug('Connection health monitoring disabled');
             return;
         }
-        this.logger.info(`Starting connection heartbeat: interval=${this.config.intervalMs}ms, ` +
-            `timeout=${this.config.timeoutMs}ms, threshold=${this.config.failureThreshold}`);
+        this.logger.info(`Starting connection health monitoring: interval=${this.config.intervalMs}ms, ` +
+            `threshold=${this.config.failureThreshold}`);
         // Immediate first check
-        await this.performHeartbeatCycle();
+        await this.performHealthCheckCycle();
         // Schedule recurring checks
-        this.heartbeatInterval = setInterval(() => this.performHeartbeatCycle(), this.config.intervalMs);
+        this.heartbeatInterval = setInterval(() => this.performHealthCheckCycle(), this.config.intervalMs);
     }
     async stop() {
         if (this.heartbeatInterval) {
@@ -42,38 +41,70 @@ export class oConnectionHeartbeatManager extends oObject {
         }
         this.healthMap.clear();
     }
-    async performHeartbeatCycle() {
+    async performHealthCheckCycle() {
+        if (this.isRunning) {
+            return;
+        }
+        this.isRunning = true;
         const targets = [];
         // Check if this is a leader node (no leader in hierarchy = we are leader)
-        const isLeaderNode = this.hierarchyManager.getLeaders().length === 0;
+        const isLeaderNode = this.node.getLeaders().length === 0;
         // Collect leader (if enabled and we're not the leader)
-        if (this.config.checkLeader && !isLeaderNode) {
-            const leaders = this.hierarchyManager.getLeaders();
+        if (!isLeaderNode) {
+            const leaders = this.node.getLeaders();
             for (const leader of leaders) {
                 targets.push({ address: leader, role: 'leader' });
             }
         }
         // Collect parent
         if (this.config.checkParent && !isLeaderNode) {
-            const parents = this.hierarchyManager.getParents();
-            for (const parent of parents) {
+            // Use this.node.parent getter to get the current parent address with transports
+            // rather than getParents() which may have a stale reference
+            const parent = this.node.parent;
+            // make sure that we don't double check the leader
+            if (parent && parent?.toString() !== oAddress.leader().toString()) {
                 targets.push({ address: parent, role: 'parent' });
             }
         }
         // Collect children
         if (this.config.checkChildren) {
-            const children = this.hierarchyManager.getChildren();
+            const children = this.node.getChildren();
             for (const child of children) {
                 targets.push({ address: child, role: 'child' });
             }
         }
-        // Ping all targets in parallel
-        await Promise.allSettled(targets.map((target) => this.pingTarget(target.address, target.role)));
+        // Check all targets in parallel
+        await Promise.allSettled(targets.map((target) => this.checkTarget(target.address, target.role)));
+        this.isRunning = false;
+    }
+    /**
+     * Check if a connection to the given address is open by examining libp2p's connection state
+     * @returns true if an open connection exists, false otherwise
+     */
+    checkConnectionStatus(address) {
+        if (address.toString() === this.node.address.toString()) {
+            return true; // Self-connection is always "open"
+        }
+        if (!address.libp2pTransports.length) {
+            return false;
+        }
+        try {
+            // Get peer ID from the address
+            const peerIdString = address.libp2pTransports[0].toPeerId();
+            // Get all connections to this peer from libp2p
+            // Note: Using 'as any' since converting to proper PeerId breaks browser implementation
+            const connections = this.node.p2pNode.getConnections(peerIdString);
+            // Check if any connection is open
+            return connections.some((conn) => conn.status === 'open');
+        }
+        catch (error) {
+            this.logger.debug(`Error checking connection status for ${address}`, error);
+            return false;
+        }
     }
-    async pingTarget(address, role) {
-        const peerId = this.extractPeerIdFromAddress(address);
-        if (!peerId) {
-            this.logger.warn(`Cannot extract peerId from ${address}`);
+    async checkTarget(address, role) {
+        if (!address.libp2pTransports.length) {
+            this.logger.debug(`${role} has no transports, skipping health check`, address);
             return;
         }
         const key = address.toString();
@@ -81,7 +112,7 @@ export class oConnectionHeartbeatManager extends oObject {
         if (!health) {
             health = {
                 address,
-                peerId,
+                peerId: 'unknown',
                 lastSuccessfulPing: 0,
                 consecutiveFailures: 0,
                 averageLatency: 0,
@@ -89,44 +120,30 @@ export class oConnectionHeartbeatManager extends oObject {
             };
             this.healthMap.set(key, health);
         }
-        try {
-            // Use libp2p's native ping service
-            const startTime = Date.now();
-            // Create timeout promise
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error('Ping timeout')), this.config.timeoutMs);
-            });
-            // Race between ping and timeout
-            // The ping service accepts PeerId as string or object
-            await Promise.race([
-                this.p2pNode.services.ping.ping(peerId),
-                timeoutPromise,
-            ]);
-            const latency = Date.now() - startTime;
-            // Success - update health
+        // Check connection status using libp2p's connection state
+        const isOpen = this.checkConnectionStatus(address);
+        if (isOpen) {
+            // Connection is open - success
             health.lastSuccessfulPing = Date.now();
             health.consecutiveFailures = 0;
-            health.averageLatency =
-                health.averageLatency === 0
-                    ? latency
-                    : health.averageLatency * 0.7 + latency * 0.3; // Exponential moving average
             const previousStatus = health.status;
             health.status = 'healthy';
             // Emit recovery event if was degraded
             if (previousStatus === 'degraded') {
-                this.logger.info(`Connection recovered: ${address} (latency: ${latency}ms)`);
+                this.logger.info(`Connection recovered: ${address}`);
                 this.emitConnectionRecoveredEvent(address, role);
             }
-            this.logger.debug(`Ping successful: ${address} (${latency}ms)`);
         }
-        catch (error) {
+        else {
+            // Connection is not open
             health.consecutiveFailures++;
-            this.logger.warn(`Ping failed: ${address} (failures: ${health.consecutiveFailures}/${this.config.failureThreshold})`);
+            this.logger.warn(`Connection check failed: ${address} (failures: ${health.consecutiveFailures}/${this.config.failureThreshold})`);
             // Update status based on failure count
             if (health.consecutiveFailures >= this.config.failureThreshold) {
                 this.handleConnectionDead(address, role, health);
             }
-            else if (health.consecutiveFailures >= Math.ceil(this.config.failureThreshold / 2)) {
+            else if (health.consecutiveFailures >=
+                Math.ceil(this.config.failureThreshold / 2)) {
                 health.status = 'degraded';
                 this.emitConnectionDegradedEvent(address, role, health.consecutiveFailures);
             }
@@ -140,20 +157,20 @@ export class oConnectionHeartbeatManager extends oObject {
         // Emit events based on role
         if (role === 'child') {
             // Remove dead child from hierarchy
-            this.hierarchyManager.removeChild(address);
+            this.node.removeChild(address);
             // Emit child left event
-            this.notificationManager.emit(new ChildLeftEvent({
-                source: this.address,
+            this.node.notificationManager.emit(new ChildLeftEvent({
+                source: this.node.address,
                 childAddress: address,
-                parentAddress: this.address,
+                parentAddress: this.node.address,
                 reason: `heartbeat_failed_${health.consecutiveFailures}_times`,
             }));
             this.logger.warn(`Removed dead child: ${address}`);
         }
         else if (role === 'parent') {
             // Emit parent disconnected event
-            this.notificationManager.emit(new ParentDisconnectedEvent({
-                source: this.address,
+            this.node.notificationManager.emit(new ParentDisconnectedEvent({
+                source: this.node.address,
                 parentAddress: address,
                 reason: `heartbeat_failed_${health.consecutiveFailures}_times`,
             }));
@@ -162,8 +179,8 @@ export class oConnectionHeartbeatManager extends oObject {
         }
         else if (role === 'leader') {
             // Emit leader disconnected event
-            this.notificationManager.emit(new LeaderDisconnectedEvent({
-                source: this.address,
+            this.node.notificationManager.emit(new LeaderDisconnectedEvent({
+                source: this.node.address,
                 leaderAddress: address,
                 reason: `heartbeat_failed_${health.consecutiveFailures}_times`,
             }));
@@ -174,8 +191,8 @@ export class oConnectionHeartbeatManager extends oObject {
     emitConnectionDegradedEvent(address, role, failures) {
         // ConnectionDegradedEvent only supports parent/child, so we map leader to parent
         const eventRole = role === 'leader' ? 'parent' : role === 'child' ? 'child' : 'parent';
-        this.notificationManager.emit(new ConnectionDegradedEvent({
-            source: this.address,
+        this.node.notificationManager.emit(new ConnectionDegradedEvent({
+            source: this.node.address,
             targetAddress: address,
             role: eventRole,
             consecutiveFailures: failures,
@@ -184,24 +201,12 @@ export class oConnectionHeartbeatManager extends oObject {
     emitConnectionRecoveredEvent(address, role) {
         // ConnectionRecoveredEvent only supports parent/child, so we map leader to parent
         const eventRole = role === 'leader' ? 'parent' : role === 'child' ? 'child' : 'parent';
-        this.notificationManager.emit(new ConnectionRecoveredEvent({
-            source: this.address,
+        this.node.notificationManager.emit(new ConnectionRecoveredEvent({
+            source: this.node.address,
             targetAddress: address,
             role: eventRole,
         }));
     }
-    extractPeerIdFromAddress(address) {
-        // Extract peerId from transport multiaddr
-        for (const transport of address.transports) {
-            const multiaddr = transport.toString();
-            // Multiaddr format: /ip4/127.0.0.1/tcp/4001/p2p/QmPeerId
-            const parts = multiaddr.split('/p2p/');
-            if (parts.length === 2) {
-                return parts[1];
-            }
-        }
-        return null;
-    }
     /**
      * Get current health status of all connections
      */

package/dist/src/managers/o-reconnection.manager.d.ts

@@ -6,6 +6,8 @@ export interface ReconnectionConfig {
     baseDelayMs: number;
     maxDelayMs: number;
     useLeaderFallback: boolean;
+    parentDiscoveryIntervalMs: number;
+    parentDiscoveryMaxDelayMs: number;
 }
 /**
  * Reconnection Manager
@@ -25,12 +27,22 @@ export declare class oReconnectionManager extends oObject {
     private reconnecting;
     constructor(node: IReconnectableNode, config: ReconnectionConfig);
     private setupEventListeners;
+    handleNodeConnected(event: any): Promise<void>;
     private handleConnectionDegraded;
     private handleLeaderDisconnected;
     private handleParentDisconnected;
     attemptReconnection(): Promise<void>;
     private tryDirectParentReconnection;
     private tryLeaderFallback;
+    /**
+     * Wait for leader to become available and reconnect
+     * Leader transports are static (configured), so we just need to detect when it's back
+     */
+    private waitForLeaderAndReconnect;
+    /**
+     * Wait for non-leader parent to appear in registry and reconnect
+     */
+    waitForParentAndReconnect(): Promise<void>;
     private handleReconnectionFailure;
     private calculateNodeLevel;
     private calculateBackoffDelay;

package/dist/src/managers/o-reconnection.manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-reconnection.manager.d.ts","sourceRoot":"","sources":["../../../src/managers/o-reconnection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAQR,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAI3E,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,oBAAqB,SAAQ,OAAO;IAI7C,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM;IAJhB,OAAO,CAAC,YAAY,CAAS;gBAGnB,IAAI,EAAE,kBAAkB,EACxB,MAAM,EAAE,kBAAkB;IAMpC,OAAO,CAAC,mBAAmB;YAoBb,wBAAwB;YAaxB,wBAAwB;YAexB,wBAAwB;IAehC,mBAAmB;YAkDX,2BAA2B;YAiB3B,iBAAiB;IAyC/B,OAAO,CAAC,yBAAyB;IAajC,OAAO,CAAC,kBAAkB;IAI1B,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,KAAK;CAGd"}
+{"version":3,"file":"o-reconnection.manager.d.ts","sourceRoot":"","sources":["../../../src/managers/o-reconnection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EASR,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAI3E,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,yBAAyB,EAAE,MAAM,CAAC;IAClC,yBAAyB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,oBAAqB,SAAQ,OAAO;IAI7C,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM;IAJhB,OAAO,CAAC,YAAY,CAAS;gBAGnB,IAAI,EAAE,kBAAkB,EACxB,MAAM,EAAE,kBAAkB;IAMpC,OAAO,CAAC,mBAAmB;IAyBrB,mBAAmB,CAAC,KAAK,EAAE,GAAG;YAatB,wBAAwB;YAaxB,wBAAwB;YAexB,wBAAwB;IAehC,mBAAmB;YAgDX,2BAA2B;YAiB3B,iBAAiB;IAkB/B;;;OAGG;YACW,yBAAyB;IAiFvC;;OAEG;IACG,yBAAyB;IAkG/B,OAAO,CAAC,yBAAyB;IAajC,OAAO,CAAC,kBAAkB;IAI1B,OAAO,CAAC,qBAAqB;IAK7B,OAAO,CAAC,KAAK;CAGd"}

package/dist/src/managers/o-reconnection.manager.js

@@ -28,6 +28,17 @@ export class oReconnectionManager extends oObject {
         this.node.notificationManager.on('leader:disconnected', this.handleLeaderDisconnected.bind(this));
         // Listen for connection degradation as early warning
         this.node.notificationManager.on('connection:degraded', this.handleConnectionDegraded.bind(this));
+        this.node.notificationManager.on('node:connected', this.handleNodeConnected.bind(this));
+    }
+    async handleNodeConnected(event) {
+        const connectedEvent = event;
+        if (connectedEvent.nodeAddress.toString() === oAddress.leader().toString()) {
+            // the leader is back online, let's re-register & tell sub-graphs to re-register
+            await this.node.useSelf({
+                method: 'register_leader',
+                params: {},
+            });
+        }
     }
     async handleConnectionDegraded(event) {
         const degradedEvent = event;
@@ -104,31 +115,136 @@ export class oReconnectionManager extends oObject {
         this.logger.info('Direct parent reconnection successful');
     }
     async tryLeaderFallback() {
-        this.logger.info('Attempting leader fallback to find new parent');
-        try {
-            // Query registry for available parents at our level
-            const response = await this.node.use(new oAddress('o://registry'), {
-                method: 'find_available_parent',
-                params: {
-                    currentAddress: this.node.address.toString(),
-                    preferredLevel: this.calculateNodeLevel(),
-                },
-            });
-            const { parentAddress, parentTransports } = response.result.data;
-            if (parentAddress && parentTransports) {
-                // Update parent reference
-                this.node.config.parent = new oNodeAddress(parentAddress, parentTransports.map((t) => new oNodeTransport(t)));
-                // Register with new parent
-                await this.tryDirectParentReconnection();
-                this.reconnecting = false;
-                this.logger.info(`Successfully reconnected via new parent: ${parentAddress}`);
-                return;
+        // Check if parent is the leader - special case
+        const parentIsLeader = this.node.config.parent?.toString() === oAddress.leader().toString();
+        if (parentIsLeader) {
+            this.logger.info('Parent is the leader - waiting for leader to become available');
+            await this.waitForLeaderAndReconnect();
+        }
+        else {
+            this.logger.info('Starting infinite parent discovery via leader registry');
+            await this.waitForParentAndReconnect();
+        }
+    }
+    /**
+     * Wait for leader to become available and reconnect
+     * Leader transports are static (configured), so we just need to detect when it's back
+     */
+    async waitForLeaderAndReconnect() {
+        const startTime = Date.now();
+        let attempt = 0;
+        let currentDelay = this.config.parentDiscoveryIntervalMs;
+        // Infinite retry loop - keep trying until leader is back
+        while (true) {
+            attempt++;
+            const elapsedMinutes = Math.floor((Date.now() - startTime) / 60000);
+            this.logger.info(`Leader discovery attempt ${attempt} (elapsed: ${elapsedMinutes}m)`);
+            try {
+                // Try to ping the leader using its configured transports
+                // The leader address should already have transports configured
+                await this.node.use(this.node.config.parent, {
+                    method: 'ping',
+                    params: {},
+                });
+                // Leader is back! Now re-register with parent and registry
+                this.logger.info(`Leader is back online after ${elapsedMinutes}m, re-registering...`);
+                try {
+                    // Register with parent (leader)
+                    await this.node.registerParent();
+                    // Force re-registration with registry by resetting the flag
+                    this.node.didRegister = false;
+                    await this.node.register();
+                    // Success!
+                    this.reconnecting = false;
+                    this.logger.info(`Successfully reconnected to leader and re-registered after ${elapsedMinutes}m`);
+                    return;
+                }
+                catch (registrationError) {
+                    this.logger.warn('Leader online but registration failed, will retry:', registrationError instanceof Error
+                        ? registrationError.message
+                        : registrationError);
+                    // Fall through to retry with backoff
+                }
+            }
+            catch (error) {
+                // Leader not yet available
+                this.logger.debug(`Leader not yet available (will retry): ${error instanceof Error ? error.message : error}`);
+            }
+            // Calculate backoff delay
+            const delay = Math.min(currentDelay, this.config.parentDiscoveryMaxDelayMs);
+            // Log periodic status updates (every 5 minutes)
+            if (attempt % 30 === 0) {
+                this.logger.info(`Still waiting for leader to come back online... (${elapsedMinutes}m elapsed, ${attempt} attempts)`);
             }
+            this.logger.debug(`Waiting ${delay}ms before next discovery attempt...`);
+            await this.sleep(delay);
+            // Exponential backoff for next iteration
+            currentDelay = Math.min(currentDelay * 2, this.config.parentDiscoveryMaxDelayMs);
         }
-        catch (error) {
-            this.logger.error('Leader fallback failed:', error instanceof Error ? error.message : error);
+    }
+    /**
+     * Wait for non-leader parent to appear in registry and reconnect
+     */
+    async waitForParentAndReconnect() {
+        const startTime = Date.now();
+        let attempt = 0;
+        let currentDelay = this.config.parentDiscoveryIntervalMs;
+        // Infinite retry loop - keep trying until parent is found
+        while (true) {
+            attempt++;
+            const elapsedMinutes = Math.floor((Date.now() - startTime) / 60000);
+            this.logger.info(`Parent discovery attempt ${attempt} (elapsed: ${elapsedMinutes}m)`);
+            try {
+                // Query registry for parent by its known address
+                const response = await this.node.use(oAddress.registry(), {
+                    method: 'find_available_parent',
+                    params: {
+                        parentAddress: this.node.config.parent?.toString(),
+                    },
+                });
+                const { parentAddress, parentTransports } = response.result.data;
+                // Check if parent was found in registry
+                if (parentAddress && parentTransports && parentTransports.length > 0) {
+                    this.logger.info(`Parent found in registry: ${parentAddress} with ${parentTransports.length} transports`);
+                    // Update parent reference with fresh transports
+                    this.node.config.parent = new oNodeAddress(parentAddress, parentTransports.map((t) => new oNodeTransport(t.value)));
+                    // Attempt to register with parent and re-register with registry
+                    try {
+                        await this.tryDirectParentReconnection();
+                        // Force re-registration with registry by resetting the flag
+                        this.node.didRegister = false;
+                        await this.node.register();
+                        // Success!
+                        this.reconnecting = false;
+                        this.logger.info(`Successfully reconnected to parent and re-registered after ${elapsedMinutes}m of discovery attempts`);
+                        return;
+                    }
+                    catch (registrationError) {
+                        this.logger.warn('Parent found but registration failed, will retry:', registrationError instanceof Error
+                            ? registrationError.message
+                            : registrationError);
+                        // Fall through to retry with backoff
+                    }
+                }
+                else {
+                    this.logger.debug(`Parent not yet available in registry: ${this.node.config.parent?.toString()}`);
+                }
+            }
+            catch (error) {
+                // Network error communicating with leader/registry
+                this.logger.warn('Error querying registry for parent (will retry):', error instanceof Error ? error.message : error);
+            }
+            // Calculate backoff delay with exponential increase, capped at max
+            const delay = Math.min(currentDelay, this.config.parentDiscoveryMaxDelayMs);
+            // Log periodic status updates (every 5 minutes)
+            if (attempt % 30 === 0) {
+                this.logger.info(`Still waiting for parent to appear in registry... (${elapsedMinutes}m elapsed, ${attempt} attempts)`);
+            }
+            this.logger.debug(`Waiting ${delay}ms before next discovery attempt...`);
+            await this.sleep(delay);
+            // Exponential backoff for next iteration
+            currentDelay = Math.min(currentDelay * 2, this.config.parentDiscoveryMaxDelayMs);
         }
-        this.handleReconnectionFailure();
     }
     handleReconnectionFailure() {
         this.reconnecting = false;

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

@@ -3,14 +3,14 @@ import { PeerId } from '@olane/o-config';
 import { oNodeHierarchyManager } from './o-node.hierarchy-manager.js';
 import { oNodeConfig } from './interfaces/o-node.config.js';
 import { oNodeTransport } from './router/o-node.transport.js';
-import { oAddress, oRequest, oNotificationManager } from '@olane/o-core';
+import { oRequest, oNotificationManager } from '@olane/o-core';
 import { oNodeAddress } from './router/o-node.address.js';
 import { oNodeConnection } from './connection/o-node-connection.js';
 import { oNodeConnectionManager } from './connection/o-node-connection.manager.js';
 import { oToolBase } from '@olane/o-tool';
 import { oConnectionHeartbeatManager } from './managers/o-connection-heartbeat.manager.js';
+import { oNodeConnectionConfig } from './connection/index.js';
 import { oReconnectionManager } from './managers/o-reconnection.manager.js';
-import { LeaderRequestWrapper } from './utils/leader-request-wrapper.js';
 export declare class oNode extends oToolBase {
     peerId: PeerId;
     p2pNode: Libp2p;
@@ -19,8 +19,7 @@ export declare class oNode extends oToolBase {
     connectionManager: oNodeConnectionManager;
     hierarchyManager: oNodeHierarchyManager;
     connectionHeartbeatManager?: oConnectionHeartbeatManager;
-    reconnectionManager?: oReconnectionManager;
-    leaderRequestWrapper: LeaderRequestWrapper;
+    protected reconnectionManager?: oReconnectionManager;
     protected didRegister: boolean;
     constructor(config: oNodeConfig);
     get leader(): oNodeAddress | null;
@@ -33,7 +32,9 @@ export declare class oNode extends oToolBase {
     get parentTransports(): oNodeTransport[];
     get transports(): oNodeTransport[];
     unregister(): Promise<void>;
+    setKeepAliveTag(address: oNodeAddress): Promise<void>;
     registerParent(): Promise<void>;
+    registerLeader(): Promise<void>;
     register(): Promise<void>;
     extractMethod(address: oNodeAddress): string;
     start(): Promise<void>;
@@ -44,18 +45,28 @@ export declare class oNode extends oToolBase {
      */
     configure(): Promise<Libp2pConfig>;
     protected createNode(): Promise<Libp2p>;
-    connect(nextHopAddress: oNodeAddress, targetAddress: oNodeAddress): Promise<oNodeConnection>;
+    connect(config: oNodeConnectionConfig): Promise<oNodeConnection>;
+    initConnectionManager(): Promise<void>;
+    hookInitializeFinished(): Promise<void>;
+    hookStartFinished(): Promise<void>;
     initialize(): Promise<void>;
     /**
      * Override use() to wrap leader/registry requests with retry logic
      */
-    use(address: oAddress, data?: {
-        method?: string;
-        params?: {
-            [key: string]: any;
-        };
-        id?: string;
-    }): Promise<any>;
     teardown(): Promise<void>;
+    getLeaders(): oNodeAddress[];
+    getParents(): oNodeAddress[];
+    getChildren(): oNodeAddress[];
+    removeChild(childAddress: oNodeAddress): void;
+    /**
+     * Get the total number of active streams across all connections
+     * @returns Total count of active streams
+     */
+    getStreamCount(): number;
+    /**
+     * Get libp2p metrics for this node
+     * Tool method that can be called remotely by monitoring systems
+     */
+    _tool_get_libp2p_metrics(request: oRequest): Promise<any>;
 }
 //# sourceMappingURL=o-node.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.d.ts","sourceRoot":"","sources":["../../src/o-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EACN,YAAY,EACb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAIL,QAAQ,EACR,QAAQ,EAER,oBAAoB,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAGnF,OAAO,EAAmB,SAAS,EAAE,MAAM,eAAe,CAAC;AAI3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAC3F,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAEzE,qBAAa,KAAM,SAAQ,SAAS;IAC3B,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAG,MAAM,CAAC;IACjB,OAAO,EAAG,YAAY,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,iBAAiB,EAAG,sBAAsB,CAAC;IAC3C,gBAAgB,EAAG,qBAAqB,CAAC;IACzC,0BAA0B,CAAC,EAAE,2BAA2B,CAAC;IACzD,mBAAmB,CAAC,EAAE,oBAAoB,CAAC;IAC3C,oBAAoB,EAAG,oBAAoB,CAAC;IACnD,SAAS,CAAC,WAAW,EAAE,OAAO,CAAS;gBAE3B,MAAM,EAAE,WAAW;IAK/B,IAAI,MAAM,IAAI,YAAY,GAAG,IAAI,CAEhC;IAED,IAAI,aAAa,IAAI,YAAY,CAKhC;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,IAAI,CAOhC;IAED,mBAAmB,IAAI,GAAG,EAAE;IAItB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IASvC,SAAS,CAAC,yBAAyB,IAAI,oBAAoB;IAQ3D,IAAI,aAAa,IAAI,YAAY,CAEhC;IAED,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,IAAI,UAAU,IAAI,cAAc,EAAE,CAIjC;IAEK,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAsD3B,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B/B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAwC/B,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;IAItC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAetB,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAG1D;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;cA0FxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAMvC,OAAO,CACX,cAAc,EAAE,YAAY,EAC5B,aAAa,EAAE,YAAY,GAC1B,OAAO,CAAC,eAAe,CAAC;IA0BrB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA2FjC;;OAEG;IACG,GAAG,CACP,OAAO,EAAE,QAAQ,EACjB,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE,CAAC;QAChC,EAAE,CAAC,EAAE,MAAM,CAAC;KACb,GACA,OAAO,CAAC,GAAG,CAAC;IAST,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAYhC"}
+{"version":3,"file":"o-node.d.ts","sourceRoot":"","sources":["../../src/o-node.ts"],"names":[],"mappings":"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"}