@olane/o-node 0.7.49 → 0.7.51

package/dist/src/connection/stream-pool-manager.js

@@ -0,0 +1,356 @@
+import { EventEmitter } from 'events';
+import { oObject, oError, oErrorCodes } from '@olane/o-core';
+import { StreamPoolEvent, } from './stream-pool-manager.events.js';
+/**
+ * StreamPoolManager manages a pool of reusable streams with automatic recovery.
+ *
+ * Architecture:
+ * - Stream[0]: Dedicated reader for incoming requests (background loop)
+ * - Streams[1-N]: Round-robin pool for outgoing request-response cycles
+ *
+ * Features:
+ * - Automatic stream pool initialization
+ * - Dedicated reader with automatic restart on failure
+ * - Event-based stream monitoring (listens to 'close' events)
+ * - Automatic stream replacement when failures detected
+ * - Event emission for monitoring and observability
+ */
+export class StreamPoolManager extends oObject {
+    constructor(config) {
+        super();
+        this.streams = [];
+        this.currentStreamIndex = 1; // Start from 1 (skip reader)
+        this.failureCount = 0;
+        this.eventEmitter = new EventEmitter();
+        this.streamEventHandlers = new Map();
+        this.isInitialized = false;
+        this.isClosing = false;
+        this.config = config;
+        this.POOL_SIZE = config.poolSize || 10;
+        this.READER_STREAM_INDEX = config.readerStreamIndex ?? 0;
+        if (this.POOL_SIZE < 2) {
+            throw new Error('Pool size must be at least 2 (1 reader + 1 request-response)');
+        }
+    }
+    get backgroundReaderActive() {
+        return this.dedicatedReaderStream?.isValid || false;
+    }
+    /**
+     * Initialize the stream pool and start the dedicated reader
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            this.logger.debug('Stream pool already initialized');
+            return;
+        }
+        this.logger.info('Initializing stream pool', {
+            poolSize: this.POOL_SIZE,
+            readerIndex: this.READER_STREAM_INDEX,
+        });
+        try {
+            // Spawn all streams in parallel
+            const streamPromises = [];
+            for (let i = 0; i < this.POOL_SIZE; i++) {
+                streamPromises.push(this.config.createStream());
+            }
+            this.streams = await Promise.all(streamPromises);
+            // Set stream types and attach event listeners
+            for (let i = 0; i < this.streams.length; i++) {
+                const stream = this.streams[i];
+                if (i === this.READER_STREAM_INDEX) {
+                    stream.config.streamType = 'dedicated-reader';
+                }
+                else {
+                    stream.config.streamType = 'request-response';
+                }
+                // Attach event listeners for monitoring
+                this.attachStreamListeners(stream, i);
+            }
+            // Initialize dedicated reader
+            await this.initializeBackgroundReader();
+            this.isInitialized = true;
+            this.emit(StreamPoolEvent.PoolInitialized, {
+                poolSize: this.streams.length,
+            });
+            this.logger.info('Stream pool initialized successfully', {
+                totalStreams: this.streams.length,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize stream pool:', error);
+            throw new oError(oErrorCodes.INTERNAL_ERROR, `Failed to initialize stream pool: ${error.message}`);
+        }
+    }
+    /**
+     * Get a stream for outgoing request-response cycles using round-robin selection
+     */
+    async getStream() {
+        if (!this.isInitialized) {
+            throw new oError(oErrorCodes.INVALID_STATE, 'Stream pool not initialized. Call initialize() first.');
+        }
+        if (this.streams.length < this.POOL_SIZE) {
+            this.logger.warn('Stream pool not at full capacity', {
+                current: this.streams.length,
+                expected: this.POOL_SIZE,
+            });
+        }
+        // Round-robin selection from request-response pool (skip reader stream)
+        const requestResponsePoolSize = this.POOL_SIZE - 1;
+        const selectedIndex = ((this.currentStreamIndex - 1) % requestResponsePoolSize) + 1;
+        this.currentStreamIndex =
+            selectedIndex === this.POOL_SIZE - 1 ? 1 : selectedIndex + 1;
+        const selectedStream = this.streams[selectedIndex];
+        // Validate stream health before returning
+        if (!selectedStream.isValid) {
+            this.logger.warn('Selected stream is not valid, attempting recovery', {
+                index: selectedIndex,
+            });
+            await this.replaceStream(selectedIndex);
+            return this.streams[selectedIndex];
+        }
+        return selectedStream;
+    }
+    /**
+     * Get statistics about the stream pool
+     */
+    getStats() {
+        const healthyStreams = this.streams.filter((s) => s.isValid).length;
+        const requestResponseStreams = this.streams.filter((s) => s.isRequestResponse).length;
+        let readerStreamHealth = 'not-initialized';
+        if (this.dedicatedReaderStream) {
+            readerStreamHealth = this.dedicatedReaderStream.isValid
+                ? 'healthy'
+                : 'unhealthy';
+        }
+        return {
+            totalStreams: this.streams.length,
+            healthyStreams,
+            readerStreamHealth,
+            requestResponseStreams,
+            failureCount: this.failureCount,
+        };
+    }
+    /**
+     * Close the stream pool and cleanup resources
+     */
+    async close() {
+        if (this.isClosing) {
+            return;
+        }
+        this.isClosing = true;
+        this.logger.info('Closing stream pool', {
+            totalStreams: this.streams.length,
+        });
+        // Remove all event listeners from streams
+        for (const stream of this.streams) {
+            this.removeStreamListeners(stream);
+        }
+        // Close all streams (though they may not actually close due to reuse policy)
+        await Promise.all(this.streams.map((s) => s.close()));
+        this.streams = [];
+        this.dedicatedReaderStream = undefined;
+        this.streamEventHandlers.clear();
+        this.isInitialized = false;
+        this.isClosing = false;
+        this.emit(StreamPoolEvent.PoolClosed);
+        this.logger.info('Stream pool closed');
+    }
+    /**
+     * Add event listener
+     */
+    on(event, listener) {
+        this.eventEmitter.on(event, listener);
+    }
+    /**
+     * Remove event listener
+     */
+    off(event, listener) {
+        this.eventEmitter.off(event, listener);
+    }
+    /**
+     * Emit event
+     */
+    emit(event, data) {
+        this.eventEmitter.emit(event, data);
+    }
+    /**
+     * Initialize the background reader on the dedicated stream
+     */
+    async initializeBackgroundReader() {
+        if (this.backgroundReaderActive) {
+            this.logger.debug('Background reader already active');
+            return;
+        }
+        const readerStream = this.streams[this.READER_STREAM_INDEX];
+        if (!readerStream) {
+            throw new oError(oErrorCodes.INTERNAL_ERROR, 'Reader stream not found in pool');
+        }
+        if (!readerStream.isValid) {
+            this.logger.warn('Reader stream is not valid, replacing it');
+            await this.replaceStream(this.READER_STREAM_INDEX);
+            return this.initializeBackgroundReader();
+        }
+        this.dedicatedReaderStream = readerStream;
+        this.logger.info('Starting background reader', {
+            streamId: readerStream.p2pStream.id,
+        });
+        // Get the raw p2p stream
+        const p2pStream = readerStream.p2pStream;
+        // Start the persistent read loop in the background
+        this.config.streamHandler
+            .handleIncomingStream(p2pStream, this.config.p2pConnection, async (request, s) => {
+            this.logger.debug('Background reader received request:', request.method);
+            if (this.config.requestHandler) {
+                return await this.config.requestHandler(request, s);
+            }
+            throw new Error('No request handler configured for incoming requests');
+        })
+            .catch((error) => {
+            this.logger.warn('Background reader exited:', error?.message || 'stream closed');
+            this.failureCount++;
+            this.emit(StreamPoolEvent.ReaderFailed, {
+                error: error?.message,
+                failureCount: this.failureCount,
+            });
+            // Attempt automatic recovery
+            this.handleReaderFailure().catch((recoveryError) => {
+                this.logger.error('Failed to recover from reader failure:', recoveryError);
+            });
+        });
+        this.emit(StreamPoolEvent.ReaderStarted, {
+            streamId: readerStream.p2pStream.id,
+        });
+    }
+    /**
+     * Handle dedicated reader failure with automatic recovery
+     */
+    async handleReaderFailure() {
+        if (this.isClosing) {
+            this.logger.debug('Pool is closing, skipping reader recovery');
+            return;
+        }
+        this.logger.warn('Attempting to recover from reader failure');
+        try {
+            // Replace the failed reader stream
+            await this.replaceStream(this.READER_STREAM_INDEX);
+            // Reinitialize the background reader
+            await this.initializeBackgroundReader();
+            this.logger.info('Successfully recovered from reader failure');
+            this.emit(StreamPoolEvent.ReaderRecovered, {
+                failureCount: this.failureCount,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to recover from reader failure:', error);
+            this.emit(StreamPoolEvent.RecoveryFailed, {
+                error: error.message,
+                failureCount: this.failureCount,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Replace a stream at the given index
+     */
+    async replaceStream(index) {
+        this.logger.info('Replacing stream', { index });
+        try {
+            const oldStream = this.streams[index];
+            const streamType = oldStream?.streamType || 'general';
+            // Remove event listeners from old stream
+            if (oldStream) {
+                this.removeStreamListeners(oldStream);
+            }
+            // Create new stream
+            const newStream = await this.config.createStream();
+            newStream.config.streamType = streamType;
+            // Replace in pool
+            this.streams[index] = newStream;
+            // Attach event listeners to new stream
+            this.attachStreamListeners(newStream, index);
+            // Close old stream (if it exists and is valid)
+            if (oldStream) {
+                try {
+                    await oldStream.close();
+                }
+                catch (error) {
+                    this.logger.debug('Error closing old stream:', error.message);
+                }
+            }
+            this.emit(StreamPoolEvent.StreamReplaced, { index, streamType });
+            this.logger.info('Stream replaced successfully', { index, streamType });
+        }
+        catch (error) {
+            this.logger.error('Failed to replace stream:', error);
+            throw new oError(oErrorCodes.INTERNAL_ERROR, `Failed to replace stream at index ${index}: ${error.message}`);
+        }
+    }
+    /**
+     * Attach event listeners to a stream for monitoring
+     */
+    attachStreamListeners(stream, index) {
+        const streamId = stream.p2pStream.id;
+        // Remove any existing listeners for this stream
+        this.removeStreamListeners(stream);
+        // Create close event handler
+        const closeHandler = (event) => {
+            this.handleStreamClose(index, event);
+        };
+        // Attach listener to underlying p2p stream
+        stream.p2pStream.addEventListener('close', closeHandler);
+        // Store handler for cleanup
+        this.streamEventHandlers.set(streamId, closeHandler);
+        this.logger.debug('Attached stream listeners', { index, streamId });
+    }
+    /**
+     * Remove event listeners from a stream
+     */
+    removeStreamListeners(stream) {
+        const streamId = stream.p2pStream.id;
+        const handler = this.streamEventHandlers.get(streamId);
+        if (handler) {
+            stream.p2pStream.removeEventListener('close', handler);
+            this.streamEventHandlers.delete(streamId);
+            this.logger.debug('Removed stream listeners', { streamId });
+        }
+    }
+    /**
+     * Handle stream close event - triggers immediate replacement
+     */
+    handleStreamClose(index, event) {
+        const stream = this.streams[index];
+        const streamId = stream?.p2pStream.id;
+        const isReaderStream = index === this.READER_STREAM_INDEX;
+        this.logger.warn('Stream closed event detected', {
+            index,
+            streamId,
+            isReaderStream,
+            error: event?.error?.message,
+        });
+        this.failureCount++;
+        // Special handling for dedicated reader stream
+        if (isReaderStream) {
+            this.emit(StreamPoolEvent.ReaderFailed, {
+                error: event?.error?.message || 'stream closed',
+                failureCount: this.failureCount,
+            });
+            // Attempt automatic recovery
+            this.handleReaderFailure().catch((recoveryError) => {
+                this.logger.error('Failed to recover from reader failure:', recoveryError);
+            });
+        }
+        else {
+            // Request-response stream failure
+            this.emit(StreamPoolEvent.StreamFailed, {
+                index,
+                streamId,
+                error: event?.error?.message,
+                failureCount: this.failureCount,
+            });
+            // Attempt automatic replacement
+            this.replaceStream(index).catch((replaceError) => {
+                this.logger.error('Failed to replace stream:', replaceError);
+            });
+        }
+    }
+}

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

@@ -4,6 +4,9 @@ import { oNodeAddress } from '../router/o-node.address.js';
 import { oNodeConfig } from './o-node.config.js';
 import { oNodeTransport } from '../router/o-node.transport.js';
 import { oNodeHierarchyManager } from '../o-node.hierarchy-manager.js';
+export interface IReconnectionManager {
+    waitForParentAndReconnect(): Promise<void>;
+}
 /**
  * Interface for nodes that support registration management.
  * This interface defines the contract that oRegistrationManager needs
@@ -50,6 +53,10 @@ export interface IRegistrableNode {
      * Hierarchy manager for tracking parent/child/leader relationships
      */
     hierarchyManager: oNodeHierarchyManager;
+    /**
+     * Reconnection manager for handling parent discovery
+     */
+    reconnectionManager?: IReconnectionManager;
     /**
      * Execute a method on another node
      */

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

@@ -1 +1 @@
-{"version":3,"file":"i-registrable-node.d.ts","sourceRoot":"","sources":["../../../src/interfaces/i-registrable-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,MAAM,EAAE,WAAW,CAAC;IAEpB;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IAEtB;;OAEG;IACH,aAAa,EAAE,YAAY,CAAC;IAE5B;;OAEG;IACH,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAE5B;;OAEG;IACH,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAE5B;;OAEG;IACH,IAAI,EAAE,QAAQ,CAAC;IAEf;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,UAAU,EAAE,cAAc,EAAE,CAAC;IAE7B;;OAEG;IACH,SAAS,EAAE,MAAM,EAAE,CAAC;IAEpB;;OAEG;IACH,gBAAgB,EAAE,qBAAqB,CAAC;IAExC;;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;IAEhB;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvD"}
+{"version":3,"file":"i-registrable-node.d.ts","sourceRoot":"","sources":["../../../src/interfaces/i-registrable-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAGvE,MAAM,WAAW,oBAAoB;IACnC,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5C;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,MAAM,EAAE,WAAW,CAAC;IAEpB;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IAEtB;;OAEG;IACH,aAAa,EAAE,YAAY,CAAC;IAE5B;;OAEG;IACH,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAE5B;;OAEG;IACH,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAE5B;;OAEG;IACH,IAAI,EAAE,QAAQ,CAAC;IAEf;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,UAAU,EAAE,cAAc,EAAE,CAAC;IAE7B;;OAEG;IACH,SAAS,EAAE,MAAM,EAAE,CAAC;IAEpB;;OAEG;IACH,gBAAgB,EAAE,qBAAqB,CAAC;IAExC;;OAEG;IACH,mBAAmB,CAAC,EAAE,oBAAoB,CAAC;IAE3C;;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;IAEhB;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACvD"}

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

@@ -1 +1 @@
-{"version":3,"file":"o-registration.manager.d.ts","sourceRoot":"","sources":["../../../src/managers/o-registration.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAIR,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAGvE,MAAM,MAAM,iBAAiB,GACzB,gBAAgB,GAChB,aAAa,GACb,YAAY,GACZ,QAAQ,CAAC;AAEb,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,oBAAqB,SAAQ,OAAO;IAMnC,OAAO,CAAC,IAAI;IALxB,OAAO,CAAC,WAAW,CAAuC;IAC1D,OAAO,CAAC,WAAW,CAAuC;IAC1D,OAAO,CAAC,WAAW,CAAC,CAAQ;IAC5B,OAAO,CAAC,WAAW,CAAC,CAAQ;gBAER,IAAI,EAAE,gBAAgB;IAI1C;;;OAGG;IACH,iBAAiB,IAAI,OAAO;IAM5B;;;OAGG;IACH,iBAAiB,IAAI,OAAO;IAM5B;;OAEG;IACH,kBAAkB,IAAI,OAAO;IAI7B;;OAEG;IACH,kBAAkB,IAAI,OAAO;IAI7B;;OAEG;IACH,iBAAiB,IAAI,OAAO;IAe5B;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAMxB;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAMxB;;OAEG;IACH,QAAQ,IAAI,IAAI;IAKhB;;OAEG;IACH,SAAS,IAAI,kBAAkB;IAS/B;;;OAGG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA6ErC;;;OAGG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;CAwDtC"}
+{"version":3,"file":"o-registration.manager.d.ts","sourceRoot":"","sources":["../../../src/managers/o-registration.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAIR,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAGvE,MAAM,MAAM,iBAAiB,GACzB,gBAAgB,GAChB,aAAa,GACb,YAAY,GACZ,QAAQ,CAAC;AAEb,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,oBAAqB,SAAQ,OAAO;IAMnC,OAAO,CAAC,IAAI;IALxB,OAAO,CAAC,WAAW,CAAuC;IAC1D,OAAO,CAAC,WAAW,CAAuC;IAC1D,OAAO,CAAC,WAAW,CAAC,CAAQ;IAC5B,OAAO,CAAC,WAAW,CAAC,CAAQ;gBAER,IAAI,EAAE,gBAAgB;IAI1C;;;OAGG;IACH,iBAAiB,IAAI,OAAO;IAM5B;;;OAGG;IACH,iBAAiB,IAAI,OAAO;IAM5B;;OAEG;IACH,kBAAkB,IAAI,OAAO;IAI7B;;OAEG;IACH,kBAAkB,IAAI,OAAO;IAI7B;;OAEG;IACH,iBAAiB,IAAI,OAAO;IAe5B;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAMxB;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAMxB;;OAEG;IACH,QAAQ,IAAI,IAAI;IAKhB;;OAEG;IACH,SAAS,IAAI,kBAAkB;IAS/B;;;OAGG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAsFrC;;;OAGG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;CAwDtC"}

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

@@ -128,7 +128,17 @@ export class oRegistrationManager extends oObject {
                     this.node.parent.setTransports(this.node.leader?.libp2pTransports || []);
                 }
                 else {
-                    throw new Error('Parent has no transports available');
+                    this.logger.debug('Waiting for parent and reconnecting...');
+                    // Reset state since we're delegating to reconnection manager
+                    this.parentState = 'not_registered';
+                    if (this.node.reconnectionManager) {
+                        await this.node.reconnectionManager.waitForParentAndReconnect();
+                    }
+                    else {
+                        throw new Error('Parent has no transports and no reconnection manager available');
+                    }
+                    // If we get here, reconnection was successful and registration is complete
+                    return;
                 }
             }
             // Register with parent via child_register call

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.tool.d.ts","sourceRoot":"","sources":["../../src/o-node.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAoB,MAAM,eAAe,CAAC;AAErE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;;AAMrD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IAC/C,OAAO,CAAC,aAAa,CAAiB;IAEhC,mBAAmB,CAAC,OAAO,EAAE,QAAQ;IAsBrC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAoBhC,mBAAmB;IAWnB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,iBAAiB,CACrB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,IAAI,CAAC;IAIV,YAAY,CAChB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,KAAK,CAAC,EAAE,OAAO,GACd,OAAO,CAAC,IAAI,CAAC;IAyCV,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAQ9B,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAiC5D"}
+{"version":3,"file":"o-node.tool.d.ts","sourceRoot":"","sources":["../../src/o-node.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAoB,MAAM,eAAe,CAAC;AAErE,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;;AAMrD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IAC/C,OAAO,CAAC,aAAa,CAAiB;IAEhC,mBAAmB,CAAC,OAAO,EAAE,QAAQ;IAuBrC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAsBhC,mBAAmB;IAWnB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,iBAAiB,CACrB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,IAAI,CAAC;IAIV,YAAY,CAChB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,KAAK,CAAC,EAAE,OAAO,GACd,OAAO,CAAC,IAAI,CAAC;IAyCV,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAQ9B,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;CAiC5D"}

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

@@ -25,6 +25,7 @@ export class oNodeTool extends oTool(oServerNode) {
         await this.p2pNode.handle(reuseProtocol, this.handleStreamReuse.bind(this), {
             maxInboundStreams: 10000,
             maxOutboundStreams: maxOutboundsStreams,
+            runOnLimitedConnection: this.config.runOnLimitedConnection,
         });
         this.logger.debug('Handled protocol reuse: ' + reuseProtocol);
     }
@@ -40,10 +41,12 @@ export class oNodeTool extends oTool(oServerNode) {
         this.logger.debug('Handling protocol: ' + address.protocol, {
             maxInboundStreams: 10000,
             maxOutboundStreams: maxOutboundsStreams,
+            runOnLimitedConnection: this.config.runOnLimitedConnection,
         });
         await this.p2pNode.handle(address.protocol, this.handleStream.bind(this), {
             maxInboundStreams: 10000,
             maxOutboundStreams: maxOutboundsStreams,
+            runOnLimitedConnection: this.config.runOnLimitedConnection,
         });
         await this.handleProtocolReuse(address);
     }
@@ -66,20 +69,20 @@ export class oNodeTool extends oTool(oServerNode) {
     async handleStream(stream, connection, reuse) {
         if (reuse) {
             this.logger.debug('Handle stream with reuse = true');
+            // record inbound connection to manager
+            const remoteAddress = await ConnectionUtils.addressFromConnection({
+                currentNode: this,
+                connection: connection,
+            });
+            this.connectionManager.answer({
+                nextHopAddress: remoteAddress,
+                address: remoteAddress,
+                callerAddress: this.address,
+                p2pConnection: connection,
+                reuse,
+                // requestHandler: this.execute.bind(this), TODO: do we need this?
+            });
         }
-        // record inbound connection to manager
-        const remoteAddress = await ConnectionUtils.addressFromConnection({
-            currentNode: this,
-            connection: connection,
-        });
-        this.connectionManager.answer({
-            nextHopAddress: remoteAddress,
-            address: remoteAddress,
-            callerAddress: this.address,
-            p2pConnection: connection,
-            reuse,
-            // requestHandler: this.execute.bind(this), TODO: do we need this?
-        });
         // Use StreamHandler for consistent stream handling
         // This follows libp2p v3 best practices for length-prefixed streaming
         await this.streamHandler.handleIncomingStream(stream, connection, async (request, stream) => {

package/dist/test/connection-management.spec.js

@@ -347,29 +347,29 @@ describe('Connection Management', () => {
             // This test verifies stop mechanism doesn't throw errors
             spy.stop();
         });
-        it('should handle cleanup of multiple connections', async () => {
-            builder = await NetworkTopologies.fiveNode();
-            const leader = builder.getNode('o://leader');
-            // Establish connections
-            const child1 = builder.getNode('o://child1');
-            const child2 = builder.getNode('o://child2');
-            await leader.use(child1.address, {
-                method: 'echo',
-                params: { message: 'child1' },
-            });
-            await leader.use(child2.address, {
-                method: 'echo',
-                params: { message: 'child2' },
-            });
-            // Stop all children
-            await builder.stopNode('o://child1');
-            await builder.stopNode('o://child2');
-            // Leader should remain operational
-            const response = await leader.use(leader.address, {
-                method: 'get_info',
-                params: {},
-            });
-            expect(response.result.success).to.be.true;
-        });
+        // it('should handle cleanup of multiple connections', async () => {
+        //   builder = await NetworkTopologies.fiveNode();
+        //   const leader = builder.getNode('o://leader')!;
+        //   // Establish connections
+        //   const child1 = builder.getNode('o://child1')!;
+        //   const child2 = builder.getNode('o://child2')!;
+        //   await leader.use(child1.address, {
+        //     method: 'echo',
+        //     params: { message: 'child1' },
+        //   });
+        //   await leader.use(child2.address, {
+        //     method: 'echo',
+        //     params: { message: 'child2' },
+        //   });
+        //   // Stop all children
+        //   await builder.stopNode('o://child1');
+        //   await builder.stopNode('o://child2');
+        //   // Leader should remain operational
+        //   const response = await leader.use(leader.address, {
+        //     method: 'get_info',
+        //     params: {},
+        //   });
+        //   expect(response.result.success).to.be.true;
+        // });
     });
 });

package/dist/test/helpers/stream-pool-test-helpers.d.ts

@@ -0,0 +1,76 @@
+import { oNodeConnectionStream } from '../../src/connection/o-node-connection-stream.js';
+import { StreamPoolManagerConfig } from '../../src/index.js';
+/**
+ * Create a mock stream for testing
+ */
+export declare function createMockStream(id?: string, options?: {
+    status?: 'open' | 'closed' | 'reset';
+    writeStatus?: 'writable' | 'writing' | 'closed';
+    readStatus?: 'readable' | 'reading' | 'closed';
+    remoteReadStatus?: 'readable' | 'reading' | 'closed';
+}): any;
+/**
+ * Create a mock P2P connection for testing
+ */
+export declare function createMockP2PConnection(id?: string, status?: 'open' | 'closed'): any;
+/**
+ * Create a mock StreamHandler for testing
+ */
+export declare function createMockStreamHandler(): any;
+/**
+ * Create a mock oNodeConnectionStream
+ */
+export declare function createMockConnectionStream(p2pStream?: any, streamType?: 'dedicated-reader' | 'request-response' | 'general'): oNodeConnectionStream;
+/**
+ * Factory for creating StreamPoolManager test config
+ */
+export declare function createStreamPoolManagerConfig(overrides?: Partial<StreamPoolManagerConfig>): StreamPoolManagerConfig;
+/**
+ * Event capture helper for testing event emissions
+ */
+export declare class EventCapture {
+    private emitter;
+    private events;
+    constructor(emitter: any);
+    /**
+     * Start capturing events
+     */
+    start(eventNames: string[]): void;
+    /**
+     * Get all captured events
+     */
+    getEvents(): Array<{
+        type: string;
+        data: any;
+        timestamp: number;
+    }>;
+    /**
+     * Get events of specific type
+     */
+    getEventsByType(type: string): any[];
+    /**
+     * Check if event was emitted
+     */
+    hasEvent(type: string): boolean;
+    /**
+     * Get count of specific event type
+     */
+    getEventCount(type: string): number;
+    /**
+     * Wait for specific event
+     */
+    waitForEvent(type: string, timeoutMs?: number): Promise<any>;
+    /**
+     * Clear captured events
+     */
+    clear(): void;
+}
+/**
+ * Helper to make a stream invalid
+ */
+export declare function makeStreamInvalid(stream: any): void;
+/**
+ * Helper to wait for condition with timeout
+ */
+export declare function waitFor(condition: () => boolean, timeoutMs?: number, intervalMs?: number): Promise<void>;
+//# sourceMappingURL=stream-pool-test-helpers.d.ts.map

package/dist/test/helpers/stream-pool-test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-pool-test-helpers.d.ts","sourceRoot":"","sources":["../../../test/helpers/stream-pool-test-helpers.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,qBAAqB,EAAE,MAAM,kDAAkD,CAAC;AACzF,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAE7D;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,GAAE,MAAsB,EAC1B,OAAO,GAAE;IACP,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IACrC,WAAW,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IAChD,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC/C,gBAAgB,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;CACjD,GACL,GAAG,CAqBL;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,GAAE,MAA0B,EAC9B,MAAM,GAAE,MAAM,GAAG,QAAiB,GACjC,GAAG,CAoBL;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,GAAG,CAwE7C;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,CAAC,EAAE,GAAG,EACf,UAAU,GAAE,kBAAkB,GAAG,kBAAkB,GAAG,SAAqB,GAC1E,qBAAqB,CASvB;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,GAAE,OAAO,CAAC,uBAAuB,CAAM,GAC/C,uBAAuB,CAuBzB;AAED;;GAEG;AACH,qBAAa,YAAY;IAGX,OAAO,CAAC,OAAO;IAF3B,OAAO,CAAC,MAAM,CAA6D;gBAEvD,OAAO,EAAE,GAAG;IAEhC;;OAEG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI;IAYjC;;OAEG;IACH,SAAS,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAIlE;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,EAAE;IAIpC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI/B;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAInC;;OAEG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,MAAa,GAAG,OAAO,CAAC,GAAG,CAAC;IAcxE;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAGnD;AAED;;GAEG;AACH,wBAAsB,OAAO,CAC3B,SAAS,EAAE,MAAM,OAAO,EACxB,SAAS,GAAE,MAAa,EACxB,UAAU,GAAE,MAAW,GACtB,OAAO,CAAC,IAAI,CAAC,CASf"}