@olane/o-node 0.7.40 → 0.7.42

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.40",
+  "version": "0.7.42",
   "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.42",
     "@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.42",
+    "@olane/o-core": "0.7.42",
+    "@olane/o-protocol": "0.7.42",
+    "@olane/o-tool": "0.7.42",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0",
     "json5": "^2.2.3"
   },
-  "gitHead": "d2d7cb62d69249fe63d4cb293dbbdfc44d250f17"
+  "gitHead": "689465b34c2aefe28b6c87e3822d69651f2a49b7"
 }

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":""}