@serve.zone/platformclient 2.3.0 → 3.0.0

package/dist_ts/coremail/classes.coremailconnector.js

@@ -0,0 +1,663 @@
+import * as plugins from '../plugins.js';
+class CoreMailTransferError extends Error {
+    constructor(messageArg, ambiguous) {
+        super(messageArg);
+        this.ambiguous = ambiguous;
+        this.name = 'CoreMailTransferError';
+    }
+}
+const identifierRegex = /^[A-Za-z0-9](?:[A-Za-z0-9._:-]{0,126}[A-Za-z0-9])?$/;
+export class SzCoreMailConnector {
+    constructor() {
+        this.stopped = false;
+        this.generation = 0;
+        this.stopController = new AbortController();
+        this.activeOperations = new Set();
+    }
+    get isConfigured() {
+        return Boolean(this.options);
+    }
+    configure(optionsArg) {
+        if (this.stopped) {
+            throw new Error('CoreMail connector has stopped.');
+        }
+        const options = this.normalizeOptions(optionsArg);
+        if (this.options) {
+            if (!this.optionsEqual(this.options, options)) {
+                throw new Error('CoreMail connector configuration is one-shot.');
+            }
+            return;
+        }
+        this.options = Object.freeze(options);
+    }
+    async init() {
+        await this.getAuthenticatedConnection();
+    }
+    async prepareOutboundSubmission(requestArg) {
+        const response = await this.fire('coreMailPrepareOutboundSubmission', {
+            idempotencyKey: requestArg.idempotencyKey,
+            message: plugins.servezoneInterfaces.data
+                .normalizeCoreMailOutboundMessageDescriptor(requestArg.message),
+        });
+        if (typeof response.replayed !== 'boolean') {
+            throw new Error('CoreMail returned an invalid replay state.');
+        }
+        return {
+            submission: plugins.servezoneInterfaces.data
+                .normalizeCoreMailSubmission(response.submission),
+            replayed: response.replayed,
+        };
+    }
+    async uploadOutboundPart(optionsArg) {
+        return await this.trackOperation(this.uploadOutboundPartInner(optionsArg));
+    }
+    async finalizeOutboundSubmission(submissionIdArg) {
+        const response = await this.fire('coreMailFinalizeOutboundSubmission', { submissionId: submissionIdArg });
+        return plugins.servezoneInterfaces.data
+            .normalizeCoreMailSubmission(response.submission);
+    }
+    async getOutboundSubmission(submissionIdArg) {
+        const response = await this.fire('coreMailGetOutboundSubmission', { submissionId: submissionIdArg });
+        return plugins.servezoneInterfaces.data
+            .normalizeCoreMailSubmission(response.submission);
+    }
+    async listInboundDeliveries(requestArg) {
+        const response = await this.fire('coreMailListInboundDeliveries', requestArg);
+        return plugins.servezoneInterfaces.data
+            .normalizeCoreMailInboundDeliveryPage(response);
+    }
+    async fetchInboundDelivery(deliveryArg) {
+        return await this.trackOperation(this.fetchInboundDeliveryInner(deliveryArg));
+    }
+    async acknowledgeInboundDelivery(requestArg) {
+        const response = await this.fire('coreMailAcknowledgeInboundDelivery', requestArg);
+        if (typeof response.replayed !== 'boolean') {
+            throw new Error('CoreMail returned an invalid acknowledgement replay state.');
+        }
+        return {
+            delivery: plugins.servezoneInterfaces.data
+                .normalizeCoreMailInboundDelivery(response.delivery),
+            replayed: response.replayed,
+        };
+    }
+    stop() {
+        this.stopPromise ??= this.stopInner();
+        return this.stopPromise;
+    }
+    normalizeOptions(optionsArg) {
+        const endpointUrl = new URL(optionsArg.endpointUrl);
+        if (optionsArg.endpointUrl.trim() !== optionsArg.endpointUrl
+            || endpointUrl.protocol !== 'https:'
+            || endpointUrl.username
+            || endpointUrl.password
+            || endpointUrl.search
+            || endpointUrl.hash
+            || endpointUrl.pathname !== '/socket'
+            || endpointUrl.toString() !== optionsArg.endpointUrl) {
+            throw new Error('CoreMail endpointUrl must be one canonical HTTPS /socket URL.');
+        }
+        for (const [name, value] of [
+            ['bindingId', optionsArg.bindingId],
+            ['credentialId', optionsArg.credentialId],
+        ]) {
+            if (typeof value !== 'string' || !identifierRegex.test(value)) {
+                throw new Error(`CoreMail ${name} must be canonical.`);
+            }
+        }
+        if (!Number.isSafeInteger(optionsArg.credentialVersion)
+            || optionsArg.credentialVersion < 1) {
+            throw new Error('CoreMail credentialVersion must be a positive integer.');
+        }
+        if (typeof optionsArg.credentialSecret !== 'string'
+            || optionsArg.credentialSecret.length < 32
+            || optionsArg.credentialSecret.length > 512) {
+            throw new Error('CoreMail credentialSecret must contain 32 to 512 characters.');
+        }
+        return {
+            endpointUrl: optionsArg.endpointUrl,
+            bindingId: optionsArg.bindingId,
+            credentialId: optionsArg.credentialId,
+            credentialVersion: optionsArg.credentialVersion,
+            credentialSecret: optionsArg.credentialSecret,
+        };
+    }
+    optionsEqual(leftArg, rightArg) {
+        return leftArg.endpointUrl === rightArg.endpointUrl
+            && leftArg.bindingId === rightArg.bindingId
+            && leftArg.credentialId === rightArg.credentialId
+            && leftArg.credentialVersion === rightArg.credentialVersion
+            && leftArg.credentialSecret === rightArg.credentialSecret;
+    }
+    requireOptions() {
+        if (this.stopped) {
+            throw this.createAbortError();
+        }
+        if (!this.options) {
+            throw new Error('CoreMail connector is not configured.');
+        }
+        return this.options;
+    }
+    async getAuthenticatedConnection() {
+        this.requireOptions();
+        if (this.connection
+            && this.connection.socket.getStatus() === 'connected') {
+            return this.connection;
+        }
+        if (this.pendingConnection) {
+            return await this.pendingConnection.promise;
+        }
+        const generation = ++this.generation;
+        const promise = this.connectAndAuthenticate(generation);
+        this.pendingConnection = { generation, promise };
+        try {
+            return await promise;
+        }
+        finally {
+            if (this.pendingConnection?.promise === promise) {
+                this.pendingConnection = undefined;
+            }
+        }
+    }
+    async connectAndAuthenticate(generationArg) {
+        const options = this.requireOptions();
+        let socket;
+        let statusSubscription;
+        let socketInvalidated = false;
+        try {
+            socket = await this.createSocket(options.endpointUrl);
+            this.assertGeneration(generationArg);
+            statusSubscription = socket.statusSubject.subscribe((statusArg) => {
+                if (statusArg !== 'connected') {
+                    socketInvalidated = true;
+                    this.invalidateConnection(socket, generationArg, statusSubscription);
+                }
+            });
+            const response = await this.trackOperation(socket.createTypedRequest('coreMailAuthenticateWorkload', undefined, {
+                timeoutMs: 4_500,
+                abortSignal: this.stopController.signal,
+            }).fire({
+                bindingId: options.bindingId,
+                credentialId: options.credentialId,
+                credentialVersion: options.credentialVersion,
+                credentialSecret: options.credentialSecret,
+            }));
+            this.assertGeneration(generationArg);
+            if (socket.getStatus() !== 'connected') {
+                throw new Error('CoreMail disconnected during authentication.');
+            }
+            const connection = {
+                generation: generationArg,
+                socket,
+                statusSubscription,
+                session: this.normalizeAuthenticationResponse(response, options),
+            };
+            this.connection = connection;
+            return connection;
+        }
+        catch (error) {
+            statusSubscription?.unsubscribe();
+            if (!socketInvalidated) {
+                await socket?.stop().catch(() => undefined);
+            }
+            throw error;
+        }
+    }
+    async createSocket(endpointUrlArg) {
+        return await plugins.typedsocket.TypedSocket.createClient(new plugins.typedrequest.TypedRouter(), endpointUrlArg, {
+            autoReconnect: false,
+            maxRetries: 0,
+            abortSignal: this.stopController.signal,
+        });
+    }
+    normalizeAuthenticationResponse(responseArg, optionsArg) {
+        if (!responseArg
+            || typeof responseArg !== 'object'
+            || Array.isArray(responseArg)
+            || JSON.stringify(Object.keys(responseArg).sort()) !== JSON.stringify([
+                'allowedOperations',
+                'authenticated',
+                'bindingState',
+                'capabilities',
+                'coreMailTransferOrigin',
+                'credentialId',
+                'credentialVersion',
+            ])
+            || responseArg.authenticated !== true
+            || responseArg.credentialId !== optionsArg.credentialId
+            || responseArg.credentialVersion !== optionsArg.credentialVersion
+            || (responseArg.bindingState !== 'active' && responseArg.bindingState !== 'draining')
+            || !Array.isArray(responseArg.capabilities)
+            || responseArg.capabilities.some((entryArg) => entryArg !== 'outbound' && entryArg !== 'inbound')
+            || new Set(responseArg.capabilities).size !== responseArg.capabilities.length
+            || !Array.isArray(responseArg.allowedOperations)) {
+            throw new Error('CoreMail returned invalid workload authentication authority.');
+        }
+        const expectedOperations = plugins.servezoneInterfaces.data.resolveCoreMailWorkloadOperations(responseArg.bindingState, responseArg.capabilities);
+        if (JSON.stringify(responseArg.allowedOperations)
+            !== JSON.stringify(expectedOperations)) {
+            throw new Error('CoreMail returned inconsistent workload operations.');
+        }
+        return Object.freeze({
+            bindingState: responseArg.bindingState,
+            capabilities: Object.freeze([...responseArg.capabilities]),
+            allowedOperations: Object.freeze([...responseArg.allowedOperations]),
+            transferOrigin: this.normalizeTransferOrigin(responseArg.coreMailTransferOrigin),
+        });
+    }
+    normalizeTransferOrigin(valueArg) {
+        if (typeof valueArg !== 'string') {
+            throw new Error('CoreMail returned an invalid transfer origin.');
+        }
+        const url = new URL(valueArg);
+        if (url.protocol !== 'https:'
+            || url.username
+            || url.password
+            || url.search
+            || url.hash
+            || url.pathname !== '/'
+            || url.origin !== valueArg) {
+            throw new Error('CoreMail returned a noncanonical transfer origin.');
+        }
+        return valueArg;
+    }
+    async fire(methodArg, requestArg) {
+        const connection = await this.getAuthenticatedConnection();
+        if (!connection.session.allowedOperations.includes(methodArg)) {
+            throw new Error(`CoreMail operation ${methodArg} is unavailable.`);
+        }
+        const response = await this.trackOperation(connection.socket.createTypedRequest(methodArg, undefined, {
+            timeoutMs: 30_000,
+            abortSignal: this.stopController.signal,
+        }).fire(requestArg));
+        this.assertGeneration(connection.generation);
+        return response;
+    }
+    async prepareUploadGrant(submissionIdArg, partIdArg) {
+        const connection = await this.getAuthenticatedConnection();
+        const method = 'coreMailPrepareOutboundPartUpload';
+        if (!connection.session.allowedOperations.includes(method)) {
+            throw new Error(`CoreMail operation ${method} is unavailable.`);
+        }
+        const response = await this.trackOperation(connection.socket.createTypedRequest(method, undefined, {
+            timeoutMs: 30_000,
+            abortSignal: this.stopController.signal,
+        }).fire({ submissionId: submissionIdArg, partId: partIdArg }));
+        this.assertGeneration(connection.generation);
+        return {
+            grant: plugins.servezoneInterfaces.data.normalizeCoreMailUploadGrant(response.grant),
+            connection,
+        };
+    }
+    async uploadOutboundPartInner(optionsArg) {
+        if (!(optionsArg.bytes instanceof Uint8Array)) {
+            throw new Error('CoreMail outbound part bytes must be a Uint8Array.');
+        }
+        const expectedSha256 = plugins.servezoneInterfaces.data
+            .normalizeCoreMailSha256(optionsArg.part.sha256);
+        const actualSha256 = await this.createSha256(optionsArg.bytes);
+        if (optionsArg.bytes.byteLength !== optionsArg.part.lengthBytes
+            || actualSha256 !== expectedSha256) {
+            throw new Error('CoreMail outbound part bytes do not match their descriptor.');
+        }
+        let lastError;
+        for (let grantAttempt = 0; grantAttempt < 2; grantAttempt++) {
+            const { grant, connection } = await this.prepareUploadGrant(optionsArg.submissionId, optionsArg.part.partId);
+            this.assertUploadGrantContext(grant, optionsArg.part, connection);
+            let uploadError;
+            try {
+                await this.putTransfer(grant, connection.session.transferOrigin, optionsArg.bytes);
+            }
+            catch (errorArg) {
+                uploadError = errorArg;
+            }
+            let completionError;
+            for (let completionAttempt = 0; completionAttempt < 2; completionAttempt++) {
+                try {
+                    const response = await this.fire('coreMailCompleteOutboundPartUpload', {
+                        submissionId: optionsArg.submissionId,
+                        partId: optionsArg.part.partId,
+                        grantId: grant.grantId,
+                        sha256: expectedSha256,
+                        lengthBytes: optionsArg.bytes.byteLength,
+                    });
+                    return plugins.servezoneInterfaces.data
+                        .normalizeCoreMailSubmission(response.submission);
+                }
+                catch (errorArg) {
+                    completionError = errorArg;
+                    if (!this.hasCoreMailErrorCode(errorArg, 'INVALID_REQUEST')) {
+                        throw uploadError ?? errorArg;
+                    }
+                    if (completionAttempt === 0) {
+                        await this.waitForDelay(25);
+                    }
+                }
+            }
+            const current = await this.getOutboundSubmission(optionsArg.submissionId);
+            const part = current.parts.find((entryArg) => entryArg.partId === optionsArg.part.partId);
+            if (part?.state === 'complete') {
+                return current;
+            }
+            lastError = uploadError ?? completionError;
+            const uploadWasAmbiguous = uploadError instanceof CoreMailTransferError
+                && uploadError.ambiguous;
+            if (grantAttempt === 0
+                && (uploadWasAmbiguous || !uploadError)
+                && this.hasCoreMailErrorCode(completionError, 'INVALID_REQUEST')) {
+                continue;
+            }
+            throw lastError;
+        }
+        throw lastError ?? new Error('CoreMail outbound part upload failed.');
+    }
+    assertUploadGrantContext(grantArg, partArg, connectionArg) {
+        this.assertGeneration(connectionArg.generation);
+        this.resolveTransferUrl(grantArg, connectionArg.session.transferOrigin);
+        if (grantArg.method !== 'PUT'
+            || grantArg.sha256 !== partArg.sha256
+            || grantArg.lengthBytes !== partArg.lengthBytes
+            || grantArg.contentType !== partArg.contentType) {
+            throw new Error('CoreMail upload grant does not match the prepared part.');
+        }
+    }
+    async putTransfer(grantArg, transferOriginArg, bytesArg) {
+        await this.trackOperation(this.putTransferInner(grantArg, transferOriginArg, bytesArg));
+    }
+    async putTransferInner(grantArg, transferOriginArg, bytesArg) {
+        const deadline = this.createTransferDeadline(plugins.servezoneInterfaces.data.coreMailLimits.transferOverallTimeoutMs);
+        try {
+            let response;
+            try {
+                response = await this.fetchTransfer(this.resolveTransferUrl(grantArg, transferOriginArg), {
+                    method: 'PUT',
+                    headers: {
+                        Authorization: `Bearer ${grantArg.bearerToken}`,
+                        'Content-Type': grantArg.contentType,
+                    },
+                    body: this.copyBytesToArrayBuffer(bytesArg),
+                    cache: 'no-store',
+                    credentials: 'omit',
+                    redirect: 'error',
+                    signal: deadline.controller.signal,
+                });
+            }
+            catch (error) {
+                if (deadline.controller.signal.aborted) {
+                    throw deadline.controller.signal.reason || error;
+                }
+                throw new CoreMailTransferError('CoreMail upload response is ambiguous.', true);
+            }
+            if (response.status !== 204) {
+                await response.body?.cancel().catch(() => undefined);
+                throw new CoreMailTransferError(`CoreMail upload failed with HTTP ${response.status}.`, false);
+            }
+        }
+        finally {
+            deadline.cleanup();
+        }
+    }
+    async fetchInboundDeliveryInner(deliveryArg) {
+        const delivery = plugins.servezoneInterfaces.data
+            .normalizeCoreMailInboundDelivery(deliveryArg);
+        const connection = await this.getAuthenticatedConnection();
+        const method = 'coreMailPrepareInboundFetch';
+        if (!connection.session.allowedOperations.includes(method)) {
+            throw new Error(`CoreMail operation ${method} is unavailable.`);
+        }
+        const response = await this.trackOperation(connection.socket.createTypedRequest(method, undefined, {
+            timeoutMs: 30_000,
+            abortSignal: this.stopController.signal,
+        }).fire({ deliveryId: delivery.deliveryId }));
+        this.assertGeneration(connection.generation);
+        const grant = plugins.servezoneInterfaces.data
+            .normalizeCoreMailDownloadGrant(response.grant);
+        this.assertDownloadGrantContext(grant, delivery, connection);
+        const bytes = await this.getTransfer(grant, connection.session.transferOrigin);
+        const completed = await this.completeInboundFetchWithRetry(delivery, grant);
+        return { delivery: completed, bytes };
+    }
+    assertDownloadGrantContext(grantArg, deliveryArg, connectionArg) {
+        this.assertGeneration(connectionArg.generation);
+        this.resolveTransferUrl(grantArg, connectionArg.session.transferOrigin);
+        if (grantArg.method !== 'GET'
+            || grantArg.sha256 !== deliveryArg.rawMime.sha256
+            || grantArg.lengthBytes !== deliveryArg.rawMime.lengthBytes
+            || grantArg.contentType !== deliveryArg.rawMime.contentType) {
+            throw new Error('CoreMail download grant does not match the selected delivery.');
+        }
+    }
+    async getTransfer(grantArg, transferOriginArg) {
+        return await this.trackOperation(this.getTransferInner(grantArg, transferOriginArg));
+    }
+    async getTransferInner(grantArg, transferOriginArg) {
+        const deadline = this.createTransferDeadline(plugins.servezoneInterfaces.data.coreMailLimits.transferOverallTimeoutMs);
+        let headerTimeout = setTimeout(() => {
+            deadline.controller.abort(new Error('CoreMail transfer header timeout.'));
+        }, plugins.servezoneInterfaces.data.coreMailLimits.transferHeaderTimeoutMs);
+        let responseBody;
+        let reader;
+        let idleTimeout;
+        try {
+            const response = await this.fetchTransfer(this.resolveTransferUrl(grantArg, transferOriginArg), {
+                method: 'GET',
+                headers: { Authorization: `Bearer ${grantArg.bearerToken}` },
+                cache: 'no-store',
+                credentials: 'omit',
+                redirect: 'error',
+                signal: deadline.controller.signal,
+            });
+            clearTimeout(headerTimeout);
+            headerTimeout = undefined;
+            responseBody = response.body || undefined;
+            if (response.status !== 200
+                || response.headers.get('content-type') !== grantArg.contentType
+                || response.headers.get('content-length') !== String(grantArg.lengthBytes)
+                || response.headers.get('cache-control') !== 'no-store'
+                || response.headers.get('x-content-type-options') !== 'nosniff'
+                || !responseBody) {
+                throw new Error('CoreMail download response metadata is invalid.');
+            }
+            reader = responseBody.getReader();
+            const chunks = [];
+            let totalLength = 0;
+            const resetIdleTimeout = () => {
+                if (idleTimeout)
+                    clearTimeout(idleTimeout);
+                idleTimeout = setTimeout(() => {
+                    deadline.controller.abort(new Error('CoreMail transfer idle timeout.'));
+                }, plugins.servezoneInterfaces.data.coreMailLimits.transferIdleTimeoutMs);
+            };
+            resetIdleTimeout();
+            while (true) {
+                const result = await reader.read();
+                if (result.done)
+                    break;
+                resetIdleTimeout();
+                totalLength += result.value.byteLength;
+                if (totalLength > grantArg.lengthBytes) {
+                    throw new Error('CoreMail download exceeds its declared length.');
+                }
+                chunks.push(result.value);
+            }
+            if (idleTimeout)
+                clearTimeout(idleTimeout);
+            if (totalLength !== grantArg.lengthBytes) {
+                throw new Error('CoreMail download length does not match its grant.');
+            }
+            const bytes = new Uint8Array(totalLength);
+            let offset = 0;
+            for (const chunk of chunks) {
+                bytes.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+            if (await this.createSha256(bytes) !== grantArg.sha256) {
+                throw new Error('CoreMail download digest does not match its grant.');
+            }
+            return bytes;
+        }
+        catch (error) {
+            if (reader) {
+                await reader.cancel().catch(() => undefined);
+            }
+            else {
+                await responseBody?.cancel().catch(() => undefined);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(headerTimeout);
+            if (idleTimeout)
+                clearTimeout(idleTimeout);
+            deadline.cleanup();
+        }
+    }
+    async completeInboundFetchWithRetry(deliveryArg, grantArg) {
+        let lastError;
+        for (let attempt = 0; attempt < 4; attempt++) {
+            try {
+                const response = await this.fire('coreMailCompleteInboundFetch', {
+                    deliveryId: deliveryArg.deliveryId,
+                    grantId: grantArg.grantId,
+                    sha256: grantArg.sha256,
+                    lengthBytes: grantArg.lengthBytes,
+                });
+                const delivery = plugins.servezoneInterfaces.data
+                    .normalizeCoreMailInboundDelivery(response.delivery);
+                if (delivery.deliveryId !== deliveryArg.deliveryId) {
+                    throw new Error('CoreMail completed another inbound delivery.');
+                }
+                return delivery;
+            }
+            catch (errorArg) {
+                lastError = errorArg;
+                if (attempt === 3
+                    || !this.hasCoreMailErrorCode(errorArg, 'INVALID_REQUEST')) {
+                    throw errorArg;
+                }
+                await this.waitForDelay(25 * (2 ** attempt));
+            }
+        }
+        throw lastError;
+    }
+    resolveTransferUrl(grantArg, transferOriginArg) {
+        const url = new URL(grantArg.path, transferOriginArg);
+        if (url.origin !== transferOriginArg
+            || url.pathname !== grantArg.path
+            || url.search
+            || url.hash) {
+            throw new Error('CoreMail transfer grant escapes its authenticated origin.');
+        }
+        return url.toString();
+    }
+    async createSha256(bytesArg) {
+        const digest = new Uint8Array(await globalThis.crypto.subtle.digest('SHA-256', this.copyBytesToArrayBuffer(bytesArg)));
+        return `sha256:${Array.from(digest)
+            .map((byteArg) => byteArg.toString(16).padStart(2, '0'))
+            .join('')}`;
+    }
+    copyBytesToArrayBuffer(bytesArg) {
+        const bytes = new Uint8Array(bytesArg.byteLength);
+        bytes.set(bytesArg);
+        return bytes.buffer;
+    }
+    async fetchTransfer(inputArg, initArg) {
+        return await globalThis.fetch(inputArg, initArg);
+    }
+    createTransferDeadline(timeoutMsArg) {
+        const controller = new AbortController();
+        const onStop = () => controller.abort(this.stopController.signal.reason);
+        if (this.stopController.signal.aborted) {
+            onStop();
+        }
+        else {
+            this.stopController.signal.addEventListener('abort', onStop, { once: true });
+        }
+        const timeout = setTimeout(() => {
+            controller.abort(new Error('CoreMail transfer overall timeout.'));
+        }, timeoutMsArg);
+        return {
+            controller,
+            cleanup: () => {
+                clearTimeout(timeout);
+                this.stopController.signal.removeEventListener('abort', onStop);
+            },
+        };
+    }
+    hasCoreMailErrorCode(errorArg, codeArg) {
+        if (!(errorArg instanceof plugins.typedrequest.TypedResponseError)) {
+            return false;
+        }
+        try {
+            return plugins.servezoneInterfaces.data
+                .normalizeCoreMailErrorData(errorArg.errorData).code === codeArg;
+        }
+        catch {
+            return false;
+        }
+    }
+    async waitForDelay(delayMsArg) {
+        if (this.stopController.signal.aborted)
+            throw this.createAbortError();
+        await this.trackOperation(new Promise((resolveArg, rejectArg) => {
+            const timeout = setTimeout(() => {
+                this.stopController.signal.removeEventListener('abort', onAbort);
+                resolveArg();
+            }, delayMsArg);
+            const onAbort = () => {
+                clearTimeout(timeout);
+                rejectArg(this.createAbortError());
+            };
+            this.stopController.signal.addEventListener('abort', onAbort, { once: true });
+        }));
+    }
+    invalidateConnection(socketArg, generationArg, subscriptionArg) {
+        const ownsConnection = this.connection?.socket === socketArg
+            && this.connection.generation === generationArg;
+        const ownsPending = this.pendingConnection?.generation === generationArg;
+        if (!ownsConnection && !ownsPending)
+            return;
+        this.generation++;
+        if (ownsConnection)
+            this.connection = undefined;
+        if (ownsPending)
+            this.pendingConnection = undefined;
+        subscriptionArg.unsubscribe();
+        void socketArg.stop().catch(() => undefined);
+    }
+    assertGeneration(generationArg) {
+        if (this.stopped || generationArg !== this.generation) {
+            throw this.createAbortError();
+        }
+    }
+    trackOperation(promiseArg) {
+        this.activeOperations.add(promiseArg);
+        return promiseArg.finally(() => {
+            this.activeOperations.delete(promiseArg);
+        });
+    }
+    async stopInner() {
+        this.stopped = true;
+        this.generation++;
+        this.stopController.abort(this.createAbortError());
+        const connection = this.connection;
+        const pendingConnection = this.pendingConnection;
+        this.connection = undefined;
+        this.pendingConnection = undefined;
+        connection?.statusSubscription.unsubscribe();
+        await Promise.allSettled([
+            connection?.socket.stop(),
+            pendingConnection?.promise.then(async (resultArg) => {
+                resultArg.statusSubscription.unsubscribe();
+                await resultArg.socket.stop();
+            }),
+            ...this.activeOperations,
+        ].filter(Boolean));
+        this.options = undefined;
+    }
+    createAbortError() {
+        const error = new Error('CoreMail connector operation aborted.');
+        error.name = 'AbortError';
+        return error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.coremailconnector.js","sourceRoot":"","sources":["../../ts/coremail/classes.coremailconnector.ts"],"names":[],"mappings":"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"}