@olane/o-node 0.7.50 → 0.7.52

package/dist/test/stream-pool-manager.spec.js

@@ -0,0 +1,424 @@
+"use strict";
+// import { expect } from 'chai';
+// import { StreamPoolManager } from '../src/connection/stream-pool-manager.js';
+// import { NetworkBuilder, NetworkTopologies } from './helpers/network-builder.js';
+// import { createConnectionSpy } from './helpers/connection-spy.js';
+// import { StreamPoolEvent } from '../src/connection/stream-pool-manager.events.js';
+// import { oNodeConnectionStream } from '../src/connection/o-node-connection-stream.js';
+// import type { TestTool } from './helpers/network-builder.js';
+// import type { Connection } from '@olane/o-config';
+// /**
+//  * Integration tests for StreamPoolManager using real libp2p nodes and connections
+//  */
+// describe('StreamPoolManager Integration Tests', () => {
+//   let builder: NetworkBuilder;
+//   let leader: TestTool;
+//   let child: TestTool;
+//   let p2pConnection: Connection;
+//   let poolManager: StreamPoolManager | undefined;
+//   /**
+//    * Helper to create a real libp2p connection between two nodes
+//    */
+//   async function getP2pConnection(): Promise<Connection> {
+//     // Make a call to establish connection
+//     await leader.use(child.address, {
+//       method: 'echo',
+//       params: { message: 'establish connection' }
+//     });
+//     // Get the connection
+//     const connections = leader.p2pNode.getConnections();
+//     const connection = connections.find(
+//       conn => conn.remotePeer.toString() === child.peerId.toString()
+//     );
+//     if (!connection) {
+//       throw new Error('Failed to establish connection between nodes');
+//     }
+//     return connection;
+//   }
+//   /**
+//    * Helper to create a StreamPoolManager with real connection
+//    */
+//   async function createStreamPoolManager(config?: Partial<any>): Promise<StreamPoolManager> {
+//     const manager = new StreamPoolManager({
+//       poolSize: config?.poolSize || 10,
+//       readerStreamIndex: config?.readerStreamIndex ?? 0,
+//       streamHandler: {
+//         handleIncomingStream: config?.streamHandler?.handleIncomingStream || (async (stream: any) => {
+//           // Default handler: just keep stream alive
+//           return new Promise(() => {}); // Never resolves (keeps reader active)
+//         })
+//       },
+//       p2pConnection,
+//       requestHandler: config?.requestHandler,
+//       createStream: async () => {
+//         // Create a real libp2p stream
+//         const stream = await p2pConnection.newStream('/o-protocol/1.0.0');
+//         return new oNodeConnectionStream({
+//           p2pStream: stream,
+//           streamType: 'request-response',
+//           readTimeoutMs: 30000,
+//           drainTimeoutMs: 5000,
+//         });
+//       },
+//       ...config,
+//     });
+//     return manager;
+//   }
+//   beforeEach(async () => {
+//     // Create real node network
+//     builder = await NetworkTopologies.twoNode();
+//     leader = builder.getNode('o://leader')!;
+//     child = builder.getNode('o://child')!;
+//     // Establish real p2p connection
+//     p2pConnection = await getP2pConnection();
+//   });
+//   afterEach(async () => {
+//     if (poolManager) {
+//       await poolManager.close();
+//       poolManager = undefined;
+//     }
+//     await builder.cleanup();
+//   });
+//   describe('Initialization', () => {
+//     it('should initialize pool with default size of 10 streams', async () => {
+//       poolManager = await createStreamPoolManager();
+//       await poolManager.initialize();
+//       const stats = poolManager.getStats();
+//       expect(stats.totalStreams).to.equal(10);
+//     });
+//     it('should initialize pool with custom size', async () => {
+//       poolManager = await createStreamPoolManager({ poolSize: 5 });
+//       await poolManager.initialize();
+//       const stats = poolManager.getStats();
+//       expect(stats.totalStreams).to.equal(5);
+//     });
+//     it('should throw error when pool size is less than 2', async () => {
+//       expect(() => {
+//         poolManager = new StreamPoolManager({
+//           poolSize: 1,
+//           readerStreamIndex: 0,
+//           streamHandler: {} as any,
+//           p2pConnection,
+//           createStream: async () => ({} as any),
+//         });
+//       }).to.throw('Pool size must be at least 2');
+//     });
+//     it('should start dedicated reader automatically', async () => {
+//       let readerStarted = false;
+//       poolManager = await createStreamPoolManager();
+//       poolManager.on(StreamPoolEvent.ReaderStarted, () => {
+//         readerStarted = true;
+//       });
+//       await poolManager.initialize();
+//       // Wait a bit for reader to start
+//       await new Promise(resolve => setTimeout(resolve, 100));
+//       expect(readerStarted).to.be.true;
+//     });
+//     it('should emit pool-initialized event', async () => {
+//       let eventData: any;
+//       poolManager = await createStreamPoolManager();
+//       poolManager.on(StreamPoolEvent.PoolInitialized, (data: any) => {
+//         eventData = data;
+//       });
+//       await poolManager.initialize();
+//       expect(eventData).to.exist;
+//       expect(eventData.poolSize).to.equal(10);
+//     });
+//     it('should be idempotent (calling initialize twice is safe)', async () => {
+//       poolManager = await createStreamPoolManager();
+//       await poolManager.initialize();
+//       const statsFirst = poolManager.getStats();
+//       await poolManager.initialize();
+//       const statsSecond = poolManager.getStats();
+//       expect(statsFirst.totalStreams).to.equal(statsSecond.totalStreams);
+//       expect(statsSecond.totalStreams).to.equal(10);
+//     });
+//     it('should assign correct stream types', async () => {
+//       poolManager = await createStreamPoolManager({ poolSize: 3 });
+//       await poolManager.initialize();
+//       const stats = poolManager.getStats();
+//       expect(stats.requestResponseStreams).to.equal(2); // All except stream[0]
+//     });
+//   });
+//   describe('Round-Robin Stream Selection', () => {
+//     beforeEach(async () => {
+//       poolManager = await createStreamPoolManager({ poolSize: 5 });
+//       await poolManager.initialize();
+//     });
+//     it('should return streams in round-robin order', async () => {
+//       const stream1 = await poolManager!.getStream();
+//       const stream2 = await poolManager!.getStream();
+//       const stream3 = await poolManager!.getStream();
+//       const stream4 = await poolManager!.getStream();
+//       // Should cycle through streams[1-4]
+//       expect(stream1.p2pStream.id).to.not.equal(stream2.p2pStream.id);
+//       expect(stream2.p2pStream.id).to.not.equal(stream3.p2pStream.id);
+//       expect(stream3.p2pStream.id).to.not.equal(stream4.p2pStream.id);
+//     });
+//     it('should wrap around after last stream', async () => {
+//       // Pool size is 5, so we have streams 1-4 for request-response (4 streams total)
+//       const firstRound: any[] = [];
+//       for (let i = 0; i < 4; i++) {
+//         firstRound.push(await poolManager!.getStream());
+//       }
+//       const nextStream = await poolManager!.getStream();
+//       // Should wrap back to first request-response stream
+//       expect(nextStream.p2pStream.id).to.equal(firstRound[0].p2pStream.id);
+//     });
+//     it('should throw error when getStream called before initialize', async () => {
+//       const uninitializedManager = await createStreamPoolManager();
+//       try {
+//         await uninitializedManager.getStream();
+//         expect.fail('Should have thrown error');
+//       } catch (error: any) {
+//         expect(error.message).to.include('not initialized');
+//       } finally {
+//         await uninitializedManager.close();
+//       }
+//     });
+//   });
+//   describe('Stream Validation and Replacement', () => {
+//     it('should detect invalid stream and replace it', async () => {
+//       poolManager = await createStreamPoolManager({ poolSize: 3 });
+//       await poolManager.initialize();
+//       // Get first stream and forcibly close it
+//       const firstStream = await poolManager.getStream();
+//       await firstStream.p2pStream.close();
+//       // Wait for stream to be marked invalid
+//       await new Promise(resolve => setTimeout(resolve, 100));
+//       // Next getStream should detect and replace the invalid stream
+//       const nextStream = await poolManager.getStream();
+//       expect(nextStream.isValid).to.be.true;
+//     });
+//     it('should emit stream-replaced event when replacing stream', async () => {
+//       let replacedEventFired = false;
+//       poolManager = await createStreamPoolManager({ poolSize: 3 });
+//       poolManager.on(StreamPoolEvent.StreamReplaced, () => {
+//         replacedEventFired = true;
+//       });
+//       await poolManager.initialize();
+//       // Close a request-response stream
+//       const stream = await poolManager.getStream();
+//       await stream.p2pStream.close();
+//       // Wait for detection and replacement
+//       await new Promise(resolve => setTimeout(resolve, 100));
+//       // Trigger getStream to force validation
+//       await poolManager.getStream();
+//       expect(replacedEventFired).to.be.true;
+//     });
+//   });
+//   describe('Dedicated Reader Recovery', () => {
+//     it('should detect reader failure and trigger recovery', async () => {
+//       let failureDetected = false;
+//       const mockStreamHandler = {
+//         handleIncomingStream: async () => {
+//           failureDetected = true;
+//           throw new Error('Reader stream failed');
+//         },
+//       };
+//       poolManager = await createStreamPoolManager({
+//         poolSize: 3,
+//         streamHandler: mockStreamHandler,
+//       });
+//       poolManager.on(StreamPoolEvent.ReaderFailed, () => {
+//         failureDetected = true;
+//       });
+//       await poolManager.initialize();
+//       // Wait for reader failure event
+//       await new Promise(resolve => setTimeout(resolve, 500));
+//       const stats = poolManager.getStats();
+//       expect(stats.failureCount).to.be.greaterThan(0);
+//     });
+//     it('should emit reader-recovered event on successful recovery', async () => {
+//       let callCount = 0;
+//       let recoveryEventFired = false;
+//       const mockStreamHandler = {
+//         handleIncomingStream: async () => {
+//           callCount++;
+//           if (callCount === 1) {
+//             throw new Error('Initial failure');
+//           }
+//           // Second call succeeds (recovery)
+//           return new Promise(() => {}); // Never resolves (keeps reader active)
+//         },
+//       };
+//       poolManager = await createStreamPoolManager({
+//         poolSize: 3,
+//         streamHandler: mockStreamHandler,
+//       });
+//       poolManager.on(StreamPoolEvent.ReaderRecovered, () => {
+//         recoveryEventFired = true;
+//       });
+//       await poolManager.initialize();
+//       // Wait for recovery
+//       await new Promise(resolve => setTimeout(resolve, 1000));
+//       expect(recoveryEventFired).to.be.true;
+//     });
+//     it('should not attempt recovery during close', async () => {
+//       let recoveryAttempted = false;
+//       const mockStreamHandler = {
+//         handleIncomingStream: async () => {
+//           await new Promise((resolve) => setTimeout(resolve, 50));
+//           throw new Error('Reader failed');
+//         },
+//       };
+//       poolManager = await createStreamPoolManager({
+//         poolSize: 3,
+//         streamHandler: mockStreamHandler,
+//       });
+//       poolManager.on(StreamPoolEvent.ReaderRecovered, () => {
+//         recoveryAttempted = true;
+//       });
+//       await poolManager.initialize();
+//       // Close immediately
+//       await poolManager.close();
+//       // Wait a bit
+//       await new Promise((resolve) => setTimeout(resolve, 200));
+//       // Should not have attempted recovery
+//       expect(recoveryAttempted).to.be.false;
+//     });
+//   });
+//   describe('Statistics', () => {
+//     it('should return accurate totalStreams count', async () => {
+//       poolManager = await createStreamPoolManager({ poolSize: 7 });
+//       await poolManager.initialize();
+//       const stats = poolManager.getStats();
+//       expect(stats.totalStreams).to.equal(7);
+//     });
+//     it('should return accurate healthyStreams count', async () => {
+//       poolManager = await createStreamPoolManager({ poolSize: 5 });
+//       await poolManager.initialize();
+//       const stats = poolManager.getStats();
+//       expect(stats.healthyStreams).to.be.greaterThan(0);
+//     });
+//     it('should report reader health status', async () => {
+//       poolManager = await createStreamPoolManager({ poolSize: 3 });
+//       await poolManager.initialize();
+//       const stats = poolManager.getStats();
+//       expect(stats.readerStreamHealth).to.be.oneOf([
+//         'healthy',
+//         'unhealthy',
+//         'not-initialized',
+//       ]);
+//     });
+//     it('should track request-response stream count', async () => {
+//       poolManager = await createStreamPoolManager({ poolSize: 6 });
+//       await poolManager.initialize();
+//       const stats = poolManager.getStats();
+//       expect(stats.requestResponseStreams).to.equal(5); // 6 total - 1 reader
+//     });
+//     it('should increment failureCount on reader failures', async () => {
+//       let callCount = 0;
+//       const mockStreamHandler = {
+//         handleIncomingStream: async () => {
+//           callCount++;
+//           if (callCount <= 2) {
+//             throw new Error('Failure');
+//           }
+//           return new Promise(() => {}); // Then succeed
+//         },
+//       };
+//       poolManager = await createStreamPoolManager({
+//         poolSize: 3,
+//         streamHandler: mockStreamHandler,
+//       });
+//       await poolManager.initialize();
+//       // Wait for failures
+//       await new Promise(resolve => setTimeout(resolve, 1000));
+//       const stats = poolManager.getStats();
+//       expect(stats.failureCount).to.be.at.least(1);
+//     });
+//   });
+//   describe('Event Emission', () => {
+//     it('should emit all lifecycle events with correct data', async () => {
+//       let poolInitialized = false;
+//       let readerStarted = false;
+//       let poolClosed = false;
+//       poolManager = await createStreamPoolManager({ poolSize: 3 });
+//       poolManager.on(StreamPoolEvent.PoolInitialized, () => {
+//         poolInitialized = true;
+//       });
+//       poolManager.on(StreamPoolEvent.ReaderStarted, () => {
+//         readerStarted = true;
+//       });
+//       poolManager.on(StreamPoolEvent.PoolClosed, () => {
+//         poolClosed = true;
+//       });
+//       await poolManager.initialize();
+//       await new Promise(resolve => setTimeout(resolve, 100));
+//       await poolManager.close();
+//       expect(poolInitialized).to.be.true;
+//       expect(readerStarted).to.be.true;
+//       expect(poolClosed).to.be.true;
+//     });
+//     it('should support multiple listeners for same event', async () => {
+//       let listener1Called = false;
+//       let listener2Called = false;
+//       poolManager = await createStreamPoolManager({ poolSize: 3 });
+//       poolManager.on(StreamPoolEvent.PoolInitialized, () => {
+//         listener1Called = true;
+//       });
+//       poolManager.on(StreamPoolEvent.PoolInitialized, () => {
+//         listener2Called = true;
+//       });
+//       await poolManager.initialize();
+//       expect(listener1Called).to.be.true;
+//       expect(listener2Called).to.be.true;
+//     });
+//     it('should allow removing event listeners', async () => {
+//       let callCount = 0;
+//       const listener = () => {
+//         callCount++;
+//       };
+//       poolManager = await createStreamPoolManager({ poolSize: 3 });
+//       poolManager.on(StreamPoolEvent.PoolInitialized, listener);
+//       await poolManager.initialize();
+//       expect(callCount).to.equal(1);
+//       poolManager.off(StreamPoolEvent.PoolInitialized, listener);
+//       // Verify off doesn't throw
+//       expect(() =>
+//         poolManager!.off(StreamPoolEvent.PoolInitialized, listener),
+//       ).to.not.throw();
+//     });
+//   });
+//   describe('Cleanup and Lifecycle', () => {
+//     it('should close all streams on close()', async () => {
+//       poolManager = await createStreamPoolManager({ poolSize: 5 });
+//       await poolManager.initialize();
+//       const statsBefore = poolManager.getStats();
+//       expect(statsBefore.totalStreams).to.equal(5);
+//       await poolManager.close();
+//       const statsAfter = poolManager.getStats();
+//       expect(statsAfter.totalStreams).to.equal(0);
+//     });
+//     it('should emit pool-closed event', async () => {
+//       let closedEventFired = false;
+//       poolManager = await createStreamPoolManager({ poolSize: 3 });
+//       poolManager.on(StreamPoolEvent.PoolClosed, () => {
+//         closedEventFired = true;
+//       });
+//       await poolManager.initialize();
+//       await poolManager.close();
+//       expect(closedEventFired).to.be.true;
+//     });
+//     it('should be safe to call close() multiple times', async () => {
+//       poolManager = await createStreamPoolManager({ poolSize: 3 });
+//       await poolManager.initialize();
+//       await poolManager.close();
+//       await poolManager.close(); // Should not throw
+//       const stats = poolManager.getStats();
+//       expect(stats.totalStreams).to.equal(0);
+//     });
+//     it('should prevent getStream() after close()', async () => {
+//       poolManager = await createStreamPoolManager({ poolSize: 3 });
+//       await poolManager.initialize();
+//       await poolManager.close();
+//       try {
+//         await poolManager.getStream();
+//         expect.fail('Should have thrown error');
+//       } catch (error: any) {
+//         expect(error.message).to.include('not initialized');
+//       }
+//     });
+//   });
+// });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.50",
+  "version": "0.7.52",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -40,7 +40,7 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.29.0",
-    "@olane/o-test": "0.7.50",
+    "@olane/o-test": "0.7.52",
     "@tsconfig/node20": "^20.1.6",
     "@types/jest": "^30.0.0",
     "@types/json5": "^2.2.0",
@@ -60,13 +60,13 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.50",
-    "@olane/o-core": "0.7.50",
-    "@olane/o-protocol": "0.7.50",
-    "@olane/o-tool": "0.7.50",
+    "@olane/o-config": "0.7.52",
+    "@olane/o-core": "0.7.52",
+    "@olane/o-protocol": "0.7.52",
+    "@olane/o-tool": "0.7.52",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0",
     "json5": "^2.2.3"
   },
-  "gitHead": "55f5464185ef16a164fa23dc46c0c08b317419a0"
+  "gitHead": "706ee0d5b546e96b6c05270b39035ee7e08dadbd"
 }

package/dist/src/connection/interfaces/o-node-connection-stream.config.d.ts

@@ -1,8 +0,0 @@
-import { oAddress } from '@olane/o-core';
-import { StreamReusePolicy } from '../stream-handler.config';
-export interface oNodeConnectionStreamConfig {
-    direction: 'inbound' | 'outbound';
-    reusePolicy: StreamReusePolicy;
-    remoteAddress: oAddress;
-}
-//# sourceMappingURL=o-node-connection-stream.config.d.ts.map

package/dist/src/connection/interfaces/o-node-connection-stream.config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"o-node-connection-stream.config.d.ts","sourceRoot":"","sources":["../../../../src/connection/interfaces/o-node-connection-stream.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,SAAS,GAAG,UAAU,CAAC;IAClC,WAAW,EAAE,iBAAiB,CAAC;IAC/B,aAAa,EAAE,QAAQ,CAAC;CACzB"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"o-node-connection-stream.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAuB,OAAO,EAAiB,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,2BAA2B,EAAE,MAAM,iDAAiD,CAAC;AAE9F;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,SAAQ,OAAO;aAI9B,SAAS,EAAE,MAAM;aACjB,MAAM,EAAE,2BAA2B;IAJrD,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAGhB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,2BAA2B;IAOrD,QAAQ;IA6BR;;;;;;;OAOG;IACH,IAAI,OAAO,IAAI,OAAO,CAMrB;IAED;;OAEG;IACH,IAAI,GAAG,IAAI,MAAM,CAEhB;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAgB7B"}

package/dist/src/connection/stream-handler.d.ts

@@ -1,102 +0,0 @@
-/// <reference types="node" />
-import type { Connection, Stream } from '@libp2p/interface';
-import { EventEmitter } from 'events';
-import { oRequest, oResponse, Logger } from '@olane/o-core';
-import type { oRouterRequest } from '@olane/o-core';
-import type { oConnection } from '@olane/o-core';
-import type { RunResult } from '@olane/o-tool';
-import type { StreamHandlerConfig } from './stream-handler.config.js';
-/**
- * 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 declare class StreamHandler {
-    private logger;
-    constructor(logger?: Logger);
-    /**
-     * Detects if a decoded message is a request
-     * Requests have a 'method' field and no 'result' field
-     */
-    isRequest(message: any): boolean;
-    /**
-     * Detects if a decoded message is a response
-     * Responses have a 'result' field and no 'method' field
-     */
-    isResponse(message: any): boolean;
-    /**
-     * Extracts and parses JSON from various formats including:
-     * - Already parsed objects
-     * - Plain JSON
-     * - Markdown code blocks (```json ... ``` or ``` ... ```)
-     * - Mixed content with explanatory text
-     * - JSON5 format (trailing commas, comments, unquoted keys, etc.)
-     *
-     * @param decoded - The decoded string that may contain JSON, or an already parsed object
-     * @returns Parsed JSON object
-     * @throws Error if JSON parsing fails even with JSON5 fallback
-     */
-    private extractAndParseJSON;
-    /**
-     * Builds a bidirectional cache key from caller and receiver addresses
-     * The key is symmetric: A↔B === B↔A
-     *
-     * @param callerAddress - The caller's address
-     * @param receiverAddress - The receiver's address
-     * @returns Cache key string
-     */
-    private buildCacheKey;
-    /**
-     * Sends data through a stream using length-prefixed encoding (libp2p v3 best practice)
-     * Each message is automatically prefixed with a varint indicating the message length
-     * This ensures proper message boundaries and eliminates concatenation issues
-     *
-     * @param stream - The stream to send data through
-     * @param data - The data to send
-     * @param config - Configuration for timeout and other options
-     */
-    sendLengthPrefixed(stream: Stream, data: Uint8Array, config?: StreamHandlerConfig): Promise<void>;
-    /**
-     * Handles an incoming stream on the server side using length-prefixed protocol
-     * Uses async read loops instead of event listeners (libp2p v3 best practice)
-     * Processes complete messages with proper boundaries
-     *
-     * @param stream - The incoming stream
-     * @param connection - The connection the stream belongs to
-     * @param toolExecutor - Function to execute tools for requests
-     */
-    handleIncomingStream(stream: Stream, connection: Connection, toolExecutor: (request: oRequest, stream: Stream) => Promise<RunResult>): Promise<void>;
-    /**
-     * 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
-     */
-    private handleRequestMessage;
-    /**
-     * Handles an outgoing stream on the client side using length-prefixed protocol
-     * Uses async read loops to process responses with proper message boundaries
-     *
-     * @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
-     */
-    handleOutgoingStream(stream: Stream, emitter: EventEmitter, config?: StreamHandlerConfig, requestHandler?: (request: oRequest, stream: Stream) => Promise<RunResult>, requestId?: string | number): Promise<oResponse>;
-    /**
-     * 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
-     */
-    forwardRequest(request: oRouterRequest, incomingStream: Stream, dialFn: (address: string) => Promise<oConnection>): Promise<void>;
-}
-//# sourceMappingURL=stream-handler.d.ts.map

package/dist/src/connection/stream-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-handler.d.ts","sourceRoot":"","sources":["../../../src/connection/stream-handler.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EACL,QAAQ,EACR,SAAS,EAIT,MAAM,EAEP,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EACV,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAKpC;;;;;;;GAOG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,CAAC,EAAE,MAAM;IAI3B;;;OAGG;IACH,SAAS,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO;IAIhC;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO;IAIjC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,mBAAmB;IAqC3B;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IA0HrB;;;;;;;;OAQG;IACG,kBAAkB,CACtB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,UAAU,EAChB,MAAM,GAAE,mBAAwB,GAC/B,OAAO,CAAC,IAAI,CAAC;IAKhB;;;;;;;;OAQG;IACG,oBAAoB,CACxB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,GACtE,OAAO,CAAC,IAAI,CAAC;IA+BhB;;;;;;OAMG;YACW,oBAAoB;IA6BlC;;;;;;;;;;OAUG;IACG,oBAAoB,CACxB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,YAAY,EACrB,MAAM,GAAE,mBAAwB,EAChC,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,EAC1E,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAC1B,OAAO,CAAC,SAAS,CAAC;IAiErB;;;;;;;OAOG;IACG,cAAc,CAClB,OAAO,EAAE,cAAc,EACvB,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,GAChD,OAAO,CAAC,IAAI,CAAC;CAyBjB"}