@steve31415/baselib 2.0.0 → 2.2.0

package/dist/sync-browser/client.js

@@ -0,0 +1,832 @@
+const RECONNECT_DELAYS_SECONDS = [1, 2, 4, 8, 16, 30];
+const PING_INTERVAL_MS = 30_000;
+const CONNECT_WATCHDOG_MS = 10_000;
+const DEFAULT_RECONNECT_BEFORE_MS = 55 * 60 * 1000;
+const FAILURE_TIMEOUT_MS = 60_000;
+const OUTAGE_ESCALATE_MS = 30_000;
+const CLOSE_NO_USER = 4403;
+const PROBE_AFTER_ATTEMPTS = 2;
+const SOCKET_OPEN = 1;
+class LifecycleAbort {
+    reason;
+    constructor(reason) {
+        this.reason = reason;
+    }
+}
+function isLifecycleAbort(error) {
+    return error instanceof LifecycleAbort;
+}
+export class SyncClient {
+    options;
+    socket = null;
+    pending = new Map();
+    unresolvedFailures = new Set();
+    rejected = new Map();
+    confirmedPending = new Map();
+    pendingRejections = new Map();
+    settlementInFlight = new Set();
+    settledPending = new Set();
+    failureTimers = new Map();
+    subscribers = new Set();
+    abortControllers = new Set();
+    removeListeners = [];
+    currentState = { kind: 'starting', pending: 0 };
+    reconnectAttempts = 0;
+    reconnectTimer = null;
+    countdownTimer = null;
+    pingTimer = null;
+    watchdogTimer = null;
+    rolloverTimer = null;
+    escalateTimer = null;
+    escalateArmedAt = 0;
+    outageStartedAt = null;
+    outageEscalated = false;
+    halted = false;
+    refetchInFlight = false;
+    probeInFlight = false;
+    resyncTimes = [];
+    reconciliationTail = Promise.resolve();
+    initialization = null;
+    disposed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    init() {
+        if (this.disposed)
+            return Promise.resolve();
+        if (this.initialization === null) {
+            let resolve;
+            let reject;
+            this.initialization = new Promise((res, rej) => {
+                resolve = res;
+                reject = rej;
+            });
+            void this.initialize().then(resolve, reject);
+        }
+        return this.initialization;
+    }
+    async initialize() {
+        this.publish({ kind: 'starting', pending: this.pendingCount() });
+        this.removeListeners.push(this.options.authState.onBlocked(() => this.halt()));
+        if (this.stopBeforeStoreMutation())
+            return;
+        this.options.markPerformance?.('outbox-start');
+        const outboxPromise = this.options.outbox
+            .init()
+            .then((entries) => {
+            this.options.markPerformance?.('outbox-ready');
+            return entries;
+        })
+            .catch((error) => {
+            this.options.logger.error('outbox initialization failed', { error });
+            throw error;
+        });
+        this.options.markPerformance?.('bootstrap-start');
+        const bootstrapPromise = this.abortable((signal) => this.options.fetchBootstrap(signal))
+            .then((bootstrap) => {
+            this.options.markPerformance?.('bootstrap-response');
+            return bootstrap;
+        })
+            .catch((error) => {
+            if (!isLifecycleAbort(error))
+                this.options.logger.error('bootstrap failed', { error });
+            throw error;
+        });
+        let recovered;
+        let bootstrap;
+        try {
+            const startup = await Promise.all([outboxPromise, bootstrapPromise]);
+            recovered = startup[0];
+            bootstrap = startup[1];
+        }
+        catch (error) {
+            this.abortFetches();
+            throw isLifecycleAbort(error) ? error.reason : error;
+        }
+        if (this.stopBeforeStoreMutation())
+            return;
+        this.options.store.installBootstrap(bootstrap);
+        for (const persisted of recovered) {
+            if (this.stopBeforeStoreMutation())
+                return;
+            const entry = {
+                event: persisted.event,
+                summary: persisted.summary,
+                createdAt: persisted.createdAt,
+                ordinal: persisted.ordinal,
+                status: 'pending',
+                recovered: true,
+            };
+            this.pending.set(entry.event.eventGuid, entry);
+            this.options.store.restorePending(entry.event);
+        }
+        this.options.markPerformance?.('store-ready');
+        if (this.stopBeforeStoreMutation())
+            return;
+        this.installRuntimeListeners();
+        this.connect();
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.abortFetches();
+        for (const remove of this.removeListeners.splice(0))
+            remove();
+        this.clearAllTimers();
+        const socket = this.socket;
+        this.socket = null;
+        if (socket) {
+            socket.close();
+            this.detachSocket(socket);
+        }
+        this.subscribers.clear();
+    }
+    async submit(event, summary) {
+        if (this.disposed)
+            return;
+        const persisted = {
+            event,
+            summary,
+            createdAt: this.options.runtime.now(),
+        };
+        const initialization = this.init();
+        if (this.stopBeforeStoreMutation()) {
+            await initialization;
+            return;
+        }
+        await this.options.outbox.add(persisted);
+        await initialization;
+        if (this.stopBeforeStoreMutation())
+            return;
+        const entry = { ...persisted, status: 'pending' };
+        this.pending.set(event.eventGuid, entry);
+        this.options.store.applyOptimistic(event);
+        this.failureTimers.set(event.eventGuid, this.options.runtime.setTimeout(() => this.failUnconfirmed(event.eventGuid), FAILURE_TIMEOUT_MS));
+        this.trySend(entry);
+        this.updatePendingState();
+        this.options.onSafetyChange?.();
+    }
+    /** Current-tab entries only; recovered work is retried silently. */
+    pendingEntries() {
+        return [...this.pending.values()].filter((entry) => !entry.recovered);
+    }
+    failedEntries() {
+        return [...this.rejected.values()];
+    }
+    hasPendingWork() {
+        return this.pendingEntries().length > 0;
+    }
+    hasUnsafeWork() {
+        return this.hasPendingWork() || this.hasUnresolvedFailures();
+    }
+    hasUnresolvedFailures() {
+        return this.unresolvedFailures.size > 0;
+    }
+    dismissFailure(eventGuid) {
+        if (!this.rejected.delete(eventGuid))
+            return;
+        this.unresolvedFailures.delete(eventGuid);
+        this.options.onSafetyChange?.();
+    }
+    refreshConnectionForBuild() {
+        if (this.halted || this.disposed)
+            return;
+        this.options.logger.info('sync reconnect for traffic build');
+        const previous = this.socket;
+        this.socket = null;
+        this.clearConnectionTimers();
+        if (previous) {
+            previous.close();
+            this.detachSocket(previous);
+        }
+        this.connectNow();
+    }
+    state() {
+        return this.currentState;
+    }
+    subscribe(listener) {
+        this.subscribers.add(listener);
+        return () => this.subscribers.delete(listener);
+    }
+    installRuntimeListeners() {
+        this.removeListeners.push(this.options.runtime.onVisibilityChange(() => {
+            if (this.options.runtime.visibility() === 'visible')
+                this.wakeConnection();
+        }), this.options.runtime.onOnline(() => this.wakeConnection()), this.options.runtime.onPageHide(() => this.flushViaBeacon()));
+    }
+    wakeConnection() {
+        if (this.halted || this.disposed)
+            return;
+        if (this.socket !== null) {
+            if (this.socket.readyState === SOCKET_OPEN)
+                this.sendConnect();
+            return;
+        }
+        this.connectNow();
+    }
+    connect() {
+        if (this.halted || this.disposed)
+            return;
+        this.publish(this.reconnectAttempts > 0
+            ? { kind: 'disconnected', pending: this.pendingCount() }
+            : { kind: 'connecting', pending: this.pendingCount() });
+        let socket;
+        try {
+            socket = this.options.runtime.createSocket(this.options.socketUrl());
+        }
+        catch (error) {
+            this.options.logger.warn('socket creation failed', { error });
+            this.startOutage(1006);
+            this.scheduleReconnect();
+            return;
+        }
+        this.socket = socket;
+        this.watchdogTimer = this.options.runtime.setTimeout(() => {
+            if (socket.readyState !== SOCKET_OPEN)
+                socket.close();
+        }, CONNECT_WATCHDOG_MS);
+        socket.onopen = () => {
+            if (this.socket !== socket) {
+                socket.close();
+                return;
+            }
+            if (this.watchdogTimer !== null)
+                this.options.runtime.clearTimeout(this.watchdogTimer);
+            this.watchdogTimer = null;
+            this.sendConnect();
+            this.pingTimer = this.options.runtime.setInterval(() => this.sendRaw({ type: 'ping' }), PING_INTERVAL_MS);
+            this.rolloverTimer = this.options.runtime.setTimeout(() => {
+                this.options.logger.info('ws rollover', {});
+                socket.close();
+            }, this.options.reconnectBeforeMs ?? DEFAULT_RECONNECT_BEFORE_MS);
+        };
+        socket.onmessage = (event) => {
+            if (this.socket === socket)
+                this.handleMessage(String(event.data));
+        };
+        socket.onerror = () => {
+            // Browsers expose no useful detail; the close event owns recovery.
+        };
+        socket.onclose = (event) => {
+            if (this.socket !== socket)
+                return;
+            this.clearConnectionTimers();
+            this.socket = null;
+            if (this.halted || this.disposed)
+                return;
+            if (event.code === CLOSE_NO_USER) {
+                this.options.authState.markBlocked();
+                this.halt();
+                return;
+            }
+            this.startOutage(event.code);
+            this.scheduleReconnect();
+        };
+    }
+    connectNow() {
+        if (this.reconnectTimer !== null)
+            this.options.runtime.clearTimeout(this.reconnectTimer);
+        if (this.countdownTimer !== null)
+            this.options.runtime.clearInterval(this.countdownTimer);
+        this.reconnectTimer = null;
+        this.countdownTimer = null;
+        this.connect();
+    }
+    scheduleReconnect() {
+        const delay = RECONNECT_DELAYS_SECONDS[Math.min(this.reconnectAttempts, RECONNECT_DELAYS_SECONDS.length - 1)];
+        this.reconnectAttempts++;
+        if (this.reconnectAttempts >= PROBE_AFTER_ATTEMPTS)
+            void this.probeSession();
+        let remaining = delay;
+        this.publish({ kind: 'reconnecting', pending: this.pendingCount(), inSeconds: remaining });
+        this.countdownTimer = this.options.runtime.setInterval(() => {
+            remaining--;
+            if (remaining > 0) {
+                this.publish({ kind: 'reconnecting', pending: this.pendingCount(), inSeconds: remaining });
+            }
+        }, 1000);
+        this.reconnectTimer = this.options.runtime.setTimeout(() => {
+            if (this.countdownTimer !== null)
+                this.options.runtime.clearInterval(this.countdownTimer);
+            this.countdownTimer = null;
+            this.reconnectTimer = null;
+            this.connect();
+        }, delay * 1000);
+    }
+    async probeSession() {
+        if (this.halted || this.disposed || this.probeInFlight)
+            return;
+        this.probeInFlight = true;
+        try {
+            const result = await this.abortable((signal) => this.options.fetchCatchup(this.options.store.currentSeq(), signal));
+            if (this.stopBeforeStoreMutation())
+                return;
+            if (result.buildId)
+                this.options.onBuildObserved?.(result.buildId);
+            if (result.reload) {
+                this.requestReload('server');
+            }
+            else {
+                for (const event of result.events)
+                    this.handleServerEvent(event);
+            }
+        }
+        catch {
+            // Offline or aborted: neither says that the session is expired.
+        }
+        finally {
+            this.probeInFlight = false;
+        }
+    }
+    startOutage(closeCode) {
+        if (this.outageStartedAt !== null)
+            return;
+        this.outageStartedAt = this.options.runtime.now();
+        this.outageEscalated = false;
+        this.escalateArmedAt = this.options.runtime.now();
+        this.escalateTimer = this.options.runtime.setTimeout(() => {
+            const late = this.options.runtime.now() - this.escalateArmedAt - OUTAGE_ESCALATE_MS;
+            if (this.options.runtime.visibility() === 'hidden' || late > 5000)
+                return;
+            if (this.outageStartedAt !== null) {
+                this.outageEscalated = true;
+                this.options.logger.error('sync outage ongoing', {
+                    durationMs: this.options.runtime.now() - this.outageStartedAt,
+                    closeCode,
+                    attempts: this.reconnectAttempts,
+                });
+            }
+        }, OUTAGE_ESCALATE_MS);
+    }
+    handleMessage(raw) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            this.options.logger.warn('unparseable ws message', { raw: raw.slice(0, 200) });
+            return;
+        }
+        switch (message.type) {
+            case 'build_changed':
+                this.options.onBuildChanged?.();
+                return;
+            case 'sync_available':
+                this.sendConnect();
+                return;
+            case 'pong':
+                if (message.buildId)
+                    this.options.onBuildObserved?.(message.buildId);
+                return;
+            case 'catchup':
+                this.handleSocketCatchup(message);
+                return;
+            case 'reload':
+                this.requestReload('server');
+                return;
+            case 'event':
+                this.handleServerEvent(message.event);
+                return;
+            case 'rejection':
+                this.handleRejection(message);
+                return;
+        }
+    }
+    handleSocketCatchup(message) {
+        if (message.buildId)
+            this.options.onBuildObserved?.(message.buildId);
+        let complete = true;
+        for (const event of message.events) {
+            if (!this.handleServerEvent(event))
+                complete = false;
+        }
+        if (complete && message.currentSeq > this.options.store.currentSeq()) {
+            this.requestReload('sequence-gap');
+            complete = false;
+        }
+        if (complete)
+            this.onSyncEstablished();
+    }
+    /** Returns false when a forward gap prevented application. */
+    handleServerEvent(event) {
+        if (this.stopBeforeStoreMutation())
+            return false;
+        const currentSeq = this.options.store.currentSeq();
+        if (event.seq <= currentSeq) {
+            if (this.pending.has(event.eventGuid))
+                this.confirmPending(event.eventGuid, true);
+            return true;
+        }
+        if (event.seq > currentSeq + 1) {
+            this.requestReload('sequence-gap');
+            return false;
+        }
+        this.options.store.applyServerEvent(event);
+        if (this.stopBeforeStoreMutation())
+            return false;
+        this.options.store.setCurrentSeq(event.seq);
+        if (this.pending.has(event.eventGuid))
+            this.confirmPending(event.eventGuid, false);
+        return true;
+    }
+    handleRejection(message) {
+        const entry = this.pending.get(message.eventGuid);
+        if (!entry)
+            return;
+        if (this.confirmedPending.has(message.eventGuid) || this.pendingRejections.has(message.eventGuid)) {
+            this.retrySettlement(message.eventGuid);
+            return;
+        }
+        if (this.stopBeforeStoreMutation())
+            return;
+        this.pendingRejections.set(message.eventGuid, message);
+        this.settledPending.add(message.eventGuid);
+        this.clearFailureTimer(message.eventGuid);
+        this.options.store.rejectPending(message.eventGuid, message.error);
+        if (!entry.recovered) {
+            const rejectedEntry = {
+                ...entry,
+                status: 'rejected',
+                error: message.error.message,
+            };
+            this.unresolvedFailures.add(message.eventGuid);
+            this.rejected.set(message.eventGuid, {
+                eventGuid: message.eventGuid,
+                entry: rejectedEntry,
+                error: message.error.message,
+            });
+            this.options.logger.warn('event rejected', {
+                eventGuid: message.eventGuid,
+                code: message.error.code,
+                message: message.error.message,
+            });
+            this.options.onEventFailed(rejectedEntry, message.error.message, true);
+        }
+        else {
+            this.unresolvedFailures.add(message.eventGuid);
+        }
+        this.options.onSafetyChange?.();
+        this.updateConnectedState();
+        this.retrySettlement(message.eventGuid);
+    }
+    confirmPending(eventGuid, reconcile) {
+        const entry = this.pending.get(eventGuid);
+        if (!entry)
+            return;
+        if (this.pendingRejections.has(eventGuid)) {
+            this.retrySettlement(eventGuid);
+            return;
+        }
+        const wasAlreadySettling = this.confirmedPending.has(eventGuid);
+        this.confirmedPending.set(eventGuid, reconcile || this.confirmedPending.get(eventGuid) === true);
+        this.settledPending.add(eventGuid);
+        this.clearFailureTimer(eventGuid);
+        if (entry.recovered && !this.unresolvedFailures.has(eventGuid)) {
+            this.unresolvedFailures.add(eventGuid);
+            this.options.onSafetyChange?.();
+        }
+        if (!wasAlreadySettling)
+            this.updateConnectedState();
+        this.retrySettlement(eventGuid);
+    }
+    clearFailureTimer(eventGuid) {
+        const timer = this.failureTimers.get(eventGuid);
+        if (timer !== undefined)
+            this.options.runtime.clearTimeout(timer);
+        this.failureTimers.delete(eventGuid);
+    }
+    retrySettlement(eventGuid) {
+        if (this.halted || this.disposed || this.settlementInFlight.has(eventGuid))
+            return;
+        if (this.confirmedPending.has(eventGuid)) {
+            void this.finishConfirmation(eventGuid);
+        }
+        else if (this.pendingRejections.has(eventGuid)) {
+            void this.finishRejection(eventGuid);
+        }
+    }
+    async finishConfirmation(eventGuid) {
+        const entry = this.pending.get(eventGuid);
+        if (!entry)
+            return;
+        const reportRecovery = !entry.recovered && this.unresolvedFailures.has(eventGuid);
+        this.settlementInFlight.add(eventGuid);
+        try {
+            await this.options.outbox.remove(eventGuid);
+            if (this.stopBeforeStoreMutation())
+                return;
+            if (this.confirmedPending.get(eventGuid) && !(await this.reconcileStore()))
+                return;
+            if (this.stopBeforeStoreMutation())
+                return;
+            this.pending.delete(eventGuid);
+            this.confirmedPending.delete(eventGuid);
+            this.settledPending.delete(eventGuid);
+            this.unresolvedFailures.delete(eventGuid);
+            this.rejected.delete(eventGuid);
+            if (reportRecovery)
+                this.options.onEventRecovered?.(eventGuid);
+            this.options.onSafetyChange?.();
+            this.updateConnectedState();
+        }
+        catch (error) {
+            if (!isLifecycleAbort(error) && !this.halted && !this.disposed) {
+                this.options.logger.error('confirmed event cleanup failed', { eventGuid, error });
+            }
+        }
+        finally {
+            this.settlementInFlight.delete(eventGuid);
+        }
+    }
+    async finishRejection(eventGuid) {
+        const entry = this.pending.get(eventGuid);
+        if (!entry)
+            return;
+        this.settlementInFlight.add(eventGuid);
+        try {
+            await this.options.outbox.remove(eventGuid);
+            if (this.stopBeforeStoreMutation() || !(await this.reconcileStore()))
+                return;
+            if (this.stopBeforeStoreMutation())
+                return;
+            this.pending.delete(eventGuid);
+            this.pendingRejections.delete(eventGuid);
+            this.settledPending.delete(eventGuid);
+            if (entry.recovered)
+                this.unresolvedFailures.delete(eventGuid);
+            this.options.onSafetyChange?.();
+            this.updateConnectedState();
+        }
+        catch (error) {
+            if (!isLifecycleAbort(error) && !this.halted && !this.disposed) {
+                this.options.logger.error('rejected event cleanup failed', { eventGuid, error });
+            }
+        }
+        finally {
+            this.settlementInFlight.delete(eventGuid);
+        }
+    }
+    async reconcileStore() {
+        const preceding = this.reconciliationTail;
+        let release;
+        this.reconciliationTail = new Promise((resolve) => {
+            release = resolve;
+        });
+        await preceding;
+        try {
+            while (true) {
+                if (this.stopBeforeStoreMutation())
+                    return false;
+                const startingSeq = this.options.store.currentSeq();
+                const bootstrap = await this.abortable((signal) => this.options.fetchBootstrap(signal));
+                if (this.stopBeforeStoreMutation())
+                    return false;
+                if (this.options.store.currentSeq() !== startingSeq)
+                    continue;
+                this.options.store.installBootstrap(bootstrap);
+                for (const [eventGuid, entry] of this.pending) {
+                    if (this.settledPending.has(eventGuid))
+                        continue;
+                    if (this.stopBeforeStoreMutation())
+                        return false;
+                    this.options.store.restorePending(entry.event);
+                }
+                return true;
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    failUnconfirmed(eventGuid) {
+        const entry = this.pending.get(eventGuid);
+        if (!entry || entry.recovered)
+            return;
+        entry.status = 'unconfirmed';
+        entry.error = 'not confirmed after 60s';
+        this.unresolvedFailures.add(eventGuid);
+        this.options.onEventFailed(entry, entry.error, false);
+        this.options.onSafetyChange?.();
+    }
+    onSyncEstablished() {
+        if (this.outageStartedAt !== null) {
+            const durationMs = this.options.runtime.now() - this.outageStartedAt;
+            const attempts = this.reconnectAttempts;
+            if (this.outageEscalated) {
+                this.options.logger.info('sync outage recovered', { durationMs, attempts });
+            }
+            else if (attempts >= 2) {
+                this.options.logger.warn('sync outage recovered', { durationMs, attempts });
+            }
+            else if (attempts === 1) {
+                this.options.logger.info('ws reconnected first try', { durationMs });
+            }
+            this.outageStartedAt = null;
+            this.outageEscalated = false;
+        }
+        if (this.escalateTimer !== null)
+            this.options.runtime.clearTimeout(this.escalateTimer);
+        this.escalateTimer = null;
+        this.reconnectAttempts = 0;
+        for (const [eventGuid, entry] of this.pending) {
+            if (this.settledPending.has(eventGuid)) {
+                this.retrySettlement(eventGuid);
+            }
+            else {
+                this.trySend(entry);
+            }
+        }
+        this.updateConnectedState();
+    }
+    requestReload(reason) {
+        this.options.onReloadRequired(reason);
+        void this.resyncFromServer(reason === 'server' ? 'server requested reload' : 'sequence gap');
+    }
+    async resyncFromServer(reason) {
+        if (this.refetchInFlight || this.halted || this.disposed)
+            return;
+        const now = this.options.runtime.now();
+        this.resyncTimes = [...this.resyncTimes.filter((time) => now - time < 60_000), now];
+        if (this.resyncTimes.length > 3) {
+            this.options.logger.error('resync loop detected', { reason });
+            this.publish({
+                kind: 'error',
+                pending: this.pendingCount(),
+                message: 'Repeated resyncs require a page reload',
+            });
+            return;
+        }
+        this.refetchInFlight = true;
+        try {
+            this.options.logger.info('resyncing from server', { reason });
+            if (!(await this.reconcileStore()))
+                return;
+            for (const entry of this.pending.values())
+                this.trySend(entry);
+        }
+        catch (error) {
+            if (!isLifecycleAbort(error) && !this.disposed && !this.halted) {
+                this.options.logger.error('resync failed', { reason, error });
+            }
+        }
+        finally {
+            this.refetchInFlight = false;
+        }
+    }
+    sendConnect() {
+        this.sendRaw({
+            type: 'connect',
+            clientGuid: this.options.clientGuid,
+            lastSeq: this.options.store.currentSeq(),
+        });
+    }
+    sendRaw(message) {
+        if (this.socket?.readyState !== SOCKET_OPEN)
+            return;
+        try {
+            this.socket.send(JSON.stringify(message));
+        }
+        catch {
+            // The close handler owns recovery.
+        }
+    }
+    trySend(entry) {
+        if (this.settledPending.has(entry.event.eventGuid))
+            return;
+        this.sendRaw({ type: 'event', clientGuid: this.options.clientGuid, event: entry.event });
+    }
+    flushViaBeacon() {
+        if (this.disposed || this.halted || this.pending.size === 0)
+            return;
+        const events = [...this.pending.values()]
+            .filter((entry) => !this.settledPending.has(entry.event.eventGuid))
+            .map((entry) => entry.event);
+        if (events.length === 0)
+            return;
+        const body = JSON.stringify({
+            clientGuid: this.options.clientGuid,
+            events,
+        });
+        this.options.runtime.sendBeacon(this.options.beaconUrl, new Blob([body], { type: 'application/json' }));
+    }
+    updateConnectedState() {
+        if (this.halted || this.disposed || this.socket?.readyState !== SOCKET_OPEN)
+            return;
+        const pending = this.pendingCount();
+        this.publish(pending > 0 ? { kind: 'syncing', pending } : { kind: 'connected', pending: 0 });
+    }
+    updatePendingState() {
+        if (this.halted || this.disposed)
+            return;
+        if (this.socket?.readyState === SOCKET_OPEN) {
+            this.updateConnectedState();
+            return;
+        }
+        const pending = this.pendingCount();
+        switch (this.currentState.kind) {
+            case 'starting':
+            case 'connecting':
+            case 'disconnected':
+                this.publish({ kind: this.currentState.kind, pending });
+                return;
+            case 'reconnecting':
+                this.publish({ kind: 'reconnecting', pending, inSeconds: this.currentState.inSeconds });
+                return;
+            case 'error':
+                this.publish({ kind: 'error', pending, message: this.currentState.message });
+                return;
+            case 'expired':
+                this.publish({ kind: 'expired', pending });
+                return;
+            case 'connected':
+            case 'syncing':
+                return;
+        }
+    }
+    publish(state) {
+        if (this.disposed)
+            return;
+        this.currentState = state;
+        this.options.onState(state);
+        for (const subscriber of this.subscribers)
+            subscriber(state);
+    }
+    pendingCount() {
+        return this.pendingEntries().length;
+    }
+    stopBeforeStoreMutation() {
+        if (this.disposed || this.halted)
+            return true;
+        if (!this.options.authState.isBlocked())
+            return false;
+        this.halt();
+        return true;
+    }
+    halt() {
+        if (this.halted || this.disposed)
+            return;
+        this.halted = true;
+        this.abortFetches();
+        this.clearAllTimers();
+        const socket = this.socket;
+        this.socket = null;
+        if (socket) {
+            socket.close();
+            this.detachSocket(socket);
+        }
+        this.publish({ kind: 'expired', pending: this.pendingCount() });
+    }
+    clearConnectionTimers() {
+        if (this.pingTimer !== null)
+            this.options.runtime.clearInterval(this.pingTimer);
+        if (this.watchdogTimer !== null)
+            this.options.runtime.clearTimeout(this.watchdogTimer);
+        if (this.rolloverTimer !== null)
+            this.options.runtime.clearTimeout(this.rolloverTimer);
+        this.pingTimer = null;
+        this.watchdogTimer = null;
+        this.rolloverTimer = null;
+    }
+    clearAllTimers() {
+        this.clearConnectionTimers();
+        if (this.reconnectTimer !== null)
+            this.options.runtime.clearTimeout(this.reconnectTimer);
+        if (this.countdownTimer !== null)
+            this.options.runtime.clearInterval(this.countdownTimer);
+        if (this.escalateTimer !== null)
+            this.options.runtime.clearTimeout(this.escalateTimer);
+        for (const timer of this.failureTimers.values())
+            this.options.runtime.clearTimeout(timer);
+        this.reconnectTimer = null;
+        this.countdownTimer = null;
+        this.escalateTimer = null;
+        this.failureTimers.clear();
+    }
+    detachSocket(socket) {
+        socket.onopen = null;
+        socket.onmessage = null;
+        socket.onerror = null;
+        socket.onclose = null;
+    }
+    async abortable(operation) {
+        const controller = new AbortController();
+        this.abortControllers.add(controller);
+        try {
+            return await operation(controller.signal);
+        }
+        catch (error) {
+            if (controller.signal.aborted)
+                throw new LifecycleAbort(error);
+            throw error;
+        }
+        finally {
+            this.abortControllers.delete(controller);
+        }
+    }
+    abortFetches() {
+        for (const controller of this.abortControllers)
+            controller.abort();
+        this.abortControllers.clear();
+    }
+}