@olane/o-node 0.7.12-alpha.21 → 0.7.12-alpha.23

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"}

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

@@ -0,0 +1,285 @@
+import { NodeState, oAddress, oAddressResolver, oCustomTransport, RestrictedAddresses, } 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 class oSearchResolver extends oAddressResolver {
+    constructor(address) {
+        super(address);
+        this.address = address;
+    }
+    get customTransports() {
+        return [new oCustomTransport('/search')];
+    }
+    /**
+     * Returns the address of the registry to search.
+     * Override this method to search a different registry.
+     * @returns The registry address to query
+     */
+    getRegistryAddress() {
+        return new oAddress('o://leader/registry');
+    }
+    /**
+     * Returns the method name to call on the registry.
+     * Override this method to use a different search method.
+     * @returns The method name to call
+     */
+    getSearchMethod() {
+        return 'search';
+    }
+    /**
+     * 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
+     */
+    buildSearchParams(address) {
+        return {
+            staticAddress: address.toRootAddress().toString(),
+            address: address.toString(),
+        };
+    }
+    /**
+     * 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
+     */
+    filterSearchResults(results, node) {
+        return results.filter(
+        // filter out the items that may cause infinite looping
+        (result) => result.staticAddress !== RestrictedAddresses.REGISTRY &&
+            result.address !== node.address);
+    }
+    /**
+     * 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
+     */
+    selectResult(results) {
+        return results.length > 0 ? results[0] : 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
+     */
+    mapTransports(result) {
+        return result.transports.map((t) => new oNodeTransport(t.value));
+    }
+    /**
+     * 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
+     */
+    resolveNextHopTransports(nextHop, targetTransports, node) {
+        // If next hop is the leader, use leader transports
+        if (nextHop.value === RestrictedAddresses.LEADER) {
+            return (node.leader?.transports || []);
+        }
+        // Check if next hop is a known child in the hierarchy
+        const childAddress = node?.hierarchyManager.getChild(nextHop);
+        if (childAddress?.transports) {
+            return childAddress.transports;
+        }
+        // Fall back to target transports from registry
+        return targetTransports;
+    }
+    /**
+     * 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;
+     *   }
+     * }
+     * ```
+     */
+    determineNextHop(node, resolvedTargetAddress, searchResult) {
+        // Determine next hop using standard hierarchy logic
+        const nextHopAddress = oAddress.next(node.address, resolvedTargetAddress);
+        // Map transports from search result
+        const targetTransports = this.mapTransports(searchResult);
+        // Set transports on the next hop based on routing logic
+        nextHopAddress.setTransports(this.resolveNextHopTransports(nextHopAddress, targetTransports, node));
+        return nextHopAddress;
+    }
+    async resolve(request) {
+        const { address, node, request: resolveRequest, targetAddress } = request;
+        // Early return: if address already has transports, no search needed
+        if (address.transports.length > 0) {
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        if (node.state !== NodeState.RUNNING) {
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        // Perform registry search with error handling
+        const searchParams = this.buildSearchParams(address);
+        const registryAddress = this.getRegistryAddress();
+        let searchResponse;
+        try {
+            searchResponse = await node.use(registryAddress, {
+                method: this.getSearchMethod(),
+                params: searchParams,
+            });
+        }
+        catch (error) {
+            // Log the error but don't throw - allow fallback resolvers to handle it
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Check if this is a circuit breaker error (fast-fail scenario)
+            if (errorMessage.includes('Circuit breaker is OPEN')) {
+                this.logger.warn(`Registry search blocked by circuit breaker for ${address.toString()}: ${errorMessage}`);
+            }
+            else {
+                this.logger.error(`Registry search failed for ${address.toString()}: ${errorMessage}`);
+            }
+            // Return original address without transports, letting next resolver in chain handle it
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        // Filter and select result
+        const filteredResults = this.filterSearchResults(searchResponse.result.data, node);
+        const selectedResult = this.selectResult(filteredResults);
+        // Early return: if no result found, return original address
+        if (!selectedResult) {
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        // Build route from search result
+        const extraParams = address
+            .toString() // o://embeddings-text replace o://embeddings-text = ''
+            .replace(address.toRootAddress().toString(), '');
+        // Check if selectedResult.address already contains the complete path
+        // This happens when registry finds via staticAddress - the returned address
+        // is the canonical hierarchical location, so we shouldn't append extraParams
+        const resultAddress = selectedResult.address;
+        const shouldAppendParams = extraParams && !resultAddress.endsWith(extraParams);
+        const resolvedTargetAddress = new oAddress(shouldAppendParams ? resultAddress + extraParams : resultAddress);
+        // Set transports on the target address
+        resolvedTargetAddress.setTransports(this.mapTransports(selectedResult));
+        // Determine next hop and configure transports
+        const nextHopAddress = this.determineNextHop(node, resolvedTargetAddress, selectedResult);
+        return {
+            nextHopAddress: nextHopAddress,
+            targetAddress: resolvedTargetAddress,
+            requestOverride: resolveRequest,
+        };
+    }
+}

package/dist/o-node/src/router/route.request.d.ts

@@ -0,0 +1,14 @@
+import { RequestParams } from '@olane/o-protocol';
+import { oRequest } from '@olane/o-core';
+import { Stream } from '@olane/o-config';
+export interface RouteRequest extends oRequest {
+    stream: Stream;
+    params: RequestParams & {
+        address: string;
+        payload: {
+            method: string;
+            params: RequestParams;
+        };
+    };
+}
+//# sourceMappingURL=route.request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"route.request.d.ts","sourceRoot":"","sources":["../../../../src/router/route.request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,MAAM,WAAW,YAAa,SAAQ,QAAQ;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,aAAa,GAAG;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE;YACP,MAAM,EAAE,MAAM,CAAC;YACf,MAAM,EAAE,aAAa,CAAC;SACvB,CAAC;KACH,CAAC;CACH"}

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

@@ -0,0 +1 @@
+export {};

package/dist/o-node/src/streaming/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Streaming functionality for o-node
+ *
+ * This module provides libp2p-specific implementations of the streaming
+ * abstractions defined in o-core.
+ */
+export * from '../../../o-core/src/streaming/index.js';
+export { Libp2pStreamTransport } from './libp2p-stream-transport.js';
+export { NodeStreamHandler, NodeStreamHandlerOptions, } from './node-stream-handler.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/streaming/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,wCAAwC,CAAC;AAGvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAGrE,OAAO,EACL,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,0BAA0B,CAAC"}

package/dist/o-node/src/streaming/index.js

@@ -0,0 +1,12 @@
+/**
+ * Streaming functionality for o-node
+ *
+ * This module provides libp2p-specific implementations of the streaming
+ * abstractions defined in o-core.
+ */
+// Re-export o-core streaming abstractions for convenience
+export * from '../../../o-core/src/streaming/index.js';
+// libp2p-specific stream transport
+export { Libp2pStreamTransport } from './libp2p-stream-transport.js';
+// o-node stream handler with metrics
+export { NodeStreamHandler, } from './node-stream-handler.js';

package/dist/o-node/src/streaming/libp2p-stream-transport.d.ts

@@ -0,0 +1,50 @@
+import { Stream } from '@olane/o-config';
+import { IStreamTransport, StreamStatus, StreamTransportConfig } from '../../../o-core/src/streaming/index.js';
+/**
+ * libp2p-specific implementation of IStreamTransport.
+ * Wraps a libp2p Stream and handles backpressure, message listening,
+ * and stream lifecycle management.
+ */
+export declare class Libp2pStreamTransport implements IStreamTransport {
+    private readonly stream;
+    private messageHandler?;
+    private config;
+    constructor(stream: Stream, config?: StreamTransportConfig);
+    /**
+     * Get the underlying libp2p Stream (useful for advanced use cases)
+     */
+    getStream(): Stream;
+    /**
+     * Send data through the stream with backpressure handling
+     */
+    send(data: Uint8Array): Promise<void>;
+    /**
+     * Set up a message handler for incoming data.
+     * IMPORTANT: For libp2p v3, this must be called synchronously after
+     * receiving the stream to prevent buffer overflow.
+     */
+    onMessage(handler: (data: Uint8Array) => void): void;
+    /**
+     * Remove the message handler
+     */
+    removeMessageHandler(): void;
+    /**
+     * Close the stream and clean up resources
+     */
+    close(): Promise<void>;
+    /**
+     * Get the current status of the stream
+     */
+    getStatus(): StreamStatus;
+    /**
+     * Check if the stream is in a usable state
+     */
+    isOpen(): boolean;
+    /**
+     * Wait for the first message with timeout
+     * @param timeoutMs - Optional timeout in milliseconds (defaults to config.readTimeoutMs)
+     * @returns Promise that resolves with the first message
+     */
+    waitForMessage(timeoutMs?: number): Promise<Uint8Array>;
+}
+//# sourceMappingURL=libp2p-stream-transport.d.ts.map

package/dist/o-node/src/streaming/libp2p-stream-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"libp2p-stream-transport.d.ts","sourceRoot":"","sources":["../../../../src/streaming/libp2p-stream-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,qBAAqB,EACtB,MAAM,wCAAwC,CAAC;AAUhD;;;;GAIG;AACH,qBAAa,qBAAsB,YAAW,gBAAgB;IAK1D,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJzB,OAAO,CAAC,cAAc,CAAC,CAA6B;IACpD,OAAO,CAAC,MAAM,CAAkC;gBAG7B,MAAM,EAAE,MAAM,EAC/B,MAAM,CAAC,EAAE,qBAAqB;IAQhC;;OAEG;IACI,SAAS,IAAI,MAAM;IAI1B;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB3C;;;;OAIG;IACH,SAAS,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI;IAcpD;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAO5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;OAEG;IACH,SAAS,IAAI,YAAY;IAkBzB;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;;;OAIG;IACG,cAAc,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAe9D"}