@olane/o-node 0.7.11 → 0.7.12-alpha.3

package/LICENSE

@@ -0,0 +1,34 @@
+# Dual License: MIT OR Apache-2.0
+
+Copyright (c) 2025 Olane Inc.
+
+Olane OS is dual-licensed under your choice of either:
+
+- **MIT License** (LICENSE-MIT or https://opensource.org/licenses/MIT)
+- **Apache License, Version 2.0** (LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0)
+
+## Why Dual Licensing?
+
+Dual licensing provides developers with flexibility when integrating Olane OS into their projects:
+
+- **Choose MIT**: If you prefer a simple, permissive license without patent provisions
+- **Choose Apache 2.0**: If you desire explicit patent protection and other features of the Apache license
+
+You may choose either license to govern your use of this software.
+
+## License Terms
+
+### MIT License
+The MIT license is very permissive and allows users to do almost anything with the software, including using, copying, modifying, merging, publishing, distributing, and selling it. The primary requirement is that the original copyright and license notice must be included in all copies of the software.
+
+See LICENSE-MIT for the full license text.
+
+### Apache License 2.0
+The Apache License 2.0 is also a permissive free software license. It grants users the right to use, modify, and distribute the software. It also includes provisions regarding patent grants, which are not present in the MIT license.
+
+See LICENSE-APACHE for the full license text.
+
+## Contributing
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you shall be dual-licensed as above, without any additional terms or conditions.
+

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

@@ -1 +1 @@
-{"version":3,"file":"o-node.search-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.search-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EAEL,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;IACvC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAED;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,IAAI,QAAQ;IAIxC;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,GAAG;IAOnD;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE;IASjE;;;;;OAKG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI;IAIlD;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,EAAE;IAOtD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,wBAAwB,CAChC,OAAO,EAAE,QAAQ,EACjB,gBAAgB,EAAE,cAAc,EAAE,EAClC,IAAI,EAAE,KAAK,GACV,cAAc,EAAE;IAgBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,SAAS,CAAC,gBAAgB,CACxB,IAAI,EAAE,KAAK,EACX,qBAAqB,EAAE,QAAQ,EAC/B,YAAY,EAAE,GAAG,GAChB,QAAQ;IAsBL,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CAkE/D"}
+{"version":3,"file":"o-node.search-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.search-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EAEL,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;IACvC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAED;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,IAAI,QAAQ;IAIxC;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,GAAG;IAOnD;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE;IASjE;;;;;OAKG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI;IAIlD;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,EAAE;IAOtD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,wBAAwB,CAChC,OAAO,EAAE,QAAQ,EACjB,gBAAgB,EAAE,cAAc,EAAE,EAClC,IAAI,EAAE,KAAK,GACV,cAAc,EAAE;IAgBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,SAAS,CAAC,gBAAgB,CACxB,IAAI,EAAE,KAAK,EACX,qBAAqB,EAAE,QAAQ,EAC/B,YAAY,EAAE,GAAG,GAChB,QAAQ;IAsBL,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CA8D/D"}

package/dist/src/router/resolvers/o-node.search-resolver.js

@@ -228,7 +228,6 @@ export class oSearchResolver extends oAddressResolver {
         // Filter and select result
         const filteredResults = this.filterSearchResults(searchResponse.result.data, node);
         const selectedResult = this.selectResult(filteredResults);
-        this.logger.debug('Selecting result:', selectedResult?.address || 'no result found');
         // Early return: if no result found, return original address
         if (!selectedResult) {
             return {

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

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

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

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

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

@@ -0,0 +1,614 @@
+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('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);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.11",
+  "version": "0.7.12-alpha.3",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -24,8 +24,6 @@
     "deep:clean": "rm -rf node_modules && rm package-lock.json",
     "start:prod": "node dist/index.js",
     "prepublishOnly": "npm run build",
-    "update:lib": "npm install @olane/o-core@latest",
-    "update:peers": "npm install @olane/o-core@latest @olane/o-config@latest @olane/o-protocol@latest @olane/o-tool@latest --save-peer",
     "lint": "eslint src/**/*.ts"
   },
   "repository": {
@@ -55,14 +53,13 @@
     "tsx": "^4.20.3",
     "typescript": "5.4.5"
   },
-  "peerDependencies": {
-    "@olane/o-config": "^0.7.10",
-    "@olane/o-core": "^0.7.10",
-    "@olane/o-protocol": "^0.7.10",
-    "@olane/o-tool": "^0.7.10"
-  },
   "dependencies": {
+    "@olane/o-config": "^0.7.12-alpha.3",
+    "@olane/o-core": "0.7.12-alpha.3",
+    "@olane/o-protocol": "^0.7.12-alpha.3",
+    "@olane/o-tool": "0.7.12-alpha.3",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0"
-  }
+  },
+  "gitHead": "5c05e5f248001abc38f34c77bd97c9a325231503"
 }