@olane/o-node 0.7.12-alpha.4 → 0.7.12-alpha.6

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

@@ -1 +1 @@
-{"version":3,"file":"o-node-connection.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAIV,MAAM,EAEP,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,WAAW,EAGX,QAAQ,EACR,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,qBAAa,eAAgB,SAAQ,WAAW;IAGlC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,qBAAqB;IAFrD,aAAa,EAAE,UAAU,CAAC;gBAEF,MAAM,EAAE,qBAAqB;IAKtD,IAAI,CAAC,MAAM,EAAE,MAAM;IAWzB,QAAQ;IAOF,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;IAyC/C,KAAK;CAKZ"}
+{"version":3,"file":"o-node-connection.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAIV,MAAM,EAEP,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,WAAW,EAGX,QAAQ,EACR,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,qBAAa,eAAgB,SAAQ,WAAW;IAGlC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,qBAAqB;IAFrD,aAAa,EAAE,UAAU,CAAC;gBAEF,MAAM,EAAE,qBAAqB;IAKtD,IAAI,CAAC,MAAM,EAAE,MAAM;IAWzB,QAAQ;IAOF,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;IAiD/C,KAAK;CAKZ"}

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

@@ -33,8 +33,14 @@ export class oNodeConnection extends oConnection {
             if (stream.status === 'reset') {
                 throw new oError(oErrorCodes.CONNECTION_LIMIT_REACHED, 'Connection limit reached');
             }
-            // Send the data
-            await stream.send(new TextEncoder().encode(request.toString()));
+            // Send the data with backpressure handling (libp2p v3 best practice)
+            const data = new TextEncoder().encode(request.toString());
+            const sent = stream.send(data);
+            // If send() returns false, wait for the stream to drain before continuing
+            if (!sent) {
+                this.logger.debug('Stream buffer full, waiting for drain...');
+                await stream.onDrain({ signal: AbortSignal.timeout(30000) }); // 30 second timeout
+            }
             const res = await this.read(stream);
             await stream.close();
             // process the response

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

@@ -6,7 +6,7 @@ export declare class oNodeConnectionManager extends oConnectionManager {
     private p2pNode;
     constructor(config: oNodeConnectionManagerConfig);
     /**
-     * Connect to a given address
+     * Connect to a given address with exponential backoff retry
      * @param address - The address to connect to
      * @returns The connection object
      */

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;gBAEZ,MAAM,EAAE,4BAA4B;IAKhD;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IAkDlE,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,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;gBAEZ,MAAM,EAAE,4BAA4B;IAKhD;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IAqFlE,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IAIpC,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,WAAW,GAAG,IAAI;CAe3D"}

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

@@ -6,7 +6,7 @@ export class oNodeConnectionManager extends oConnectionManager {
         this.p2pNode = config.p2pNode;
     }
     /**
-     * Connect to a given address
+     * Connect to a given address with exponential backoff retry
      * @param address - The address to connect to
      * @returns The connection object
      */
@@ -26,25 +26,45 @@ export class oNodeConnectionManager extends oConnectionManager {
                 this.cache.delete(nextHopAddress.toString());
             }
         }
-        // first time setup connection
-        try {
-            const p2pConnection = await this.p2pNode.dial(nextHopAddress.libp2pTransports.map((ma) => ma.toMultiaddr()));
-            const connection = new oNodeConnection({
-                nextHopAddress: nextHopAddress,
-                address: address,
-                p2pConnection: p2pConnection,
-                callerAddress: callerAddress,
-            });
-            // this.cache.set(nextHopAddress.toString(), connection);
-            return connection;
-        }
-        catch (error) {
-            this.logger.error(`[${callerAddress?.toString() || 'unknown'}] Error connecting to address! Next hop:` +
-                nextHopAddress +
-                ' With Address:' +
-                address.toString(), error);
-            throw error;
+        // Retry configuration for handling transient connection failures
+        const MAX_RETRIES = 3;
+        const BASE_DELAY_MS = 1000; // Start with 1 second
+        const MAX_DELAY_MS = 10000; // Cap at 10 seconds
+        // first time setup connection with retry logic
+        let lastError;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                if (attempt > 0) {
+                    // Calculate exponential backoff delay: 1s, 2s, 4s, 8s (capped at MAX_DELAY_MS)
+                    const delay = Math.min(BASE_DELAY_MS * Math.pow(2, attempt - 1), MAX_DELAY_MS);
+                    this.logger.debug(`Retry attempt ${attempt}/${MAX_RETRIES} for ${nextHopAddress.toString()} after ${delay}ms delay`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+                const p2pConnection = await this.p2pNode.dial(nextHopAddress.libp2pTransports.map((ma) => ma.toMultiaddr()));
+                const connection = new oNodeConnection({
+                    nextHopAddress: nextHopAddress,
+                    address: address,
+                    p2pConnection: p2pConnection,
+                    callerAddress: callerAddress,
+                });
+                if (attempt > 0) {
+                    this.logger.info(`Successfully connected to ${nextHopAddress.toString()} on retry attempt ${attempt}`);
+                }
+                // this.cache.set(nextHopAddress.toString(), connection);
+                return connection;
+            }
+            catch (error) {
+                lastError = error;
+                this.logger.warn(`[${callerAddress?.toString() || 'unknown'}] Connection attempt ${attempt + 1}/${MAX_RETRIES + 1} failed for ${nextHopAddress.toString()}: ${error instanceof Error ? error.message : String(error)}`);
+                // Don't retry on the last attempt
+                if (attempt === MAX_RETRIES) {
+                    break;
+                }
+            }
         }
+        // All retries exhausted
+        this.logger.error(`[${callerAddress?.toString() || 'unknown'}] Failed to connect after ${MAX_RETRIES + 1} attempts to address! Next hop: ${nextHopAddress} With Address: ${address.toString()}`, lastError);
+        throw lastError;
     }
     isCached(address) {
         return this.cache.has(address.toString());

package/dist/src/interfaces/i-reconnectable-node.d.ts

@@ -0,0 +1,41 @@
+import { oAddress, NodeState, oNotificationManager } from '@olane/o-core';
+import { oNodeAddress } from '../router/o-node.address.js';
+import { oNodeConfig } from './o-node.config.js';
+/**
+ * Interface for nodes that support reconnection management.
+ * This interface defines the contract that oReconnectionManager needs
+ * to perform reconnection operations without creating a circular dependency.
+ */
+export interface IReconnectableNode {
+    /**
+     * The node's configuration
+     */
+    config: oNodeConfig;
+    /**
+     * The node's current address
+     */
+    address: oNodeAddress;
+    /**
+     * The node's current state
+     */
+    state: NodeState;
+    /**
+     * The notification manager for subscribing to events
+     */
+    notificationManager: oNotificationManager;
+    /**
+     * Register with the parent node
+     */
+    registerParent(): Promise<void>;
+    /**
+     * Execute a method on another node
+     */
+    use(address: oAddress, data?: {
+        method?: string;
+        params?: {
+            [key: string]: any;
+        };
+        id?: string;
+    }): Promise<any>;
+}
+//# sourceMappingURL=i-reconnectable-node.d.ts.map

package/dist/src/interfaces/i-reconnectable-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i-reconnectable-node.d.ts","sourceRoot":"","sources":["../../../src/interfaces/i-reconnectable-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,MAAM,EAAE,WAAW,CAAC;IAEpB;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IAEtB;;OAEG;IACH,KAAK,EAAE,SAAS,CAAC;IAEjB;;OAEG;IACH,mBAAmB,EAAE,oBAAoB,CAAC;IAE1C;;OAEG;IACH,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC;;OAEG;IACH,GAAG,CACD,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,CAAC;CACjB"}

package/dist/src/interfaces/i-reconnectable-node.js

@@ -0,0 +1 @@
+export {};

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

@@ -3,5 +3,40 @@ import { oNodeAddress } from '../router/o-node.address.js';
 export interface oNodeConfig extends oCoreConfig {
     leader: oNodeAddress | null;
     parent: oNodeAddress | null;
+    /**
+     * Connection heartbeat configuration (libp2p-native pings)
+     * Detects dead connections via periodic pings using libp2p's ping service
+     */
+    connectionHeartbeat?: {
+        enabled?: boolean;
+        intervalMs?: number;
+        timeoutMs?: number;
+        failureThreshold?: number;
+        checkChildren?: boolean;
+        checkParent?: boolean;
+        checkLeader?: boolean;
+    };
+    /**
+     * Automatic reconnection configuration
+     * Handles parent connection failures and attempts to reconnect
+     */
+    reconnection?: {
+        enabled?: boolean;
+        maxAttempts?: number;
+        baseDelayMs?: number;
+        maxDelayMs?: number;
+        useLeaderFallback?: boolean;
+    };
+    /**
+     * Leader request retry configuration
+     * Handles temporary leader unavailability (healing, maintenance)
+     */
+    leaderRetry?: {
+        enabled?: boolean;
+        maxAttempts?: number;
+        baseDelayMs?: number;
+        maxDelayMs?: number;
+        timeoutMs?: number;
+    };
 }
 //# sourceMappingURL=o-node.config.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.config.d.ts","sourceRoot":"","sources":["../../../src/interfaces/o-node.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;CAC7B"}
+{"version":3,"file":"o-node.config.d.ts","sourceRoot":"","sources":["../../../src/interfaces/o-node.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAE5B;;;OAGG;IACH,mBAAmB,CAAC,EAAE;QACpB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC;IAEF;;;OAGG;IACH,YAAY,CAAC,EAAE;QACb,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;KAC7B,CAAC;IAEF;;;OAGG;IACH,WAAW,CAAC,EAAE;QACZ,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH"}

package/dist/src/managers/o-connection-heartbeat.manager.d.ts

@@ -0,0 +1,67 @@
+import { Libp2p } from '@olane/o-config';
+import { oObject } from '@olane/o-core';
+import { oNodeAddress } from '../router/o-node.address.js';
+import { oNodeHierarchyManager } from '../o-node.hierarchy-manager.js';
+import { oNotificationManager } from '@olane/o-core';
+export interface HeartbeatConfig {
+    enabled: boolean;
+    intervalMs: number;
+    timeoutMs: number;
+    failureThreshold: number;
+    checkChildren: boolean;
+    checkParent: boolean;
+    checkLeader: boolean;
+}
+export interface ConnectionHealth {
+    address: oNodeAddress;
+    peerId: string;
+    lastSuccessfulPing: number;
+    consecutiveFailures: number;
+    averageLatency: number;
+    status: 'healthy' | 'degraded' | 'dead';
+}
+/**
+ * Connection Heartbeat Manager
+ *
+ * Uses libp2p's native ping service to detect dead connections early.
+ * Continuously pings parent and children to ensure they're alive.
+ *
+ * How it works:
+ * - Every `intervalMs`, pings all tracked connections
+ * - If ping fails, 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 declare class oConnectionHeartbeatManager extends oObject {
+    private p2pNode;
+    private hierarchyManager;
+    private notificationManager;
+    private address;
+    private config;
+    private heartbeatInterval?;
+    private healthMap;
+    constructor(p2pNode: Libp2p, hierarchyManager: oNodeHierarchyManager, notificationManager: oNotificationManager, address: oNodeAddress, config: HeartbeatConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private performHeartbeatCycle;
+    private pingTarget;
+    private handleConnectionDead;
+    private emitConnectionDegradedEvent;
+    private emitConnectionRecoveredEvent;
+    private extractPeerIdFromAddress;
+    /**
+     * Get current health status of all connections
+     */
+    getHealthStatus(): ConnectionHealth[];
+    /**
+     * Get health status for specific address
+     */
+    getConnectionHealth(address: oNodeAddress): ConnectionHealth | undefined;
+    /**
+     * Get current configuration
+     */
+    getConfig(): HeartbeatConfig;
+}
+//# sourceMappingURL=o-connection-heartbeat.manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-connection-heartbeat.manager.d.ts","sourceRoot":"","sources":["../../../src/managers/o-connection-heartbeat.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EACL,OAAO,EAMR,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAErD,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;IAC3B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;CACzC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,2BAA4B,SAAQ,OAAO;IAKpD,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,MAAM;IARhB,OAAO,CAAC,iBAAiB,CAAC,CAAiB;IAC3C,OAAO,CAAC,SAAS,CAAuC;gBAG9C,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,qBAAqB,EACvC,mBAAmB,EAAE,oBAAoB,EACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe;IAK3B,KAAK;IAqBL,IAAI;YAQI,qBAAqB;YAuCrB,UAAU;IAyFxB,OAAO,CAAC,oBAAoB;IAyD5B,OAAO,CAAC,2BAA2B;IAmBnC,OAAO,CAAC,4BAA4B;IAiBpC,OAAO,CAAC,wBAAwB;IAahC;;OAEG;IACH,eAAe,IAAI,gBAAgB,EAAE;IAIrC;;OAEG;IACH,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,gBAAgB,GAAG,SAAS;IAIxE;;OAEG;IACH,SAAS,IAAI,eAAe;CAG7B"}

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

@@ -0,0 +1,223 @@
+import { oObject, ChildLeftEvent, ParentDisconnectedEvent, LeaderDisconnectedEvent, ConnectionDegradedEvent, ConnectionRecoveredEvent, } from '@olane/o-core';
+/**
+ * Connection Heartbeat Manager
+ *
+ * Uses libp2p's native ping service to detect dead connections early.
+ * Continuously pings parent and children to ensure they're alive.
+ *
+ * How it works:
+ * - Every `intervalMs`, pings all tracked connections
+ * - If ping fails, 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) {
+        super();
+        this.p2pNode = p2pNode;
+        this.hierarchyManager = hierarchyManager;
+        this.notificationManager = notificationManager;
+        this.address = address;
+        this.config = config;
+        this.healthMap = new Map();
+    }
+    async start() {
+        if (!this.config.enabled) {
+            this.logger.debug('Connection heartbeat disabled');
+            return;
+        }
+        this.logger.info(`Starting connection heartbeat: interval=${this.config.intervalMs}ms, ` +
+            `timeout=${this.config.timeoutMs}ms, threshold=${this.config.failureThreshold}`);
+        // Immediate first check
+        await this.performHeartbeatCycle();
+        // Schedule recurring checks
+        this.heartbeatInterval = setInterval(() => this.performHeartbeatCycle(), this.config.intervalMs);
+    }
+    async stop() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = undefined;
+        }
+        this.healthMap.clear();
+    }
+    async performHeartbeatCycle() {
+        const targets = [];
+        // Check if this is a leader node (no leader in hierarchy = we are leader)
+        const isLeaderNode = this.hierarchyManager.getLeaders().length === 0;
+        // Collect leader (if enabled and we're not the leader)
+        if (this.config.checkLeader && !isLeaderNode) {
+            const leaders = this.hierarchyManager.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) {
+                targets.push({ address: parent, role: 'parent' });
+            }
+        }
+        // Collect children
+        if (this.config.checkChildren) {
+            const children = this.hierarchyManager.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)));
+    }
+    async pingTarget(address, role) {
+        const peerId = this.extractPeerIdFromAddress(address);
+        if (!peerId) {
+            this.logger.warn(`Cannot extract peerId from ${address}`);
+            return;
+        }
+        const key = address.toString();
+        let health = this.healthMap.get(key);
+        if (!health) {
+            health = {
+                address,
+                peerId,
+                lastSuccessfulPing: 0,
+                consecutiveFailures: 0,
+                averageLatency: 0,
+                status: 'healthy',
+            };
+            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
+            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.emitConnectionRecoveredEvent(address, role);
+            }
+            this.logger.debug(`Ping successful: ${address} (${latency}ms)`);
+        }
+        catch (error) {
+            health.consecutiveFailures++;
+            this.logger.warn(`Ping 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)) {
+                health.status = 'degraded';
+                this.emitConnectionDegradedEvent(address, role, health.consecutiveFailures);
+            }
+        }
+    }
+    handleConnectionDead(address, role, health) {
+        health.status = 'dead';
+        this.logger.error(`Connection dead after ${health.consecutiveFailures} failures: ${address} (role: ${role})`);
+        // Remove from health tracking
+        this.healthMap.delete(address.toString());
+        // Emit events based on role
+        if (role === 'child') {
+            // Remove dead child from hierarchy
+            this.hierarchyManager.removeChild(address);
+            // Emit child left event
+            this.notificationManager.emit(new ChildLeftEvent({
+                source: this.address,
+                childAddress: address,
+                parentAddress: this.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,
+                parentAddress: address,
+                reason: `heartbeat_failed_${health.consecutiveFailures}_times`,
+            }));
+            this.logger.error(`Parent connection dead: ${address}`);
+            // Reconnection manager will handle this event
+        }
+        else if (role === 'leader') {
+            // Emit leader disconnected event
+            this.notificationManager.emit(new LeaderDisconnectedEvent({
+                source: this.address,
+                leaderAddress: address,
+                reason: `heartbeat_failed_${health.consecutiveFailures}_times`,
+            }));
+            this.logger.error(`Leader connection dead: ${address}`);
+            // Reconnection manager will handle this event
+        }
+    }
+    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,
+            targetAddress: address,
+            role: eventRole,
+            consecutiveFailures: failures,
+        }));
+    }
+    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,
+            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
+     */
+    getHealthStatus() {
+        return Array.from(this.healthMap.values());
+    }
+    /**
+     * Get health status for specific address
+     */
+    getConnectionHealth(address) {
+        return this.healthMap.get(address.toString());
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}

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

@@ -0,0 +1,39 @@
+import { oObject } from '@olane/o-core';
+import { IReconnectableNode } from '../interfaces/i-reconnectable-node.js';
+export interface ReconnectionConfig {
+    enabled: boolean;
+    maxAttempts: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    useLeaderFallback: boolean;
+}
+/**
+ * Reconnection Manager
+ *
+ * Automatically attempts to reconnect to parent when connection is lost.
+ *
+ * Strategy:
+ * 1. Listen for ParentDisconnectedEvent (from heartbeat or libp2p)
+ * 2. Attempt direct reconnection with exponential backoff
+ * 3. If direct reconnection fails, query leader for new parent
+ * 4. Register with new parent and continue operation
+ * 5. If all attempts fail, transition node to ERROR state
+ */
+export declare class oReconnectionManager extends oObject {
+    private node;
+    private config;
+    private reconnecting;
+    constructor(node: IReconnectableNode, config: ReconnectionConfig);
+    private setupEventListeners;
+    private handleConnectionDegraded;
+    private handleLeaderDisconnected;
+    private handleParentDisconnected;
+    attemptReconnection(): Promise<void>;
+    private tryDirectParentReconnection;
+    private tryLeaderFallback;
+    private handleReconnectionFailure;
+    private calculateNodeLevel;
+    private calculateBackoffDelay;
+    private sleep;
+}
+//# sourceMappingURL=o-reconnection.manager.d.ts.map

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

@@ -0,0 +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"}