@olane/o-node 0.7.12-alpha.4 → 0.7.12-alpha.41

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

@@ -0,0 +1,181 @@
+import { CoreUtils, oAddress, oError, oErrorCodes, oRequest, ResponseBuilder, } from '@olane/o-core';
+import { oToolRouter } from '@olane/o-tool';
+import { oNodeConnection } from '../connection/o-node-connection.js';
+import { oNodeRoutingPolicy } from './o-node.routing-policy.js';
+import { oStreamRequest } from '../connection/o-stream.request.js';
+export class oNodeRouter extends oToolRouter {
+    constructor() {
+        super();
+        this.routingPolicy = new oNodeRoutingPolicy();
+    }
+    /**
+     * Forwards a request to the specified address via libp2p transport.
+     * Handles self-routing (local execution) and destination detection.
+     *
+     * @param address The next hop address to forward to
+     * @param request The router request to forward
+     * @param node The current node context
+     * @returns The response from the forwarded request
+     */
+    async forward(address, request, node) {
+        if (!request.stream) {
+            throw new oError(oErrorCodes.INVALID_REQUEST, 'Stream is required');
+        }
+        let nextHopRequest = new oRequest({
+            method: request.method,
+            params: request.params,
+            id: request.id,
+        });
+        if (request.stream) {
+            nextHopRequest.stream = request.stream;
+        }
+        // Handle self-routing: execute locally instead of dialing
+        if (this.routingPolicy.isSelfAddress(address, node)) {
+            return this.executeSelfRouting(request, node);
+        }
+        // Check if we've reached the final destination
+        const isDestination = this.isDestinationAddress(address, request);
+        if (isDestination) {
+            nextHopRequest = this.unwrapDestinationRequest(request);
+        }
+        // Dial and transmit to remote node
+        return this.dialAndTransmit(address, nextHopRequest, node);
+    }
+    /**
+     * Executes a request locally when routing to self.
+     * Now uses ResponseBuilder for consistency with useSelf() behavior.
+     */
+    async executeSelfRouting(request, node) {
+        const { payload } = request.params;
+        const params = payload.params;
+        const localRequest = new oRequest({
+            method: payload.method,
+            params: {
+                ...params,
+                _connectionId: request.params._connectionId,
+                _requestMethod: payload.method,
+            },
+            id: request.id,
+        });
+        // Create ResponseBuilder with metrics tracking
+        const responseBuilder = ResponseBuilder.create().withMetrics(node.metrics);
+        // Handle streaming requests
+        const isStream = request.params._isStreaming;
+        if (isStream && request.stream) {
+            // For streaming, we need to handle the stream chunks
+            try {
+                const result = await node.execute(localRequest, request.stream);
+                const response = await responseBuilder.build(localRequest, result, null, {
+                    isStream: true,
+                });
+                // Return unwrapped data for consistency with dialAndTransmit
+                return response.result.data;
+            }
+            catch (error) {
+                const errorResponse = await responseBuilder.buildError(localRequest, error, {
+                    isStream: true,
+                });
+                // For errors, throw to match remote behavior
+                throw responseBuilder.normalizeError(error);
+            }
+        }
+        // Handle non-streaming requests with error handling
+        try {
+            const result = await node.execute(localRequest);
+            const response = await responseBuilder.build(localRequest, result, null);
+            // Return unwrapped data to match dialAndTransmit behavior
+            return response.result.data;
+        }
+        catch (error) {
+            // Build error response for metrics tracking
+            await responseBuilder.buildError(localRequest, error);
+            // Then throw the normalized error
+            throw responseBuilder.normalizeError(error);
+        }
+    }
+    /**
+     * Checks if the next hop is the final destination address.
+     */
+    isDestinationAddress(address, request) {
+        return address
+            ?.toStaticAddress()
+            .equals(new oAddress(request?.params?.address).toStaticAddress());
+    }
+    /**
+     * Unwraps the routing envelope when we've reached the destination.
+     */
+    unwrapDestinationRequest(request) {
+        const { payload } = request.params;
+        const params = payload.params;
+        return new oStreamRequest({
+            method: payload.method,
+            params: { ...params },
+            id: request.id,
+            stream: request.stream,
+        });
+    }
+    /**
+     * Dials a remote node and transmits the request via libp2p.
+     */
+    async dialAndTransmit(address, request, node) {
+        try {
+            const isStream = request.params._isStreaming ||
+                request.params.payload?.params?._isStreaming;
+            const connection = await node.p2pNode.dial(address.libp2pTransports.map((t) => t.toMultiaddr()));
+            const nodeConnection = new oNodeConnection({
+                p2pConnection: connection,
+                nextHopAddress: address,
+                address: node.address,
+                callerAddress: node.address,
+                isStream: isStream,
+            });
+            if (isStream) {
+                const routeRequest = request;
+                if (!routeRequest.stream) {
+                    throw new oError(oErrorCodes.INVALID_REQUEST, 'Stream is required');
+                }
+                nodeConnection.onChunk(async (response) => {
+                    CoreUtils.sendStreamResponse(response, routeRequest.stream);
+                });
+                // allow this to continue as we will tell the transmitter to stream the response and we will intercept via the above listener
+            }
+            const response = await nodeConnection.transmit(request);
+            return response.result.data;
+        }
+        catch (error) {
+            if (error?.name === 'UnsupportedProtocolError') {
+                throw new oError(oErrorCodes.NOT_FOUND, 'Address not found');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Translates an address to determine the next hop and target addresses.
+     * First checks routing policy for external routing, then applies resolver chain.
+     */
+    async translate(address, node) {
+        // Check if external routing is needed
+        const externalRoute = this.routingPolicy.getExternalRoutingStrategy(address, node);
+        if (externalRoute) {
+            return externalRoute;
+        }
+        // Apply resolver chain for internal routing
+        const { nextHopAddress, targetAddress, requestOverride } = await this.addressResolution.resolve({
+            address,
+            node,
+            targetAddress: address,
+        });
+        return {
+            nextHopAddress,
+            targetAddress: targetAddress,
+            requestOverride,
+        };
+    }
+    /**
+     * Determines if an address is internal to this node's hierarchy.
+     * Delegates to the routing policy for the decision.
+     */
+    isInternal(addressWithTransports, node) {
+        return this.routingPolicy.isInternalAddress(addressWithTransports, node);
+    }
+}

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

@@ -0,0 +1,30 @@
+import { oAddress, oRoutingPolicy, RouteResponse } from '@olane/o-core';
+import type { oNode } from '../o-node.js';
+/**
+ * Routing policy implementation for oNode that handles internal/external routing decisions
+ * and leader-based routing strategies.
+ */
+export declare class oNodeRoutingPolicy extends oRoutingPolicy {
+    /**
+     * Determines if an address is internal to the current node's hierarchy.
+     * An address is considered internal if:
+     * 1. It doesn't have leader references, OR
+     * 2. Its leader references match our known leaders
+     *
+     * @param address The address to check
+     * @param node The current node context
+     * @returns True if the address is internal to this hierarchy
+     */
+    isInternalAddress(address: oAddress, node: oNode): boolean;
+    /**
+     * Determines the routing strategy for external addresses.
+     * External addresses are routed to the leader of the external OS using
+     * the address's libp2p transports.
+     *
+     * @param address The address to evaluate
+     * @param node The current node context
+     * @returns RouteResponse if external routing is needed, null if internal
+     */
+    getExternalRoutingStrategy(address: oAddress, node: oNode): RouteResponse | null;
+}
+//# sourceMappingURL=o-node.routing-policy.d.ts.map

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

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

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

@@ -0,0 +1,57 @@
+import { oAddress, oRoutingPolicy } from '@olane/o-core';
+import { oNodeAddress } from './o-node.address.js';
+/**
+ * Routing policy implementation for oNode that handles internal/external routing decisions
+ * and leader-based routing strategies.
+ */
+export class oNodeRoutingPolicy extends oRoutingPolicy {
+    /**
+     * Determines if an address is internal to the current node's hierarchy.
+     * An address is considered internal if:
+     * 1. It doesn't have leader references, OR
+     * 2. Its leader references match our known leaders
+     *
+     * @param address The address to check
+     * @param node The current node context
+     * @returns True if the address is internal to this hierarchy
+     */
+    isInternalAddress(address, node) {
+        const nodeAddress = address;
+        // if we are trying to connect to a parent, it's internal
+        if (node.hierarchyManager.parents.some((p) => p.equals(address))) {
+            return true;
+        }
+        if (nodeAddress.paths.indexOf(oAddress.leader().paths) !== -1 && // if the address has a leader
+            nodeAddress.libp2pTransports?.length > 0) {
+            // transports are provided, let's see if they match our known leaders
+            const isLeaderRef = nodeAddress.toString() === oAddress.leader().toString();
+            const isOurLeaderRef = node.address.equals(nodeAddress) ||
+                node.hierarchyManager.leaders.some((l) => l.equals(nodeAddress));
+            return isLeaderRef || isOurLeaderRef;
+        }
+        return true;
+    }
+    /**
+     * Determines the routing strategy for external addresses.
+     * External addresses are routed to the leader of the external OS using
+     * the address's libp2p transports.
+     *
+     * @param address The address to evaluate
+     * @param node The current node context
+     * @returns RouteResponse if external routing is needed, null if internal
+     */
+    getExternalRoutingStrategy(address, node) {
+        const nodeAddress = address;
+        const isInternal = this.isInternalAddress(address, node);
+        if (!isInternal) {
+            // external address, so we need to route
+            this.logger.debug('Address is external, routing...', nodeAddress);
+            // route to leader of external OS
+            return {
+                nextHopAddress: new oNodeAddress(oAddress.leader().toString(), nodeAddress.libp2pTransports),
+                targetAddress: nodeAddress,
+            };
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Multiaddr } from '@olane/o-config';
+import { oTransport, TransportType } from '@olane/o-core';
+export declare class oNodeTransport extends oTransport {
+    readonly type: TransportType;
+    value: Multiaddr | string;
+    constructor(value: Multiaddr | string);
+    toMultiaddr(): Multiaddr;
+    toString(): string;
+    toPeerId(): string;
+}
+//# sourceMappingURL=o-node.transport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.transport.d.ts","sourceRoot":"","sources":["../../../../src/router/o-node.transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE1D,qBAAa,cAAe,SAAQ,UAAU;IAC5C,SAAgB,IAAI,EAAE,aAAa,CAAwB;IACpD,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC;gBAErB,KAAK,EAAE,SAAS,GAAG,MAAM;IAKrC,WAAW,IAAI,SAAS;IAIxB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM;CAGnB"}

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

@@ -0,0 +1,18 @@
+import { multiaddr } from '@olane/o-config';
+import { oTransport, TransportType } from '@olane/o-core';
+export class oNodeTransport extends oTransport {
+    constructor(value) {
+        super(value);
+        this.type = TransportType.LIBP2P;
+        this.value = value;
+    }
+    toMultiaddr() {
+        return multiaddr(this.toString());
+    }
+    toString() {
+        return this.value.toString();
+    }
+    toPeerId() {
+        return this.value.toString().split('/p2p/')[1];
+    }
+}

package/dist/o-node/src/router/resolvers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './o-node.search-resolver.js';
+export * from './o-node.resolver.js';
+export * from './o-node.leader-resolver-fallback.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/router/resolvers/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sCAAsC,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from './o-node.search-resolver.js';
+export * from './o-node.resolver.js';
+export * from './o-node.leader-resolver-fallback.js';

package/dist/o-node/src/router/resolvers/o-node.leader-resolver-fallback.d.ts

@@ -0,0 +1,8 @@
+import { oAddress, oAddressResolver, oTransport, ResolveRequest, RouteResponse } from '@olane/o-core';
+export declare class oLeaderResolverFallback extends oAddressResolver {
+    protected readonly address: oAddress;
+    constructor(address: oAddress);
+    get customTransports(): oTransport[];
+    resolve(request: ResolveRequest): Promise<RouteResponse>;
+}
+//# sourceMappingURL=o-node.leader-resolver-fallback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.leader-resolver-fallback.d.ts","sourceRoot":"","sources":["../../../../../src/router/resolvers/o-node.leader-resolver-fallback.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAEhB,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AAIvB,qBAAa,uBAAwB,SAAQ,gBAAgB;IAC/C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAEK,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CA4B/D"}

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

@@ -0,0 +1,35 @@
+import { oAddressResolver, oCustomTransport, } from '@olane/o-core';
+export class oLeaderResolverFallback extends oAddressResolver {
+    constructor(address) {
+        super(address);
+        this.address = address;
+    }
+    get customTransports() {
+        return [new oCustomTransport('/fallback/leader')];
+    }
+    async resolve(request) {
+        const { address, node, request: resolveRequest, targetAddress } = request;
+        // check to see if something odd was attempted where the leader transports were applied to a different address
+        if (node.leader &&
+            address.transports.some((t) => node.leader?.transports.includes(t))) {
+            return {
+                nextHopAddress: node.leader,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        // if already has transports, return the address
+        if (address.transports.length > 0) {
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        return {
+            nextHopAddress: node.leader,
+            targetAddress: targetAddress,
+            requestOverride: resolveRequest,
+        };
+    }
+}

package/dist/{src/router/resolvers/o-node.child-resolver.d.ts → o-node/src/router/resolvers/o-node.resolver.d.ts}

@@ -2,10 +2,10 @@ import { oAddressResolver, TransportType } from '@olane/o-core';
 import { oNodeAddress } from '../o-node.address.js';
 import { oNodeRouterResponse } from '../interfaces/o-node-router.response.js';
 import { ResolveRequest } from '@olane/o-core';
-export declare class oNodeChildResolver extends oAddressResolver {
+export declare class oNodeResolver extends oAddressResolver {
     protected readonly address: oNodeAddress;
     constructor(address: oNodeAddress);
     get supportedTransports(): TransportType[];
     resolve(routeRequest: ResolveRequest): Promise<oNodeRouterResponse>;
 }
-//# sourceMappingURL=o-node.child-resolver.d.ts.map
+//# sourceMappingURL=o-node.resolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.resolver.d.ts","sourceRoot":"","sources":["../../../../../src/router/resolvers/o-node.resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEhB,aAAa,EAId,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,qBAAa,aAAc,SAAQ,gBAAgB;IACrC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY;gBAArB,OAAO,EAAE,YAAY;IAIpD,IAAI,mBAAmB,IAAI,aAAa,EAAE,CAEzC;IAEK,OAAO,CAAC,YAAY,EAAE,cAAc,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA8C1E"}

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

@@ -0,0 +1,45 @@
+import { oAddressResolver, oAddress, TransportType, oError, oErrorCodes, } from '@olane/o-core';
+import { oNodeAddress } from '../o-node.address.js';
+export class oNodeResolver extends oAddressResolver {
+    constructor(address) {
+        super(address);
+        this.address = address;
+    }
+    get supportedTransports() {
+        return [TransportType.LIBP2P];
+    }
+    async resolve(routeRequest) {
+        const { address, node, request, targetAddress } = routeRequest;
+        // get the next node & check for child address existence
+        const remainingPath = targetAddress.paths.replace(node.address.paths + '/', '');
+        // ensure this is going down in the hierarchy
+        if (remainingPath === targetAddress.paths && node.isLeader === false) {
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: request,
+            };
+        }
+        // next term resolver
+        const parts = remainingPath.split('/');
+        const nextNode = new oNodeAddress(`o://${parts.shift()}`);
+        const childAddress = node?.hierarchyManager.getChild(nextNode);
+        // get the child address from hierarchy (which includes transports)
+        if (childAddress) {
+            return {
+                nextHopAddress: childAddress,
+                targetAddress: targetAddress,
+                requestOverride: request,
+            };
+        }
+        // no child address, and we have already been to the leader, fail
+        if (address.toString().indexOf(oAddress.leader().toString()) > -1) {
+            throw new oError(oErrorCodes.NOT_FOUND, targetAddress.toString() + ' node not found.');
+        }
+        return {
+            nextHopAddress: address,
+            targetAddress: targetAddress,
+            requestOverride: request,
+        };
+    }
+}

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

@@ -0,0 +1,170 @@
+import { oAddress, oAddressResolver, oCore, oTransport, ResolveRequest, RouteResponse } from '@olane/o-core';
+import { oNodeTransport } from '../o-node.transport.js';
+/**
+ * Address resolver that searches a registry to find transports for addresses.
+ *
+ * This resolver queries a registry service to find the transport information
+ * for addresses that don't already have transports configured. It's designed
+ * to be extensible through subclassing via protected template methods.
+ *
+ * @example Basic usage
+ * ```typescript
+ * const resolver = new oSearchResolver(nodeAddress);
+ * router.addResolver(resolver);
+ * ```
+ *
+ * @example Creating a custom search resolver
+ * ```typescript
+ * class CustomSearchResolver extends oSearchResolver {
+ *   // Search a different registry
+ *   protected getRegistryAddress(): oAddress {
+ *     return new oAddress('o://my-custom-registry');
+ *   }
+ *
+ *   // Use round-robin selection instead of first result
+ *   private currentIndex = 0;
+ *   protected selectResult(results: any[]): any | null {
+ *     if (results.length === 0) return null;
+ *     const result = results[this.currentIndex % results.length];
+ *     this.currentIndex++;
+ *     return result;
+ *   }
+ *
+ *   // Add custom filtering logic
+ *   protected filterSearchResults(results: any[], node: oCore): any[] {
+ *     return super.filterSearchResults(results, node).filter(
+ *       result => result.status === 'active'
+ *     );
+ *   }
+ *
+ *   // Implement custom routing logic with transport setup
+ *   protected determineNextHop(
+ *     node: oCore,
+ *     resolvedTargetAddress: oAddress,
+ *     searchResult: any
+ *   ): oAddress {
+ *     // Always route directly to target, bypassing hierarchy
+ *     const targetTransports = this.mapTransports(searchResult);
+ *     resolvedTargetAddress.setTransports(targetTransports);
+ *     return resolvedTargetAddress;
+ *   }
+ * }
+ * ```
+ *
+ * ## Extension Points
+ *
+ * The following protected methods can be overridden to customize behavior:
+ *
+ * - `getRegistryAddress()` - Change which registry to search
+ * - `getSearchMethod()` - Change the registry method to call
+ * - `buildSearchParams()` - Customize search parameters
+ * - `filterSearchResults()` - Add custom filtering logic
+ * - `selectResult()` - Implement custom result selection (e.g., load balancing)
+ * - `mapTransports()` - Customize how transports are mapped from results
+ * - `determineNextHop()` - Implement custom routing logic to determine the next hop address
+ * - `resolveNextHopTransports()` - Customize transport resolution for the next hop
+ */
+export declare class oSearchResolver extends oAddressResolver {
+    protected readonly address: oAddress;
+    constructor(address: oAddress);
+    get customTransports(): oTransport[];
+    /**
+     * Returns the address of the registry to search.
+     * Override this method to search a different registry.
+     * @returns The registry address to query
+     */
+    protected getRegistryAddress(): oAddress;
+    /**
+     * Returns the method name to call on the registry.
+     * Override this method to use a different search method.
+     * @returns The method name to call
+     */
+    protected getSearchMethod(): string;
+    /**
+     * Builds the search parameters for the registry query.
+     * Override this method to customize search parameters.
+     * @param address - The address being resolved
+     * @returns Parameters to pass to the registry search method
+     */
+    protected buildSearchParams(address: oAddress): any;
+    /**
+     * Filters the search results from the registry.
+     * Override this method to apply custom filtering logic.
+     * @param results - Raw results from the registry
+     * @param node - The current node context
+     * @returns Filtered array of results
+     */
+    protected filterSearchResults(results: any[], node: oCore): any[];
+    /**
+     * Selects which result to use from the filtered results.
+     * Override this method to implement custom selection logic (e.g., load balancing).
+     * @param results - Filtered search results
+     * @returns The selected result, or null if no suitable result
+     */
+    protected selectResult(results: any[]): any | null;
+    /**
+     * Maps the transport data from the search result to oNodeTransport instances.
+     * Override this method to customize transport mapping.
+     * @param result - The selected search result
+     * @returns Array of oNodeTransport instances
+     */
+    protected mapTransports(result: any): oNodeTransport[];
+    /**
+     * Resolves the transports for the next hop address.
+     * This handles the logic of determining which transports to use based on
+     * whether the next hop is the leader, a known child, or a new target.
+     *
+     * Override this method to customize transport resolution logic.
+     *
+     * @param nextHop - The next hop address
+     * @param targetTransports - The transports from the registry search result
+     * @param node - The current node context
+     * @returns Array of transports to use for the next hop
+     */
+    protected resolveNextHopTransports(nextHop: oAddress, targetTransports: oNodeTransport[], node: oCore): oNodeTransport[];
+    /**
+     * Determines the next hop address for routing to the target and sets up its transports.
+     *
+     * This method implements the complete routing logic including:
+     * 1. Determining the next address in the path (using `oAddress.next()`)
+     * 2. Mapping transports from the search result
+     * 3. Resolving and setting transports on the next hop address
+     * 4. Setting transports on the target address
+     *
+     * The default implementation:
+     * - Uses `oAddress.next()` for standard hierarchy-based routing
+     * - Maps transports from the registry search result
+     * - Resolves next hop transports based on leader/hierarchy
+     * - Configures both next hop and target with appropriate transports
+     *
+     * Override this method to implement custom routing logic, such as:
+     * - Direct peer-to-peer routing
+     * - Custom hierarchy traversal
+     * - Alternative transport selection strategies
+     * - Bypass leader for certain routes
+     *
+     * @param node - The current node context
+     * @param resolvedTargetAddress - The resolved target address to route to
+     * @param searchResult - The raw search result from the registry containing transport data
+     * @returns The next hop address with transports configured
+     *
+     * @example Custom direct routing
+     * ```typescript
+     * class DirectSearchResolver extends oSearchResolver {
+     *   protected determineNextHop(
+     *     node: oCore,
+     *     resolvedTargetAddress: oAddress,
+     *     searchResult: any
+     *   ): oAddress {
+     *     // Always route directly to the target, bypassing hierarchy
+     *     const targetTransports = this.mapTransports(searchResult);
+     *     resolvedTargetAddress.setTransports(targetTransports);
+     *     return resolvedTargetAddress;
+     *   }
+     * }
+     * ```
+     */
+    protected determineNextHop(node: oCore, resolvedTargetAddress: oAddress, searchResult: any): oAddress;
+    resolve(request: ResolveRequest): Promise<RouteResponse>;
+}
+//# sourceMappingURL=o-node.search-resolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.search-resolver.d.ts","sourceRoot":"","sources":["../../../../../src/router/resolvers/o-node.search-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,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;IAeL,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CAsG/D"}