@olane/o-node 0.7.51 → 0.7.52

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

@@ -1,102 +0,0 @@
-/// <reference types="node" />
-import type { Connection, Stream } from '@libp2p/interface';
-import { EventEmitter } from 'events';
-import { oRequest, oResponse, Logger } from '@olane/o-core';
-import type { oRouterRequest } from '@olane/o-core';
-import type { oConnection } from '@olane/o-core';
-import type { RunResult } from '@olane/o-tool';
-import type { StreamHandlerConfig } from './stream-handler.config.js';
-/**
- * StreamHandler centralizes all stream-related functionality including:
- * - Message type detection (request vs response)
- * - Stream lifecycle management (create, reuse, close)
- * - Backpressure handling
- * - Request/response handling
- * - Stream routing for middleware nodes
- */
-export declare class StreamHandler {
-    private logger;
-    constructor(logger?: Logger);
-    /**
-     * Detects if a decoded message is a request
-     * Requests have a 'method' field and no 'result' field
-     */
-    isRequest(message: any): boolean;
-    /**
-     * Detects if a decoded message is a response
-     * Responses have a 'result' field and no 'method' field
-     */
-    isResponse(message: any): boolean;
-    /**
-     * Extracts and parses JSON from various formats including:
-     * - Already parsed objects
-     * - Plain JSON
-     * - Markdown code blocks (```json ... ``` or ``` ... ```)
-     * - Mixed content with explanatory text
-     * - JSON5 format (trailing commas, comments, unquoted keys, etc.)
-     *
-     * @param decoded - The decoded string that may contain JSON, or an already parsed object
-     * @returns Parsed JSON object
-     * @throws Error if JSON parsing fails even with JSON5 fallback
-     */
-    private extractAndParseJSON;
-    /**
-     * Builds a bidirectional cache key from caller and receiver addresses
-     * The key is symmetric: A↔B === B↔A
-     *
-     * @param callerAddress - The caller's address
-     * @param receiverAddress - The receiver's address
-     * @returns Cache key string
-     */
-    private buildCacheKey;
-    /**
-     * Sends data through a stream using length-prefixed encoding (libp2p v3 best practice)
-     * Each message is automatically prefixed with a varint indicating the message length
-     * This ensures proper message boundaries and eliminates concatenation issues
-     *
-     * @param stream - The stream to send data through
-     * @param data - The data to send
-     * @param config - Configuration for timeout and other options
-     */
-    sendLengthPrefixed(stream: Stream, data: Uint8Array, config?: StreamHandlerConfig): Promise<void>;
-    /**
-     * Handles an incoming stream on the server side using length-prefixed protocol
-     * Uses async read loops instead of event listeners (libp2p v3 best practice)
-     * Processes complete messages with proper boundaries
-     *
-     * @param stream - The incoming stream
-     * @param connection - The connection the stream belongs to
-     * @param toolExecutor - Function to execute tools for requests
-     */
-    handleIncomingStream(stream: Stream, connection: Connection, toolExecutor: (request: oRequest, stream: Stream) => Promise<RunResult>): Promise<void>;
-    /**
-     * Handles a request message by executing the tool and sending response
-     *
-     * @param message - The decoded request message
-     * @param stream - The stream to send the response on
-     * @param toolExecutor - Function to execute the tool
-     */
-    private handleRequestMessage;
-    /**
-     * Handles an outgoing stream on the client side using length-prefixed protocol
-     * Uses async read loops to process responses with proper message boundaries
-     *
-     * @param stream - The outgoing stream
-     * @param emitter - Event emitter for chunk events
-     * @param config - Configuration including abort signal
-     * @param requestHandler - Optional handler for processing router requests received on this stream
-     * @param requestId - Optional request ID to filter responses (for stream reuse scenarios)
-     * @returns Promise that resolves with the final response
-     */
-    handleOutgoingStream(stream: Stream, emitter: EventEmitter, config?: StreamHandlerConfig, requestHandler?: (request: oRequest, stream: Stream) => Promise<RunResult>, requestId?: string | number): Promise<oResponse>;
-    /**
-     * Forwards a request to the next hop and relays response chunks back
-     * This implements the middleware/proxy pattern for intermediate nodes
-     *
-     * @param request - The router request to forward
-     * @param incomingStream - The stream to send responses back on
-     * @param dialFn - Function to dial the next hop connection
-     */
-    forwardRequest(request: oRouterRequest, incomingStream: Stream, dialFn: (address: string) => Promise<oConnection>): Promise<void>;
-}
-//# sourceMappingURL=stream-handler.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"stream-handler.d.ts","sourceRoot":"","sources":["../../../src/connection/stream-handler.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EACL,QAAQ,EACR,SAAS,EAIT,MAAM,EAEP,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EACV,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAKpC;;;;;;;GAOG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,CAAC,EAAE,MAAM;IAI3B;;;OAGG;IACH,SAAS,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO;IAIhC;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO;IAIjC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,mBAAmB;IAqC3B;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IA0HrB;;;;;;;;OAQG;IACG,kBAAkB,CACtB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,UAAU,EAChB,MAAM,GAAE,mBAAwB,GAC/B,OAAO,CAAC,IAAI,CAAC;IAKhB;;;;;;;;OAQG;IACG,oBAAoB,CACxB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,GACtE,OAAO,CAAC,IAAI,CAAC;IA+BhB;;;;;;OAMG;YACW,oBAAoB;IA6BlC;;;;;;;;;;OAUG;IACG,oBAAoB,CACxB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,YAAY,EACrB,MAAM,GAAE,mBAAwB,EAChC,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,CAAC,EAC1E,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAC1B,OAAO,CAAC,SAAS,CAAC;IAiErB;;;;;;;OAOG;IACG,cAAc,CAClB,OAAO,EAAE,cAAc,EACvB,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,GAChD,OAAO,CAAC,IAAI,CAAC;CAyBjB"}

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

@@ -1,357 +0,0 @@
-import { oRequest, oResponse, CoreUtils, oError, oErrorCodes, Logger, ResponseBuilder, } from '@olane/o-core';
-import { lpStream } from '@olane/o-config';
-import JSON5 from 'json5';
-/**
- * StreamHandler centralizes all stream-related functionality including:
- * - Message type detection (request vs response)
- * - Stream lifecycle management (create, reuse, close)
- * - Backpressure handling
- * - Request/response handling
- * - Stream routing for middleware nodes
- */
-export class StreamHandler {
-    constructor(logger) {
-        this.logger = logger ?? new Logger('StreamHandler');
-    }
-    /**
-     * Detects if a decoded message is a request
-     * Requests have a 'method' field and no 'result' field
-     */
-    isRequest(message) {
-        return typeof message?.method === 'string' && message.result === undefined;
-    }
-    /**
-     * Detects if a decoded message is a response
-     * Responses have a 'result' field and no 'method' field
-     */
-    isResponse(message) {
-        return message?.result !== undefined && message.method === undefined;
-    }
-    /**
-     * Extracts and parses JSON from various formats including:
-     * - Already parsed objects
-     * - Plain JSON
-     * - Markdown code blocks (```json ... ``` or ``` ... ```)
-     * - Mixed content with explanatory text
-     * - JSON5 format (trailing commas, comments, unquoted keys, etc.)
-     *
-     * @param decoded - The decoded string that may contain JSON, or an already parsed object
-     * @returns Parsed JSON object
-     * @throws Error if JSON parsing fails even with JSON5 fallback
-     */
-    extractAndParseJSON(decoded) {
-        // If already an object (not a string), return it directly
-        if (typeof decoded !== 'string') {
-            return decoded;
-        }
-        let jsonString = decoded.trim();
-        // Attempt standard JSON.parse first
-        try {
-            return JSON.parse(jsonString);
-        }
-        catch (jsonError) {
-            this.logger.debug('Standard JSON parse failed, trying JSON5', {
-                error: jsonError.message,
-                position: jsonError.message.match(/position (\d+)/)?.[1],
-                preview: jsonString,
-            });
-            // Fallback to JSON5 for more relaxed parsing
-            try {
-                return JSON5.parse(jsonString);
-            }
-            catch (json5Error) {
-                // Enhanced error with context
-                this.logger.error('JSON5 parse also failed', {
-                    originalError: jsonError.message,
-                    json5Error: json5Error.message,
-                    preview: jsonString.substring(0, 200),
-                    length: jsonString.length,
-                });
-                throw new Error(`Failed to parse JSON: ${jsonError.message}\nJSON5 also failed: ${json5Error.message}\nPreview: ${jsonString.substring(0, 200)}${jsonString.length > 200 ? '...' : ''}`);
-            }
-        }
-    }
-    /**
-     * Builds a bidirectional cache key from caller and receiver addresses
-     * The key is symmetric: A↔B === B↔A
-     *
-     * @param callerAddress - The caller's address
-     * @param receiverAddress - The receiver's address
-     * @returns Cache key string
-     */
-    buildCacheKey(callerAddress, receiverAddress) {
-        const addresses = [callerAddress.value, receiverAddress.value].sort();
-        return `${addresses[0]}↔${addresses[1]}`;
-    }
-    // /**
-    //  * Gets an existing open stream or creates a new one based on reuse policy
-    //  *
-    //  * @param connection - The libp2p connection
-    //  * @param protocol - The protocol to use for the stream
-    //  * @param config - Stream handler configuration
-    //  * @param streamAddresses - Optional addresses for address-based stream reuse
-    //  */
-    // async getOrCreateStream(
-    //   connection: Connection,
-    //   protocol: string,
-    //   config: StreamHandlerConfig = {},
-    //   streamAddresses?: {
-    //     callerAddress: oAddress;
-    //     receiverAddress: oAddress;
-    //     direction: 'inbound' | 'outbound';
-    //   },
-    // ): Promise<Stream> {
-    //   this.logger.debug(
-    //     `Getting or creating stream for protocol: ${protocol}, connection`,
-    //     {
-    //       status: connection.status,
-    //       remoteAddr: connection.remoteAddr.toString(),
-    //       streamCount: connection.streams.length,
-    //       reusePolicy: config.reusePolicy ?? 'none',
-    //       hasAddresses: !!streamAddresses,
-    //     },
-    //   );
-    //   if (connection.status !== 'open') {
-    //     throw new oError(oErrorCodes.INVALID_STATE, 'Connection not open');
-    //   }
-    //   const reusePolicy = config.reusePolicy ?? 'none';
-    //   // Check address-based cache if reuse is enabled and addresses provided
-    //   if (reusePolicy === 'reuse' && streamAddresses) {
-    //     const cacheKey = this.buildCacheKey(
-    //       streamAddresses.callerAddress,
-    //       streamAddresses.receiverAddress,
-    //     );
-    //     const cachedStream = this.streamCache.get(cacheKey);
-    //     if (cachedStream?.isReusable) {
-    //       this.logger.debug('Reusing cached stream by address', {
-    //         cacheKey,
-    //         streamId: cachedStream.stream.id,
-    //         direction: cachedStream.direction,
-    //       });
-    //       cachedStream.updateLastUsed();
-    //       return cachedStream.stream;
-    //     } else if (cachedStream) {
-    //       // Stream exists but not reusable, remove from cache
-    //       this.logger.debug('Removing non-reusable stream from cache', {
-    //         cacheKey,
-    //         status: cachedStream.stream.status,
-    //       });
-    //       this.streamCache.delete(cacheKey);
-    //     }
-    //   }
-    //   this.logger.debug(
-    //     'No reusable cached stream found, checking connection streams',
-    //     connection.streams.map((s) => ({
-    //       status: s.status,
-    //       protocol: s.protocol,
-    //       writeStatus: s.writeStatus,
-    //       remoteReadStatus: s.remoteReadStatus,
-    //       id: s.id,
-    //     })),
-    //   );
-    //   // Fallback to protocol-based check (legacy behavior)
-    //   if (reusePolicy === 'reuse' && !streamAddresses) {
-    //     const existingStream = connection.streams.find(
-    //       (stream) =>
-    //         stream.status === 'open' &&
-    //         stream.protocol === protocol &&
-    //         stream.writeStatus === 'writable' &&
-    //         stream.remoteReadStatus === 'readable',
-    //     );
-    //     if (existingStream) {
-    //       this.logger.debug(
-    //         'Reusing existing stream by protocol (legacy)',
-    //         existingStream.id,
-    //         existingStream.direction,
-    //       );
-    //       return existingStream;
-    //     }
-    //   }
-    //   // Create new stream
-    //   this.logger.debug('Creating new stream', { protocol });
-    //   const stream = await connection.newStream(protocol, {
-    //     signal: config.signal,
-    //     maxOutboundStreams: config.maxOutboundStreams ?? 1000,
-    //     runOnLimitedConnection: config.runOnLimitedConnection ?? false,
-    //   });
-    //   // Cache the stream if reuse is enabled and addresses are provided
-    //   if (reusePolicy === 'reuse' && streamAddresses) {
-    //     const managedStream = new oNodeConnectionStream(
-    //       stream,
-    //       streamAddresses.callerAddress,
-    //       streamAddresses.receiverAddress,
-    //       streamAddresses.direction,
-    //     );
-    //     this.cacheStream(managedStream);
-    //     this.setupStreamCleanup(stream);
-    //   }
-    //   return stream;
-    // }
-    /**
-     * Sends data through a stream using length-prefixed encoding (libp2p v3 best practice)
-     * Each message is automatically prefixed with a varint indicating the message length
-     * This ensures proper message boundaries and eliminates concatenation issues
-     *
-     * @param stream - The stream to send data through
-     * @param data - The data to send
-     * @param config - Configuration for timeout and other options
-     */
-    async sendLengthPrefixed(stream, data, config = {}) {
-        const lp = lpStream(stream);
-        await lp.write(data, { signal: config.signal });
-    }
-    /**
-     * Handles an incoming stream on the server side using length-prefixed protocol
-     * Uses async read loops instead of event listeners (libp2p v3 best practice)
-     * Processes complete messages with proper boundaries
-     *
-     * @param stream - The incoming stream
-     * @param connection - The connection the stream belongs to
-     * @param toolExecutor - Function to execute tools for requests
-     */
-    async handleIncomingStream(stream, connection, toolExecutor) {
-        const lp = lpStream(stream);
-        try {
-            while (stream.status === 'open') {
-                // Read complete length-prefixed message
-                const messageBytes = await lp.read();
-                const decoded = new TextDecoder().decode(messageBytes.subarray());
-                // Parse JSON (handles markdown blocks, mixed content, and JSON5)
-                const message = this.extractAndParseJSON(decoded);
-                if (this.isRequest(message)) {
-                    await this.handleRequestMessage(message, stream, toolExecutor);
-                }
-                else if (this.isResponse(message)) {
-                    this.logger.warn('Received response message on server-side stream, ignoring', message);
-                }
-                else {
-                    this.logger.warn('Received unknown message type', message);
-                }
-            }
-        }
-        catch (error) {
-            // Stream closed or error occurred
-            if (stream.status === 'open') {
-                this.logger.error('Error in length-prefixed stream handler:', error);
-            }
-        }
-    }
-    /**
-     * Handles a request message by executing the tool and sending response
-     *
-     * @param message - The decoded request message
-     * @param stream - The stream to send the response on
-     * @param toolExecutor - Function to execute the tool
-     */
-    async handleRequestMessage(message, stream, toolExecutor) {
-        const request = new oRequest(message);
-        const responseBuilder = ResponseBuilder.create();
-        try {
-            // this.logger.debug(
-            //   `Processing request on stream: method=${request.method}, id=${request.id}`,
-            // );
-            const result = await toolExecutor(request, stream);
-            const response = await responseBuilder.build(request, result, null);
-            await CoreUtils.sendResponse(response, stream);
-            this.logger.debug(`Successfully processed request: method=${request.method}, id=${request.id}`);
-        }
-        catch (error) {
-            this.logger.error(`Error processing request: method=${request.method}, id=${request.id}`, error);
-            const errorResponse = await responseBuilder.buildError(request, error);
-            await CoreUtils.sendResponse(errorResponse, stream);
-        }
-    }
-    /**
-     * Handles an outgoing stream on the client side using length-prefixed protocol
-     * Uses async read loops to process responses with proper message boundaries
-     *
-     * @param stream - The outgoing stream
-     * @param emitter - Event emitter for chunk events
-     * @param config - Configuration including abort signal
-     * @param requestHandler - Optional handler for processing router requests received on this stream
-     * @param requestId - Optional request ID to filter responses (for stream reuse scenarios)
-     * @returns Promise that resolves with the final response
-     */
-    async handleOutgoingStream(stream, emitter, config = {}, requestHandler, requestId) {
-        const lp = lpStream(stream);
-        try {
-            while (stream.status === 'open') {
-                this.logger.debug('Waiting for response...');
-                // Read complete length-prefixed message
-                const messageBytes = await lp.read({ signal: config.signal });
-                const decoded = new TextDecoder().decode(messageBytes.subarray());
-                // Parse JSON (handles markdown blocks, mixed content, and JSON5)
-                const message = this.extractAndParseJSON(decoded);
-                if (this.isResponse(message)) {
-                    const response = new oResponse({
-                        ...message.result,
-                        id: message.id,
-                    });
-                    // Filter by request ID if provided
-                    if (requestId !== undefined && response.id !== requestId) {
-                        this.logger.debug(`Ignoring response for different request (expected: ${requestId}, received: ${response.id})`);
-                        continue;
-                    }
-                    // Emit chunk for streaming responses
-                    emitter.emit('chunk', response);
-                    // Check if this is the last chunk
-                    if (response.result._last || !response.result._isStreaming) {
-                        return response;
-                    }
-                }
-                else if (this.isRequest(message)) {
-                    // Process incoming router requests if handler is provided
-                    if (requestHandler) {
-                        this.logger.debug('Received router request on client-side stream, processing...', message);
-                        await this.handleRequestMessage(message, stream, requestHandler);
-                    }
-                    else {
-                        this.logger.warn('Received request message on client-side stream, ignoring (no handler)', message);
-                    }
-                }
-                else {
-                    this.logger.warn('Received unknown message type', message);
-                }
-            }
-            throw new oError(oErrorCodes.TIMEOUT, 'Stream closed before response received');
-        }
-        catch (error) {
-            if (config.signal?.aborted) {
-                throw new oError(oErrorCodes.TIMEOUT, 'Request aborted');
-            }
-            throw error;
-        }
-    }
-    /**
-     * Forwards a request to the next hop and relays response chunks back
-     * This implements the middleware/proxy pattern for intermediate nodes
-     *
-     * @param request - The router request to forward
-     * @param incomingStream - The stream to send responses back on
-     * @param dialFn - Function to dial the next hop connection
-     */
-    async forwardRequest(request, incomingStream, dialFn) {
-        try {
-            // Connect to next hop
-            const nextHopConnection = await dialFn(request.params.address);
-            // Set up chunk relay - forward responses from next hop back to incoming stream
-            nextHopConnection.onChunk(async (response) => {
-                try {
-                    await CoreUtils.sendResponse(response, incomingStream);
-                }
-                catch (error) {
-                    this.logger.error('Error forwarding chunk:', error);
-                }
-            });
-            // Transmit the request to next hop
-            await nextHopConnection.transmit(request);
-        }
-        catch (error) {
-            this.logger.error('Error forwarding request:', error);
-            // Send error response back on incoming stream using ResponseBuilder
-            const responseBuilder = ResponseBuilder.create();
-            const errorResponse = await responseBuilder.buildError(request, error);
-            await CoreUtils.sendResponse(errorResponse, incomingStream);
-        }
-    }
-}

package/dist/src/connection/stream-pool-manager.d.ts

@@ -1,86 +0,0 @@
-import { oObject } from '@olane/o-core';
-import { oNodeConnectionStream } from './o-node-connection-stream.js';
-import { StreamPoolEvent, StreamPoolEventData } from './stream-pool-manager.events.js';
-import type { StreamPoolManagerConfig, StreamPoolStats } from './interfaces/stream-pool-manager.config.js';
-/**
- * StreamPoolManager manages a pool of reusable streams with automatic recovery.
- *
- * Architecture:
- * - Stream[0]: Dedicated reader for incoming requests (background loop)
- * - Streams[1-N]: Round-robin pool for outgoing request-response cycles
- *
- * Features:
- * - Automatic stream pool initialization
- * - Dedicated reader with automatic restart on failure
- * - Event-based stream monitoring (listens to 'close' events)
- * - Automatic stream replacement when failures detected
- * - Event emission for monitoring and observability
- */
-export declare class StreamPoolManager extends oObject {
-    private streams;
-    private readonly POOL_SIZE;
-    private readonly READER_STREAM_INDEX;
-    private dedicatedReaderStream?;
-    private currentStreamIndex;
-    private failureCount;
-    private eventEmitter;
-    private streamEventHandlers;
-    private config;
-    private isInitialized;
-    private isClosing;
-    constructor(config: StreamPoolManagerConfig);
-    get backgroundReaderActive(): boolean;
-    /**
-     * Initialize the stream pool and start the dedicated reader
-     */
-    initialize(): Promise<void>;
-    /**
-     * Get a stream for outgoing request-response cycles using round-robin selection
-     */
-    getStream(): Promise<oNodeConnectionStream>;
-    /**
-     * Get statistics about the stream pool
-     */
-    getStats(): StreamPoolStats;
-    /**
-     * Close the stream pool and cleanup resources
-     */
-    close(): Promise<void>;
-    /**
-     * Add event listener
-     */
-    on<K extends StreamPoolEvent>(event: K | string, listener: (data: StreamPoolEventData[K]) => void): void;
-    /**
-     * Remove event listener
-     */
-    off<K extends StreamPoolEvent>(event: K | string, listener: (data: StreamPoolEventData[K]) => void): void;
-    /**
-     * Emit event
-     */
-    private emit;
-    /**
-     * Initialize the background reader on the dedicated stream
-     */
-    private initializeBackgroundReader;
-    /**
-     * Handle dedicated reader failure with automatic recovery
-     */
-    private handleReaderFailure;
-    /**
-     * Replace a stream at the given index
-     */
-    private replaceStream;
-    /**
-     * Attach event listeners to a stream for monitoring
-     */
-    private attachStreamListeners;
-    /**
-     * Remove event listeners from a stream
-     */
-    private removeStreamListeners;
-    /**
-     * Handle stream close event - triggers immediate replacement
-     */
-    private handleStreamClose;
-}
-//# sourceMappingURL=stream-pool-manager.d.ts.map

package/dist/src/connection/stream-pool-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-pool-manager.d.ts","sourceRoot":"","sources":["../../../src/connection/stream-pool-manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAiC,MAAM,eAAe,CAAC;AAEvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EACL,eAAe,EACf,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EACV,uBAAuB,EACvB,eAAe,EAChB,MAAM,4CAA4C,CAAC;AAEpD;;;;;;;;;;;;;GAaG;AACH,qBAAa,iBAAkB,SAAQ,OAAO;IAC5C,OAAO,CAAC,OAAO,CAA+B;IAC9C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAE7C,OAAO,CAAC,qBAAqB,CAAC,CAAwB;IACtD,OAAO,CAAC,kBAAkB,CAAa;IAEvC,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,YAAY,CAAoC;IACxD,OAAO,CAAC,mBAAmB,CAAgD;IAE3E,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,SAAS,CAAkB;gBAEvB,MAAM,EAAE,uBAAuB;IAa3C,IAAI,sBAAsB,YAEzB;IAED;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAoDjC;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAqCjD;;OAEG;IACH,QAAQ,IAAI,eAAe;IAuB3B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA4B5B;;OAEG;IACH,EAAE,CAAC,CAAC,SAAS,eAAe,EAC1B,KAAK,EAAE,CAAC,GAAG,MAAM,EACjB,QAAQ,EAAE,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/C,IAAI;IAIP;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,eAAe,EAC3B,KAAK,EAAE,CAAC,GAAG,MAAM,EACjB,QAAQ,EAAE,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC,CAAC,KAAK,IAAI,GAC/C,IAAI;IAIP;;OAEG;IACH,OAAO,CAAC,IAAI;IAOZ;;OAEG;YACW,0BAA0B;IA0ExC;;OAEG;YACW,mBAAmB;IA6BjC;;OAEG;YACW,aAAa;IA0C3B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAuB7B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAW7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;CA2C1B"}

package/dist/src/connection/stream-pool-manager.events.d.ts

@@ -1,57 +0,0 @@
-/**
- * Events emitted by StreamPoolManager
- */
-export declare enum StreamPoolEvent {
-    PoolInitialized = "pool-initialized",
-    PoolClosed = "pool-closed",
-    ReaderStarted = "reader-started",
-    ReaderFailed = "reader-failed",
-    ReaderRecovered = "reader-recovered",
-    RecoveryFailed = "recovery-failed",
-    StreamReplaced = "stream-replaced",
-    StreamFailed = "stream-failed"
-}
-/**
- * Event data interfaces
- */
-export interface PoolInitializedData {
-    poolSize: number;
-}
-export interface ReaderStartedData {
-    streamId: string;
-}
-export interface ReaderFailedData {
-    error?: string;
-    failureCount: number;
-}
-export interface ReaderRecoveredData {
-    failureCount: number;
-}
-export interface RecoveryFailedData {
-    error: string;
-    failureCount: number;
-}
-export interface StreamReplacedData {
-    index: number;
-    streamType: string;
-}
-export interface StreamFailedData {
-    index: number;
-    streamId: string;
-    error?: string;
-    failureCount: number;
-}
-/**
- * Mapped type for type-safe event listeners
- */
-export type StreamPoolEventData = {
-    [StreamPoolEvent.PoolInitialized]: PoolInitializedData;
-    [StreamPoolEvent.PoolClosed]: void;
-    [StreamPoolEvent.ReaderStarted]: ReaderStartedData;
-    [StreamPoolEvent.ReaderFailed]: ReaderFailedData;
-    [StreamPoolEvent.ReaderRecovered]: ReaderRecoveredData;
-    [StreamPoolEvent.RecoveryFailed]: RecoveryFailedData;
-    [StreamPoolEvent.StreamReplaced]: StreamReplacedData;
-    [StreamPoolEvent.StreamFailed]: StreamFailedData;
-};
-//# sourceMappingURL=stream-pool-manager.events.d.ts.map

package/dist/src/connection/stream-pool-manager.events.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream-pool-manager.events.d.ts","sourceRoot":"","sources":["../../../src/connection/stream-pool-manager.events.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,eAAe;IACzB,eAAe,qBAAqB;IACpC,UAAU,gBAAgB;IAC1B,aAAa,mBAAmB;IAChC,YAAY,kBAAkB;IAC9B,eAAe,qBAAqB;IACpC,cAAc,oBAAoB;IAClC,cAAc,oBAAoB;IAClC,YAAY,kBAAkB;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,CAAC,eAAe,CAAC,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACvD,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC;IACnC,CAAC,eAAe,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IACnD,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,gBAAgB,CAAC;IACjD,CAAC,eAAe,CAAC,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACvD,CAAC,eAAe,CAAC,cAAc,CAAC,EAAE,kBAAkB,CAAC;IACrD,CAAC,eAAe,CAAC,cAAc,CAAC,EAAE,kBAAkB,CAAC;IACrD,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,gBAAgB,CAAC;CAClD,CAAC"}

package/dist/src/connection/stream-pool-manager.events.js

@@ -1,14 +0,0 @@
-/**
- * Events emitted by StreamPoolManager
- */
-export var StreamPoolEvent;
-(function (StreamPoolEvent) {
-    StreamPoolEvent["PoolInitialized"] = "pool-initialized";
-    StreamPoolEvent["PoolClosed"] = "pool-closed";
-    StreamPoolEvent["ReaderStarted"] = "reader-started";
-    StreamPoolEvent["ReaderFailed"] = "reader-failed";
-    StreamPoolEvent["ReaderRecovered"] = "reader-recovered";
-    StreamPoolEvent["RecoveryFailed"] = "recovery-failed";
-    StreamPoolEvent["StreamReplaced"] = "stream-replaced";
-    StreamPoolEvent["StreamFailed"] = "stream-failed";
-})(StreamPoolEvent || (StreamPoolEvent = {}));