miakapi 3.0.31 → 4.0.0-alpha.1

package/dist/browser-client.js

@@ -0,0 +1,678 @@
+import { createBrowserRuntime } from './internal/browser-socket.js';
+import { BrowserClientError, browserCancelled, browserInternalFailure, browserInvalidLifecycle, browserProtocolFailure, browserRelayFailure, browserUnavailable, safeBrowserLog, } from './internal/browser-errors.js';
+import { UserCallManager } from './internal/user-calls.js';
+import { childAbortController, createDeferred, IdSequence, ListenerSet, } from './internal/resources.js';
+import { delay } from './internal/runtime.js';
+import { parseUserHomeStatus, UserRelaySession } from './internal/user-session.js';
+import { UserStateManager } from './internal/user-state.js';
+import { validateBrowserClientOptions, validateBrowserRelayCredential, validateStartOptions, validateStopOptions, } from './internal/validation.js';
+import { Opcode } from './protocol/codec.js';
+const FIRST_RECONNECT_CEILING_MS = 1_000;
+const MAX_RECONNECT_CEILING_MS = 30_000;
+const SESSION_PHASE_TIMEOUT_MS = 10_000;
+function relayInteger(frame, index, label, minimum = 0) {
+    const value = frame.payload[index];
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < minimum) {
+        throw browserProtocolFailure(`${label} is not an integer`);
+    }
+    return value;
+}
+function relayBoolean(frame, index, label) {
+    const value = frame.payload[index];
+    if (typeof value !== 'boolean')
+        throw browserProtocolFailure(`${label} is not a boolean`);
+    return value;
+}
+function sameEpoch(left, right) {
+    return right instanceof Uint8Array
+        && right.length === left.length
+        && right.every((value, index) => value === left[index]);
+}
+class BrowserClientImpl {
+    #options;
+    #runtime;
+    #lifecycleListeners = new ListenerSet();
+    #errorListeners = new ListenerSet();
+    #homeListeners = new ListenerSet();
+    #loopController = new AbortController();
+    home;
+    state;
+    calls;
+    errors;
+    #status = 'idle';
+    #started = false;
+    #session;
+    #sessionEnd;
+    #sessionReady;
+    #startDeferred;
+    #stopDeferred;
+    #stopTimer;
+    #bootstrapTimer;
+    #loopTask;
+    #startSignal;
+    #startAbort;
+    #credentialRequest;
+    #reauthentication;
+    #reauthTimer;
+    #sessionRelayUrl;
+    #requestIds = new IdSequence();
+    #callIds = new IdSequence();
+    #localCallIds = new IdSequence();
+    #reconnectAttempt = 0;
+    #goawayRetryAfterMs;
+    #stateReady = false;
+    #functionReady = false;
+    #topicReady = false;
+    #homeStatus;
+    constructor(options, runtime) {
+        this.#options = options;
+        this.#runtime = runtime;
+        this.state = new UserStateManager(this);
+        this.calls = new UserCallManager(this);
+        this.home = Object.freeze({
+            snapshot: () => this.#homeStatus,
+            subscribe: (listener) => this.#subscribeHome(listener),
+        });
+        this.errors = Object.freeze({
+            subscribe: (listener) => {
+                if (typeof listener !== 'function')
+                    throw new TypeError('error listener must be a function');
+                return this.#errorListeners.subscribe(listener);
+            },
+        });
+    }
+    get status() {
+        return this.#status;
+    }
+    start(options = {}) {
+        if (this.#started || this.#status !== 'idle') {
+            return Promise.reject(browserInvalidLifecycle('Browser client has already started or stopped'));
+        }
+        const signal = validateStartOptions(options);
+        if (signal?.aborted === true)
+            return Promise.reject(browserCancelled('not_dispatched'));
+        this.#started = true;
+        this.#startDeferred = createDeferred();
+        if (signal !== undefined) {
+            const abort = () => void this.stop();
+            this.#startSignal = signal;
+            this.#startAbort = abort;
+            signal.addEventListener('abort', abort, { once: true });
+        }
+        this.#loopTask = this.#runConnectionLoop();
+        void this.#loopTask.catch(() => {
+            const failure = browserInternalFailure();
+            this.#startDeferred?.reject(failure);
+            this.#emitFailure(failure);
+            void this.stop();
+        });
+        return this.#startDeferred.promise;
+    }
+    stop(options = {}) {
+        if (this.#stopDeferred !== undefined)
+            return this.#stopDeferred.promise;
+        let deadlineMs;
+        try {
+            deadlineMs = validateStopOptions(options);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        this.#stopDeferred = createDeferred();
+        const stopping = browserCancelled('not_dispatched', 'Browser client is stopping');
+        this.#transition('stopping');
+        this.calls.stop();
+        this.state.stop();
+        this.#markHomeStale();
+        this.#clearReauthentication();
+        this.#abortCredentialRequest();
+        this.#loopController.abort(stopping);
+        this.#sessionReady?.reject(stopping);
+        this.#sessionEnd?.resolve({ failure: stopping });
+        this.#session?.terminate();
+        this.#startDeferred?.reject(stopping);
+        const finish = () => this.#finishStop();
+        if (this.#loopTask === undefined)
+            finish();
+        else {
+            this.#stopTimer = this.#runtime.setTimer(finish, deadlineMs);
+            void this.#loopTask.then(finish, finish);
+        }
+        return this.#stopDeferred.promise;
+    }
+    subscribe(listener) {
+        if (typeof listener !== 'function')
+            throw new TypeError('lifecycle listener must be a function');
+        return this.#lifecycleListeners.subscribe(listener);
+    }
+    nextRequestId() {
+        return this.#requestIds.take();
+    }
+    nextCallId() {
+        return this.#callIds.take();
+    }
+    nextLocalCallId() {
+        return this.#localCallIds.take();
+    }
+    runtime() {
+        return this.#runtime;
+    }
+    readySession() {
+        return this.#status === 'ready' ? this.#session : undefined;
+    }
+    send(frame) {
+        const session = this.#session;
+        if (session === undefined || (this.#status !== 'ready' && this.#status !== 'synchronizing')) {
+            return Promise.reject(browserUnavailable());
+        }
+        return session.send(frame);
+    }
+    stateSynchronized() {
+        this.#stateReady = true;
+        this.#maybeReady();
+    }
+    functionDictionarySynchronized() {
+        this.#functionReady = true;
+        this.#maybeReady();
+    }
+    transportFailure(error) {
+        const failure = error instanceof BrowserClientError
+            ? error
+            : browserUnavailable('Browser relay transport failed');
+        this.#sessionReady?.reject(failure);
+        this.#sessionEnd?.resolve({ failure });
+        this.#session?.terminate();
+    }
+    emitFailure(failure) {
+        this.#emitFailure(failure);
+    }
+    async #runConnectionLoop() {
+        let reason = 'initial';
+        let pendingCredential;
+        while (!this.#loopController.signal.aborted) {
+            let end = {};
+            let connectionEnd;
+            try {
+                this.#transition('connecting');
+                if (this.#loopController.signal.aborted)
+                    break;
+                const credential = pendingCredential ?? await this.#getCredential(reason);
+                pendingCredential = undefined;
+                if (this.#loopController.signal.aborted)
+                    break;
+                if (credential.expiresAtMs <= this.#runtime.now()) {
+                    throw browserUnavailable('Browser relay credential expired before connection');
+                }
+                this.#transition('authenticating');
+                if (this.#loopController.signal.aborted)
+                    break;
+                this.#requestIds = new IdSequence();
+                this.#callIds = new IdSequence();
+                connectionEnd = createDeferred();
+                const sessionReady = createDeferred();
+                void sessionReady.promise.catch(() => undefined);
+                this.#sessionEnd = connectionEnd;
+                this.#sessionReady = sessionReady;
+                this.#goawayRetryAfterMs = undefined;
+                const session = await UserRelaySession.connect(this.#runtime, this.#options.homeId, credential.relayUrl, credential.accessToken, this.#loopController.signal, {
+                    frame: (frame) => this.#handleFrame(frame),
+                    closed: () => {
+                        const failure = browserUnavailable('Browser relay connection closed');
+                        sessionReady.reject(failure);
+                        connectionEnd?.resolve(this.#goawayRetryAfterMs === undefined
+                            ? { failure }
+                            : { failure, retryAfterMs: this.#goawayRetryAfterMs });
+                    },
+                    failed: (error) => {
+                        const failure = error instanceof BrowserClientError
+                            ? error
+                            : browserUnavailable('Browser relay connection failed');
+                        sessionReady.reject(failure);
+                        connectionEnd?.resolve({ failure });
+                    },
+                }, (createdSession) => {
+                    this.#session = createdSession;
+                    this.#sessionRelayUrl = credential.relayUrl;
+                });
+                if (this.#loopController.signal.aborted) {
+                    session.terminate();
+                    session.detach();
+                    break;
+                }
+                if (credential.expiresAtMs <= this.#runtime.now()) {
+                    session.terminate();
+                    throw browserUnavailable('Browser relay credential expired during authentication');
+                }
+                this.#reconnectAttempt = 0;
+                this.#setHomeStatus(Object.freeze({
+                    enrolled: session.welcome.readySession.enrolled,
+                    coordinators: session.welcome.readySession.coordinators,
+                    stale: false,
+                }));
+                if (this.#loopController.signal.aborted)
+                    break;
+                this.#stateReady = false;
+                this.#functionReady = false;
+                this.#topicReady = false;
+                this.state.beginSession(session.welcome.epoch);
+                this.calls.beginSession(session.welcome.epoch);
+                this.#transition('synchronizing');
+                if (this.#loopController.signal.aborted)
+                    break;
+                this.#scheduleReauthentication(Math.min(session.welcome.expiresAtMs, credential.expiresAtMs));
+                const bootstrapTimeout = this.#runtime.setTimer(() => {
+                    const failure = browserUnavailable('Browser relay bootstrap timed out');
+                    sessionReady.reject(failure);
+                    connectionEnd?.resolve({ failure });
+                    session.terminate();
+                }, SESSION_PHASE_TIMEOUT_MS);
+                this.#bootstrapTimer = bootstrapTimeout;
+                session.startDelivery();
+                try {
+                    await Promise.race([
+                        sessionReady.promise,
+                        connectionEnd.promise.then((closed) => Promise.reject(closed.failure ?? browserUnavailable('Browser relay closed during synchronization'))),
+                    ]);
+                }
+                finally {
+                    bootstrapTimeout.cancel();
+                    if (this.#bootstrapTimer === bootstrapTimeout)
+                        this.#bootstrapTimer = undefined;
+                }
+                if (this.#loopController.signal.aborted)
+                    break;
+                end = await connectionEnd.promise;
+            }
+            catch (error) {
+                if (this.#loopController.signal.aborted)
+                    break;
+                end = connectionEnd?.settled === true
+                    ? await connectionEnd.promise
+                    : { failure: error instanceof BrowserClientError
+                            ? error
+                            : browserUnavailable('Browser relay connection attempt failed') };
+            }
+            const endedSession = this.#session;
+            this.#deactivateSession();
+            if (this.#loopController.signal.aborted)
+                break;
+            if (end.failure !== undefined)
+                this.#emitFailure(end.failure);
+            if (this.#loopController.signal.aborted)
+                break;
+            this.#transition('reconnecting', undefined, end.failure);
+            if (this.#loopController.signal.aborted)
+                break;
+            if (endedSession !== undefined
+                && !endedSession.transportClosed
+                && !await this.#waitForTransportClose(endedSession)) {
+                if (!this.#loopController.signal.aborted) {
+                    const failure = browserUnavailable('Browser relay transport close timed out');
+                    this.#emitFailure(failure);
+                    this.#startDeferred?.reject(failure);
+                    void this.stop();
+                }
+                break;
+            }
+            this.#disconnectSession();
+            if (this.#loopController.signal.aborted)
+                break;
+            if (end.handoffCredential !== undefined) {
+                pendingCredential = end.handoffCredential;
+                reason = 'reconnect';
+                continue;
+            }
+            const ceiling = Math.min(FIRST_RECONNECT_CEILING_MS * (2 ** this.#reconnectAttempt), MAX_RECONNECT_CEILING_MS);
+            this.#reconnectAttempt += 1;
+            const randomDelay = Math.floor(this.#runtime.random() * (ceiling + 1));
+            try {
+                await delay(this.#runtime, Math.max(randomDelay, end.retryAfterMs ?? 0), this.#loopController.signal);
+            }
+            catch {
+                break;
+            }
+            reason = 'reconnect';
+        }
+    }
+    async #getCredential(reason, timeoutMs = SESSION_PHASE_TIMEOUT_MS) {
+        if (this.#credentialRequest !== undefined)
+            return this.#credentialRequest.promise;
+        const child = childAbortController(this.#loopController.signal);
+        const request = Object.freeze({
+            homeId: this.#options.homeId,
+            reason,
+            signal: child.controller.signal,
+        });
+        let abort;
+        const interrupted = new Promise((_resolve, reject) => {
+            abort = () => reject(child.controller.signal.reason ?? browserCancelled('not_dispatched'));
+            if (child.controller.signal.aborted)
+                abort();
+            else
+                child.controller.signal.addEventListener('abort', abort, { once: true });
+        });
+        const provider = Promise.resolve()
+            .then(() => {
+            if (child.controller.signal.aborted) {
+                throw child.controller.signal.reason ?? browserCancelled('not_dispatched');
+            }
+            return this.#options.credentialProvider.getCredential(request);
+        })
+            .then((value) => validateBrowserRelayCredential(value, this.#runtime.now()))
+            .catch(() => { throw browserUnavailable('Browser relay credential provider failed'); });
+        const timeout = this.#runtime.setTimer(() => {
+            child.controller.abort(browserUnavailable('Browser relay credential request timed out'));
+        }, Math.max(1, Math.min(timeoutMs, SESSION_PHASE_TIMEOUT_MS)));
+        const promise = Promise.race([provider, interrupted]);
+        let disposed = false;
+        const dispose = () => {
+            if (disposed)
+                return;
+            disposed = true;
+            timeout.cancel();
+            if (abort !== undefined)
+                child.controller.signal.removeEventListener('abort', abort);
+            child.dispose();
+        };
+        const credentialRequest = { controller: child.controller, dispose, promise };
+        this.#credentialRequest = credentialRequest;
+        void promise.finally(() => {
+            dispose();
+            if (this.#credentialRequest === credentialRequest)
+                this.#credentialRequest = undefined;
+        }).catch(() => undefined);
+        return promise;
+    }
+    #abortCredentialRequest() {
+        const request = this.#credentialRequest;
+        if (request === undefined)
+            return;
+        request.controller.abort(browserCancelled('not_dispatched'));
+        request.dispose();
+        this.#credentialRequest = undefined;
+    }
+    #scheduleReauthentication(expiresAtMs) {
+        this.#clearReauthentication();
+        if (this.#status === 'draining' || this.#status === 'stopping' || this.#status === 'stopped')
+            return;
+        const remaining = Math.max(0, expiresAtMs - this.#runtime.now());
+        const lead = Math.min(30_000, Math.floor(remaining / 2));
+        this.#reauthTimer = this.#runtime.setTimer(() => void this.#reauthenticate(expiresAtMs), remaining - lead);
+    }
+    async #reauthenticate(currentExpiresAtMs) {
+        const session = this.#session;
+        if (session === undefined || this.#loopController.signal.aborted)
+            return;
+        try {
+            const credential = await this.#getCredential('reauth', Math.max(1, currentExpiresAtMs - this.#runtime.now()));
+            if (!this.#mayReauthenticate(session))
+                return;
+            if (this.#sessionRelayUrl === undefined) {
+                throw browserUnavailable('Browser relay routing state is unavailable');
+            }
+            if (credential.relayUrl !== this.#sessionRelayUrl) {
+                if (this.#sessionEnd === undefined || this.#sessionEnd.settled) {
+                    throw browserUnavailable('Browser relay handoff state is unavailable');
+                }
+                session.terminate();
+                this.#sessionEnd.resolve({ handoffCredential: credential });
+                return;
+            }
+            const remaining = Math.min(currentExpiresAtMs, credential.expiresAtMs)
+                - this.#runtime.now();
+            if (remaining <= 0)
+                throw browserUnavailable('Browser authentication lease expired');
+            const requestId = this.nextRequestId();
+            const deferred = createDeferred();
+            void deferred.promise.catch(() => undefined);
+            const timer = this.#runtime.setTimer(() => {
+                deferred.reject(browserUnavailable('Browser reauthentication timed out'));
+            }, Math.max(1, Math.min(remaining, SESSION_PHASE_TIMEOUT_MS)));
+            this.#reauthentication = {
+                requestId,
+                maximumExpiresAtMs: credential.expiresAtMs,
+                deferred,
+                timer,
+            };
+            await session.send({ opcode: Opcode.Reauth, payload: [requestId, credential.accessToken] });
+            const expiresAtMs = await deferred.promise;
+            if (this.#mayReauthenticate(session))
+                this.#scheduleReauthentication(expiresAtMs);
+        }
+        catch {
+            if (this.#mayReauthenticate(session)) {
+                this.transportFailure(browserUnavailable('Browser reauthentication failed'));
+            }
+        }
+    }
+    #mayReauthenticate(session) {
+        return this.#session === session
+            && !this.#loopController.signal.aborted
+            && this.#status !== 'draining';
+    }
+    async #waitForTransportClose(session) {
+        const interrupted = createDeferred();
+        const abort = () => interrupted.resolve(false);
+        if (this.#loopController.signal.aborted)
+            return false;
+        this.#loopController.signal.addEventListener('abort', abort, { once: true });
+        if (this.#loopController.signal.aborted)
+            abort();
+        const timeout = this.#runtime.setTimer(() => interrupted.resolve(false), SESSION_PHASE_TIMEOUT_MS);
+        try {
+            return await Promise.race([
+                session.waitForTransportClose().then(() => true),
+                interrupted.promise,
+            ]);
+        }
+        finally {
+            timeout.cancel();
+            this.#loopController.signal.removeEventListener('abort', abort);
+        }
+    }
+    #clearReauthentication() {
+        this.#reauthTimer?.cancel();
+        this.#reauthTimer = undefined;
+        this.#reauthentication?.timer.cancel();
+        this.#reauthentication?.deferred.reject(browserCancelled('not_dispatched'));
+        this.#reauthentication = undefined;
+    }
+    #handleFrame(frame) {
+        try {
+            if (frame.opcode >= 0x80)
+                return;
+            if (frame.opcode === Opcode.Error) {
+                this.#handleRelayError(frame);
+                return;
+            }
+            if (frame.opcode === Opcode.Fatal) {
+                const code = relayInteger(frame, 1, 'FATAL.code', 1);
+                const retryable = relayBoolean(frame, 2, 'FATAL.retryable');
+                const failure = browserRelayFailure(code, retryable, 'not_dispatched');
+                if (retryable)
+                    this.transportFailure(failure);
+                else {
+                    this.#emitFailure(failure);
+                    this.#startDeferred?.reject(failure);
+                    void this.stop();
+                }
+                return;
+            }
+            if (frame.opcode === Opcode.ReauthOk) {
+                const requestId = relayInteger(frame, 0, 'REAUTH_OK.requestId', 1);
+                if (this.#reauthentication?.requestId !== requestId) {
+                    throw browserProtocolFailure('REAUTH_OK is not correlated');
+                }
+                const expiresAtMs = relayInteger(frame, 1, 'REAUTH_OK.expiresAtMs', 1);
+                if (expiresAtMs <= this.#runtime.now()
+                    || expiresAtMs > this.#reauthentication.maximumExpiresAtMs) {
+                    throw browserProtocolFailure('REAUTH_OK expiry is outside the credential lease');
+                }
+                this.#reauthentication.timer.cancel();
+                this.#reauthentication.deferred.resolve(expiresAtMs);
+                this.#reauthentication = undefined;
+                return;
+            }
+            if (frame.opcode === Opcode.Goaway) {
+                this.#transition('draining');
+                this.#reauthTimer?.cancel();
+                this.#reauthTimer = undefined;
+                this.#abortCredentialRequest();
+                this.#goawayRetryAfterMs = relayInteger(frame, 0, 'GOAWAY.retryAfterMs');
+                return;
+            }
+            if (frame.opcode === Opcode.HomeStatus) {
+                this.#setHomeStatus(parseUserHomeStatus(frame.payload[0], frame.payload[1], false));
+                return;
+            }
+            if (frame.opcode === Opcode.TopicDict) {
+                if (this.#session === undefined || !sameEpoch(this.#session.welcome.epoch, frame.payload[0])) {
+                    throw browserProtocolFailure('TOPIC_DICT uses a stale epoch');
+                }
+                if (frame.payload[1] === true) {
+                    this.#topicReady = true;
+                    this.#maybeReady();
+                }
+                return;
+            }
+            if (this.state.handleFrame(frame) || this.calls.handleFrame(frame))
+                return;
+            throw browserProtocolFailure('Relay sent an unsupported user frame');
+        }
+        catch (error) {
+            this.transportFailure(error instanceof Error ? error : browserProtocolFailure());
+        }
+    }
+    #handleRelayError(frame) {
+        const correlationId = relayInteger(frame, 0, 'ERROR.correlationId');
+        const sourceOpcode = relayInteger(frame, 1, 'ERROR.sourceOpcode');
+        const code = relayInteger(frame, 2, 'ERROR.code', 1);
+        const retryable = relayBoolean(frame, 3, 'ERROR.retryable');
+        if (sourceOpcode === Opcode.StateResync
+            && this.state.handleError(correlationId, code, retryable))
+            return;
+        if ((sourceOpcode === Opcode.Call || sourceOpcode === Opcode.CallCancel)
+            && this.calls.handleError(correlationId, code, retryable))
+            return;
+        if (sourceOpcode === Opcode.CallError
+            && this.calls.handleResponseError(correlationId, code, retryable))
+            return;
+        if (sourceOpcode === Opcode.Reauth && this.#reauthentication?.requestId === correlationId) {
+            this.#reauthentication.timer.cancel();
+            this.#reauthentication.deferred.reject(browserRelayFailure(code, retryable, 'not_dispatched'));
+            this.#reauthentication = undefined;
+            return;
+        }
+        if (correlationId !== 0 || sourceOpcode !== 0) {
+            throw browserProtocolFailure('ERROR is not correlated to an active operation');
+        }
+        this.#emitFailure(browserRelayFailure(code, retryable, 'not_dispatched'));
+    }
+    #maybeReady() {
+        const session = this.#session;
+        if (this.#status !== 'synchronizing'
+            || !this.#stateReady
+            || !this.#functionReady
+            || !this.#topicReady
+            || session === undefined)
+            return;
+        const ready = session.welcome.readySession;
+        this.#bootstrapTimer?.cancel();
+        this.#bootstrapTimer = undefined;
+        this.#transition('ready', ready);
+        this.#sessionReady?.resolve(undefined);
+        this.#startDeferred?.resolve(ready);
+    }
+    #disconnectSession() {
+        this.#deactivateSession();
+        this.#session?.detach();
+        this.#session = undefined;
+        this.#sessionRelayUrl = undefined;
+        this.#sessionEnd = undefined;
+        this.#sessionReady = undefined;
+        this.#goawayRetryAfterMs = undefined;
+        this.#stateReady = false;
+        this.#functionReady = false;
+        this.#topicReady = false;
+    }
+    #deactivateSession() {
+        this.#bootstrapTimer?.cancel();
+        this.#bootstrapTimer = undefined;
+        this.#clearReauthentication();
+        this.#abortCredentialRequest();
+        this.state.disconnected();
+        this.calls.disconnected();
+        this.#markHomeStale();
+    }
+    #emitFailure(failure) {
+        this.#errorListeners.emit(failure, () => {
+            safeBrowserLog(this.#options.logger, { level: 'error', event: 'error_listener_failed' });
+        });
+    }
+    #subscribeHome(listener) {
+        if (typeof listener !== 'function')
+            throw new TypeError('home listener must be a function');
+        const remove = this.#homeListeners.subscribe(listener);
+        if (this.#homeStatus !== undefined) {
+            try {
+                listener(this.#homeStatus);
+            }
+            catch {
+                this.#emitFailure(browserInternalFailure());
+            }
+        }
+        return remove;
+    }
+    #setHomeStatus(status) {
+        this.#homeStatus = status;
+        this.#homeListeners.emit(status, () => this.#emitFailure(browserInternalFailure()));
+    }
+    #markHomeStale() {
+        const status = this.#homeStatus;
+        if (status === undefined || status.stale)
+            return;
+        this.#setHomeStatus(Object.freeze({ ...status, stale: true }));
+    }
+    #transition(current, session, reason) {
+        if ((this.#status === 'stopping' || this.#status === 'stopped') && current !== 'stopped')
+            return;
+        if (this.#status === current)
+            return;
+        const previous = this.#status;
+        this.#status = current;
+        const event = session === undefined && reason === undefined
+            ? Object.freeze({ previous, current })
+            : session === undefined
+                ? Object.freeze({ previous, current, reason })
+                : reason === undefined
+                    ? Object.freeze({ previous, current, session })
+                    : Object.freeze({ previous, current, session, reason });
+        safeBrowserLog(this.#options.logger, { level: 'info', event: 'status_changed', status: current });
+        this.#lifecycleListeners.emit(event, () => {
+            safeBrowserLog(this.#options.logger, { level: 'error', event: 'lifecycle_listener_failed' });
+        });
+    }
+    #finishStop() {
+        if (this.#status === 'stopped')
+            return;
+        this.#stopTimer?.cancel();
+        this.#stopTimer = undefined;
+        this.#disconnectSession();
+        if (this.#startSignal !== undefined && this.#startAbort !== undefined) {
+            this.#startSignal.removeEventListener('abort', this.#startAbort);
+        }
+        this.#transition('stopped');
+        this.#stopDeferred?.resolve(undefined);
+        this.#lifecycleListeners.clear();
+        this.#errorListeners.clear();
+        this.#homeListeners.clear();
+    }
+}
+export function createBrowserClient(options) {
+    return new BrowserClientImpl(validateBrowserClientOptions(options), createBrowserRuntime());
+}
+/** @internal */
+export function createBrowserClientWithRuntime(options, runtime) {
+    return new BrowserClientImpl(validateBrowserClientOptions(options), runtime);
+}
+//# sourceMappingURL=browser-client.js.map