agentic-qe 1.3.3 → 1.3.5

package/dist/transport/QUICTransport.js

@@ -1,814 +0,0 @@
-"use strict";
-/**
- * QUICTransport - High-performance QUIC transport layer for distributed QE fleet coordination
- *
- * Provides 50-70% latency reduction vs TCP through:
- * - 0-RTT connection establishment
- * - Multiplexed bidirectional streams
- * - Built-in congestion control
- * - Automatic TCP fallback for compatibility
- *
- * @module transport/QUICTransport
- * @version 1.0.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.QUICTransport = exports.ConnectionState = exports.TransportMode = void 0;
-exports.createQUICTransport = createQUICTransport;
-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 - QUIC or TCP fallback
- */
-var TransportMode;
-(function (TransportMode) {
-    TransportMode["QUIC"] = "QUIC";
-    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 = {}));
-/**
- * QUICTransport - Production-ready QUIC/TCP transport layer
- *
- * Features:
- * - QUIC protocol with 0-RTT support
- * - Automatic TCP fallback
- * - Channel-based message routing
- * - Bidirectional streaming
- * - Connection pooling and multiplexing
- * - Comprehensive error handling
- * - Performance monitoring
- *
- * @example
- * ```typescript
- * const transport = new QUICTransport();
- * await transport.initialize({
- *   host: 'fleet.example.com',
- *   port: 4433,
- *   enable0RTT: true
- * });
- *
- * await transport.receive('coordination', (data) => {
- *   console.log('Received:', data);
- * });
- *
- * await transport.send('coordination', { action: 'sync', agentId: 'qe-01' });
- * ```
- */
-class QUICTransport extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.mode = TransportMode.UNKNOWN;
-        this.state = ConnectionState.DISCONNECTED;
-        // QUIC/UDP socket
-        this.quicSocket = null;
-        // TCP fallback socket
-        this.tcpSocket = null;
-        // TLS credentials
-        this.tlsCert = null;
-        this.tlsKey = null;
-        // Channel subscriptions
-        this.channelCallbacks = new Map();
-        // Active streams
-        this.streams = new Map();
-        // Performance metrics
-        this.metrics = {
-            mode: TransportMode.UNKNOWN,
-            state: ConnectionState.DISCONNECTED,
-            messagessent: 0,
-            messagesReceived: 0,
-            bytesTransferred: 0,
-            averageLatency: 0,
-            connectionUptime: 0,
-            activeStreams: 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: '',
-            enable0RTT: true,
-            enableTCPFallback: true,
-            connectionTimeout: 5000,
-            maxRetries: 3,
-            retryDelay: 1000,
-            keepAlive: true,
-            keepAliveInterval: 30000,
-            maxConcurrentStreams: 100,
-            debug: false
-        };
-    }
-    /**
-     * Initialize QUIC transport with configuration
-     *
-     * Attempts QUIC connection first, falls back to TCP if:
-     * - QUIC not supported by network
-     * - Connection fails after retries
-     * - UDP blocked by firewall
-     *
-     * @param config - Transport configuration options
-     * @throws {Error} If both QUIC and TCP connections fail
-     *
-     * @example
-     * ```typescript
-     * await transport.initialize({
-     *   host: 'fleet.example.com',
-     *   port: 4433,
-     *   certPath: '/path/to/cert.pem',
-     *   keyPath: '/path/to/key.pem',
-     *   enable0RTT: true
-     * });
-     * ```
-     */
-    async initialize(config) {
-        this.config = { ...this.getDefaultConfig(), ...config };
-        this.state = ConnectionState.CONNECTING;
-        this.emit('stateChange', this.state);
-        this.log('Initializing QUIC transport', { config: this.config });
-        try {
-            // Load or generate TLS credentials
-            await this.loadTLSCredentials();
-            // Try QUIC first
-            try {
-                await this.connectQUIC();
-                this.mode = TransportMode.QUIC;
-                this.state = ConnectionState.CONNECTED;
-                this.connectionStartTime = Date.now();
-                this.log('QUIC connection established successfully');
-                this.emit('connected', { mode: TransportMode.QUIC });
-                // Start keep-alive if enabled
-                if (this.config.keepAlive) {
-                    this.startKeepAlive();
-                }
-                return;
-            }
-            catch (quicError) {
-                this.log('QUIC connection failed', { error: quicError });
-                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 quicError;
-            }
-        }
-        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 QUIC connection over UDP
-     * @private
-     */
-    async connectQUIC() {
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new Error('QUIC connection timeout'));
-            }, this.config.connectionTimeout);
-            try {
-                // Create UDP socket for QUIC
-                this.quicSocket = dgram.createSocket('udp4');
-                // Handle socket errors
-                this.quicSocket.on('error', (error) => {
-                    clearTimeout(timeout);
-                    this.log('QUIC socket error', { error });
-                    reject(error);
-                });
-                // Handle incoming messages
-                this.quicSocket.on('message', (msg, rinfo) => {
-                    this.handleQUICMessage(msg, rinfo);
-                });
-                // Bind socket
-                this.quicSocket.bind(() => {
-                    this.log('QUIC socket bound', {
-                        address: this.quicSocket.address()
-                    });
-                    // Send connection handshake
-                    this.sendQUICHandshake()
-                        .then(() => {
-                        clearTimeout(timeout);
-                        resolve();
-                    })
-                        .catch((error) => {
-                        clearTimeout(timeout);
-                        reject(error);
-                    });
-                });
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Send QUIC handshake packet with 0-RTT support
-     * @private
-     */
-    async sendQUICHandshake() {
-        if (!this.quicSocket) {
-            throw new Error('QUIC socket not initialized');
-        }
-        // Simplified QUIC handshake (in production, use proper QUIC library)
-        const handshake = {
-            type: 'HANDSHAKE',
-            version: '1.0',
-            enable0RTT: this.config.enable0RTT,
-            timestamp: Date.now()
-        };
-        const packet = Buffer.from(JSON.stringify(handshake));
-        return new Promise((resolve, reject) => {
-            this.quicSocket.send(packet, 0, packet.length, this.config.port, this.config.host, (error) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    this.log('QUIC handshake sent');
-                    resolve();
-                }
-            });
-        });
-    }
-    /**
-     * Handle incoming QUIC message
-     * @private
-     */
-    handleQUICMessage(msg, rinfo) {
-        try {
-            const startTime = Date.now();
-            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('QUIC message received', {
-                channel: envelope.channel,
-                latency: `${latency}ms`,
-                from: rinfo
-            });
-        }
-        catch (error) {
-            this.log('Error handling QUIC 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 (QUIC 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.QUIC && this.quicSocket) {
-                await this.sendQUICMessage(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 QUIC
-     * @private
-     */
-    async sendQUICMessage(message) {
-        if (!this.quicSocket) {
-            throw new Error('QUIC socket not available');
-        }
-        return new Promise((resolve, reject) => {
-            this.quicSocket.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 stream metadata
-        const streamId = this.generateStreamId(channel);
-        if (!this.streams.has(streamId)) {
-            this.streams.set(streamId, {
-                streamId,
-                channel,
-                created: Date.now(),
-                lastActivity: Date.now(),
-                messageCount: 0
-            });
-            this.metrics.activeStreams = this.streams.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 stream metadata
-                const streamId = this.generateStreamId(channel);
-                this.streams.delete(streamId);
-                this.metrics.activeStreams = this.streams.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 QUIC socket
-            if (this.quicSocket) {
-                this.quicSocket.close();
-                this.quicSocket = null;
-            }
-            // Close TCP socket
-            if (this.tcpSocket) {
-                this.tcpSocket.destroy();
-                this.tcpSocket = null;
-            }
-            // Clear subscriptions
-            this.channelCallbacks.clear();
-            this.streams.clear();
-            // Update state
-            this.state = ConnectionState.DISCONNECTED;
-            this.mode = TransportMode.UNKNOWN;
-            this.metrics.activeStreams = 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 QUIC or TCP, false otherwise
-     */
-    isConnected() {
-        return this.state === ConnectionState.CONNECTED;
-    }
-    /**
-     * Get current transport mode
-     *
-     * @returns Current transport mode (QUIC, 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 streams
-     * - 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 stream ID from channel
-     * @private
-     */
-    generateStreamId(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(`[QUICTransport ${timestamp}] ${message}`, data || '');
-        }
-        this.emit('log', { message, data, timestamp: Date.now() });
-    }
-}
-exports.QUICTransport = QUICTransport;
-/**
- * Create and initialize QUIC transport
- *
- * Convenience factory function for quick setup.
- *
- * @param config - Transport configuration
- * @returns Initialized QUICTransport instance
- *
- * @example
- * ```typescript
- * const transport = await createQUICTransport({
- *   host: 'fleet.example.com',
- *   port: 4433,
- *   enable0RTT: true
- * });
- * ```
- */
-async function createQUICTransport(config) {
-    const transport = new QUICTransport();
-    await transport.initialize(config);
-    return transport;
-}
-//# sourceMappingURL=QUICTransport.js.map