@olane/o-node 0.7.40 → 0.7.41

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.40",
+  "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.40",
+    "@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.40",
-    "@olane/o-core": "0.7.40",
-    "@olane/o-protocol": "0.7.40",
-    "@olane/o-tool": "0.7.40",
+    "@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": "d2d7cb62d69249fe63d4cb293dbbdfc44d250f17"
+  "gitHead": "f705ab1099e0df6220c8f1d9a44e5b6cd09eb224"
 }

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

@@ -1,57 +0,0 @@
-import type { Stream } from '@libp2p/interface';
-import type { oAddress } from '@olane/o-core';
-/**
- * oManagedStream 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 oManagedStream {
-    readonly stream: Stream;
-    readonly callerAddress: oAddress;
-    readonly receiverAddress: oAddress;
-    readonly direction: 'inbound' | 'outbound';
-    readonly createdAt: number;
-    private _lastUsedAt;
-    constructor(stream: Stream, callerAddress: oAddress, receiverAddress: oAddress, direction: 'inbound' | 'outbound');
-    /**
-     * Generates a bidirectional cache key from caller and receiver addresses.
-     * The key is symmetric: A↔B === B↔A
-     *
-     * @returns Cache key string in format "address1↔address2" (sorted)
-     */
-    get cacheKey(): string;
-    /**
-     * Checks if the stream is in a reusable state:
-     * - Stream status is 'open'
-     * - Write status is 'writable'
-     * - Remote read status is 'readable'
-     *
-     * @returns true if stream can be reused
-     */
-    get isReusable(): boolean;
-    /**
-     * Gets the last used timestamp
-     */
-    get lastUsedAt(): number;
-    /**
-     * Gets the age of the stream in milliseconds
-     */
-    get age(): number;
-    /**
-     * Gets the idle time in milliseconds since last use
-     */
-    get idleTime(): number;
-    /**
-     * Updates the last used timestamp to now
-     */
-    updateLastUsed(): void;
-    /**
-     * Gets a string representation of the managed stream for debugging
-     */
-    toString(): string;
-}
-//# sourceMappingURL=o-managed-stream.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"o-managed-stream.d.ts","sourceRoot":"","sources":["../../../src/connection/o-managed-stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C;;;;;;;;GAQG;AACH,qBAAa,cAAc;aAKP,MAAM,EAAE,MAAM;aACd,aAAa,EAAE,QAAQ;aACvB,eAAe,EAAE,QAAQ;aACzB,SAAS,EAAE,SAAS,GAAG,UAAU;IAPnD,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,OAAO,CAAC,WAAW,CAAS;gBAGV,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,QAAQ,EACvB,eAAe,EAAE,QAAQ,EACzB,SAAS,EAAE,SAAS,GAAG,UAAU;IAMnD;;;;;OAKG;IACH,IAAI,QAAQ,IAAI,MAAM,CAQrB;IAED;;;;;;;OAOG;IACH,IAAI,UAAU,IAAI,OAAO,CAMxB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;OAEG;IACH,IAAI,GAAG,IAAI,MAAM,CAEhB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;OAEG;IACH,cAAc,IAAI,IAAI;IAItB;;OAEG;IACH,QAAQ,IAAI,MAAM;CAGnB"}

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

@@ -1,76 +0,0 @@
-/**
- * oManagedStream 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 oManagedStream {
-    constructor(stream, callerAddress, receiverAddress, direction) {
-        this.stream = stream;
-        this.callerAddress = callerAddress;
-        this.receiverAddress = receiverAddress;
-        this.direction = direction;
-        this.createdAt = Date.now();
-        this._lastUsedAt = this.createdAt;
-    }
-    /**
-     * Generates a bidirectional cache key from caller and receiver addresses.
-     * The key is symmetric: A↔B === B↔A
-     *
-     * @returns Cache key string in format "address1↔address2" (sorted)
-     */
-    get cacheKey() {
-        // Sort addresses to ensure bidirectionality
-        const addresses = [
-            this.callerAddress.value,
-            this.receiverAddress.value,
-        ].sort();
-        return `${addresses[0]}↔${addresses[1]}`;
-    }
-    /**
-     * Checks if the stream is in a reusable state:
-     * - Stream status is 'open'
-     * - Write status is 'writable'
-     * - Remote read status is 'readable'
-     *
-     * @returns true if stream can be reused
-     */
-    get isReusable() {
-        return (this.stream.status === 'open' &&
-            this.stream.writeStatus === 'writable' &&
-            this.stream.remoteReadStatus === 'readable');
-    }
-    /**
-     * Gets the last used timestamp
-     */
-    get lastUsedAt() {
-        return this._lastUsedAt;
-    }
-    /**
-     * Gets the age of the stream in milliseconds
-     */
-    get age() {
-        return Date.now() - this.createdAt;
-    }
-    /**
-     * Gets the idle time in milliseconds since last use
-     */
-    get idleTime() {
-        return Date.now() - this._lastUsedAt;
-    }
-    /**
-     * Updates the last used timestamp to now
-     */
-    updateLastUsed() {
-        this._lastUsedAt = Date.now();
-    }
-    /**
-     * Gets a string representation of the managed stream for debugging
-     */
-    toString() {
-        return `oManagedStream(${this.cacheKey}, ${this.direction}, ${this.stream.status})`;
-    }
-}

package/dist/test/o-managed-stream.spec.d.ts

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

package/dist/test/o-managed-stream.spec.d.ts.map

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

package/dist/test/o-managed-stream.spec.js

@@ -1,122 +0,0 @@
-import { expect } from 'chai';
-import { oManagedStream } from '../src/connection/o-managed-stream.js';
-import { oAddress } from '@olane/o-core';
-describe('oManagedStream', () => {
-    let mockStream;
-    let callerAddress;
-    let receiverAddress;
-    beforeEach(() => {
-        // Create mock stream
-        mockStream = {
-            id: 'test-stream-id',
-            status: 'open',
-            writeStatus: 'writable',
-            remoteReadStatus: 'readable',
-            direction: 'outbound',
-            protocol: '/o/test',
-            addEventListener: () => { },
-        };
-        callerAddress = new oAddress('o://caller');
-        receiverAddress = new oAddress('o://receiver');
-    });
-    describe('Construction', () => {
-        it('should create managed stream with correct properties', () => {
-            const managedStream = new oManagedStream(mockStream, callerAddress, receiverAddress, 'outbound');
-            expect(managedStream.stream).to.equal(mockStream);
-            expect(managedStream.callerAddress).to.equal(callerAddress);
-            expect(managedStream.receiverAddress).to.equal(receiverAddress);
-            expect(managedStream.direction).to.equal('outbound');
-            expect(managedStream.createdAt).to.be.a('number');
-            expect(managedStream.lastUsedAt).to.equal(managedStream.createdAt);
-        });
-    });
-    describe('Cache Key Generation', () => {
-        it('should generate bidirectional cache key (A→B === B→A)', () => {
-            const streamAtoB = new oManagedStream(mockStream, callerAddress, receiverAddress, 'outbound');
-            const streamBtoA = new oManagedStream(mockStream, receiverAddress, callerAddress, 'inbound');
-            // Cache keys should be identical regardless of direction
-            expect(streamAtoB.cacheKey).to.equal(streamBtoA.cacheKey);
-        });
-        it('should generate different keys for different address pairs', () => {
-            const address1 = new oAddress('o://node-1');
-            const address2 = new oAddress('o://node-2');
-            const address3 = new oAddress('o://node-3');
-            const stream1 = new oManagedStream(mockStream, address1, address2, 'outbound');
-            const stream2 = new oManagedStream(mockStream, address1, address3, 'outbound');
-            expect(stream1.cacheKey).to.not.equal(stream2.cacheKey);
-        });
-        it('should create stable, sorted cache keys', () => {
-            const managedStream = new oManagedStream(mockStream, callerAddress, receiverAddress, 'outbound');
-            const expectedKey = [callerAddress.value, receiverAddress.value]
-                .sort()
-                .join('↔');
-            expect(managedStream.cacheKey).to.equal(expectedKey);
-        });
-    });
-    describe('Reusability Check', () => {
-        it('should be reusable when stream is open, writable, and readable', () => {
-            mockStream.status = 'open';
-            mockStream.writeStatus = 'writable';
-            mockStream.remoteReadStatus = 'readable';
-            const managedStream = new oManagedStream(mockStream, callerAddress, receiverAddress, 'outbound');
-            expect(managedStream.isReusable).to.be.true;
-        });
-        it('should not be reusable when stream is closed', () => {
-            mockStream.status = 'closed';
-            mockStream.writeStatus = 'writable';
-            mockStream.remoteReadStatus = 'readable';
-            const managedStream = new oManagedStream(mockStream, callerAddress, receiverAddress, 'outbound');
-            expect(managedStream.isReusable).to.be.false;
-        });
-        it('should not be reusable when stream is not writable', () => {
-            mockStream.status = 'open';
-            mockStream.writeStatus = 'closed';
-            mockStream.remoteReadStatus = 'readable';
-            const managedStream = new oManagedStream(mockStream, callerAddress, receiverAddress, 'outbound');
-            expect(managedStream.isReusable).to.be.false;
-        });
-        it('should not be reusable when remote is not readable', () => {
-            mockStream.status = 'open';
-            mockStream.writeStatus = 'writable';
-            mockStream.remoteReadStatus = 'closed';
-            const managedStream = new oManagedStream(mockStream, callerAddress, receiverAddress, 'outbound');
-            expect(managedStream.isReusable).to.be.false;
-        });
-    });
-    describe('Timestamp Management', () => {
-        it('should update lastUsedAt when updateLastUsed is called', async () => {
-            const managedStream = new oManagedStream(mockStream, callerAddress, receiverAddress, 'outbound');
-            const initialLastUsed = managedStream.lastUsedAt;
-            // Wait a bit to ensure timestamp difference
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            managedStream.updateLastUsed();
-            expect(managedStream.lastUsedAt).to.be.greaterThan(initialLastUsed);
-        });
-        it('should calculate age correctly', async () => {
-            const managedStream = new oManagedStream(mockStream, callerAddress, receiverAddress, 'outbound');
-            // Wait a bit
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(managedStream.age).to.be.greaterThan(0);
-            expect(managedStream.age).to.be.lessThan(1000); // Should be less than 1 second
-        });
-        it('should calculate idle time correctly', async () => {
-            const managedStream = new oManagedStream(mockStream, callerAddress, receiverAddress, 'outbound');
-            // Wait a bit without using
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            expect(managedStream.idleTime).to.be.greaterThan(0);
-            // Update and check idle time resets
-            managedStream.updateLastUsed();
-            expect(managedStream.idleTime).to.be.lessThan(5);
-        });
-    });
-    describe('String Representation', () => {
-        it('should provide meaningful toString output', () => {
-            const managedStream = new oManagedStream(mockStream, callerAddress, receiverAddress, 'outbound');
-            const str = managedStream.toString();
-            expect(str).to.include('oManagedStream');
-            expect(str).to.include(managedStream.cacheKey);
-            expect(str).to.include('outbound');
-            expect(str).to.include('open');
-        });
-    });
-});

package/dist/test/stream-handler-caching.spec.d.ts

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

package/dist/test/stream-handler-caching.spec.d.ts.map

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

package/dist/test/stream-handler-caching.spec.js

@@ -1,261 +0,0 @@
-import { expect } from 'chai';
-import { StreamHandler } from '../src/connection/stream-handler.js';
-import { oAddress } from '@olane/o-core';
-describe('StreamHandler Address-Based Caching', () => {
-    let streamHandler;
-    let mockConnection;
-    let mockStream;
-    let callerAddress;
-    let receiverAddress;
-    beforeEach(() => {
-        streamHandler = new StreamHandler();
-        // Create mock connection
-        mockConnection = {
-            status: 'open',
-            remotePeer: {
-                toString: () => 'test-peer-id',
-            },
-            remoteAddr: {
-                toString: () => '/memory/test',
-            },
-            streams: [],
-            newStream: async () => mockStream,
-        };
-        // Create mock stream
-        mockStream = {
-            id: 'test-stream-id',
-            status: 'open',
-            writeStatus: 'writable',
-            remoteReadStatus: 'readable',
-            direction: 'outbound',
-            protocol: '/o/test',
-            addEventListener: () => { },
-        };
-        callerAddress = new oAddress('o://caller');
-        receiverAddress = new oAddress('o://receiver');
-    });
-    describe('getOrCreateStream with Address-Based Caching', () => {
-        it('should create new stream when cache is empty', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            const stream = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            expect(stream).to.equal(mockStream);
-        });
-        it('should reuse cached stream with same caller-receiver pair', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            // First call creates and caches
-            const stream1 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            // Second call should reuse
-            const stream2 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            expect(stream1).to.equal(stream2);
-        });
-        it('should reuse stream bidirectionally (A→B same as B→A)', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            // First: caller → receiver
-            const streamAtoB = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            const stream1 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAtoB);
-            // Second: receiver → caller (reversed)
-            const streamBtoA = {
-                callerAddress: receiverAddress,
-                receiverAddress: callerAddress,
-                direction: 'inbound',
-            };
-            const stream2 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamBtoA);
-            // Should be the same stream due to bidirectional caching
-            expect(stream1).to.equal(stream2);
-        });
-        it('should create new stream for different address pairs', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const otherReceiver = new oAddress('o://other-receiver');
-            // Create new mock stream for second call
-            const mockStream2 = {
-                ...mockStream,
-                id: 'test-stream-id-2',
-            };
-            let streamCount = 0;
-            mockConnection.newStream = async () => {
-                streamCount++;
-                return (streamCount === 1 ? mockStream : mockStream2);
-            };
-            // First pair
-            const stream1 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            });
-            // Different pair
-            const stream2 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, {
-                callerAddress,
-                receiverAddress: otherReceiver,
-                direction: 'outbound',
-            });
-            // Should be different streams
-            expect(stream1.id).to.not.equal(stream2.id);
-        });
-        it('should not cache when reusePolicy is none', async () => {
-            const config = {
-                reusePolicy: 'none',
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            let callCount = 0;
-            mockConnection.newStream = async () => {
-                callCount++;
-                return {
-                    ...mockStream,
-                    id: `stream-${callCount}`,
-                };
-            };
-            const stream1 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            const stream2 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            // Should be different streams (not cached)
-            expect(stream1.id).to.not.equal(stream2.id);
-        });
-        it('should remove non-reusable streams from cache', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            // First call creates and caches
-            const stream1 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            // Make stream non-reusable
-            mockStream.status = 'closed';
-            // Create new mock stream for second call
-            const mockStream2 = {
-                ...mockStream,
-                id: 'test-stream-id-2',
-                status: 'open',
-            };
-            mockConnection.newStream = async () => mockStream2;
-            // Second call should create new stream (old one not reusable)
-            const stream2 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            expect(stream1.id).to.not.equal(stream2.id);
-        });
-        it('should fall back to protocol-based check when addresses not provided', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            // Add mock stream to connection streams
-            mockConnection.streams = [mockStream];
-            // Call without streamAddresses
-            const stream = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config);
-            // Should find and return the existing stream by protocol
-            expect(stream).to.equal(mockStream);
-        });
-    });
-    describe('extractRemotePeerAddress', () => {
-        it('should extract address from connection peer ID', () => {
-            const address = streamHandler.extractRemotePeerAddress(mockConnection);
-            expect(address.value).to.include('o://peer/');
-            expect(address.value).to.include('test-peer-id');
-        });
-    });
-    describe('cacheInboundStream', () => {
-        it('should cache inbound stream when reuse is enabled', async () => {
-            streamHandler.cacheInboundStream(mockStream, callerAddress, receiverAddress, 'reuse');
-            // Try to get the cached stream
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            const stream = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            // Should reuse the cached inbound stream
-            expect(stream).to.equal(mockStream);
-        });
-        it('should not cache when reusePolicy is none', async () => {
-            streamHandler.cacheInboundStream(mockStream, callerAddress, receiverAddress, 'none');
-            // Try to get stream - should create new one
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const newMockStream = { ...mockStream, id: 'new-stream-id' };
-            mockConnection.newStream = async () => newMockStream;
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            const stream = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            // Should not reuse (was not cached)
-            expect(stream.id).to.equal('new-stream-id');
-        });
-        it('should not cache duplicate streams', () => {
-            // Cache first time
-            streamHandler.cacheInboundStream(mockStream, callerAddress, receiverAddress, 'reuse');
-            // Try to cache again - should be no-op
-            streamHandler.cacheInboundStream(mockStream, callerAddress, receiverAddress, 'reuse');
-            // No error should occur, and stream should still be cached
-            // (This test mainly ensures no exception is thrown)
-        });
-    });
-    describe('Stream Cleanup', () => {
-        it('should remove stream from cache on close event', (done) => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            let closeListener;
-            // Override addEventListener to capture the close listener
-            mockStream.addEventListener = (event, listener) => {
-                if (event === 'close') {
-                    closeListener = listener;
-                }
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            streamHandler
-                .getOrCreateStream(mockConnection, '/o/test', config, streamAddresses)
-                .then(() => {
-                expect(closeListener).to.not.be.undefined;
-                // Simulate close event
-                if (closeListener) {
-                    closeListener();
-                }
-                // Create new stream for next call
-                const newMockStream = { ...mockStream, id: 'new-stream-after-close' };
-                mockConnection.newStream = async () => newMockStream;
-                // Try to get stream again - should create new one since old one was removed
-                return streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            })
-                .then((stream) => {
-                expect(stream.id).to.equal('new-stream-after-close');
-                done();
-            })
-                .catch(done);
-        });
-    });
-});