heartbeat: TimerHandle | null;

watchdogTimer: TimerHandle | null;

lastInboundAt: number | null;

lastTransportActivityAt: number;

handledMessages: number;

unregisterUnhandled: (() => void) | null;

unregisterTransportActivity: (() => void) | null;

backgroundTasks: Set<Promise<unknown>>;

closePromise: Promise<WebListenerCloseReason>;

resolveClose: (reason: WebListenerCloseReason) => void;

connectionId: string;

startedAt: number;

lastInboundAt: number | null;

lastTransportActivityAt: number;

handledMessages: number;

reconnectAttempts: number;

uptimeMs: number;

return new Promise<T>(() => {});

}

type SocketActivityEmitter = {

on?: (event: string, listener: (...args: unknown[]) => void) => void;

off?: (event: string, listener: (...args: unknown[]) => void) => void;

removeListener?: (event: string, listener: (...args: unknown[]) => void) => void;

};

function createLiveConnection(params: {

connectionId: string;

sock: WASocket;

heartbeat: null,

watchdogTimer: null,

lastInboundAt: null,

lastTransportActivityAt: Date.now(),

handledMessages: 0,

unregisterUnhandled: null,

unregisterTransportActivity: null,

backgroundTasks: new Set<Promise<unknown>>(),

closePromise,

resolveClose: resolveClosePromise,

private readonly heartbeatSeconds: number;

private readonly keepAlive: boolean;

private readonly messageTimeoutMs: number;

private readonly appSilenceTimeoutMs: number;

private readonly watchdogCheckMs: number;

private readonly verbose: boolean;

private readonly abortSignal?: AbortSignal;

this.keepAlive = params.keepAlive;

this.heartbeatSeconds = params.heartbeatSeconds;

this.messageTimeoutMs = params.messageTimeoutMs;

this.appSilenceTimeoutMs = Math.max(params.messageTimeoutMs, params.messageTimeoutMs * 4);

this.watchdogCheckMs = params.watchdogCheckMs;

this.reconnectPolicy = params.reconnectPolicy;

this.abortSignal = params.abortSignal;

}

this.current.handledMessages += 1;

this.current.lastInboundAt = timestamp;

this.current.lastTransportActivityAt = timestamp;

}

noteTransportActivity(timestamp = Date.now()): void {

if (!this.current) {

return;

}

this.current.lastTransportActivityAt = timestamp;

}

getCurrentSnapshot(

connectionId: connection.connectionId,

startedAt: connection.startedAt,

lastInboundAt: connection.lastInboundAt,

lastTransportActivityAt: connection.lastTransportActivityAt,

handledMessages: connection.handledMessages,

reconnectAttempts: this.reconnectAttempts,

uptimeMs: Date.now() - connection.startedAt,

const listener = await params.createListener({ sock, connection });

connection.listener = listener;

this.current = connection;

connection.unregisterTransportActivity = this.attachTransportActivityListener(sock);

registerWhatsAppConnectionController(this.accountId, this);

this.startTimers(connection, {

onHeartbeat: params.onHeartbeat,

if (connection?.unregisterUnhandled) {

connection.unregisterUnhandled();

}

connection?.unregisterTransportActivity?.();

throw err;

}

}

this.socketRef.current = null;

}

connection.unregisterUnhandled?.();

connection.unregisterTransportActivity?.();

if (connection.heartbeat) {

clearInterval(connection.heartbeat);

}

}, this.heartbeatSeconds * 1000);

connection.watchdogTimer = setInterval(() => {

const baselineAt = connection.lastInboundAt ?? connection.startedAt;

const staleForMs = Date.now() - baselineAt;

if (staleForMs <= this.messageTimeoutMs) {

const now = Date.now();

const transportStaleForMs = now - connection.lastTransportActivityAt;

const appBaselineAt = connection.lastInboundAt ?? connection.startedAt;

const appSilentForMs = now - appBaselineAt;

if (

transportStaleForMs <= this.messageTimeoutMs &&

appSilentForMs <= this.appSilenceTimeoutMs

) {

return;

}

const snapshot = this.getCurrentSnapshot(connection);

}, this.watchdogCheckMs);

}

private attachTransportActivityListener(sock: WASocket): (() => void) | null {

const ws = sock.ws as SocketActivityEmitter | undefined;

if (!ws || typeof ws.on !== "function") {

return null;

}

const noteActivity = () => this.noteTransportActivity();

ws.on("frame", noteActivity);

return () => {

if (typeof ws.off === "function") {

ws.off("frame", noteActivity);

return;

}

ws.removeListener?.("frame", noteActivity);

};

}

private stopDisconnectRetries(): void {

if (!this.disconnectRetryController.signal.aborted) {

this.disconnectRetryController.abort();