@olane/o-node 0.7.12-alpha.56 → 0.7.12-alpha.58

package/dist/src/connection/o-node-connection.manager.d.ts

@@ -1,10 +1,10 @@
 import { oAddress, oConnectionConfig, oConnectionManager } from '@olane/o-core';
-import { Connection } from '@olane/o-config';
+import { Libp2p, Connection } from '@olane/o-config';
 import { oNodeConnectionManagerConfig } from './interfaces/o-node-connection-manager.config.js';
 import { oNodeConnection } from './o-node-connection.js';
 export declare class oNodeConnectionManager extends oConnectionManager {
     readonly config: oNodeConnectionManagerConfig;
-    private p2pNode;
+    protected p2pNode: Libp2p;
     private defaultReadTimeoutMs?;
     private defaultDrainTimeoutMs?;
     constructor(config: oNodeConnectionManagerConfig);

package/dist/src/connection/o-node-connection.manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node-connection.manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,EAAU,UAAU,EAAU,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD,qBAAa,sBAAuB,SAAQ,kBAAkB;IAKhD,QAAQ,CAAC,MAAM,EAAE,4BAA4B;IAJzD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,oBAAoB,CAAC,CAAS;IACtC,OAAO,CAAC,qBAAqB,CAAC,CAAS;gBAElB,MAAM,EAAE,4BAA4B;IAOnD,qBAAqB,CACzB,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,UAAU,CAAC;IA4BtB;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IA8BlE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IA4BpC;;;;OAIG;IACH,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI;CA0BhE"}
+{"version":3,"file":"o-node-connection.manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,UAAU,EAAU,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD,qBAAa,sBAAuB,SAAQ,kBAAkB;IAKhD,QAAQ,CAAC,MAAM,EAAE,4BAA4B;IAJzD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,oBAAoB,CAAC,CAAS;IACtC,OAAO,CAAC,qBAAqB,CAAC,CAAS;gBAElB,MAAM,EAAE,4BAA4B;IAOnD,qBAAqB,CACzB,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,UAAU,CAAC;IA4BtB;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IA8BlE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IA4BpC;;;;OAIG;IACH,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI;CA0BhE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.12-alpha.56",
+  "version": "0.7.12-alpha.58",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -54,12 +54,12 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.12-alpha.56",
-    "@olane/o-core": "0.7.12-alpha.56",
-    "@olane/o-protocol": "0.7.12-alpha.56",
-    "@olane/o-tool": "0.7.12-alpha.56",
+    "@olane/o-config": "0.7.12-alpha.58",
+    "@olane/o-core": "0.7.12-alpha.58",
+    "@olane/o-protocol": "0.7.12-alpha.58",
+    "@olane/o-tool": "0.7.12-alpha.58",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0"
   },
-  "gitHead": "e59edf30cd442f528f9b4981ca69572b3777aa4e"
+  "gitHead": "57bb9dec306f5283a838479f5d61f6981585b18f"
 }

package/dist/src/connection/stream-handler.spec.d.ts

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

package/dist/src/connection/stream-handler.spec.d.ts.map

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

package/dist/src/connection/stream-handler.spec.js

@@ -1,309 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { StreamHandler } from './stream-handler.js';
-import { EventEmitter } from 'events';
-import { oError, oErrorCodes } from '@o/o-core/src/error/o-error';
-// Mock Stream interface
-const createMockStream = (status = 'open') => {
-    const listeners = new Map();
-    return {
-        status,
-        send: vi.fn().mockReturnValue(true),
-        close: vi.fn().mockResolvedValue(undefined),
-        abort: vi.fn().mockResolvedValue(undefined),
-        onDrain: vi.fn().mockResolvedValue(undefined),
-        addEventListener: vi.fn((event, handler) => {
-            if (!listeners.has(event)) {
-                listeners.set(event, []);
-            }
-            listeners.get(event)?.push(handler);
-        }),
-        removeEventListener: vi.fn((event, handler) => {
-            const handlers = listeners.get(event);
-            if (handlers) {
-                const index = handlers.indexOf(handler);
-                if (index > -1) {
-                    handlers.splice(index, 1);
-                }
-            }
-        }),
-        // Helper to trigger events in tests
-        _triggerEvent: (event, data) => {
-            listeners.get(event)?.forEach((handler) => handler(data));
-        },
-    };
-};
-// Mock Connection interface
-const createMockConnection = (status = 'open') => {
-    return {
-        status,
-        streams: [],
-        newStream: vi.fn().mockImplementation(() => createMockStream()),
-    };
-};
-describe('StreamHandler', () => {
-    let streamHandler;
-    beforeEach(() => {
-        streamHandler = new StreamHandler();
-    });
-    describe('Message Type Detection', () => {
-        it('should identify a request message', () => {
-            const message = {
-                jsonrpc: '2.0',
-                id: '1',
-                method: 'test_method',
-                params: {},
-            };
-            expect(streamHandler.isRequest(message)).toBe(true);
-            expect(streamHandler.isResponse(message)).toBe(false);
-        });
-        it('should identify a response message', () => {
-            const message = {
-                jsonrpc: '2.0',
-                id: '1',
-                result: { success: true },
-            };
-            expect(streamHandler.isResponse(message)).toBe(true);
-            expect(streamHandler.isRequest(message)).toBe(false);
-        });
-        it('should not identify malformed message as request or response', () => {
-            const message = {
-                jsonrpc: '2.0',
-                id: '1',
-            };
-            expect(streamHandler.isRequest(message)).toBe(false);
-            expect(streamHandler.isResponse(message)).toBe(false);
-        });
-        it('should handle message with both method and result', () => {
-            const message = {
-                jsonrpc: '2.0',
-                id: '1',
-                method: 'test',
-                result: {},
-            };
-            // Should identify as request since method is present
-            expect(streamHandler.isRequest(message)).toBe(true);
-            expect(streamHandler.isResponse(message)).toBe(false);
-        });
-    });
-    describe('Stream Lifecycle - getOrCreateStream', () => {
-        it('should create a new stream with none reuse policy', async () => {
-            const connection = createMockConnection();
-            const protocol = '/test/1.0.0';
-            const stream = await streamHandler.getOrCreateStream(connection, protocol, {
-                reusePolicy: 'none',
-            });
-            expect(stream).toBeDefined();
-            expect(connection.newStream).toHaveBeenCalledWith(protocol, expect.any(Object));
-        });
-        it('should reuse existing stream with reuse policy', async () => {
-            const existingStream = createMockStream();
-            const connection = createMockConnection();
-            connection.streams = [existingStream];
-            const stream = await streamHandler.getOrCreateStream(connection, '/test/1.0.0', { reusePolicy: 'reuse' });
-            expect(stream).toBe(existingStream);
-            expect(connection.newStream).not.toHaveBeenCalled();
-        });
-        it('should create new stream when no open stream exists with reuse policy', async () => {
-            const closedStream = createMockStream('closed');
-            const connection = createMockConnection();
-            connection.streams = [closedStream];
-            const stream = await streamHandler.getOrCreateStream(connection, '/test/1.0.0', { reusePolicy: 'reuse' });
-            expect(stream).not.toBe(closedStream);
-            expect(connection.newStream).toHaveBeenCalled();
-        });
-        it('should throw error when connection is not open', async () => {
-            const connection = createMockConnection('closed');
-            await expect(streamHandler.getOrCreateStream(connection, '/test/1.0.0')).rejects.toThrow();
-        });
-        it('should pass configuration options to newStream', async () => {
-            const connection = createMockConnection();
-            const signal = new AbortController().signal;
-            await streamHandler.getOrCreateStream(connection, '/test/1.0.0', {
-                signal,
-                maxOutboundStreams: 500,
-                runOnLimitedConnection: true,
-            });
-            expect(connection.newStream).toHaveBeenCalledWith('/test/1.0.0', {
-                signal,
-                maxOutboundStreams: 500,
-                runOnLimitedConnection: true,
-            });
-        });
-    });
-    describe('Stream Lifecycle - send', () => {
-        it('should send data without backpressure', async () => {
-            const stream = createMockStream();
-            stream.send = vi.fn().mockReturnValue(true);
-            const data = new TextEncoder().encode('test data');
-            await streamHandler.send(stream, data);
-            expect(stream.send).toHaveBeenCalledWith(data);
-            expect(stream.onDrain).not.toHaveBeenCalled();
-        });
-        it('should wait for drain when backpressure occurs', async () => {
-            const stream = createMockStream();
-            stream.send = vi.fn().mockReturnValue(false);
-            const data = new TextEncoder().encode('test data');
-            await streamHandler.send(stream, data, { drainTimeoutMs: 5000 });
-            expect(stream.send).toHaveBeenCalledWith(data);
-            expect(stream.onDrain).toHaveBeenCalledWith({
-                signal: expect.any(AbortSignal),
-            });
-        });
-    });
-    describe('Stream Lifecycle - close', () => {
-        it('should close stream when reuse policy is none', async () => {
-            const stream = createMockStream();
-            await streamHandler.close(stream, { reusePolicy: 'none' });
-            expect(stream.close).toHaveBeenCalled();
-        });
-        it('should not close stream when reuse policy is reuse', async () => {
-            const stream = createMockStream();
-            await streamHandler.close(stream, { reusePolicy: 'reuse' });
-            expect(stream.close).not.toHaveBeenCalled();
-        });
-        it('should not close stream when status is not open', async () => {
-            const stream = createMockStream('closed');
-            await streamHandler.close(stream, { reusePolicy: 'none' });
-            expect(stream.close).not.toHaveBeenCalled();
-        });
-        it('should handle errors during close gracefully', async () => {
-            const stream = createMockStream();
-            stream.close = vi.fn().mockRejectedValue(new Error('Close failed'));
-            // Should not throw
-            await expect(streamHandler.close(stream)).resolves.toBeUndefined();
-        });
-    });
-    describe('Server-side - handleIncomingStream', () => {
-        it('should attach message listener immediately', async () => {
-            const stream = createMockStream();
-            const connection = createMockConnection();
-            const toolExecutor = vi.fn().mockResolvedValue({ success: true });
-            await streamHandler.handleIncomingStream(stream, connection, toolExecutor);
-            expect(stream.addEventListener).toHaveBeenCalledWith('message', expect.any(Function));
-            expect(stream.addEventListener).toHaveBeenCalledWith('close', expect.any(Function));
-        });
-        it('should execute tool when request message is received', async () => {
-            const stream = createMockStream();
-            const connection = createMockConnection();
-            const toolExecutor = vi.fn().mockResolvedValue({ success: true });
-            await streamHandler.handleIncomingStream(stream, connection, toolExecutor);
-            // Simulate receiving a request
-            const requestData = {
-                data: new TextEncoder().encode(JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: '1',
-                    method: 'test_method',
-                    params: {},
-                })),
-            };
-            stream._triggerEvent('message', requestData);
-            // Wait for async handling
-            await new Promise(resolve => setTimeout(resolve, 10));
-            expect(toolExecutor).toHaveBeenCalled();
-        });
-        it('should send error response when tool execution fails', async () => {
-            const stream = createMockStream();
-            const connection = createMockConnection();
-            const toolExecutor = vi.fn().mockRejectedValue(new oError(oErrorCodes.INTERNAL_ERROR, 'Tool execution failed'));
-            await streamHandler.handleIncomingStream(stream, connection, toolExecutor);
-            const requestData = {
-                data: new TextEncoder().encode(JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: '1',
-                    method: 'test_method',
-                    params: {},
-                })),
-            };
-            stream._triggerEvent('message', requestData);
-            // Wait for async handling
-            await new Promise(resolve => setTimeout(resolve, 10));
-            expect(stream.send).toHaveBeenCalled();
-        });
-        it('should clean up listeners on stream close', async () => {
-            const stream = createMockStream();
-            const connection = createMockConnection();
-            const toolExecutor = vi.fn();
-            await streamHandler.handleIncomingStream(stream, connection, toolExecutor);
-            stream._triggerEvent('close', {});
-            expect(stream.removeEventListener).toHaveBeenCalledWith('message', expect.any(Function));
-            expect(stream.removeEventListener).toHaveBeenCalledWith('close', expect.any(Function));
-        });
-    });
-    describe('Client-side - handleOutgoingStream', () => {
-        it('should resolve with response when final chunk received', async () => {
-            const stream = createMockStream();
-            const emitter = new EventEmitter();
-            const responsePromise = streamHandler.handleOutgoingStream(stream, emitter);
-            // Simulate receiving a final response
-            const responseData = {
-                data: new TextEncoder().encode(JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: '1',
-                    result: { _last: true, success: true },
-                })),
-            };
-            stream._triggerEvent('message', responseData);
-            const response = await responsePromise;
-            expect(response).toBeDefined();
-            expect(response.result._last).toBe(true);
-        });
-        it('should emit chunks for streaming responses', async () => {
-            const stream = createMockStream();
-            const emitter = new EventEmitter();
-            const chunkListener = vi.fn();
-            emitter.on('chunk', chunkListener);
-            const responsePromise = streamHandler.handleOutgoingStream(stream, emitter);
-            // Send a chunk
-            const chunkData = {
-                data: new TextEncoder().encode(JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: '1',
-                    result: { _isStreaming: true, _last: false, data: 'chunk 1' },
-                })),
-            };
-            stream._triggerEvent('message', chunkData);
-            // Wait for async handling
-            await new Promise(resolve => setTimeout(resolve, 10));
-            expect(chunkListener).toHaveBeenCalled();
-            // Send final chunk
-            const finalData = {
-                data: new TextEncoder().encode(JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: '1',
-                    result: { _isStreaming: true, _last: true, data: 'final chunk' },
-                })),
-            };
-            stream._triggerEvent('message', finalData);
-            await responsePromise;
-        });
-        it('should reject when stream closes before response', async () => {
-            const stream = createMockStream();
-            const emitter = new EventEmitter();
-            const responsePromise = streamHandler.handleOutgoingStream(stream, emitter);
-            stream._triggerEvent('close', {});
-            await expect(responsePromise).rejects.toThrow();
-        });
-        it('should handle abort signal', async () => {
-            const stream = createMockStream();
-            const emitter = new EventEmitter();
-            const abortController = new AbortController();
-            const responsePromise = streamHandler.handleOutgoingStream(stream, emitter, {
-                signal: abortController.signal,
-            });
-            abortController.abort();
-            // Wait for abort to be processed
-            await new Promise(resolve => setTimeout(resolve, 10));
-            await expect(responsePromise).rejects.toThrow();
-            expect(stream.abort).toHaveBeenCalled();
-        });
-    });
-    describe('Message Decoding', () => {
-        it('should decode Uint8Array message', async () => {
-            const testData = { test: 'data' };
-            const encoded = new TextEncoder().encode(JSON.stringify(testData));
-            const event = { data: encoded };
-            const decoded = await streamHandler.decodeMessage(event);
-            expect(decoded).toEqual(testData);
-        });
-    });
-});

package/dist/test/o-node.spec.d.ts

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

package/dist/test/o-node.spec.d.ts.map

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

package/dist/test/o-node.spec.js

@@ -1,20 +0,0 @@
-import { NodeState } from '@olane/o-core';
-import { expect } from 'chai';
-import { oNode } from '../src/index.js';
-import { oNodeAddress } from '../src/router/o-node.address.js';
-describe('in-process @memory', () => {
-    it('should be able to start a single node with no leader', async () => {
-        const node = new oNode({
-            address: new oNodeAddress('o://test'),
-            leader: null,
-            parent: null,
-        });
-        await node.start();
-        expect(node.state).to.equal(NodeState.RUNNING);
-        const transports = node.transports;
-        // expect(transports.length).to.equal(1);
-        // expect(transports[0].toString()).to.contain('/memory');
-        await node.stop();
-        expect(node.state).to.equal(NodeState.STOPPED);
-    });
-});

package/dist/test/search-resolver.spec.d.ts

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

package/dist/test/search-resolver.spec.d.ts.map

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

package/dist/test/search-resolver.spec.js

@@ -1,693 +0,0 @@
-import { expect } from 'chai';
-import { oSearchResolver } from '../src/router/resolvers/o-node.search-resolver.js';
-import { oAddress, RestrictedAddresses, NodeState, TransportType, } from '@olane/o-core';
-import { oNodeTransport } from '../src/router/o-node.transport.js';
-import { oNodeAddress } from '../src/router/o-node.address.js';
-import { oProtocolMethods } from '@olane/o-protocol';
-describe('oSearchResolver', () => {
-    let resolver;
-    let mockNode;
-    const testAddress = new oNodeAddress('o://test-node');
-    // Helper to create a proper oRouterRequest
-    const createRouterRequest = () => ({
-        method: oProtocolMethods.ROUTE,
-        params: {
-            _connectionId: 'test-connection',
-            _requestMethod: 'test',
-            address: 'o://test',
-            payload: {},
-        },
-        jsonrpc: '2.0',
-        id: '1',
-        state: {},
-        connectionId: 'test-connection',
-        toJSON: () => ({}),
-        setState: () => { },
-        logger: {},
-    });
-    // Helper to create a proper oResponse
-    const createResponse = (result) => ({
-        jsonrpc: '2.0',
-        id: '1',
-        result,
-    });
-    beforeEach(() => {
-        resolver = new oSearchResolver(testAddress);
-        // Create mock node with necessary properties
-        mockNode = {
-            address: testAddress,
-            state: NodeState.RUNNING,
-            leader: new oNodeAddress(RestrictedAddresses.LEADER, [
-                new oNodeTransport('/ip4/127.0.0.1/tcp/4001'),
-            ]),
-            hierarchyManager: {
-                getChild: (address) => null,
-            },
-            use: async (address, request) => {
-                // Mock registry search response
-                return createResponse({
-                    data: [],
-                });
-            },
-        };
-    });
-    describe('Basic resolver configuration', () => {
-        it('should have custom transport for /search', () => {
-            const transports = resolver.customTransports;
-            expect(transports).to.have.lengthOf(1);
-            expect(transports[0].value).to.equal('/search');
-        });
-        it('should use registry as default search target', () => {
-            const registryAddress = resolver.getRegistryAddress();
-            expect(registryAddress.value).to.equal(RestrictedAddresses.REGISTRY);
-        });
-        it('should use "search" as default method', () => {
-            const method = resolver.getSearchMethod();
-            expect(method).to.equal('search');
-        });
-    });
-    describe('resolve() - Basic flow', () => {
-        it('should skip search if address already has transports', async () => {
-            const addressWithTransports = new oNodeAddress('o://test', [
-                new oNodeTransport('/ip4/127.0.0.1/tcp/5001'),
-            ]);
-            const result = await resolver.resolve({
-                address: addressWithTransports,
-                targetAddress: addressWithTransports,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.nextHopAddress.value).to.equal('o://test');
-            expect(result.nextHopAddress.transports).to.have.lengthOf(1);
-        });
-        it('should return original address when no search results found', async () => {
-            const address = new oNodeAddress('o://unknown-service');
-            mockNode.use = async () => createResponse({ data: [] });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.nextHopAddress.value).to.equal('o://unknown-service');
-        });
-        it('should resolve address using registry search results', async () => {
-            const address = new oNodeAddress('o://embeddings-text');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings');
-            expect(result.targetAddress.transports).to.have.lengthOf(1);
-        });
-        it('should preserve extra path parameters in resolved address', async () => {
-            const address = new oNodeAddress('o://embeddings-text/method/params');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings/method/params');
-        });
-        it('should handle hierarchical address resolution', async () => {
-            const address = new oNodeAddress('o://leader/services/embeddings-text');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.transports).to.have.lengthOf(1);
-        });
-    });
-    describe('buildSearchParams()', () => {
-        it('should include both staticAddress and address', () => {
-            const address = new oNodeAddress('o://leader/services/embeddings-text');
-            const params = resolver.buildSearchParams(address);
-            expect(params.staticAddress).to.equal('o://leader');
-            expect(params.address).to.equal('o://leader/services/embeddings-text');
-        });
-        it('should use root address for staticAddress', () => {
-            const address = new oNodeAddress('o://leader/deep/nested/path');
-            const params = resolver.buildSearchParams(address);
-            expect(params.staticAddress).to.equal('o://leader');
-            expect(params.address).to.equal('o://leader/deep/nested/path');
-        });
-        it('should handle static addresses', () => {
-            const address = new oNodeAddress('o://embeddings-text');
-            const params = resolver.buildSearchParams(address);
-            expect(params.staticAddress).to.equal('o://embeddings-text');
-            expect(params.address).to.equal('o://embeddings-text');
-        });
-    });
-    describe('filterSearchResults()', () => {
-        it('should filter out registry address to prevent loops', () => {
-            const results = [
-                {
-                    staticAddress: RestrictedAddresses.REGISTRY,
-                    address: 'o://registry',
-                },
-                { staticAddress: 'o://service', address: 'o://service' },
-            ];
-            const filtered = resolver.filterSearchResults(results, mockNode);
-            expect(filtered).to.have.lengthOf(1);
-            expect(filtered[0].staticAddress).to.equal('o://service');
-        });
-        it('should filter out self address to prevent loops', () => {
-            const results = [
-                { address: 'o://test-node', staticAddress: 'o://test' },
-                { address: 'o://other-node', staticAddress: 'o://other' },
-            ];
-            const filtered = resolver.filterSearchResults(results, mockNode);
-            expect(filtered).to.have.lengthOf(1);
-            expect(filtered[0].address).to.equal('o://other-node');
-        });
-        it('should allow all valid results', () => {
-            const results = [
-                { address: 'o://service-1', staticAddress: 'o://s1' },
-                { address: 'o://service-2', staticAddress: 'o://s2' },
-                { address: 'o://service-3', staticAddress: 'o://s3' },
-            ];
-            const filtered = resolver.filterSearchResults(results, mockNode);
-            expect(filtered).to.have.lengthOf(3);
-        });
-        it('should handle empty results array', () => {
-            const filtered = resolver.filterSearchResults([], mockNode);
-            expect(filtered).to.be.an('array').that.is.empty;
-        });
-    });
-    describe('selectResult()', () => {
-        it('should select first result from multiple options', () => {
-            const results = [
-                { address: 'o://service-1', peerId: 'peer-1' },
-                { address: 'o://service-2', peerId: 'peer-2' },
-                { address: 'o://service-3', peerId: 'peer-3' },
-            ];
-            const selected = resolver.selectResult(results);
-            expect(selected).to.equal(results[0]);
-            expect(selected.peerId).to.equal('peer-1');
-        });
-        it('should return null for empty results', () => {
-            const selected = resolver.selectResult([]);
-            expect(selected).to.be.null;
-        });
-        it('should return single result', () => {
-            const results = [{ address: 'o://only-service', peerId: 'only-peer' }];
-            const selected = resolver.selectResult(results);
-            expect(selected).to.equal(results[0]);
-        });
-    });
-    describe('mapTransports()', () => {
-        it('should map transport objects to oNodeTransport instances', () => {
-            const result = {
-                transports: [
-                    { value: '/ip4/127.0.0.1/tcp/4001', type: TransportType.LIBP2P },
-                    { value: '/ip4/192.168.1.1/tcp/4002', type: TransportType.LIBP2P },
-                ],
-            };
-            const transports = resolver.mapTransports(result);
-            expect(transports).to.have.lengthOf(2);
-            expect(transports[0]).to.be.instanceOf(oNodeTransport);
-            expect(transports[0].value).to.equal('/ip4/127.0.0.1/tcp/4001');
-            expect(transports[1].value).to.equal('/ip4/192.168.1.1/tcp/4002');
-        });
-        it('should handle empty transports array', () => {
-            const result = { transports: [] };
-            const transports = resolver.mapTransports(result);
-            expect(transports).to.be.an('array').that.is.empty;
-        });
-        it('should handle single transport', () => {
-            const result = {
-                transports: [{ value: '/memory', type: TransportType.CUSTOM }],
-            };
-            const transports = resolver.mapTransports(result);
-            expect(transports).to.have.lengthOf(1);
-            expect(transports[0].value).to.equal('/memory');
-        });
-    });
-    describe('resolveNextHopTransports()', () => {
-        it('should use leader transports when next hop is leader', () => {
-            const nextHop = new oNodeAddress(RestrictedAddresses.LEADER);
-            const targetTransports = [
-                new oNodeTransport('/ip4/192.168.1.1/tcp/9999'),
-            ];
-            const resolved = resolver.resolveNextHopTransports(nextHop, targetTransports, mockNode);
-            expect(resolved).to.have.lengthOf(1);
-            expect(resolved[0].value).to.equal('/ip4/127.0.0.1/tcp/4001'); // Leader transport from mock
-        });
-        it('should use child transports when next hop is known child', () => {
-            const childAddress = new oNodeAddress('o://known-child', [
-                new oNodeTransport('/ip4/10.0.0.1/tcp/7001'),
-            ]);
-            mockNode.hierarchyManager = {
-                getChild: (address) => {
-                    if (address.value === 'o://known-child') {
-                        return childAddress;
-                    }
-                    return null;
-                },
-            };
-            const nextHop = new oNodeAddress('o://known-child');
-            const targetTransports = [
-                new oNodeTransport('/ip4/192.168.1.1/tcp/9999'),
-            ];
-            const resolved = resolver.resolveNextHopTransports(nextHop, targetTransports, mockNode);
-            expect(resolved).to.have.lengthOf(1);
-            expect(resolved[0].value).to.equal('/ip4/10.0.0.1/tcp/7001');
-        });
-        it('should use target transports for unknown next hop', () => {
-            const nextHop = new oNodeAddress('o://unknown-node');
-            const targetTransports = [
-                new oNodeTransport('/ip4/192.168.1.1/tcp/8001'),
-            ];
-            const resolved = resolver.resolveNextHopTransports(nextHop, targetTransports, mockNode);
-            expect(resolved).to.have.lengthOf(1);
-            expect(resolved[0].value).to.equal('/ip4/192.168.1.1/tcp/8001');
-        });
-        it('should return empty array when leader has no transports', () => {
-            // Create a new mock node with leader that has no transports
-            const mockNodeNoLeaderTransports = {
-                ...mockNode,
-                leader: new oNodeAddress(RestrictedAddresses.LEADER, []),
-            };
-            const nextHop = new oNodeAddress(RestrictedAddresses.LEADER);
-            const targetTransports = [
-                new oNodeTransport('/ip4/192.168.1.1/tcp/9999'),
-            ];
-            const resolved = resolver.resolveNextHopTransports(nextHop, targetTransports, mockNodeNoLeaderTransports);
-            expect(resolved).to.be.an('array').that.is.empty;
-        });
-    });
-    describe('determineNextHop()', () => {
-        it('should use oAddress.next() for hierarchy routing', async () => {
-            const resolvedTarget = new oNodeAddress('o://leader/services/embeddings');
-            const searchResult = {
-                transports: [
-                    { value: '/ip4/127.0.0.1/tcp/6001', type: TransportType.LIBP2P },
-                ],
-            };
-            mockNode.address = new oNodeAddress(RestrictedAddresses.LEADER);
-            const nextHop = resolver.determineNextHop(mockNode, resolvedTarget, searchResult);
-            // From leader to o://leader/services/embeddings, next hop should be o://leader/services
-            expect(nextHop.value).to.equal('o://leader/services');
-            expect(nextHop.transports).to.not.be.empty;
-        });
-        it('should set transports on next hop address', async () => {
-            const resolvedTarget = new oNodeAddress('o://leader/services');
-            const searchResult = {
-                transports: [
-                    { value: '/ip4/127.0.0.1/tcp/6001', type: TransportType.LIBP2P },
-                ],
-            };
-            mockNode.address = new oNodeAddress(RestrictedAddresses.LEADER);
-            const nextHop = resolver.determineNextHop(mockNode, resolvedTarget, searchResult);
-            expect(nextHop.transports).to.not.be.undefined;
-            expect(nextHop.transports).to.not.be.empty;
-        });
-        it('should handle routing to immediate child', async () => {
-            const resolvedTarget = new oNodeAddress('o://leader/services');
-            const searchResult = {
-                transports: [
-                    { value: '/ip4/127.0.0.1/tcp/6001', type: TransportType.LIBP2P },
-                ],
-            };
-            mockNode.address = new oNodeAddress(RestrictedAddresses.LEADER);
-            const nextHop = resolver.determineNextHop(mockNode, resolvedTarget, searchResult);
-            expect(nextHop.value).to.equal('o://leader/services');
-        });
-    });
-    describe('Custom resolver subclassing', () => {
-        it('should allow overriding getRegistryAddress()', () => {
-            class CustomRegistryResolver extends oSearchResolver {
-                getRegistryAddress() {
-                    return new oAddress('o://custom-registry');
-                }
-            }
-            const customResolver = new CustomRegistryResolver(testAddress);
-            const registryAddress = customResolver.getRegistryAddress();
-            expect(registryAddress.value).to.equal('o://custom-registry');
-        });
-        it('should allow overriding getSearchMethod()', () => {
-            class CustomMethodResolver extends oSearchResolver {
-                getSearchMethod() {
-                    return 'custom_search';
-                }
-            }
-            const customResolver = new CustomMethodResolver(testAddress);
-            const method = customResolver.getSearchMethod();
-            expect(method).to.equal('custom_search');
-        });
-        it('should allow custom result selection (e.g., round-robin)', () => {
-            class RoundRobinResolver extends oSearchResolver {
-                constructor() {
-                    super(...arguments);
-                    this.currentIndex = 0;
-                }
-                selectResult(results) {
-                    if (results.length === 0)
-                        return null;
-                    const result = results[this.currentIndex % results.length];
-                    this.currentIndex++;
-                    return result;
-                }
-            }
-            const customResolver = new RoundRobinResolver(testAddress);
-            const results = [
-                { address: 'o://service-1' },
-                { address: 'o://service-2' },
-                { address: 'o://service-3' },
-            ];
-            // First call
-            let selected = customResolver.selectResult(results);
-            expect(selected.address).to.equal('o://service-1');
-            // Second call
-            selected = customResolver.selectResult(results);
-            expect(selected.address).to.equal('o://service-2');
-            // Third call
-            selected = customResolver.selectResult(results);
-            expect(selected.address).to.equal('o://service-3');
-            // Fourth call - wraps around
-            selected = customResolver.selectResult(results);
-            expect(selected.address).to.equal('o://service-1');
-        });
-        it('should allow custom filtering logic', () => {
-            class StatusFilterResolver extends oSearchResolver {
-                filterSearchResults(results, node) {
-                    // First apply parent filtering
-                    const filtered = super.filterSearchResults(results, node);
-                    // Then apply custom filtering
-                    return filtered.filter((result) => result.status === 'active');
-                }
-            }
-            const customResolver = new StatusFilterResolver(testAddress);
-            const results = [
-                { address: 'o://service-1', status: 'active', staticAddress: 'o://s1' },
-                {
-                    address: 'o://service-2',
-                    status: 'inactive',
-                    staticAddress: 'o://s2',
-                },
-                { address: 'o://service-3', status: 'active', staticAddress: 'o://s3' },
-            ];
-            const filtered = customResolver.filterSearchResults(results, mockNode);
-            expect(filtered).to.have.lengthOf(2);
-            expect(filtered.every((r) => r.status === 'active')).to.be.true;
-        });
-        it('should allow direct routing by overriding determineNextHop()', () => {
-            class DirectRoutingResolver extends oSearchResolver {
-                determineNextHop(node, resolvedTargetAddress, searchResult) {
-                    // Always route directly to target, bypassing hierarchy
-                    const targetTransports = this.mapTransports(searchResult);
-                    resolvedTargetAddress.setTransports(targetTransports);
-                    return resolvedTargetAddress;
-                }
-            }
-            const customResolver = new DirectRoutingResolver(testAddress);
-            const resolvedTarget = new oNodeAddress('o://leader/services/embeddings');
-            const searchResult = {
-                transports: [
-                    { value: '/ip4/127.0.0.1/tcp/6001', type: TransportType.LIBP2P },
-                ],
-            };
-            mockNode.address = new oNodeAddress(RestrictedAddresses.LEADER);
-            const nextHop = customResolver.determineNextHop(mockNode, resolvedTarget, searchResult);
-            // Direct routing: next hop is the target itself
-            expect(nextHop.value).to.equal('o://leader/services/embeddings');
-            expect(nextHop.transports).to.have.lengthOf(1);
-        });
-    });
-    describe('Integration with registry calls', () => {
-        it('should call node.use() with correct registry address', async () => {
-            const address = new oNodeAddress('o://test-service');
-            let capturedAddress;
-            let capturedRequest;
-            mockNode.use = async (addr, req) => {
-                capturedAddress = addr;
-                capturedRequest = req;
-                return createResponse({ data: [] });
-            };
-            await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(capturedAddress?.value).to.equal(RestrictedAddresses.REGISTRY);
-            expect(capturedRequest.method).to.equal('search');
-        });
-        it('should pass correct search parameters to registry', async () => {
-            const address = new oNodeAddress('o://leader/services/embeddings');
-            let capturedParams;
-            mockNode.use = async (addr, req) => {
-                capturedParams = req.params;
-                return createResponse({ data: [] });
-            };
-            await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(capturedParams.staticAddress).to.equal('o://leader');
-            expect(capturedParams.address).to.equal('o://leader/services/embeddings');
-        });
-        it('should handle registry errors gracefully', async () => {
-            const address = new oNodeAddress('o://test-service');
-            mockNode.use = async () => {
-                throw new Error('Registry unavailable');
-            };
-            // Should throw error since registry is unavailable
-            try {
-                await resolver.resolve({
-                    address,
-                    targetAddress: address,
-                    node: mockNode,
-                    request: createRouterRequest(),
-                });
-                expect.fail('Should have thrown error');
-            }
-            catch (error) {
-                expect(error.message).to.equal('Registry unavailable');
-            }
-        });
-    });
-    describe('Address duplication bug fix', () => {
-        it('should NOT duplicate path segments when registry returns full hierarchical address', async () => {
-            // This test verifies the fix for the bug where o://services/embeddings-text
-            // was being resolved to o://leader/services/embeddings-text/services/embeddings-text
-            const address = new oNodeAddress('o://services/embeddings-text');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings-text',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            // Should be o://leader/services/embeddings-text, NOT o://leader/services/embeddings-text/embeddings-text
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings-text');
-        });
-        it('should NOT duplicate when calling via static address', async () => {
-            const address = new oNodeAddress('o://embeddings-text');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings-text',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings-text');
-        });
-        it('should still append legitimate extra params beyond the service name', async () => {
-            // If someone calls o://embeddings-text/custom/path, we should preserve /custom/path
-            const address = new oNodeAddress('o://embeddings-text/custom/path');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings-text',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            // Should append the extra /custom/path
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings-text/custom/path');
-        });
-    });
-    describe('Edge cases', () => {
-        it('should handle address with long nested paths', async () => {
-            const address = new oNodeAddress('o://leader/a/b/c/d/e/f');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/a/b/c/d/e/f',
-                        transports: [{ value: '/memory', type: TransportType.CUSTOM }],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.value).to.equal('o://leader/a/b/c/d/e/f');
-        });
-        it('should handle static addresses correctly', async () => {
-            const address = new oNodeAddress('o://embeddings-text');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings');
-        });
-        it('should handle when leader is undefined', async () => {
-            const address = new oNodeAddress('o://test');
-            // Create a new mock node with undefined leader
-            const mockNodeNoLeader = {
-                ...mockNode,
-                leader: undefined,
-            };
-            mockNodeNoLeader.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://test',
-                        transports: [{ value: '/memory', type: TransportType.CUSTOM }],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNodeNoLeader,
-                request: createRouterRequest(),
-            });
-            // Should still work, just won't have leader transports
-            expect(result.targetAddress.value).to.equal('o://test');
-        });
-        it('should handle multiple transports in search result', async () => {
-            const address = new oNodeAddress('o://multi-transport');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://multi-transport',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/4001',
-                                type: TransportType.LIBP2P,
-                            },
-                            {
-                                value: '/ip4/192.168.1.1/tcp/4002',
-                                type: TransportType.LIBP2P,
-                            },
-                            { value: '/memory', type: TransportType.CUSTOM },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.transports).to.have.lengthOf(3);
-        });
-    });
-});