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

package/dist/test/helpers/connection-spy.js

@@ -0,0 +1,229 @@
+/**
+ * Spy that monitors libp2p connections and streams for testing
+ */
+export class ConnectionSpy {
+    constructor(node) {
+        this.events = [];
+        this.listeners = new Map();
+        this.isMonitoring = false;
+        this.node = node;
+    }
+    /**
+     * Start monitoring connection events
+     */
+    start() {
+        if (this.isMonitoring) {
+            return;
+        }
+        this.isMonitoring = true;
+        // Monitor peer events
+        const peerConnectListener = (event) => {
+            this.events.push({
+                type: 'peer:connect',
+                timestamp: Date.now(),
+                peerId: event.detail.toString(),
+            });
+        };
+        this.node.p2pNode.addEventListener('peer:connect', peerConnectListener);
+        this.listeners.set('peer:connect', peerConnectListener);
+        const peerDisconnectListener = (event) => {
+            this.events.push({
+                type: 'peer:disconnect',
+                timestamp: Date.now(),
+                peerId: event.detail.toString(),
+            });
+        };
+        this.node.p2pNode.addEventListener('peer:disconnect', peerDisconnectListener);
+        this.listeners.set('peer:disconnect', peerDisconnectListener);
+        // Monitor connection events
+        const connectionOpenListener = (event) => {
+            const connection = event.detail;
+            this.events.push({
+                type: 'connection:open',
+                timestamp: Date.now(),
+                peerId: connection.remotePeer.toString(),
+                remoteAddr: connection.remoteAddr.toString(),
+                metadata: {
+                    status: connection.status,
+                    direction: connection.direction,
+                },
+            });
+        };
+        this.node.p2pNode.addEventListener('connection:open', connectionOpenListener);
+        this.listeners.set('connection:open', connectionOpenListener);
+        const connectionCloseListener = (event) => {
+            const connection = event.detail;
+            this.events.push({
+                type: 'connection:close',
+                timestamp: Date.now(),
+                peerId: connection.remotePeer.toString(),
+                remoteAddr: connection.remoteAddr.toString(),
+            });
+        };
+        this.node.p2pNode.addEventListener('connection:close', connectionCloseListener);
+        this.listeners.set('connection:close', connectionCloseListener);
+    }
+    /**
+     * Stop monitoring
+     */
+    stop() {
+        if (!this.isMonitoring) {
+            return;
+        }
+        this.isMonitoring = false;
+        for (const [event, listener] of this.listeners.entries()) {
+            this.node.p2pNode.removeEventListener(event, listener);
+        }
+        this.listeners.clear();
+    }
+    /**
+     * Clear all captured events
+     */
+    clear() {
+        this.events = [];
+    }
+    /**
+     * Get all captured events
+     */
+    getEvents() {
+        return [...this.events];
+    }
+    /**
+     * Get events of a specific type
+     */
+    getEventsByType(type) {
+        return this.events.filter((e) => e.type === type);
+    }
+    /**
+     * Get events for a specific peer
+     */
+    getEventsForPeer(peerId) {
+        return this.events.filter((e) => e.peerId === peerId);
+    }
+    /**
+     * Get current connection statistics
+     */
+    getConnectionStats() {
+        const stats = [];
+        const connections = this.node.p2pNode.getConnections();
+        for (const conn of connections) {
+            const streamStats = conn.streams.map((stream) => ({
+                protocol: stream.protocol || 'unknown',
+                status: stream.status,
+                writeStatus: stream.writeStatus,
+                readStatus: stream.readStatus,
+                created: Date.now(), // Approximate
+            }));
+            stats.push({
+                peerId: conn.remotePeer.toString(),
+                status: conn.status,
+                remoteAddr: conn.remoteAddr.toString(),
+                streams: streamStats,
+                created: Date.now(), // Approximate
+            });
+        }
+        return stats;
+    }
+    /**
+     * Get total stream count across all connections
+     */
+    getTotalStreamCount() {
+        const connections = this.node.p2pNode.getConnections();
+        return connections.reduce((sum, conn) => sum + conn.streams.length, 0);
+    }
+    /**
+     * Get stream count for a specific protocol
+     */
+    getStreamCountByProtocol(protocol) {
+        const connections = this.node.p2pNode.getConnections();
+        let count = 0;
+        for (const conn of connections) {
+            count += conn.streams.filter((s) => s.protocol === protocol).length;
+        }
+        return count;
+    }
+    /**
+     * Check if a connection exists to a peer
+     */
+    hasConnectionToPeer(peerId) {
+        const connections = this.node.p2pNode.getConnections();
+        return connections.some((conn) => conn.remotePeer.toString() === peerId);
+    }
+    /**
+     * Get connection to a specific peer
+     */
+    getConnectionToPeer(peerId) {
+        const connections = this.node.p2pNode.getConnections();
+        return connections.find((conn) => conn.remotePeer.toString() === peerId);
+    }
+    /**
+     * Get all streams for a specific peer
+     */
+    getStreamsForPeer(peerId) {
+        const connection = this.getConnectionToPeer(peerId);
+        return connection ? connection.streams : [];
+    }
+    /**
+     * Wait for a specific event to occur
+     */
+    async waitForEvent(type, timeoutMs = 5000) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+            const events = this.getEventsByType(type);
+            if (events.length > 0) {
+                return events[events.length - 1];
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        throw new Error(`Timeout waiting for event: ${type}`);
+    }
+    /**
+     * Wait for connection to a specific peer
+     */
+    async waitForConnectionToPeer(peerId, timeoutMs = 5000) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+            const connection = this.getConnectionToPeer(peerId);
+            if (connection && connection.status === 'open') {
+                return connection;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        throw new Error(`Timeout waiting for connection to peer: ${peerId}`);
+    }
+    /**
+     * Wait for stream count to reach expected value
+     */
+    async waitForStreamCount(expectedCount, timeoutMs = 5000) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+            const currentCount = this.getTotalStreamCount();
+            if (currentCount === expectedCount) {
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        const actualCount = this.getTotalStreamCount();
+        throw new Error(`Timeout waiting for stream count. Expected: ${expectedCount}, Actual: ${actualCount}`);
+    }
+    /**
+     * Get summary of connection activity
+     */
+    getSummary() {
+        return {
+            totalEvents: this.events.length,
+            connectionOpens: this.getEventsByType('connection:open').length,
+            connectionCloses: this.getEventsByType('connection:close').length,
+            peerConnects: this.getEventsByType('peer:connect').length,
+            peerDisconnects: this.getEventsByType('peer:disconnect').length,
+            currentConnections: this.node.p2pNode.getConnections().length,
+            currentStreams: this.getTotalStreamCount(),
+        };
+    }
+}
+/**
+ * Create a connection spy for a node
+ */
+export function createConnectionSpy(node) {
+    return new ConnectionSpy(node);
+}

package/dist/test/helpers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './test-environment.js';
+export * from './simple-node-builder.js';
+export * from './network-builder.js';
+export * from './connection-spy.js';
+export * from './test-node.tool.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../test/helpers/index.ts"],"names":[],"mappings":"AAOA,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AAGzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}

package/dist/test/helpers/index.js

@@ -0,0 +1,12 @@
+// Test helpers barrel export
+// These utilities are available for other packages during development and testing
+// Core test environment and builders (moved from @olane/o-test)
+// Note: Leader-related utilities have been removed to avoid circular dependencies
+// with @olane/o-leader. Packages needing leader functionality should implement
+// their own test utilities.
+export * from './test-environment.js';
+export * from './simple-node-builder.js';
+// o-node specific helpers
+export * from './network-builder.js';
+export * from './connection-spy.js';
+export * from './test-node.tool.js';

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

@@ -0,0 +1,109 @@
+import { oNodeTool } from '../../src/o-node.tool.js';
+import { oNodeAddress } from '../../src/router/o-node.address.js';
+import { oNodeToolConfig } from '../../src/interfaces/o-node.tool-config.js';
+import { oRequest } from '@olane/o-core';
+import { Libp2pConfig } from '@olane/o-config';
+/**
+ * Simple test tool for network communication testing
+ */
+export declare class TestTool extends oNodeTool {
+    callCount: number;
+    constructor(config: oNodeToolConfig & {
+        address: oNodeAddress;
+    });
+    configure(): Promise<Libp2pConfig>;
+    registerParent(): Promise<void>;
+    _tool_echo(request: oRequest): Promise<any>;
+    _tool_get_info(request: oRequest): Promise<any>;
+    _tool_stream(request: oRequest): AsyncGenerator<any>;
+}
+/**
+ * Configuration for a node in the network
+ */
+export interface NodeConfig {
+    address: string;
+    parent?: string;
+    seed?: string;
+    disableHeartbeat?: boolean;
+}
+/**
+ * Simplified network topology builder for testing node-to-node communication
+ * Focuses on peer connections and parent-child relationships without leader abstractions
+ */
+export declare class NetworkBuilder {
+    private nodes;
+    private startedNodes;
+    /**
+     * Add a node to the network
+     * If parentAddress is provided, the node will register as a child
+     */
+    addNode(address: string, parentAddress?: string, config?: Partial<NodeConfig>): Promise<TestTool>;
+    /**
+     * Start a specific node
+     */
+    startNode(address: string): Promise<void>;
+    /**
+     * Stop a specific node
+     */
+    stopNode(address: string): Promise<void>;
+    /**
+     * Stop all nodes in the network
+     * Stops in reverse dependency order: children first, then parents
+     */
+    stopAll(): Promise<void>;
+    /**
+     * Get a node by address
+     */
+    getNode(address: string): TestTool | undefined;
+    /**
+     * Get all nodes
+     */
+    getAllNodes(): Map<string, TestTool>;
+    /**
+     * Sort nodes by hierarchy depth (root nodes first)
+     */
+    private getSortedNodesByDepth;
+    /**
+     * Wait for a node to have transports available
+     */
+    private waitForTransports;
+    /**
+     * Clean up all nodes
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Quick network topology builders for common test scenarios
+ * All topologies use simple parent-child relationships without leader abstractions
+ * Note: "leader" in address names is just a convention, not a special node type
+ */
+export declare class NetworkTopologies {
+    /**
+     * Create a simple two-node network (parent-child)
+     * Addresses: o://leader (root), o://child
+     */
+    static twoNode(): Promise<NetworkBuilder>;
+    /**
+     * Create a three-node hierarchy (leader → parent → child)
+     * Addresses: o://leader (root), o://parent, o://child
+     */
+    static threeNode(): Promise<NetworkBuilder>;
+    /**
+     * Create a five-node hierarchy with two branches
+     * Structure: leader → parent1 → child1, child2
+     *                  → parent2
+     */
+    static fiveNode(): Promise<NetworkBuilder>;
+    /**
+     * Create two standalone nodes (peer-to-peer)
+     */
+    static twoStandalone(): Promise<NetworkBuilder>;
+    /**
+     * Create a complex hierarchy for integration testing
+     * Structure: leader → parent1 → child1, child2
+     *                  → parent2 → child3, child4
+     *                  → parent3 → child5, child6
+     */
+    static complex(): Promise<NetworkBuilder>;
+}
+//# sourceMappingURL=network-builder.d.ts.map

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

@@ -0,0 +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"}

package/dist/test/helpers/network-builder.js

@@ -0,0 +1,309 @@
+import { oNodeTool } from '../../src/o-node.tool.js';
+import { oNodeAddress } from '../../src/router/o-node.address.js';
+import { oAddress } from '@olane/o-core';
+/**
+ * Simple test tool for network communication testing
+ */
+export class TestTool extends oNodeTool {
+    constructor(config) {
+        super(config);
+        this.callCount = 0;
+    }
+    async configure() {
+        const config = await super.configure();
+        config.connectionGater = {
+            denyDialPeer: (peerId) => {
+                return false;
+            },
+            // who can call us?
+            denyInboundEncryptedConnection: (peerId, maConn) => {
+                return false;
+            },
+        };
+        return config;
+    }
+    // NEED TO OVERRIDE to ensure that we can test fully without a proper leader node
+    async registerParent() {
+        if (!this.parent) {
+            this.logger.warn('no parent, skipping registration');
+            return;
+        }
+        if (!this.parent?.libp2pTransports?.length) {
+            this.logger.debug('Parent has no transports, waiting for reconnection & leader ack');
+            if (this.parent?.toString() === oAddress.leader().toString()) {
+                this.parent.setTransports(this.leader?.libp2pTransports || []);
+            }
+            else {
+                this.logger.debug('Waiting for parent and reconnecting...');
+                await this.reconnectionManager?.waitForParentAndReconnect();
+            }
+        }
+        // if no parent transports, register with the parent to get them
+        // TODO: should we remove the transports check to make this more consistent?
+        if (this.config.parent) {
+            this.logger.debug('Registering node with parent...', this.config.parent?.toString());
+            // avoid transports to ensure we do not try direct connection, we need to route via the leader for proper access controls
+            await this.use(this.config.parent, {
+                method: 'child_register',
+                params: {
+                    address: this.address.toString(),
+                    transports: this.transports.map((t) => t.toString()),
+                    peerId: this.peerId.toString(),
+                    _token: this.config.joinToken,
+                },
+            });
+            this.setKeepAliveTag(this.parent);
+        }
+    }
+    async _tool_echo(request) {
+        this.callCount++;
+        return {
+            message: request.params.message || 'echo',
+            nodeAddress: this.address.toString(),
+            timestamp: Date.now(),
+        };
+    }
+    async _tool_get_info(request) {
+        return {
+            address: this.address.toString(),
+            parent: this.parent?.toString(),
+            children: this.getChildren().map((c) => c.toString()),
+            callCount: this.callCount,
+        };
+    }
+    async *_tool_stream(request) {
+        const count = request.params.count || 5;
+        for (let i = 0; i < count; i++) {
+            yield {
+                chunk: i + 1,
+                total: count,
+                nodeAddress: this.address.toString(),
+                timestamp: Date.now(),
+            };
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+}
+/**
+ * Simplified network topology builder for testing node-to-node communication
+ * Focuses on peer connections and parent-child relationships without leader abstractions
+ */
+export class NetworkBuilder {
+    constructor() {
+        this.nodes = new Map();
+        this.startedNodes = new Set();
+    }
+    /**
+     * Add a node to the network
+     * If parentAddress is provided, the node will register as a child
+     */
+    async addNode(address, parentAddress, config = {}) {
+        const seed = config.seed || `node-seed-${address}-${Date.now()}`;
+        let parentNode;
+        let parentRef = null;
+        if (parentAddress) {
+            parentNode = this.nodes.get(parentAddress);
+            if (!parentNode) {
+                throw new Error(`Parent node not found: ${parentAddress}`);
+            }
+            // Wait for parent to have transports
+            // await this.waitForTransports(parentNode);
+            parentRef = new oNodeAddress(parentNode.address.toString(), parentNode.address.libp2pTransports);
+        }
+        const node = new TestTool({
+            address: new oNodeAddress(address),
+            parent: parentRef,
+            leader: null, // No leader abstraction in o-node tests
+            seed,
+            connectionHeartbeat: {
+                enabled: !config.disableHeartbeat,
+                checkChildren: parentAddress ? false : true, // Only root monitors children
+            },
+        });
+        this.nodes.set(address, node);
+        await this.startNode(address);
+        return node;
+    }
+    /**
+     * Start a specific node
+     */
+    async startNode(address) {
+        const node = this.nodes.get(address);
+        if (!node) {
+            throw new Error(`Node not found: ${address}`);
+        }
+        if (this.startedNodes.has(address)) {
+            return; // Already started
+        }
+        await node.start();
+        this.startedNodes.add(address);
+        // Wait for transports to be available
+        // await this.waitForTransports(node);
+    }
+    /**
+     * Stop a specific node
+     */
+    async stopNode(address) {
+        const node = this.nodes.get(address);
+        if (!node) {
+            throw new Error(`Node not found: ${address}`);
+        }
+        if (!this.startedNodes.has(address)) {
+            return; // Not started
+        }
+        await node.stop();
+        this.startedNodes.delete(address);
+    }
+    /**
+     * Stop all nodes in the network
+     * Stops in reverse dependency order: children first, then parents
+     */
+    async stopAll() {
+        const sortedNodes = this.getSortedNodesByDepth().reverse();
+        for (const address of sortedNodes) {
+            if (this.startedNodes.has(address)) {
+                await this.stopNode(address);
+            }
+        }
+    }
+    /**
+     * Get a node by address
+     */
+    getNode(address) {
+        return this.nodes.get(address);
+    }
+    /**
+     * Get all nodes
+     */
+    getAllNodes() {
+        return new Map(this.nodes);
+    }
+    /**
+     * Sort nodes by hierarchy depth (root nodes first)
+     */
+    getSortedNodesByDepth() {
+        const depths = new Map();
+        const addresses = Array.from(this.nodes.keys());
+        // Calculate depth for each node
+        const calculateDepth = (address) => {
+            if (depths.has(address)) {
+                return depths.get(address);
+            }
+            const node = this.nodes.get(address);
+            if (!node.parent) {
+                depths.set(address, 0);
+                return 0;
+            }
+            // Find parent address in our map
+            const parentAddress = Array.from(this.nodes.entries()).find(([_, n]) => n.address.toString() === node.parent?.toString())?.[0];
+            if (!parentAddress) {
+                depths.set(address, 0);
+                return 0;
+            }
+            const depth = calculateDepth(parentAddress) + 1;
+            depths.set(address, depth);
+            return depth;
+        };
+        addresses.forEach((addr) => calculateDepth(addr));
+        // Sort by depth (ascending)
+        return addresses.sort((a, b) => {
+            const depthA = depths.get(a) || 0;
+            const depthB = depths.get(b) || 0;
+            return depthA - depthB;
+        });
+    }
+    /**
+     * Wait for a node to have transports available
+     */
+    async waitForTransports(node, timeoutMs = 5000) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+            if (node.address.libp2pTransports.length > 0) {
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        throw new Error(`Timeout waiting for transports on ${node.address.toString()}`);
+    }
+    /**
+     * Clean up all nodes
+     */
+    async cleanup() {
+        await this.stopAll();
+        this.nodes.clear();
+        this.startedNodes.clear();
+    }
+}
+/**
+ * Quick network topology builders for common test scenarios
+ * All topologies use simple parent-child relationships without leader abstractions
+ * Note: "leader" in address names is just a convention, not a special node type
+ */
+export class NetworkTopologies {
+    /**
+     * Create a simple two-node network (parent-child)
+     * Addresses: o://leader (root), o://child
+     */
+    static async twoNode() {
+        const builder = new NetworkBuilder();
+        await builder.addNode('o://leader');
+        await builder.addNode('o://child', 'o://leader');
+        return builder;
+    }
+    /**
+     * Create a three-node hierarchy (leader → parent → child)
+     * Addresses: o://leader (root), o://parent, o://child
+     */
+    static async threeNode() {
+        const builder = new NetworkBuilder();
+        await builder.addNode('o://leader');
+        await builder.addNode('o://parent', 'o://leader');
+        await builder.addNode('o://child', 'o://parent');
+        return builder;
+    }
+    /**
+     * Create a five-node hierarchy with two branches
+     * Structure: leader → parent1 → child1, child2
+     *                  → parent2
+     */
+    static async fiveNode() {
+        const builder = new NetworkBuilder();
+        await builder.addNode('o://leader');
+        await builder.addNode('o://parent1', 'o://leader');
+        await builder.addNode('o://parent2', 'o://leader');
+        await builder.addNode('o://child1', 'o://parent1');
+        await builder.addNode('o://child2', 'o://parent1');
+        return builder;
+    }
+    /**
+     * Create two standalone nodes (peer-to-peer)
+     */
+    static async twoStandalone() {
+        const builder = new NetworkBuilder();
+        await builder.addNode('o://node1');
+        await builder.addNode('o://node2');
+        return builder;
+    }
+    /**
+     * Create a complex hierarchy for integration testing
+     * Structure: leader → parent1 → child1, child2
+     *                  → parent2 → child3, child4
+     *                  → parent3 → child5, child6
+     */
+    static async complex() {
+        const builder = new NetworkBuilder();
+        await builder.addNode('o://leader');
+        // Add three parent nodes
+        await builder.addNode('o://parent1', 'o://leader');
+        await builder.addNode('o://parent2', 'o://leader');
+        await builder.addNode('o://parent3', 'o://leader');
+        // Add children to each parent
+        await builder.addNode('o://parent1-child1', 'o://parent1');
+        await builder.addNode('o://parent1-child2', 'o://parent1');
+        await builder.addNode('o://parent2-child1', 'o://parent2');
+        await builder.addNode('o://parent2-child2', 'o://parent2');
+        await builder.addNode('o://parent3-child1', 'o://parent3');
+        await builder.addNode('o://parent3-child2', 'o://parent3');
+        return builder;
+    }
+}