@olane/o-client-limited 0.7.51 → 0.7.52

package/dist/src/connection/o-limited-connection.d.ts

@@ -1,40 +1,31 @@
 import { oNodeConnection } from '@olane/o-node';
 import type { oNodeConnectionConfig } from '@olane/o-node';
+import { oLimitedStreamManager } from './o-limited.stream-manager.js';
 /**
- * oLimitedConnection extends oNodeConnection with stream reuse and pool management.
+ * oLimitedConnection extends oNodeConnection with stream reuse for limited connections.
  *
  * This is optimized for limited connections where creating new streams is expensive
  * (mobile clients, browsers, resource-constrained environments).
  *
- * Stream Pool Architecture (10 streams total):
- * - Stream 0: Dedicated background reader for incoming requests
- * - Streams 1-9: Round-robin pool for outgoing request-response cycles
+ * Stream Architecture:
+ * - 1 dedicated reader stream for receiving requests from receiver
+ * - Reuses outbound streams for multiple request-response cycles
  *
  * Features:
- * - Automatic recovery when dedicated reader fails
- * - Health monitoring of all pooled streams
- * - Automatic stream replacement on failure
- * - Event emission for monitoring (reader-failed, stream-replaced, etc.)
+ * - Automatic reader stream creation and maintenance
+ * - Single retry on reader failure
+ * - Stream reuse for outbound requests
+ * - Event emission for monitoring (reader-started, reader-failed, reader-recovered)
  *
  * Default Behavior:
  * - Uses 'reuse' stream policy by default
- * - Automatically initializes pool manager on first stream request
+ * - Automatically initializes dedicated reader on connection start
  */
 export declare class oLimitedConnection extends oNodeConnection {
-    private streamPoolManager?;
-    private poolInitialized;
+    streamManager: oLimitedStreamManager;
     constructor(config: oNodeConnectionConfig);
     /**
-     * Initialize the stream pool manager
-     */
-    private initializePoolManager;
-    getOrCreateStream(): Promise<any>;
-    /**
-     * Get stream pool statistics
-     */
-    getPoolStats(): import("@olane/o-node").StreamPoolStats | undefined;
-    /**
-     * Override close to cleanup pool manager
+     * Override close to cleanup stream manager properly
      */
     close(): Promise<void>;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"o-limited-connection.d.ts","sourceRoot":"","sources":["../../../src/connection/o-limited-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAqB,MAAM,eAAe,CAAC;AACnE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,kBAAmB,SAAQ,eAAe;IACrD,OAAO,CAAC,iBAAiB,CAAC,CAAoB;IAC9C,OAAO,CAAC,eAAe,CAAS;gBAEpB,MAAM,EAAE,qBAAqB;IASzC;;OAEG;YACW,qBAAqB;IAqC7B,iBAAiB,IAAI,OAAO,CAAC,GAAG,CAAC;IAevC;;OAEG;IACH,YAAY;IAIZ;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAY7B"}
+{"version":3,"file":"o-limited-connection.d.ts","sourceRoot":"","sources":["../../../src/connection/o-limited-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EACL,qBAAqB,EAEtB,MAAM,+BAA+B,CAAC;AAGvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,kBAAmB,SAAQ,eAAe;IAC7C,aAAa,EAAE,qBAAqB,CAAC;gBAEjC,MAAM,EAAE,qBAAqB;IAmCzC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAK7B"}

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

@@ -1,94 +1,60 @@
-import { oNodeConnection, StreamPoolManager } from '@olane/o-node';
+import { oNodeConnection } from '@olane/o-node';
+import { oLimitedStreamManager, } from './o-limited.stream-manager.js';
+import { StreamManagerEvent } from '@olane/o-node';
 /**
- * oLimitedConnection extends oNodeConnection with stream reuse and pool management.
+ * oLimitedConnection extends oNodeConnection with stream reuse for limited connections.
  *
  * This is optimized for limited connections where creating new streams is expensive
  * (mobile clients, browsers, resource-constrained environments).
  *
- * Stream Pool Architecture (10 streams total):
- * - Stream 0: Dedicated background reader for incoming requests
- * - Streams 1-9: Round-robin pool for outgoing request-response cycles
+ * Stream Architecture:
+ * - 1 dedicated reader stream for receiving requests from receiver
+ * - Reuses outbound streams for multiple request-response cycles
  *
  * Features:
- * - Automatic recovery when dedicated reader fails
- * - Health monitoring of all pooled streams
- * - Automatic stream replacement on failure
- * - Event emission for monitoring (reader-failed, stream-replaced, etc.)
+ * - Automatic reader stream creation and maintenance
+ * - Single retry on reader failure
+ * - Stream reuse for outbound requests
+ * - Event emission for monitoring (reader-started, reader-failed, reader-recovered)
  *
  * Default Behavior:
  * - Uses 'reuse' stream policy by default
- * - Automatically initializes pool manager on first stream request
+ * - Automatically initializes dedicated reader on connection start
  */
 export class oLimitedConnection extends oNodeConnection {
     constructor(config) {
         const reusePolicy = config.reusePolicy ?? 'reuse';
         super({
             ...config,
-            reusePolicy: reusePolicy,
+            reusePolicy,
         });
-        this.poolInitialized = false;
-        this.reusePolicy = reusePolicy;
-    }
-    /**
-     * Initialize the stream pool manager
-     */
-    async initializePoolManager() {
-        if (this.poolInitialized || this.streamPoolManager) {
-            return;
-        }
-        this.logger.debug('Initializing stream pool manager');
-        this.streamPoolManager = new StreamPoolManager({
-            poolSize: 10,
-            readerStreamIndex: 0,
-            streamHandler: this.streamHandler,
+        // Replace the base streamManager with our limited version
+        const protocol = this.nextHopAddress.protocol +
+            (reusePolicy === 'reuse' ? '/reuse' : '');
+        const limitedConfig = {
             p2pConnection: this.p2pConnection,
-            requestHandler: this.config.requestHandler,
-            createStream: async () => {
-                return await super.getOrCreateStream();
-            },
-        });
+            protocol,
+            remoteAddress: this.nextHopAddress,
+            requestHandler: config.requestHandler,
+        };
+        this.streamManager = new oLimitedStreamManager(limitedConfig);
         // Set up event listeners for monitoring
-        this.streamPoolManager.on('reader-failed', (data) => {
-            this.logger.warn('Stream pool reader failed', data);
+        this.streamManager.on(StreamManagerEvent.ReaderStarted, (data) => {
+            this.logger.info('Reader stream started', data);
         });
-        this.streamPoolManager.on('reader-recovered', (data) => {
-            this.logger.info('Stream pool reader recovered', data);
+        this.streamManager.on(StreamManagerEvent.ReaderFailed, (data) => {
+            this.logger.warn('Reader stream failed', data);
         });
-        this.streamPoolManager.on('stream-replaced', (data) => {
-            this.logger.info('Stream replaced in pool', data);
+        this.streamManager.on(StreamManagerEvent.ReaderRecovered, (data) => {
+            this.logger.info('Reader stream recovered', data);
         });
-        await this.streamPoolManager.initialize();
-        this.poolInitialized = true;
-        this.logger.info('Stream pool manager initialized successfully');
-    }
-    async getOrCreateStream() {
-        if (this.reusePolicy === 'reuse') {
-            // Initialize pool manager on first call
-            if (!this.poolInitialized) {
-                await this.initializePoolManager();
-            }
-            // Delegate to pool manager for stream selection
-            return await this.streamPoolManager.getStream();
-        }
-        // Fallback to default behavior if reuse is not enabled
-        return super.getOrCreateStream();
-    }
-    /**
-     * Get stream pool statistics
-     */
-    getPoolStats() {
-        return this.streamPoolManager?.getStats();
     }
     /**
-     * Override close to cleanup pool manager
+     * Override close to cleanup stream manager properly
      */
     async close() {
-        this.logger.debug('Closing connection and stream pool manager');
-        if (this.streamPoolManager) {
-            await this.streamPoolManager.close();
-            this.streamPoolManager = undefined;
-        }
-        this.poolInitialized = false;
+        this.logger.debug('Closing limited connection');
+        await this.streamManager.close();
         await super.close();
     }
 }

package/dist/src/connection/o-limited.stream-manager.d.ts

@@ -0,0 +1,79 @@
+import type { Stream } from '@libp2p/interface';
+import { oNodeStreamManager, oNodeStream, StreamManagerConfig } from '@olane/o-node';
+import type { StreamHandlerConfig } from '@olane/o-node';
+/**
+ * Extended configuration for limited stream manager
+ */
+export interface oLimitedStreamManagerConfig extends StreamManagerConfig {
+    /**
+     * Protocol string for creating streams
+     */
+    protocol: string;
+    /**
+     * Remote address for the connection
+     */
+    remoteAddress: any;
+    /**
+     * Optional request handler for bidirectional communication
+     */
+    requestHandler?: (request: any, stream: Stream) => Promise<any>;
+}
+/**
+ * Limited Stream Manager handles stream lifecycle for limited connections
+ * Features:
+ * - Maintains dedicated reader stream for receiving requests from receiver
+ * - Reuses outbound streams (no close after use)
+ * - Single retry on reader failure
+ * - No health checks (error handling on use)
+ */
+export declare class oLimitedStreamManager extends oNodeStreamManager {
+    private readerStream?;
+    private isReaderLoopActive;
+    private readerLoopAbortController?;
+    private outboundStream?;
+    private limitedConfig;
+    private closing;
+    constructor(config: oLimitedStreamManagerConfig);
+    /**
+     * Initialize the limited stream manager
+     * Creates dedicated reader stream and starts background read loop
+     */
+    initialize(): Promise<void>;
+    /**
+     * Creates and initializes the dedicated reader stream
+     */
+    private createReaderStream;
+    /**
+     * Sends stream initialization message to identify this as a reader stream
+     */
+    private sendStreamInitMessage;
+    /**
+     * Starts the background reader loop
+     * Continuously listens for incoming requests on the reader stream
+     */
+    private startReaderLoop;
+    /**
+     * Background reader loop implementation
+     */
+    private runReaderLoop;
+    /**
+     * Attempts to recover the reader stream (single retry)
+     */
+    private recoverReaderStream;
+    /**
+     * Override getOrCreateStream to reuse outbound streams
+     * Does not create new stream for every request
+     * Auto-initializes on first use
+     */
+    getOrCreateStream(protocol: string, remoteAddress: any, config?: StreamHandlerConfig): Promise<oNodeStream>;
+    /**
+     * Override releaseStream to NOT close the stream
+     * Keep streams open for reuse
+     */
+    releaseStream(streamId: string): Promise<void>;
+    /**
+     * Close the stream manager and cleanup all resources
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=o-limited.stream-manager.d.ts.map

package/dist/src/connection/o-limited.stream-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-limited.stream-manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-limited.stream-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EACL,kBAAkB,EAElB,WAAW,EACX,mBAAmB,EAGpB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEzD;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,mBAAmB;IACtE;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,aAAa,EAAE,GAAG,CAAC;IAEnB;;OAEG;IACH,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACjE;AAED;;;;;;;GAOG;AACH,qBAAa,qBAAsB,SAAQ,kBAAkB;IAC3D,OAAO,CAAC,YAAY,CAAC,CAAc;IACnC,OAAO,CAAC,kBAAkB,CAAkB;IAC5C,OAAO,CAAC,yBAAyB,CAAC,CAAkB;IACpD,OAAO,CAAC,cAAc,CAAC,CAAc;IACrC,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,OAAO,CAAkB;gBAErB,MAAM,EAAE,2BAA2B;IAK/C;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAqDjC;;OAEG;YACW,kBAAkB;IA4BhC;;OAEG;YACW,qBAAqB;IAiBnC;;;OAGG;YACW,eAAe;IAe7B;;OAEG;YACW,aAAa;IAwB3B;;OAEG;YACW,mBAAmB;IAgCjC;;;;OAIG;IACG,iBAAiB,CACrB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,GAAG,EAClB,MAAM,GAAE,mBAAwB,GAC/B,OAAO,CAAC,WAAW,CAAC;IA6BvB;;;OAGG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMpD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAqC7B"}

package/dist/src/connection/o-limited.stream-manager.js

@@ -0,0 +1,234 @@
+import { oError, oErrorCodes } from '@olane/o-core';
+import { oNodeStreamManager, StreamManagerEvent, } from '@olane/o-node';
+/**
+ * Limited Stream Manager handles stream lifecycle for limited connections
+ * Features:
+ * - Maintains dedicated reader stream for receiving requests from receiver
+ * - Reuses outbound streams (no close after use)
+ * - Single retry on reader failure
+ * - No health checks (error handling on use)
+ */
+export class oLimitedStreamManager extends oNodeStreamManager {
+    constructor(config) {
+        super(config);
+        this.isReaderLoopActive = false;
+        this.closing = false;
+        this.limitedConfig = config;
+    }
+    /**
+     * Initialize the limited stream manager
+     * Creates dedicated reader stream and starts background read loop
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        await super.initialize();
+        // Register InboundRequest listener if requestHandler provided
+        // This enables bidirectional communication - receiver can send requests to caller via reader stream
+        if (this.limitedConfig.requestHandler) {
+            this.eventEmitter.on(StreamManagerEvent.InboundRequest, async (data) => {
+                try {
+                    const result = await this.limitedConfig.requestHandler(data.request, data.stream);
+                    return result;
+                }
+                catch (error) {
+                    this.logger.error('Error in requestHandler for inbound request:', data.request.toString(), error);
+                    throw error; // StreamManager will handle error response
+                }
+            });
+            this.logger.debug('Registered InboundRequest handler for limited connection');
+        }
+        try {
+            // Create dedicated reader stream
+            await this.createReaderStream();
+            this.isInitialized = true;
+            this.logger.info('Limited stream manager initialized', {
+                remotePeer: this.limitedConfig.p2pConnection.remotePeer.toString(),
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize limited stream manager:', error);
+            throw new oError(oErrorCodes.INTERNAL_ERROR, `Failed to initialize limited stream manager: ${error.message}`);
+        }
+    }
+    /**
+     * Creates and initializes the dedicated reader stream
+     */
+    async createReaderStream() {
+        try {
+            // Create reader stream using parent's createStream method
+            this.readerStream = await this.createStream(this.limitedConfig.protocol, this.limitedConfig.remoteAddress, {});
+            // Send self-identification message
+            await this.sendStreamInitMessage(this.readerStream.p2pStream);
+            // Start background reader loop
+            await this.startReaderLoop();
+            this.eventEmitter.emit(StreamManagerEvent.ReaderStarted, {
+                streamId: this.readerStream.p2pStream.id,
+            });
+            this.logger.info('Reader stream created and started', {
+                streamId: this.readerStream.p2pStream.id,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to create reader stream:', error);
+            throw error;
+        }
+    }
+    /**
+     * Sends stream initialization message to identify this as a reader stream
+     */
+    async sendStreamInitMessage(stream) {
+        const initMessage = {
+            type: 'stream-init',
+            role: 'reader',
+            timestamp: Date.now(),
+            connectionId: this.limitedConfig.p2pConnection.id,
+        };
+        const messageBytes = new TextEncoder().encode(JSON.stringify(initMessage));
+        await this.sendLengthPrefixed(stream, messageBytes, {});
+        this.logger.debug('Sent stream-init message', {
+            streamId: stream.id,
+            role: 'reader',
+        });
+    }
+    /**
+     * Starts the background reader loop
+     * Continuously listens for incoming requests on the reader stream
+     */
+    async startReaderLoop() {
+        if (!this.readerStream || this.isReaderLoopActive) {
+            return;
+        }
+        this.isReaderLoopActive = true;
+        this.readerLoopAbortController = new AbortController();
+        // Start background task (don't await)
+        this.runReaderLoop().catch((error) => {
+            this.logger.error('Reader loop failed:', error);
+            this.isReaderLoopActive = false;
+        });
+    }
+    /**
+     * Background reader loop implementation
+     */
+    async runReaderLoop() {
+        if (!this.readerStream) {
+            return;
+        }
+        const stream = this.readerStream.p2pStream;
+        try {
+            // Continuous read loop using parent's handleIncomingStream
+            // This will process all incoming requests on the reader stream
+            await this.handleIncomingStream(stream, this.limitedConfig.p2pConnection);
+        }
+        catch (error) {
+            if (!this.closing) {
+                this.logger.error('Reader loop error, attempting recovery:', error);
+                await this.recoverReaderStream();
+            }
+        }
+        finally {
+            this.isReaderLoopActive = false;
+        }
+    }
+    /**
+     * Attempts to recover the reader stream (single retry)
+     */
+    async recoverReaderStream() {
+        try {
+            this.logger.info('Attempting to recover reader stream...');
+            // Close old stream if it exists
+            if (this.readerStream) {
+                try {
+                    await this.readerStream.p2pStream.close();
+                }
+                catch (e) {
+                    // Ignore close errors
+                }
+                this.readerStream = undefined;
+            }
+            // Try to recreate
+            await this.createReaderStream();
+            this.eventEmitter.emit(StreamManagerEvent.ReaderRecovered, {
+                failureCount: 1,
+            });
+            this.logger.info('Reader stream recovered successfully');
+        }
+        catch (error) {
+            this.logger.error('Reader stream recovery failed:', error);
+            this.eventEmitter.emit(StreamManagerEvent.ReaderFailed, {
+                error: error.message,
+                failureCount: 1,
+            });
+        }
+    }
+    /**
+     * Override getOrCreateStream to reuse outbound streams
+     * Does not create new stream for every request
+     * Auto-initializes on first use
+     */
+    async getOrCreateStream(protocol, remoteAddress, config = {}) {
+        // Auto-initialize on first use
+        if (!this.isInitialized) {
+            await this.initialize();
+        }
+        // Check if we have an existing outbound stream that's still valid
+        if (this.outboundStream &&
+            this.outboundStream.p2pStream.status === 'open' &&
+            this.outboundStream.p2pStream.writeStatus === 'writable') {
+            this.logger.debug('Reusing existing outbound stream', {
+                streamId: this.outboundStream.p2pStream.id,
+            });
+            return this.outboundStream;
+        }
+        // Create new outbound stream if none exists or current is invalid
+        this.logger.debug('Creating new outbound stream (no valid stream to reuse)');
+        this.outboundStream = await this.createStream(protocol, remoteAddress, config);
+        return this.outboundStream;
+    }
+    /**
+     * Override releaseStream to NOT close the stream
+     * Keep streams open for reuse
+     */
+    async releaseStream(streamId) {
+        // Don't close the stream - just log that we're keeping it open
+        this.logger.debug('Keeping stream open for reuse', { streamId });
+        // Do NOT call super.releaseStream() as that would close the stream
+    }
+    /**
+     * Close the stream manager and cleanup all resources
+     */
+    async close() {
+        if (this.closing) {
+            return;
+        }
+        this.closing = true;
+        this.logger.info('Closing limited stream manager');
+        // Stop reader loop
+        if (this.readerLoopAbortController) {
+            this.readerLoopAbortController.abort();
+        }
+        this.isReaderLoopActive = false;
+        // Close reader stream
+        if (this.readerStream) {
+            try {
+                await this.readerStream.p2pStream.close();
+            }
+            catch (error) {
+                this.logger.warn('Error closing reader stream:', error);
+            }
+            this.readerStream = undefined;
+        }
+        // Close outbound stream
+        if (this.outboundStream) {
+            try {
+                await this.outboundStream.p2pStream.close();
+            }
+            catch (error) {
+                this.logger.warn('Error closing outbound stream:', error);
+            }
+            this.outboundStream = undefined;
+        }
+        this.eventEmitter.emit(StreamManagerEvent.ManagerClosed, undefined);
+    }
+}

package/dist/test/bidirectional-communication.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bidirectional-communication.spec.d.ts.map

package/dist/test/bidirectional-communication.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bidirectional-communication.spec.d.ts","sourceRoot":"","sources":["../../test/bidirectional-communication.spec.ts"],"names":[],"mappings":""}