@olane/o-node 0.7.12 → 0.7.13-alpha.1

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

@@ -11,6 +11,11 @@ import { StreamHandler } from './connection/stream-handler.js';
  */
 export class oNodeTool extends oTool(oServerNode) {
     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);
         await this.p2pNode.handle(address.protocol, this.handleStream.bind(this), {
             maxInboundStreams: 10000,

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.router.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAML,cAAc,EAGd,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAM5C,qBAAa,WAAY,SAAQ,WAAW;IAC1C,OAAO,CAAC,aAAa,CAAqB;;IAO1C;;;;;;;;OAQG;cACa,OAAO,CACrB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,KAAK,GACV,OAAO,CAAC,GAAG,CAAC;IA6Bf;;;OAGG;YACW,kBAAkB;IA8DhC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAWhC;;OAEG;YACW,eAAe;IAsC7B;;;OAGG;IACG,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IAyB3E;;;OAGG;IACH,UAAU,CAAC,qBAAqB,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;CAGtE"}
+{"version":3,"file":"o-node.router.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAML,cAAc,EAGd,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAM5C,qBAAa,WAAY,SAAQ,WAAW;IAC1C,OAAO,CAAC,aAAa,CAAqB;;IAO1C;;;;;;;;OAQG;cACa,OAAO,CACrB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,KAAK,GACV,OAAO,CAAC,GAAG,CAAC;IA6Bf;;;OAGG;YACW,kBAAkB;IA8DhC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAWhC;;OAEG;YACW,eAAe;IAsC7B;;;OAGG;IACG,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IAmC3E;;;OAGG;IACH,UAAU,CAAC,qBAAqB,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;CAGtE"}

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

@@ -141,7 +141,7 @@ export class oNodeRouter extends oToolRouter {
         }
         catch (error) {
             if (error?.name === 'UnsupportedProtocolError') {
-                throw new oError(oErrorCodes.NOT_FOUND, 'Address not found');
+                throw new oError(oErrorCodes.NOT_FOUND, 'Address not found: ' + address.value);
             }
             throw error;
         }
@@ -151,17 +151,27 @@ export class oNodeRouter extends oToolRouter {
      * First checks routing policy for external routing, then applies resolver chain.
      */
     async translate(address, node) {
-        // Check if external routing is needed
-        const externalRoute = this.routingPolicy.getExternalRoutingStrategy(address, node);
-        if (externalRoute) {
-            return externalRoute;
-        }
         // Apply resolver chain for internal routing
+        if (!node.parent && !node.leader && address.transports?.length > 0) {
+            // independent node
+            return {
+                nextHopAddress: address,
+                targetAddress: address,
+            };
+        }
         const { nextHopAddress, targetAddress, requestOverride } = await this.addressResolution.resolve({
             address,
             node,
             targetAddress: address,
         });
+        // if we defaulted back to the leader
+        if (nextHopAddress.value === oAddress.leader().value) {
+            // Check if external routing is needed for leader routing
+            const externalRoute = this.routingPolicy.getExternalRoutingStrategy(address, node);
+            if (externalRoute) {
+                return externalRoute;
+            }
+        }
         return {
             nextHopAddress,
             targetAddress: targetAddress,

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.routing-policy.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.routing-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,cAAc;IACpD;;;;;;;;;OASG;IACH,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IAuB1D;;;;;;;;OAQG;IACH,0BAA0B,CACxB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,KAAK,GACV,aAAa,GAAG,IAAI;CAmBxB"}
+{"version":3,"file":"o-node.routing-policy.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.routing-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,cAAc;IACpD;;;;;;;;;OASG;IACH,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IA4B1D;;;;;;;;OAQG;IACH,0BAA0B,CACxB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,KAAK,GACV,aAAa,GAAG,IAAI;CAmBxB"}

package/dist/src/router/o-node.routing-policy.js

@@ -21,6 +21,10 @@ export class oNodeRoutingPolicy extends oRoutingPolicy {
         if (node.hierarchyManager.parents.some((p) => p.equals(address))) {
             return true;
         }
+        // if we are trying to connect to a child, it's internal
+        if (node.hierarchyManager.children.some((p) => p.equals(address))) {
+            return true;
+        }
         if (nodeAddress.paths.indexOf(oAddress.leader().paths) !== -1 && // if the address has a leader
             nodeAddress.libp2pTransports?.length > 0) {
             // transports are provided, let's see if they match our known leaders

package/dist/test/connection-management.spec.d.ts

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

package/dist/test/connection-management.spec.d.ts.map

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

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

@@ -0,0 +1,370 @@
+import { expect } from 'chai';
+import { TestEnvironment } from './helpers/index.js';
+import { NetworkBuilder, NetworkTopologies } from './helpers/network-builder.js';
+import { createConnectionSpy } from './helpers/connection-spy.js';
+import { oNodeAddress } from '../src/router/o-node.address.js';
+import { oNodeTransport } from '../src/index.js';
+describe('Connection Management', () => {
+    const env = new TestEnvironment();
+    let builder;
+    afterEach(async () => {
+        if (builder) {
+            await builder.cleanup();
+        }
+        await env.cleanup();
+    });
+    describe('Connection Pooling', () => {
+        it('should cache and reuse connections', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            // Make first request (establishes connection)
+            await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'ping',
+                params: { message: 'first' },
+            });
+            const connectionsAfterFirst = spy.getSummary().currentConnections;
+            // Make second request (should reuse connection)
+            await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'ping',
+                params: { message: 'second' },
+            });
+            const connectionsAfterSecond = spy.getSummary().currentConnections;
+            // Connection count should remain the same (reused)
+            expect(connectionsAfterFirst).to.equal(connectionsAfterSecond);
+            expect(connectionsAfterFirst).to.be.greaterThan(0);
+            spy.stop();
+        });
+        it('should maintain separate connections to different nodes', async () => {
+            builder = await NetworkTopologies.fiveNode();
+            const leader = builder.getNode('o://leader');
+            const parent1 = builder.getNode('o://parent1');
+            const parent2 = builder.getNode('o://parent2');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            // Call different nodes
+            await leader.use(parent1.address, {
+                method: 'echo',
+                params: { message: 'to parent1' },
+            });
+            await leader.use(parent2.address, {
+                method: 'echo',
+                params: { message: 'to parent2' },
+            });
+            const stats = spy.getConnectionStats();
+            // Should have connections to both parents
+            expect(stats.length).to.be.greaterThan(1);
+            spy.stop();
+        });
+        it('should handle connection pool efficiently under load', async () => {
+            builder = await NetworkTopologies.fiveNode();
+            const leader = builder.getNode('o://leader');
+            const child1 = builder.getNode('o://child1');
+            const child2 = builder.getNode('o://child2');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            // Make many requests to different nodes
+            const promises = [];
+            for (let i = 0; i < 50; i++) {
+                const target = i % 2 === 0 ? child1 : child2;
+                promises.push(leader.use(target.address, {
+                    method: 'echo',
+                    params: { message: `request-${i}` },
+                }));
+            }
+            await Promise.all(promises);
+            const summary = spy.getSummary();
+            // Connection count should be reasonable (not 50)
+            expect(summary.currentConnections).to.be.lessThan(10);
+            expect(summary.currentConnections).to.be.greaterThan(0);
+            spy.stop();
+        });
+    });
+    describe('Connection Status', () => {
+        it('should report correct connection status', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            // Establish connection
+            await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const stats = spy.getConnectionStats();
+            expect(stats.length).to.be.greaterThan(0);
+            const connection = stats[0];
+            expect(connection.status).to.equal('open');
+            expect(connection.peerId).to.be.a('string');
+            expect(connection.remoteAddr).to.be.a('string');
+            spy.stop();
+        });
+        it('should detect open connections', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Get child's peer ID
+            const childPeerId = child.address.libp2pTransports[0].toPeerId();
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            // Establish connection
+            await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            // Verify connection exists
+            const hasConnection = spy.hasConnectionToPeer(childPeerId);
+            expect(hasConnection).to.be.true;
+            spy.stop();
+        });
+    });
+    describe('Connection Validation', () => {
+        it('should validate connection before transmission', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Valid connection should work
+            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;
+        });
+        it('should handle connection to unreachable node', async () => {
+            builder = new NetworkBuilder();
+            const leader = await builder.addNode('o://leader');
+            // Create address to non-existent node
+            const fakeAddress = new oNodeAddress('o://nonexistent', [
+                new oNodeTransport('/ip4/127.0.0.1/tcp/4099'),
+            ]);
+            // Attempt to connect should fail gracefully
+            await leader.use(fakeAddress, {
+                method: 'echo',
+                params: { message: 'test' },
+            }).catch((err) => {
+                expect(err.message).to.be.equal('Unable to extract peer ID from address: o://nonexistent');
+            });
+        });
+        it('should verify connection is open before use', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            // Make request
+            await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            // Verify connection is open
+            const stats = spy.getConnectionStats();
+            expect(stats.length).to.be.greaterThan(0);
+            expect(stats[0].status).to.equal('open');
+            spy.stop();
+        });
+    });
+    describe('Connection Recovery', () => {
+        it('should handle transient connection errors', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Make successful request
+            const response1 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'before' },
+            });
+            expect(response1.result.success).to.be.true;
+            // Simulate brief disconnection by stopping and restarting child
+            await child.stop();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            await child.start();
+            // Wait for reconnection
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            // Subsequent request should eventually work
+            // Note: May need retry logic depending on implementation
+            const response2 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'after' },
+            });
+            // This may fail if connection not re-established
+            // Test verifies graceful error handling
+            if (response2.result.success) {
+                expect(response2.result.data.message).to.equal('after');
+            }
+            else {
+                expect(response2.result.error).to.exist;
+            }
+        });
+        it('should maintain other connections when one fails', async () => {
+            builder = await NetworkTopologies.fiveNode();
+            const leader = builder.getNode('o://leader');
+            const child1 = builder.getNode('o://child1');
+            const child2 = builder.getNode('o://child2');
+            // Establish connections to both children
+            await leader.use(child1.address, {
+                method: 'echo',
+                params: { message: 'child1' },
+            });
+            await leader.use(child2.address, {
+                method: 'echo',
+                params: { message: 'child2' },
+            });
+            // Stop child1
+            await builder.stopNode('o://child1');
+            // Connection to child2 should still work
+            const response = await leader.use(child2.address, {
+                method: 'echo',
+                params: { message: 'child2-after' },
+            });
+            expect(response.result.success).to.be.true;
+            expect(response.result.data.message).to.equal('child2-after');
+        });
+    });
+    describe('Multi-node Connection Management', () => {
+        it('should manage connections in complex topology', async () => {
+            builder = await NetworkTopologies.complex();
+            const leader = builder.getNode('o://leader');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            // Make requests to various nodes
+            for (let i = 1; i <= 3; i++) {
+                const parent = builder.getNode(`o://parent${i}`);
+                await leader.use(parent.address, {
+                    method: 'echo',
+                    params: { message: `parent${i}` },
+                });
+            }
+            const summary = spy.getSummary();
+            // Should have connections to parents
+            expect(summary.currentConnections).to.be.greaterThan(0);
+            expect(summary.currentConnections).to.be.lessThan(10);
+            spy.stop();
+        });
+    });
+    describe('Connection Metadata', () => {
+        it('should track connection creation time', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            const beforeTime = Date.now();
+            await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const afterTime = Date.now();
+            const stats = spy.getConnectionStats();
+            if (stats.length > 0) {
+                expect(stats[0].created).to.be.at.least(beforeTime);
+                expect(stats[0].created).to.be.at.most(afterTime);
+            }
+            spy.stop();
+        });
+        it('should track remote peer information', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const stats = spy.getConnectionStats();
+            if (stats.length > 0) {
+                const connection = stats[0];
+                expect(connection.peerId).to.be.a('string');
+                expect(connection.peerId.length).to.be.greaterThan(0);
+                expect(connection.remoteAddr).to.be.a('string');
+                expect(connection.remoteAddr.length).to.be.greaterThan(0);
+            }
+            spy.stop();
+        });
+    });
+    describe('Connection Gating', () => {
+        it('should enforce connection gating rules', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Parent-child connections should be allowed
+            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;
+        });
+        it('should allow connections within hierarchy', async () => {
+            builder = await NetworkTopologies.threeNode();
+            const leader = builder.getNode('o://leader');
+            const parent = builder.getNode('o://parent');
+            const child = builder.getNode('o://child');
+            // All connections in hierarchy should work
+            const response1 = await leader.use(parent.address, {
+                method: 'echo',
+                params: { message: 'leader-to-parent' },
+            });
+            const response2 = await parent.use(child.address, {
+                method: 'echo',
+                params: { message: 'parent-to-child' },
+            });
+            const response3 = await child.use(parent.address, {
+                method: 'echo',
+                params: { message: 'child-to-parent' },
+            });
+            expect(response1.result.success).to.be.true;
+            expect(response2.result.success).to.be.true;
+            expect(response3.result.success).to.be.true;
+        });
+    });
+    describe('Connection Cleanup', () => {
+        it('should clean up connections on node stop', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Establish connection
+            await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            const beforeConnections = spy.getSummary().currentConnections;
+            expect(beforeConnections).to.be.greaterThan(0);
+            // Stop child
+            await builder.stopNode('o://child');
+            // Wait for cleanup
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            // Note: Connection may still exist until cleanup cycle runs
+            // This test verifies stop mechanism doesn't throw errors
+            spy.stop();
+        });
+        it('should handle cleanup of multiple connections', async () => {
+            builder = await NetworkTopologies.fiveNode();
+            const leader = builder.getNode('o://leader');
+            // Establish connections
+            const child1 = builder.getNode('o://child1');
+            const child2 = builder.getNode('o://child2');
+            await leader.use(child1.address, {
+                method: 'echo',
+                params: { message: 'child1' },
+            });
+            await leader.use(child2.address, {
+                method: 'echo',
+                params: { message: 'child2' },
+            });
+            // Stop all children
+            await builder.stopNode('o://child1');
+            await builder.stopNode('o://child2');
+            // Leader should remain operational
+            const response = await leader.use(leader.address, {
+                method: 'get_info',
+                params: {},
+            });
+            expect(response.result.success).to.be.true;
+        });
+    });
+});

package/dist/test/helpers/connection-spy.d.ts

@@ -0,0 +1,124 @@
+import { oNode } from '../../src/o-node.js';
+import { oNodeTool } from '../../src/o-node.tool.js';
+import type { Connection, Stream } from '@libp2p/interface';
+/**
+ * Connection event captured by the spy
+ */
+export interface ConnectionEvent {
+    type: 'peer:connect' | 'peer:disconnect' | 'connection:open' | 'connection:close' | 'stream:open' | 'stream:close';
+    timestamp: number;
+    peerId?: string;
+    remoteAddr?: string;
+    protocol?: string;
+    streamId?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Stream statistics
+ */
+export interface StreamStats {
+    protocol: string;
+    status: string;
+    writeStatus?: string;
+    readStatus?: string;
+    created: number;
+    closed?: number;
+}
+/**
+ * Connection statistics
+ */
+export interface ConnectionStats {
+    peerId: string;
+    status: string;
+    remoteAddr: string;
+    streams: StreamStats[];
+    created: number;
+    closed?: number;
+}
+/**
+ * Spy that monitors libp2p connections and streams for testing
+ */
+export declare class ConnectionSpy {
+    private events;
+    private node;
+    private listeners;
+    private isMonitoring;
+    constructor(node: oNode | oNodeTool);
+    /**
+     * Start monitoring connection events
+     */
+    start(): void;
+    /**
+     * Stop monitoring
+     */
+    stop(): void;
+    /**
+     * Clear all captured events
+     */
+    clear(): void;
+    /**
+     * Get all captured events
+     */
+    getEvents(): ConnectionEvent[];
+    /**
+     * Get events of a specific type
+     */
+    getEventsByType(type: ConnectionEvent['type']): ConnectionEvent[];
+    /**
+     * Get events for a specific peer
+     */
+    getEventsForPeer(peerId: string): ConnectionEvent[];
+    /**
+     * Get current connection statistics
+     */
+    getConnectionStats(): ConnectionStats[];
+    /**
+     * Get total stream count across all connections
+     */
+    getTotalStreamCount(): number;
+    /**
+     * Get stream count for a specific protocol
+     */
+    getStreamCountByProtocol(protocol: string): number;
+    /**
+     * Check if a connection exists to a peer
+     */
+    hasConnectionToPeer(peerId: string): boolean;
+    /**
+     * Get connection to a specific peer
+     */
+    getConnectionToPeer(peerId: string): Connection | undefined;
+    /**
+     * Get all streams for a specific peer
+     */
+    getStreamsForPeer(peerId: string): Stream[];
+    /**
+     * Wait for a specific event to occur
+     */
+    waitForEvent(type: ConnectionEvent['type'], timeoutMs?: number): Promise<ConnectionEvent>;
+    /**
+     * Wait for connection to a specific peer
+     */
+    waitForConnectionToPeer(peerId: string, timeoutMs?: number): Promise<Connection>;
+    /**
+     * Wait for stream count to reach expected value
+     */
+    waitForStreamCount(expectedCount: number, timeoutMs?: number): Promise<void>;
+    /**
+     * Get summary of connection activity
+     */
+    getSummary(): {
+        totalEvents: number;
+        connectionOpens: number;
+        connectionCloses: number;
+        peerConnects: number;
+        peerDisconnects: number;
+        currentConnections: number;
+        currentStreams: number;
+    };
+}
+/**
+ * Create a connection spy for a node
+ */
+export declare function createConnectionSpy(node: oNode | oNodeTool): ConnectionSpy;
+//# sourceMappingURL=connection-spy.d.ts.map

package/dist/test/helpers/connection-spy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-spy.d.ts","sourceRoot":"","sources":["../../../test/helpers/connection-spy.ts"],"names":[],"mappings":"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"}