@olane/o-client-limited 0.7.50 → 0.7.52

package/dist/test/limited-connection-lifecycle.spec.js

@@ -0,0 +1,209 @@
+import { expect } from 'chai';
+import { TestEnvironment, createConnectionSpy, } from '@olane/o-node/test/helpers';
+import { oNodeAddress } from '@olane/o-node';
+import { LimitedTestTool, ReceiverTestTool } from './helpers/index.js';
+describe('Limited Connection Lifecycle', () => {
+    const env = new TestEnvironment();
+    let caller;
+    let receiver;
+    afterEach(async () => {
+        await env.cleanup();
+    });
+    describe('Connection Creation', () => {
+        it('should create limited connection with reuse policy', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const callerConn = caller.getFirstConnection();
+            expect(callerConn).to.exist;
+            expect(callerConn.reusePolicy).to.equal('reuse');
+        });
+        it('should initialize stream manager on first use', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Before first use, no connections
+            const connectionsBefore = Array.from(caller.connectionManager.connections.values());
+            expect(connectionsBefore).to.have.lengthOf(0);
+            // Make first request
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            // After first use, connection and stream manager should exist
+            const callerConn = caller.getFirstConnection();
+            expect(callerConn).to.exist;
+            expect(callerConn.streamManager).to.exist;
+        });
+    });
+    describe('Connection Reuse', () => {
+        it('should maintain single connection across multiple requests', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            const spy = createConnectionSpy(caller);
+            spy.start();
+            // Make multiple requests
+            for (let i = 0; i < 5; i++) {
+                await caller.use(receiverAddr, {
+                    method: 'echo',
+                    params: { message: `request-${i}` },
+                });
+            }
+            // Should only have 1 connection
+            const summary = spy.getSummary();
+            expect(summary.currentConnections).to.equal(1);
+            spy.stop();
+        });
+        it('should properly initialize when using ConnectionSpy', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            const spy = createConnectionSpy(caller);
+            spy.start();
+            // Make requests
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test1' },
+            });
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test2' },
+            });
+            const stats = spy.getConnectionStats();
+            expect(stats).to.have.lengthOf(1);
+            expect(stats[0].status).to.equal('open');
+            spy.stop();
+        });
+    });
+    describe('Cleanup', () => {
+        it('should cleanup all streams on close', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Create connection
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const callerConn = caller.getFirstConnection();
+            expect(callerConn).to.exist;
+            // Close connection
+            await callerConn.close();
+            // Connection should be closed
+            expect(callerConn.p2pConnection.status).to.equal('closed');
+        });
+        it('should handle cleanup during node stop', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Create connection
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const callerConn = caller.getFirstConnection();
+            const connectionId = callerConn.p2pConnection.id;
+            // Stop caller (should cleanup all connections)
+            await caller.stop();
+            // Connection should be closed
+            expect(callerConn.p2pConnection.status).to.equal('closed');
+        });
+    });
+    describe('Multiple Concurrent Connections', () => {
+        it('should handle multiple concurrent connections to different receivers', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            const receiver1 = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver1'),
+            });
+            const receiver2 = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver2'),
+            });
+            const receiver1Addr = new oNodeAddress(receiver1.address.toString(), receiver1.address.libp2pTransports);
+            const receiver2Addr = new oNodeAddress(receiver2.address.toString(), receiver2.address.libp2pTransports);
+            const spy = createConnectionSpy(caller);
+            spy.start();
+            // Make concurrent requests to both receivers
+            const promises = [];
+            for (let i = 0; i < 3; i++) {
+                promises.push(caller.use(receiver1Addr, {
+                    method: 'echo',
+                    params: { message: `r1-${i}` },
+                }));
+                promises.push(caller.use(receiver2Addr, {
+                    method: 'echo',
+                    params: { message: `r2-${i}` },
+                }));
+            }
+            const responses = await Promise.all(promises);
+            responses.forEach((response) => {
+                expect(response.result.success).to.be.true;
+            });
+            // Should have 2 connections (one to each receiver)
+            const summary = spy.getSummary();
+            expect(summary.currentConnections).to.equal(2);
+            // Each receiver should have received 3 requests
+            expect(receiver1.receivedRequests).to.have.lengthOf(3);
+            expect(receiver2.receivedRequests).to.have.lengthOf(3);
+            spy.stop();
+        });
+    });
+    describe('Connection State', () => {
+        it('should maintain connection state across requests', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Make first request
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'first' },
+            });
+            const callerConnFirst = caller.getFirstConnection();
+            const connectionIdFirst = callerConnFirst.p2pConnection.id;
+            // Make second request
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'second' },
+            });
+            const callerConnSecond = caller.getFirstConnection();
+            const connectionIdSecond = callerConnSecond.p2pConnection.id;
+            // Should be the same connection
+            expect(connectionIdFirst).to.equal(connectionIdSecond);
+            expect(callerConnFirst).to.equal(callerConnSecond);
+        });
+    });
+});

package/dist/test/limited-stream-manager.spec.d.ts

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

package/dist/test/limited-stream-manager.spec.d.ts.map

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

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

@@ -0,0 +1,222 @@
+import { expect } from 'chai';
+import { TestEnvironment } from '@olane/o-node/test/helpers';
+import { oNodeAddress } from '@olane/o-node';
+import { LimitedTestTool, ReceiverTestTool } from './helpers/index.js';
+describe('Limited Stream Manager', () => {
+    const env = new TestEnvironment();
+    let caller;
+    let receiver;
+    afterEach(async () => {
+        await env.cleanup();
+    });
+    describe('Initialization', () => {
+        it('should create dedicated reader stream on initialization', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Make a connection to trigger initialization
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            // Set up event listeners after connection
+            const callerConn = caller.getFirstConnection();
+            const receiverConn = receiver.getFirstConnection();
+            if (callerConn) {
+                caller.setupEventListeners(callerConn);
+            }
+            if (receiverConn) {
+                receiver.setupStreamListeners(receiverConn);
+            }
+            // Wait for events
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            // Verify reader stream was created
+            const readerEvents = caller.getReaderEvents();
+            expect(readerEvents.length).to.be.greaterThan(0);
+            // Verify receiver identified the reader stream
+            expect(receiver.identifiedStreams.length).to.be.greaterThan(0);
+            expect(receiver.identifiedStreams[0].role).to.equal('reader');
+        });
+        it('should send stream-init message with role=reader', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const receiverConn = receiver.getFirstConnection();
+            if (receiverConn) {
+                receiver.setupStreamListeners(receiverConn);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            // Receiver should have identified reader stream with correct role
+            expect(receiver.identifiedStreams.length).to.be.greaterThan(0);
+            const identified = receiver.identifiedStreams.find((s) => s.role === 'reader');
+            expect(identified).to.exist;
+        });
+        it('should start background reader loop', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const callerConn = caller.getFirstConnection();
+            if (callerConn) {
+                caller.setupEventListeners(callerConn);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            // Reader started event should be emitted
+            const readerStarted = caller
+                .getReaderEvents()
+                .find((e) => e.type === 'reader-started');
+            expect(readerStarted).to.exist;
+        });
+        it('should auto-initialize on first getOrCreateStream', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // First use should trigger auto-initialization
+            const response = await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'first-request' },
+            });
+            expect(response.result.success).to.be.true;
+            // Verify initialization happened
+            const callerConn = caller.getFirstConnection();
+            expect(callerConn).to.exist;
+            expect(callerConn.streamManager).to.exist;
+        });
+    });
+    describe('Stream Reuse', () => {
+        it('should reuse outbound streams across multiple requests', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Make multiple requests
+            for (let i = 0; i < 5; i++) {
+                const response = await caller.use(receiverAddr, {
+                    method: 'echo',
+                    params: { message: `request-${i}` },
+                });
+                expect(response.result.success).to.be.true;
+            }
+            // All requests should have been processed
+            expect(receiver.receivedRequests).to.have.lengthOf(5);
+            // Connection should still be active
+            const callerConn = caller.getFirstConnection();
+            expect(callerConn).to.exist;
+        });
+        it('should NOT close streams after releaseStream', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Make first request
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'first' },
+            });
+            const callerConn = caller.getFirstConnection();
+            const streamsBefore = callerConn?.p2pConnection?.streams?.length || 0;
+            // Make second request (should reuse stream)
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'second' },
+            });
+            const streamsAfter = callerConn?.p2pConnection?.streams?.length || 0;
+            // Stream count should not decrease (streams kept open)
+            expect(streamsAfter).to.be.greaterThanOrEqual(streamsBefore);
+        });
+    });
+    describe('Cleanup', () => {
+        it('should close reader stream on manager close', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const callerConn = caller.getFirstConnection();
+            expect(callerConn).to.exist;
+            // Close the connection
+            await callerConn.close();
+            // Verify cleanup (stream manager should be closed)
+            // We can't directly check private fields, but connection should be closed
+            expect(callerConn.p2pConnection.status).to.equal('closed');
+        });
+        it('should close outbound stream on manager close', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Create outbound stream
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const callerConn = caller.getFirstConnection();
+            // Stop caller (should close all connections and streams)
+            await caller.stop();
+            // Connection should be closed
+            expect(callerConn.p2pConnection.status).to.equal('closed');
+        });
+    });
+    describe('Events', () => {
+        it('should emit ReaderStarted event', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const callerConn = caller.getFirstConnection();
+            if (callerConn) {
+                caller.setupEventListeners(callerConn);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            const events = caller.streamManagerEvents;
+            const readerStarted = events.find((e) => e.type === 'reader-started');
+            expect(readerStarted).to.exist;
+            expect(readerStarted?.data.streamId).to.be.a('string');
+        });
+    });
+});

package/dist/test/reader-stream-recovery.spec.d.ts

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

package/dist/test/reader-stream-recovery.spec.d.ts.map

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

package/dist/test/reader-stream-recovery.spec.js

@@ -0,0 +1,188 @@
+import { expect } from 'chai';
+import { TestEnvironment } from '@olane/o-node/test/helpers';
+import { oNodeAddress } from '@olane/o-node';
+import { LimitedTestTool, ReceiverTestTool } from './helpers/index.js';
+describe('Reader Stream Recovery', () => {
+    const env = new TestEnvironment();
+    let caller;
+    let receiver;
+    afterEach(async () => {
+        await env.cleanup();
+    });
+    describe('Recovery Events', () => {
+        it('should emit ReaderStarted on initial creation', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const callerConn = caller.getFirstConnection();
+            if (callerConn) {
+                caller.setupEventListeners(callerConn);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            const readerEvents = caller.getReaderEvents();
+            const startedEvent = readerEvents.find((e) => e.type === 'reader-started');
+            expect(startedEvent).to.exist;
+            expect(startedEvent?.data).to.have.property('streamId');
+        });
+    });
+    describe('Graceful Degradation', () => {
+        it('should continue processing caller->receiver requests even if reader fails', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Establish connection
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'initial' },
+            });
+            const callerConn = caller.getFirstConnection();
+            if (callerConn) {
+                caller.setupEventListeners(callerConn);
+            }
+            // Even if reader stream has issues, outbound requests should still work
+            const response = await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'after-setup' },
+            });
+            expect(response.result.success).to.be.true;
+            expect(response.result.data.message).to.equal('after-setup');
+        });
+    });
+    describe('Reader Stream Lifecycle', () => {
+        it('should create reader stream only once per connection', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Make multiple requests
+            for (let i = 0; i < 5; i++) {
+                await caller.use(receiverAddr, {
+                    method: 'echo',
+                    params: { message: `request-${i}` },
+                });
+            }
+            const callerConn = caller.getFirstConnection();
+            if (callerConn) {
+                caller.setupEventListeners(callerConn);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            // Should only have one reader-started event
+            const readerStartedEvents = caller
+                .getReaderEvents()
+                .filter((e) => e.type === 'reader-started');
+            expect(readerStartedEvents.length).to.be.lessThanOrEqual(1);
+        });
+        it('should maintain reader stream across many requests', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            const callerAddr = new oNodeAddress(caller.address.toString(), caller.address.libp2pTransports);
+            // Establish connection
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'initial' },
+            });
+            const callerConn = caller.getFirstConnection();
+            const receiverConn = receiver.getFirstConnection();
+            if (callerConn) {
+                caller.setupEventListeners(callerConn);
+            }
+            if (receiverConn) {
+                receiver.setupStreamListeners(receiverConn);
+            }
+            // Wait for reader stream identification
+            await env.waitFor(() => receiver.identifiedStreams.length > 0, 5000, 100);
+            // Make many bidirectional requests
+            for (let i = 0; i < 10; i++) {
+                await caller.use(receiverAddr, {
+                    method: 'echo',
+                    params: { message: `c2r-${i}` },
+                });
+                await receiver.use(callerAddr, {
+                    method: 'echo',
+                    params: { message: `r2c-${i}` },
+                });
+            }
+            // Reader stream should still be identified
+            expect(receiver.identifiedStreams.length).to.be.greaterThan(0);
+            expect(receiver.identifiedStreams[0].role).to.equal('reader');
+        });
+    });
+    describe('Error Handling', () => {
+        it('should not crash if receiver closes connection during communication', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Establish connection
+            await caller.use(receiverAddr, {
+                method: 'echo',
+                params: { message: 'initial' },
+            });
+            // Close receiver connection
+            const receiverConn = receiver.getFirstConnection();
+            if (receiverConn) {
+                await receiverConn.close();
+            }
+            // Caller should handle the error gracefully
+            try {
+                await caller.use(receiverAddr, {
+                    method: 'echo',
+                    params: { message: 'after-close' },
+                });
+            }
+            catch (error) {
+                // Error is expected, but should not crash
+                expect(error).to.exist;
+            }
+            // Caller should still be running
+            expect(caller.state).to.equal('started');
+        });
+        it('should handle concurrent requests during reader stream setup', async () => {
+            caller = await env.createNode(LimitedTestTool, {
+                address: new oNodeAddress('o://caller'),
+            });
+            receiver = await env.createNode(ReceiverTestTool, {
+                address: new oNodeAddress('o://receiver'),
+            });
+            const receiverAddr = new oNodeAddress(receiver.address.toString(), receiver.address.libp2pTransports);
+            // Make concurrent requests immediately (reader stream might still be setting up)
+            const promises = [];
+            for (let i = 0; i < 5; i++) {
+                promises.push(caller.use(receiverAddr, {
+                    method: 'echo',
+                    params: { message: `concurrent-${i}` },
+                }));
+            }
+            const responses = await Promise.all(promises);
+            // All should succeed
+            responses.forEach((response, i) => {
+                expect(response.result.success).to.be.true;
+                expect(response.result.data.message).to.equal(`concurrent-${i}`);
+            });
+            expect(receiver.receivedRequests).to.have.lengthOf(5);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-client-limited",
-  "version": "0.7.50",
+  "version": "0.7.52",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -19,7 +19,7 @@
     "test": "aegir test",
     "test:node": "aegir test -t node",
     "test:browser": "aegir test -t browser",
-    "build": "tsc",
+    "build": "rm -rf dist && tsc",
     "deep:clean": "rm -rf node_modules && rm package-lock.json",
     "start:prod": "node dist/index.js",
     "prepublishOnly": "npm run build",
@@ -53,13 +53,13 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.50",
-    "@olane/o-core": "0.7.50",
-    "@olane/o-node": "0.7.50",
-    "@olane/o-protocol": "0.7.50",
-    "@olane/o-tool": "0.7.50",
+    "@olane/o-config": "0.7.52",
+    "@olane/o-core": "0.7.52",
+    "@olane/o-node": "0.7.52",
+    "@olane/o-protocol": "0.7.52",
+    "@olane/o-tool": "0.7.52",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0"
   },
-  "gitHead": "55f5464185ef16a164fa23dc46c0c08b317419a0"
+  "gitHead": "706ee0d5b546e96b6c05270b39035ee7e08dadbd"
 }

package/dist/test/configuration.spec.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=configuration.spec.d.ts.map