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

package/dist/src/connection/stream-handler.js

@@ -0,0 +1,310 @@
+import { oRequest, CoreUtils, oError, oErrorCodes, Logger, ResponseBuilder, } from '@olane/o-core';
+/**
+ * StreamHandler centralizes all stream-related functionality including:
+ * - Message type detection (request vs response)
+ * - Stream lifecycle management (create, reuse, close)
+ * - Backpressure handling
+ * - Request/response handling
+ * - Stream routing for middleware nodes
+ */
+export class StreamHandler {
+    constructor(logger) {
+        this.logger = logger ?? new Logger('StreamHandler');
+    }
+    /**
+     * Detects if a decoded message is a request
+     * Requests have a 'method' field and no 'result' field
+     */
+    isRequest(message) {
+        return typeof message?.method === 'string' && message.result === undefined;
+    }
+    /**
+     * Detects if a decoded message is a response
+     * Responses have a 'result' field and no 'method' field
+     */
+    isResponse(message) {
+        return message?.result !== undefined && message.method === undefined;
+    }
+    /**
+     * Decodes a stream message event into a JSON object
+     */
+    async decodeMessage(event) {
+        return CoreUtils.processStream(event);
+    }
+    /**
+     * Gets an existing open stream or creates a new one based on reuse policy
+     *
+     * @param connection - The libp2p connection
+     * @param protocol - The protocol to use for the stream
+     * @param config - Stream handler configuration
+     */
+    async getOrCreateStream(connection, protocol, config = {}) {
+        if (connection.status !== 'open') {
+            throw new oError(oErrorCodes.INVALID_STATE, 'Connection not open');
+        }
+        const reusePolicy = config.reusePolicy ?? 'none';
+        this.logger.debug('Reuse policy:', reusePolicy);
+        // Check for existing stream if reuse is enabled
+        if (reusePolicy === 'reuse') {
+            const existingStream = connection.streams.find((stream) => stream.status === 'open' &&
+                stream.protocol === protocol &&
+                stream.writeStatus === 'writable' &&
+                stream.remoteReadStatus === 'readable');
+            if (existingStream) {
+                this.logger.debug('Reusing existing stream', existingStream.id, existingStream.direction);
+                return existingStream;
+            }
+        }
+        // Create new stream
+        this.logger.debug('Creating new stream');
+        const stream = await connection.newStream(protocol, {
+            signal: config.signal,
+            maxOutboundStreams: config.maxOutboundStreams ?? 1000,
+            runOnLimitedConnection: config.runOnLimitedConnection ?? false,
+        });
+        return stream;
+    }
+    /**
+     * Sends data through a stream with backpressure handling
+     *
+     * @param stream - The stream to send data through
+     * @param data - The data to send
+     * @param config - Configuration for timeout and other options
+     */
+    async send(stream, data, config = {}) {
+        // Send the data with backpressure handling (libp2p v3 best practice)
+        const sent = stream.send(data);
+        // If send() returns false, buffer is full - wait for drain
+        if (!sent) {
+            this.logger.debug('Stream buffer full, waiting for drain...');
+            const drainTimeout = config.drainTimeoutMs ?? 30000;
+            await stream.onDrain({
+                signal: AbortSignal.timeout(drainTimeout),
+            });
+            this.logger.debug('Stream drained successfully');
+        }
+    }
+    /**
+     * Closes a stream safely with error handling
+     *
+     * @param stream - The stream to close
+     * @param config - Configuration including reuse policy
+     */
+    async close(stream, config = {}) {
+        // Don't close if reuse policy is enabled
+        if (config.reusePolicy === 'reuse') {
+            this.logger.debug('Stream reuse enabled, not closing stream');
+            return;
+        }
+        if (stream.status === 'open') {
+            try {
+                // force the close for now until we can implement a proper close
+                await stream.abort(new Error('Stream closed'));
+                this.logger.debug('Stream closed successfully');
+            }
+            catch (error) {
+                this.logger.debug('Error closing stream:', error.message);
+            }
+        }
+    }
+    /**
+     * Handles an incoming stream on the server side
+     * Attaches message listener immediately (libp2p v3 best practice)
+     * Routes requests or executes tools based on the message
+     *
+     * @param stream - The incoming stream
+     * @param connection - The connection the stream belongs to
+     * @param toolExecutor - Function to execute tools for requests
+     */
+    async handleIncomingStream(stream, connection, toolExecutor) {
+        // CRITICAL: Attach message listener immediately to prevent buffer overflow (libp2p v3)
+        const messageHandler = async (event) => {
+            try {
+                // avoid processing non-olane messages
+                if (!event.data) {
+                    return;
+                }
+                const message = await this.decodeMessage(event);
+                if (typeof message === 'string') {
+                    return;
+                }
+                if (this.isRequest(message)) {
+                    await this.handleRequestMessage(message, stream, toolExecutor);
+                }
+                else if (this.isResponse(message)) {
+                    this.logger.warn('Received response message on server-side stream, ignoring', message);
+                }
+                else {
+                    this.logger.warn('Received unknown message type', message);
+                }
+            }
+            catch (error) {
+                this.logger.error('Error handling stream message:', error);
+                // Error already logged, stream will be closed by remote peer or timeout
+            }
+        };
+        const closeHandler = () => {
+            this.logger.debug('Stream closed by remote peer');
+            stream.removeEventListener('message', messageHandler);
+            stream.removeEventListener('close', closeHandler);
+        };
+        stream.addEventListener('message', messageHandler);
+        stream.addEventListener('close', closeHandler);
+    }
+    /**
+     * Handles a request message by executing the tool and sending response
+     *
+     * @param message - The decoded request message
+     * @param stream - The stream to send the response on
+     * @param toolExecutor - Function to execute the tool
+     */
+    async handleRequestMessage(message, stream, toolExecutor) {
+        const request = new oRequest(message);
+        const responseBuilder = ResponseBuilder.create();
+        try {
+            this.logger.debug(`Processing request on stream: method=${request.method}, id=${request.id}`);
+            const result = await toolExecutor(request, stream);
+            const response = await responseBuilder.build(request, result, null);
+            await CoreUtils.sendResponse(response, stream);
+            this.logger.debug(`Successfully processed request: method=${request.method}, id=${request.id}`);
+        }
+        catch (error) {
+            this.logger.error(`Error processing request: method=${request.method}, id=${request.id}`, error);
+            const errorResponse = await responseBuilder.buildError(request, error);
+            await CoreUtils.sendResponse(errorResponse, stream);
+        }
+    }
+    /**
+     * Handles an outgoing stream on the client side
+     * Listens for response messages and emits them via the event emitter
+     * If requestHandler is provided, also processes incoming router requests
+     *
+     * @param stream - The outgoing stream
+     * @param emitter - Event emitter for chunk events
+     * @param config - Configuration including abort signal
+     * @param requestHandler - Optional handler for processing router requests received on this stream
+     * @param requestId - Optional request ID to filter responses (for stream reuse scenarios)
+     * @returns Promise that resolves with the final response
+     */
+    async handleOutgoingStream(stream, emitter, config = {}, requestHandler, requestId) {
+        return new Promise((resolve, reject) => {
+            let lastResponse;
+            const messageHandler = async (event) => {
+                // avoid processing non-olane messages
+                if (!event.data) {
+                    return;
+                }
+                try {
+                    const message = await this.decodeMessage(event);
+                    if (typeof message === 'string') {
+                        // this.logger.warn(
+                        //   'Received string message on server-side stream, ignoring',
+                        //   message,
+                        // );
+                        return;
+                    }
+                    if (this.isResponse(message)) {
+                        const response = await CoreUtils.processStreamResponse(event);
+                        // If requestId is provided, filter responses to only process those matching our request
+                        // This prevents premature termination when multiple requests share the same stream
+                        if (requestId !== undefined && response.id !== requestId) {
+                            this.logger.debug(`Ignoring response for different request (expected: ${requestId}, received: ${response.id})`);
+                            return;
+                        }
+                        // Emit chunk for streaming responses
+                        emitter.emit('chunk', response);
+                        // Check if this is the last chunk for THIS request
+                        if (response.result._last || !response.result._isStreaming) {
+                            lastResponse = response;
+                            cleanup();
+                            resolve(response);
+                        }
+                    }
+                    else if (this.isRequest(message)) {
+                        // Process incoming router requests if handler is provided
+                        if (requestHandler) {
+                            this.logger.debug('Received router request on client-side stream, processing...', message);
+                            await this.handleRequestMessage(message, stream, requestHandler);
+                        }
+                        else {
+                            this.logger.warn('Received request message on client-side stream, ignoring (no handler)', message);
+                        }
+                    }
+                    else {
+                        this.logger.warn('Received unknown message type', message);
+                    }
+                }
+                catch (error) {
+                    this.logger.error('Error handling response message:', error);
+                    cleanup();
+                    reject(error);
+                }
+            };
+            const closeHandler = () => {
+                this.logger.debug('Stream closed by remote peer');
+                cleanup();
+                if (lastResponse) {
+                    resolve(lastResponse);
+                }
+                else {
+                    reject(new oError(oErrorCodes.TIMEOUT, 'Stream closed before response received'));
+                }
+            };
+            const abortHandler = () => {
+                this.logger.debug('Request aborted');
+                cleanup();
+                try {
+                    stream.abort(new Error('Request aborted'));
+                }
+                catch (error) {
+                    this.logger.debug('Error aborting stream:', error.message);
+                }
+                reject(new oError(oErrorCodes.TIMEOUT, 'Request aborted'));
+            };
+            const cleanup = () => {
+                stream.removeEventListener('message', messageHandler);
+                stream.removeEventListener('close', closeHandler);
+                if (config.signal) {
+                    config.signal.removeEventListener('abort', abortHandler);
+                }
+            };
+            stream.addEventListener('message', messageHandler);
+            stream.addEventListener('close', closeHandler);
+            if (config.signal) {
+                config.signal.addEventListener('abort', abortHandler);
+            }
+        });
+    }
+    /**
+     * Forwards a request to the next hop and relays response chunks back
+     * This implements the middleware/proxy pattern for intermediate nodes
+     *
+     * @param request - The router request to forward
+     * @param incomingStream - The stream to send responses back on
+     * @param dialFn - Function to dial the next hop connection
+     */
+    async forwardRequest(request, incomingStream, dialFn) {
+        try {
+            // Connect to next hop
+            const nextHopConnection = await dialFn(request.params.address);
+            // Set up chunk relay - forward responses from next hop back to incoming stream
+            nextHopConnection.onChunk(async (response) => {
+                try {
+                    await CoreUtils.sendStreamResponse(response, incomingStream);
+                }
+                catch (error) {
+                    this.logger.error('Error forwarding chunk:', error);
+                }
+            });
+            // Transmit the request to next hop
+            await nextHopConnection.transmit(request);
+        }
+        catch (error) {
+            this.logger.error('Error forwarding request:', error);
+            // Send error response back on incoming stream using ResponseBuilder
+            const responseBuilder = ResponseBuilder.create();
+            const errorResponse = await responseBuilder.buildError(request, error);
+            await CoreUtils.sendResponse(errorResponse, incomingStream);
+        }
+    }
+}

package/dist/src/index.d.ts

@@ -1,5 +1,5 @@
 export * from './o-node.js';
-export * from './utils/network.utils.js';
+export * from './utils/index.js';
 export * from './o-node.hierarchy-manager.js';
 export * from './interfaces/o-node.config.js';
 export * from './connection/index.js';
@@ -7,4 +7,5 @@ export * from './o-node.tool.js';
 export * from './nodes/index.js';
 export * from './interfaces/o-node.tool-config.js';
 export * from './router/index.js';
+export * from './connection/o-stream.request.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AACnD,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AACnD,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC"}

package/dist/src/index.js

@@ -1,5 +1,5 @@
 export * from './o-node.js';
-export * from './utils/network.utils.js';
+export * from './utils/index.js';
 export * from './o-node.hierarchy-manager.js';
 export * from './interfaces/o-node.config.js';
 export * from './connection/index.js';
@@ -7,3 +7,4 @@ export * from './o-node.tool.js';
 export * from './nodes/index.js';
 export * from './interfaces/o-node.tool-config.js';
 export * from './router/index.js';
+export * from './connection/o-stream.request.js';

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

@@ -0,0 +1,49 @@
+import { oNotificationManager } from '@olane/o-core';
+import { Libp2p } from '@olane/o-config';
+import { oNodeAddress } from '../router/o-node.address.js';
+/**
+ * Interface for nodes that support connection heartbeat monitoring.
+ * This interface defines the contract that oConnectionHeartbeatManager needs
+ * to access live hierarchy state without holding stale references.
+ */
+export interface IHeartbeatableNode {
+    /**
+     * The node's current address
+     */
+    address: oNodeAddress;
+    /**
+     * The notification manager for emitting heartbeat events
+     */
+    notificationManager: oNotificationManager;
+    /**
+     * The underlying libp2p node for ping operations
+     */
+    p2pNode: Libp2p;
+    /**
+     * The current parent address (with live transport updates)
+     * @returns Parent address or null if no parent
+     */
+    parent: oNodeAddress | null;
+    /**
+     * Get the current list of leader addresses
+     * @returns Array of leader addresses (empty if this node is the leader)
+     */
+    getLeaders(): oNodeAddress[];
+    /**
+     * Get the current list of parent addresses
+     * @returns Array of parent addresses
+     */
+    getParents(): oNodeAddress[];
+    /**
+     * Get the current list of child addresses
+     * @returns Array of child addresses
+     */
+    getChildren(): oNodeAddress[];
+    /**
+     * Remove a child from the hierarchy
+     * @param childAddress The address of the child to remove
+     */
+    removeChild(childAddress: oNodeAddress): void;
+    use(param1: any, param2: any): Promise<any>;
+}
+//# sourceMappingURL=i-heartbeatable-node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"i-heartbeatable-node.d.ts","sourceRoot":"","sources":["../../../src/interfaces/i-heartbeatable-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IAEtB;;OAEG;IACH,mBAAmB,EAAE,oBAAoB,CAAC;IAE1C;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAE5B;;;OAGG;IACH,UAAU,IAAI,YAAY,EAAE,CAAC;IAE7B;;;OAGG;IACH,UAAU,IAAI,YAAY,EAAE,CAAC;IAE7B;;;OAGG;IACH,WAAW,IAAI,YAAY,EAAE,CAAC;IAE9B;;;OAGG;IACH,WAAW,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAE9C,GAAG,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CAC7C"}

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

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

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

@@ -27,6 +27,11 @@ export interface IReconnectableNode {
      * Register with the parent node
      */
     registerParent(): Promise<void>;
+    /**
+     * Register with the leader's global registry
+     */
+    register(): Promise<void>;
+    useSelf(request?: any): Promise<any>;
     /**
      * Execute a method on another node
      */

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

@@ -1 +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"}
+{"version":3,"file":"i-reconnectable-node.d.ts","sourceRoot":"","sources":["../../../src/interfaces/i-reconnectable-node.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,SAAS,EACT,oBAAoB,EAErB,MAAM,eAAe,CAAC;AACvB,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,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1B,OAAO,CAAC,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAErC;;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/o-node.config.d.ts

@@ -4,39 +4,33 @@ 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
+     * Connection health monitoring configuration
+     * Detects dead connections by checking libp2p connection state
      */
     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
+     * Connection timeout configuration
+     * Controls timeouts for stream read and drain operations in connections
      */
-    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;
+    connectionTimeouts?: {
+        /**
+         * Timeout in milliseconds for reading response data from a stream
+         * Default: 120000 (2 minutes)
+         */
+        readTimeoutMs?: number;
+        /**
+         * Timeout in milliseconds for waiting for stream buffer to drain when backpressure occurs
+         * Default: 30000 (30 seconds)
+         */
+        drainTimeoutMs?: number;
     };
+    runOnLimitedConnection?: boolean;
 }
 //# 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;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"}
+{"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,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,kBAAkB,CAAC,EAAE;QACnB;;;WAGG;QACH,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB;;;WAGG;QACH,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;IAEF,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC"}

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

@@ -1,12 +1,9 @@
-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';
+import { IHeartbeatableNode } from '../interfaces/i-heartbeatable-node.js';
 export interface HeartbeatConfig {
     enabled: boolean;
     intervalMs: number;
-    timeoutMs: number;
     failureThreshold: number;
     checkChildren: boolean;
     checkParent: boolean;
@@ -21,36 +18,39 @@ export interface ConnectionHealth {
     status: 'healthy' | 'degraded' | 'dead';
 }
 /**
- * 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 declare class oConnectionHeartbeatManager extends oObject {
-    private p2pNode;
-    private hierarchyManager;
-    private notificationManager;
-    private address;
+    private node;
     private config;
     private heartbeatInterval?;
     private healthMap;
-    constructor(p2pNode: Libp2p, hierarchyManager: oNodeHierarchyManager, notificationManager: oNotificationManager, address: oNodeAddress, config: HeartbeatConfig);
+    private isRunning;
+    constructor(node: IHeartbeatableNode, config: HeartbeatConfig);
     start(): Promise<void>;
     stop(): Promise<void>;
-    private performHeartbeatCycle;
-    private pingTarget;
+    private performHealthCheckCycle;
+    /**
+     * 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
+     */
+    private checkConnectionStatus;
+    private checkTarget;
     private handleConnectionDead;
     private emitConnectionDegradedEvent;
     private emitConnectionRecoveredEvent;
-    private extractPeerIdFromAddress;
     /**
      * Get current health status of all connections
      */

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

@@ -1 +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"}
+{"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,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;;;;;;;;;;;;;;GAcG;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,uBAAuB;IAgDrC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;YA8Bf,WAAW;IAoEzB,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"}