@olane/o-node 0.7.12-alpha.5 → 0.7.12-alpha.51

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

@@ -0,0 +1,63 @@
+import { oObject } from '@olane/o-core';
+import { oNodeAddress } from '../router/o-node.address.js';
+import { IHeartbeatableNode } from '../interfaces/i-heartbeatable-node.js';
+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 node;
+    private config;
+    private heartbeatInterval?;
+    private healthMap;
+    private isRunning;
+    constructor(node: IHeartbeatableNode, config: HeartbeatConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private performHeartbeatCycle;
+    private doPing;
+    private pingTarget;
+    private handleConnectionDead;
+    private emitConnectionDegradedEvent;
+    private emitConnectionRecoveredEvent;
+    /**
+     * 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,EACL,OAAO,EAOR,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAE3E,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;IAMpD,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM;IANhB,OAAO,CAAC,iBAAiB,CAAC,CAAiB;IAC3C,OAAO,CAAC,SAAS,CAAuC;IACxD,OAAO,CAAC,SAAS,CAAS;gBAGhB,IAAI,EAAE,kBAAkB,EACxB,MAAM,EAAE,eAAe;IAK3B,KAAK;IAqBL,IAAI;YAQI,qBAAqB;IAgDnC,OAAO,CAAC,MAAM;YAcA,UAAU;IAuFxB,OAAO,CAAC,oBAAoB;IAyD5B,OAAO,CAAC,2BAA2B;IAmBnC,OAAO,CAAC,4BAA4B;IAiBpC;;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,227 @@
+import { oObject, ChildLeftEvent, ParentDisconnectedEvent, LeaderDisconnectedEvent, ConnectionDegradedEvent, ConnectionRecoveredEvent, oAddress, } 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(node, config) {
+        super();
+        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');
+            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() {
+        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.node.getLeaders().length === 0;
+        // Collect leader (if enabled and we're not the leader)
+        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) {
+            // 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 ping the leader
+            if (parent && parent?.toString() !== oAddress.leader().toString()) {
+                targets.push({ address: parent, role: 'parent' });
+            }
+        }
+        // Collect children
+        if (this.config.checkChildren) {
+            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)));
+        this.isRunning = false;
+    }
+    doPing(address) {
+        if (address.toString() === this.node.address.toString()) {
+            return Promise.resolve();
+        }
+        const transport = address.libp2pTransports[0].toMultiaddr();
+        if (transport.toString().indexOf('p2p-circuit') > -1) {
+            return this.node.use(address, {
+                method: 'ping',
+                params: {},
+            });
+        }
+        return this.node.p2pNode.services.ping.ping(transport);
+    }
+    async pingTarget(address, role) {
+        if (!address.libp2pTransports.length) {
+            this.logger.debug(`${role} has no transports, skipping ping`, address);
+            return;
+        }
+        const key = address.toString();
+        let health = this.healthMap.get(key);
+        if (!health) {
+            health = {
+                address,
+                peerId: 'unknown',
+                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.doPing(address), 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})`, error);
+            // 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.node.removeChild(address);
+            // Emit child left event
+            this.node.notificationManager.emit(new ChildLeftEvent({
+                source: this.node.address,
+                childAddress: 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.node.notificationManager.emit(new ParentDisconnectedEvent({
+                source: this.node.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.node.notificationManager.emit(new LeaderDisconnectedEvent({
+                source: this.node.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.node.notificationManager.emit(new ConnectionDegradedEvent({
+            source: this.node.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.node.notificationManager.emit(new ConnectionRecoveredEvent({
+            source: this.node.address,
+            targetAddress: address,
+            role: eventRole,
+        }));
+    }
+    /**
+     * 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,51 @@
+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;
+    parentDiscoveryIntervalMs: number;
+    parentDiscoveryMaxDelayMs: number;
+}
+/**
+ * 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;
+    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;
+    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,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

@@ -0,0 +1,266 @@
+import { oObject, oAddress, NodeState, } from '@olane/o-core';
+import { oNodeAddress } from '../router/o-node.address.js';
+import { oNodeTransport } from '../router/o-node.transport.js';
+/**
+ * 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 class oReconnectionManager extends oObject {
+    constructor(node, config) {
+        super();
+        this.node = node;
+        this.config = config;
+        this.reconnecting = false;
+        this.setupEventListeners();
+    }
+    setupEventListeners() {
+        // Listen for parent disconnection (from heartbeat or libp2p)
+        this.node.notificationManager.on('parent:disconnected', this.handleParentDisconnected.bind(this));
+        // Listen for leader disconnection (from heartbeat)
+        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;
+        if (degradedEvent.role !== 'parent')
+            return;
+        this.logger.warn(`Parent connection degraded: ${degradedEvent.targetAddress} ` +
+            `(failures: ${degradedEvent.consecutiveFailures})`);
+        // Could implement pre-emptive parent discovery here
+        // For now, just log the warning and wait for full disconnection
+    }
+    async handleLeaderDisconnected(event) {
+        const disconnectEvent = event;
+        this.logger.warn(`Leader disconnected: ${disconnectEvent.leaderAddress} (reason: ${disconnectEvent.reason})`);
+        // Don't attempt reconnection for leader - the LeaderRequestWrapper
+        // will handle retries automatically when we make requests
+        // Just log the event for observability
+        this.logger.info('Leader requests will use automatic retry mechanism (LeaderRequestWrapper)');
+    }
+    async handleParentDisconnected(event) {
+        const disconnectEvent = event;
+        if (this.reconnecting) {
+            this.logger.debug('Already reconnecting, ignoring duplicate event');
+            return;
+        }
+        this.logger.warn(`Parent disconnected: ${disconnectEvent.parentAddress} (reason: ${disconnectEvent.reason})`);
+        await this.attemptReconnection();
+    }
+    async attemptReconnection() {
+        if (!this.config.enabled) {
+            this.logger.warn('Reconnection disabled - node will remain disconnected');
+            return;
+        }
+        this.reconnecting = true;
+        let attempt = 0;
+        while (attempt < this.config.maxAttempts) {
+            attempt++;
+            this.logger.info(`Reconnection attempt ${attempt}/${this.config.maxAttempts} to parent: ${this.node.config.parent}`);
+            try {
+                // Strategy 1: Try direct parent reconnection
+                await this.tryDirectParentReconnection();
+                // Success!
+                this.reconnecting = false;
+                this.logger.info(`Successfully reconnected to parent after ${attempt} attempts`);
+                return;
+            }
+            catch (error) {
+                this.logger.warn(`Reconnection attempt ${attempt} failed:`, error instanceof Error ? error.message : error);
+                if (attempt < this.config.maxAttempts) {
+                    const delay = this.calculateBackoffDelay(attempt);
+                    this.logger.debug(`Waiting ${delay}ms before next attempt...`);
+                    await this.sleep(delay);
+                }
+            }
+        }
+        // All direct attempts failed - try leader fallback
+        if (this.config.useLeaderFallback) {
+            await this.tryLeaderFallback();
+        }
+        else {
+            this.handleReconnectionFailure();
+        }
+    }
+    async tryDirectParentReconnection() {
+        if (!this.node.config.parent) {
+            throw new Error('No parent configured');
+        }
+        // Re-register with parent (might have new transports)
+        await this.node.registerParent();
+        // Verify connection works with a ping
+        await this.node.use(this.node.config.parent, {
+            method: 'ping',
+            params: {},
+        });
+        this.logger.info('Direct parent reconnection successful');
+    }
+    async tryLeaderFallback() {
+        // 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);
+        }
+    }
+    /**
+     * 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);
+        }
+    }
+    handleReconnectionFailure() {
+        this.reconnecting = false;
+        this.logger.error('Failed to reconnect to parent after all attempts - node in ERROR state');
+        // Transition to error state
+        this.node.state = NodeState.ERROR;
+        // Could emit custom event here for monitoring
+    }
+    calculateNodeLevel() {
+        return this.node.address.paths.length;
+    }
+    calculateBackoffDelay(attempt) {
+        const delay = this.config.baseDelayMs * Math.pow(2, attempt - 1);
+        return Math.min(delay, this.config.maxDelayMs);
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}