@olane/o-client-limited 0.7.55 → 0.7.57

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

@@ -1,4 +1,2 @@
-export * from './o-limited-connection.js';
 export * from './o-limited-connection-manager.js';
-export * from './o-limited.stream-manager.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC"}

package/dist/src/connection/index.js

@@ -1,3 +1 @@
-export * from './o-limited-connection.js';
 export * from './o-limited-connection-manager.js';
-export * from './o-limited.stream-manager.js';

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

@@ -1 +1 @@
-{"version":3,"file":"o-limited-connection-manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-limited-connection-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAI9E,qBAAa,yBAA0B,SAAQ,sBAAsB;IACnE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;CAClC"}
+{"version":3,"file":"o-limited-connection-manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-limited-connection-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAE9E,qBAAa,yBAA0B,SAAQ,sBAAsB;IACnE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;CAClC"}

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

@@ -1,8 +1,6 @@
-import { oNodeConnection, oNodeConnectionConfig, oNodeTool } from '@olane/o-node';
+import { oNodeTool } from '@olane/o-node';
 import { oNodeConfig } from '@olane/o-node';
 export declare class oLimitedTool extends oNodeTool {
     constructor(config: oNodeConfig);
-    connect(config: oNodeConnectionConfig): Promise<oNodeConnection>;
-    initConnectionManager(): Promise<void>;
 }
 //# sourceMappingURL=o-limited.tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"o-limited.tool.d.ts","sourceRoot":"","sources":["../../src/o-limited.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,SAAS,EACV,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,qBAAa,YAAa,SAAQ,SAAS;gBAC7B,MAAM,EAAE,WAAW;IAWzB,OAAO,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,eAAe,CAAC;IAkBhE,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ7C"}
+{"version":3,"file":"o-limited.tool.d.ts","sourceRoot":"","sources":["../../src/o-limited.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,SAAS,EACV,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,qBAAa,YAAa,SAAQ,SAAS;gBAC7B,MAAM,EAAE,WAAW;CAqChC"}

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

@@ -1,5 +1,4 @@
 import { oNodeTool, } from '@olane/o-node';
-import { oLimitedConnectionManager } from './connection/o-limited-connection-manager.js';
 export class oLimitedTool extends oNodeTool {
     constructor(config) {
         super({
@@ -11,26 +10,4 @@ export class oLimitedTool extends oNodeTool {
             runOnLimitedConnection: true,
         });
     }
-    async connect(config) {
-        this.handleProtocol(config.nextHopAddress).catch((error) => {
-            this.logger.error('Error handling protocol:', error);
-        });
-        // Inject requestHandler to enable bidirectional stream processing
-        // This allows incoming router requests to be processed through the tool's execute method
-        // The StreamPoolManager (in oLimitedConnection) will use this handler for the dedicated reader
-        const configWithHandler = {
-            ...config,
-            requestHandler: this.execute.bind(this),
-        };
-        const connection = await super.connect(configWithHandler);
-        return connection;
-    }
-    async initConnectionManager() {
-        this.connectionManager = new oLimitedConnectionManager({
-            p2pNode: this.p2pNode,
-            defaultReadTimeoutMs: this.config.connectionTimeouts?.readTimeoutMs,
-            defaultDrainTimeoutMs: this.config.connectionTimeouts?.drainTimeoutMs,
-            runOnLimitedConnection: true,
-        });
-    }
 }

package/dist/test/bidirectional-communication.spec.js

@@ -55,6 +55,7 @@ describe('Bidirectional Communication', () => {
     //     expect(receiver.receivedRequests).to.have.lengthOf(5);
     //   });
     // });
+    // TODO: verify that the read only caller stream can receive requests from receiver
     describe('Receiver → Caller', () => {
         it('should fail when receiver tries to dial limited caller directly', async () => {
             caller = await env.createNode(LimitedTestTool, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-client-limited",
-  "version": "0.7.55",
+  "version": "0.7.57",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -54,13 +54,13 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.55",
-    "@olane/o-core": "0.7.55",
-    "@olane/o-node": "0.7.55",
-    "@olane/o-protocol": "0.7.55",
-    "@olane/o-tool": "0.7.55",
+    "@olane/o-config": "0.7.57",
+    "@olane/o-core": "0.7.57",
+    "@olane/o-node": "0.7.57",
+    "@olane/o-protocol": "0.7.57",
+    "@olane/o-tool": "0.7.57",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0"
   },
-  "gitHead": "f7d02a1ecfb0d28b7b1009a7c3eb6d0d4863adc2"
+  "gitHead": "2528b14a811472157ca94927ef6f3b39ccd31886"
 }

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

@@ -1,43 +0,0 @@
-import { oNodeConnection } from '@olane/o-node';
-import type { oNodeConnectionConfig } from '@olane/o-node';
-import { oLimitedStreamManager } from './o-limited.stream-manager.js';
-import type { oRequest, oResponse } from '@olane/o-core';
-/**
- * oLimitedConnection extends oNodeConnection with dual persistent streams for limited connections.
- *
- * This is optimized for limited connections where the caller cannot be dialed
- * (browser clients, mobile clients, resource-constrained environments).
- *
- * Stream Architecture:
- * - 1 dedicated reader stream for receiving ALL inbound data from receiver
- *   (receiver-initiated requests AND responses to limited client's outbound requests)
- * - 1 dedicated writer stream for sending ALL outbound data to receiver
- *   (responses to receiver's requests AND limited client's outbound requests)
- * - No ephemeral streams - all communication uses persistent streams for efficiency
- *
- * Features:
- * - Automatic reader/writer stream creation and maintenance
- * - Single retry on reader failure
- * - Stream reuse for all outbound requests (no ephemeral streams)
- * - Response routing via _streamId and _responseConnectionId in request params
- * - Event emission for monitoring (reader-started, writer-started, reader-failed, reader-recovered)
- *
- * Default Behavior:
- * - Uses 'reuse' stream policy by default
- * - Automatically initializes persistent streams on connection start
- */
-export declare class oLimitedConnection extends oNodeConnection {
-    streamManager: oLimitedStreamManager;
-    constructor(config: oNodeConnectionConfig);
-    /**
-     * Override transmit to inject response routing params
-     * Adds _streamId and _responseConnectionId to enable receiver to route responses
-     * to the persistent reader stream
-     */
-    transmit(request: oRequest): Promise<oResponse>;
-    /**
-     * Override close to cleanup stream manager properly
-     */
-    close(): Promise<void>;
-}
-//# sourceMappingURL=o-limited-connection.d.ts.map

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

@@ -1 +0,0 @@
-{"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;AAEvC,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,kBAAmB,SAAQ,eAAe;IAC7C,aAAa,EAAE,qBAAqB,CAAC;gBAEjC,MAAM,EAAE,qBAAqB;IAsCzC;;;;OAIG;IACG,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;IA6BrD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAK7B"}

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

@@ -1,95 +0,0 @@
-import { oNodeConnection } from '@olane/o-node';
-import { oLimitedStreamManager, } from './o-limited.stream-manager.js';
-import { StreamManagerEvent } from '@olane/o-node';
-/**
- * oLimitedConnection extends oNodeConnection with dual persistent streams for limited connections.
- *
- * This is optimized for limited connections where the caller cannot be dialed
- * (browser clients, mobile clients, resource-constrained environments).
- *
- * Stream Architecture:
- * - 1 dedicated reader stream for receiving ALL inbound data from receiver
- *   (receiver-initiated requests AND responses to limited client's outbound requests)
- * - 1 dedicated writer stream for sending ALL outbound data to receiver
- *   (responses to receiver's requests AND limited client's outbound requests)
- * - No ephemeral streams - all communication uses persistent streams for efficiency
- *
- * Features:
- * - Automatic reader/writer stream creation and maintenance
- * - Single retry on reader failure
- * - Stream reuse for all outbound requests (no ephemeral streams)
- * - Response routing via _streamId and _responseConnectionId in request params
- * - Event emission for monitoring (reader-started, writer-started, reader-failed, reader-recovered)
- *
- * Default Behavior:
- * - Uses 'reuse' stream policy by default
- * - Automatically initializes persistent streams on connection start
- */
-export class oLimitedConnection extends oNodeConnection {
-    constructor(config) {
-        const reusePolicy = config.reusePolicy ?? 'reuse';
-        super({
-            ...config,
-            reusePolicy,
-        });
-        // Replace the base streamManager with our limited version
-        const protocol = this.nextHopAddress.protocol + (reusePolicy === 'reuse' ? '/reuse' : '');
-        const limitedConfig = {
-            p2pConnection: this.p2pConnection,
-            protocol,
-            remoteAddress: this.nextHopAddress,
-            requestHandler: config.requestHandler,
-        };
-        this.streamManager = new oLimitedStreamManager(limitedConfig);
-        // Set up event listeners for monitoring
-        this.streamManager.on(StreamManagerEvent.ReaderStarted, (data) => {
-            this.logger.info('Reader stream started', data);
-        });
-        this.streamManager.on(StreamManagerEvent.WriterStarted, (data) => {
-            this.logger.info('Writer stream started', data);
-        });
-        this.streamManager.on(StreamManagerEvent.ReaderFailed, (data) => {
-            this.logger.warn('Reader stream failed', data);
-        });
-        this.streamManager.on(StreamManagerEvent.ReaderRecovered, (data) => {
-            this.logger.info('Reader stream recovered', data);
-        });
-    }
-    /**
-     * Override transmit to inject response routing params
-     * Adds _streamId and _responseConnectionId to enable receiver to route responses
-     * to the persistent reader stream
-     */
-    async transmit(request) {
-        // Wait for stream manager initialization to ensure streams are available
-        if (!this.streamManager.isInitialized) {
-            await this.streamManager.initialize();
-        }
-        // Inject response routing params to route responses to reader stream
-        // Writer stream sends the request, reader stream receives the response
-        if (this.streamManager.readerStream) {
-            request.params._streamId = this.streamManager.readerStream.p2pStream.id;
-            request.params._responseConnectionId = this.p2pConnection.id;
-            if (request.params.payload) {
-                request.params.payload.params._streamId = request.params._streamId;
-            }
-            this.logger.debug('Injected response routing params', {
-                streamId: request.params._streamId,
-                responseConnectionId: request.params._responseConnectionId,
-            });
-        }
-        else {
-            this.logger.warn('Reader stream not available, response routing params not injected');
-        }
-        // Call parent transmit with modified request
-        return await super.transmit(request);
-    }
-    /**
-     * Override close to cleanup stream manager properly
-     */
-    async close() {
-        this.logger.debug('Closing limited connection');
-        await this.streamManager.close();
-        await super.close();
-    }
-}

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

@@ -1,96 +0,0 @@
-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 all inbound data from receiver
- *   (both receiver-initiated requests and responses to limited client's outbound requests)
- * - Maintains dedicated writer stream for sending all outbound data to receiver
- *   (both responses to receiver's requests and limited client's outbound requests)
- * - No ephemeral streams - all communication uses persistent streams
- * - Single retry on reader failure
- * - No health checks (error handling on use)
- */
-export declare class oLimitedStreamManager extends oNodeStreamManager {
-    readerStream?: oNodeStream;
-    writerStream?: oNodeStream;
-    private isReaderLoopActive;
-    private readerLoopAbortController?;
-    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;
-    /**
-     * Creates and initializes the dedicated writer stream
-     */
-    private createWriterStream;
-    /**
-     * Sends stream initialization message to identify the stream role
-     * Waits for acknowledgment from receiver before proceeding
-     */
-    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 use persistent writer stream for outbound requests
-     * This eliminates ephemeral stream creation for limited connections
-     * Auto-initializes on first use
-     */
-    getOrCreateStream(protocol: string, remoteAddress: any, config?: StreamHandlerConfig): Promise<oNodeStream>;
-    /**
-     * Override releaseStream to protect persistent streams from being closed
-     * Persistent streams (reader/writer) should never be released via this method
-     * Only closes streams that are not the dedicated reader or writer streams
-     */
-    releaseStream(streamId: string): Promise<void>;
-    /**
-     * Override getStreamById to check persistent streams first
-     * Provides access to reader and writer streams by ID
-     *
-     * @param streamId - The ID of the stream to retrieve
-     * @returns The libp2p Stream or undefined if not found
-     */
-    getStreamById(streamId: string): Stream | undefined;
-    /**
-     * 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

@@ -1 +0,0 @@
-{"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,EAKpB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGzD;;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;;;;;;;;;;GAUG;AACH,qBAAa,qBAAsB,SAAQ,kBAAkB;IACpD,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,YAAY,CAAC,EAAE,WAAW,CAAC;IAClC,OAAO,CAAC,kBAAkB,CAAkB;IAC5C,OAAO,CAAC,yBAAyB,CAAC,CAAkB;IACpD,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,OAAO,CAAkB;gBAErB,MAAM,EAAE,2BAA2B;IAK/C;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAsDjC;;OAEG;YACW,kBAAkB;IA4BhC;;OAEG;YACW,kBAAkB;IAyBhC;;;OAGG;YACW,qBAAqB;IA0EnC;;;OAGG;YACW,eAAe;IAe7B;;OAEG;YACW,aAAa;IAqB3B;;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;IAqBvB;;;;OAIG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAepD;;;;;;OAMG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAcnD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAqC7B"}

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

@@ -1,319 +0,0 @@
-import { oError, oErrorCodes } from '@olane/o-core';
-import { oNodeStreamManager, StreamManagerEvent, isStreamInitAckMessage, } from '@olane/o-node';
-import { lpStream } from '@olane/o-config';
-/**
- * Limited Stream Manager handles stream lifecycle for limited connections
- * Features:
- * - Maintains dedicated reader stream for receiving all inbound data from receiver
- *   (both receiver-initiated requests and responses to limited client's outbound requests)
- * - Maintains dedicated writer stream for sending all outbound data to receiver
- *   (both responses to receiver's requests and limited client's outbound requests)
- * - No ephemeral streams - all communication uses persistent streams
- * - 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 and writer streams
-            await this.createReaderStream();
-            await this.createWriterStream();
-            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, 'reader');
-            // 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;
-        }
-    }
-    /**
-     * Creates and initializes the dedicated writer stream
-     */
-    async createWriterStream() {
-        try {
-            // Create writer stream using parent's createStream method
-            this.writerStream = await this.createStream(this.limitedConfig.protocol, this.limitedConfig.remoteAddress, {});
-            // Send self-identification message
-            await this.sendStreamInitMessage(this.writerStream.p2pStream, 'writer');
-            this.eventEmitter.emit(StreamManagerEvent.WriterStarted, {
-                streamId: this.writerStream.p2pStream.id,
-            });
-            this.logger.info('Writer stream created', {
-                streamId: this.writerStream.p2pStream.id,
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to create writer stream:', error);
-            throw error;
-        }
-    }
-    /**
-     * Sends stream initialization message to identify the stream role
-     * Waits for acknowledgment from receiver before proceeding
-     */
-    async sendStreamInitMessage(stream, role) {
-        const initMessage = {
-            type: 'stream-init',
-            role,
-            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, waiting for ack', {
-            streamId: stream.id,
-            role,
-        });
-        // Wait for acknowledgment with timeout
-        const ackTimeout = 5000; // 5 seconds
-        const abortController = new AbortController();
-        const timeoutId = setTimeout(() => {
-            abortController.abort();
-        }, ackTimeout);
-        try {
-            const lp = lpStream(stream);
-            // Read acknowledgment message
-            const ackBytes = await lp.read({ signal: abortController.signal });
-            const ackDecoded = new TextDecoder().decode(ackBytes.subarray());
-            const ackMessage = this.extractAndParseJSON(ackDecoded);
-            // Validate acknowledgment
-            if (!isStreamInitAckMessage(ackMessage)) {
-                throw new oError(oErrorCodes.INTERNAL_ERROR, `Invalid stream-init-ack message received: ${JSON.stringify(ackMessage)}`);
-            }
-            if (ackMessage.status === 'error') {
-                throw new oError(oErrorCodes.INTERNAL_ERROR, `Stream initialization failed: ${ackMessage.error || 'Unknown error'}`);
-            }
-            if (ackMessage.role !== role) {
-                throw new oError(oErrorCodes.INTERNAL_ERROR, `Stream role mismatch: expected ${role}, got ${ackMessage.role}`);
-            }
-            this.logger.info('Received stream-init-ack', {
-                streamId: stream.id,
-                role,
-                ackStreamId: ackMessage.streamId,
-            });
-        }
-        catch (error) {
-            if (error.name === 'AbortError') {
-                throw new oError(oErrorCodes.TIMEOUT, `Stream initialization acknowledgment timeout after ${ackTimeout}ms`);
-            }
-            throw error;
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * 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 use persistent writer stream for outbound requests
-     * This eliminates ephemeral stream creation for limited connections
-     * Auto-initializes on first use
-     */
-    async getOrCreateStream(protocol, remoteAddress, config = {}) {
-        // Auto-initialize on first use
-        if (!this.isInitialized) {
-            await this.initialize();
-        }
-        // Use persistent writer stream for all outbound requests
-        if (this.writerStream && this.writerStream.p2pStream.status === 'open') {
-            this.logger.debug('Reusing writer stream for outbound request', {
-                streamId: this.writerStream.p2pStream.id,
-            });
-            return this.writerStream;
-        }
-        // Writer stream should always be available after initialization
-        throw new oError(oErrorCodes.INTERNAL_ERROR, 'Writer stream not available or not open');
-    }
-    /**
-     * Override releaseStream to protect persistent streams from being closed
-     * Persistent streams (reader/writer) should never be released via this method
-     * Only closes streams that are not the dedicated reader or writer streams
-     */
-    async releaseStream(streamId) {
-        // Check if this is a persistent stream - don't close those
-        if ((this.readerStream && this.readerStream.p2pStream.id === streamId) ||
-            (this.writerStream && this.writerStream.p2pStream.id === streamId)) {
-            this.logger.debug('Skipping release of persistent stream', { streamId });
-            return;
-        }
-        // Close any other streams (should not occur in normal operation)
-        this.logger.debug('Releasing non-persistent stream', { streamId });
-        await super.releaseStream(streamId);
-    }
-    /**
-     * Override getStreamById to check persistent streams first
-     * Provides access to reader and writer streams by ID
-     *
-     * @param streamId - The ID of the stream to retrieve
-     * @returns The libp2p Stream or undefined if not found
-     */
-    getStreamById(streamId) {
-        // Check our persistent streams first
-        if (this.writerStream?.p2pStream.id === streamId) {
-            return this.writerStream.p2pStream;
-        }
-        if (this.readerStream?.p2pStream.id === streamId) {
-            return this.readerStream.p2pStream;
-        }
-        // Fall back to parent implementation (checks tracked ephemeral streams)
-        return super.getStreamById(streamId);
-    }
-    /**
-     * 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 writer stream
-        if (this.writerStream) {
-            try {
-                await this.writerStream.p2pStream.close();
-            }
-            catch (error) {
-                this.logger.warn('Error closing writer stream:', error);
-            }
-            this.writerStream = undefined;
-        }
-        this.eventEmitter.emit(StreamManagerEvent.ManagerClosed, undefined);
-    }
-}