@serve.zone/coremail 1.0.0

package/dist_ts/classes.inbound.js

@@ -0,0 +1,702 @@
+import * as plugins from './plugins.js';
+import {} from './classes.models.js';
+import { createOpaqueToken, createSha256, } from './classes.storage.js';
+import { CoreMailTransferService } from './classes.transfer.js';
+import { normalizeCoreMailConnectionInfo, normalizeCoreMailEnvelope, normalizeCoreMailGatewayMessage, normalizeCoreMailMailboxAddress, } from './coremail.validation.js';
+import { CoreMailInboundCursorCodec } from './coremail.cursor.js';
+import { createCoreMailPendingQuotaDescriptor, decrementCoreMailQuotaCounter, ensureCoreMailQuotaCounter, incrementCoreMailQuotaCounter, withCoreMailTransaction, } from './coremail.quota.js';
+import { requireCoreMailIdentifier, requireCoreMailUuid, } from './coremail.selectors.js';
+const routingHandleTtlMs = plugins.serveZoneInterfaces.data.coreMailLimits.routingHandleTtlMs;
+const listLimitMaximum = plugins.serveZoneInterfaces.data.coreMailLimits.inboundPageSize;
+const gatewayAuthority = (serviceIdArg) => ({
+    kind: 'gateway',
+    tenantId: '-',
+    serviceId: serviceIdArg,
+    bindingId: '-',
+});
+const workloadAuthority = (sessionArg) => ({
+    kind: 'workload',
+    tenantId: sessionArg.tenantId,
+    serviceId: sessionArg.serviceId,
+    bindingId: sessionArg.bindingId,
+});
+const workloadFilter = (sessionArg, deliveryIdArg) => ({
+    tenantId: requireCoreMailIdentifier(sessionArg.tenantId, 'session.tenantId'),
+    serviceId: requireCoreMailIdentifier(sessionArg.serviceId, 'session.serviceId'),
+    bindingId: requireCoreMailIdentifier(sessionArg.bindingId, 'session.bindingId'),
+    bindingRevision: sessionArg.bindingRevision,
+    ...(deliveryIdArg === undefined
+        ? {}
+        : { deliveryId: requireCoreMailUuid(deliveryIdArg, 'deliveryId') }),
+});
+const toPublicDelivery = (deliveryArg) => ({
+    deliveryId: deliveryArg.deliveryId,
+    transportDeliveryId: deliveryArg.transportDeliveryId,
+    state: deliveryArg.state,
+    envelope: deliveryArg.envelope,
+    rawMime: {
+        sha256: deliveryArg.rawMimeSha256,
+        lengthBytes: deliveryArg.rawMimeLengthBytes,
+        contentType: 'message/rfc822',
+    },
+    ...(deliveryArg.messageId ? { messageId: deliveryArg.messageId } : {}),
+    ...(deliveryArg.subject ? { subject: deliveryArg.subject } : {}),
+    receivedAt: deliveryArg.receivedAt,
+    updatedAt: deliveryArg.updatedAt,
+    ...(deliveryArg.state === 'acknowledged'
+        ? {
+            acknowledgedAt: deliveryArg.updatedAt,
+            acknowledgedOutcome: deliveryArg.acknowledgedOutcome,
+        }
+        : {}),
+});
+const createEnvelopeDigest = (envelopeArg, sourceArg) => createSha256(JSON.stringify({
+    envelope: envelopeArg,
+    source: sourceArg,
+}));
+const canonicalJson = (valueArg) => {
+    const visit = (value) => {
+        if (Array.isArray(value))
+            return value.map(visit);
+        if (value && typeof value === 'object') {
+            return Object.fromEntries(Object.keys(value)
+                .sort()
+                .map((keyArg) => [
+                keyArg,
+                visit(value[keyArg]),
+            ]));
+        }
+        return value;
+    };
+    return JSON.stringify(visit(valueArg));
+};
+const isUniqueConflict = (errorArg) => errorArg instanceof plugins.smartdata.SmartdataExactPersistenceError
+    && errorArg.code === 'unique_conflict';
+export class CoreMailInboundService {
+    database;
+    models;
+    transfers;
+    serviceId;
+    getDesiredState;
+    now;
+    cursorCodec;
+    constructor(database, models, transfers, serviceId, getDesiredState, resolveRuntimeSecretArg, now = Date.now) {
+        this.database = database;
+        this.models = models;
+        this.transfers = transfers;
+        this.serviceId = serviceId;
+        this.getDesiredState = getDesiredState;
+        this.now = now;
+        this.cursorCodec = new CoreMailInboundCursorCodec(resolveRuntimeSecretArg);
+    }
+    async resolveRecipients(requestArg) {
+        const desiredState = await this.getDesiredState();
+        if (!desiredState) {
+            throw new Error('CoreMail desired state is unavailable.');
+        }
+        if (!Array.isArray(requestArg.recipients)
+            || requestArg.recipients.length === 0
+            || requestArg.recipients.length > 100) {
+            throw new Error('CoreMail gateway recipients are invalid.');
+        }
+        const envelope = normalizeCoreMailEnvelope(requestArg.envelope);
+        const source = normalizeCoreMailConnectionInfo(requestArg.source);
+        const envelopeDigest = createEnvelopeDigest(envelope, source);
+        const recipients = requestArg.recipients.map(normalizeCoreMailMailboxAddress);
+        if (new Set(recipients).size !== recipients.length) {
+            throw new Error('CoreMail gateway recipients contain duplicates.');
+        }
+        const resolutions = [];
+        const pendingCounts = new Map();
+        for (const recipient of recipients) {
+            const binding = desiredState.bindings.find((bindingArg) => bindingArg.state === 'active'
+                && bindingArg.capabilities.includes('inbound')
+                && bindingArg.inboundRecipients.includes(recipient));
+            if (!binding) {
+                resolutions.push({
+                    recipient,
+                    action: 'reject',
+                    smtpCode: 550,
+                    message: 'Recipient unavailable',
+                });
+                continue;
+            }
+            let pendingCount = pendingCounts.get(binding.bindingId);
+            if (pendingCount === undefined) {
+                pendingCount = await this.models.InboundDelivery.exact.count({
+                    tenantId: binding.tenantId,
+                    serviceId: binding.serviceId,
+                    bindingId: binding.bindingId,
+                    bindingRevision: binding.revision,
+                    state: {
+                        $in: [...plugins.serveZoneInterfaces.data.coreMailQuotaPolicy
+                                .pendingInboundStates],
+                    },
+                });
+                pendingCounts.set(binding.bindingId, pendingCount);
+            }
+            if (pendingCount >= binding.limits.maxPendingInbound) {
+                resolutions.push({
+                    recipient,
+                    action: 'defer',
+                    smtpCode: 452,
+                    message: 'Recipient temporarily unavailable',
+                });
+                continue;
+            }
+            const routingHandle = createOpaqueToken();
+            const createdAt = this.now();
+            const inserted = await this.models.RecipientHandle.exact.insert({
+                routingHandle: createSha256(routingHandle),
+                tenantId: binding.tenantId,
+                serviceId: binding.serviceId,
+                bindingId: binding.bindingId,
+                bindingRevision: binding.revision,
+                maxPendingInbound: binding.limits.maxPendingInbound,
+                recipient,
+                envelopeDigest,
+                state: 'issued',
+                expiresAt: createdAt + routingHandleTtlMs,
+                createdAt,
+            });
+            if (inserted.status === 'conflict') {
+                throw new Error('CoreMail routing handle identity conflict.');
+            }
+            resolutions.push({
+                recipient,
+                action: 'accept',
+                routingHandle,
+            });
+        }
+        return { resolutions };
+    }
+    async prepareInboundHandoff(requestArg) {
+        if (!Array.isArray(requestArg.routingHandles)
+            || requestArg.routingHandles.length === 0
+            || requestArg.routingHandles.length > 100) {
+            throw new Error('CoreMail inbound handoff identity is invalid.');
+        }
+        const transportDeliveryId = requireCoreMailIdentifier(requestArg.transportDeliveryId, 'transportDeliveryId');
+        const routingHandles = requestArg.routingHandles.map((handleArg) => {
+            if (typeof handleArg !== 'string' || handleArg.length < 32 || handleArg.length > 512) {
+                throw new Error('CoreMail routing handle is invalid.');
+            }
+            return createSha256(handleArg);
+        });
+        if (new Set(routingHandles).size !== routingHandles.length) {
+            throw new Error('CoreMail inbound handoff contains duplicate routing handles.');
+        }
+        const message = normalizeCoreMailGatewayMessage(requestArg.message);
+        const source = normalizeCoreMailConnectionInfo(requestArg.source);
+        const envelopeDigest = createEnvelopeDigest(message.envelope, source);
+        const existing = await this.models.InboundHandoff.exact.findStoredOne({
+            transportDeliveryId,
+        });
+        if (existing) {
+            if (canonicalJson(existing.routingHandles) !== canonicalJson(routingHandles)
+                || canonicalJson(existing.message) !== canonicalJson(message)
+                || canonicalJson(existing.source) !== canonicalJson(source)
+                || existing.state === 'failed') {
+                throw new Error('CoreMail inbound handoff replay conflicts with persisted intent.');
+            }
+            if (existing.state === 'completed') {
+                return {
+                    handoffId: existing.handoffId,
+                    replayed: true,
+                };
+            }
+            const grant = await this.issueInboundGrant(existing);
+            return {
+                handoffId: existing.handoffId,
+                grant,
+                replayed: true,
+            };
+        }
+        const now = this.now();
+        for (const routingHandle of routingHandles) {
+            const handle = await this.models.RecipientHandle.exact.findStoredOne({
+                routingHandle,
+                state: 'issued',
+                expiresAt: { $gte: now },
+            });
+            if (!handle) {
+                throw new Error('CoreMail routing authority is unavailable.');
+            }
+            if (handle.envelopeDigest !== envelopeDigest) {
+                throw new Error('CoreMail routing authority is bound to another envelope.');
+            }
+        }
+        const handoffId = plugins.nodeCrypto.randomUUID();
+        const handoff = {
+            handoffId,
+            revision: 0,
+            transportDeliveryId,
+            routingHandles,
+            message,
+            source,
+            state: 'prepared',
+            objectKey: `inbound-mime/${handoffId}/${message.rawMime.sha256.slice(7)}`,
+            deliveryIds: [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        let storedHandoff;
+        try {
+            const inserted = await this.models.InboundHandoff.exact.insert(handoff);
+            if (inserted.status === 'conflict') {
+                throw new Error('CoreMail inbound handoff identity conflict.');
+            }
+            storedHandoff = inserted.document;
+        }
+        catch (error) {
+            if (!isUniqueConflict(error)) {
+                throw error;
+            }
+            const concurrent = await this.models.InboundHandoff.exact.findStoredOne({
+                transportDeliveryId,
+            });
+            if (!concurrent
+                || canonicalJson(concurrent.routingHandles)
+                    !== canonicalJson(routingHandles)
+                || canonicalJson(concurrent.message) !== canonicalJson(message)
+                || canonicalJson(concurrent.source) !== canonicalJson(source)
+                || concurrent.state === 'failed') {
+                throw new Error('CoreMail inbound handoff conflicts with persisted intent.');
+            }
+            if (concurrent.state === 'completed') {
+                return {
+                    handoffId: concurrent.handoffId,
+                    replayed: true,
+                };
+            }
+            const concurrentGrant = await this.issueInboundGrant(concurrent);
+            return {
+                handoffId: concurrent.handoffId,
+                grant: concurrentGrant,
+                replayed: true,
+            };
+        }
+        const grant = await this.issueInboundGrant(storedHandoff);
+        return { handoffId, grant, replayed: false };
+    }
+    async issueInboundGrant(handoffArg) {
+        if (handoffArg.state !== 'prepared' && handoffArg.state !== 'uploaded') {
+            throw new Error('CoreMail inbound handoff cannot issue an upload grant.');
+        }
+        const grant = await this.transfers.issueGrant({
+            authority: gatewayAuthority(this.serviceId),
+            purpose: 'inbound-mime-upload',
+            method: 'PUT',
+            expectedSha256: handoffArg.message.rawMime.sha256,
+            lengthBytes: handoffArg.message.rawMime.lengthBytes,
+            contentType: 'message/rfc822',
+            objectKey: handoffArg.objectKey,
+        });
+        const update = await this.models.InboundHandoff.exact.transition({
+            current: handoffArg,
+            change: (modelArg) => {
+                modelArg.grantId = grant.grantId;
+                modelArg.state = 'uploaded';
+                modelArg.updatedAt = this.now();
+                modelArg.revision += 1;
+            },
+        });
+        if (update.status !== 'transitioned') {
+            throw new Error('CoreMail inbound handoff upload fence changed.');
+        }
+        return grant;
+    }
+    async completeInboundHandoff(requestArg) {
+        const handoff = await this.models.InboundHandoff.exact.findStoredOne({
+            handoffId: requireCoreMailUuid(requestArg.handoffId, 'handoffId'),
+        });
+        if (!handoff || handoff.state === 'failed') {
+            throw new Error('CoreMail inbound handoff is unavailable.');
+        }
+        const sha256 = plugins.serveZoneInterfaces.data.normalizeCoreMailSha256(requestArg.sha256);
+        if ((handoff.state !== 'uploaded' && handoff.state !== 'completed')
+            || handoff.message.rawMime.sha256 !== sha256
+            || handoff.message.rawMime.lengthBytes !== requestArg.lengthBytes) {
+            throw new Error('CoreMail inbound handoff completion is invalid.');
+        }
+        await this.transfers.assertConsumed({
+            grantId: requestArg.grantId,
+            authority: gatewayAuthority(this.serviceId),
+            purpose: 'inbound-mime-upload',
+            expectedSha256: handoff.message.rawMime.sha256,
+            lengthBytes: handoff.message.rawMime.lengthBytes,
+            objectKey: handoff.objectKey,
+        });
+        if (handoff.state === 'completed') {
+            return {
+                accepted: true,
+                deliveryIds: [...handoff.deliveryIds],
+                replayed: true,
+            };
+        }
+        const handles = [];
+        for (const routingHandle of handoff.routingHandles) {
+            const handle = await this.models.RecipientHandle.exact.findStoredOne({
+                routingHandle,
+            });
+            if (!handle
+                || (handle.state === 'consumed'
+                    && handle.handoffId !== handoff.handoffId)
+                || (handle.state === 'issued'
+                    && handle.expiresAt < this.now())
+                || handle.envelopeDigest !== createEnvelopeDigest(handoff.message.envelope, handoff.source)) {
+                throw new Error('CoreMail routing handle fence changed.');
+            }
+            handles.push(handle);
+        }
+        const grouped = new Map();
+        for (const handle of handles) {
+            const key = JSON.stringify([
+                handle.tenantId,
+                handle.serviceId,
+                handle.bindingId,
+                handle.bindingRevision,
+            ]);
+            const group = grouped.get(key) ?? [];
+            group.push(handle);
+            grouped.set(key, group);
+        }
+        const groups = [...grouped.values()];
+        const candidates = [];
+        for (const group of groups) {
+            const authority = group[0];
+            if (group.some((handleArg) => handleArg.maxPendingInbound !== authority.maxPendingInbound)) {
+                throw new Error('CoreMail routing handles disagree on pending quota.');
+            }
+            const quota = createCoreMailPendingQuotaDescriptor(authority);
+            await ensureCoreMailQuotaCounter(this.models, quota);
+            const receivedAt = this.now();
+            candidates.push({
+                deliveryId: plugins.nodeCrypto.randomUUID(),
+                tenantId: authority.tenantId,
+                serviceId: authority.serviceId,
+                bindingId: authority.bindingId,
+                bindingRevision: authority.bindingRevision,
+                revision: 0,
+                transportDeliveryId: handoff.transportDeliveryId,
+                state: 'pending',
+                envelope: {
+                    mailFrom: handoff.message.envelope.mailFrom,
+                    rcptTo: group.map((handleArg) => handleArg.recipient),
+                },
+                rawMimeSha256: handoff.message.rawMime.sha256,
+                rawMimeLengthBytes: handoff.message.rawMime.lengthBytes,
+                rawMimeObjectKey: handoff.objectKey,
+                receivedAt,
+                updatedAt: receivedAt,
+            });
+        }
+        try {
+            const deliveryIds = await withCoreMailTransaction(this.database, async (transactionArg) => {
+                const transactionHandoff = await this.models.InboundHandoff.exact.findStoredOne({
+                    handoffId: handoff.handoffId,
+                    state: 'uploaded',
+                    revision: handoff.revision,
+                }, { session: transactionArg });
+                if (!transactionHandoff) {
+                    throw new Error('CoreMail inbound handoff completion fence changed.');
+                }
+                const committedIds = [];
+                for (const [index, group] of groups.entries()) {
+                    const authority = group[0];
+                    const candidate = candidates[index];
+                    const quota = createCoreMailPendingQuotaDescriptor(authority);
+                    const existing = await this.models.InboundDelivery.exact.findStoredOne({
+                        transportDeliveryId: handoff.transportDeliveryId,
+                        bindingId: authority.bindingId,
+                        bindingRevision: authority.bindingRevision,
+                    }, { session: transactionArg });
+                    if (!existing) {
+                        await incrementCoreMailQuotaCounter(this.models, quota, authority.maxPendingInbound, candidate.receivedAt, transactionArg);
+                        const inserted = await this.models.InboundDelivery.exact.insert(candidate, { session: transactionArg });
+                        if (inserted.status === 'conflict') {
+                            throw new Error('CoreMail inbound delivery identity conflict.');
+                        }
+                    }
+                    for (const originalHandle of group) {
+                        const handle = await this.models.RecipientHandle.exact.findStoredOne({ routingHandle: originalHandle.routingHandle }, { session: transactionArg });
+                        if (!handle
+                            || handle.tenantId !== authority.tenantId
+                            || handle.serviceId !== authority.serviceId
+                            || handle.bindingId !== authority.bindingId
+                            || handle.bindingRevision !== authority.bindingRevision
+                            || handle.maxPendingInbound !== authority.maxPendingInbound
+                            || (handle.state === 'consumed'
+                                && handle.handoffId !== handoff.handoffId)
+                            || (handle.state === 'issued'
+                                && handle.expiresAt < candidate.receivedAt)) {
+                            throw new Error('CoreMail routing handle fence changed.');
+                        }
+                        if (handle.state === 'issued') {
+                            const claim = await this.models.RecipientHandle.exact.transition({
+                                current: handle,
+                                change: (modelArg) => {
+                                    modelArg.state = 'consumed';
+                                    modelArg.handoffId = handoff.handoffId;
+                                },
+                            }, { session: transactionArg });
+                            if (claim.status !== 'transitioned') {
+                                throw new Error('CoreMail routing handle claim fence changed.');
+                            }
+                        }
+                    }
+                    committedIds.push(existing?.deliveryId ?? candidate.deliveryId);
+                }
+                committedIds.sort();
+                const completion = await this.models.InboundHandoff.exact.transition({
+                    current: transactionHandoff,
+                    change: (modelArg) => {
+                        modelArg.state = 'completed';
+                        modelArg.grantId = requestArg.grantId;
+                        modelArg.deliveryIds = committedIds;
+                        modelArg.completedAt = this.now();
+                        modelArg.updatedAt = modelArg.completedAt;
+                        modelArg.revision += 1;
+                    },
+                }, { session: transactionArg });
+                if (completion.status !== 'transitioned') {
+                    throw new Error('CoreMail inbound handoff completion fence changed.');
+                }
+                return committedIds;
+            });
+            return { accepted: true, deliveryIds, replayed: false };
+        }
+        catch (error) {
+            const replay = await this.models.InboundHandoff.exact.findStoredOne({
+                handoffId: handoff.handoffId,
+                state: 'completed',
+            });
+            if (replay) {
+                return {
+                    accepted: true,
+                    deliveryIds: [...replay.deliveryIds],
+                    replayed: true,
+                };
+            }
+            throw error;
+        }
+    }
+    async listDeliveries(sessionArg, requestArg) {
+        if (!Number.isSafeInteger(requestArg.limit)
+            || requestArg.limit < 1
+            || requestArg.limit > listLimitMaximum
+            || (requestArg.cursor !== undefined
+                && (typeof requestArg.cursor !== 'string'
+                    || requestArg.cursor.length >
+                        plugins.serveZoneInterfaces.data.coreMailLimits.cursorBytes))) {
+            throw new Error('CoreMail inbound list window is invalid.');
+        }
+        const authority = {
+            tenantId: sessionArg.tenantId,
+            serviceId: sessionArg.serviceId,
+            bindingId: sessionArg.bindingId,
+            bindingRevision: sessionArg.bindingRevision,
+        };
+        const now = this.now();
+        const desiredState = await this.getDesiredState();
+        if (!desiredState) {
+            throw new Error('CoreMail desired state is unavailable.');
+        }
+        const position = requestArg.cursor
+            ? this.cursorCodec.decode(requestArg.cursor, authority, now, desiredState.cursorKeys)
+            : null;
+        const snapshotAt = position?.snapshotAt ?? now;
+        const deliveries = await this.models.InboundDelivery.exact.findStored({
+            filter: {
+                ...workloadFilter(sessionArg, undefined),
+                receivedAt: { $lt: snapshotAt },
+                ...(position
+                    ? {
+                        $or: [{
+                                receivedAt: { $gt: position.receivedAt },
+                            }, {
+                                receivedAt: position.receivedAt,
+                                deliveryId: { $gt: position.deliveryId },
+                            }],
+                    }
+                    : {}),
+            },
+            sort: { receivedAt: 1, deliveryId: 1 },
+            limit: requestArg.limit + 1,
+        });
+        const page = [];
+        for (const delivery of deliveries.slice(0, requestArg.limit)) {
+            const publicDelivery = toPublicDelivery(delivery);
+            const cursor = this.cursorCodec.encode(authority, {
+                snapshotAt,
+                receivedAt: delivery.receivedAt,
+                deliveryId: delivery.deliveryId,
+            }, desiredState.cursorKeys);
+            const candidate = {
+                deliveries: [...page, publicDelivery],
+                nextCursor: cursor,
+            };
+            if (Buffer.byteLength(JSON.stringify(candidate), 'utf8')
+                > plugins.serveZoneInterfaces.data.coreMailLimits.inboundPageBytes) {
+                break;
+            }
+            page.push(publicDelivery);
+        }
+        if (page.length === 0 && deliveries.length > 0) {
+            throw new Error('CoreMail inbound delivery exceeds the page byte budget.');
+        }
+        const hasMore = page.length < deliveries.length;
+        const last = page.at(-1);
+        const response = {
+            deliveries: page,
+            ...(hasMore && last
+                ? {
+                    nextCursor: this.cursorCodec.encode(authority, {
+                        snapshotAt,
+                        receivedAt: last.receivedAt,
+                        deliveryId: last.deliveryId,
+                    }, desiredState.cursorKeys),
+                }
+                : {}),
+        };
+        return plugins.serveZoneInterfaces.data
+            .normalizeCoreMailInboundDeliveryPage(response);
+    }
+    async prepareFetch(sessionArg, requestArg) {
+        const delivery = await this.requireDelivery(sessionArg, requestArg.deliveryId);
+        if (delivery.state === 'acknowledged') {
+            throw new Error('CoreMail inbound delivery is already acknowledged.');
+        }
+        const grant = await this.transfers.issueGrant({
+            authority: workloadAuthority(sessionArg),
+            purpose: 'inbound-mime-download',
+            method: 'GET',
+            expectedSha256: delivery.rawMimeSha256,
+            lengthBytes: delivery.rawMimeLengthBytes,
+            contentType: 'message/rfc822',
+            objectKey: delivery.rawMimeObjectKey,
+        });
+        const update = await this.models.InboundDelivery.exact.transition({
+            current: delivery,
+            change: (modelArg) => {
+                modelArg.state = 'fetching';
+                modelArg.fetchGrantId = grant.grantId;
+                modelArg.updatedAt = this.now();
+                modelArg.revision += 1;
+            },
+        });
+        if (update.status !== 'transitioned') {
+            throw new Error('CoreMail inbound fetch preparation fence changed.');
+        }
+        return {
+            grant: grant,
+        };
+    }
+    async completeFetch(sessionArg, requestArg) {
+        const delivery = await this.requireDelivery(sessionArg, requestArg.deliveryId);
+        const sha256 = plugins.serveZoneInterfaces.data.normalizeCoreMailSha256(requestArg.sha256);
+        if ((delivery.state !== 'fetching' && delivery.state !== 'fetched')
+            || delivery.rawMimeSha256 !== sha256
+            || delivery.rawMimeLengthBytes !== requestArg.lengthBytes) {
+            throw new Error('CoreMail inbound fetch completion is invalid.');
+        }
+        await this.transfers.assertConsumed({
+            grantId: requestArg.grantId,
+            authority: workloadAuthority(sessionArg),
+            purpose: 'inbound-mime-download',
+            expectedSha256: delivery.rawMimeSha256,
+            lengthBytes: delivery.rawMimeLengthBytes,
+            objectKey: delivery.rawMimeObjectKey,
+        });
+        if (delivery.state === 'fetched') {
+            return { delivery: toPublicDelivery(delivery) };
+        }
+        const updatedAt = this.now();
+        const update = await this.models.InboundDelivery.exact.transition({
+            current: delivery,
+            change: (modelArg) => {
+                modelArg.state = 'fetched';
+                modelArg.fetchGrantId = requestArg.grantId;
+                modelArg.updatedAt = updatedAt;
+                modelArg.revision += 1;
+            },
+        });
+        if (update.status !== 'transitioned') {
+            throw new Error('CoreMail inbound fetch completion fence changed.');
+        }
+        return {
+            delivery: toPublicDelivery(update.document),
+        };
+    }
+    async acknowledge(sessionArg, requestArg) {
+        if (requestArg.outcome !== 'processed' && requestArg.outcome !== 'discarded') {
+            throw new Error('CoreMail inbound acknowledgement outcome is invalid.');
+        }
+        const delivery = await this.requireDelivery(sessionArg, requestArg.deliveryId);
+        if (delivery.state === 'acknowledged') {
+            if (delivery.acknowledgedOutcome !== requestArg.outcome) {
+                throw new Error('CoreMail inbound acknowledgement conflicts with persisted intent.');
+            }
+            return { delivery: toPublicDelivery(delivery), replayed: true };
+        }
+        if (delivery.state !== 'fetched') {
+            throw new Error('CoreMail inbound delivery must be fetched before acknowledgement.');
+        }
+        const updatedAt = this.now();
+        const quota = createCoreMailPendingQuotaDescriptor({
+            tenantId: sessionArg.tenantId,
+            serviceId: sessionArg.serviceId,
+            bindingId: sessionArg.bindingId,
+            bindingRevision: sessionArg.bindingRevision,
+        });
+        await ensureCoreMailQuotaCounter(this.models, quota);
+        const transactionResult = await withCoreMailTransaction(this.database, async (transactionArg) => {
+            const current = await this.models.InboundDelivery.exact.findStoredOne(workloadFilter(sessionArg, requestArg.deliveryId), { session: transactionArg });
+            if (!current) {
+                throw new Error('CoreMail inbound delivery is unavailable.');
+            }
+            if (current.state === 'acknowledged') {
+                if (current.acknowledgedOutcome !== requestArg.outcome) {
+                    throw new Error('CoreMail inbound acknowledgement conflicts with persisted intent.');
+                }
+                return { replayed: true };
+            }
+            if (current.state !== 'fetched') {
+                throw new Error('CoreMail inbound delivery must be fetched before acknowledgement.');
+            }
+            await decrementCoreMailQuotaCounter(this.models, quota, updatedAt, transactionArg);
+            const update = await this.models.InboundDelivery.exact.transition({
+                current,
+                change: (modelArg) => {
+                    modelArg.state = 'acknowledged';
+                    modelArg.acknowledgedOutcome = requestArg.outcome;
+                    modelArg.updatedAt = updatedAt;
+                    modelArg.revision += 1;
+                },
+            }, { session: transactionArg });
+            if (update.status !== 'transitioned') {
+                throw new Error('CoreMail inbound acknowledgement fence changed.');
+            }
+            return { replayed: false };
+        });
+        const committed = await this.requireDelivery(sessionArg, requestArg.deliveryId);
+        if (committed.state !== 'acknowledged'
+            || committed.acknowledgedOutcome !== requestArg.outcome) {
+            throw new Error('CoreMail committed inbound acknowledgement is unavailable.');
+        }
+        return {
+            delivery: toPublicDelivery(committed),
+            replayed: transactionResult.replayed,
+        };
+    }
+    async requireDelivery(sessionArg, deliveryIdArg) {
+        const delivery = await this.models.InboundDelivery.exact.findStoredOne({
+            ...workloadFilter(sessionArg, deliveryIdArg),
+        });
+        if (!delivery) {
+            throw new Error('CoreMail inbound delivery is unavailable.');
+        }
+        return delivery;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.inbound.js","sourceRoot":"","sources":["../ts/classes.inbound.ts"],"names":[],"mappings":"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"}