@olane/o-node 0.7.39 → 0.7.41

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

@@ -2,4 +2,6 @@ export * from './o-node-connection.js';
 export * from './o-node-connection.manager.js';
 export * from './interfaces/o-node-connection.config.js';
 export * from './interfaces/o-node-connection-manager.config.js';
+export * from './o-node-connection-stream.js';
+export * from './stream-handler.config.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,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0CAA0C,CAAC;AACzD,cAAc,kDAAkD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0CAA0C,CAAC;AACzD,cAAc,kDAAkD,CAAC;AACjE,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC"}

package/dist/src/connection/index.js

@@ -2,3 +2,5 @@ export * from './o-node-connection.js';
 export * from './o-node-connection.manager.js';
 export * from './interfaces/o-node-connection.config.js';
 export * from './interfaces/o-node-connection-manager.config.js';
+export * from './o-node-connection-stream.js';
+export * from './stream-handler.config.js';

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1 @@
+{"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/interfaces/o-node-connection-stream.config.js

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

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

@@ -0,0 +1,34 @@
+import type { Stream } from '@libp2p/interface';
+import { oObject } from '@olane/o-core';
+import { oNodeConnectionStreamConfig } from './interfaces/o-node-connection-stream.config.js';
+/**
+ * oNodeConnectionStream 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
+ */
+export declare class oNodeConnectionStream extends oObject {
+    readonly p2pStream: Stream;
+    readonly config: oNodeConnectionStreamConfig;
+    readonly createdAt: number;
+    constructor(p2pStream: Stream, config: oNodeConnectionStreamConfig);
+    validate(): void;
+    /**
+     * Checks if the stream is in a valid state:
+     * - Stream status is 'open'
+     * - Write status is 'writable'
+     * - Remote read status is 'readable'
+     *
+     * @returns true if stream can be used
+     */
+    get isValid(): boolean;
+    /**
+     * Gets the age of the stream in milliseconds
+     */
+    get age(): number;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=o-node-connection-stream.d.ts.map

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

@@ -0,0 +1 @@
+{"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/o-node-connection-stream.js

@@ -0,0 +1,68 @@
+import { oError, oErrorCodes, oObject } from '@olane/o-core';
+/**
+ * oNodeConnectionStream 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
+ */
+export class oNodeConnectionStream extends oObject {
+    constructor(p2pStream, config) {
+        super();
+        this.p2pStream = p2pStream;
+        this.config = config;
+        this.createdAt = Date.now();
+    }
+    // callable pattern to disrupt flow if not in valid state
+    validate() {
+        // do nothing
+        if (!this.p2pStream ||
+            (this.p2pStream.status !== 'open' && this.p2pStream.status !== 'reset')) {
+            throw new oError(oErrorCodes.FAILED_TO_DIAL_TARGET, 'Failed to dial target');
+        }
+        if (this.p2pStream.status === 'reset') {
+            this.logger.debug('P2P stream failed to create, status:', this.p2pStream.status);
+            throw new oError(oErrorCodes.CONNECTION_LIMIT_REACHED, 'Connection limit reached or configuration prevented stream creation');
+        }
+        if (!this.isValid) {
+            throw new oError(oErrorCodes.INVALID_STATE, 'Session is not in a valid state');
+        }
+    }
+    /**
+     * Checks if the stream is in a valid state:
+     * - Stream status is 'open'
+     * - Write status is 'writable'
+     * - Remote read status is 'readable'
+     *
+     * @returns true if stream can be used
+     */
+    get isValid() {
+        return (this.p2pStream.status === 'open' &&
+            this.p2pStream.writeStatus === 'writable' &&
+            this.p2pStream.remoteReadStatus === 'readable');
+    }
+    /**
+     * Gets the age of the stream in milliseconds
+     */
+    get age() {
+        return Date.now() - this.createdAt;
+    }
+    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
+                await this.p2pStream.abort(new Error('Stream closed'));
+            }
+            catch (error) {
+                this.logger.debug('Error closing stream:', error.message);
+            }
+        }
+    }
+}

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

@@ -1,18 +1,24 @@
-import { Connection, Stream } from '@olane/o-config';
+import { Connection } from '@olane/o-config';
 import { oConnection, oRequest, oResponse } from '@olane/o-core';
 import { oNodeConnectionConfig } from './interfaces/o-node-connection.config.js';
 import { StreamHandler } from './stream-handler.js';
 import type { StreamReusePolicy } from './stream-handler.config.js';
+import { oNodeAddress } from '../router/o-node.address.js';
+import { oNodeConnectionStream } from './o-node-connection-stream.js';
 export declare class oNodeConnection extends oConnection {
     protected readonly config: oNodeConnectionConfig;
     p2pConnection: Connection;
     protected streamHandler: StreamHandler;
     protected reusePolicy: StreamReusePolicy;
     constructor(config: oNodeConnectionConfig);
-    validate(stream?: Stream): void;
-    getOrCreateStream(): Promise<Stream>;
+    get remotePeerId(): import("@olane/o-config").PeerId;
+    get remoteAddr(): import("@olane/o-config").Multiaddr;
+    supportsAddress(address: oNodeAddress): boolean;
+    getOrCreateStream(): Promise<oNodeConnectionStream>;
+    createStream(): Promise<oNodeConnectionStream>;
+    get streams(): oNodeConnectionStream[];
     transmit(request: oRequest): Promise<oResponse>;
-    postTransmit(stream: Stream): Promise<void>;
+    postTransmit(stream: oNodeConnectionStream): Promise<void>;
     abort(error: Error): Promise<void>;
     close(): Promise<void>;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"o-node-connection.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAEL,WAAW,EAGX,QAAQ,EACR,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAEV,iBAAiB,EAClB,MAAM,4BAA4B,CAAC;AAEpC,qBAAa,eAAgB,SAAQ,WAAW;IAKlC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,qBAAqB;IAJrD,aAAa,EAAE,UAAU,CAAC;IACjC,SAAS,CAAC,aAAa,EAAE,aAAa,CAAC;IACvC,SAAS,CAAC,WAAW,EAAE,iBAAiB,CAAC;gBAEV,MAAM,EAAE,qBAAqB;IAO5D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM;IAmBlB,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAkBpC,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;IA2C/C,YAAY,CAAC,MAAM,EAAE,MAAM;IAQ3B,KAAK,CAAC,KAAK,EAAE,KAAK;IAMlB,KAAK;CAKZ"}
+{"version":3,"file":"o-node-connection.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAU,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAEL,WAAW,EAGX,QAAQ,EACR,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAEV,iBAAiB,EAClB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,qBAAa,eAAgB,SAAQ,WAAW;IAKlC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,qBAAqB;IAJrD,aAAa,EAAE,UAAU,CAAC;IACjC,SAAS,CAAC,aAAa,EAAE,aAAa,CAAC;IACvC,SAAS,CAAC,WAAW,EAAE,iBAAiB,CAAC;gBAEV,MAAM,EAAE,qBAAqB;IAO5D,IAAI,YAAY,qCAEf;IAED,IAAI,UAAU,wCAEb;IAED,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IAMzC,iBAAiB,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAanD,YAAY,IAAI,OAAO,CAAC,qBAAqB,CAAC;IA6BpD,IAAI,OAAO,IAAI,qBAAqB,EAAE,CAcrC;IAEK,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;IA6C/C,YAAY,CAAC,MAAM,EAAE,qBAAqB;IAI1C,KAAK,CAAC,KAAK,EAAE,KAAK;IAMlB,KAAK;CAKZ"}

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

@@ -1,5 +1,6 @@
 import { oConnection, oError, oErrorCodes, } from '@olane/o-core';
 import { StreamHandler } from './stream-handler.js';
+import { oNodeConnectionStream } from './o-node-connection-stream.js';
 export class oNodeConnection extends oConnection {
     constructor(config) {
         super(config);
@@ -8,37 +9,64 @@ export class oNodeConnection extends oConnection {
         this.streamHandler = new StreamHandler(this.logger);
         this.reusePolicy = config.reusePolicy ?? 'none';
     }
-    validate(stream) {
-        if (this.config.p2pConnection.status !== 'open') {
-            throw new Error('Connection is not valid');
-        }
-        // do nothing
-        if (!stream || (stream.status !== 'open' && stream.status !== 'reset')) {
-            throw new oError(oErrorCodes.FAILED_TO_DIAL_TARGET, 'Failed to dial target');
-        }
-        if (stream.status === 'reset') {
-            throw new oError(oErrorCodes.CONNECTION_LIMIT_REACHED, 'Connection limit reached');
-        }
+    get remotePeerId() {
+        return this.p2pConnection.remotePeer;
+    }
+    get remoteAddr() {
+        return this.p2pConnection.remoteAddr;
+    }
+    supportsAddress(address) {
+        return address.libp2pTransports.some((transport) => {
+            return transport.toString() === this.remoteAddr.toString();
+        });
     }
     async getOrCreateStream() {
-        const streamConfig = {
+        if (this.reusePolicy === 'reuse' && this.streams.length > 0) {
+            this.logger.debug('Returning reuse stream: ', this.streams[0].p2pStream.protocol);
+            // search for streams that allow re-use
+            return this.streams[0];
+        }
+        return this.createStream();
+    }
+    async createStream() {
+        const protocol = this.nextHopAddress.protocol +
+            (this.reusePolicy === 'reuse' ? '/reuse' : ''); // connect specifically to the reuse protocol version if desired
+        this.logger.debug('Creating stream for protocol:', protocol);
+        const stream = await this.p2pConnection.newStream(protocol, {
             signal: this.abortSignal,
             maxOutboundStreams: process.env.MAX_OUTBOUND_STREAMS
                 ? parseInt(process.env.MAX_OUTBOUND_STREAMS)
                 : 1000,
             runOnLimitedConnection: this.config.runOnLimitedConnection ?? true,
-            reusePolicy: this.reusePolicy,
-            drainTimeoutMs: this.config.drainTimeoutMs,
-        };
-        return this.streamHandler.getOrCreateStream(this.p2pConnection, this.nextHopAddress.protocol, streamConfig);
+        });
+        const managedStream = new oNodeConnectionStream(stream, {
+            direction: stream.direction,
+            reusePolicy: this.config.reusePolicy ?? 'none', // default to no re-use stream
+            remoteAddress: this.nextHopAddress,
+        });
+        // print the num streams
+        const numStreams = this.streams.map((s) => s.isValid).length;
+        this.logger.debug(`Connection spawned new stream: ${stream.id}. Connection now has ${numStreams} total streams open`);
+        return managedStream;
+    }
+    get streams() {
+        return (this.p2pConnection?.streams
+            ?.filter((s) => {
+            return s.protocol.includes('/o/');
+        })
+            .map((s) => {
+            return new oNodeConnectionStream(s, {
+                direction: s.direction,
+                reusePolicy: this.config.reusePolicy ?? 'none', // default to no re-use stream
+                remoteAddress: this.nextHopAddress,
+            });
+        }) || []);
     }
     async transmit(request) {
         try {
-            // if (this.config.runOnLimitedConnection) {
-            //   this.logger.debug('Running on limited connection...');
-            // }
             const stream = await this.getOrCreateStream();
-            this.validate(stream);
+            // ensure stream is valid
+            stream.validate();
             const streamConfig = {
                 signal: this.abortSignal,
                 drainTimeoutMs: this.config.drainTimeoutMs,
@@ -46,11 +74,11 @@ export class oNodeConnection extends oConnection {
             };
             // Send the request with backpressure handling
             const data = new TextEncoder().encode(request.toString());
-            await this.streamHandler.sendLengthPrefixed(stream, data, streamConfig);
+            await this.streamHandler.sendLengthPrefixed(stream.p2pStream, data, streamConfig);
             // Handle response using StreamHandler
             // Pass request handler if configured to enable bidirectional stream processing
             // Pass request ID to enable proper response correlation on shared streams
-            const response = await this.streamHandler.handleOutgoingStream(stream, this.emitter, streamConfig, this.config.requestHandler, request.id);
+            const response = await this.streamHandler.handleOutgoingStream(stream.p2pStream, this.emitter, streamConfig, this.config.requestHandler, request.id);
             // Handle cleanup of the stream
             await this.postTransmit(stream);
             return response;
@@ -63,10 +91,7 @@ export class oNodeConnection extends oConnection {
         }
     }
     async postTransmit(stream) {
-        const streamConfig = {
-            reusePolicy: this.reusePolicy,
-        };
-        await this.streamHandler.close(stream, streamConfig);
+        await stream.close();
     }
     async abort(error) {
         this.logger.debug('Aborting connection');

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

@@ -30,6 +30,10 @@ export declare class oNodeConnectionManager extends oConnectionManager {
     private getPeerIdFromAddress;
     getOrCreateConnection(nextHopAddress: oAddress, address: oAddress): Promise<Connection>;
     private performDial;
+    answer(config: oConnectionConfig & {
+        p2pConnection: Connection;
+        reuse?: boolean;
+    }): Promise<oNodeConnection>;
     /**
      * Connect to a given address, reusing libp2p connections when possible
      * @param config - Connection configuration

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

@@ -1 +1 @@
-{"version":3,"file":"o-node-connection.manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,UAAU,EAAU,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD,qBAAa,sBAAuB,SAAQ,kBAAkB;IAQhD,QAAQ,CAAC,MAAM,EAAE,4BAA4B;IAPzD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,oBAAoB,CAAC,CAAS;IACtC,OAAO,CAAC,qBAAqB,CAAC,CAAS;IACvC,OAAO,CAAC,yBAAyB,CAAsC;IACvE,OAAO,CAAC,0BAA0B,CACtB;gBAES,MAAM,EAAE,4BAA4B;IAWzD;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAsBhC;;;;;;OAMG;IACH,OAAO,CAAC,0BAA0B;IAiBlC;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAatB,qBAAqB,CACzB,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,UAAU,CAAC;YA+DR,WAAW;IAwBzB;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IA8BlE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IAwCpC;;;;OAIG;IACH,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI;IA+C/D;;;OAGG;IACH,aAAa,IAAI;QACf,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE,MAAM,CAAC;QACrB,iBAAiB,EAAE,KAAK,CAAC;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC9D;IAaD;;;OAGG;IACH,uBAAuB,IAAI,MAAM;CAgBlC"}
+{"version":3,"file":"o-node-connection.manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,UAAU,EAAU,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD,qBAAa,sBAAuB,SAAQ,kBAAkB;IAQhD,QAAQ,CAAC,MAAM,EAAE,4BAA4B;IAPzD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,oBAAoB,CAAC,CAAS;IACtC,OAAO,CAAC,qBAAqB,CAAC,CAAS;IACvC,OAAO,CAAC,yBAAyB,CAAsC;IACvE,OAAO,CAAC,0BAA0B,CACtB;gBAES,MAAM,EAAE,4BAA4B;IAWzD;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAsBhC;;;;;;OAMG;IACH,OAAO,CAAC,0BAA0B;IAiBlC;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAatB,qBAAqB,CACzB,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,UAAU,CAAC;YA+DR,WAAW;IAwBnB,MAAM,CACV,MAAM,EAAE,iBAAiB,GAAG;QAAE,aAAa,EAAE,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GACzE,OAAO,CAAC,eAAe,CAAC;IAmC3B;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IA8BlE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IAwCpC;;;;OAIG;IACH,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI;IA+C/D;;;OAGG;IACH,aAAa,IAAI;QACf,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE,MAAM,CAAC;QACrB,iBAAiB,EAAE,KAAK,CAAC;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC9D;IAaD;;;OAGG;IACH,uBAAuB,IAAI,MAAM;CAgBlC"}

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

@@ -130,6 +130,30 @@ export class oNodeConnectionManager extends oConnectionManager {
         });
         return connection;
     }
+    async answer(config) {
+        const { address, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, p2pConnection, reuse, } = config;
+        const connection = new oNodeConnection({
+            nextHopAddress: nextHopAddress,
+            address: address,
+            p2pConnection: p2pConnection,
+            callerAddress: callerAddress,
+            readTimeoutMs: readTimeoutMs ?? this.defaultReadTimeoutMs,
+            drainTimeoutMs: drainTimeoutMs ?? this.defaultDrainTimeoutMs,
+            isStream: config.isStream ?? false,
+            abortSignal: config.abortSignal,
+            runOnLimitedConnection: this.config.runOnLimitedConnection ?? false,
+            requestHandler: config.requestHandler ?? undefined,
+            reusePolicy: reuse ? 'reuse' : 'none',
+        });
+        const transportKey = this.getTransportKeyFromAddress(nextHopAddress);
+        if (transportKey) {
+            this.connectionsByTransportKey.set(transportKey, p2pConnection);
+        }
+        else {
+            this.logger.error('Should not happen! Failed to generate a transport key for address:', nextHopAddress);
+        }
+        return connection;
+    }
     /**
      * Connect to a given address, reusing libp2p connections when possible
      * @param config - Connection configuration

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

@@ -34,6 +34,17 @@ export interface StreamHandlerConfig {
      * AbortSignal for cancellation
      */
     signal?: AbortSignal;
+    /**
+     * Maximum number of streams to cache
+     * Older streams will be evicted when limit is reached
+     * @default unlimited
+     */
+    maxCachedStreams?: number;
+    /**
+     * Time in milliseconds after which idle cached streams are closed
+     * @default unlimited (streams remain cached until closed by peer)
+     */
+    streamIdleTimeout?: number;
 }
 /**
  * Context for stream lifecycle operations

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;CACtB;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,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"}

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

@@ -41,13 +41,14 @@ export declare class StreamHandler {
      */
     private extractAndParseJSON;
     /**
-     * Gets an existing open stream or creates a new one based on reuse policy
+     * Builds a bidirectional cache key from caller and receiver addresses
+     * The key is symmetric: A↔B === B↔A
      *
-     * @param connection - The libp2p connection
-     * @param protocol - The protocol to use for the stream
-     * @param config - Stream handler configuration
+     * @param callerAddress - The caller's address
+     * @param receiverAddress - The receiver's address
+     * @returns Cache key string
      */
-    getOrCreateStream(connection: Connection, protocol: string, config?: StreamHandlerConfig): Promise<Stream>;
+    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
@@ -58,13 +59,6 @@ export declare class StreamHandler {
      * @param config - Configuration for timeout and other options
      */
     sendLengthPrefixed(stream: Stream, data: Uint8Array, config?: StreamHandlerConfig): Promise<void>;
-    /**
-     * Closes a stream safely with error handling
-     *
-     * @param stream - The stream to close
-     * @param config - Configuration including reuse policy
-     */
-    close(stream: Stream, 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)

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

@@ -1 +1 @@
-{"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;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAItE;;;;;;;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;;;;;;OAMG;IACG,iBAAiB,CACrB,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,mBAAwB,GAC/B,OAAO,CAAC,MAAM,CAAC;IAwDlB;;;;;;;;OAQG;IACG,kBAAkB,CACtB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,UAAU,EAChB,MAAM,GAAE,mBAAwB,GAC/B,OAAO,CAAC,IAAI,CAAC;IAKhB;;;;;OAKG;IACG,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,mBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB5E;;;;;;;;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"}
+{"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"}

package/dist/src/connection/stream-handler.js

@@ -72,49 +72,121 @@ export class StreamHandler {
         }
     }
     /**
-     * Gets an existing open stream or creates a new one based on reuse policy
+     * Builds a bidirectional cache key from caller and receiver addresses
+     * The key is symmetric: A↔B === B↔A
      *
-     * @param connection - The libp2p connection
-     * @param protocol - The protocol to use for the stream
-     * @param config - Stream handler configuration
+     * @param callerAddress - The caller's address
+     * @param receiverAddress - The receiver's address
+     * @returns Cache key string
      */
-    async getOrCreateStream(connection, protocol, config = {}) {
-        this.logger.debug(`Getting or creating stream for protocol: ${protocol}, connection`, {
-            status: connection.status,
-            remoteAddr: connection.remoteAddr.toString(),
-            streamCount: connection.streams.length,
-            reusePolicy: config.reusePolicy ?? 'none',
-        });
-        if (connection.status !== 'open') {
-            throw new oError(oErrorCodes.INVALID_STATE, 'Connection not open');
-        }
-        const reusePolicy = config.reusePolicy ?? 'none';
-        this.logger.debug('Checking for existing reusable stream', connection.streams.map((s) => ({
-            status: s.status,
-            protocol: s.protocol,
-            writeStatus: s.writeStatus,
-            remoteReadStatus: s.remoteReadStatus,
-            id: s.id,
-        })));
-        // Check for existing stream if reuse is enabled
-        if (reusePolicy === 'reuse') {
-            const existingStream = connection.streams.find((stream) => stream.status === 'open' &&
-                stream.protocol === protocol &&
-                stream.writeStatus === 'writable' &&
-                stream.remoteReadStatus === 'readable');
-            if (existingStream) {
-                this.logger.debug('Reusing existing stream', existingStream.id, existingStream.direction);
-                return existingStream;
-            }
-        }
-        // Create new stream
-        const stream = await connection.newStream(protocol, {
-            signal: config.signal,
-            maxOutboundStreams: config.maxOutboundStreams ?? 1000,
-            runOnLimitedConnection: config.runOnLimitedConnection ?? false,
-        });
-        return stream;
+    buildCacheKey(callerAddress, receiverAddress) {
+        const addresses = [callerAddress.value, receiverAddress.value].sort();
+        return `${addresses[0]}↔${addresses[1]}`;
     }
+    // /**
+    //  * Gets an existing open stream or creates a new one based on reuse policy
+    //  *
+    //  * @param connection - The libp2p connection
+    //  * @param protocol - The protocol to use for the stream
+    //  * @param config - Stream handler configuration
+    //  * @param streamAddresses - Optional addresses for address-based stream reuse
+    //  */
+    // async getOrCreateStream(
+    //   connection: Connection,
+    //   protocol: string,
+    //   config: StreamHandlerConfig = {},
+    //   streamAddresses?: {
+    //     callerAddress: oAddress;
+    //     receiverAddress: oAddress;
+    //     direction: 'inbound' | 'outbound';
+    //   },
+    // ): Promise<Stream> {
+    //   this.logger.debug(
+    //     `Getting or creating stream for protocol: ${protocol}, connection`,
+    //     {
+    //       status: connection.status,
+    //       remoteAddr: connection.remoteAddr.toString(),
+    //       streamCount: connection.streams.length,
+    //       reusePolicy: config.reusePolicy ?? 'none',
+    //       hasAddresses: !!streamAddresses,
+    //     },
+    //   );
+    //   if (connection.status !== 'open') {
+    //     throw new oError(oErrorCodes.INVALID_STATE, 'Connection not open');
+    //   }
+    //   const reusePolicy = config.reusePolicy ?? 'none';
+    //   // Check address-based cache if reuse is enabled and addresses provided
+    //   if (reusePolicy === 'reuse' && streamAddresses) {
+    //     const cacheKey = this.buildCacheKey(
+    //       streamAddresses.callerAddress,
+    //       streamAddresses.receiverAddress,
+    //     );
+    //     const cachedStream = this.streamCache.get(cacheKey);
+    //     if (cachedStream?.isReusable) {
+    //       this.logger.debug('Reusing cached stream by address', {
+    //         cacheKey,
+    //         streamId: cachedStream.stream.id,
+    //         direction: cachedStream.direction,
+    //       });
+    //       cachedStream.updateLastUsed();
+    //       return cachedStream.stream;
+    //     } else if (cachedStream) {
+    //       // Stream exists but not reusable, remove from cache
+    //       this.logger.debug('Removing non-reusable stream from cache', {
+    //         cacheKey,
+    //         status: cachedStream.stream.status,
+    //       });
+    //       this.streamCache.delete(cacheKey);
+    //     }
+    //   }
+    //   this.logger.debug(
+    //     'No reusable cached stream found, checking connection streams',
+    //     connection.streams.map((s) => ({
+    //       status: s.status,
+    //       protocol: s.protocol,
+    //       writeStatus: s.writeStatus,
+    //       remoteReadStatus: s.remoteReadStatus,
+    //       id: s.id,
+    //     })),
+    //   );
+    //   // Fallback to protocol-based check (legacy behavior)
+    //   if (reusePolicy === 'reuse' && !streamAddresses) {
+    //     const existingStream = connection.streams.find(
+    //       (stream) =>
+    //         stream.status === 'open' &&
+    //         stream.protocol === protocol &&
+    //         stream.writeStatus === 'writable' &&
+    //         stream.remoteReadStatus === 'readable',
+    //     );
+    //     if (existingStream) {
+    //       this.logger.debug(
+    //         'Reusing existing stream by protocol (legacy)',
+    //         existingStream.id,
+    //         existingStream.direction,
+    //       );
+    //       return existingStream;
+    //     }
+    //   }
+    //   // Create new stream
+    //   this.logger.debug('Creating new stream', { protocol });
+    //   const stream = await connection.newStream(protocol, {
+    //     signal: config.signal,
+    //     maxOutboundStreams: config.maxOutboundStreams ?? 1000,
+    //     runOnLimitedConnection: config.runOnLimitedConnection ?? false,
+    //   });
+    //   // Cache the stream if reuse is enabled and addresses are provided
+    //   if (reusePolicy === 'reuse' && streamAddresses) {
+    //     const managedStream = new oNodeConnectionStream(
+    //       stream,
+    //       streamAddresses.callerAddress,
+    //       streamAddresses.receiverAddress,
+    //       streamAddresses.direction,
+    //     );
+    //     this.cacheStream(managedStream);
+    //     this.setupStreamCleanup(stream);
+    //   }
+    //   return stream;
+    // }
     /**
      * 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
@@ -128,28 +200,6 @@ export class StreamHandler {
         const lp = lpStream(stream);
         await lp.write(data, { signal: config.signal });
     }
-    /**
-     * Closes a stream safely with error handling
-     *
-     * @param stream - The stream to close
-     * @param config - Configuration including reuse policy
-     */
-    async close(stream, config = {}) {
-        // Don't close if reuse policy is enabled
-        if (config.reusePolicy === 'reuse') {
-            this.logger.debug('Stream reuse enabled, not closing stream');
-            return;
-        }
-        if (stream.status === 'open') {
-            try {
-                // force the close for now until we can implement a proper close
-                await stream.abort(new Error('Stream closed'));
-            }
-            catch (error) {
-                this.logger.debug('Error closing stream:', error.message);
-            }
-        }
-    }
     /**
      * Handles an incoming stream on the server side using length-prefixed protocol
      * Uses async read loops instead of event listeners (libp2p v3 best practice)

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

@@ -9,9 +9,11 @@ declare const oNodeTool_base: typeof oServerNode;
  */
 export declare class oNodeTool extends oNodeTool_base {
     private streamHandler;
+    handleProtocolReuse(address: oAddress): Promise<void>;
     handleProtocol(address: oAddress): Promise<void>;
     initialize(): Promise<void>;
-    handleStream(stream: Stream, connection: Connection): Promise<void>;
+    handleStreamReuse(stream: Stream, connection: Connection): Promise<void>;
+    handleStream(stream: Stream, connection: Connection, reuse?: boolean): Promise<void>;
     _tool_identify(): Promise<any>;
     _tool_child_register(request: oRequest): Promise<any>;
 }

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

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

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

@@ -4,25 +4,46 @@ import { oServerNode } from './nodes/server.node.js';
 import { oNodeTransport } from './router/o-node.transport.js';
 import { oNodeAddress } from './router/o-node.address.js';
 import { StreamHandler } from './connection/stream-handler.js';
+import { ConnectionUtils } from './utils/connection.utils.js';
 /**
  * oTool is a mixin that extends the base class and implements the oTool interface
  * @param Base - The base class to extend
  * @returns A new class that extends the base class and implements the oTool interface
  */
 export class oNodeTool extends oTool(oServerNode) {
+    async handleProtocolReuse(address) {
+        const reuseProtocol = address.protocol + '/reuse';
+        const protocols = this.p2pNode.getProtocols();
+        if (protocols.find((p) => p === reuseProtocol)) {
+            // already handling
+            return;
+        }
+        const maxOutboundsStreams = process.env.MAX_OUTBOUND_STREAMS
+            ? parseInt(process.env.MAX_OUTBOUND_STREAMS)
+            : 1000;
+        await this.p2pNode.handle(reuseProtocol, this.handleStream.bind(this), {
+            maxInboundStreams: 10000,
+            maxOutboundStreams: maxOutboundsStreams,
+        });
+    }
     async handleProtocol(address) {
         const protocols = this.p2pNode.getProtocols();
         if (protocols.find((p) => p === address.protocol)) {
             // already handling
             return;
         }
-        this.logger.debug('Handling protocol: ' + address.protocol);
+        const maxOutboundsStreams = process.env.MAX_OUTBOUND_STREAMS
+            ? parseInt(process.env.MAX_OUTBOUND_STREAMS)
+            : 1000;
+        this.logger.debug('Handling protocol: ' + address.protocol, {
+            maxInboundStreams: 10000,
+            maxOutboundStreams: maxOutboundsStreams,
+        });
         await this.p2pNode.handle(address.protocol, this.handleStream.bind(this), {
             maxInboundStreams: 10000,
-            maxOutboundStreams: process.env.MAX_OUTBOUND_STREAMS
-                ? parseInt(process.env.MAX_OUTBOUND_STREAMS)
-                : 1000,
+            maxOutboundStreams: maxOutboundsStreams,
         });
+        await this.handleProtocolReuse(address);
     }
     async initialize() {
         await super.initialize();
@@ -33,7 +54,25 @@ export class oNodeTool extends oTool(oServerNode) {
             await this.handleProtocol(this.staticAddress);
         }
     }
-    async handleStream(stream, connection) {
+    async handleStreamReuse(stream, connection) {
+        return this.handleStream(stream, connection, true);
+    }
+    async handleStream(stream, connection, reuse) {
+        if (reuse) {
+            this.logger.debug('Handle stream with reuse = true');
+        }
+        // record inbound connection to manager
+        const remoteAddress = await ConnectionUtils.addressFromConnection({
+            currentNode: this,
+            connection: connection,
+        });
+        this.connectionManager.answer({
+            nextHopAddress: remoteAddress,
+            address: remoteAddress,
+            callerAddress: this.address,
+            p2pConnection: connection,
+            reuse,
+        });
         // Use StreamHandler for consistent stream handling
         // This follows libp2p v3 best practices for length-prefixed streaming
         await this.streamHandler.handleIncomingStream(stream, connection, async (request, stream) => {
@@ -56,7 +95,6 @@ export class oNodeTool extends oTool(oServerNode) {
         };
     }
     async _tool_child_register(request) {
-        this.logger.debug('Child register: ', request.params);
         const { address, transports } = request.params;
         const childAddress = new oNodeAddress(address, transports.map((t) => new oNodeTransport(t)));
         // Add child to hierarchy

package/dist/src/router/o-node.address.d.ts

@@ -14,5 +14,6 @@ export declare class oNodeAddress extends oAddress {
     toString(): string;
     toMultiaddr(): Multiaddr;
     static fromMultiaddr(ma: Multiaddr): oAddress;
+    static fromProtocol(protocol: string): oAddress;
 }
 //# sourceMappingURL=o-node.address.d.ts.map

package/dist/src/router/o-node.address.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.address.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAa,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAqB,QAAQ,EAAiB,MAAM,eAAe,CAAC;AAE3E,qBAAa,YAAa,SAAQ,QAAQ;aAItB,KAAK,EAAE,MAAM;IAHxB,UAAU,EAAE,cAAc,EAAE,CAAM;gBAGvB,KAAK,EAAE,MAAM,EAC7B,UAAU,GAAE,cAAc,EAAO;IAMnC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAAC;KACpC,GAAG,YAAY;IAShB,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,QAAQ,IAAI,MAAM;IAIlB,WAAW,IAAI,SAAS;IAIxB,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,SAAS,GAAG,QAAQ;CAG9C"}
+{"version":3,"file":"o-node.address.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAa,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAiB,MAAM,eAAe,CAAC;AAExD,qBAAa,YAAa,SAAQ,QAAQ;aAItB,KAAK,EAAE,MAAM;IAHxB,UAAU,EAAE,cAAc,EAAE,CAAM;gBAGvB,KAAK,EAAE,MAAM,EAC7B,UAAU,GAAE,cAAc,EAAO;IAMnC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAAC;KACpC,GAAG,YAAY;IAShB,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,QAAQ,IAAI,MAAM;IAIlB,WAAW,IAAI,SAAS;IAIxB,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,SAAS,GAAG,QAAQ;IAI7C,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ;CAIhD"}

package/dist/src/router/o-node.address.js

@@ -26,4 +26,8 @@ export class oNodeAddress extends oAddress {
     static fromMultiaddr(ma) {
         return new oAddress(ma.toString().replace('/o/', 'o://'));
     }
+    static fromProtocol(protocol) {
+        const addressInput = protocol.replace('/o/', 'o://');
+        return new oAddress(addressInput);
+    }
 }

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

@@ -0,0 +1,9 @@
+import { Connection } from '@olane/o-config';
+import { oObject } from '@olane/o-core';
+export declare class ConnectionUtils extends oObject {
+    static addressFromConnection(options: {
+        currentNode: any;
+        connection: Connection;
+    }): Promise<import("@olane/o-core").oAddress>;
+}
+//# sourceMappingURL=connection.utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connection.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/connection.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAGxC,qBAAa,eAAgB,SAAQ,OAAO;WACtB,qBAAqB,CAAC,OAAO,EAAE;QACjD,WAAW,EAAE,GAAG,CAAC;QACjB,UAAU,EAAE,UAAU,CAAC;KACxB;CAsCF"}

package/dist/src/utils/connection.utils.js

@@ -0,0 +1,26 @@
+import { oObject } from '@olane/o-core';
+import { oNodeAddress } from '../router/o-node.address.js';
+export class ConnectionUtils extends oObject {
+    static async addressFromConnection(options) {
+        const { currentNode, connection } = options;
+        const p2pNode = currentNode.p2pNode;
+        // Extract the actual olane address from the peer store
+        const peers = await p2pNode.peerStore.all();
+        const remotePeer = peers.find((peer) => peer.id.toString() === connection.remotePeer.toString());
+        if (!remotePeer) {
+            console.log('Failed to find peer:', remotePeer);
+            throw new Error(`Failed to extract remote address, peer ${connection.remotePeer.toString()} not found in peer store.`);
+        }
+        // Get origin address for comparison
+        const originAddress = currentNode.address?.value;
+        if (!originAddress) {
+            throw new Error('Origin address is not configured');
+        }
+        const originProtocol = originAddress.toString();
+        const oProtocol = remotePeer.protocols.find((p) => p.startsWith('/o/') && p.startsWith(originProtocol) === false);
+        if (!oProtocol) {
+            throw new Error('Failed to extract remote address, could not find o-protocol in peer protocols.');
+        }
+        return oNodeAddress.fromProtocol(oProtocol);
+    }
+}

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

@@ -1,3 +1,4 @@
 export * from './stream.utils.js';
 export * from './network.utils.js';
+export * from './connection.utils.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC"}

package/dist/src/utils/index.js

@@ -1,2 +1,3 @@
 export * from './stream.utils.js';
 export * from './network.utils.js';
+export * from './connection.utils.js';

package/dist/test/astream-reuse.spec.d.ts

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

package/dist/test/astream-reuse.spec.d.ts.map

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

package/dist/test/astream-reuse.spec.js

@@ -0,0 +1,107 @@
+import { expect } from 'chai';
+import { TestEnvironment } from './helpers/index.js';
+import { NetworkTopologies, } from './helpers/network-builder.js';
+import { oNodeAddress } from '../src/router/o-node.address.js';
+describe('Stream Reuse', () => {
+    const env = new TestEnvironment();
+    let builder;
+    afterEach(async () => {
+        if (builder) {
+            await builder.cleanup();
+        }
+        await env.cleanup();
+    });
+    describe('Stream Reuse with reusePolicy="reuse"', () => {
+        it('should reuse the same stream across multiple requests', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Track stream IDs
+            const streamIds = [];
+            // Make first request
+            const response1 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'first' },
+            });
+            expect(response1.result.success).to.be.true;
+            // Get active connection to inspect streams
+            const connectionManager = leader.connectionManager;
+            const connection = connectionManager.getCachedLibp2pConnection(child.address);
+            connection.reusePolicy;
+            if (connection) {
+                // Store initial stream count and first stream ID
+                const initialStreamCount = connection.streams.length;
+                if (connection.streams.length > 0) {
+                    streamIds.push(connection.streams[0].id);
+                }
+                // Make second request
+                const response2 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                    method: 'echo',
+                    params: { message: 'second' },
+                });
+                expect(response2.result.success).to.be.true;
+                // Get stream count after second request
+                const finalStreamCount = connection.streams.length;
+                if (connection.streams.length > 0) {
+                    streamIds.push(connection.streams[0].id);
+                }
+                // With default behavior (reusePolicy='none'), new streams are created
+                // This test verifies current behavior
+                expect(streamIds.length).to.be.greaterThan(0);
+                expect(finalStreamCount).to.be.greaterThan(0);
+            }
+        });
+    });
+    describe('Stream Creation with reusePolicy="none"', () => {
+        it('should create new streams for each request', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Make multiple requests
+            for (let i = 0; i < 3; i++) {
+                const response = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                    method: 'echo',
+                    params: { message: `request-${i}` },
+                });
+                expect(response.result.success).to.be.true;
+            }
+            // Get connection to verify stream behavior
+            const connectionManager = leader.connectionManager;
+            const connection = connectionManager.getCachedLibp2pConnection(child.address);
+            // With default reusePolicy='none', streams are closed after each request
+            // So we expect minimal open streams
+            expect(connection).to.exist;
+            if (connection) {
+                // The number of open streams should be limited since old ones are closed
+                expect(connection.streams.length).to.be.lessThan(10);
+            }
+        });
+    });
+    describe('Stream Persistence After Transmission', () => {
+        it('should close streams after transmission with reusePolicy="none"', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Make a request
+            const response = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            expect(response.result.success).to.be.true;
+            // Get connection
+            const connectionManager = leader.connectionManager;
+            const connection = connectionManager.getCachedLibp2pConnection(child.address);
+            expect(connection).to.exist;
+            if (connection) {
+                // Make another request to verify new stream can be created
+                const response2 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                    method: 'echo',
+                    params: { message: 'test2' },
+                });
+                expect(response2.result.success).to.be.true;
+                // Verify connection is still functional
+                expect(connection.status).to.equal('open');
+            }
+        });
+    });
+});

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

@@ -16,6 +16,7 @@ describe('Connection Management', () => {
     describe('Connection Pooling', () => {
         it('should cache and reuse connections', async () => {
             builder = await NetworkTopologies.twoNode();
+            console.log('Built the 2 node network, starting test');
             const leader = builder.getNode('o://leader');
             const child = builder.getNode('o://child');
             const spy = createConnectionSpy(leader);

package/dist/test/helpers/network-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-builder.d.ts","sourceRoot":"","sources":["../../../test/helpers/network-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAC7E,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C;;GAEG;AACH,qBAAa,QAAS,SAAQ,SAAS;IAC9B,SAAS,SAAK;gBAET,MAAM,EAAE,eAAe,GAAG;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE;IAIzD,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;IAelC,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAwC/B,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAS3C,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAS9C,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,cAAc,CAAC,GAAG,CAAC;CAY5D;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;GAGG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,YAAY,CAA0B;IAE9C;;;OAGG;IACG,OAAO,CACX,OAAO,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,MAAM,EACtB,MAAM,GAAE,OAAO,CAAC,UAAU,CAAM,GAC/B,OAAO,CAAC,QAAQ,CAAC;IAqCpB;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB/C;;OAEG;IACG,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc9C;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAU9B;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAI9C;;OAEG;IACH,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC;IAIpC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAyC7B;;OAEG;YACW,iBAAiB;IAkB/B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B;AAED;;;;GAIG;AACH,qBAAa,iBAAiB;IAC5B;;;OAGG;WACU,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;IAO/C;;;OAGG;WACU,SAAS,IAAI,OAAO,CAAC,cAAc,CAAC;IAQjD;;;;OAIG;WACU,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC;IAUhD;;OAEG;WACU,aAAa,IAAI,OAAO,CAAC,cAAc,CAAC;IAOrD;;;;;OAKG;WACU,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;CAmBhD"}
+{"version":3,"file":"network-builder.d.ts","sourceRoot":"","sources":["../../../test/helpers/network-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAC7E,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C;;GAEG;AACH,qBAAa,QAAS,SAAQ,SAAS;IAC9B,SAAS,SAAK;gBAET,MAAM,EAAE,eAAe,GAAG;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE;IAIzD,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;IAelC,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAuC/B,UAAU,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAS3C,cAAc,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAS9C,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,cAAc,CAAC,GAAG,CAAC;CAY5D;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;GAGG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,YAAY,CAA0B;IAE9C;;;OAGG;IACG,OAAO,CACX,OAAO,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,MAAM,EACtB,MAAM,GAAE,OAAO,CAAC,UAAU,CAAM,GAC/B,OAAO,CAAC,QAAQ,CAAC;IAqCpB;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB/C;;OAEG;IACG,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc9C;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAU9B;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAI9C;;OAEG;IACH,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC;IAIpC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAyC7B;;OAEG;YACW,iBAAiB;IAkB/B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B;AAED;;;;GAIG;AACH,qBAAa,iBAAiB;IAC5B;;;OAGG;WACU,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;IAO/C;;;OAGG;WACU,SAAS,IAAI,OAAO,CAAC,cAAc,CAAC;IAQjD;;;;OAIG;WACU,QAAQ,IAAI,OAAO,CAAC,cAAc,CAAC;IAUhD;;OAEG;WACU,aAAa,IAAI,OAAO,CAAC,cAAc,CAAC;IAOrD;;;;;OAKG;WACU,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;CAmBhD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.39",
+  "version": "0.7.41",
   "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.39",
+    "@olane/o-test": "0.7.41",
     "@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.39",
-    "@olane/o-core": "0.7.39",
-    "@olane/o-protocol": "0.7.39",
-    "@olane/o-tool": "0.7.39",
+    "@olane/o-config": "0.7.41",
+    "@olane/o-core": "0.7.41",
+    "@olane/o-protocol": "0.7.41",
+    "@olane/o-tool": "0.7.41",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0",
     "json5": "^2.2.3"
   },
-  "gitHead": "9c992e3bda91a7d2b587392a1db5cff47a2ca23a"
+  "gitHead": "f705ab1099e0df6220c8f1d9a44e5b6cd09eb224"
 }