bunqueue 2.8.53 → 2.8.56

package/dist/infrastructure/server/sse/eventBuffer.js

@@ -0,0 +1,21 @@
+import { SSE_EVENT_BUFFER_SIZE, sseTextEncoder } from './constants';
+export function bufferSseEvent(buffer, event) {
+    buffer.push(event);
+    if (buffer.length > SSE_EVENT_BUFFER_SIZE)
+        buffer.shift();
+}
+export function replaySseEvents(buffer, client, lastEventId) {
+    for (const buffered of buffer) {
+        if (buffered.id <= lastEventId)
+            continue;
+        if (client.queueFilter && buffered.queue && client.queueFilter !== buffered.queue)
+            continue;
+        try {
+            const message = `id: ${buffered.id}\nevent: ${buffered.event}\ndata: ${buffered.data}\n\n`;
+            client.controller.enqueue(sseTextEncoder.encode(message));
+        }
+        catch {
+            break;
+        }
+    }
+}

package/dist/infrastructure/server/sseHandler.d.ts

@@ -13,12 +13,8 @@
  */
 import type { QueueManager } from '../../application/queueManager';
 import type { JobEvent } from '../../domain/types/queue';
-/** SSE client tracking */
-export interface SseClient {
-    id: string;
-    controller: ReadableStreamDefaultController;
-    queueFilter: string | null;
-}
+import type { SseClient } from './types/sse';
+export type { SseClient } from './types/sse';
 /**
  * SSE Handler - manages Server-Sent Events clients with full event parity
  */

package/dist/infrastructure/server/sseHandler.js

@@ -11,30 +11,12 @@
  * - Connection limits to prevent resource exhaustion
  * - Automatic dead client cleanup
  */
-import { throughputTracker } from '../../application/throughputTracker';
 import { uuid } from '../../shared/hash';
 import { QueueCountsScheduler } from './queueCountsScheduler';
-const textEncoder = new TextEncoder();
-/** Tuning constants */
-const MAX_CLIENTS = 1000;
-const HEARTBEAT_MS = 30_000;
-const RETRY_MS = 3_000;
-const EVENT_BUFFER_SIZE = 1000;
-/** Old eventType → SSE event name (mirrors wsHandler) */
-const EVENT_MAP = {
-    pushed: 'job:pushed',
-    pulled: 'job:active',
-    completed: 'job:completed',
-    failed: 'job:failed',
-    progress: 'job:progress',
-    stalled: 'job:stalled',
-    removed: 'job:removed',
-    delayed: 'job:delayed',
-    duplicated: 'job:duplicated',
-    retried: 'job:retried',
-    'waiting-children': 'job:waiting-children',
-    drained: 'queue:drained',
-};
+import { MAX_SSE_CLIENTS, SSE_HEARTBEAT_MS, SSE_RETRY_MS, sseTextEncoder } from './sse/constants';
+import { bufferSseEvent, replaySseEvents } from './sse/eventBuffer';
+import { WS_EVENT_MAP } from './ws/constants';
+import { buildHealthSnapshot, buildStatsSnapshot, buildStorageSnapshot } from './ws/snapshots';
 /**
  * SSE Handler - manages Server-Sent Events clients with full event parity
  */
@@ -69,7 +51,7 @@ export class SseHandler {
         });
         this.heartbeatTimer ??= setInterval(() => {
             this.sendHeartbeat();
-        }, HEARTBEAT_MS);
+        }, SSE_HEARTBEAT_MS);
         this.statsInterval ??= setInterval(() => {
             if (this.clients.size > 0)
                 this.broadcastStats(qm);
@@ -87,7 +69,7 @@ export class SseHandler {
     startHeartbeat() {
         this.heartbeatTimer ??= setInterval(() => {
             this.sendHeartbeat();
-        }, HEARTBEAT_MS);
+        }, SSE_HEARTBEAT_MS);
     }
     /** Stop all timers */
     stopTimers() {
@@ -115,7 +97,7 @@ export class SseHandler {
     sendHeartbeat() {
         if (this.clients.size === 0)
             return;
-        const heartbeat = textEncoder.encode(`:heartbeat\n\n`);
+        const heartbeat = sseTextEncoder.encode(`:heartbeat\n\n`);
         const disconnected = [];
         for (const [clientId, client] of this.clients) {
             try {
@@ -139,7 +121,7 @@ export class SseHandler {
         if (this.clients.size === 0)
             return;
         const id = ++this.eventId;
-        const eventName = EVENT_MAP[event.eventType] ?? `job:${event.eventType}`;
+        const eventName = WS_EVENT_MAP[event.eventType] ?? `job:${event.eventType}`;
         const eventData = {
             queue: event.queue,
             jobId: event.jobId,
@@ -155,7 +137,7 @@ export class SseHandler {
             eventData.delay = event.delay;
         const data = JSON.stringify(eventData);
         this.bufferEvent(id, eventName, data, event.queue);
-        const msg = textEncoder.encode(`id: ${id}\nevent: ${eventName}\ndata: ${data}\n\n`);
+        const msg = sseTextEncoder.encode(`id: ${id}\nevent: ${eventName}\ndata: ${data}\n\n`);
         const disconnected = [];
         for (const [clientId, client] of this.clients) {
             if (!client.queueFilter || client.queueFilter === event.queue) {
@@ -184,7 +166,7 @@ export class SseHandler {
             return;
         const id = ++this.eventId;
         const jsonData = JSON.stringify(data);
-        const msg = textEncoder.encode(`id: ${id}\nevent: ${eventName}\ndata: ${jsonData}\n\n`);
+        const msg = sseTextEncoder.encode(`id: ${id}\nevent: ${eventName}\ndata: ${jsonData}\n\n`);
         const disconnected = [];
         for (const [clientId, client] of this.clients) {
             try {
@@ -199,86 +181,26 @@ export class SseHandler {
     }
     // ── Periodic broadcasts ────────────────────────────────────
     broadcastStats(qm) {
-        const stats = qm.getStats();
-        const rates = throughputTracker.getRates();
-        const perQueue = qm.getPerQueueStats();
-        const workerStats = qm.workerManager.getStats();
-        const crons = qm.listCrons();
-        const queues = {};
-        for (const [name, s] of perQueue) {
-            queues[name] = {
-                waiting: s.waiting ?? 0,
-                active: s.active ?? 0,
-                delayed: s.delayed ?? 0,
-                dlq: s.dlq ?? 0,
-                paused: qm.isPaused(name),
-            };
-        }
-        this.sendTypedEvent('stats:snapshot', {
-            waiting: stats.waiting,
-            active: stats.active,
-            delayed: stats.delayed,
-            completed: stats.completed,
-            dlq: stats.dlq,
-            totalPushed: Number(stats.totalPushed),
-            totalCompleted: Number(stats.totalCompleted),
-            totalFailed: Number(stats.totalFailed),
-            pushPerSec: rates.pushPerSec,
-            pullPerSec: rates.pullPerSec,
-            uptime: stats.uptime,
-            queues,
-            workers: { total: workerStats.total, active: workerStats.active },
-            cronJobs: crons.length,
-        });
+        this.sendTypedEvent('stats:snapshot', buildStatsSnapshot(qm));
     }
     broadcastHealth(qm) {
-        const mem = process.memoryUsage();
-        const storage = qm.getStorageStatus();
-        this.sendTypedEvent('health:status', {
-            ok: !storage.diskFull,
-            uptime: Math.floor(process.uptime()),
-            memory: {
-                rss: Math.round(mem.rss / 1024 / 1024),
-                heapUsed: Math.round(mem.heapUsed / 1024 / 1024),
-            },
-            connections: { sse: this.clients.size },
-        });
+        this.sendTypedEvent('health:status', buildHealthSnapshot(qm, this.clients.size, 'sse'));
     }
     broadcastStorage(qm) {
-        const memStats = qm.getMemoryStats();
-        const storage = qm.getStorageStatus();
-        this.sendTypedEvent('storage:status', {
-            collections: memStats,
-            diskFull: storage.diskFull,
-        });
+        this.sendTypedEvent('storage:status', buildStorageSnapshot(qm));
     }
     // ── Event buffer (ring buffer for Last-Event-ID replay) ────
     bufferEvent(id, event, data, queue) {
-        this.eventBuffer.push({ id, event, data, queue });
-        if (this.eventBuffer.length > EVENT_BUFFER_SIZE) {
-            this.eventBuffer.shift();
-        }
+        bufferSseEvent(this.eventBuffer, { id, event, data, queue });
     }
     /** Replay missed events for a reconnecting client */
     replayEvents(client, lastEventId) {
-        for (const buffered of this.eventBuffer) {
-            if (buffered.id <= lastEventId)
-                continue;
-            if (client.queueFilter && buffered.queue && client.queueFilter !== buffered.queue)
-                continue;
-            try {
-                const msg = `id: ${buffered.id}\nevent: ${buffered.event}\ndata: ${buffered.data}\n\n`;
-                client.controller.enqueue(textEncoder.encode(msg));
-            }
-            catch {
-                break;
-            }
-        }
+        replaySseEvents(this.eventBuffer, client, lastEventId);
     }
     // ── Client connection ──────────────────────────────────────
     /** Create SSE response for a new client */
     createResponse(queueFilter, corsOrigin, lastEventId) {
-        if (this.clients.size >= MAX_CLIENTS) {
+        if (this.clients.size >= MAX_SSE_CLIENTS) {
             return new Response('Too many SSE connections', { status: 503 });
         }
         const clientId = uuid();
@@ -288,7 +210,7 @@ export class SseHandler {
                 const client = { id: clientId, controller, queueFilter };
                 this.clients.set(clientId, client);
                 // Retry interval + connected confirmation in a single chunk
-                controller.enqueue(textEncoder.encode(`retry: ${RETRY_MS}\ndata: {"connected":true,"clientId":"${clientId}"}\n\n`));
+                controller.enqueue(sseTextEncoder.encode(`retry: ${SSE_RETRY_MS}\ndata: {"connected":true,"clientId":"${clientId}"}\n\n`));
                 // Replay missed events on reconnection
                 if (resumeId > 0) {
                     this.replayEvents(client, resumeId);
@@ -297,7 +219,9 @@ export class SseHandler {
             cancel: () => {
                 this.clients.delete(clientId);
                 this.queueManager?.unregisterWorkersByClientId(clientId);
-                this.queueManager?.releaseClientJobs(clientId).catch(() => { });
+                this.queueManager?.releaseClientJobs(clientId).catch(() => {
+                    // Client cleanup is best-effort during transport cancellation.
+                });
             },
         });
         return new Response(stream, {

package/dist/infrastructure/server/tcp/clientRelease.d.ts

@@ -0,0 +1,2 @@
+import type { QueueManager } from '../../../application/queueManager';
+export declare function releaseClientJobsWithRetry(queueManager: QueueManager, clientId: string, maxRetries?: number): Promise<number>;

package/dist/infrastructure/server/tcp/clientRelease.js

@@ -0,0 +1,18 @@
+import { tcpLog } from '../../../shared/logger';
+export async function releaseClientJobsWithRetry(queueManager, clientId, maxRetries = 3) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await queueManager.releaseClientJobs(clientId);
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            await Bun.sleep(100 * Math.pow(2, attempt));
+        }
+    }
+    tcpLog.error('Failed to release client jobs after retries', {
+        clientId,
+        error: lastError?.message,
+    });
+    throw lastError ?? new Error('Failed to release client jobs after retries');
+}

package/dist/infrastructure/server/tcp/connections.d.ts

@@ -0,0 +1,24 @@
+import type { Socket } from 'bun';
+import type { QueueManager } from '../../../application/queueManager';
+import type { TcpConnectionData } from '../types/tcpServer';
+/** Owns per-client state, slowloris timers, backpressure, and disconnect cleanup. */
+export declare class TcpConnectionRegistry {
+    private readonly queueManager;
+    private readonly authTokens;
+    private readonly idleTimeoutMs;
+    private readonly maxWriteQueueBytes;
+    readonly connections: Map<string, Socket<TcpConnectionData>>;
+    private eventUnsubscribe;
+    constructor(queueManager: QueueManager, authTokens: Set<string>, idleTimeoutMs: number, maxWriteQueueBytes: number);
+    init(socket: Socket<TcpConnectionData>): void;
+    clearStallTimer(socket: Socket<TcpConnectionData>): void;
+    updateStallTimer(socket: Socket<TcpConnectionData>): void;
+    dropForWriteOverflow(socket: Socket<TcpConnectionData>): boolean;
+    close(socket: Socket<TcpConnectionData>): void;
+    broadcast(message: unknown): void;
+    subscribeEvents(socket: Socket<TcpConnectionData>, queue: string): void;
+    unsubscribeEvents(socket: Socket<TcpConnectionData>): void;
+    private broadcastEvent;
+    private releaseEventBridgeIfIdle;
+    closeAll(): void;
+}

package/dist/infrastructure/server/tcp/connections.js

@@ -0,0 +1,162 @@
+import { uuid } from '../../../shared/hash';
+import { tcpLog } from '../../../shared/logger';
+import { encodeMessagePack } from '../../../shared/msgpack';
+import { Semaphore } from '../../../shared/semaphore';
+import { FrameParser, createConnectionState } from '../protocol';
+import { getRateLimiter } from '../rateLimiter';
+import { SocketWriteQueue } from '../socketWriteQueue';
+import { releaseClientJobsWithRetry } from './clientRelease';
+import { MAX_CONCURRENT_PER_CONNECTION } from './constants';
+/** Owns per-client state, slowloris timers, backpressure, and disconnect cleanup. */
+export class TcpConnectionRegistry {
+    queueManager;
+    authTokens;
+    idleTimeoutMs;
+    maxWriteQueueBytes;
+    connections = new Map();
+    eventUnsubscribe = null;
+    constructor(queueManager, authTokens, idleTimeoutMs, maxWriteQueueBytes) {
+        this.queueManager = queueManager;
+        this.authTokens = authTokens;
+        this.idleTimeoutMs = idleTimeoutMs;
+        this.maxWriteQueueBytes = maxWriteQueueBytes;
+    }
+    init(socket) {
+        if (socket.data)
+            return;
+        const clientId = uuid();
+        const abortController = new AbortController();
+        socket.data = {
+            state: createConnectionState(clientId),
+            abortController,
+            frameParser: new FrameParser(),
+            ctx: {
+                queueManager: this.queueManager,
+                authTokens: this.authTokens,
+                authenticated: this.authTokens.size === 0,
+                clientId,
+                signal: abortController.signal,
+            },
+            semaphore: new Semaphore(MAX_CONCURRENT_PER_CONNECTION),
+            writeQueue: new SocketWriteQueue(this.maxWriteQueueBytes),
+            stallTimer: null,
+            eventQueue: null,
+        };
+        this.connections.set(clientId, socket);
+        this.queueManager.emitDashboardEvent('client:connected', { clientId, transport: 'tcp' });
+    }
+    clearStallTimer(socket) {
+        if (socket.data.stallTimer !== null) {
+            clearTimeout(socket.data.stallTimer);
+            socket.data.stallTimer = null;
+        }
+    }
+    updateStallTimer(socket) {
+        if (this.idleTimeoutMs <= 0)
+            return;
+        this.clearStallTimer(socket);
+        if (!socket.data.frameParser.hasPartialFrame)
+            return;
+        socket.data.stallTimer = setTimeout(() => {
+            socket.data.stallTimer = null;
+            tcpLog.warn('Closing stalled connection (incomplete frame)', {
+                clientId: socket.data.state.clientId,
+                bufferedBytes: socket.data.frameParser.bufferedBytes,
+                idleTimeoutMs: this.idleTimeoutMs,
+            });
+            socket.data.writeQueue.clear();
+            socket.terminate();
+        }, this.idleTimeoutMs);
+    }
+    dropForWriteOverflow(socket) {
+        const { writeQueue, state } = socket.data;
+        if (!writeQueue.isOverBudget)
+            return false;
+        tcpLog.warn('Closing connection: write queue exceeded budget', {
+            clientId: state.clientId,
+            queuedBytes: writeQueue.bytesQueued,
+        });
+        this.clearStallTimer(socket);
+        writeQueue.clear();
+        socket.terminate();
+        return true;
+    }
+    close(socket) {
+        if (!socket.data)
+            return;
+        socket.data.abortController.abort();
+        const clientId = socket.data.state.clientId;
+        this.clearStallTimer(socket);
+        socket.data.writeQueue.clear();
+        socket.data.eventQueue = null;
+        this.connections.delete(clientId);
+        this.releaseEventBridgeIfIdle();
+        getRateLimiter().removeClient(clientId);
+        this.queueManager.unregisterWorkersByClientId(clientId);
+        this.queueManager.emitDashboardEvent('client:disconnected', {
+            clientId,
+            transport: 'tcp',
+        });
+        releaseClientJobsWithRetry(this.queueManager, clientId).catch((error) => {
+            const touched = this.queueManager.forceReleaseClientJobs(clientId);
+            tcpLog.error('Client jobs release failed; fell back to force-release', {
+                clientId,
+                error: String(error),
+                forcedJobs: touched,
+                note: 'Stall detector will recover orphaned active jobs on next tick',
+            });
+        });
+    }
+    broadcast(message) {
+        const frame = FrameParser.frame(encodeMessagePack(message));
+        for (const socket of this.connections.values()) {
+            socket.data.writeQueue.write(socket, frame);
+            if (socket.data.writeQueue.isOverBudget) {
+                this.clearStallTimer(socket);
+                socket.data.writeQueue.clear();
+                socket.terminate();
+            }
+        }
+    }
+    subscribeEvents(socket, queue) {
+        socket.data.eventQueue = queue;
+        if (!this.eventUnsubscribe) {
+            this.eventUnsubscribe = this.queueManager.subscribe((event) => this.broadcastEvent(event));
+        }
+    }
+    unsubscribeEvents(socket) {
+        socket.data.eventQueue = null;
+        this.releaseEventBridgeIfIdle();
+    }
+    broadcastEvent(event) {
+        let frame = null;
+        for (const socket of this.connections.values()) {
+            if (socket.data.eventQueue !== event.queue)
+                continue;
+            frame ??= FrameParser.frame(encodeMessagePack({ type: 'event', event }));
+            socket.data.writeQueue.write(socket, frame);
+            this.dropForWriteOverflow(socket);
+        }
+    }
+    releaseEventBridgeIfIdle() {
+        if (!this.eventUnsubscribe)
+            return;
+        for (const socket of this.connections.values()) {
+            if (socket.data.eventQueue !== null)
+                return;
+        }
+        this.eventUnsubscribe();
+        this.eventUnsubscribe = null;
+    }
+    closeAll() {
+        this.eventUnsubscribe?.();
+        this.eventUnsubscribe = null;
+        for (const socket of this.connections.values()) {
+            this.clearStallTimer(socket);
+            socket.data.eventQueue = null;
+            socket.data.writeQueue.clear();
+            socket.terminate();
+        }
+        this.connections.clear();
+    }
+}

package/dist/infrastructure/server/tcp/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_CONCURRENT_PER_CONNECTION = 50;
+export declare const TCP_IDLE_TIMEOUT_MS: number;
+export declare const MAX_WRITE_QUEUE_BYTES: number;

package/dist/infrastructure/server/tcp/constants.js

@@ -0,0 +1,3 @@
+export const MAX_CONCURRENT_PER_CONNECTION = 50;
+export const TCP_IDLE_TIMEOUT_MS = Math.max(0, parseInt(Bun.env.TCP_IDLE_TIMEOUT_MS ?? '60000', 10) || 0);
+export const MAX_WRITE_QUEUE_BYTES = Math.max(0, parseInt(Bun.env.TCP_MAX_WRITE_QUEUE_BYTES ?? String(64 * 1024 * 1024), 10) || 0);

package/dist/infrastructure/server/tcp/eventSubscriptions.d.ts

@@ -0,0 +1,10 @@
+import type { Socket } from 'bun';
+import type { Command } from '../../../domain/types/command';
+import type { Response } from '../../../domain/types/response';
+import type { TcpConnectionData } from '../types/tcpServer';
+import type { TcpConnectionRegistry } from './connections';
+type EventCommand = Extract<Command, {
+    cmd: 'SubscribeEvents' | 'UnsubscribeEvents';
+}>;
+export declare function handleEventSubscription(command: EventCommand, socket: Socket<TcpConnectionData>, registry: TcpConnectionRegistry): Response;
+export {};

package/dist/infrastructure/server/tcp/eventSubscriptions.js

@@ -0,0 +1,17 @@
+import * as resp from '../../../domain/types/response';
+import { validateQueueName } from '../protocol';
+export function handleEventSubscription(command, socket, registry) {
+    const { ctx } = socket.data;
+    if (ctx.authTokens.size > 0 && !ctx.authenticated) {
+        return resp.error('Not authenticated', command.reqId);
+    }
+    if (command.cmd === 'UnsubscribeEvents') {
+        registry.unsubscribeEvents(socket);
+        return resp.ok(undefined, command.reqId);
+    }
+    const validationError = validateQueueName(command.queue);
+    if (validationError)
+        return resp.error(validationError, command.reqId);
+    registry.subscribeEvents(socket, command.queue);
+    return resp.ok(undefined, command.reqId);
+}

package/dist/infrastructure/server/tcp/responses.d.ts

@@ -0,0 +1,3 @@
+import type { Response } from '../../../domain/types/response';
+export declare function serializeTcpResponse(response: Response): Uint8Array;
+export declare function tcpErrorResponse(message: string, requestId?: string): Uint8Array;

package/dist/infrastructure/server/tcp/responses.js

@@ -0,0 +1,8 @@
+import { encodeMessagePack } from '../../../shared/msgpack';
+import { FrameParser } from '../protocol';
+export function serializeTcpResponse(response) {
+    return FrameParser.frame(encodeMessagePack(response));
+}
+export function tcpErrorResponse(message, requestId) {
+    return FrameParser.frame(encodeMessagePack({ ok: false, error: message, reqId: requestId }));
+}

package/dist/infrastructure/server/tcp.d.ts

@@ -1,78 +1,20 @@
-/**
- * TCP Server
- * Handles TCP connections with msgpack binary protocol
- * Supports pipelining with parallel command processing
- */
 import type { Socket, TCPSocketListener } from 'bun';
 import type { QueueManager } from '../../application/queueManager';
-import { type HandlerContext } from './handler';
-import { FrameParser, type ConnectionState } from './protocol';
-import { Semaphore } from '../../shared/semaphore';
-import { SocketWriteQueue } from './socketWriteQueue';
-import { type TlsServerOptions } from './tls';
-/** TCP Server configuration */
-export interface TcpServerConfig {
-    /** TCP port */
-    port?: number;
-    /** Hostname to bind */
-    hostname?: string;
-    /** Auth tokens for authentication */
-    authTokens?: string[];
-    /**
-     * Slowloris stall timeout (ms): close a connection that started a frame but
-     * made no progress completing it within this window. 0 disables. Defaults to
-     * TCP_IDLE_TIMEOUT_MS env (60s). Mainly for tests.
-     */
-    idleTimeoutMs?: number;
-    /**
-     * Max outbound write-queue bytes before dropping a connection (write-side
-     * memory bound). 0 disables. Defaults to TCP_MAX_WRITE_QUEUE_BYTES env (64MB).
-     * Mainly for tests.
-     */
-    maxWriteQueueBytes?: number;
-    /**
-     * Native TLS termination. When set, the server only accepts TLS clients —
-     * the msgpack protocol is unchanged, only the transport is wrapped.
-     */
-    tls?: TlsServerOptions;
-}
-/** Per-connection data */
-interface ConnectionData {
-    state: ConnectionState;
-    abortController: AbortController;
-    frameParser: FrameParser;
-    ctx: HandlerContext;
-    /** Semaphore for limiting concurrent command processing (pipelining) */
-    semaphore: Semaphore;
-    /** Backpressure-aware write queue: buffers unwritten tails, flushes on drain */
-    writeQueue: SocketWriteQueue;
-    /** Active partial-frame stall timer (slowloris mitigation); null when idle. */
-    stallTimer: ReturnType<typeof setTimeout> | null;
-}
-/**
- * Create and start TCP server
- */
+import type { TcpConnectionData, TcpServerConfig } from './types/tcpServer';
+export type { TcpServerConfig } from './types/tcpServer';
+/** Create and start the MessagePack TCP server. */
 export declare function createTcpServer(queueManager: QueueManager, config: TcpServerConfig): {
-    server: TCPSocketListener<ConnectionData>;
-    connections: Map<string, Socket<ConnectionData>>;
-    /**
-     * Raw Bun socket handlers. Exposed for tests that need to drive the socket
-     * lifecycle directly (e.g. a `data` event arriving before `open` under TLS,
-     * #108) — production code goes through Bun.listen above.
-     */
+    server: TCPSocketListener<TcpConnectionData>;
+    connections: Map<string, Socket<TcpConnectionData>>;
     _socketHandlers: {
-        open(socket: Socket<ConnectionData>): void;
-        data(socket: Socket<ConnectionData>, data: Buffer): Promise<void>;
-        close(socket: Socket<ConnectionData>): void;
-        error(_socket: Socket<ConnectionData>, error: Error): void;
-        drain(socket: Socket<ConnectionData>): void;
+        open(socket: Socket<TcpConnectionData>): void;
+        data(socket: Socket<TcpConnectionData>, data: Buffer): Promise<void>;
+        close(socket: Socket<TcpConnectionData>): void;
+        error(_socket: Socket<TcpConnectionData>, error: Error): void;
+        drain(socket: Socket<TcpConnectionData>): void;
     };
-    /** Get connection count */
     getConnectionCount(): number;
-    /** Broadcast to all connections */
     broadcast(message: unknown): void;
-    /** Stop the server */
     stop(): void;
 };
 export type TcpServer = ReturnType<typeof createTcpServer>;
-export {};