@olane/o-node 0.7.12-alpha.42 → 0.7.12-alpha.43

package/dist/src/streaming/index.d.ts

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

package/dist/src/streaming/index.d.ts.map

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

package/dist/src/streaming/index.js

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

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

@@ -1,50 +0,0 @@
-import { Stream } from '@olane/o-config';
-import { IStreamTransport, StreamStatus, StreamTransportConfig } from '@olane/o-core';
-/**
- * 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/src/streaming/libp2p-stream-transport.d.ts.map

@@ -1 +0,0 @@
-{"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,eAAe,CAAC;AAUvB;;;;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"}

package/dist/src/streaming/libp2p-stream-transport.js

@@ -1,137 +0,0 @@
-import { StreamStatus, } from '@olane/o-core';
-/**
- * Default configuration for libp2p stream transport
- */
-const DEFAULT_CONFIG = {
-    drainTimeoutMs: 30000, // 30 seconds
-    readTimeoutMs: 120000, // 2 minutes
-};
-/**
- * libp2p-specific implementation of IStreamTransport.
- * Wraps a libp2p Stream and handles backpressure, message listening,
- * and stream lifecycle management.
- */
-export class Libp2pStreamTransport {
-    constructor(stream, config) {
-        this.stream = stream;
-        this.config = {
-            ...DEFAULT_CONFIG,
-            ...config,
-        };
-    }
-    /**
-     * Get the underlying libp2p Stream (useful for advanced use cases)
-     */
-    getStream() {
-        return this.stream;
-    }
-    /**
-     * Send data through the stream with backpressure handling
-     */
-    async send(data) {
-        // Check stream status before sending
-        if (this.stream.status !== 'open') {
-            throw new Error(`Cannot send on stream with status: ${this.stream.status}`);
-        }
-        try {
-            // Attempt to send the data
-            const sent = this.stream.send(data);
-            // Handle backpressure if the buffer is full
-            if (!sent) {
-                // Wait for the stream to drain with timeout
-                await this.stream.onDrain({
-                    signal: AbortSignal.timeout(this.config.drainTimeoutMs),
-                });
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to send data: ${error}`);
-        }
-    }
-    /**
-     * 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) {
-        this.messageHandler = handler;
-        // Attach the message listener to the stream
-        // This is synchronous and must be done immediately for libp2p v3
-        this.stream.addEventListener('message', (event) => {
-            if (this.messageHandler) {
-                // Extract the data from the event
-                const data = event.detail;
-                this.messageHandler(data);
-            }
-        });
-    }
-    /**
-     * Remove the message handler
-     */
-    removeMessageHandler() {
-        this.messageHandler = undefined;
-        // Note: We don't remove the event listener because libp2p doesn't
-        // provide a clean way to do this. The handler being undefined
-        // effectively disables it.
-    }
-    /**
-     * Close the stream and clean up resources
-     */
-    async close() {
-        try {
-            if (this.stream.status === 'open' || this.stream.status === 'closing') {
-                await this.stream.close();
-            }
-        }
-        catch (error) {
-            console.error('Error closing stream:', error);
-            // Don't throw - closing errors are not critical
-        }
-        finally {
-            this.removeMessageHandler();
-        }
-    }
-    /**
-     * Get the current status of the stream
-     */
-    getStatus() {
-        // Map libp2p status to our StreamStatus enum
-        const status = this.stream.status;
-        switch (status) {
-            case 'open':
-                return StreamStatus.OPEN;
-            case 'closing':
-                return StreamStatus.CLOSING;
-            case 'closed':
-                return StreamStatus.CLOSED;
-            case 'reset':
-                return StreamStatus.RESET;
-            default:
-                return StreamStatus.CLOSED;
-        }
-    }
-    /**
-     * Check if the stream is in a usable state
-     */
-    isOpen() {
-        return this.stream.status === 'open';
-    }
-    /**
-     * 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
-     */
-    async waitForMessage(timeoutMs) {
-        const timeout = timeoutMs ?? this.config.readTimeoutMs;
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.removeMessageHandler();
-                reject(new Error(`Timeout waiting for message after ${timeout}ms`));
-            }, timeout);
-            this.onMessage((data) => {
-                clearTimeout(timer);
-                resolve(data);
-            });
-        });
-    }
-}

package/dist/src/streaming/node-stream-handler.d.ts

@@ -1,65 +0,0 @@
-import { StreamHandlerBase, StreamHandlerOptions } from '@olane/o-core';
-import { oRequest } from '@olane/o-protocol';
-import { Libp2pStreamTransport } from './libp2p-stream-transport.js';
-/**
- * Options for NodeStreamHandler
- */
-export interface NodeStreamHandlerOptions extends StreamHandlerOptions {
-    /**
-     * Enable success count tracking
-     */
-    trackSuccessCount?: boolean;
-    /**
-     * Enable error count tracking
-     */
-    trackErrorCount?: boolean;
-}
-/**
- * o-node specific implementation of StreamHandlerBase.
- * Integrates with libp2p streams and tracks metrics for o-node tools.
- */
-export declare class NodeStreamHandler extends StreamHandlerBase {
-    private successCount;
-    private errorCount;
-    private transport;
-    private nodeOptions;
-    constructor(transport: Libp2pStreamTransport, options?: NodeStreamHandlerOptions);
-    /**
-     * Get the success count (number of chunks successfully sent)
-     */
-    getSuccessCount(): number;
-    /**
-     * Get the error count
-     */
-    getErrorCount(): number;
-    /**
-     * Reset metrics
-     */
-    resetMetrics(): void;
-    /**
-     * Implementation of sendChunk using libp2p transport and protocol builder
-     */
-    protected sendChunk(chunk: unknown, sequence: number, isLast: boolean, request: oRequest): Promise<void>;
-    /**
-     * Hook: Called when streaming starts
-     */
-    protected onStreamStart(request: oRequest): void;
-    /**
-     * Hook: Called when streaming completes successfully
-     */
-    protected onStreamComplete(request: oRequest, totalChunks: number): void;
-    /**
-     * Hook: Called when streaming encounters an error
-     */
-    protected onStreamError(request: oRequest, error: any): void;
-    /**
-     * Reset the handler for reuse with a new transport
-     */
-    reset(): void;
-    /**
-     * Create a new NodeStreamHandler with a different transport
-     * (useful for handling multiple streams)
-     */
-    static create(transport: Libp2pStreamTransport, options?: NodeStreamHandlerOptions): NodeStreamHandler;
-}
-//# sourceMappingURL=node-stream-handler.d.ts.map

package/dist/src/streaming/node-stream-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-stream-handler.d.ts","sourceRoot":"","sources":["../../../src/streaming/node-stream-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EAErB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,oBAAoB;IACpE;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB;IACtD,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,SAAS,CAAwB;IACzC,OAAO,CAAC,WAAW,CAA2B;gBAG5C,SAAS,EAAE,qBAAqB,EAChC,OAAO,GAAE,wBAA6B;IAWxC;;OAEG;IACI,eAAe,IAAI,MAAM;IAIhC;;OAEG;IACI,aAAa,IAAI,MAAM;IAI9B;;OAEG;IACI,YAAY,IAAI,IAAI;IAK3B;;OAEG;cACa,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,IAAI,CAAC;IA0BhB;;OAEG;cACgB,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI;IAOzD;;OAEG;cACgB,gBAAgB,CACjC,OAAO,EAAE,QAAQ,EACjB,WAAW,EAAE,MAAM,GAClB,IAAI;IASP;;OAEG;cACgB,aAAa,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IAUrE;;OAEG;IACI,KAAK,IAAI,IAAI;IAOpB;;;OAGG;WACW,MAAM,CAClB,SAAS,EAAE,qBAAqB,EAChC,OAAO,CAAC,EAAE,wBAAwB,GACjC,iBAAiB;CAGrB"}

package/dist/src/streaming/node-stream-handler.js

@@ -1,101 +0,0 @@
-import { StreamHandlerBase, ProtocolBuilder, } from '@olane/o-core';
-/**
- * o-node specific implementation of StreamHandlerBase.
- * Integrates with libp2p streams and tracks metrics for o-node tools.
- */
-export class NodeStreamHandler extends StreamHandlerBase {
-    constructor(transport, options = {}) {
-        super(options);
-        this.successCount = 0;
-        this.errorCount = 0;
-        this.transport = transport;
-        this.nodeOptions = {
-            trackSuccessCount: true,
-            trackErrorCount: true,
-            ...options,
-        };
-    }
-    /**
-     * Get the success count (number of chunks successfully sent)
-     */
-    getSuccessCount() {
-        return this.successCount;
-    }
-    /**
-     * Get the error count
-     */
-    getErrorCount() {
-        return this.errorCount;
-    }
-    /**
-     * Reset metrics
-     */
-    resetMetrics() {
-        this.successCount = 0;
-        this.errorCount = 0;
-    }
-    /**
-     * Implementation of sendChunk using libp2p transport and protocol builder
-     */
-    async sendChunk(chunk, sequence, isLast, request) {
-        // Build the JSON-RPC streaming chunk message
-        const message = ProtocolBuilder.buildStreamChunkFromRequest(chunk, sequence, isLast, request);
-        // Encode the message to bytes
-        const encoded = ProtocolBuilder.encodeMessage(message);
-        // Send through the transport (handles backpressure)
-        await this.transport.send(encoded);
-        // Track metrics if enabled
-        if (this.nodeOptions.trackSuccessCount) {
-            this.successCount++;
-        }
-        // Close the stream if this is the last chunk
-        if (isLast) {
-            await this.transport.close();
-        }
-    }
-    /**
-     * Hook: Called when streaming starts
-     */
-    onStreamStart(request) {
-        // Reset metrics for this stream
-        if (this.nodeOptions.enableMetrics) {
-            this.resetMetrics();
-        }
-    }
-    /**
-     * Hook: Called when streaming completes successfully
-     */
-    onStreamComplete(request, totalChunks) {
-        // Log completion if metrics enabled
-        if (this.nodeOptions.enableMetrics) {
-            console.log(`Stream completed for ${request.method}: ${totalChunks} chunks sent`);
-        }
-    }
-    /**
-     * Hook: Called when streaming encounters an error
-     */
-    onStreamError(request, error) {
-        // Track error count
-        if (this.nodeOptions.trackErrorCount) {
-            this.errorCount++;
-        }
-        // Log error
-        console.error(`Stream error for ${request.method}:`, error);
-    }
-    /**
-     * Reset the handler for reuse with a new transport
-     */
-    reset() {
-        // Call parent reset
-        this.state = 0; // Reset state (IDLE)
-        this.currentSequence = 0;
-        this.resetMetrics();
-    }
-    /**
-     * Create a new NodeStreamHandler with a different transport
-     * (useful for handling multiple streams)
-     */
-    static create(transport, options) {
-        return new NodeStreamHandler(transport, options);
-    }
-}

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

@@ -1,33 +0,0 @@
-import { Stream } from '@olane/o-config';
-import { oRequest, StreamTransportConfig } from '@olane/o-core';
-/**
- * Client-side streaming orchestration for o-node.
- * Manages chunk queues, backpressure, timeouts, and provides both
- * callback and AsyncGenerator interfaces for streaming responses.
- */
-export declare class oNodeStreamingClient {
-    /**
-     * Transmit a request via streaming and receive chunks through a callback.
-     * This method handles the full streaming lifecycle including timeouts,
-     * chunk sequencing, and cleanup.
-     *
-     * @param stream The libp2p stream to use for communication
-     * @param request The request to send
-     * @param onChunk Callback invoked for each chunk received
-     * @param config Optional transport configuration
-     * @returns Promise that resolves when the stream completes
-     */
-    streamRequest(stream: Stream, request: oRequest, onChunk: (chunk: any, sequence: number, isLast: boolean) => void, config?: StreamTransportConfig): Promise<void>;
-    /**
-     * Transmit a request via streaming and receive chunks as an AsyncGenerator.
-     * This enables true streaming by yielding chunks as they arrive, not buffering them all first.
-     * Manages chunk queue with backpressure coordination between chunk arrival and consumption.
-     *
-     * @param stream The libp2p stream to use for communication
-     * @param request The request to send
-     * @param config Optional transport configuration
-     * @returns AsyncGenerator that yields chunks as they arrive
-     */
-    streamAsGenerator(stream: Stream, request: oRequest, config?: StreamTransportConfig): AsyncGenerator<any, void, unknown>;
-}
-//# sourceMappingURL=o-node-streaming-client.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"o-node-streaming-client.d.ts","sourceRoot":"","sources":["../../../src/streaming/o-node-streaming-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAGL,QAAQ,EAER,qBAAqB,EACtB,MAAM,eAAe,CAAC;AAGvB;;;;GAIG;AACH,qBAAa,oBAAoB;IAC/B;;;;;;;;;;OAUG;IACG,aAAa,CACjB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,EAChE,MAAM,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAAC,IAAI,CAAC;IAgEhB;;;;;;;;;OASG;IACI,iBAAiB,CACtB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,QAAQ,EACjB,MAAM,CAAC,EAAE,qBAAqB,GAC7B,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC;CA2DtC"}

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

@@ -1,130 +0,0 @@
-import { oError, oErrorCodes, ProtocolBuilder, } from '@olane/o-core';
-import { Libp2pStreamTransport } from './libp2p-stream-transport.js';
-/**
- * Client-side streaming orchestration for o-node.
- * Manages chunk queues, backpressure, timeouts, and provides both
- * callback and AsyncGenerator interfaces for streaming responses.
- */
-export class oNodeStreamingClient {
-    /**
-     * Transmit a request via streaming and receive chunks through a callback.
-     * This method handles the full streaming lifecycle including timeouts,
-     * chunk sequencing, and cleanup.
-     *
-     * @param stream The libp2p stream to use for communication
-     * @param request The request to send
-     * @param onChunk Callback invoked for each chunk received
-     * @param config Optional transport configuration
-     * @returns Promise that resolves when the stream completes
-     */
-    async streamRequest(stream, request, onChunk, config) {
-        // Create transport abstraction
-        const transport = new Libp2pStreamTransport(stream, config);
-        // Send the request using the transport
-        const data = new TextEncoder().encode(request.toString());
-        await transport.send(data);
-        // Set up to receive multiple chunks
-        return new Promise((resolve, reject) => {
-            // Set up timeout for receiving first chunk
-            const timeout = setTimeout(async () => {
-                transport.removeMessageHandler();
-                await transport.close();
-                reject(new oError(oErrorCodes.TIMEOUT, 'Timeout waiting for streaming response'));
-            }, config?.readTimeoutMs ?? 120000);
-            let timeoutCleared = false;
-            const messageHandler = async (data) => {
-                // Clear timeout on first message
-                if (!timeoutCleared) {
-                    clearTimeout(timeout);
-                    timeoutCleared = true;
-                }
-                try {
-                    const response = ProtocolBuilder.decodeMessage(data);
-                    // Try to parse as streaming chunk
-                    const chunk = ProtocolBuilder.parseStreamChunk(response);
-                    if (chunk) {
-                        // Streaming response
-                        onChunk(chunk.data, chunk.sequence, chunk.isLast);
-                        if (chunk.isLast) {
-                            transport.removeMessageHandler();
-                            await transport.close();
-                            resolve();
-                        }
-                    }
-                    else {
-                        // Non-streaming response (fallback for compatibility)
-                        onChunk(response.result, 1, true);
-                        transport.removeMessageHandler();
-                        await transport.close();
-                        resolve();
-                    }
-                }
-                catch (error) {
-                    transport.removeMessageHandler();
-                    await transport.close();
-                    reject(error);
-                }
-            };
-            transport.onMessage(messageHandler);
-        });
-    }
-    /**
-     * Transmit a request via streaming and receive chunks as an AsyncGenerator.
-     * This enables true streaming by yielding chunks as they arrive, not buffering them all first.
-     * Manages chunk queue with backpressure coordination between chunk arrival and consumption.
-     *
-     * @param stream The libp2p stream to use for communication
-     * @param request The request to send
-     * @param config Optional transport configuration
-     * @returns AsyncGenerator that yields chunks as they arrive
-     */
-    async *streamAsGenerator(stream, request, config) {
-        const chunkQueue = [];
-        let streamComplete = false;
-        let streamError = null;
-        let resolveNextChunk = null;
-        // Start streaming in the background using callback pattern
-        const transmitPromise = this.streamRequest(stream, request, (chunk, sequence, isLast) => {
-            chunkQueue.push({ chunk, sequence, isLast });
-            if (isLast) {
-                streamComplete = true;
-            }
-            // Notify that a new chunk is available
-            if (resolveNextChunk) {
-                resolveNextChunk();
-                resolveNextChunk = null;
-            }
-        }, config).catch((error) => {
-            streamError = error;
-            // Notify of error
-            if (resolveNextChunk) {
-                resolveNextChunk();
-                resolveNextChunk = null;
-            }
-        });
-        // Yield chunks as they arrive
-        while (!streamComplete && !streamError) {
-            if (chunkQueue.length > 0) {
-                const { chunk } = chunkQueue.shift();
-                yield chunk;
-            }
-            else {
-                // Wait for next chunk
-                await new Promise((resolve) => {
-                    resolveNextChunk = resolve;
-                });
-            }
-        }
-        // Yield any remaining chunks
-        while (chunkQueue.length > 0) {
-            const { chunk } = chunkQueue.shift();
-            yield chunk;
-        }
-        // Wait for transmit to complete
-        await transmitPromise;
-        // If there was an error, throw it
-        if (streamError) {
-            throw streamError;
-        }
-    }
-}

package/dist/src/utils/circuit-breaker.d.ts

@@ -1,107 +0,0 @@
-import { oObject } from '@olane/o-core';
-export declare enum CircuitState {
-    CLOSED = "CLOSED",// Normal operation, requests pass through
-    OPEN = "OPEN",// Circuit broken, requests fast-fail
-    HALF_OPEN = "HALF_OPEN"
-}
-export interface CircuitBreakerConfig {
-    failureThreshold: number;
-    openTimeoutMs: number;
-    halfOpenMaxAttempts: number;
-    enabled: boolean;
-}
-export interface CircuitStats {
-    state: CircuitState;
-    consecutiveFailures: number;
-    totalFailures: number;
-    totalSuccesses: number;
-    lastFailureTime?: number;
-    lastSuccessTime?: number;
-    openedAt?: number;
-}
-/**
- * Circuit Breaker Pattern Implementation
- *
- * Prevents cascading failures by "breaking the circuit" when a service
- * experiences persistent failures. This allows the system to fail fast
- * rather than wasting resources on retries that are likely to fail.
- *
- * States:
- * - CLOSED: Normal operation, all requests pass through
- * - OPEN: Circuit broken due to failures, requests fail immediately
- * - HALF_OPEN: Testing recovery, limited requests allowed
- *
- * Flow:
- * 1. CLOSED -> OPEN: After N consecutive failures
- * 2. OPEN -> HALF_OPEN: After timeout period
- * 3. HALF_OPEN -> CLOSED: After successful request
- * 4. HALF_OPEN -> OPEN: After failure in recovery
- *
- * @example
- * ```typescript
- * const breaker = new CircuitBreaker('registry', {
- *   failureThreshold: 3,
- *   openTimeoutMs: 30000,
- *   halfOpenMaxAttempts: 1,
- *   enabled: true,
- * });
- *
- * // Before making request
- * if (!breaker.shouldAllowRequest()) {
- *   throw new Error('Circuit breaker is open');
- * }
- *
- * try {
- *   const result = await makeRequest();
- *   breaker.recordSuccess();
- *   return result;
- * } catch (error) {
- *   breaker.recordFailure();
- *   throw error;
- * }
- * ```
- */
-export declare class CircuitBreaker extends oObject {
-    private readonly serviceName;
-    private readonly config;
-    private state;
-    private consecutiveFailures;
-    private totalFailures;
-    private totalSuccesses;
-    private lastFailureTime?;
-    private lastSuccessTime?;
-    private openedAt?;
-    private halfOpenAttempts;
-    constructor(serviceName: string, config: CircuitBreakerConfig);
-    /**
-     * Check if a request should be allowed through the circuit breaker
-     * @returns true if request should proceed, false if should fast-fail
-     */
-    shouldAllowRequest(): boolean;
-    /**
-     * Record a successful request
-     */
-    recordSuccess(): void;
-    /**
-     * Record a failed request
-     */
-    recordFailure(): void;
-    /**
-     * Get current statistics
-     */
-    getStats(): CircuitStats;
-    /**
-     * Get current circuit state
-     */
-    getState(): CircuitState;
-    /**
-     * Force reset the circuit breaker to CLOSED state
-     * Use with caution - mainly for testing or manual recovery
-     */
-    reset(): void;
-    /**
-     * Transition to a new state
-     */
-    private transitionTo;
-}
-//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/src/utils/circuit-breaker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../../src/utils/circuit-breaker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,oBAAY,YAAY;IACtB,MAAM,WAAW,CAAE,0CAA0C;IAC7D,IAAI,SAAS,CAAE,qCAAqC;IACpD,SAAS,cAAc;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,YAAY,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,cAAe,SAAQ,OAAO;IAWvC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAXzB,OAAO,CAAC,KAAK,CAAqC;IAClD,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,eAAe,CAAC,CAAS;IACjC,OAAO,CAAC,eAAe,CAAC,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,CAAS;IAC1B,OAAO,CAAC,gBAAgB,CAAa;gBAGlB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,oBAAoB;IAW/C;;;OAGG;IACH,kBAAkB,IAAI,OAAO;IA2C7B;;OAEG;IACH,aAAa,IAAI,IAAI;IAkBrB;;OAEG;IACH,aAAa,IAAI,IAAI;IA+BrB;;OAEG;IACH,QAAQ,IAAI,YAAY;IAYxB;;OAEG;IACH,QAAQ,IAAI,YAAY;IAIxB;;;OAGG;IACH,KAAK,IAAI,IAAI;IAQb;;OAEG;IACH,OAAO,CAAC,YAAY;CAOrB"}