@serve.zone/coremail 1.0.0

package/dist_ts/classes.transfer.js

@@ -0,0 +1,289 @@
+import * as plugins from './plugins.js';
+import {} from './classes.models.js';
+import { CoreMailStorage, createOpaqueToken, createSha256, } from './classes.storage.js';
+import { logCoreMailFailure } from './coremail.log.js';
+import { requireCoreMailIdentifier, requireCoreMailUuid, } from './coremail.selectors.js';
+const transferPathRegex = /^\/transfers\/([a-f0-9-]{36})$/;
+const maximumBytesForPurpose = (purposeArg) => {
+    const limits = plugins.serveZoneInterfaces.data.coreMailLimits;
+    switch (purposeArg) {
+        case 'desired-state-upload':
+            return limits.desiredStateBytes;
+        case 'outbound-part-upload':
+            return limits.attachmentBytes;
+        case 'outbound-mime-download':
+        case 'inbound-mime-upload':
+        case 'inbound-mime-download':
+            return limits.serializedMimeBytes;
+    }
+};
+const secureDigestEqual = (leftArg, rightArg) => {
+    const left = Buffer.from(leftArg.slice('sha256:'.length), 'hex');
+    const right = Buffer.from(rightArg.slice('sha256:'.length), 'hex');
+    return left.byteLength === right.byteLength
+        && plugins.nodeCrypto.timingSafeEqual(left, right);
+};
+const authorityFilter = (grantIdArg, authorityArg) => ({
+    grantId: requireCoreMailUuid(grantIdArg, 'grantId'),
+    authorityKind: authorityArg.kind,
+    tenantId: authorityArg.tenantId === '-'
+        ? '-'
+        : requireCoreMailIdentifier(authorityArg.tenantId, 'authority.tenantId'),
+    serviceId: requireCoreMailIdentifier(authorityArg.serviceId, 'authority.serviceId'),
+    bindingId: authorityArg.bindingId === '-'
+        ? '-'
+        : requireCoreMailIdentifier(authorityArg.bindingId, 'authority.bindingId'),
+});
+export class CoreMailTransferService {
+    models;
+    storage;
+    now;
+    completionTasks = new Set();
+    operationControllers = new Set();
+    stopController = new AbortController();
+    stopping = false;
+    constructor(models, storage, now = Date.now) {
+        this.models = models;
+        this.storage = storage;
+        this.now = now;
+    }
+    async stop() {
+        this.stopping = true;
+        this.stopController.abort(new Error('CoreMail transfer service is stopping.'));
+        for (const controller of this.operationControllers) {
+            controller.abort(new Error('CoreMail transfer service is stopping.'));
+        }
+        await Promise.allSettled([...this.completionTasks]);
+    }
+    track(taskArg, controllerArg) {
+        this.completionTasks.add(taskArg);
+        this.operationControllers.add(controllerArg);
+        void taskArg.then(() => {
+            this.completionTasks.delete(taskArg);
+            this.operationControllers.delete(controllerArg);
+        }, () => {
+            this.completionTasks.delete(taskArg);
+            this.operationControllers.delete(controllerArg);
+        });
+    }
+    async issueGrant(optionsArg) {
+        if (this.stopping) {
+            throw new Error('CoreMail transfer service is stopping.');
+        }
+        const maximumBytes = maximumBytesForPurpose(optionsArg.purpose);
+        if (!Number.isSafeInteger(optionsArg.lengthBytes)
+            || optionsArg.lengthBytes < 0
+            || optionsArg.lengthBytes > maximumBytes) {
+            throw new Error('CoreMail transfer length exceeds its purpose budget.');
+        }
+        const grantId = plugins.nodeCrypto.randomUUID();
+        const bearerToken = createOpaqueToken();
+        const path = `/transfers/${grantId}`;
+        const createdAt = this.now();
+        const expiresAt = createdAt + plugins.serveZoneInterfaces.data.coreMailLimits.transferGrantTtlMs;
+        const inserted = await this.models.TransferGrant.exact.insert({
+            grantId,
+            authorityKind: optionsArg.authority.kind,
+            tenantId: optionsArg.authority.tenantId,
+            serviceId: optionsArg.authority.serviceId,
+            bindingId: optionsArg.authority.bindingId,
+            purpose: optionsArg.purpose,
+            method: optionsArg.method,
+            path,
+            bearerSha256: createSha256(bearerToken),
+            expectedSha256: optionsArg.expectedSha256,
+            lengthBytes: optionsArg.lengthBytes,
+            contentType: optionsArg.contentType,
+            objectKey: optionsArg.objectKey,
+            state: 'issued',
+            expiresAt,
+            createdAt,
+        });
+        if (inserted.status === 'conflict') {
+            throw new Error('CoreMail transfer grant identity conflict.');
+        }
+        return {
+            grantId,
+            method: optionsArg.method,
+            path,
+            bearerToken,
+            sha256: optionsArg.expectedSha256,
+            lengthBytes: optionsArg.lengthBytes,
+            contentType: optionsArg.contentType,
+            issuedAt: createdAt,
+            expiresAt,
+        };
+    }
+    async assertConsumed(optionsArg) {
+        const grant = await this.models.TransferGrant.exact.findStoredOne({
+            ...authorityFilter(optionsArg.grantId, optionsArg.authority),
+            state: 'consumed',
+            purpose: optionsArg.purpose,
+            expectedSha256: optionsArg.expectedSha256,
+            lengthBytes: optionsArg.lengthBytes,
+            ...(optionsArg.objectKey === undefined
+                ? {}
+                : { objectKey: optionsArg.objectKey }),
+        });
+        if (!grant) {
+            throw new Error('CoreMail transfer grant is not consumed by this authority.');
+        }
+        await this.storage.verifyObject(grant.objectKey, grant.lengthBytes, grant.expectedSha256, maximumBytesForPurpose(grant.purpose));
+        return grant;
+    }
+    async handleHttp(contextArg) {
+        const match = transferPathRegex.exec(contextArg.path);
+        if (!match) {
+            return null;
+        }
+        if (contextArg.method !== 'GET' && contextArg.method !== 'PUT') {
+            return new Response('Method Not Allowed', {
+                status: 405,
+                headers: { Allow: 'GET, PUT' },
+            });
+        }
+        const authorization = contextArg.headers.get('authorization');
+        if (!authorization?.startsWith('Bearer ')) {
+            return new Response('Unauthorized', { status: 401 });
+        }
+        const bearer = authorization.slice('Bearer '.length);
+        if (bearer.length < 32 || bearer.length > 512) {
+            return new Response('Unauthorized', { status: 401 });
+        }
+        const grantId = match[1];
+        const grant = await this.models.TransferGrant.exact.findStoredOne({
+            grantId,
+            method: contextArg.method,
+            state: 'issued',
+        });
+        if (!grant
+            || grant.expiresAt < this.now()
+            || !secureDigestEqual(grant.bearerSha256, createSha256(bearer))) {
+            return new Response('Unauthorized', { status: 401 });
+        }
+        const claim = await this.models.TransferGrant.exact.transition({
+            current: grant,
+            change: (modelArg) => {
+                modelArg.state = 'transferring';
+            },
+        });
+        if (claim.status !== 'transitioned') {
+            return new Response('Conflict', { status: 409 });
+        }
+        if (contextArg.method === 'PUT') {
+            return await this.handleUpload(contextArg, claim.document);
+        }
+        return await this.handleDownload(contextArg, claim.document);
+    }
+    async handleUpload(contextArg, grantArg) {
+        const contentLength = Number(contextArg.headers.get('content-length'));
+        if (!contextArg.request.body
+            || !Number.isSafeInteger(contentLength)
+            || contentLength !== grantArg.lengthBytes
+            || contextArg.headers.get('content-type') !== grantArg.contentType) {
+            await this.failGrant(grantArg.grantId);
+            return new Response('Invalid transfer metadata', { status: 400 });
+        }
+        const operationController = new AbortController();
+        const signal = AbortSignal.any([
+            contextArg.request.signal,
+            this.stopController.signal,
+            operationController.signal,
+            AbortSignal.timeout(plugins.serveZoneInterfaces.data.coreMailLimits.transferOverallTimeoutMs),
+        ]);
+        const task = (async () => {
+            try {
+                await this.storage.putExact(grantArg.objectKey, contextArg.request.body, grantArg.lengthBytes, grantArg.expectedSha256, grantArg.contentType, maximumBytesForPurpose(grantArg.purpose), signal);
+                const consumed = await this.models.TransferGrant.exact.transition({
+                    current: grantArg,
+                    change: (modelArg) => {
+                        modelArg.state = 'consumed';
+                        modelArg.consumedAt = this.now();
+                    },
+                });
+                if (consumed.status !== 'transitioned') {
+                    throw new Error('CoreMail transfer completion fence changed.');
+                }
+                return new Response(null, { status: 204 });
+            }
+            catch {
+                operationController.abort();
+                await this.failGrant(grantArg.grantId);
+                return new Response('Transfer failed', { status: 409 });
+            }
+        })();
+        this.track(task, operationController);
+        return await task;
+    }
+    async handleDownload(contextArg, grantArg) {
+        const operationController = new AbortController();
+        const signal = AbortSignal.any([
+            contextArg.request.signal,
+            this.stopController.signal,
+            operationController.signal,
+            AbortSignal.timeout(plugins.serveZoneInterfaces.data.coreMailLimits.transferOverallTimeoutMs),
+        ]);
+        try {
+            const verified = await this.storage.getVerifiedStream(grantArg.objectKey, grantArg.lengthBytes, grantArg.expectedSha256, maximumBytesForPurpose(grantArg.purpose), signal);
+            const completion = verified.completion.then(async () => {
+                const consumed = await this.models.TransferGrant.exact.transition({
+                    current: grantArg,
+                    change: (modelArg) => {
+                        modelArg.state = 'consumed';
+                        modelArg.consumedAt = this.now();
+                    },
+                });
+                if (consumed.status !== 'transitioned') {
+                    throw new Error('CoreMail transfer completion fence changed.');
+                }
+            }).catch(async () => {
+                await this.failGrant(grantArg.grantId);
+            });
+            this.track(completion, operationController);
+            return new Response(verified.stream, {
+                status: 200,
+                headers: {
+                    'Content-Type': grantArg.contentType,
+                    'Content-Length': String(grantArg.lengthBytes),
+                    'Cache-Control': 'no-store',
+                    'X-Content-Type-Options': 'nosniff',
+                },
+            });
+        }
+        catch {
+            operationController.abort();
+            await this.failGrant(grantArg.grantId);
+            return new Response('Transfer failed', { status: 409 });
+        }
+    }
+    async failGrant(grantIdArg) {
+        try {
+            const grant = await this.models.TransferGrant.exact.findStoredOne({
+                grantId: grantIdArg,
+                state: { $in: ['issued', 'transferring'] },
+            });
+            if (!grant) {
+                return;
+            }
+            const failed = await this.models.TransferGrant.exact.transition({
+                current: grant,
+                change: (modelArg) => {
+                    modelArg.state = 'failed';
+                },
+            });
+            if (failed.status === 'concurrent_change') {
+                const current = await this.models.TransferGrant.exact.findStoredOne({
+                    grantId: grantIdArg,
+                });
+                if (current?.state === 'issued' || current?.state === 'transferring') {
+                    throw new Error('CoreMail transfer failure fence changed.');
+                }
+            }
+        }
+        catch {
+            await logCoreMailFailure('transfer', 'GRANT_FAILURE_PERSISTENCE_FAILED')
+                .catch(() => undefined);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.transfer.js","sourceRoot":"","sources":["../ts/classes.transfer.ts"],"names":[],"mappings":"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"}

package/dist_ts/coremail.cursor.d.ts

@@ -0,0 +1,20 @@
+import * as plugins from './plugins.js';
+export interface ICoreMailInboundCursorAuthority {
+    tenantId: string;
+    serviceId: string;
+    bindingId: string;
+    bindingRevision: number;
+}
+export interface ICoreMailInboundCursorPosition {
+    snapshotAt: number;
+    receivedAt: number;
+    deliveryId: string;
+}
+type TCursorKey = plugins.serveZoneInterfaces.data.ICoreMailRuntimeKeyReference;
+export declare class CoreMailInboundCursorCodec {
+    private readonly resolveRuntimeSecret;
+    constructor(resolveRuntimeSecret: (secretKeyArg: string) => string);
+    encode(authorityArg: ICoreMailInboundCursorAuthority, positionArg: ICoreMailInboundCursorPosition, keysArg: TCursorKey[]): string;
+    decode(cursorArg: string, authorityArg: ICoreMailInboundCursorAuthority, nowArg: number, keysArg: TCursorKey[]): ICoreMailInboundCursorPosition;
+}
+export {};

package/dist_ts/coremail.cursor.js

@@ -0,0 +1,191 @@
+import * as plugins from './plugins.js';
+import { requireCoreMailIdentifier, requireCoreMailSafeInteger, requireCoreMailUuid, } from './coremail.selectors.js';
+const maximumCursorAgeMs = 24 * 60 * 60 * 1_000;
+const maximumFutureSkewMs = 1_000;
+const payloadKeys = new Set([
+    'version',
+    'tenantId',
+    'serviceId',
+    'bindingId',
+    'bindingRevision',
+    'snapshotAt',
+    'receivedAt',
+    'deliveryId',
+]);
+const envelopeKeys = new Set([
+    'version',
+    'keyId',
+    'keyVersion',
+    'payload',
+    'signature',
+]);
+const canonicalPayload = (payloadArg) => JSON.stringify({
+    version: payloadArg.version,
+    tenantId: payloadArg.tenantId,
+    serviceId: payloadArg.serviceId,
+    bindingId: payloadArg.bindingId,
+    bindingRevision: payloadArg.bindingRevision,
+    snapshotAt: payloadArg.snapshotAt,
+    receivedAt: payloadArg.receivedAt,
+    deliveryId: payloadArg.deliveryId,
+});
+const canonicalEnvelope = (envelopeArg) => JSON.stringify({
+    version: envelopeArg.version,
+    keyId: envelopeArg.keyId,
+    keyVersion: envelopeArg.keyVersion,
+    payload: envelopeArg.payload,
+    signature: envelopeArg.signature,
+});
+const requireAuthority = (authorityArg) => ({
+    tenantId: requireCoreMailIdentifier(authorityArg.tenantId, 'cursor.tenantId'),
+    serviceId: requireCoreMailIdentifier(authorityArg.serviceId, 'cursor.serviceId'),
+    bindingId: requireCoreMailIdentifier(authorityArg.bindingId, 'cursor.bindingId'),
+    bindingRevision: requireCoreMailSafeInteger(authorityArg.bindingRevision, 'cursor.bindingRevision', 1),
+});
+const parseCanonicalRecord = (encodedArg, keysArg) => {
+    let decoded;
+    let parsed;
+    try {
+        decoded = Buffer.from(encodedArg, 'base64url');
+        if (decoded.toString('base64url') !== encodedArg) {
+            throw new Error('noncanonical encoding');
+        }
+        parsed = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(decoded));
+    }
+    catch {
+        throw new Error('CoreMail inbound cursor is invalid.');
+    }
+    if (!parsed
+        || typeof parsed !== 'object'
+        || Array.isArray(parsed)
+        || Object.getPrototypeOf(parsed) !== Object.prototype
+        || Object.keys(parsed).length !== keysArg.size
+        || Object.keys(parsed).some((keyArg) => !keysArg.has(keyArg))) {
+        throw new Error('CoreMail inbound cursor is invalid.');
+    }
+    return parsed;
+};
+const parsePayload = (encodedArg) => {
+    const value = parseCanonicalRecord(encodedArg, payloadKeys);
+    if (value.version !== 1) {
+        throw new Error('CoreMail inbound cursor version is unsupported.');
+    }
+    const payload = {
+        version: 1,
+        tenantId: requireCoreMailIdentifier(value.tenantId, 'cursor.tenantId'),
+        serviceId: requireCoreMailIdentifier(value.serviceId, 'cursor.serviceId'),
+        bindingId: requireCoreMailIdentifier(value.bindingId, 'cursor.bindingId'),
+        bindingRevision: requireCoreMailSafeInteger(value.bindingRevision, 'cursor.bindingRevision', 1),
+        snapshotAt: requireCoreMailSafeInteger(value.snapshotAt, 'cursor.snapshotAt'),
+        receivedAt: requireCoreMailSafeInteger(value.receivedAt, 'cursor.receivedAt'),
+        deliveryId: requireCoreMailUuid(value.deliveryId, 'cursor.deliveryId'),
+    };
+    if (canonicalPayload(payload) !== Buffer.from(encodedArg, 'base64url').toString('utf8')) {
+        throw new Error('CoreMail inbound cursor is not canonical.');
+    }
+    return payload;
+};
+const deriveHmacKey = (secretArg) => {
+    if (typeof secretArg !== 'string'
+        || Buffer.byteLength(secretArg, 'utf8') < 32
+        || Buffer.byteLength(secretArg, 'utf8') > 512
+        || secretArg.trim() !== secretArg) {
+        throw new Error('CoreMail cursor secret is invalid.');
+    }
+    return plugins.nodeCrypto.createHash('sha256').update(secretArg, 'utf8').digest();
+};
+const signatureInput = (keyIdArg, keyVersionArg, payloadArg) => `${keyIdArg}:${keyVersionArg}:${payloadArg}`;
+const sign = (keyArg, keyIdArg, keyVersionArg, payloadArg) => plugins.nodeCrypto
+    .createHmac('sha256', keyArg)
+    .update(signatureInput(keyIdArg, keyVersionArg, payloadArg), 'ascii')
+    .digest('base64url');
+export class CoreMailInboundCursorCodec {
+    resolveRuntimeSecret;
+    constructor(resolveRuntimeSecret) {
+        this.resolveRuntimeSecret = resolveRuntimeSecret;
+    }
+    encode(authorityArg, positionArg, keysArg) {
+        const currentKey = keysArg.find((keyArg) => keyArg.state === 'current');
+        if (!currentKey) {
+            throw new Error('CoreMail current cursor key is unavailable.');
+        }
+        const authority = requireAuthority(authorityArg);
+        const payload = {
+            version: 1,
+            ...authority,
+            snapshotAt: requireCoreMailSafeInteger(positionArg.snapshotAt, 'cursor.snapshotAt'),
+            receivedAt: requireCoreMailSafeInteger(positionArg.receivedAt, 'cursor.receivedAt'),
+            deliveryId: requireCoreMailUuid(positionArg.deliveryId, 'cursor.deliveryId'),
+        };
+        if (payload.receivedAt >= payload.snapshotAt) {
+            throw new Error('CoreMail inbound cursor position is invalid.');
+        }
+        const encodedPayload = Buffer.from(canonicalPayload(payload), 'utf8').toString('base64url');
+        const envelope = {
+            version: 1,
+            keyId: currentKey.keyId,
+            keyVersion: currentKey.version,
+            payload: encodedPayload,
+            signature: sign(deriveHmacKey(this.resolveRuntimeSecret(currentKey.secretKey)), currentKey.keyId, currentKey.version, encodedPayload),
+        };
+        return plugins.serveZoneInterfaces.data.normalizeCoreMailInboundCursor(Buffer.from(canonicalEnvelope(envelope), 'utf8').toString('base64url'));
+    }
+    decode(cursorArg, authorityArg, nowArg, keysArg) {
+        const cursor = plugins.serveZoneInterfaces.data.normalizeCoreMailInboundCursor(cursorArg);
+        const value = parseCanonicalRecord(cursor, envelopeKeys);
+        if (value.version !== 1) {
+            throw new Error('CoreMail inbound cursor version is unsupported.');
+        }
+        const now = requireCoreMailSafeInteger(nowArg, 'cursor.now');
+        const keyId = requireCoreMailIdentifier(value.keyId, 'cursor.keyId');
+        const keyVersion = requireCoreMailSafeInteger(value.keyVersion, 'cursor.keyVersion', 1);
+        if (typeof value.payload !== 'string' || typeof value.signature !== 'string') {
+            throw new Error('CoreMail inbound cursor is invalid.');
+        }
+        const envelope = {
+            version: 1,
+            keyId,
+            keyVersion,
+            payload: value.payload,
+            signature: value.signature,
+        };
+        if (canonicalEnvelope(envelope) !== Buffer.from(cursor, 'base64url').toString('utf8')) {
+            throw new Error('CoreMail inbound cursor is not canonical.');
+        }
+        const key = keysArg.find((keyArg) => keyArg.keyId === keyId
+            && keyArg.version === keyVersion
+            && (keyArg.state === 'current'
+                || (keyArg.state === 'retiring'
+                    && keyArg.acceptUntil !== undefined
+                    && keyArg.acceptUntil >= now)));
+        if (!key) {
+            throw new Error('CoreMail inbound cursor key is unavailable.');
+        }
+        const actualSignature = Buffer.from(envelope.signature, 'base64url');
+        const expectedSignature = Buffer.from(sign(deriveHmacKey(this.resolveRuntimeSecret(key.secretKey)), key.keyId, key.version, envelope.payload), 'base64url');
+        if (actualSignature.toString('base64url') !== envelope.signature
+            || actualSignature.byteLength !== expectedSignature.byteLength
+            || !plugins.nodeCrypto.timingSafeEqual(actualSignature, expectedSignature)) {
+            throw new Error('CoreMail inbound cursor is invalid.');
+        }
+        const payload = parsePayload(envelope.payload);
+        const authority = requireAuthority(authorityArg);
+        if (payload.tenantId !== authority.tenantId
+            || payload.serviceId !== authority.serviceId
+            || payload.bindingId !== authority.bindingId
+            || payload.bindingRevision !== authority.bindingRevision) {
+            throw new Error('CoreMail inbound cursor authority is invalid.');
+        }
+        if (payload.receivedAt >= payload.snapshotAt
+            || payload.snapshotAt > now + maximumFutureSkewMs
+            || now - payload.snapshotAt > maximumCursorAgeMs) {
+            throw new Error('CoreMail inbound cursor window is invalid.');
+        }
+        return {
+            snapshotAt: payload.snapshotAt,
+            receivedAt: payload.receivedAt,
+            deliveryId: payload.deliveryId,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"coremail.cursor.js","sourceRoot":"","sources":["../ts/coremail.cursor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EACL,yBAAyB,EACzB,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AA8BjC,MAAM,kBAAkB,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC;AAChD,MAAM,mBAAmB,GAAG,KAAK,CAAC;AAClC,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC;IAC1B,SAAS;IACT,UAAU;IACV,WAAW;IACX,WAAW;IACX,iBAAiB;IACjB,YAAY;IACZ,YAAY;IACZ,YAAY;CACb,CAAC,CAAC;AACH,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC;IAC3B,SAAS;IACT,OAAO;IACP,YAAY;IACZ,SAAS;IACT,WAAW;CACZ,CAAC,CAAC;AAEH,MAAM,gBAAgB,GAAG,CACvB,UAAyC,EACjC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC;IAC1B,OAAO,EAAE,UAAU,CAAC,OAAO;IAC3B,QAAQ,EAAE,UAAU,CAAC,QAAQ;IAC7B,SAAS,EAAE,UAAU,CAAC,SAAS;IAC/B,SAAS,EAAE,UAAU,CAAC,SAAS;IAC/B,eAAe,EAAE,UAAU,CAAC,eAAe;IAC3C,UAAU,EAAE,UAAU,CAAC,UAAU;IACjC,UAAU,EAAE,UAAU,CAAC,UAAU;IACjC,UAAU,EAAE,UAAU,CAAC,UAAU;CAClC,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAG,CACxB,WAA2C,EACnC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC;IAC1B,OAAO,EAAE,WAAW,CAAC,OAAO;IAC5B,KAAK,EAAE,WAAW,CAAC,KAAK;IACxB,UAAU,EAAE,WAAW,CAAC,UAAU;IAClC,OAAO,EAAE,WAAW,CAAC,OAAO;IAC5B,SAAS,EAAE,WAAW,CAAC,SAAS;CACjC,CAAC,CAAC;AAEH,MAAM,gBAAgB,GAAG,CACvB,YAA6C,EACZ,EAAE,CAAC,CAAC;IACrC,QAAQ,EAAE,yBAAyB,CACjC,YAAY,CAAC,QAAQ,EACrB,iBAAiB,CAClB;IACD,SAAS,EAAE,yBAAyB,CAClC,YAAY,CAAC,SAAS,EACtB,kBAAkB,CACnB;IACD,SAAS,EAAE,yBAAyB,CAClC,YAAY,CAAC,SAAS,EACtB,kBAAkB,CACnB;IACD,eAAe,EAAE,0BAA0B,CACzC,YAAY,CAAC,eAAe,EAC5B,wBAAwB,EACxB,CAAC,CACF;CACF,CAAC,CAAC;AAEH,MAAM,oBAAoB,GAAG,CAC3B,UAAkB,EAClB,OAAoB,EACK,EAAE;IAC3B,IAAI,OAAe,CAAC;IACpB,IAAI,MAAe,CAAC;IACpB,IAAI,CAAC;QACH,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;QAC/C,IAAI,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,KAAK,UAAU,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAC3C,CAAC;QACD,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;IACjF,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IACzD,CAAC;IACD,IACE,CAAC,MAAM;WACJ,OAAO,MAAM,KAAK,QAAQ;WAC1B,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;WACrB,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,SAAS;WAClD,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,OAAO,CAAC,IAAI;WAC3C,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAC7D,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,MAAiC,CAAC;AAC3C,CAAC,CAAC;AAEF,MAAM,YAAY,GAAG,CAAC,UAAkB,EAAiC,EAAE;IACzE,MAAM,KAAK,GAAG,oBAAoB,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;IAC5D,IAAI,KAAK,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IACrE,CAAC;IACD,MAAM,OAAO,GAAkC;QAC7C,OAAO,EAAE,CAAC;QACV,QAAQ,EAAE,yBAAyB,CAAC,KAAK,CAAC,QAAQ,EAAE,iBAAiB,CAAC;QACtE,SAAS,EAAE,yBAAyB,CAAC,KAAK,CAAC,SAAS,EAAE,kBAAkB,CAAC;QACzE,SAAS,EAAE,yBAAyB,CAAC,KAAK,CAAC,SAAS,EAAE,kBAAkB,CAAC;QACzE,eAAe,EAAE,0BAA0B,CACzC,KAAK,CAAC,eAAe,EACrB,wBAAwB,EACxB,CAAC,CACF;QACD,UAAU,EAAE,0BAA0B,CACpC,KAAK,CAAC,UAAU,EAChB,mBAAmB,CACpB;QACD,UAAU,EAAE,0BAA0B,CACpC,KAAK,CAAC,UAAU,EAChB,mBAAmB,CACpB;QACD,UAAU,EAAE,mBAAmB,CAAC,KAAK,CAAC,UAAU,EAAE,mBAAmB,CAAC;KACvE,CAAC;IACF,IAAI,gBAAgB,CAAC,OAAO,CAAC,KAAK,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACxF,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC/D,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,CAAC,SAAiB,EAAU,EAAE;IAClD,IACE,OAAO,SAAS,KAAK,QAAQ;WAC1B,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,EAAE;WACzC,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,GAAG;WAC1C,SAAS,CAAC,IAAI,EAAE,KAAK,SAAS,EACjC,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IACxD,CAAC;IACD,OAAO,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,MAAM,EAAE,CAAC;AACpF,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,CACrB,QAAgB,EAChB,aAAqB,EACrB,UAAkB,EACV,EAAE,CAAC,GAAG,QAAQ,IAAI,aAAa,IAAI,UAAU,EAAE,CAAC;AAE1D,MAAM,IAAI,GAAG,CACX,MAAc,EACd,QAAgB,EAChB,aAAqB,EACrB,UAAkB,EACV,EAAE,CAAC,OAAO,CAAC,UAAU;KAC5B,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC5B,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,aAAa,EAAE,UAAU,CAAC,EAAE,OAAO,CAAC;KACpE,MAAM,CAAC,WAAW,CAAC,CAAC;AAEvB,MAAM,OAAO,0BAA0B;IAElB;IADnB,YACmB,oBAAsD;QAAtD,yBAAoB,GAApB,oBAAoB,CAAkC;IACtE,CAAC;IAEG,MAAM,CACX,YAA6C,EAC7C,WAA2C,EAC3C,OAAqB;QAErB,MAAM,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC;QACxE,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,MAAM,SAAS,GAAG,gBAAgB,CAAC,YAAY,CAAC,CAAC;QACjD,MAAM,OAAO,GAAkC;YAC7C,OAAO,EAAE,CAAC;YACV,GAAG,SAAS;YACZ,UAAU,EAAE,0BAA0B,CACpC,WAAW,CAAC,UAAU,EACtB,mBAAmB,CACpB;YACD,UAAU,EAAE,0BAA0B,CACpC,WAAW,CAAC,UAAU,EACtB,mBAAmB,CACpB;YACD,UAAU,EAAE,mBAAmB,CAC7B,WAAW,CAAC,UAAU,EACtB,mBAAmB,CACpB;SACF,CAAC;QACF,IAAI,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;QAClE,CAAC;QACD,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAChC,gBAAgB,CAAC,OAAO,CAAC,EACzB,MAAM,CACP,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QACxB,MAAM,QAAQ,GAAmC;YAC/C,OAAO,EAAE,CAAC;YACV,KAAK,EAAE,UAAU,CAAC,KAAK;YACvB,UAAU,EAAE,UAAU,CAAC,OAAO;YAC9B,OAAO,EAAE,cAAc;YACvB,SAAS,EAAE,IAAI,CACb,aAAa,CAAC,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,EAC9D,UAAU,CAAC,KAAK,EAChB,UAAU,CAAC,OAAO,EAClB,cAAc,CACf;SACF,CAAC;QACF,OAAO,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,8BAA8B,CACpE,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CACvE,CAAC;IACJ,CAAC;IAEM,MAAM,CACX,SAAiB,EACjB,YAA6C,EAC7C,MAAc,EACd,OAAqB;QAErB,MAAM,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,8BAA8B,CAC5E,SAAS,CACV,CAAC;QACF,MAAM,KAAK,GAAG,oBAAoB,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QACzD,IAAI,KAAK,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;QACrE,CAAC;QACD,MAAM,GAAG,GAAG,0BAA0B,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QAC7D,MAAM,KAAK,GAAG,yBAAyB,CAAC,KAAK,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC;QACrE,MAAM,UAAU,GAAG,0BAA0B,CAC3C,KAAK,CAAC,UAAU,EAChB,mBAAmB,EACnB,CAAC,CACF,CAAC;QACF,IAAI,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;YAC7E,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACzD,CAAC;QACD,MAAM,QAAQ,GAAmC;YAC/C,OAAO,EAAE,CAAC;YACV,KAAK;YACL,UAAU;YACV,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,SAAS,EAAE,KAAK,CAAC,SAAS;SAC3B,CAAC;QACF,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACtF,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC/D,CAAC;QACD,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAClC,MAAM,CAAC,KAAK,KAAK,KAAK;eACnB,MAAM,CAAC,OAAO,KAAK,UAAU;eAC7B,CACD,MAAM,CAAC,KAAK,KAAK,SAAS;mBACvB,CACD,MAAM,CAAC,KAAK,KAAK,UAAU;uBACxB,MAAM,CAAC,WAAW,KAAK,SAAS;uBAChC,MAAM,CAAC,WAAW,IAAI,GAAG,CAC7B,CACF,CACF,CAAC;QACF,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,MAAM,eAAe,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QACrE,MAAM,iBAAiB,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CACxC,aAAa,CAAC,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EACvD,GAAG,CAAC,KAAK,EACT,GAAG,CAAC,OAAO,EACX,QAAQ,CAAC,OAAO,CACjB,EAAE,WAAW,CAAC,CAAC;QAChB,IACE,eAAe,CAAC,QAAQ,CAAC,WAAW,CAAC,KAAK,QAAQ,CAAC,SAAS;eACzD,eAAe,CAAC,UAAU,KAAK,iBAAiB,CAAC,UAAU;eAC3D,CAAC,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,eAAe,EAAE,iBAAiB,CAAC,EAC1E,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACzD,CAAC;QACD,MAAM,OAAO,GAAG,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAC/C,MAAM,SAAS,GAAG,gBAAgB,CAAC,YAAY,CAAC,CAAC;QACjD,IACE,OAAO,CAAC,QAAQ,KAAK,SAAS,CAAC,QAAQ;eACpC,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC,SAAS;eACzC,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC,SAAS;eACzC,OAAO,CAAC,eAAe,KAAK,SAAS,CAAC,eAAe,EACxD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACnE,CAAC;QACD,IACE,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,UAAU;eACrC,OAAO,CAAC,UAAU,GAAG,GAAG,GAAG,mBAAmB;eAC9C,GAAG,GAAG,OAAO,CAAC,UAAU,GAAG,kBAAkB,EAChD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAChE,CAAC;QACD,OAAO;YACL,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,UAAU,EAAE,OAAO,CAAC,UAAU;SAC/B,CAAC;IACJ,CAAC;CACF"}

package/dist_ts/coremail.log.d.ts

@@ -0,0 +1,3 @@
+import * as plugins from './plugins.js';
+export declare const coreMailLogger: plugins.smartlog.Smartlog;
+export declare const logCoreMailFailure: (componentArg: "desired-state" | "gateway" | "retention" | "transfer" | "worker", codeArg: string) => Promise<void>;

package/dist_ts/coremail.log.js

@@ -0,0 +1,11 @@
+import * as plugins from './plugins.js';
+export const coreMailLogger = plugins.smartlog.Smartlog.createForCommitinfo({
+    name: '@serve.zone/coremail',
+    version: '1.0.0',
+    description: 'Authenticated mail persistence and delivery orchestration for serve.zone workloads.',
+});
+coreMailLogger.enableConsole();
+export const logCoreMailFailure = async (componentArg, codeArg) => {
+    await coreMailLogger.log('warn', 'CoreMail background operation failed.', { component: componentArg, code: codeArg });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29yZW1haWwubG9nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvY29yZW1haWwubG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBRXhDLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxPQUFPLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxtQkFBbUIsQ0FBQztJQUMxRSxJQUFJLEVBQUUsc0JBQXNCO0lBQzVCLE9BQU8sRUFBRSxPQUFPO0lBQ2hCLFdBQVcsRUFDVCxxRkFBcUY7Q0FDeEYsQ0FBQyxDQUFDO0FBRUgsY0FBYyxDQUFDLGFBQWEsRUFBRSxDQUFDO0FBRS9CLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLEtBQUssRUFDckMsWUFBK0UsRUFDL0UsT0FBZSxFQUNBLEVBQUU7SUFDakIsTUFBTSxjQUFjLENBQUMsR0FBRyxDQUN0QixNQUFNLEVBQ04sdUNBQXVDLEVBQ3ZDLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsT0FBTyxFQUFFLENBQzNDLENBQUM7QUFDSixDQUFDLENBQUMifQ==

package/dist_ts/coremail.mime.d.ts

@@ -0,0 +1,8 @@
+import * as plugins from './plugins.js';
+import type { ISubmissionPartRecord } from './interfaces.js';
+type TMessage = plugins.serveZoneInterfaces.data.ICoreMailOutboundMessageDescriptor;
+export declare const createCoreMailMime: (submissionIdArg: string, submissionDigestArg: plugins.serveZoneInterfaces.data.TCoreMailSha256, createdAtArg: number, messageArg: TMessage, partsArg: Array<{
+    descriptor: ISubmissionPartRecord;
+    bytes: Uint8Array;
+}>) => Uint8Array;
+export {};

package/dist_ts/coremail.mime.js

@@ -0,0 +1,63 @@
+import * as plugins from './plugins.js';
+const encodeHeaderText = (valueArg) => /^[\x20-\x7e]*$/.test(valueArg)
+    ? valueArg
+    : `=?UTF-8?B?${Buffer.from(valueArg, 'utf8').toString('base64')}?=`;
+const formatMailbox = (mailboxArg) => {
+    if (!mailboxArg.displayName) {
+        return `<${mailboxArg.address}>`;
+    }
+    const displayName = encodeHeaderText(mailboxArg.displayName);
+    const rendered = /^[A-Za-z0-9 ._-]+$/.test(displayName)
+        ? displayName
+        : `"${displayName.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+    return `${rendered} <${mailboxArg.address}>`;
+};
+const foldBase64 = (bytesArg) => Buffer.from(bytesArg)
+    .toString('base64')
+    .match(/.{1,76}/g)
+    ?.join('\r\n') ?? '';
+const contentDisposition = (partArg) => {
+    if (partArg.kind !== 'attachment') {
+        return 'inline';
+    }
+    if (!partArg.filename) {
+        return 'attachment';
+    }
+    const fallback = partArg.filename
+        .replace(/[^\x20-\x7e]/g, '_')
+        .replaceAll('\\', '\\\\')
+        .replaceAll('"', '\\"');
+    return `attachment; filename="${fallback}"; filename*=UTF-8''${encodeURIComponent(partArg.filename)}`;
+};
+export const createCoreMailMime = (submissionIdArg, submissionDigestArg, createdAtArg, messageArg, partsArg) => {
+    const boundary = `coremail_${submissionDigestArg.slice('sha256:'.length, 48)}`;
+    const to = messageArg.recipients.to.map(formatMailbox).join(', ');
+    const cc = messageArg.recipients.cc?.map(formatMailbox).join(', ');
+    const headers = [
+        `Date: ${new Date(createdAtArg).toUTCString()}`,
+        `Message-ID: <${submissionIdArg}@coremail.serve.zone>`,
+        `From: ${formatMailbox(messageArg.sender)}`,
+        `To: ${to}`,
+        ...(cc ? [`Cc: ${cc}`] : []),
+        ...(messageArg.replyTo ? [`Reply-To: ${formatMailbox(messageArg.replyTo)}`] : []),
+        `Subject: ${encodeHeaderText(messageArg.subject)}`,
+        ...(messageArg.headers ?? []).map((headerArg) => `${headerArg.name}: ${encodeHeaderText(headerArg.value)}`),
+        'MIME-Version: 1.0',
+        `Content-Type: multipart/mixed; boundary="${boundary}"`,
+        '',
+        'This is a multipart message in MIME format.',
+    ];
+    for (const part of partsArg) {
+        headers.push(`--${boundary}`, `Content-Type: ${part.descriptor.contentType}`, 'Content-Transfer-Encoding: base64', `Content-Disposition: ${contentDisposition(part.descriptor)}`, ...(part.descriptor.contentId
+            ? [`Content-ID: <${part.descriptor.contentId}>`]
+            : []), '', foldBase64(part.bytes));
+    }
+    headers.push(`--${boundary}--`, '');
+    const encoded = new TextEncoder().encode(headers.join('\r\n'));
+    if (encoded.byteLength >
+        plugins.serveZoneInterfaces.data.coreMailLimits.serializedMimeBytes) {
+        throw new Error('CoreMail serialized MIME exceeds its byte budget.');
+    }
+    return encoded;
+};
+//# sourceMappingURL=data:application/json;base64,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