Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

feat(desktop): add per-account engine sessions

Hampus099f147104fb
diff --git a/fluxer_desktop/src/engine/AccountSession.ts b/fluxer_desktop/src/engine/AccountSession.ts
new file mode 100644
index 000000000..f9a19c0c3
--- /dev/null
+++ b/fluxer_desktop/src/engine/AccountSession.ts
@@ -0,0 +1,819 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {createHash} from 'node:crypto';
+import {errorMessage} from '@electron/common/ErrorMessage';
+import type {DispatchConsumer, DispatchPump} from '@electron/engine/DispatchPump';
+import type {EngineClock} from '@electron/engine/EngineClock';
+import {
+ GatewayClient,
+ type GatewayClientExit,
+ GatewayClose,
+ type GatewayCompressionMode,
+ type GatewayResumeState,
+} from '@electron/engine/GatewayClient';
+import type {GatewayTransportFactory} from '@electron/engine/GatewayTransport';
+import type {EngineAccountRecord, EngineLogLevel} from '@electron/engine/HostProtocol';
+import {SCHEDULER_LIMITS, type SchedulerClient, type SessionScheduler} from '@electron/engine/SessionScheduler';
+import {
+ ACCOUNT_ENGINE_LIMITS,
+ type AccountEngineAccountSummary,
+ AccountEngineCacheState,
+ type AccountEngineClientConfig,
+ AccountEngineConnectionState,
+ type AccountEngineDemotion,
+ AccountEngineErrorCode,
+ type AccountEngineMention,
+ type AccountEngineNotification,
+ type AccountEnginePromotion,
+ AccountEngineRequestError,
+ type AccountEngineSnapshotCapture,
+ type AccountEngineSubscriptionRelease,
+ type AccountEngineUser,
+} from '@fluxer/desktop_ipc/src/AccountEngineContract';
+import type {
+ AccountEngineCore,
+ AccountEngineCoreCounts,
+ AccountEngineRowStore,
+ CreateAccountEngineCore,
+} from '@fluxer/desktop_ipc/src/AccountEngineCoreContract';
+
+const INBOUND_QUEUE_MAX_BYTES = 32 * 1024 * 1024;
+const NOTIFICATION_MAX_AGE_MS = 2 * 60 * 1000;
+const NOTIFICATION_BURST = 5;
+const NOTIFICATION_REFILL_MS = 1_000;
+const INVALID_SESSION_MIN_DELAY_MS = 1_000;
+const INVALID_SESSION_MAX_DELAY_MS = 5_000;
+const DECODE_RETRY_DELAY_MS = 1_000;
+const SUBSCRIPTION_RELEASE_SETTLE_MS = 250;
+
+export interface AdmittedGateway {
+ readonly url: string;
+ readonly address: string | null;
+}
+
+export interface AccountSessionDependencies {
+ readonly clock: EngineClock;
+ readonly scheduler: SessionScheduler;
+ readonly pump: DispatchPump;
+ readonly transport: GatewayTransportFactory;
+ readonly store: AccountEngineRowStore;
+ readonly createCore: CreateAccountEngineCore;
+ readonly admit: (accountKey: string, url: string) => Promise<AdmittedGateway>;
+ readonly config: () => AccountEngineClientConfig | null;
+ readonly commitCache: () => void;
+ readonly onSummaryChanged: (session: AccountSession) => void;
+ readonly onNotification: (notification: AccountEngineNotification) => void;
+ readonly onMention: (accountKey: string, mention: AccountEngineMention) => void;
+ readonly onChannelRead: (accountKey: string, channelId: string) => void;
+ readonly onAuthFailed: (accountKey: string, tokenTag: string) => void;
+ readonly onTokenRotated: (accountKey: string, previousToken: string, token: string) => void;
+ readonly log: (level: EngineLogLevel, message: string, detail?: unknown) => void;
+}
+
+interface InboundDispatch {
+ readonly type: string;
+ readonly data: unknown;
+ readonly sequence: number | null;
+ readonly bytes: number;
+ readonly client: GatewayClient;
+}
+
+export interface PersistedAccountSummary extends AccountEngineAccountSummary {
+ readonly mentionCounts?: Readonly<Record<string, number>>;
+}
+
+export function accountTokenTag(token: string): string {
+ return createHash('sha256').update(token, 'utf8').digest('hex').slice(0, 32);
+}
+
+function estimateCaptureBytes(capture: AccountEngineSnapshotCapture): number {
+ let bytes = 0;
+ for (const [entity, rows] of Object.entries(capture.entries)) {
+ bytes += entity.length;
+ for (const [key, value] of Object.entries(rows)) {
+ bytes += key.length + value.length;
+ }
+ }
+ return bytes;
+}
+
+export class AccountSession implements SchedulerClient, DispatchConsumer {
+ readonly accountKey: string;
+ private record: EngineAccountRecord;
+ private token: string;
+ private readonly deps: AccountSessionDependencies;
+ private readonly core: AccountEngineCore;
+ private state: AccountEngineConnectionState = AccountEngineConnectionState.STARTING;
+ private stateChangedAt: number;
+ private nextRetryAt: number | null = null;
+ private user: AccountEngineUser | null;
+ private counts: AccountEngineCoreCounts = {
+ mentionCount: 0,
+ unreadChannelCount: 0,
+ lastMessageAt: null,
+ degraded: false,
+ };
+ private cache: AccountEngineCacheState = AccountEngineCacheState.EMPTY;
+ private cacheUpdatedAt: number | null = null;
+ private revision = 0;
+ private client: GatewayClient | null = null;
+ private connecting = false;
+ private resume: GatewayResumeState | null = null;
+ private handedOff: GatewayResumeState | null = null;
+ private subscriptionRelease: AccountEngineSubscriptionRelease | null = null;
+ private releaseSentAt: number | null = null;
+ private admittedUrl: string | null = null;
+ private compression: GatewayCompressionMode = 'zstd-stream';
+ private attempt = 0;
+ private queue: Array<InboundDispatch> = [];
+ private queueHead = 0;
+ private queueBytes = 0;
+ private held = false;
+ private stopped = false;
+ private mutex: Promise<unknown> = Promise.resolve();
+ private supersededToken: string | null = null;
+ private failedTokenTag: string | null = null;
+ private handshakeSucceeded = false;
+ private invalidations = 0;
+ private notificationTokens = NOTIFICATION_BURST;
+ private notificationsRefilledAt: number;
+
+ private readonly persistedMentionCounts: Readonly<Record<string, number>> | null;
+
+ constructor(
+ record: EngineAccountRecord,
+ deps: AccountSessionDependencies,
+ persisted: PersistedAccountSummary | null,
+ ) {
+ this.accountKey = record.accountKey;
+ this.record = record;
+ this.token = record.token;
+ this.deps = deps;
+ this.stateChangedAt = deps.clock.now();
+ this.notificationsRefilledAt = this.stateChangedAt;
+ this.user = persisted?.user ?? null;
+ this.persistedMentionCounts = persisted?.mentionCounts ?? null;
+ if (persisted !== null) {
+ this.cache = persisted.cache;
+ this.cacheUpdatedAt = persisted.cacheUpdatedAt;
+ this.counts = {
+ mentionCount: persisted.mentionCount,
+ unreadChannelCount: persisted.unreadChannelCount,
+ lastMessageAt: persisted.lastMessageAt,
+ degraded: persisted.degraded,
+ };
+ }
+ this.core = deps.createCore({
+ accountKey: record.accountKey,
+ userId: record.userId,
+ store: deps.store,
+ onCountsChanged: (counts) => {
+ this.counts = counts;
+ this.touch();
+ },
+ onNotification: (notification) => {
+ if (this.admitNotification(notification.message)) {
+ this.deps.onNotification({...notification, accountKey: this.accountKey});
+ }
+ },
+ onMention: (mention) => this.deps.onMention(this.accountKey, mention),
+ onChannelRead: (channelId) => this.deps.onChannelRead(this.accountKey, channelId),
+ onSelfUser: (user) => {
+ if (JSON.stringify(user) !== JSON.stringify(this.user)) {
+ this.user = user;
+ this.touch();
+ }
+ },
+ onTokenRotated: (token) => this.rotateToken(token),
+ onInvalid: (error) => {
+ this.invalidations += 1;
+ this.deps.log('warn', 'Account engine cache invalidated', {accountKey: this.accountKey, error: error.message});
+ this.cache = AccountEngineCacheState.STALE;
+ this.touch();
+ },
+ });
+ }
+
+ get origin(): string {
+ return this.record.instanceKey;
+ }
+
+ get priority(): number {
+ return this.record.lastActive;
+ }
+
+ get resuming(): boolean {
+ return this.resume !== null;
+ }
+
+ get connectionState(): AccountEngineConnectionState {
+ return this.state;
+ }
+
+ get currentToken(): string {
+ return this.token;
+ }
+
+ get resumeState(): GatewayResumeState | null {
+ return this.resume;
+ }
+
+ get isHeld(): boolean {
+ return this.held;
+ }
+
+ get authFailedTokenTag(): string | null {
+ return this.state === AccountEngineConnectionState.AUTH_FAILED ? this.failedTokenTag : null;
+ }
+
+ start(options: {held: boolean}): void {
+ this.held = options.held;
+ try {
+ if (this.core.seedFromStore(this.persistedMentionCounts)) {
+ this.cache = AccountEngineCacheState.LIVE;
+ this.cacheUpdatedAt = this.deps.store.readCursor(this.accountKey)?.updatedAt ?? null;
+ }
+ } catch (error) {
+ this.deps.log('warn', 'Account engine could not seed from its cache', {
+ accountKey: this.accountKey,
+ error: String(error),
+ });
+ this.cache = AccountEngineCacheState.STALE;
+ }
+ if (!this.record.isValid) {
+ this.setState(AccountEngineConnectionState.AUTH_FAILED);
+ return;
+ }
+ if (this.held) {
+ this.setState(AccountEngineConnectionState.FOREGROUND);
+ return;
+ }
+ this.requestConnect();
+ }
+
+ serialize<T>(run: () => Promise<T> | T): Promise<T> {
+ const next = this.mutex.then(run, run);
+ this.mutex = next.catch(() => undefined);
+ return next;
+ }
+
+ updateRecord(record: EngineAccountRecord): void {
+ const previous = this.record;
+ this.record = record;
+ if (this.stopped) {
+ return;
+ }
+ if (!record.isValid) {
+ this.disconnect(GatewayClose.NORMAL, 'account invalid');
+ this.resume = null;
+ this.setState(AccountEngineConnectionState.AUTH_FAILED);
+ return;
+ }
+ if (record.token === this.token) {
+ this.supersededToken = null;
+ }
+ const tokenChanged = record.token !== this.token && record.token !== this.supersededToken;
+ const endpointChanged = record.gatewayEndpoint !== previous.gatewayEndpoint;
+ const recovered = this.state === AccountEngineConnectionState.AUTH_FAILED && (tokenChanged || !previous.isValid);
+ if (tokenChanged) {
+ this.token = record.token;
+ this.supersededToken = null;
+ }
+ if (!tokenChanged && !endpointChanged && !recovered) {
+ return;
+ }
+ this.resume = null;
+ this.admittedUrl = null;
+ if (this.held) {
+ return;
+ }
+ this.disconnect(GatewayClose.NORMAL, 'account changed');
+ this.attempt = 0;
+ this.requestConnect();
+ }
+
+ configChanged(): void {
+ if (this.state === AccountEngineConnectionState.STARTING && !this.held && !this.stopped && !this.connecting) {
+ this.requestConnect();
+ }
+ }
+
+ claimForeground(): void {
+ if (this.held || this.stopped) {
+ return;
+ }
+ this.deps.scheduler.cancel(this.accountKey);
+ this.cancelRetryTimer();
+ this.nextRetryAt = null;
+ this.disconnect(GatewayClose.NORMAL, 'claimed by the renderer');
+ this.resume = null;
+ this.handedOff = null;
+ this.subscriptionRelease = null;
+ this.held = true;
+ if (this.record.isValid) {
+ this.setState(AccountEngineConnectionState.FOREGROUND);
+ }
+ }
+
+ releaseHold(): void {
+ if (!this.held || this.stopped) {
+ return;
+ }
+ this.held = false;
+ if (this.resume === null) {
+ this.resume = this.handedOff;
+ }
+ this.handedOff = null;
+ this.attempt = 0;
+ if (this.record.isValid) {
+ this.requestConnect();
+ } else {
+ this.setState(AccountEngineConnectionState.AUTH_FAILED);
+ }
+ }
+
+ beginPromotion(): AccountEnginePromotion {
+ if (this.stopped) {
+ throw new AccountEngineRequestError(AccountEngineErrorCode.UNKNOWN_ACCOUNT, 'The account was removed');
+ }
+ this.deps.scheduler.cancel(this.accountKey);
+ this.dropQueue();
+ this.deps.commitCache();
+ const session =
+ this.resume !== null && this.admittedUrl !== null && this.subscriptionRelease === null
+ ? {sessionId: this.resume.sessionId, sequence: this.resume.sequence, gatewayUrl: this.admittedUrl}
+ : null;
+ this.handedOff = this.resume;
+ this.resume = null;
+ this.disconnect(session === null ? GatewayClose.NORMAL : GatewayClose.HANDOFF, 'handoff');
+ this.held = true;
+ this.setState(AccountEngineConnectionState.FOREGROUND);
+ const capture = this.cache === AccountEngineCacheState.LIVE ? this.deps.store.capture(this.accountKey) : null;
+ return {accountKey: this.accountKey, capture, mentionCounts: this.core.mentionCounts(), session};
+ }
+
+ settleSubscriptionRelease(): Promise<void> {
+ const sentAt = this.releaseSentAt;
+ this.releaseSentAt = null;
+ const remainingMs = sentAt === null ? 0 : sentAt + SUBSCRIPTION_RELEASE_SETTLE_MS - this.deps.clock.now();
+ if (remainingMs <= 0) {
+ return Promise.resolve();
+ }
+ return new Promise((resolve) => {
+ this.deps.clock.setTimeout(resolve, remainingMs);
+ });
+ }
+
+ completePromotion(): void {
+ this.handedOff = null;
+ }
+
+ abortPromotion(): void {
+ if (!this.held || this.stopped) {
+ return;
+ }
+ this.resume = this.handedOff;
+ this.handedOff = null;
+ this.held = false;
+ this.attempt = 0;
+ this.requestConnect();
+ }
+
+ async demote(demotion: AccountEngineDemotion): Promise<void> {
+ if (this.stopped) {
+ return;
+ }
+ this.handedOff = null;
+ this.held = false;
+ this.disconnect(GatewayClose.NORMAL, 'replaced by the renderer session');
+ const capture = demotion.capture;
+ if (capture !== null && estimateCaptureBytes(capture) <= ACCOUNT_ENGINE_LIMITS.demotionCaptureMaxBytes) {
+ await new Promise((resolve) => setImmediate(resolve));
+ if (this.stopped) {
+ return;
+ }
+ try {
+ this.core.replaceFromCapture(capture, demotion.mentionCounts);
+ this.deps.commitCache();
+ this.cache = AccountEngineCacheState.LIVE;
+ this.cacheUpdatedAt = capture.cursor.updatedAt;
+ } catch (error) {
+ this.deps.log('warn', 'Account engine could not store a demotion capture', {
+ accountKey: this.accountKey,
+ error: String(error),
+ });
+ this.cache = AccountEngineCacheState.STALE;
+ }
+ }
+ const session = demotion.session;
+ this.resume = session === null ? null : {sessionId: session.sessionId, sequence: session.sequence};
+ this.subscriptionRelease = session === null ? null : demotion.release;
+ this.attempt = 0;
+ if (this.record.isValid) {
+ this.requestConnect();
+ } else {
+ this.setState(AccountEngineConnectionState.AUTH_FAILED);
+ }
+ }
+
+ reconnect(): void {
+ if (this.stopped || this.held || !this.record.isValid) {
+ return;
+ }
+ this.attempt = 0;
+ this.disconnect(GatewayClose.ZOMBIE, 'reconnect');
+ this.requestConnect();
+ }
+
+ probe(): void {
+ this.client?.probe();
+ }
+
+ retryNowIfWaiting(): void {
+ if (this.state === AccountEngineConnectionState.BACKOFF || this.state === AccountEngineConnectionState.OFFLINE) {
+ this.deps.scheduler.cancelRetry(this.accountKey);
+ this.requestConnect();
+ }
+ }
+
+ markOffline(): void {
+ if (this.state === AccountEngineConnectionState.BACKOFF) {
+ this.setState(AccountEngineConnectionState.OFFLINE);
+ }
+ }
+
+ stop(code: number, reason: string, options: {dispose: boolean}): void {
+ this.stopped = true;
+ this.deps.scheduler.cancel(this.accountKey);
+ this.dropQueue();
+ this.deps.pump.forget(this);
+ this.disconnect(code, reason);
+ this.resume = null;
+ this.setState(AccountEngineConnectionState.STOPPED);
+ if (options.dispose) {
+ this.core.dispose();
+ }
+ }
+
+ mentionCounts(): Record<string, number> {
+ return this.core.mentionCounts();
+ }
+
+ refreshUnread(): void {
+ if (!this.stopped) {
+ this.core.refreshUnread();
+ }
+ }
+
+ setUnreadBadgeCustomization(enabled: boolean): void {
+ if (!this.stopped) {
+ this.core.setUnreadBadgeCustomization(enabled);
+ }
+ }
+
+ activity(channelLimit: number) {
+ return this.core.activity(channelLimit);
+ }
+
+ summary(): AccountEngineAccountSummary {
+ return {
+ accountKey: this.accountKey,
+ instanceKey: this.record.instanceKey,
+ userId: this.record.userId,
+ user: this.user,
+ state: this.state,
+ stateChangedAt: this.stateChangedAt,
+ nextRetryAt: this.nextRetryAt,
+ mentionCount: this.counts.mentionCount,
+ unreadChannelCount: this.counts.unreadChannelCount,
+ lastMessageAt: this.counts.lastMessageAt,
+ cache: this.cache,
+ cacheUpdatedAt: this.cacheUpdatedAt,
+ degraded: this.counts.degraded,
+ revision: this.revision,
+ };
+ }
+
+ hasPending(): boolean {
+ return this.queueHead < this.queue.length;
+ }
+
+ processNext(): void {
+ if (this.queueHead >= this.queue.length) {
+ return;
+ }
+ const item = this.queue[this.queueHead];
+ this.queueHead += 1;
+ this.queueBytes -= item.bytes;
+ if (this.queueHead >= this.queue.length) {
+ this.queue = [];
+ this.queueHead = 0;
+ this.queueBytes = 0;
+ }
+ if (item.client !== this.client) {
+ return;
+ }
+ this.applyInbound(item);
+ }
+
+ onSlotGranted(): void {
+ void this.connect();
+ }
+
+ private applyInbound(item: InboundDispatch): void {
+ try {
+ if (item.type === 'READY') {
+ const invalidations = this.invalidations;
+ const {sessionId} = this.core.applyReady(item.data);
+ this.resume = sessionId === null || item.sequence === null ? null : {sessionId, sequence: item.sequence};
+ this.attempt = 0;
+ this.handshakeSucceeded = true;
+ if (this.invalidations === invalidations) {
+ this.cache = AccountEngineCacheState.LIVE;
+ }
+ this.cacheUpdatedAt = this.deps.clock.now();
+ this.setState(AccountEngineConnectionState.READY);
+ return;
+ }
+ if (item.type === 'RESUMED') {
+ this.attempt = 0;
+ this.handshakeSucceeded = true;
+ this.setState(AccountEngineConnectionState.READY);
+ } else {
+ this.core.applyDispatch(item.type, item.data);
+ }
+ if (this.resume !== null && item.sequence !== null) {
+ this.resume = {sessionId: this.resume.sessionId, sequence: item.sequence};
+ }
+ } catch (error) {
+ this.deps.log('warn', 'Account engine failed to reduce a dispatch', {
+ accountKey: this.accountKey,
+ type: item.type,
+ error: errorMessage(error),
+ });
+ if (item.type === 'READY') {
+ this.resume = null;
+ this.disconnect(GatewayClose.NORMAL, 'ready rejected');
+ this.scheduleBackoff(0);
+ }
+ }
+ }
+
+ private requestConnect(): void {
+ if (this.stopped || this.held) {
+ return;
+ }
+ if (this.deps.config() === null) {
+ this.setState(AccountEngineConnectionState.STARTING);
+ return;
+ }
+ this.cancelRetryTimer();
+ this.nextRetryAt = null;
+ if (this.state !== AccountEngineConnectionState.READY || this.client === null) {
+ this.setState(
+ this.resume !== null ? AccountEngineConnectionState.RESUMING : AccountEngineConnectionState.CONNECTING,
+ );
+ }
+ this.deps.scheduler.requestSlot(this);
+ }
+
+ private async connect(): Promise<void> {
+ const config = this.deps.config();
+ if (this.stopped || this.held || config === null || this.client !== null || this.connecting) {
+ this.deps.scheduler.releaseSlot(this.accountKey);
+ return;
+ }
+ this.connecting = true;
+ let admitted: AdmittedGateway;
+ try {
+ admitted = await this.deps.admit(this.accountKey, this.record.gatewayEndpoint);
+ } catch (error) {
+ this.connecting = false;
+ this.deps.scheduler.releaseSlot(this.accountKey);
+ this.deps.log('warn', 'Account engine gateway admission failed', {
+ accountKey: this.accountKey,
+ error: errorMessage(error),
+ });
+ if (!this.stopped && !this.held) {
+ this.scheduleBackoff(0);
+ }
+ return;
+ }
+ this.connecting = false;
+ if (this.stopped || this.held || this.client !== null) {
+ this.deps.scheduler.releaseSlot(this.accountKey);
+ return;
+ }
+ this.admittedUrl = admitted.url;
+ this.handshakeSucceeded = false;
+ const resume = this.resume;
+ this.setState(resume !== null ? AccountEngineConnectionState.RESUMING : AccountEngineConnectionState.CONNECTING);
+ let client: GatewayClient;
+ try {
+ client = this.createClient(admitted, resume, config);
+ } catch (error) {
+ this.deps.scheduler.releaseSlot(this.accountKey);
+ this.deps.log('warn', 'Account engine could not open a gateway connection', {
+ accountKey: this.accountKey,
+ error: errorMessage(error),
+ });
+ this.scheduleBackoff(0);
+ return;
+ }
+ this.client = client;
+ client.start();
+ }
+
+ private createClient(
+ admitted: AdmittedGateway,
+ resume: GatewayResumeState | null,
+ config: AccountEngineClientConfig,
+ ): GatewayClient {
+ const client: GatewayClient = new GatewayClient({
+ gatewayUrl: admitted.url,
+ address: admitted.address,
+ token: this.token,
+ config,
+ resume,
+ compression: this.compression,
+ transport: this.deps.transport,
+ clock: this.deps.clock,
+ handlers: {
+ onDispatch: (type, data, sequence, bytes) => this.receive(client, type, data, sequence, bytes),
+ onExit: (exit) => this.handleExit(client, exit),
+ },
+ });
+ return client;
+ }
+
+ private receive(client: GatewayClient, type: string, data: unknown, sequence: number | null, bytes: number): void {
+ if (client !== this.client) {
+ return;
+ }
+ if (type === 'READY' || type === 'RESUMED') {
+ this.deps.scheduler.releaseSlot(this.accountKey);
+ const release = this.subscriptionRelease;
+ this.subscriptionRelease = null;
+ if (type === 'RESUMED' && release !== null) {
+ client.releaseSubscriptions(release);
+ this.releaseSentAt = this.deps.clock.now();
+ }
+ }
+ if (this.queueBytes + bytes > INBOUND_QUEUE_MAX_BYTES && type !== 'READY') {
+ this.deps.log('warn', 'Account engine inbound queue overflowed, resuming', {accountKey: this.accountKey});
+ this.dropQueue();
+ this.disconnect(GatewayClose.ZOMBIE, 'overflow');
+ this.requestConnect();
+ return;
+ }
+ this.queue.push({type, data, sequence, bytes, client});
+ this.queueBytes += bytes;
+ this.deps.pump.schedule(this);
+ }
+
+ private handleExit(client: GatewayClient, exit: GatewayClientExit): void {
+ if (client !== this.client) {
+ return;
+ }
+ this.client = null;
+ this.deps.scheduler.releaseSlot(this.accountKey);
+ this.dropQueue();
+ if (this.stopped || this.held) {
+ return;
+ }
+ switch (exit.kind) {
+ case 'auth_failed':
+ this.resume = null;
+ this.failedTokenTag = accountTokenTag(this.token);
+ this.setState(AccountEngineConnectionState.AUTH_FAILED);
+ this.deps.onAuthFailed(this.accountKey, this.failedTokenTag);
+ return;
+ case 'rate_limited':
+ this.scheduleBackoff(SCHEDULER_LIMITS.rateLimitFloorMs);
+ return;
+ case 'session_invalid': {
+ if (!exit.resumable) {
+ this.resume = null;
+ }
+ const delay =
+ INVALID_SESSION_MIN_DELAY_MS +
+ Math.floor(this.deps.clock.random() * (INVALID_SESSION_MAX_DELAY_MS - INVALID_SESSION_MIN_DELAY_MS));
+ this.scheduleRetry(delay);
+ return;
+ }
+ case 'reconnect_requested':
+ case 'zombie':
+ if (this.handshakeSucceeded) {
+ this.requestConnect();
+ } else {
+ this.scheduleBackoff(SCHEDULER_LIMITS.backoffBaseMs);
+ }
+ return;
+ case 'overflow':
+ this.deps.log('warn', 'Account engine fell behind decoding, resuming', {accountKey: this.accountKey});
+ this.scheduleBackoff(SCHEDULER_LIMITS.backoffBaseMs);
+ return;
+ case 'decode_error':
+ this.compression = 'none';
+ this.resume = null;
+ this.scheduleRetry(DECODE_RETRY_DELAY_MS);
+ return;
+ case 'timeout':
+ this.scheduleBackoff(0);
+ return;
+ case 'closed':
+ if (!exit.resumable) {
+ this.resume = null;
+ }
+ this.scheduleBackoff(0);
+ return;
+ }
+ }
+
+ private scheduleBackoff(floorMs: number): void {
+ const delay = this.deps.scheduler.backoffDelay(this.attempt, floorMs);
+ this.attempt += 1;
+ this.scheduleRetry(delay);
+ }
+
+ private scheduleRetry(delayMs: number): void {
+ if (this.stopped || this.held) {
+ return;
+ }
+ this.cancelRetryTimer();
+ this.nextRetryAt = this.deps.scheduler.scheduleRetry(this.accountKey, delayMs, () => {
+ this.nextRetryAt = null;
+ this.requestConnect();
+ });
+ this.setState(
+ this.deps.scheduler.isOnline ? AccountEngineConnectionState.BACKOFF : AccountEngineConnectionState.OFFLINE,
+ );
+ }
+
+ private cancelRetryTimer(): void {
+ this.deps.scheduler.cancelRetry(this.accountKey);
+ }
+
+ private disconnect(code: number, reason: string): void {
+ const client = this.client;
+ this.client = null;
+ this.dropQueue();
+ this.deps.scheduler.releaseSlot(this.accountKey);
+ client?.close(code, reason);
+ }
+
+ private dropQueue(): void {
+ this.queue = [];
+ this.queueHead = 0;
+ this.queueBytes = 0;
+ }
+
+ private admitNotification(message: unknown): boolean {
+ const now = this.deps.clock.now();
+ const timestamp = (message as {timestamp?: unknown} | null)?.timestamp;
+ const sentAt = typeof timestamp === 'string' ? Date.parse(timestamp) : Number.NaN;
+ if (Number.isFinite(sentAt) && now - sentAt > NOTIFICATION_MAX_AGE_MS) {
+ return false;
+ }
+ const refills = Math.floor((now - this.notificationsRefilledAt) / NOTIFICATION_REFILL_MS);
+ if (refills > 0) {
+ this.notificationTokens = Math.min(NOTIFICATION_BURST, this.notificationTokens + refills);
+ this.notificationsRefilledAt += refills * NOTIFICATION_REFILL_MS;
+ }
+ if (this.notificationTokens === NOTIFICATION_BURST) {
+ this.notificationsRefilledAt = now;
+ }
+ if (this.notificationTokens <= 0) {
+ return false;
+ }
+ this.notificationTokens -= 1;
+ return true;
+ }
+
+ private rotateToken(token: string): void {
+ const previous = this.token;
+ if (token === previous) {
+ return;
+ }
+ this.token = token;
+ this.supersededToken = previous;
+ this.deps.onTokenRotated(this.accountKey, previous, token);
+ }
+
+ private setState(state: AccountEngineConnectionState): void {
+ if (this.state === state) {
+ return;
+ }
+ this.state = state;
+ this.stateChangedAt = this.deps.clock.now();
+ if (state !== AccountEngineConnectionState.BACKOFF && state !== AccountEngineConnectionState.OFFLINE) {
+ this.nextRetryAt = null;
+ }
+ this.touch();
+ }
+
+ private touch(): void {
+ this.revision += 1;
+ this.deps.onSummaryChanged(this);
+ }
+}