checkServerIdentity?: (servername: string, cert: CertMeta) => Error | undefined;

};

export type GatewayReconnectPausedInfo = {

code: number;

reason: string;

detailCode: string | null;

};

export class GatewayClientRequestError extends Error {

readonly gatewayCode: string;

readonly details?: unknown;

onEvent?: (evt: EventFrame) => void;

onHelloOk?: (hello: HelloOk) => void;

onConnectError?: (err: Error) => void;

onReconnectPaused?: (info: GatewayReconnectPausedInfo) => void;

onClose?: (code: number, reason: string) => void;

onGap?: (info: { expected: number; received: number }) => void;

};

private connectNonce: string | null = null;

private connectSent = false;

private connectTimer: NodeJS.Timeout | null = null;

private reconnectTimer: NodeJS.Timeout | null = null;

private pendingDeviceTokenRetry = false;

private deviceTokenRetryBudgetUsed = false;

private pendingConnectErrorDetailCode: string | null = null;

if (this.closed) {

return;

}

this.clearReconnectTimer();

this.clearConnectChallengeTimeout();

this.connectNonce = null;

this.connectSent = false;

}

this.flushPendingErrors(new Error(`gateway closed (${code}): ${reasonText}`));

if (this.shouldPauseReconnectAfterAuthFailure(connectErrorDetailCode)) {

this.opts.onReconnectPaused?.({

code,

reason: reasonText,

detailCode: connectErrorDetailCode,

});

this.opts.onClose?.(code, reasonText);

return;

}

this.pendingDeviceTokenRetry = false;

this.deviceTokenRetryBudgetUsed = false;

this.pendingConnectErrorDetailCode = null;

this.clearReconnectTimer();

if (this.tickTimer) {

clearInterval(this.tickTimer);

this.tickTimer = null;

}

}

private clearReconnectTimer() {

if (this.reconnectTimer) {

clearTimeout(this.reconnectTimer);

this.reconnectTimer = null;

}

}

private armConnectChallengeTimeout() {

const connectChallengeTimeoutMs = resolveGatewayClientConnectChallengeTimeoutMs(this.opts);

const armedAt = Date.now();

clearInterval(this.tickTimer);

this.tickTimer = null;

}

this.clearReconnectTimer();

const delay = this.backoffMs;

this.backoffMs = Math.min(this.backoffMs * 2, 30_000);

setTimeout(() => this.start(), delay).unref();

this.reconnectTimer = setTimeout(() => {

this.reconnectTimer = null;

this.start();

}, delay);

}

private flushPendingErrors(err: Error) {