agentic-qe 1.3.3 → 1.3.5

package/dist/transport/UDPTransport.js

@@ -1,820 +0,0 @@
-"use strict";
-/**
- * UDPTransport - Lightweight UDP transport layer for distributed QE fleet coordination
- *
- * Provides fast local coordination through:
- * - UDP sockets for reduced connection overhead (~67% faster than TCP handshake)
- * - Channel-based message routing for pub/sub patterns
- * - Automatic TCP fallback for cross-network reliability
- * - Production-ready error handling and reconnection
- *
- * Note: This is UDP transport, NOT QUIC protocol (RFC 9000).
- * For real QUIC with congestion control and stream multiplexing, see v2.0 roadmap.
- *
- * @module transport/UDPTransport
- * @version 1.1.0
- * @since 2025-10-20
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UDPTransport = exports.ConnectionState = exports.TransportMode = void 0;
-exports.createUDPTransport = createUDPTransport;
-const events_1 = require("events");
-const dgram = __importStar(require("dgram"));
-const tls = __importStar(require("tls"));
-const fs = __importStar(require("fs/promises"));
-const crypto = __importStar(require("crypto"));
-/**
- * Transport mode - UDP or TCP fallback
- */
-var TransportMode;
-(function (TransportMode) {
-    TransportMode["UDP"] = "UDP";
-    TransportMode["TCP"] = "TCP";
-    TransportMode["UNKNOWN"] = "UNKNOWN";
-})(TransportMode || (exports.TransportMode = TransportMode = {}));
-/**
- * Connection state
- */
-var ConnectionState;
-(function (ConnectionState) {
-    ConnectionState["DISCONNECTED"] = "DISCONNECTED";
-    ConnectionState["CONNECTING"] = "CONNECTING";
-    ConnectionState["CONNECTED"] = "CONNECTED";
-    ConnectionState["RECONNECTING"] = "RECONNECTING";
-    ConnectionState["FAILED"] = "FAILED";
-})(ConnectionState || (exports.ConnectionState = ConnectionState = {}));
-/**
- * UDPTransport - Production-ready UDP/TCP transport layer
- *
- * Features:
- * - UDP sockets for fast local coordination
- * - Automatic TCP fallback for reliability
- * - Channel-based message routing
- * - Connection pooling and multiplexing
- * - Comprehensive error handling
- * - Performance monitoring
- *
- * Performance Characteristics:
- * - Connection time: ~5ms UDP vs ~15ms TCP (67% faster)
- * - Message latency: ~1-2ms UDP vs ~3-5ms TCP (40-60% faster)
- * - Best for: Local fleet coordination, development environments
- * - TCP fallback: Automatic for cross-network communication
- *
- * @example
- * ```typescript
- * const transport = new UDPTransport();
- * await transport.initialize({
- *   host: 'localhost',
- *   port: 4433,
- *   enableFastReconnect: true
- * });
- *
- * await transport.receive('coordination', (data) => {
- *   console.log('Received:', data);
- * });
- *
- * await transport.send('coordination', { action: 'sync', agentId: 'qe-01' });
- * ```
- */
-class UDPTransport extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.mode = TransportMode.UNKNOWN;
-        this.state = ConnectionState.DISCONNECTED;
-        // UDP socket
-        this.udpSocket = null;
-        // TCP fallback socket
-        this.tcpSocket = null;
-        // TLS credentials
-        this.tlsCert = null;
-        this.tlsKey = null;
-        // Channel subscriptions
-        this.channelCallbacks = new Map();
-        // Active channels
-        this.channels = new Map();
-        // Performance metrics
-        this.metrics = {
-            mode: TransportMode.UNKNOWN,
-            state: ConnectionState.DISCONNECTED,
-            messagesSent: 0,
-            messagesReceived: 0,
-            bytesTransferred: 0,
-            averageLatency: 0,
-            connectionUptime: 0,
-            activeChannels: 0,
-            failedAttempts: 0
-        };
-        // Latency tracking
-        this.latencySamples = [];
-        this.connectionStartTime = 0;
-        // Keep-alive timer
-        this.keepAliveTimer = null;
-        // Retry state
-        this.retryCount = 0;
-        this.isReconnecting = false;
-        this.config = this.getDefaultConfig();
-    }
-    /**
-     * Get default configuration with sensible defaults
-     * @private
-     */
-    getDefaultConfig() {
-        return {
-            host: 'localhost',
-            port: 4433,
-            certPath: '',
-            keyPath: '',
-            enableFastReconnect: true,
-            enableTCPFallback: true,
-            connectionTimeout: 5000,
-            maxRetries: 3,
-            retryDelay: 1000,
-            keepAlive: true,
-            keepAliveInterval: 30000,
-            maxConcurrentChannels: 100,
-            debug: false
-        };
-    }
-    /**
-     * Initialize UDP transport with configuration
-     *
-     * Attempts UDP connection first, falls back to TCP if:
-     * - UDP not supported by network
-     * - Connection fails after retries
-     * - UDP blocked by firewall
-     *
-     * @param config - Transport configuration options
-     * @throws {Error} If both UDP and TCP connections fail
-     *
-     * @example
-     * ```typescript
-     * await transport.initialize({
-     *   host: 'localhost',
-     *   port: 4433,
-     *   certPath: '/path/to/cert.pem',
-     *   keyPath: '/path/to/key.pem',
-     *   enableFastReconnect: true
-     * });
-     * ```
-     */
-    async initialize(config) {
-        this.config = { ...this.getDefaultConfig(), ...config };
-        this.state = ConnectionState.CONNECTING;
-        this.emit('stateChange', this.state);
-        this.log('Initializing UDP transport', { config: this.config });
-        try {
-            // Load or generate TLS credentials
-            await this.loadTLSCredentials();
-            // Try UDP first
-            try {
-                await this.connectUDP();
-                this.mode = TransportMode.UDP;
-                this.state = ConnectionState.CONNECTED;
-                this.connectionStartTime = Date.now();
-                this.log('UDP connection established successfully');
-                this.emit('connected', { mode: TransportMode.UDP });
-                // Start keep-alive if enabled
-                if (this.config.keepAlive) {
-                    this.startKeepAlive();
-                }
-                return;
-            }
-            catch (udpError) {
-                this.log('UDP connection failed', { error: udpError });
-                this.metrics.failedAttempts++;
-                // Try TCP fallback if enabled
-                if (this.config.enableTCPFallback) {
-                    this.log('Attempting TCP fallback');
-                    await this.connectTCP();
-                    this.mode = TransportMode.TCP;
-                    this.state = ConnectionState.CONNECTED;
-                    this.connectionStartTime = Date.now();
-                    this.log('TCP fallback connection established');
-                    this.emit('connected', { mode: TransportMode.TCP });
-                    if (this.config.keepAlive) {
-                        this.startKeepAlive();
-                    }
-                    return;
-                }
-                throw udpError;
-            }
-        }
-        catch (error) {
-            this.state = ConnectionState.FAILED;
-            this.metrics.lastError = error instanceof Error ? error.message : String(error);
-            this.emit('stateChange', this.state);
-            throw new Error(`Transport initialization failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Load TLS credentials from files or generate self-signed
-     * @private
-     */
-    async loadTLSCredentials() {
-        try {
-            if (this.config.certPath && this.config.keyPath) {
-                // Load from files
-                this.tlsCert = await fs.readFile(this.config.certPath);
-                this.tlsKey = await fs.readFile(this.config.keyPath);
-                this.log('Loaded TLS credentials from files');
-            }
-            else {
-                // Generate self-signed certificate for development
-                const { cert, key } = await this.generateSelfSignedCert();
-                this.tlsCert = Buffer.from(cert);
-                this.tlsKey = Buffer.from(key);
-                this.log('Generated self-signed TLS certificate');
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to load TLS credentials: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Generate self-signed certificate for development
-     * @private
-     */
-    async generateSelfSignedCert() {
-        // Note: In production, use proper certificate authority
-        // This is a simplified implementation for development
-        const { generateKeyPairSync } = crypto;
-        const { publicKey, privateKey } = generateKeyPairSync('rsa', {
-            modulusLength: 2048,
-            publicKeyEncoding: { type: 'spki', format: 'pem' },
-            privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
-        });
-        // Create a basic self-signed certificate
-        // In production, use proper X.509 certificate generation
-        const cert = publicKey;
-        const key = privateKey;
-        return { cert, key };
-    }
-    /**
-     * Establish UDP connection
-     * @private
-     */
-    async connectUDP() {
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error('UDP connection timeout'));
-            }, this.config.connectionTimeout);
-            try {
-                // Create UDP socket
-                this.udpSocket = dgram.createSocket('udp4');
-                // Handle socket errors
-                this.udpSocket.on('error', (error) => {
-                    clearTimeout(timeout);
-                    this.log('UDP socket error', { error });
-                    reject(error);
-                });
-                // Handle incoming messages
-                this.udpSocket.on('message', (msg, rinfo) => {
-                    this.handleUDPMessage(msg, rinfo);
-                });
-                // Bind socket
-                this.udpSocket.bind(() => {
-                    this.log('UDP socket bound', {
-                        address: this.udpSocket.address()
-                    });
-                    // Send connection handshake
-                    this.sendUDPHandshake()
-                        .then(() => {
-                        clearTimeout(timeout);
-                        resolve();
-                    })
-                        .catch((error) => {
-                        clearTimeout(timeout);
-                        reject(error);
-                    });
-                });
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Send UDP handshake packet
-     * @private
-     */
-    async sendUDPHandshake() {
-        if (!this.udpSocket) {
-            throw new Error('UDP socket not initialized');
-        }
-        const handshake = {
-            type: 'HANDSHAKE',
-            version: '1.1',
-            protocol: 'UDP',
-            timestamp: Date.now()
-        };
-        const packet = Buffer.from(JSON.stringify(handshake));
-        return new Promise((resolve, reject) => {
-            this.udpSocket.send(packet, 0, packet.length, this.config.port, this.config.host, (error) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    this.log('UDP handshake sent');
-                    resolve();
-                }
-            });
-        });
-    }
-    /**
-     * Handle incoming UDP message
-     * @private
-     */
-    handleUDPMessage(msg, rinfo) {
-        try {
-            const envelope = JSON.parse(msg.toString());
-            // Update metrics
-            this.metrics.messagesReceived++;
-            this.metrics.bytesTransferred += msg.length;
-            // Calculate latency
-            const latency = Date.now() - envelope.timestamp;
-            this.latencySamples.push(latency);
-            if (this.latencySamples.length > 100) {
-                this.latencySamples.shift();
-            }
-            this.metrics.averageLatency =
-                this.latencySamples.reduce((a, b) => a + b, 0) / this.latencySamples.length;
-            // Route to channel callbacks
-            this.routeMessage(envelope);
-            this.log('UDP message received', {
-                channel: envelope.channel,
-                latency: `${latency}ms`,
-                from: rinfo
-            });
-        }
-        catch (error) {
-            this.log('Error handling UDP message', { error });
-            this.emit('error', error);
-        }
-    }
-    /**
-     * Establish TCP fallback connection
-     * @private
-     */
-    async connectTCP() {
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error('TCP connection timeout'));
-            }, this.config.connectionTimeout);
-            try {
-                // Create TCP socket with TLS
-                this.tcpSocket = tls.connect({
-                    host: this.config.host,
-                    port: this.config.port,
-                    cert: this.tlsCert,
-                    key: this.tlsKey,
-                    rejectUnauthorized: false // For self-signed certs in development
-                });
-                // Handle connection events
-                this.tcpSocket.on('secureConnect', () => {
-                    clearTimeout(timeout);
-                    this.log('TCP connection established');
-                    resolve();
-                });
-                this.tcpSocket.on('error', (error) => {
-                    clearTimeout(timeout);
-                    this.log('TCP socket error', { error });
-                    reject(error);
-                });
-                this.tcpSocket.on('data', (data) => {
-                    this.handleTCPMessage(data);
-                });
-                this.tcpSocket.on('close', () => {
-                    this.log('TCP connection closed');
-                    this.handleDisconnect();
-                });
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Handle incoming TCP message
-     * @private
-     */
-    handleTCPMessage(data) {
-        try {
-            const envelope = JSON.parse(data.toString());
-            // Update metrics
-            this.metrics.messagesReceived++;
-            this.metrics.bytesTransferred += data.length;
-            // Calculate latency
-            const latency = Date.now() - envelope.timestamp;
-            this.latencySamples.push(latency);
-            if (this.latencySamples.length > 100) {
-                this.latencySamples.shift();
-            }
-            this.metrics.averageLatency =
-                this.latencySamples.reduce((a, b) => a + b, 0) / this.latencySamples.length;
-            // Route to channel callbacks
-            this.routeMessage(envelope);
-            this.log('TCP message received', {
-                channel: envelope.channel,
-                latency: `${latency}ms`
-            });
-        }
-        catch (error) {
-            this.log('Error handling TCP message', { error });
-            this.emit('error', error);
-        }
-    }
-    /**
-     * Route message to channel callbacks
-     * @private
-     */
-    routeMessage(envelope) {
-        const callbacks = this.channelCallbacks.get(envelope.channel);
-        if (callbacks && callbacks.size > 0) {
-            callbacks.forEach((callback) => {
-                try {
-                    callback(envelope.data);
-                }
-                catch (error) {
-                    this.log('Error in channel callback', { channel: envelope.channel, error });
-                    this.emit('error', error);
-                }
-            });
-        }
-    }
-    /**
-     * Send message on specified channel
-     *
-     * Automatically routes message through active transport (UDP or TCP).
-     * Includes retry logic and error handling.
-     *
-     * @param channel - Channel name for routing
-     * @param data - Message data (any JSON-serializable object)
-     * @throws {Error} If transport not connected or send fails
-     *
-     * @example
-     * ```typescript
-     * await transport.send('coordination', {
-     *   action: 'sync',
-     *   agentId: 'qe-01',
-     *   timestamp: Date.now()
-     * });
-     * ```
-     */
-    async send(channel, data) {
-        if (this.state !== ConnectionState.CONNECTED) {
-            throw new Error(`Cannot send: transport not connected (state: ${this.state})`);
-        }
-        const envelope = {
-            channel,
-            data,
-            timestamp: Date.now(),
-            messageId: this.generateMessageId()
-        };
-        const message = Buffer.from(JSON.stringify(envelope));
-        try {
-            if (this.mode === TransportMode.UDP && this.udpSocket) {
-                await this.sendUDPMessage(message);
-            }
-            else if (this.mode === TransportMode.TCP && this.tcpSocket) {
-                await this.sendTCPMessage(message);
-            }
-            else {
-                throw new Error('No active transport connection');
-            }
-            // Update metrics
-            this.metrics.messagesSent++;
-            this.metrics.bytesTransferred += message.length;
-            this.log('Message sent', { channel, mode: this.mode });
-        }
-        catch (error) {
-            this.log('Error sending message', { channel, error });
-            // Attempt retry with exponential backoff
-            if (this.retryCount < this.config.maxRetries) {
-                this.retryCount++;
-                const delay = this.config.retryDelay * Math.pow(2, this.retryCount - 1);
-                this.log('Retrying send', { attempt: this.retryCount, delay });
-                await new Promise(resolve => setTimeout(resolve, delay));
-                return this.send(channel, data);
-            }
-            throw new Error(`Failed to send message after ${this.config.maxRetries} retries: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Send message via UDP
-     * @private
-     */
-    async sendUDPMessage(message) {
-        if (!this.udpSocket) {
-            throw new Error('UDP socket not available');
-        }
-        return new Promise((resolve, reject) => {
-            this.udpSocket.send(message, 0, message.length, this.config.port, this.config.host, (error) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    /**
-     * Send message via TCP
-     * @private
-     */
-    async sendTCPMessage(message) {
-        if (!this.tcpSocket || this.tcpSocket.destroyed) {
-            throw new Error('TCP socket not available');
-        }
-        return new Promise((resolve, reject) => {
-            this.tcpSocket.write(message, (error) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    /**
-     * Register callback for channel messages
-     *
-     * Supports multiple callbacks per channel for pub/sub pattern.
-     *
-     * @param channel - Channel name to subscribe to
-     * @param callback - Function to call when message received
-     *
-     * @example
-     * ```typescript
-     * await transport.receive('coordination', (data) => {
-     *   console.log('Coordination event:', data);
-     * });
-     *
-     * await transport.receive('metrics', (data) => {
-     *   console.log('Performance metrics:', data);
-     * });
-     * ```
-     */
-    async receive(channel, callback) {
-        if (!this.channelCallbacks.has(channel)) {
-            this.channelCallbacks.set(channel, new Set());
-        }
-        this.channelCallbacks.get(channel).add(callback);
-        // Update channel metadata
-        const channelId = this.generateChannelId(channel);
-        if (!this.channels.has(channelId)) {
-            this.channels.set(channelId, {
-                channelId,
-                channel,
-                created: Date.now(),
-                lastActivity: Date.now(),
-                messageCount: 0
-            });
-            this.metrics.activeChannels = this.channels.size;
-        }
-        this.log('Registered channel callback', { channel, totalCallbacks: this.channelCallbacks.get(channel).size });
-    }
-    /**
-     * Unregister callback from channel
-     *
-     * @param channel - Channel name
-     * @param callback - Callback function to remove
-     */
-    unsubscribe(channel, callback) {
-        const callbacks = this.channelCallbacks.get(channel);
-        if (callbacks) {
-            callbacks.delete(callback);
-            if (callbacks.size === 0) {
-                this.channelCallbacks.delete(channel);
-                // Clean up channel metadata
-                const channelId = this.generateChannelId(channel);
-                this.channels.delete(channelId);
-                this.metrics.activeChannels = this.channels.size;
-            }
-            this.log('Unregistered channel callback', { channel });
-        }
-    }
-    /**
-     * Close transport connection gracefully
-     *
-     * Cleanup includes:
-     * - Closing active sockets
-     * - Clearing subscriptions
-     * - Stopping keep-alive timer
-     * - Emitting disconnect event
-     *
-     * @example
-     * ```typescript
-     * await transport.close();
-     * console.log('Transport closed successfully');
-     * ```
-     */
-    async close() {
-        this.log('Closing transport connection');
-        try {
-            // Stop keep-alive
-            if (this.keepAliveTimer) {
-                clearInterval(this.keepAliveTimer);
-                this.keepAliveTimer = null;
-            }
-            // Close UDP socket
-            if (this.udpSocket) {
-                this.udpSocket.close();
-                this.udpSocket = null;
-            }
-            // Close TCP socket
-            if (this.tcpSocket) {
-                this.tcpSocket.destroy();
-                this.tcpSocket = null;
-            }
-            // Clear subscriptions
-            this.channelCallbacks.clear();
-            this.channels.clear();
-            // Update state
-            this.state = ConnectionState.DISCONNECTED;
-            this.mode = TransportMode.UNKNOWN;
-            this.metrics.activeChannels = 0;
-            this.emit('disconnected');
-            this.log('Transport closed successfully');
-        }
-        catch (error) {
-            this.log('Error closing transport', { error });
-            throw error;
-        }
-    }
-    /**
-     * Check if transport is connected
-     *
-     * @returns true if connected via UDP or TCP, false otherwise
-     */
-    isConnected() {
-        return this.state === ConnectionState.CONNECTED;
-    }
-    /**
-     * Get current transport mode
-     *
-     * @returns Current transport mode (UDP, TCP, or UNKNOWN)
-     */
-    getMode() {
-        return this.mode;
-    }
-    /**
-     * Get connection state
-     *
-     * @returns Current connection state
-     */
-    getState() {
-        return this.state;
-    }
-    /**
-     * Get performance metrics
-     *
-     * Includes:
-     * - Messages sent/received
-     * - Average latency
-     * - Connection uptime
-     * - Active channels
-     * - Failed attempts
-     *
-     * @returns Current transport metrics
-     */
-    getMetrics() {
-        return {
-            ...this.metrics,
-            mode: this.mode,
-            state: this.state,
-            connectionUptime: this.connectionStartTime
-                ? Date.now() - this.connectionStartTime
-                : 0
-        };
-    }
-    /**
-     * Handle disconnection and attempt reconnect
-     * @private
-     */
-    async handleDisconnect() {
-        if (this.isReconnecting) {
-            return;
-        }
-        this.log('Connection lost, attempting reconnect');
-        this.state = ConnectionState.RECONNECTING;
-        this.isReconnecting = true;
-        this.emit('stateChange', this.state);
-        try {
-            await this.initialize(this.config);
-            this.isReconnecting = false;
-            this.retryCount = 0;
-            this.emit('reconnected');
-        }
-        catch (error) {
-            this.log('Reconnection failed', { error });
-            this.isReconnecting = false;
-            this.state = ConnectionState.FAILED;
-            this.emit('stateChange', this.state);
-        }
-    }
-    /**
-     * Start keep-alive timer
-     * @private
-     */
-    startKeepAlive() {
-        if (this.keepAliveTimer) {
-            clearInterval(this.keepAliveTimer);
-        }
-        this.keepAliveTimer = setInterval(async () => {
-            try {
-                await this.send('__keepalive__', { timestamp: Date.now() });
-                this.log('Keep-alive sent');
-            }
-            catch (error) {
-                this.log('Keep-alive failed', { error });
-                this.handleDisconnect();
-            }
-        }, this.config.keepAliveInterval);
-    }
-    /**
-     * Generate unique message ID
-     * @private
-     */
-    generateMessageId() {
-        return `${Date.now()}-${crypto.randomBytes(8).toString('hex')}`;
-    }
-    /**
-     * Generate channel ID from channel name
-     * @private
-     */
-    generateChannelId(channel) {
-        return crypto.createHash('sha256').update(channel).digest('hex').substring(0, 16);
-    }
-    /**
-     * Debug logging
-     * @private
-     */
-    log(message, data) {
-        if (this.config.debug) {
-            const timestamp = new Date().toISOString();
-            console.log(`[UDPTransport ${timestamp}] ${message}`, data || '');
-        }
-        this.emit('log', { message, data, timestamp: Date.now() });
-    }
-}
-exports.UDPTransport = UDPTransport;
-/**
- * Create and initialize UDP transport
- *
- * Convenience factory function for quick setup.
- *
- * @param config - Transport configuration
- * @returns Initialized UDPTransport instance
- *
- * @example
- * ```typescript
- * const transport = await createUDPTransport({
- *   host: 'localhost',
- *   port: 4433,
- *   enableFastReconnect: true
- * });
- * ```
- */
-async function createUDPTransport(config) {
-    const transport = new UDPTransport();
-    await transport.initialize(config);
-    return transport;
-}
-//# sourceMappingURL=UDPTransport.js.map