@iworkforces/tracelattice 2.0.3 → 2.0.5

package/dist/transport/SseTransport.d.ts

@@ -1,149 +0,0 @@
-/**
- * SSE (Server-Sent Events) Transport implementation.
- *
- * This transport allows multiple concurrent connections over HTTP using Server-Sent Events,
- * enabling multi-user scenarios and horizontal scaling.
- *
- * When a ConnectionPool is provided, each SSE client gets an isolated session with its own
- * thought history. Without a pool, all clients share a single server instance (backward compatible).
- *
- * @example
- * ```typescript
- * const transport = new SseTransport({
- *   port: 3000,
- *   host: 'localhost'
- * });
- * await transport.connect(server);
- * ```
- */
-import type { McpServer } from 'tmcp';
-import type { IMetrics } from '../contracts/interfaces.js';
-import type { PersistenceConfig } from '../contracts/PersistenceBackend.js';
-import type { IConnectionPool } from '../pool/IConnectionPool.js';
-import { BaseTransport, type TransportOptions } from './BaseTransport.js';
-import type { ITransport, TransportKind } from '../contracts/transport.js';
-/**
- * SSE-specific transport options extending base TransportOptions.
- */
-export interface SseTransportOptions extends TransportOptions {
-    path?: string;
-    metrics?: IMetrics;
-    /**
-     * Optional connection pool for per-session state isolation.
-     * When provided, each SSE client gets an isolated thought history.
-     * When omitted, all clients share a single server instance (backward compatible).
-     */
-    connectionPool?: IConnectionPool;
-    readonly persistence?: PersistenceConfig;
-}
-/** Rejects persistence backends that cannot isolate pooled SSE child servers. */
-export declare function assertPooledSsePersistence(poolingEnabled: boolean, persistence: PersistenceConfig | undefined): void;
-/**
- * SSE Transport for MCP server over HTTP.
- *
- * This transport uses Server-Sent Events (SSE) to communicate with clients,
- * allowing multiple concurrent connections and web-based clients.
- *
- * @remarks
- * **Security Features:**
- * - Session ID validation (alphanumeric, max 64 chars)
- * - Query parameter sanitization (whitelist allowed keys)
- * - Rate limiting per IP (configurable, default 100 req/min)
- * - CORS origin validation
- *
- * **Rate Limiting:**
- * - Tracks requests per IP address within a time window
- * - Returns 429 Too Many Requests when limit exceeded
- * - Can be disabled via `enableRateLimit: false`
- */
-export declare class SseTransport extends BaseTransport implements ITransport {
-    get kind(): TransportKind;
-    private _server;
-    private _path;
-    private _clients;
-    private _clientSessionMap;
-    private readonly _sessionAttachmentCounts;
-    private readonly _releasePromises;
-    private readonly _pendingReleases;
-    private readonly _releaseFailures;
-    private _messageQueue;
-    private _metrics?;
-    private _connectionPool?;
-    private _stopPromise;
-    constructor(options?: SseTransportOptions);
-    /**
-     * Connect MCP server to this transport.
-     *
-     * @param mcpServer - The MCP server instance
-     */
-    connect(mcpServer: McpServer): Promise<void>;
-    private _mcpServer;
-    /**
-     * Handle incoming HTTP requests
-     */
-    private _handleRequest;
-    private _prepareRequest;
-    /**
-     * Handle health check (liveness) endpoint
-     */
-    private _handleHealthCheck;
-    /**
-     * Handle readiness check endpoint
-     */
-    private _handleReadinessCheck;
-    /**
-     * Handle new SSE connection
-     */
-    private _handleSseConnection;
-    /**
-     * Handle incoming message from client
-     */
-    private _handleMessage;
-    private _parseMessage;
-    private _writeSessionUnavailable;
-    private _releaseClient;
-    private _releaseAfterDisconnect;
-    /**
-     * Send an SSE event to a specific client
-     */
-    private _sendSseEvent;
-    private _updateActiveConnectionsMetric;
-    private _updatePoolMetrics;
-    /**
-     * Broadcast a message to all connected clients
-     */
-    broadcast(event: string, data: unknown): void;
-    /**
-     * Generate a unique client ID
-     */
-    private _generateClientId;
-    /**
-     * Get number of connected clients
-     */
-    get clientCount(): number;
-    /**
-     * Get the connection pool, if one was configured.
-     */
-    get connectionPool(): IConnectionPool | undefined;
-    /**
-     * Stop the transport server with graceful shutdown.
-     *
-     * @param timeout - Maximum time to wait for requests to drain (not used for SSE)
-     * @returns Promise that resolves when shutdown is complete
-     */
-    stop(_timeout?: number): Promise<void>;
-}
-/**
- * Create an SSE transport with given options.
- *
- * @param options - Transport configuration
- * @returns A configured SSE transport
- *
- * @example
- * ```typescript
- * const transport = createSseTransport({ port: 3000 });
- * await transport.connect(mcpServer);
- * ```
- */
-export declare function createSseTransport(options?: SseTransportOptions): SseTransport;
-//# sourceMappingURL=SseTransport.d.ts.map

package/dist/transport/SseTransport.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SseTransport.d.ts","sourceRoot":"","sources":["../../src/transport/SseTransport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAEtC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAIlE,OAAO,EAAE,aAAa,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAW3E;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IAC5D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB;;;;OAIG;IACH,cAAc,CAAC,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,WAAW,CAAC,EAAE,iBAAiB,CAAC;CACzC;AAED,iFAAiF;AACjF,wBAAgB,0BAA0B,CACzC,cAAc,EAAE,OAAO,EACvB,WAAW,EAAE,iBAAiB,GAAG,SAAS,GACxC,IAAI,CAQN;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,YAAa,SAAQ,aAAc,YAAW,UAAU;IACpE,IAAI,IAAI,IAAI,aAAa,CAExB;IACD,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,iBAAiB,CAA6C;IACtE,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAgC;IACzE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAgD;IACjF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA4B;IAC7D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;IACvD,OAAO,CAAC,aAAa,CAAqC;IAC1D,OAAO,CAAC,QAAQ,CAAC,CAAW;IAC5B,OAAO,CAAC,eAAe,CAAC,CAAkB;IAC1C,OAAO,CAAC,YAAY,CAA8B;gBAEtC,OAAO,GAAE,mBAAwB;IAW7C;;;;OAIG;IACG,OAAO,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IA4BlD,OAAO,CAAC,UAAU,CAA0B;IAE5C;;OAEG;YACW,cAAc;IAkC5B,OAAO,CAAC,eAAe;IAuFvB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAc1B;;OAEG;YACW,qBAAqB;IAcnC;;OAEG;YACW,oBAAoB;IAgElC;;OAEG;YACW,cAAc;YA8Ed,aAAa;IAuD3B,OAAO,CAAC,wBAAwB;IAKhC,OAAO,CAAC,cAAc;IAwCtB,OAAO,CAAC,uBAAuB;IAM/B;;OAEG;IACH,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,8BAA8B;IAStC,OAAO,CAAC,kBAAkB;IAyB1B;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI;IAM7C;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAI,cAAc,IAAI,eAAe,GAAG,SAAS,CAEhD;IAED;;;;;OAKG;IACH,IAAI,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAgEtC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,mBAAwB,GAAG,YAAY,CAElF"}

package/dist/transport/SseTransport.js

@@ -1,470 +0,0 @@
-import { createServer } from "node:http";
-import { randomUUID } from "node:crypto";
-import { URL } from "node:url";
-import { safeParse } from "valibot";
-import { ConfigurationError } from "../errors.js";
-import { SessionNotActiveError, SessionNotFoundError } from "../pool/PoolErrors.js";
-import { JsonRpcRequestSchema } from "../schema.js";
-import { BaseTransport } from "./BaseTransport.js";
-import { asSessionId } from "../contracts/ids.js";
-import { runWithContext } from "../context/RequestContext.js";
-import { assertNever } from "../utils.js";
-function assertPooledSsePersistence(poolingEnabled, persistence) {
-    if (poolingEnabled && persistence?.enabled === true && ('file' === persistence.backend || 'sqlite' === persistence.backend)) throw new ConfigurationError(`pooled SSE does not support ${persistence.backend} persistence`);
-}
-class SseTransport extends BaseTransport {
-    get kind() {
-        return 'sse';
-    }
-    _server;
-    _path;
-    _clients = new Set();
-    _clientSessionMap = new Map();
-    _sessionAttachmentCounts = new Map();
-    _releasePromises = new WeakMap();
-    _pendingReleases = new Set();
-    _releaseFailures = new Set();
-    _messageQueue = new Map();
-    _metrics;
-    _connectionPool;
-    _stopPromise = null;
-    constructor(options = {}){
-        assertPooledSsePersistence(void 0 !== options.connectionPool, options.persistence);
-        super(options);
-        this._path = options.path ?? '/sse';
-        this._metrics = options.metrics;
-        this._connectionPool = options.connectionPool;
-        this._updateActiveConnectionsMetric();
-        this._server = createServer((req, res)=>this._handleRequest(req, res));
-    }
-    async connect(mcpServer) {
-        this._mcpServer = mcpServer;
-        return new Promise((resolve, reject)=>{
-            const cleanup = ()=>{
-                this._server.off('error', onError);
-                this._server.off('listening', onListening);
-            };
-            const onError = (error)=>{
-                cleanup();
-                reject(error);
-            };
-            const onListening = ()=>{
-                cleanup();
-                this.log('info', `SSE transport listening on http://${this._host}:${this._port}`);
-                resolve();
-            };
-            this._server.once('error', onError);
-            this._server.once('listening', onListening);
-            try {
-                this._server.listen(this._port, this._host);
-            } catch (error) {
-                cleanup();
-                reject(error);
-            }
-        });
-    }
-    _mcpServer = null;
-    async _handleRequest(req, res) {
-        const routing = this._prepareRequest(req, res);
-        if (!routing) return;
-        if (this._enableCors && 'OPTIONS' === req.method) {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-        if (routing.url.pathname === this._path && 'GET' === req.method) return void await this._handleSseConnection(req, res, routing.params);
-        if (routing.url.pathname === `${this._path}/message` && 'POST' === req.method) return void await this._handleMessage(req, res, routing.params);
-        if ('/health' === routing.url.pathname) return void this._handleHealthCheck(res);
-        if ('/ready' === routing.url.pathname) return void await this._handleReadinessCheck(res);
-        res.writeHead(404, {
-            'Content-Type': 'text/plain'
-        });
-        res.end('Not Found');
-    }
-    _prepareRequest(req, res) {
-        const startTime = Date.now();
-        const requestPath = req.url || '/';
-        const requestMethod = req.method || 'GET';
-        this._metrics?.counter('http_requests_total', 1, {
-            transport: 'sse',
-            method: requestMethod,
-            path: requestPath
-        }, 'Total HTTP requests');
-        res.once('finish', ()=>{
-            const durationSeconds = (Date.now() - startTime) / 1000;
-            this._metrics?.histogram('http_request_duration_seconds', durationSeconds, {
-                transport: 'sse',
-                path: requestPath
-            });
-        });
-        if (!this.validateHostHeader(req)) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'forbidden'
-            }, 'Total HTTP request errors');
-            res.writeHead(403, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                error: 'Forbidden - invalid host header'
-            }));
-            return;
-        }
-        const url = new URL(req.url || '', `http://${req.headers.host}`);
-        const clientIp = this.getClientIp(req);
-        if (this.checkRateLimit(clientIp)) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'rate_limit'
-            }, 'Total HTTP request errors');
-            res.writeHead(429, {
-                'Content-Type': 'application/json',
-                'Retry-After': '60'
-            });
-            res.end(JSON.stringify({
-                error: 'Too many requests'
-            }));
-            return;
-        }
-        if (!this.validateCorsOrigin(req)) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'forbidden'
-            }, 'Total HTTP request errors');
-            res.writeHead(403, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                error: 'Forbidden - invalid origin'
-            }));
-            return;
-        }
-        this.setCorsHeaders(res);
-        const sanitizedParams = this.sanitizeQueryParams(url);
-        const requestSessionId = sanitizedParams.session ?? sanitizedParams.sessionId;
-        if (void 0 !== requestSessionId && !this.validateSessionId(requestSessionId)) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'validation'
-            }, 'Total HTTP request errors');
-            res.writeHead(400, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                error: 'Invalid session ID format'
-            }));
-            return;
-        }
-        return {
-            url,
-            params: sanitizedParams
-        };
-    }
-    _handleHealthCheck(res) {
-        const healthData = {
-            status: 'healthy',
-            clients: this._clients.size
-        };
-        if (this._connectionPool) {
-            const poolStats = this._connectionPool.getStats();
-            healthData.pool = poolStats;
-        }
-        if (this._healthChecker) {
-            const liveness = this._healthChecker.checkLiveness();
-            healthData.liveness = liveness;
-        }
-        res.writeHead(200, {
-            'Content-Type': 'application/json'
-        });
-        res.end(JSON.stringify(healthData));
-    }
-    async _handleReadinessCheck(res) {
-        if (this._healthChecker) {
-            const readiness = await this._healthChecker.checkReadiness();
-            const statusCode = 'ok' === readiness.status ? 200 : 503;
-            res.writeHead(statusCode, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify(readiness));
-        } else {
-            res.writeHead(200, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                status: 'ok',
-                timestamp: new Date().toISOString(),
-                components: {}
-            }));
-        }
-    }
-    async _handleSseConnection(req, res, params) {
-        res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            Connection: 'keep-alive'
-        });
-        let sessionId;
-        if (this._connectionPool) {
-            const requestedSession = params.session ?? params.sessionId;
-            const requestedSessionId = requestedSession ? asSessionId(requestedSession) : void 0;
-            if (requestedSessionId && this._connectionPool.getSessionInfo(requestedSessionId)) sessionId = requestedSessionId;
-            else try {
-                sessionId = await this._connectionPool.createSession();
-            } catch (error) {
-                res.write(`event: error\n`);
-                res.write(`data: ${JSON.stringify({
-                    error: error instanceof Error ? error.message : 'Failed to create session'
-                })}\n\n`);
-                res.end();
-                return;
-            }
-            this._clientSessionMap.set(res, sessionId);
-            this._sessionAttachmentCounts.set(sessionId, (this._sessionAttachmentCounts.get(sessionId) ?? 0) + 1);
-            this._updatePoolMetrics();
-        }
-        this._clients.add(res);
-        this._updateActiveConnectionsMetric();
-        const release = ()=>this._releaseAfterDisconnect(res);
-        req.once('close', release);
-        res.once('close', release);
-        res.once('error', release);
-        const connectedPayload = {
-            timestamp: Date.now()
-        };
-        if (sessionId) connectedPayload.sessionId = sessionId;
-        this._sendSseEvent(res, 'connected', connectedPayload);
-        const clientId = this._generateClientId();
-        const queued = this._messageQueue.get(clientId);
-        if (queued) {
-            for (const message of queued)this._sendSseEvent(res, 'message', message);
-            this._messageQueue.delete(clientId);
-        }
-    }
-    async _handleMessage(req, res, params) {
-        let pooledOwner;
-        if (this._connectionPool) {
-            const correlation = params.session ?? params.sessionId;
-            if (void 0 === correlation) {
-                res.writeHead(400, {
-                    'Content-Type': 'application/json'
-                });
-                res.end(JSON.stringify({
-                    error: 'Missing session ID'
-                }));
-                return;
-            }
-            pooledOwner = asSessionId(correlation);
-        }
-        const jsonRpcRequest = await this._parseMessage(req, res);
-        if (!jsonRpcRequest) return;
-        const mcpServer = this._mcpServer;
-        if (!mcpServer) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'server_not_ready'
-            }, 'Total HTTP request errors');
-            res.writeHead(503, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                error: 'Server not ready'
-            }));
-            return;
-        }
-        const owner = pooledOwner ?? `sse-${randomUUID()}`;
-        const receive = ()=>runWithContext({
-                requestId: randomUUID(),
-                owner
-            }, ()=>mcpServer.receive(jsonRpcRequest, {
-                    sessionInfo: {}
-                }));
-        try {
-            let response;
-            if (this._connectionPool && pooledOwner) {
-                if ('function' != typeof this._connectionPool.runWithSession) return void this._writeSessionUnavailable(res);
-                const result = await this._connectionPool.runWithSession(pooledOwner, receive);
-                switch(result.status){
-                    case 'completed':
-                        response = result.value;
-                        break;
-                    case 'inactive':
-                    case 'missing':
-                        this._writeSessionUnavailable(res);
-                        return;
-                    default:
-                        return assertNever(result);
-                }
-            } else response = await receive();
-            res.writeHead(200, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify(response ?? {
-                jsonrpc: '2.0',
-                id: 'id' in jsonRpcRequest ? jsonRpcRequest.id : null,
-                result: null
-            }));
-        } catch (error) {
-            if (error instanceof SessionNotFoundError || error instanceof SessionNotActiveError) return void this._writeSessionUnavailable(res);
-            throw error;
-        }
-    }
-    async _parseMessage(req, res) {
-        let body = '';
-        for await (const chunk of req)body += chunk.toString();
-        let rawBody;
-        try {
-            rawBody = JSON.parse(body);
-        } catch (error) {
-            if (!(error instanceof SyntaxError)) throw error;
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'parse_error'
-            }, 'Total HTTP request errors');
-            res.writeHead(400, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                error: 'Invalid JSON'
-            }));
-            return;
-        }
-        const parseResult = safeParse(JsonRpcRequestSchema, rawBody);
-        const rawId = rawBody && 'object' == typeof rawBody && 'id' in rawBody ? rawBody.id ?? null : null;
-        if (!parseResult.success) {
-            this._metrics?.counter('http_request_errors_total', 1, {
-                transport: 'sse',
-                error_type: 'validation'
-            }, 'Total HTTP request errors');
-            res.writeHead(200, {
-                'Content-Type': 'application/json'
-            });
-            res.end(JSON.stringify({
-                jsonrpc: '2.0',
-                id: rawId,
-                error: {
-                    code: -32600,
-                    message: 'Invalid Request',
-                    data: parseResult.issues
-                }
-            }));
-            return;
-        }
-        return parseResult.output;
-    }
-    _writeSessionUnavailable(res) {
-        res.writeHead(404, {
-            'Content-Type': 'application/json'
-        });
-        res.end(JSON.stringify({
-            error: 'Session not found'
-        }));
-    }
-    _releaseClient(res) {
-        const existing = this._releasePromises.get(res);
-        if (existing) return existing;
-        this._clients.delete(res);
-        const sessionId = this._clientSessionMap.get(res);
-        this._clientSessionMap.delete(res);
-        this._updateActiveConnectionsMetric();
-        let releasePromise = Promise.resolve();
-        if (sessionId && this._connectionPool) {
-            const attachmentCount = this._sessionAttachmentCounts.get(sessionId);
-            if (void 0 !== attachmentCount && attachmentCount > 1) this._sessionAttachmentCounts.set(sessionId, attachmentCount - 1);
-            else {
-                this._sessionAttachmentCounts.delete(sessionId);
-                releasePromise = this._connectionPool.closeSession(sessionId).catch((error)=>{
-                    if (error instanceof SessionNotFoundError) return;
-                    throw error;
-                });
-            }
-            this._updatePoolMetrics();
-        }
-        this._releasePromises.set(res, releasePromise);
-        this._pendingReleases.add(releasePromise);
-        releasePromise.then(()=>this._pendingReleases.delete(releasePromise), (error)=>{
-            this._pendingReleases.delete(releasePromise);
-            this._releaseFailures.add(error);
-        });
-        return releasePromise;
-    }
-    _releaseAfterDisconnect(res) {
-        this._releaseClient(res).catch((error)=>{
-            this.log('error', 'SSE pooled session release failed', {
-                error
-            });
-        });
-    }
-    _sendSseEvent(res, event, data) {
-        try {
-            res.write(`event: ${event}\n`);
-            res.write(`data: ${JSON.stringify(data)}\n\n`);
-        } catch  {
-            this._releaseAfterDisconnect(res);
-        }
-    }
-    _updateActiveConnectionsMetric() {
-        this._metrics?.gauge('sse_active_connections', this._clients.size, {}, 'Current active SSE connections');
-    }
-    _updatePoolMetrics() {
-        if (!this._connectionPool || !this._metrics) return;
-        const stats = this._connectionPool.getStats();
-        this._metrics.gauge('sse_pool_active_sessions', stats.activeSessions, {}, 'Active sessions in connection pool');
-        this._metrics.gauge('sse_pool_total_sessions', stats.totalSessions, {}, 'Total sessions in connection pool');
-        this._metrics.gauge('sse_pool_max_sessions', stats.maxSessions, {}, 'Maximum sessions in connection pool');
-    }
-    broadcast(event, data) {
-        for (const client of this._clients)this._sendSseEvent(client, event, data);
-    }
-    _generateClientId() {
-        return `client_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
-    }
-    get clientCount() {
-        return this._clients.size;
-    }
-    get connectionPool() {
-        return this._connectionPool;
-    }
-    stop(_timeout) {
-        if (this._stopPromise) return this._stopPromise;
-        const completion = Promise.withResolvers();
-        this._stopPromise = completion.promise;
-        this._isShuttingDown = true;
-        this._stopRateLimitCleanup();
-        const operations = new Set();
-        for (const client of Array.from(this._clients)){
-            operations.add(this._releaseClient(client));
-            try {
-                client.end();
-            } catch (error) {
-                operations.add(Promise.reject(error instanceof Error ? error : new AggregateError([
-                    error
-                ], 'SSE client close failed')));
-            }
-        }
-        for (const release of this._pendingReleases)operations.add(release);
-        if (this._connectionPool) operations.add(this._connectionPool.terminate());
-        operations.add(this._server.listening ? new Promise((resolve, reject)=>{
-            this._server.close((error)=>error ? reject(error) : resolve());
-        }) : Promise.resolve());
-        Promise.allSettled(operations).then((outcomes)=>{
-            const failures = new Set(this._releaseFailures);
-            for (const outcome of outcomes)if ('rejected' === outcome.status) if (outcome.reason instanceof AggregateError) for (const error of outcome.reason.errors)failures.add(error);
-            else failures.add(outcome.reason);
-            this._clients.clear();
-            this._clientSessionMap.clear();
-            this._sessionAttachmentCounts.clear();
-            this._updateActiveConnectionsMetric();
-            this._updatePoolMetrics();
-            if (failures.size > 0) return void completion.reject(new AggregateError(failures, 'SSE transport shutdown failed'));
-            this.log('info', 'SSE transport stopped');
-            completion.resolve();
-        });
-        return completion.promise;
-    }
-}
-function createSseTransport(options = {}) {
-    return new SseTransport(options);
-}
-export { SseTransport, assertPooledSsePersistence, createSseTransport };
-
-//# sourceMappingURL=SseTransport.js.map