@olane/o-node 0.7.55 → 0.7.57

package/dist/src/connection/o-node-connection.manager.js

@@ -1,5 +1,7 @@
 import { oConnectionManager } from '@olane/o-core';
 import { oNodeConnection } from './o-node-connection.js';
+import { EventEmitter } from 'events';
+import { oNodeStream } from './o-node-stream.js';
 /**
  * Manages oNodeConnection instances, reusing connections when possible.
  */
@@ -10,10 +12,11 @@ export class oNodeConnectionManager extends oConnectionManager {
         /** Single cache of oNodeConnection instances keyed by address */
         this.cachedConnections = new Map();
         this.pendingDialsByAddress = new Map();
+        this.eventEmitter = new EventEmitter();
         this.p2pNode = config.p2pNode;
         this.defaultReadTimeoutMs = config.defaultReadTimeoutMs;
         this.defaultDrainTimeoutMs = config.defaultDrainTimeoutMs;
-        this.logger.setNamespace(`oNodeConnectionManager[${config.originAddress}]`);
+        this.logger.setNamespace(`oNodeConnectionManager[${config.callerAddress}]`);
         // Set up connection lifecycle listeners for cache management
         this.setupConnectionListeners();
     }
@@ -54,7 +57,7 @@ export class oNodeConnectionManager extends oConnectionManager {
      * @param addressKey - The address key to cache under
      */
     cacheConnection(conn) {
-        this.logger.debug('Caching connection for address:', conn.p2pConnection.id, conn.p2pConnection.direction, conn.nextHopAddress.value, conn.p2pConnection.streams.map((s) => s.protocol).join(', '));
+        this.logger.debug('Caching connection for address:', conn.p2pConnection.id, conn.p2pConnection.direction, conn.nextHopAddress.value, conn.p2pConnection.streams.map((s) => s.protocol).join(', '), conn.remotePeerId);
         this.cachedConnections.set(conn.p2pConnection.id, conn);
     }
     /**
@@ -92,66 +95,63 @@ export class oNodeConnectionManager extends oConnectionManager {
         });
         return connection;
     }
-    async answer(config) {
-        const { address, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, p2pConnection, reuse, } = config;
+    async createConnection(config) {
+        return new oNodeConnection(config);
+    }
+    async answer(config, stream) {
+        const { targetAddress, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, p2pConnection, } = config;
+        if (!p2pConnection) {
+            throw new Error('Failed to answer connection, p2pConnection is undefined');
+        }
         this.logger.debug('Answering connection for address:', {
             address: nextHopAddress?.value,
             connectionId: p2pConnection.id,
             direction: p2pConnection.direction,
-            reuse,
         });
         // Check if we already have a cached connection for this address with the same connection id
         const existingConnection = this.cachedConnections.get(p2pConnection.id);
         if (existingConnection) {
-            this.logger.debug('Reusing cached connection for answer:', existingConnection.p2pConnection.id);
+            this.logger.debug('Reusing cached connection for answer:', existingConnection.id);
+            existingConnection.trackStream(new oNodeStream(stream, {
+                remoteAddress: nextHopAddress,
+                limited: this.config.runOnLimitedConnection,
+            }), config);
             return existingConnection;
         }
-        const connection = new oNodeConnection({
+        const connection = await this.createConnection({
             nextHopAddress: nextHopAddress,
-            address: address,
-            p2pConnection: p2pConnection,
-            p2pNode: this.p2pNode,
+            targetAddress: targetAddress,
             callerAddress: callerAddress,
             readTimeoutMs: readTimeoutMs ?? this.defaultReadTimeoutMs,
             drainTimeoutMs: drainTimeoutMs ?? this.defaultDrainTimeoutMs,
             isStream: config.isStream ?? false,
             abortSignal: config.abortSignal,
             runOnLimitedConnection: this.config.runOnLimitedConnection ?? false,
-            reusePolicy: reuse ? 'reuse' : 'none',
+            p2pConnection: p2pConnection,
         });
+        connection.trackStream(new oNodeStream(stream, {
+            remoteAddress: nextHopAddress,
+            limited: this.config.runOnLimitedConnection,
+        }), config);
         // Cache the new connection
         this.cacheConnection(connection);
         return connection;
     }
-    getConnectionFromAddress(address) {
-        const protocol = address.protocol;
-        this.logger.debug('Searching cached connections for protocol:', protocol);
-        for (const conn of this.cachedConnections.values()) {
-            // if nextHopAddress protocol matches, return conn
-            if (conn.nextHopAddress.protocol === protocol) {
-                this.logger.debug('local reuse cache found:', protocol);
-                return conn;
-            }
-            // if remote protocols include protocol, return conn
-            if (conn.remoteProtocols.includes(protocol)) {
-                this.logger.debug('remote reuse cache found', protocol);
-                return conn;
-            }
-        }
-        return null;
-    }
     /**
      * Connect to a given address, reusing oNodeConnection when possible
      * @param config - Connection configuration
      * @returns The connection object
      */
     async connect(config) {
-        const { address, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, } = config;
+        const { targetAddress, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, } = config;
         if (!nextHopAddress) {
             throw new Error('Invalid address passed');
         }
+        if (nextHopAddress.libp2pTransports?.length === 0) {
+            throw new Error('No transports provided for the address, cannot connect');
+        }
         // Check for existing valid cached connection
-        const existingConnection = this.getConnectionFromAddress(nextHopAddress);
+        const existingConnection = this.getCachedConnectionFromAddress(nextHopAddress);
         if (existingConnection) {
             this.logger.debug('Reusing cached connection for address:', existingConnection.p2pConnection.id);
             return existingConnection;
@@ -159,15 +159,14 @@ export class oNodeConnectionManager extends oConnectionManager {
         else {
             this.logger.debug('No cached connection found for address:', {
                 address: nextHopAddress.value,
+                peerId: nextHopAddress.libp2pTransports?.[0].toPeerId(),
             });
         }
         // Get or create the underlying p2p connection
         const p2pConnection = await this.getOrCreateP2pConnection(nextHopAddress, nextHopAddress.value);
-        // Create new oNodeConnection
-        const connection = new oNodeConnection({
+        const connection = await this.createConnection({
             nextHopAddress: nextHopAddress,
-            address: address,
-            p2pNode: this.p2pNode,
+            targetAddress: targetAddress,
             p2pConnection: p2pConnection,
             callerAddress: callerAddress,
             readTimeoutMs: readTimeoutMs ?? this.defaultReadTimeoutMs,
@@ -175,10 +174,25 @@ export class oNodeConnectionManager extends oConnectionManager {
             isStream: config.isStream ?? false,
             abortSignal: config.abortSignal,
             runOnLimitedConnection: this.config.runOnLimitedConnection ?? false,
-            requestHandler: config.requestHandler,
         });
         // Cache the new connection
         this.cacheConnection(connection);
         return connection;
     }
+    getCachedConnectionFromAddress(address) {
+        const vals = Array.from(this.cachedConnections.values());
+        for (let i = 0; i < vals.length; ++i) {
+            const c = vals[i];
+            const connection = c;
+            const peerId = address.libp2pTransports?.[0].toPeerId();
+            if (connection.p2pConnection?.remotePeer.toString() === peerId &&
+                connection.isOpen) {
+                return connection;
+            }
+        }
+        return null;
+    }
+    get connectionCount() {
+        return this.cachedConnections.size;
+    }
 }

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

@@ -1,21 +1,53 @@
+/// <reference types="node" />
 import type { Stream } from '@libp2p/interface';
-import { oObject } from '@olane/o-core';
+import { oObject, oRequest, oResponse } from '@olane/o-core';
 import { oNodeStreamConfig } from './interfaces/o-node-stream.config.js';
+import { LengthPrefixedStream } from '@olane/o-config';
+import { AbortSignalConfig } from './interfaces/abort-signal.config.js';
+import { EventEmitter } from 'events';
+import { oNodeMessageEvent, oNodeMessageEventData } from './enums/o-node-message-event.js';
 /**
- * oNodeStream wraps a libp2p Stream with caller/receiver address metadata
- * to enable proper stream reuse based on address pairs rather than protocol only.
- *
- * Key features:
- * - Bidirectional cache keys: A↔B === B↔A
- * - Automatic reusability checking
- * - Idle time tracking for cleanup
+ * oNodeStream wraps a libp2p Stream and transmits or receives messages across the libp2p streams
  */
 export declare class oNodeStream extends oObject {
     readonly p2pStream: Stream;
     readonly config: oNodeStreamConfig;
     readonly createdAt: number;
+    protected readonly lp: LengthPrefixedStream;
+    protected readonly eventEmitter: EventEmitter;
     constructor(p2pStream: Stream, config: oNodeStreamConfig);
+    listenForLibp2pEvents(): void;
     validate(): void;
+    /**
+     * 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
+     */
+    protected extractAndParseJSON(decoded: string | any): any;
+    send(request: oRequest, options: AbortSignalConfig): Promise<void>;
+    /**
+     * listen - process every message inbound on the stream and emit it for the connection to bubble up
+     * @param options
+     */
+    listen(options: AbortSignalConfig): Promise<void>;
+    listenOnce(options: AbortSignalConfig): Promise<void>;
+    waitForResponse(requestId: string): Promise<oResponse>;
+    /**
+     * 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
+     */
+    isResponse(message: any): boolean;
     /**
      * Checks if the stream is in a valid state:
      * - Stream status is 'open'
@@ -29,18 +61,19 @@ export declare class oNodeStream extends oObject {
      * Gets the age of the stream in milliseconds
      */
     get age(): number;
+    close(): Promise<void>;
+    get id(): string;
     /**
-     * Returns the stream type (defaults to 'general' for backward compatibility)
+     * Add event listener
      */
-    get streamType(): string;
+    on<K extends oNodeMessageEvent>(event: K, listener: (data: oNodeMessageEventData[K]) => void): void;
     /**
-     * Checks if this stream is designated as a dedicated reader
+     * Remove event listener
      */
-    get isDedicatedReader(): boolean;
+    off<K extends oNodeMessageEvent>(event: K, listener: (data: oNodeMessageEventData[K]) => void): void;
     /**
-     * Checks if this stream is designated for request-response cycles
+     * Emit event
      */
-    get isRequestResponse(): boolean;
-    close(): Promise<void>;
+    private emit;
 }
 //# sourceMappingURL=o-node-stream.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"o-node-stream.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAuB,OAAO,EAAiB,MAAM,eAAe,CAAC;AAC5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAEzE;;;;;;;;GAQG;AACH,qBAAa,WAAY,SAAQ,OAAO;aAIpB,SAAS,EAAE,MAAM;aACjB,MAAM,EAAE,iBAAiB;IAJ3C,SAAgB,SAAS,EAAE,MAAM,CAAC;gBAGhB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,iBAAiB;IAO3C,QAAQ;IA6BR;;;;;;;OAOG;IACH,IAAI,OAAO,IAAI,OAAO,CAMrB;IAED;;OAEG;IACH,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAiB7B"}
+{"version":3,"file":"o-node-stream.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-stream.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAGL,OAAO,EACP,QAAQ,EACR,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAY,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAExE,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AAGzC;;GAEG;AACH,qBAAa,WAAY,SAAQ,OAAO;aAMpB,SAAS,EAAE,MAAM;aACjB,MAAM,EAAE,iBAAiB;IAN3C,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,QAAQ,CAAC,EAAE,EAAE,oBAAoB,CAAC;IAC5C,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAsB;gBAGjD,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,iBAAiB;IAQ3C,qBAAqB;IAOrB,QAAQ;IA6BR;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG;IAqCnD,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,iBAAiB;IAUxD;;;OAGG;IACG,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAMjD,UAAU,CAAC,OAAO,EAAE,iBAAiB;IAqBrC,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAe5D;;;OAGG;IACH,SAAS,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO;IAQhC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO;IAIjC;;;;;;;OAOG;IACH,IAAI,OAAO,IAAI,OAAO,CAMrB;IAED;;OAEG;IACH,IAAI,GAAG,IAAI,MAAM,CAEhB;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAY5B,IAAI,EAAE,IAAI,MAAM,CAEf;IAED;;OAEG;IACH,EAAE,CAAC,CAAC,SAAS,iBAAiB,EAC5B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAAK,IAAI,GACjD,IAAI;IAIP;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,iBAAiB,EAC7B,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAAK,IAAI,GACjD,IAAI;IAIP;;OAEG;IACH,OAAO,CAAC,IAAI;CAMb"}

package/dist/src/connection/o-node-stream.js

@@ -1,19 +1,26 @@
-import { oError, oErrorCodes, oObject } from '@olane/o-core';
+import { oError, oErrorCodes, oObject, oResponse, } from '@olane/o-core';
+import { lpStream } from '@olane/o-config';
+import JSON5 from 'json5';
+import { EventEmitter } from 'events';
+import { oNodeMessageEvent, } from './enums/o-node-message-event.js';
+import { oStreamRequest } from './o-stream.request.js';
 /**
- * oNodeStream wraps a libp2p Stream with caller/receiver address metadata
- * to enable proper stream reuse based on address pairs rather than protocol only.
- *
- * Key features:
- * - Bidirectional cache keys: A↔B === B↔A
- * - Automatic reusability checking
- * - Idle time tracking for cleanup
+ * oNodeStream wraps a libp2p Stream and transmits or receives messages across the libp2p streams
  */
 export class oNodeStream extends oObject {
     constructor(p2pStream, config) {
         super();
         this.p2pStream = p2pStream;
         this.config = config;
+        this.eventEmitter = new EventEmitter();
         this.createdAt = Date.now();
+        this.lp = lpStream(p2pStream);
+        this.listenForLibp2pEvents();
+    }
+    listenForLibp2pEvents() {
+        this.p2pStream.addEventListener('close', () => {
+            this.close();
+        });
     }
     // callable pattern to disrupt flow if not in valid state
     validate() {
@@ -30,6 +37,113 @@ export class oNodeStream extends oObject {
             throw new oError(oErrorCodes.INVALID_STATE, 'Session is not in a valid state');
         }
     }
+    /**
+     * 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
+     */
+    extractAndParseJSON(decoded) {
+        // If already an object (not a string), return it directly
+        if (typeof decoded !== 'string') {
+            return decoded;
+        }
+        let jsonString = decoded.trim();
+        // Attempt standard JSON.parse first
+        try {
+            return JSON.parse(jsonString);
+        }
+        catch (jsonError) {
+            this.logger.debug('Standard JSON parse failed, trying JSON5', {
+                error: jsonError.message,
+                position: jsonError.message.match(/position (\d+)/)?.[1],
+                preview: jsonString,
+            });
+            // Fallback to JSON5 for more relaxed parsing
+            try {
+                return JSON5.parse(jsonString);
+            }
+            catch (json5Error) {
+                // Enhanced error with context
+                this.logger.error('JSON5 parse also failed', {
+                    originalError: jsonError.message,
+                    json5Error: json5Error.message,
+                    preview: jsonString.substring(0, 200),
+                    length: jsonString.length,
+                });
+                throw new Error(`Failed to parse JSON: ${jsonError.message}\nJSON5 also failed: ${json5Error.message}\nPreview: ${jsonString.substring(0, 200)}${jsonString.length > 200 ? '...' : ''}`);
+            }
+        }
+    }
+    async send(request, options) {
+        // Ensure stream is valid
+        this.validate();
+        // Send the request with backpressure handling
+        const data = new TextEncoder().encode(request.toString());
+        await this.lp.write(data, { signal: options?.abortSignal });
+    }
+    /**
+     * listen - process every message inbound on the stream and emit it for the connection to bubble up
+     * @param options
+     */
+    async listen(options) {
+        while (this.isValid && !options?.abortSignal?.aborted) {
+            await this.listenOnce(options);
+        }
+    }
+    async listenOnce(options) {
+        const messageBytes = await this.lp.read({ signal: options?.abortSignal });
+        const decoded = new TextDecoder().decode(messageBytes.subarray());
+        const message = this.extractAndParseJSON(decoded);
+        if (this.isRequest(message)) {
+            // package up the request + stream and emit
+            const request = new oStreamRequest({
+                ...message,
+                stream: this.p2pStream,
+            });
+            this.emit(oNodeMessageEvent.request, request);
+        }
+        else if (this.isResponse(message)) {
+            const response = new oResponse({
+                ...message.result,
+                id: message.id,
+            });
+            this.emit(oNodeMessageEvent.response, response);
+        }
+    }
+    async waitForResponse(requestId) {
+        return new Promise((resolve, reject) => {
+            const handler = (data) => {
+                if (data.id === requestId) {
+                    this.off(oNodeMessageEvent.response, handler);
+                    this.logger.debug('Stream stopped listening for responses due to "waitForResponse", technically should continue if listen was called elsewhere');
+                    resolve(data);
+                }
+            };
+            this.on(oNodeMessageEvent.response, handler);
+        });
+    }
+    /**
+     * Detects if a decoded message is a request
+     * Requests have a 'method' field and no 'result' field
+     */
+    isRequest(message) {
+        return (typeof message?.method === 'string' &&
+            message.result === undefined &&
+            message.error === undefined);
+    }
+    /**
+     * Detects if a decoded message is a response
+     */
+    isResponse(message) {
+        return message?.result !== undefined || message?.error !== undefined;
+    }
     /**
      * Checks if the stream is in a valid state:
      * - Stream status is 'open'
@@ -49,30 +163,7 @@ export class oNodeStream extends oObject {
     get age() {
         return Date.now() - this.createdAt;
     }
-    /**
-     * Returns the stream type (defaults to 'general' for backward compatibility)
-     */
-    get streamType() {
-        return this.config.streamType || 'general';
-    }
-    /**
-     * Checks if this stream is designated as a dedicated reader
-     */
-    get isDedicatedReader() {
-        return this.streamType === 'dedicated-reader';
-    }
-    /**
-     * Checks if this stream is designated for request-response cycles
-     */
-    get isRequestResponse() {
-        return this.streamType === 'request-response';
-    }
     async close() {
-        // Don't close if reuse policy is enabled
-        if (this.config.reusePolicy === 'reuse') {
-            this.logger.debug('Stream reuse enabled, not closing stream');
-            return;
-        }
         if (this.p2pStream.status === 'open') {
             try {
                 // force the close for now until we can implement a proper close
@@ -84,4 +175,25 @@ export class oNodeStream extends oObject {
             }
         }
     }
+    get id() {
+        return this.p2pStream?.id;
+    }
+    /**
+     * 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);
+    }
 }

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

@@ -1,20 +1,9 @@
 /// <reference types="node" />
 import type { Stream } from '@libp2p/interface';
-/**
- * Stream reuse policy determines how streams are managed across multiple requests
- */
-export type StreamReusePolicy = 'none' | 'reuse' | 'pool';
 /**
  * Configuration for StreamHandler behavior
  */
 export interface StreamHandlerConfig {
-    /**
-     * Stream reuse policy:
-     * - 'none': Create new stream for each request (default)
-     * - 'reuse': Reuse existing open streams
-     * - 'pool': (Future) Maintain a pool of streams
-     */
-    reusePolicy?: StreamReusePolicy;
     /**
      * Timeout in milliseconds to wait for stream drain when buffer is full
      * @default 30000 (30 seconds)

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

@@ -1 +1 @@
-{"version":3,"file":"stream-handler.config.d.ts","sourceRoot":"","sources":["../../../src/connection/stream-handler.config.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAEhC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IAErB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,mBAAmB,CAAC;CAC7B"}
+{"version":3,"file":"stream-handler.config.d.ts","sourceRoot":"","sources":["../../../src/connection/stream-handler.config.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAEjC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;IAErB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,mBAAmB,CAAC;CAC7B"}

package/dist/src/lib/interfaces/o-node-request-manager.config.d.ts

@@ -0,0 +1,9 @@
+import { oNodeAddress } from '../../router/o-node.address.js';
+import { oNodeConnectionManager } from '../../connection/o-node-connection.manager.js';
+import { oNodeRouter } from '../../router/o-node.router.js';
+export interface oNodeRequestManagerConfig {
+    callerAddress: oNodeAddress;
+    connectionManager: oNodeConnectionManager;
+    router: oNodeRouter;
+}
+//# sourceMappingURL=o-node-request-manager.config.d.ts.map

package/dist/src/lib/interfaces/o-node-request-manager.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-node-request-manager.config.d.ts","sourceRoot":"","sources":["../../../../src/lib/interfaces/o-node-request-manager.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,+CAA+C,CAAC;AACvF,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE5D,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,YAAY,CAAC;IAC5B,iBAAiB,EAAE,sBAAsB,CAAC;IAC1C,MAAM,EAAE,WAAW,CAAC;CACrB"}

package/dist/src/lib/interfaces/o-node-request-manager.config.js

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

package/dist/src/lib/o-node-request-manager.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { oRequestManager, oResponse, UseOptions } from '@olane/o-core';
+import { oNodeRequestManagerConfig } from './interfaces/o-node-request-manager.config.js';
+import { oNodeConnection, oNodeConnectionConfig, oNodeConnectionManager } from '../connection/index.js';
+import { oNodeRouter } from '../router/o-node.router.js';
+import { oNodeAddress } from '../router/o-node.address.js';
+import { UseDataConfig } from '@olane/o-core/dist/src/core/interfaces/use-data.config.js';
+import { oNode } from '../o-node.js';
+import { Connection, Stream } from '@olane/o-config';
+import { oNodeMessageEvent, oNodeMessageEventData } from '../connection/enums/o-node-message-event.js';
+import { oStreamRequest } from '../connection/o-stream.request.js';
+import { EventEmitter } from 'events';
+import { AbortSignalConfig } from '../connection/interfaces/abort-signal.config.js';
+import { RunResult } from '@olane/o-tool';
+export declare class oNodeRequestManager extends oRequestManager {
+    readonly config: oNodeRequestManagerConfig;
+    connectionManager: oNodeConnectionManager;
+    router: oNodeRouter;
+    protected eventEmitter: EventEmitter;
+    constructor(config: oNodeRequestManagerConfig);
+    translateAddress(address: oNodeAddress, options?: UseOptions, nodeRef?: oNode): Promise<{
+        nextHopAddress: oNodeAddress;
+        targetAddress: oNodeAddress;
+    }>;
+    connectToNode(nextHopAddress: oNodeAddress, options: Omit<oNodeConnectionConfig, 'nextHopAddress'>): Promise<oNodeConnection>;
+    send(address: oNodeAddress, data: UseDataConfig, options?: UseOptions, nodeRef?: oNode): Promise<oResponse>;
+    receiveStream({ connection, stream, }: {
+        connection: Connection;
+        stream: Stream;
+    }): Promise<void>;
+    sendResponse(request: oStreamRequest, result: RunResult): Promise<void>;
+    protected listenForMessages(connection: oNodeConnection, options: AbortSignalConfig): Promise<void>;
+    /**
+     * Add event listener
+     */
+    on<K extends oNodeMessageEvent>(event: K | string, listener: (data: oNodeMessageEventData[K]) => void): void;
+    /**
+     * Remove event listener
+     */
+    off<K extends oNodeMessageEvent>(event: K | string, listener: (data: oNodeMessageEventData[K]) => void): void;
+    /**
+     * Emit event
+     */
+    private emitAsync;
+}
+//# sourceMappingURL=o-node-request-manager.d.ts.map

package/dist/src/lib/o-node-request-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-node-request-manager.d.ts","sourceRoot":"","sources":["../../../src/lib/o-node-request-manager.ts"],"names":[],"mappings":";AAAA,OAAO,EAML,eAAe,EACf,SAAS,EAET,UAAU,EACX,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,yBAAyB,EAAE,MAAM,+CAA+C,CAAC;AAC1F,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,sBAAsB,EAEvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,2DAA2D,CAAC;AAC1F,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,iDAAiD,CAAC;AACpF,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG1C,qBAAa,mBAAoB,SAAQ,eAAe;IAK1C,QAAQ,CAAC,MAAM,EAAE,yBAAyB;IAJtD,iBAAiB,EAAE,sBAAsB,CAAC;IAC1C,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,CAAC,YAAY,EAAE,YAAY,CAAsB;gBAErC,MAAM,EAAE,yBAAyB;IAMhD,gBAAgB,CACpB,OAAO,EAAE,YAAY,EACrB,OAAO,CAAC,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE,KAAK,GACd,OAAO,CAAC;QAAE,cAAc,EAAE,YAAY,CAAC;QAAC,aAAa,EAAE,YAAY,CAAA;KAAE,CAAC;IAenE,aAAa,CACjB,cAAc,EAAE,YAAY,EAC5B,OAAO,EAAE,IAAI,CAAC,qBAAqB,EAAE,gBAAgB,CAAC,GACrD,OAAO,CAAC,eAAe,CAAC;IAyBrB,IAAI,CACR,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE,UAAU,EACpB,OAAO,CAAC,EAAE,KAAK,GACd,OAAO,CAAC,SAAS,CAAC;IAgEf,aAAa,CAAC,EAClB,UAAU,EACV,MAAM,GACP,EAAE;QACD,UAAU,EAAE,UAAU,CAAC;QACvB,MAAM,EAAE,MAAM,CAAC;KAChB;IAsBK,YAAY,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,SAAS;cAsB7C,iBAAiB,CAC/B,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE,iBAAiB;IAyB5B;;OAEG;IACH,EAAE,CAAC,CAAC,SAAS,iBAAiB,EAC5B,KAAK,EAAE,CAAC,GAAG,MAAM,EACjB,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAAK,IAAI,GACjD,IAAI;IAIP;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,iBAAiB,EAC7B,KAAK,EAAE,CAAC,GAAG,MAAM,EACjB,QAAQ,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAAK,IAAI,GACjD,IAAI;IAIP;;OAEG;YAQW,SAAS;CAcxB"}