bunqueue 2.8.53 → 2.8.56

package/dist/infrastructure/server/protocol/commands.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from '../../../domain/types/command';
+import { type Response } from '../../../domain/types/response';
+import type { ConnectionState } from '../types/protocol';
+export declare function parseCommand(data: string): Command | null;
+export declare function serializeResponse(response: Response): string;
+export declare function parseCommands(data: string): Command[];
+export declare function createConnectionState(clientId: string): ConnectionState;
+export declare function errorResponse(message: string, requestId?: string): string;

package/dist/infrastructure/server/protocol/commands.js

@@ -0,0 +1,31 @@
+import { error } from '../../../domain/types/response';
+export function parseCommand(data) {
+    try {
+        const parsed = JSON.parse(data);
+        if (!parsed['cmd'])
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function serializeResponse(response) {
+    return JSON.stringify(response);
+}
+export function parseCommands(data) {
+    const lines = data.split('\n').filter((line) => line.trim().length > 0);
+    const commands = [];
+    for (const line of lines) {
+        const command = parseCommand(line);
+        if (command)
+            commands.push(command);
+    }
+    return commands;
+}
+export function createConnectionState(clientId) {
+    return { authenticated: false, clientId };
+}
+export function errorResponse(message, requestId) {
+    return serializeResponse(error(message, requestId));
+}

package/dist/infrastructure/server/protocol/frameParser.d.ts

@@ -0,0 +1,16 @@
+export declare const MAX_FRAME_SIZE: number;
+export declare class FrameSizeError extends Error {
+    readonly requestedSize: number;
+    readonly maxSize: number;
+    constructor(requestedSize: number, maxSize: number);
+}
+export declare class FrameParser {
+    private buffer;
+    private readonly maxFrameSize;
+    constructor(maxFrameSize?: number);
+    addData(data: Uint8Array): Uint8Array[];
+    get bufferedBytes(): number;
+    get hasPartialFrame(): boolean;
+    clear(): void;
+    static frame(data: Uint8Array): Uint8Array;
+}

package/dist/infrastructure/server/protocol/frameParser.js

@@ -0,0 +1,65 @@
+export const MAX_FRAME_SIZE = 64 * 1024 * 1024;
+export class FrameSizeError extends Error {
+    requestedSize;
+    maxSize;
+    constructor(requestedSize, maxSize) {
+        super(`Frame size ${requestedSize} exceeds maximum allowed size ${maxSize}`);
+        this.requestedSize = requestedSize;
+        this.maxSize = maxSize;
+        this.name = 'FrameSizeError';
+    }
+}
+export class FrameParser {
+    buffer = new Uint8Array(0);
+    maxFrameSize;
+    constructor(maxFrameSize = MAX_FRAME_SIZE) {
+        this.maxFrameSize = maxFrameSize;
+    }
+    addData(data) {
+        const buffer = new Uint8Array(this.buffer.length + data.length);
+        buffer.set(this.buffer);
+        buffer.set(data, this.buffer.length);
+        const frames = [];
+        let offset = 0;
+        while (buffer.length - offset >= 4) {
+            const length = ((buffer[offset] << 24) |
+                (buffer[offset + 1] << 16) |
+                (buffer[offset + 2] << 8) |
+                buffer[offset + 3]) >>>
+                0;
+            if (length > this.maxFrameSize) {
+                this.buffer = new Uint8Array(0);
+                throw new FrameSizeError(length, this.maxFrameSize);
+            }
+            if (buffer.length - offset < 4 + length)
+                break;
+            frames.push(buffer.slice(offset + 4, offset + 4 + length));
+            offset += 4 + length;
+        }
+        if (offset >= buffer.length)
+            this.buffer = new Uint8Array(0);
+        else if (offset === 0)
+            this.buffer = buffer;
+        else
+            this.buffer = buffer.slice(offset);
+        return frames;
+    }
+    get bufferedBytes() {
+        return this.buffer.length;
+    }
+    get hasPartialFrame() {
+        return this.buffer.length > 0;
+    }
+    clear() {
+        this.buffer = new Uint8Array(0);
+    }
+    static frame(data) {
+        const frame = new Uint8Array(4 + data.length);
+        frame[0] = (data.length >> 24) & 0xff;
+        frame[1] = (data.length >> 16) & 0xff;
+        frame[2] = (data.length >> 8) & 0xff;
+        frame[3] = data.length & 0xff;
+        frame.set(data, 4);
+        return frame;
+    }
+}

package/dist/infrastructure/server/protocol/lineBuffer.d.ts

@@ -0,0 +1,6 @@
+export declare class LineBuffer {
+    private buffer;
+    addData(data: string): string[];
+    getRemaining(): string;
+    clear(): void;
+}

package/dist/infrastructure/server/protocol/lineBuffer.js

@@ -0,0 +1,21 @@
+export class LineBuffer {
+    buffer = '';
+    addData(data) {
+        this.buffer += data;
+        const lines = [];
+        let newlineIndex;
+        while ((newlineIndex = this.buffer.indexOf('\n')) !== -1) {
+            const line = this.buffer.slice(0, newlineIndex).trim();
+            this.buffer = this.buffer.slice(newlineIndex + 1);
+            if (line.length > 0)
+                lines.push(line);
+        }
+        return lines;
+    }
+    getRemaining() {
+        return this.buffer;
+    }
+    clear() {
+        this.buffer = '';
+    }
+}

package/dist/infrastructure/server/protocol/validation.d.ts

@@ -0,0 +1,9 @@
+export declare function validateQueueName(name: string): string | null;
+export declare function validateJobData(data: unknown): string | null;
+export declare function validateNumericField(value: unknown, name: string, options?: {
+    min?: number;
+    max?: number;
+    required?: boolean;
+}): string | null;
+export declare function validateBackoffField(value: unknown): string | null;
+export declare function validateJobOptions(options: Record<string, unknown>): string | null;

package/dist/infrastructure/server/protocol/validation.js

@@ -0,0 +1,75 @@
+export function validateQueueName(name) {
+    if (!name || name.length === 0)
+        return 'Queue name is required';
+    if (name.length > 256)
+        return 'Queue name too long (max 256 characters)';
+    if (!/^[a-zA-Z0-9_\-.:]+$/.test(name))
+        return 'Queue name contains invalid characters';
+    return null;
+}
+export function validateJobData(data) {
+    let json;
+    try {
+        json = JSON.stringify(data);
+    }
+    catch {
+        return 'Job data must be JSON serializable';
+    }
+    if (json !== undefined && json.length > 10 * 1024 * 1024) {
+        return 'Job data too large (max 10MB)';
+    }
+    return null;
+}
+export function validateNumericField(value, name, options = {}) {
+    const { min = 0, max = Number.MAX_SAFE_INTEGER, required = false } = options;
+    if (value === undefined || value === null)
+        return required ? `${name} is required` : null;
+    if (typeof value !== 'number')
+        return `${name} must be a number`;
+    if (!Number.isFinite(value))
+        return `${name} must be a finite number`;
+    if (!Number.isInteger(value) &&
+        (name === 'priority' || name === 'attempts' || name === 'maxAttempts')) {
+        return `${name} must be an integer`;
+    }
+    if (value < min)
+        return `${name} must be at least ${min}`;
+    if (value > max)
+        return `${name} must be at most ${max}`;
+    return null;
+}
+export function validateBackoffField(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value === 'object') {
+        const object = value;
+        if (object['type'] !== 'fixed' && object['type'] !== 'exponential') {
+            return "backoff.type must be 'fixed' or 'exponential'";
+        }
+        return validateNumericField(object['delay'], 'backoff.delay', {
+            min: 0,
+            max: 24 * 60 * 60 * 1000,
+            required: true,
+        });
+    }
+    return validateNumericField(value, 'backoff', { min: 0, max: 24 * 60 * 60 * 1000 });
+}
+export function validateJobOptions(options) {
+    const validations = [
+        validateNumericField(options['priority'], 'priority', { min: -1000000, max: 1000000 }),
+        validateNumericField(options['delay'], 'delay', { min: 0, max: 365 * 24 * 60 * 60 * 1000 }),
+        validateNumericField(options['timeout'], 'timeout', { min: 0, max: 24 * 60 * 60 * 1000 }),
+        validateNumericField(options['maxAttempts'], 'maxAttempts', { min: 1, max: 1000 }),
+        validateBackoffField(options['backoff']),
+        validateNumericField(options['ttl'], 'ttl', { min: 0, max: 365 * 24 * 60 * 60 * 1000 }),
+        validateNumericField(options['stallTimeout'], 'stallTimeout', {
+            min: 0,
+            max: 24 * 60 * 60 * 1000,
+        }),
+    ];
+    for (const error of validations) {
+        if (error)
+            return error;
+    }
+    return null;
+}

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

@@ -1,78 +1,6 @@
-/**
- * Protocol Parser
- * Handles JSON text protocol parsing and serialization
- */
-import type { Command } from '../../domain/types/command';
-import { type Response } from '../../domain/types/response';
-/** Parse a command from JSON string */
-export declare function parseCommand(data: string): Command | null;
-/** Serialize response to JSON string */
-export declare function serializeResponse(response: Response): string;
-/** Parse multiple commands from newline-delimited JSON */
-export declare function parseCommands(data: string): Command[];
-/** Validate queue name */
-export declare function validateQueueName(name: string): string | null;
-/** Validate job data size */
-export declare function validateJobData(data: unknown): string | null;
-/** Validate a numeric field is within safe bounds */
-export declare function validateNumericField(value: unknown, name: string, options?: {
-    min?: number;
-    max?: number;
-    required?: boolean;
-}): string | null;
-/**
- * Validate the backoff field, which the public JobOptions type allows in two
- * forms: a plain number (delay ms) or `{ type: 'fixed' | 'exponential', delay
- * }`. Embedded mode already accepts both (domain parseBackoff); the TCP path
- * must too, or the object form throws over the wire while working embedded.
- */
-export declare function validateBackoffField(value: unknown): string | null;
-/** Validate job options numeric fields */
-export declare function validateJobOptions(options: Record<string, unknown>): string | null;
-/** Re-export from shared module for backward compatibility */
+export { createConnectionState, errorResponse, parseCommand, parseCommands, serializeResponse, } from './protocol/commands';
+export { FrameParser, FrameSizeError, MAX_FRAME_SIZE } from './protocol/frameParser';
+export { LineBuffer } from './protocol/lineBuffer';
+export { validateBackoffField, validateJobData, validateJobOptions, validateNumericField, validateQueueName, } from './protocol/validation';
+export type { ConnectionState } from './types/protocol';
 export { validateWebhookUrl } from '../../shared/webhookValidation';
-/** Connection state */
-export interface ConnectionState {
-    authenticated: boolean;
-    clientId: string;
-}
-/** Create initial connection state */
-export declare function createConnectionState(clientId: string): ConnectionState;
-/** Error response helper */
-export declare function errorResponse(message: string, reqId?: string): string;
-/** Line buffer for TCP connections */
-export declare class LineBuffer {
-    private buffer;
-    /** Add data to buffer and extract complete lines */
-    addData(data: string): string[];
-    /** Get remaining buffer content */
-    getRemaining(): string;
-    /** Clear buffer */
-    clear(): void;
-}
-/** Maximum allowed frame size (64MB) - prevents memory exhaustion DoS */
-export declare const MAX_FRAME_SIZE: number;
-/** Error thrown when frame size exceeds maximum */
-export declare class FrameSizeError extends Error {
-    readonly requestedSize: number;
-    readonly maxSize: number;
-    constructor(requestedSize: number, maxSize: number);
-}
-/** Binary protocol frame parser */
-export declare class FrameParser {
-    private buffer;
-    private readonly maxFrameSize;
-    constructor(maxFrameSize?: number);
-    /** Add data and extract complete frames
-     * @throws {FrameSizeError} if frame length exceeds maxFrameSize
-     */
-    addData(data: Uint8Array): Uint8Array[];
-    /** Number of bytes currently buffered awaiting a complete frame. */
-    get bufferedBytes(): number;
-    /** True while a partial (incomplete) frame is buffered. */
-    get hasPartialFrame(): boolean;
-    /** Clear the internal buffer */
-    clear(): void;
-    /** Create a framed message */
-    static frame(data: Uint8Array): Uint8Array;
-}

package/dist/infrastructure/server/protocol.js

@@ -1,266 +1,5 @@
-/**
- * Protocol Parser
- * Handles JSON text protocol parsing and serialization
- */
-import { error } from '../../domain/types/response';
-/** Parse a command from JSON string */
-export function parseCommand(data) {
-    try {
-        const parsed = JSON.parse(data);
-        if (!parsed['cmd']) {
-            return null;
-        }
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-/** Serialize response to JSON string */
-export function serializeResponse(response) {
-    return JSON.stringify(response);
-}
-/** Parse multiple commands from newline-delimited JSON */
-export function parseCommands(data) {
-    const lines = data.split('\n').filter((line) => line.trim().length > 0);
-    const commands = [];
-    for (const line of lines) {
-        const cmd = parseCommand(line);
-        if (cmd) {
-            commands.push(cmd);
-        }
-    }
-    return commands;
-}
-/** Validate queue name */
-export function validateQueueName(name) {
-    if (!name || name.length === 0) {
-        return 'Queue name is required';
-    }
-    if (name.length > 256) {
-        return 'Queue name too long (max 256 characters)';
-    }
-    if (!/^[a-zA-Z0-9_\-.:]+$/.test(name)) {
-        return 'Queue name contains invalid characters';
-    }
-    return null;
-}
-/** Validate job data size */
-export function validateJobData(data) {
-    const json = JSON.stringify(data);
-    if (json.length > 10 * 1024 * 1024) {
-        return 'Job data too large (max 10MB)';
-    }
-    return null;
-}
-/** Validate a numeric field is within safe bounds */
-export function validateNumericField(value, name, options = {}) {
-    const { min = 0, max = Number.MAX_SAFE_INTEGER, required = false } = options;
-    if (value === undefined || value === null) {
-        return required ? `${name} is required` : null;
-    }
-    if (typeof value !== 'number') {
-        return `${name} must be a number`;
-    }
-    if (!Number.isFinite(value)) {
-        return `${name} must be a finite number`;
-    }
-    if (!Number.isInteger(value) &&
-        (name === 'priority' || name === 'attempts' || name === 'maxAttempts')) {
-        return `${name} must be an integer`;
-    }
-    if (value < min) {
-        return `${name} must be at least ${min}`;
-    }
-    if (value > max) {
-        return `${name} must be at most ${max}`;
-    }
-    return null;
-}
-/**
- * Validate the backoff field, which the public JobOptions type allows in two
- * forms: a plain number (delay ms) or `{ type: 'fixed' | 'exponential', delay
- * }`. Embedded mode already accepts both (domain parseBackoff); the TCP path
- * must too, or the object form throws over the wire while working embedded.
- */
-export function validateBackoffField(value) {
-    if (value === undefined || value === null)
-        return null;
-    if (typeof value === 'object') {
-        const obj = value;
-        if (obj['type'] !== 'fixed' && obj['type'] !== 'exponential') {
-            return "backoff.type must be 'fixed' or 'exponential'";
-        }
-        return validateNumericField(obj['delay'], 'backoff.delay', {
-            min: 0,
-            max: 24 * 60 * 60 * 1000, // max 1 day
-            required: true,
-        });
-    }
-    return validateNumericField(value, 'backoff', { min: 0, max: 24 * 60 * 60 * 1000 }); // max 1 day
-}
-/** Validate job options numeric fields */
-export function validateJobOptions(options) {
-    const validations = [
-        validateNumericField(options['priority'], 'priority', { min: -1000000, max: 1000000 }),
-        validateNumericField(options['delay'], 'delay', { min: 0, max: 365 * 24 * 60 * 60 * 1000 }), // max 1 year
-        validateNumericField(options['timeout'], 'timeout', { min: 0, max: 24 * 60 * 60 * 1000 }), // max 1 day
-        validateNumericField(options['maxAttempts'], 'maxAttempts', { min: 1, max: 1000 }),
-        validateBackoffField(options['backoff']),
-        validateNumericField(options['ttl'], 'ttl', { min: 0, max: 365 * 24 * 60 * 60 * 1000 }), // max 1 year
-        validateNumericField(options['stallTimeout'], 'stallTimeout', {
-            min: 0,
-            max: 24 * 60 * 60 * 1000,
-        }), // max 1 day
-    ];
-    for (const error of validations) {
-        if (error)
-            return error;
-    }
-    return null;
-}
-/** Re-export from shared module for backward compatibility */
+export { createConnectionState, errorResponse, parseCommand, parseCommands, serializeResponse, } from './protocol/commands';
+export { FrameParser, FrameSizeError, MAX_FRAME_SIZE } from './protocol/frameParser';
+export { LineBuffer } from './protocol/lineBuffer';
+export { validateBackoffField, validateJobData, validateJobOptions, validateNumericField, validateQueueName, } from './protocol/validation';
 export { validateWebhookUrl } from '../../shared/webhookValidation';
-/** Create initial connection state */
-export function createConnectionState(clientId) {
-    return {
-        authenticated: false,
-        clientId,
-    };
-}
-/** Error response helper */
-export function errorResponse(message, reqId) {
-    return serializeResponse(error(message, reqId));
-}
-/** Line buffer for TCP connections */
-export class LineBuffer {
-    buffer = '';
-    /** Add data to buffer and extract complete lines */
-    addData(data) {
-        this.buffer += data;
-        const lines = [];
-        let newlineIdx;
-        while ((newlineIdx = this.buffer.indexOf('\n')) !== -1) {
-            const line = this.buffer.slice(0, newlineIdx).trim();
-            this.buffer = this.buffer.slice(newlineIdx + 1);
-            if (line.length > 0) {
-                lines.push(line);
-            }
-        }
-        return lines;
-    }
-    /** Get remaining buffer content */
-    getRemaining() {
-        return this.buffer;
-    }
-    /** Clear buffer */
-    clear() {
-        this.buffer = '';
-    }
-}
-/** Maximum allowed frame size (64MB) - prevents memory exhaustion DoS */
-export const MAX_FRAME_SIZE = 64 * 1024 * 1024;
-/** Error thrown when frame size exceeds maximum */
-export class FrameSizeError extends Error {
-    requestedSize;
-    maxSize;
-    constructor(requestedSize, maxSize) {
-        super(`Frame size ${requestedSize} exceeds maximum allowed size ${maxSize}`);
-        this.requestedSize = requestedSize;
-        this.maxSize = maxSize;
-        this.name = 'FrameSizeError';
-    }
-}
-/** Binary protocol frame parser */
-export class FrameParser {
-    buffer = new Uint8Array(0);
-    maxFrameSize;
-    constructor(maxFrameSize = MAX_FRAME_SIZE) {
-        this.maxFrameSize = maxFrameSize;
-    }
-    /** Add data and extract complete frames
-     * @throws {FrameSizeError} if frame length exceeds maxFrameSize
-     */
-    addData(data) {
-        // Concatenate any buffered partial frame with the new data into a single
-        // owned buffer (one copy). `data` is fully copied here and never retained,
-        // so the caller may safely reuse its read buffer after this returns.
-        const buffer = new Uint8Array(this.buffer.length + data.length);
-        buffer.set(this.buffer);
-        buffer.set(data, this.buffer.length);
-        const frames = [];
-        // Read cursor. Previously the tail was resliced with `buffer.slice(4 + len)`
-        // after EVERY frame — O(tail) per frame, i.e. O(F²) when F frames arrive
-        // coalesced in a single read (deep pipelining / OS segment coalescing). The
-        // cursor advances in O(1) per frame, making the whole pass O(total bytes).
-        let offset = 0;
-        while (buffer.length - offset >= 4) {
-            // Read length prefix (big-endian u32) using unsigned right shift to ensure positive value
-            // Using >>> 0 at the end converts the result to an unsigned 32-bit integer
-            const length = ((buffer[offset] << 24) |
-                (buffer[offset + 1] << 16) |
-                (buffer[offset + 2] << 8) |
-                buffer[offset + 3]) >>>
-                0;
-            // Validate frame size to prevent memory exhaustion DoS. A single frame's
-            // declared length can never exceed maxFrameSize (64MB), so the partial
-            // buffer is bounded by maxFrameSize regardless of how it is segmented
-            // across TCP reads. Slowloris (a connection that declares a large frame
-            // then never completes it) is handled at the transport layer by an idle
-            // read timeout in the server, NOT by dropping legal large partial frames.
-            if (length > this.maxFrameSize) {
-                // Clear buffer to prevent further processing of malicious data
-                this.buffer = new Uint8Array(0);
-                throw new FrameSizeError(length, this.maxFrameSize);
-            }
-            if (buffer.length - offset < 4 + length) {
-                // Not enough data for this (legal, < maxFrameSize) frame yet. Keep the
-                // partial bytes buffered until the rest of the frame arrives across
-                // subsequent TCP segments.
-                break;
-            }
-            // Extract frame. The body is copied out (slice) so it never aliases the
-            // retained tail buffer.
-            frames.push(buffer.slice(offset + 4, offset + 4 + length));
-            offset += 4 + length;
-        }
-        // Retain only the unconsumed tail. Three cases mirror the previous behavior
-        // without the per-frame reslice:
-        //  - fully drained: a fresh empty buffer (do not pin the read's ArrayBuffer)
-        //  - nothing consumed: keep the concat buffer as-is (no extra copy)
-        //  - partial leftover after ≥1 frame: copy the small tail (no aliasing)
-        if (offset >= buffer.length) {
-            this.buffer = new Uint8Array(0);
-        }
-        else if (offset === 0) {
-            this.buffer = buffer;
-        }
-        else {
-            this.buffer = buffer.slice(offset);
-        }
-        return frames;
-    }
-    /** Number of bytes currently buffered awaiting a complete frame. */
-    get bufferedBytes() {
-        return this.buffer.length;
-    }
-    /** True while a partial (incomplete) frame is buffered. */
-    get hasPartialFrame() {
-        return this.buffer.length > 0;
-    }
-    /** Clear the internal buffer */
-    clear() {
-        this.buffer = new Uint8Array(0);
-    }
-    /** Create a framed message */
-    static frame(data) {
-        const frame = new Uint8Array(4 + data.length);
-        // Write length prefix (big-endian u32)
-        frame[0] = (data.length >> 24) & 0xff;
-        frame[1] = (data.length >> 16) & 0xff;
-        frame[2] = (data.length >> 8) & 0xff;
-        frame[3] = data.length & 0xff;
-        frame.set(data, 4);
-        return frame;
-    }
-}

package/dist/infrastructure/server/rateLimiter.js

@@ -96,6 +96,7 @@ export class ProtocolRateLimiter {
             this.cleanupInterval = setInterval(() => {
                 this.cleanup();
             }, this.config.cleanupIntervalMs);
+            this.cleanupInterval.unref();
         }
     }
     /** Clean up old entries - O(n) but runs infrequently */

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

@@ -48,7 +48,7 @@ export declare class SocketWriteQueue {
      * Call from the socket's `drain` handler. Stops at the first short write,
      * leaving the remainder queued for the next drain.
      */
-    flush(socket: WritableSocket): void;
+    flush(socket: WritableSocket): boolean;
     /** Number of bytes still buffered awaiting drain. */
     get bytesQueued(): number;
     /** Whether there is unwritten data awaiting drain. */

package/dist/infrastructure/server/socketWriteQueue.js

@@ -84,23 +84,26 @@ export class SocketWriteQueue {
                 written = socket.write(view);
             }
             catch {
-                return;
+                return false;
             }
-            if (written <= 0) {
-                // Socket not ready / closed; wait for the next drain.
-                return;
+            if (written < 0)
+                return false;
+            if (written === 0) {
+                // Socket is still backpressured; wait for the next drain.
+                return true;
             }
             if (written < view.length) {
                 // Still backpressured: advance offset within the current chunk.
                 this.offset += written;
                 this.queuedBytes -= written;
-                return;
+                return true;
             }
             // Whole chunk flushed.
             this.queuedBytes -= view.length;
             this.pending.shift();
             this.offset = 0;
         }
+        return true;
     }
     /** Number of bytes still buffered awaiting drain. */
     get bytesQueued() {

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

@@ -0,0 +1,5 @@
+export declare const sseTextEncoder: TextEncoder;
+export declare const MAX_SSE_CLIENTS = 1000;
+export declare const SSE_HEARTBEAT_MS = 30000;
+export declare const SSE_RETRY_MS = 3000;
+export declare const SSE_EVENT_BUFFER_SIZE = 1000;

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

@@ -0,0 +1,5 @@
+export const sseTextEncoder = new TextEncoder();
+export const MAX_SSE_CLIENTS = 1000;
+export const SSE_HEARTBEAT_MS = 30_000;
+export const SSE_RETRY_MS = 3_000;
+export const SSE_EVENT_BUFFER_SIZE = 1000;

package/dist/infrastructure/server/sse/eventBuffer.d.ts

@@ -0,0 +1,3 @@
+import type { BufferedSseEvent, SseClient } from '../types/sse';
+export declare function bufferSseEvent(buffer: BufferedSseEvent[], event: BufferedSseEvent): void;
+export declare function replaySseEvents(buffer: readonly BufferedSseEvent[], client: SseClient, lastEventId: number): void;