@serve.zone/coremail 1.0.0

package/.smartconfig.json

@@ -0,0 +1,50 @@
+{
+  "@git.zone/cli": {
+    "schemaVersion": 2,
+    "projectType": "service",
+    "module": {
+      "githost": "code.foss.global",
+      "gitscope": "serve.zone",
+      "gitrepo": "coremail",
+      "description": "Authenticated mail persistence and delivery orchestration for serve.zone workloads.",
+      "npmPackagename": "@serve.zone/coremail",
+      "license": "MIT"
+    },
+    "release": {
+      "targets": {
+        "git": {
+          "enabled": true,
+          "remote": "origin",
+          "pushBranch": true,
+          "pushTags": true
+        },
+        "npm": {
+          "enabled": true,
+          "registries": [
+            "https://verdaccio.lossless.digital",
+            "https://registry.npmjs.org"
+          ],
+          "accessLevel": "public",
+          "alreadyPublished": "success"
+        },
+        "docker": {
+          "enabled": true,
+          "engine": "tsdocker",
+          "patterns": []
+        }
+      }
+    }
+  },
+  "@git.zone/tsdocker": {
+    "registries": [
+      "code.foss.global"
+    ],
+    "registryRepoMap": {
+      "code.foss.global": "serve.zone/coremail"
+    },
+    "platforms": [
+      "linux/amd64",
+      "linux/arm64"
+    ]
+  }
+}

package/changelog.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 2026-07-30 - 1.0.0
+
+### Breaking Changes
+
+- Add the standalone CoreMail service with authenticated workload/control and
+  dcrouter gateway sessions, SmartData-only state transitions, exact
+  SmartBucket transfers, deterministic MIME, bounded inbound delivery cursors,
+  monotonic desired-state activation, and lifecycle-owned outbound delivery.

package/cli.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+process.env.CLI_CALL = 'true';
+const cliTool = await import('./dist_ts/index.js');
+await cliTool.runCli();

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@serve.zone/coremail',
+    version: '1.0.0',
+    description: 'Authenticated mail persistence and delivery orchestration for serve.zone workloads.'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxzQkFBc0I7SUFDNUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHFGQUFxRjtDQUNuRyxDQUFBIn0=

package/dist_ts/classes.auth.d.ts

@@ -0,0 +1,45 @@
+import * as plugins from './plugins.js';
+import type { ICoreMailAuthLimiterSnapshot, ICoreMailControlSession, ICoreMailPeer, ICoreMailWorkloadSession } from './interfaces.js';
+type TCoreMailDesiredState = plugins.serveZoneInterfaces.data.ICoreMailDesiredState;
+type TCoreMailBinding = plugins.serveZoneInterfaces.data.ICoreMailBindingDesiredState;
+export declare const coreMailSessionKey = "coremail.authenticated-session";
+export declare const coreMailPreAuthDeadlineKey = "coremail.pre-auth-deadline";
+export declare class CoreMailAuthenticationError extends Error {
+    constructor();
+}
+export declare class CoreMailAuthorizationError extends Error {
+    constructor();
+}
+export declare class CoreMailCapabilityDeniedError extends Error {
+    constructor();
+}
+export declare class CoreMailAuthLimiter {
+    private readonly maximumInFlight;
+    private readonly capacity;
+    private readonly refillPerSecond;
+    private readonly now;
+    private inFlight;
+    private tokens;
+    private lastRefillAt;
+    constructor(maximumInFlight?: number, capacity?: number, refillPerSecond?: number, now?: () => number);
+    private refill;
+    snapshot(): ICoreMailAuthLimiterSnapshot;
+    run<T>(workArg: () => Promise<T>): Promise<T>;
+}
+export declare class CoreMailAuth {
+    private readonly controlBootstrap;
+    private readonly getActiveDesiredState;
+    private readonly now;
+    readonly limiter: CoreMailAuthLimiter;
+    constructor(controlBootstrap: plugins.serveZoneInterfaces.data.ICoreMailControlBootstrap, getActiveDesiredState: () => Promise<TCoreMailDesiredState | null>, now?: () => number);
+    private requireFreshPeer;
+    private verify;
+    authenticateControl(peerArg: ICoreMailPeer, requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailAuthenticateControl['request']): Promise<ICoreMailControlSession>;
+    authenticateWorkload(peerArg: ICoreMailPeer, requestArg: plugins.serveZoneInterfaces.requests.coremail.IReq_CoreMailAuthenticateWorkload['request']): Promise<ICoreMailWorkloadSession>;
+    requireControlSession(peerArg: ICoreMailPeer): ICoreMailControlSession;
+    requireWorkloadSession(peerArg: ICoreMailPeer, operationArg: plugins.serveZoneInterfaces.data.TCoreMailWorkloadOperation): Promise<{
+        session: ICoreMailWorkloadSession;
+        binding: TCoreMailBinding;
+    }>;
+}
+export {};

package/dist_ts/classes.auth.js

@@ -0,0 +1,204 @@
+import * as plugins from './plugins.js';
+import { requireCoreMailIdentifier, requireCoreMailSafeInteger, } from './coremail.selectors.js';
+export const coreMailSessionKey = 'coremail.authenticated-session';
+export const coreMailPreAuthDeadlineKey = 'coremail.pre-auth-deadline';
+export class CoreMailAuthenticationError extends Error {
+    constructor() {
+        super('CoreMail authentication failed.');
+        this.name = 'CoreMailAuthenticationError';
+    }
+}
+export class CoreMailAuthorizationError extends Error {
+    constructor() {
+        super('CoreMail authority is unavailable.');
+        this.name = 'CoreMailAuthorizationError';
+    }
+}
+export class CoreMailCapabilityDeniedError extends Error {
+    constructor() {
+        super('CoreMail operation is not permitted by this authority.');
+        this.name = 'CoreMailCapabilityDeniedError';
+    }
+}
+export class CoreMailAuthLimiter {
+    maximumInFlight;
+    capacity;
+    refillPerSecond;
+    now;
+    inFlight = 0;
+    tokens;
+    lastRefillAt;
+    constructor(maximumInFlight = 4, capacity = 8, refillPerSecond = 2, now = Date.now) {
+        this.maximumInFlight = maximumInFlight;
+        this.capacity = capacity;
+        this.refillPerSecond = refillPerSecond;
+        this.now = now;
+        this.tokens = capacity;
+        this.lastRefillAt = now();
+    }
+    refill() {
+        const now = this.now();
+        const elapsedMs = Math.max(0, now - this.lastRefillAt);
+        if (elapsedMs < 1_000) {
+            return;
+        }
+        const intervals = Math.floor(elapsedMs / 1_000);
+        this.tokens = Math.min(this.capacity, this.tokens + (intervals * this.refillPerSecond));
+        this.lastRefillAt += intervals * 1_000;
+    }
+    snapshot() {
+        this.refill();
+        return { inFlight: this.inFlight, tokens: this.tokens };
+    }
+    async run(workArg) {
+        this.refill();
+        if (this.inFlight >= this.maximumInFlight || this.tokens < 1) {
+            throw new CoreMailAuthenticationError();
+        }
+        this.tokens--;
+        this.inFlight++;
+        try {
+            return await workArg();
+        }
+        finally {
+            this.inFlight--;
+        }
+    }
+}
+const findAcceptedVerifier = (credentialsArg, credentialIdArg, credentialVersionArg, nowArg) => credentialsArg.find((credentialArg) => credentialArg.credentialId === credentialIdArg
+    && credentialArg.version === credentialVersionArg
+    && (credentialArg.state === 'current'
+        || (credentialArg.state === 'retiring'
+            && credentialArg.acceptUntil !== undefined
+            && credentialArg.acceptUntil >= nowArg)));
+export class CoreMailAuth {
+    controlBootstrap;
+    getActiveDesiredState;
+    now;
+    limiter = new CoreMailAuthLimiter();
+    constructor(controlBootstrap, getActiveDesiredState, now = Date.now) {
+        this.controlBootstrap = controlBootstrap;
+        this.getActiveDesiredState = getActiveDesiredState;
+        this.now = now;
+    }
+    requireFreshPeer(peerArg) {
+        const deadline = peerArg.context.state[coreMailPreAuthDeadlineKey];
+        if (peerArg.data.has(coreMailSessionKey)
+            || !Number.isSafeInteger(deadline)
+            || Number(deadline) < this.now()) {
+            peerArg.close(4401, 'authentication required');
+            throw new CoreMailAuthenticationError();
+        }
+    }
+    async verify(verifierArg, secretArg) {
+        if (!verifierArg
+            || typeof secretArg !== 'string'
+            || secretArg.length < 32
+            || secretArg.length > 512) {
+            throw new CoreMailAuthenticationError();
+        }
+        const verified = await this.limiter.run(async () => plugins.argon2.verify(verifierArg.verificationHash, secretArg));
+        if (!verified) {
+            throw new CoreMailAuthenticationError();
+        }
+    }
+    async authenticateControl(peerArg, requestArg) {
+        this.requireFreshPeer(peerArg);
+        try {
+            const credentialId = requireCoreMailIdentifier(requestArg.credentialId, 'credentialId');
+            const credentialVersion = requireCoreMailSafeInteger(requestArg.credentialVersion, 'credentialVersion', 1);
+            const verifier = findAcceptedVerifier(this.controlBootstrap.credentials, credentialId, credentialVersion, this.now());
+            await this.verify(verifier, requestArg.credentialSecret);
+            const session = Object.freeze({
+                kind: 'control',
+                peerId: peerArg.id,
+                credentialId,
+                credentialVersion,
+                authenticatedAt: this.now(),
+            });
+            peerArg.data.set(coreMailSessionKey, session);
+            return session;
+        }
+        catch {
+            peerArg.close(4401, 'authentication failed');
+            throw new CoreMailAuthenticationError();
+        }
+    }
+    async authenticateWorkload(peerArg, requestArg) {
+        this.requireFreshPeer(peerArg);
+        try {
+            const desiredState = await this.getActiveDesiredState();
+            const bindingId = requireCoreMailIdentifier(requestArg.bindingId, 'bindingId');
+            const credentialId = requireCoreMailIdentifier(requestArg.credentialId, 'credentialId');
+            const credentialVersion = requireCoreMailSafeInteger(requestArg.credentialVersion, 'credentialVersion', 1);
+            const binding = desiredState?.bindings.find((bindingArg) => bindingArg.bindingId === bindingId
+                && bindingArg.state !== 'disabled');
+            const verifier = binding && findAcceptedVerifier(binding.credentials, credentialId, credentialVersion, this.now());
+            await this.verify(verifier, requestArg.credentialSecret);
+            const allowedOperations = plugins.serveZoneInterfaces.data.resolveCoreMailWorkloadOperations(binding.state, binding.capabilities);
+            const session = Object.freeze({
+                kind: 'workload',
+                peerId: peerArg.id,
+                tenantId: binding.tenantId,
+                serviceId: binding.serviceId,
+                bindingId: binding.bindingId,
+                bindingRevision: binding.revision,
+                configEpoch: desiredState.configEpoch,
+                credentialId,
+                credentialVersion,
+                bindingState: binding.state,
+                capabilities: Object.freeze([...binding.capabilities]),
+                allowedOperations: Object.freeze([...allowedOperations]),
+                coreMailTransferOrigin: desiredState.gateway.coreMailTransferOrigin,
+                authenticatedAt: this.now(),
+            });
+            peerArg.data.set(coreMailSessionKey, session);
+            return session;
+        }
+        catch {
+            peerArg.close(4401, 'authentication failed');
+            throw new CoreMailAuthenticationError();
+        }
+    }
+    requireControlSession(peerArg) {
+        const session = peerArg.data.get(coreMailSessionKey);
+        if (!session || session.kind !== 'control' || session.peerId !== peerArg.id) {
+            peerArg.close(4403, 'authority unavailable');
+            throw new CoreMailAuthorizationError();
+        }
+        const verifier = findAcceptedVerifier(this.controlBootstrap.credentials, session.credentialId, session.credentialVersion, this.now());
+        if (!verifier) {
+            peerArg.close(4403, 'authority expired');
+            throw new CoreMailAuthorizationError();
+        }
+        return session;
+    }
+    async requireWorkloadSession(peerArg, operationArg) {
+        const session = peerArg.data.get(coreMailSessionKey);
+        if (!session || session.kind !== 'workload' || session.peerId !== peerArg.id) {
+            peerArg.close(4403, 'authority unavailable');
+            throw new CoreMailAuthorizationError();
+        }
+        const desiredState = await this.getActiveDesiredState();
+        const binding = desiredState?.bindings.find((bindingArg) => bindingArg.bindingId === session.bindingId
+            && bindingArg.serviceId === session.serviceId
+            && bindingArg.tenantId === session.tenantId
+            && bindingArg.revision === session.bindingRevision
+            && bindingArg.state === session.bindingState);
+        const verifier = binding && findAcceptedVerifier(binding.credentials, session.credentialId, session.credentialVersion, this.now());
+        if (!desiredState
+            || desiredState.configEpoch !== session.configEpoch
+            || !binding
+            || !verifier) {
+            peerArg.close(4403, 'authority expired');
+            throw new CoreMailAuthorizationError();
+        }
+        const allowedOperations = plugins.serveZoneInterfaces.data.resolveCoreMailWorkloadOperations(binding.state, binding.capabilities);
+        if (!session.allowedOperations.includes(operationArg)
+            || !allowedOperations.includes(operationArg)) {
+            throw new CoreMailCapabilityDeniedError();
+        }
+        return { session, binding };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.auth.js","sourceRoot":"","sources":["../ts/classes.auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAQxC,OAAO,EACL,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,yBAAyB,CAAC;AAOjC,MAAM,CAAC,MAAM,kBAAkB,GAAG,gCAAgC,CAAC;AACnE,MAAM,CAAC,MAAM,0BAA0B,GAAG,4BAA4B,CAAC;AAEvE,MAAM,OAAO,2BAA4B,SAAQ,KAAK;IACpD;QACE,KAAK,CAAC,iCAAiC,CAAC,CAAC;QACzC,IAAI,CAAC,IAAI,GAAG,6BAA6B,CAAC;IAC5C,CAAC;CACF;AAED,MAAM,OAAO,0BAA2B,SAAQ,KAAK;IACnD;QACE,KAAK,CAAC,oCAAoC,CAAC,CAAC;QAC5C,IAAI,CAAC,IAAI,GAAG,4BAA4B,CAAC;IAC3C,CAAC;CACF;AAED,MAAM,OAAO,6BAA8B,SAAQ,KAAK;IACtD;QACE,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAChE,IAAI,CAAC,IAAI,GAAG,+BAA+B,CAAC;IAC9C,CAAC;CACF;AAED,MAAM,OAAO,mBAAmB;IAMX;IACA;IACA;IACA;IARX,QAAQ,GAAG,CAAC,CAAC;IACb,MAAM,CAAS;IACf,YAAY,CAAS;IAE7B,YACmB,kBAAkB,CAAC,EACnB,WAAW,CAAC,EACZ,kBAAkB,CAAC,EACnB,MAAoB,IAAI,CAAC,GAAG;QAH5B,oBAAe,GAAf,eAAe,CAAI;QACnB,aAAQ,GAAR,QAAQ,CAAI;QACZ,oBAAe,GAAf,eAAe,CAAI;QACnB,QAAG,GAAH,GAAG,CAAyB;QAE7C,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC;QACvB,IAAI,CAAC,YAAY,GAAG,GAAG,EAAE,CAAC;IAC5B,CAAC;IAEO,MAAM;QACZ,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC;QACvD,IAAI,SAAS,GAAG,KAAK,EAAE,CAAC;YACtB,OAAO;QACT,CAAC;QACD,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC;QAChD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CACpB,IAAI,CAAC,QAAQ,EACb,IAAI,CAAC,MAAM,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,CACjD,CAAC;QACF,IAAI,CAAC,YAAY,IAAI,SAAS,GAAG,KAAK,CAAC;IACzC,CAAC;IAEM,QAAQ;QACb,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;IAC1D,CAAC;IAEM,KAAK,CAAC,GAAG,CAAI,OAAyB;QAC3C,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7D,MAAM,IAAI,2BAA2B,EAAE,CAAC;QAC1C,CAAC;QACD,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChB,IAAI,CAAC;YACH,OAAO,MAAM,OAAO,EAAE,CAAC;QACzB,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClB,CAAC;IACH,CAAC;CACF;AAED,MAAM,oBAAoB,GAAG,CAC3B,cAAmC,EACnC,eAAuB,EACvB,oBAA4B,EAC5B,MAAc,EACiB,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,EAAE,CACxE,aAAa,CAAC,YAAY,KAAK,eAAe;OAC3C,aAAa,CAAC,OAAO,KAAK,oBAAoB;OAC9C,CACD,aAAa,CAAC,KAAK,KAAK,SAAS;WAC9B,CACD,aAAa,CAAC,KAAK,KAAK,UAAU;eAC/B,aAAa,CAAC,WAAW,KAAK,SAAS;eACvC,aAAa,CAAC,WAAW,IAAI,MAAM,CACvC,CACF,CACF,CAAC;AAEF,MAAM,OAAO,YAAY;IAIJ;IAEA;IAEA;IAPH,OAAO,GAAG,IAAI,mBAAmB,EAAE,CAAC;IAEpD,YACmB,gBAC2C,EAC3C,qBACsB,EACtB,MAAoB,IAAI,CAAC,GAAG;QAJ5B,qBAAgB,GAAhB,gBAAgB,CAC2B;QAC3C,0BAAqB,GAArB,qBAAqB,CACC;QACtB,QAAG,GAAH,GAAG,CAAyB;IAC5C,CAAC;IAEI,gBAAgB,CAAC,OAAsB;QAC7C,MAAM,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC;QACnE,IACE,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC;eACjC,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC;eAC/B,MAAM,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,EAChC,CAAC;YACD,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,yBAAyB,CAAC,CAAC;YAC/C,MAAM,IAAI,2BAA2B,EAAE,CAAC;QAC1C,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,MAAM,CAClB,WAA0C,EAC1C,SAAiB;QAEjB,IACE,CAAC,WAAW;eACT,OAAO,SAAS,KAAK,QAAQ;eAC7B,SAAS,CAAC,MAAM,GAAG,EAAE;eACrB,SAAS,CAAC,MAAM,GAAG,GAAG,EACzB,CAAC;YACD,MAAM,IAAI,2BAA2B,EAAE,CAAC;QAC1C,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CACjD,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAC/D,CAAC;QACF,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,2BAA2B,EAAE,CAAC;QAC1C,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,mBAAmB,CAC9B,OAAsB,EACtB,UAC2F;QAE3F,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,yBAAyB,CAC5C,UAAU,CAAC,YAAY,EACvB,cAAc,CACf,CAAC;YACF,MAAM,iBAAiB,GAAG,0BAA0B,CAClD,UAAU,CAAC,iBAAiB,EAC5B,mBAAmB,EACnB,CAAC,CACF,CAAC;YACF,MAAM,QAAQ,GAAG,oBAAoB,CACnC,IAAI,CAAC,gBAAgB,CAAC,WAAW,EACjC,YAAY,EACZ,iBAAiB,EACjB,IAAI,CAAC,GAAG,EAAE,CACX,CAAC;YACF,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC;YACzD,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAA0B;gBACrD,IAAI,EAAE,SAAS;gBACf,MAAM,EAAE,OAAO,CAAC,EAAE;gBAClB,YAAY;gBACZ,iBAAiB;gBACjB,eAAe,EAAE,IAAI,CAAC,GAAG,EAAE;aAC5B,CAAC,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC;YAC9C,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAC;YAC7C,MAAM,IAAI,2BAA2B,EAAE,CAAC;QAC1C,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,oBAAoB,CAC/B,OAAsB,EACtB,UAC4F;QAE5F,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;YACxD,MAAM,SAAS,GAAG,yBAAyB,CACzC,UAAU,CAAC,SAAS,EACpB,WAAW,CACZ,CAAC;YACF,MAAM,YAAY,GAAG,yBAAyB,CAC5C,UAAU,CAAC,YAAY,EACvB,cAAc,CACf,CAAC;YACF,MAAM,iBAAiB,GAAG,0BAA0B,CAClD,UAAU,CAAC,iBAAiB,EAC5B,mBAAmB,EACnB,CAAC,CACF,CAAC;YACF,MAAM,OAAO,GAAG,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CACzD,UAAU,CAAC,SAAS,KAAK,SAAS;mBAC/B,UAAU,CAAC,KAAK,KAAK,UAAU,CACnC,CAAC;YACF,MAAM,QAAQ,GAAG,OAAO,IAAI,oBAAoB,CAC9C,OAAO,CAAC,WAAW,EACnB,YAAY,EACZ,iBAAiB,EACjB,IAAI,CAAC,GAAG,EAAE,CACX,CAAC;YACF,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,gBAAgB,CAAC,CAAC;YACzD,MAAM,iBAAiB,GACrB,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,iCAAiC,CAChE,OAAQ,CAAC,KAAK,EACd,OAAQ,CAAC,YAAY,CACtB,CAAC;YACJ,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAA2B;gBACtD,IAAI,EAAE,UAAU;gBAChB,MAAM,EAAE,OAAO,CAAC,EAAE;gBAClB,QAAQ,EAAE,OAAQ,CAAC,QAAQ;gBAC3B,SAAS,EAAE,OAAQ,CAAC,SAAS;gBAC7B,SAAS,EAAE,OAAQ,CAAC,SAAS;gBAC7B,eAAe,EAAE,OAAQ,CAAC,QAAQ;gBAClC,WAAW,EAAE,YAAa,CAAC,WAAW;gBACtC,YAAY;gBACZ,iBAAiB;gBACjB,YAAY,EAAE,OAAQ,CAAC,KAA8B;gBACrD,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,OAAQ,CAAC,YAAY,CAAC,CACE;gBACxD,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,iBAAiB,CAAC,CACQ;gBAC/D,sBAAsB,EAAE,YAAa,CAAC,OAAO,CAAC,sBAAsB;gBACpE,eAAe,EAAE,IAAI,CAAC,GAAG,EAAE;aAC5B,CAAC,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC;YAC9C,OAAO,OAAO,CAAC;QACjB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAC;YAC7C,MAAM,IAAI,2BAA2B,EAAE,CAAC;QAC1C,CAAC;IACH,CAAC;IAEM,qBAAqB,CAAC,OAAsB;QACjD,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAiC,CAAC;QACrF,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,EAAE,EAAE,CAAC;YAC5E,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAC;YAC7C,MAAM,IAAI,0BAA0B,EAAE,CAAC;QACzC,CAAC;QACD,MAAM,QAAQ,GAAG,oBAAoB,CACnC,IAAI,CAAC,gBAAgB,CAAC,WAAW,EACjC,OAAO,CAAC,YAAY,EACpB,OAAO,CAAC,iBAAiB,EACzB,IAAI,CAAC,GAAG,EAAE,CACX,CAAC;QACF,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;YACzC,MAAM,IAAI,0BAA0B,EAAE,CAAC;QACzC,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAEM,KAAK,CAAC,sBAAsB,CACjC,OAAsB,EACtB,YAAyE;QAKzE,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAiC,CAAC;QACrF,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,KAAK,UAAU,IAAI,OAAO,CAAC,MAAM,KAAK,OAAO,CAAC,EAAE,EAAE,CAAC;YAC7E,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAC;YAC7C,MAAM,IAAI,0BAA0B,EAAE,CAAC;QACzC,CAAC;QACD,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;QACxD,MAAM,OAAO,GAAG,YAAY,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CACzD,UAAU,CAAC,SAAS,KAAK,OAAO,CAAC,SAAS;eACvC,UAAU,CAAC,SAAS,KAAK,OAAO,CAAC,SAAS;eAC1C,UAAU,CAAC,QAAQ,KAAK,OAAO,CAAC,QAAQ;eACxC,UAAU,CAAC,QAAQ,KAAK,OAAO,CAAC,eAAe;eAC/C,UAAU,CAAC,KAAK,KAAK,OAAO,CAAC,YAAY,CAC7C,CAAC;QACF,MAAM,QAAQ,GAAG,OAAO,IAAI,oBAAoB,CAC9C,OAAO,CAAC,WAAW,EACnB,OAAO,CAAC,YAAY,EACpB,OAAO,CAAC,iBAAiB,EACzB,IAAI,CAAC,GAAG,EAAE,CACX,CAAC;QACF,IACE,CAAC,YAAY;eACV,YAAY,CAAC,WAAW,KAAK,OAAO,CAAC,WAAW;eAChD,CAAC,OAAO;eACR,CAAC,QAAQ,EACZ,CAAC;YACD,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;YACzC,MAAM,IAAI,0BAA0B,EAAE,CAAC;QACzC,CAAC;QACD,MAAM,iBAAiB,GACrB,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,iCAAiC,CAChE,OAAO,CAAC,KAAK,EACb,OAAO,CAAC,YAAY,CACrB,CAAC;QACJ,IACE,CAAC,OAAO,CAAC,iBAAiB,CAAC,QAAQ,CAAC,YAAY,CAAC;eAC9C,CAAC,iBAAiB,CAAC,QAAQ,CAAC,YAAY,CAAC,EAC5C,CAAC;YACD,MAAM,IAAI,6BAA6B,EAAE,CAAC;QAC5C,CAAC;QACD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;IAC9B,CAAC;CACF"}

package/dist_ts/classes.config.d.ts

@@ -0,0 +1,2 @@
+import type { ICoreMailConfig } from './interfaces.js';
+export declare const readCoreMailConfig: () => ICoreMailConfig;

package/dist_ts/classes.config.js

@@ -0,0 +1,72 @@
+import * as plugins from './plugins.js';
+const requireEnv = (keyArg) => {
+    const value = process.env[keyArg];
+    if (!value || value.trim() !== value) {
+        throw new Error(`CoreMail requires a non-empty canonical ${keyArg}.`);
+    }
+    return value;
+};
+const parsePositiveInteger = (valueArg, keyArg, maximumArg) => {
+    if (!/^[1-9][0-9]*$/.test(valueArg)) {
+        throw new Error(`${keyArg} must be a positive integer.`);
+    }
+    const value = Number(valueArg);
+    if (!Number.isSafeInteger(value) || value > maximumArg) {
+        throw new Error(`${keyArg} is outside the supported range.`);
+    }
+    return value;
+};
+const parsePlainJson = (valueArg, keyArg) => {
+    const parsed = JSON.parse(valueArg);
+    if (!parsed
+        || typeof parsed !== 'object'
+        || Array.isArray(parsed)
+        || Object.getPrototypeOf(parsed) !== Object.prototype) {
+        throw new Error(`${keyArg} must contain one plain JSON object.`);
+    }
+    return parsed;
+};
+const parseHostnames = (valueArg) => {
+    const hostnames = valueArg.split(',');
+    if (hostnames.length === 0
+        || hostnames.length > 16
+        || hostnames.some((entryArg) => entryArg.trim() !== entryArg
+            || !/^[a-z0-9](?:[a-z0-9.-]{0,251}[a-z0-9])?$/.test(entryArg)
+            || entryArg.includes('..'))
+        || new Set(hostnames).size !== hostnames.length) {
+        throw new Error('COREMAIL_HOSTNAMES must be a unique canonical hostname list.');
+    }
+    return hostnames;
+};
+export const readCoreMailConfig = () => {
+    const controlBootstrap = plugins.serveZoneInterfaces.data.normalizeCoreMailControlBootstrap(parsePlainJson(requireEnv(plugins.serveZoneInterfaces.data.coreMailRuntimeKeys.controlBootstrap), plugins.serveZoneInterfaces.data.coreMailRuntimeKeys.controlBootstrap));
+    const serviceId = requireEnv('COREMAIL_SERVICE_ID');
+    if (controlBootstrap.coreMailServiceId !== serviceId) {
+        throw new Error('CoreMail control bootstrap is bound to another service.');
+    }
+    const storageDescriptor = parsePlainJson(requireEnv('COREMAIL_STORAGE_DESCRIPTOR'), 'COREMAIL_STORAGE_DESCRIPTOR');
+    return Object.freeze({
+        port: parsePositiveInteger(process.env.COREMAIL_PORT ?? '3000', 'COREMAIL_PORT', 65_535),
+        hostnames: Object.freeze(parseHostnames(process.env.COREMAIL_HOSTNAMES ?? 'coremail.serve.zone')),
+        mongoDescriptor: Object.freeze({
+            mongoDbUrl: requireEnv('COREMAIL_MONGODB_URL'),
+            mongoDbName: requireEnv('COREMAIL_MONGODB_NAME'),
+            maxPoolSize: parsePositiveInteger(process.env.COREMAIL_MONGODB_MAX_POOL_SIZE ?? '50', 'COREMAIL_MONGODB_MAX_POOL_SIZE', 500),
+            maxIdleTimeMS: 300_000,
+            serverSelectionTimeoutMS: 10_000,
+            socketTimeoutMS: 30_000,
+        }),
+        storageDescriptor: Object.freeze(storageDescriptor),
+        bucketName: requireEnv('COREMAIL_BUCKET_NAME'),
+        controlBootstrap,
+        resolveRuntimeSecret: requireEnv,
+        replica: Object.freeze({
+            taskId: requireEnv('COREMAIL_TASK_ID'),
+            serviceId,
+            rolloutId: requireEnv('COREMAIL_ROLLOUT_ID'),
+            rolloutGeneration: parsePositiveInteger(requireEnv('COREMAIL_ROLLOUT_GENERATION'), 'COREMAIL_ROLLOUT_GENERATION', Number.MAX_SAFE_INTEGER),
+            imageDigest: plugins.serveZoneInterfaces.data.normalizeCoreMailSha256(requireEnv('COREMAIL_IMAGE_DIGEST')),
+        }),
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.coremail.d.ts

@@ -0,0 +1,41 @@
+import * as plugins from './plugins.js';
+import { CoreMailAuth } from './classes.auth.js';
+import { CoreMailDesiredStateService } from './classes.desiredstate.js';
+import { CoreMailGateway, CoreMailOutboundWorker } from './classes.gateway.js';
+import { CoreMailInboundService } from './classes.inbound.js';
+import { CoreMailMaintenanceService } from './classes.maintenance.js';
+import { type ICoreMailModels } from './classes.models.js';
+import { CoreMailServer } from './classes.server.js';
+import { CoreMailStorage } from './classes.storage.js';
+import { CoreMailSubmissionService } from './classes.submissions.js';
+import { CoreMailTransferService } from './classes.transfer.js';
+import type { ICoreMailConfig } from './interfaces.js';
+export declare class CoreMail {
+    readonly config: ICoreMailConfig;
+    readonly database: plugins.smartdata.SmartdataDb;
+    readonly models: ICoreMailModels;
+    readonly storage: CoreMailStorage;
+    readonly transfers: CoreMailTransferService;
+    readonly desiredState: CoreMailDesiredStateService;
+    readonly auth: CoreMailAuth;
+    readonly submissions: CoreMailSubmissionService;
+    readonly inbound: CoreMailInboundService;
+    readonly maintenance: CoreMailMaintenanceService;
+    readonly gateway: CoreMailGateway;
+    readonly server: CoreMailServer;
+    readonly outboundWorker: CoreMailOutboundWorker;
+    private lifecycleState;
+    private startPromise;
+    private stopPromise;
+    private databaseStarted;
+    private storageStarted;
+    private gatewayStarted;
+    private serverStarted;
+    private workerStarted;
+    private maintenanceStarted;
+    constructor(configArg?: ICoreMailConfig);
+    start(): Promise<void>;
+    private startInternal;
+    stop(): Promise<void>;
+    private stopStartedResources;
+}

package/dist_ts/classes.coremail.js

@@ -0,0 +1,155 @@
+import * as plugins from './plugins.js';
+import { CoreMailAuth } from './classes.auth.js';
+import { readCoreMailConfig } from './classes.config.js';
+import { CoreMailDesiredStateService } from './classes.desiredstate.js';
+import { CoreMailGateway, CoreMailOutboundWorker, } from './classes.gateway.js';
+import { CoreMailInboundService } from './classes.inbound.js';
+import { CoreMailMaintenanceService } from './classes.maintenance.js';
+import { createCoreMailModels, prepareCoreMailModelsForTransactions, } from './classes.models.js';
+import { CoreMailServer } from './classes.server.js';
+import { CoreMailStorage } from './classes.storage.js';
+import { CoreMailSubmissionService } from './classes.submissions.js';
+import { CoreMailTransferService } from './classes.transfer.js';
+export class CoreMail {
+    config;
+    database;
+    models;
+    storage;
+    transfers;
+    desiredState;
+    auth;
+    submissions;
+    inbound;
+    maintenance;
+    gateway;
+    server;
+    outboundWorker;
+    lifecycleState = 'new';
+    startPromise = null;
+    stopPromise = null;
+    databaseStarted = false;
+    storageStarted = false;
+    gatewayStarted = false;
+    serverStarted = false;
+    workerStarted = false;
+    maintenanceStarted = false;
+    constructor(configArg = readCoreMailConfig()) {
+        this.config = configArg;
+        this.database = new plugins.smartdata.SmartdataDb(configArg.mongoDescriptor);
+        this.models = createCoreMailModels(this.database);
+        this.storage = new CoreMailStorage(configArg.storageDescriptor, configArg.bucketName);
+        this.transfers = new CoreMailTransferService(this.models, this.storage);
+        let server;
+        this.desiredState = new CoreMailDesiredStateService(this.database, this.models, this.storage, this.transfers, configArg.replica, (bindingArg, configEpochArg) => server?.activeSessionCounts(bindingArg, configEpochArg) ?? []);
+        this.auth = new CoreMailAuth(configArg.controlBootstrap, this.desiredState.getActiveDesiredState);
+        this.submissions = new CoreMailSubmissionService(this.database, this.models, this.storage, this.transfers);
+        this.inbound = new CoreMailInboundService(this.database, this.models, this.transfers, configArg.replica.serviceId, this.desiredState.getActiveDesiredState, configArg.resolveRuntimeSecret);
+        this.gateway = new CoreMailGateway(configArg, this.models, this.transfers, this.inbound, this.desiredState.getActiveDesiredState);
+        this.maintenance = new CoreMailMaintenanceService(this.models, this.storage);
+        this.server = server = new CoreMailServer(configArg, this.database, this.storage, this.transfers, this.desiredState, this.auth, this.submissions, this.inbound, this.gateway);
+        this.outboundWorker = new CoreMailOutboundWorker(this.models, this.transfers, this.gateway, configArg.replica.taskId, configArg.replica.serviceId);
+    }
+    async start() {
+        if (this.lifecycleState === 'running')
+            return;
+        if (this.lifecycleState === 'starting') {
+            await this.startPromise;
+            return;
+        }
+        if (this.lifecycleState !== 'new') {
+            throw new Error(`CoreMail cannot start from lifecycle state "${this.lifecycleState}".`);
+        }
+        this.lifecycleState = 'starting';
+        const startPromise = this.startInternal();
+        this.startPromise = startPromise;
+        try {
+            await startPromise;
+            this.lifecycleState = 'running';
+        }
+        catch (error) {
+            try {
+                await this.stopStartedResources();
+                this.lifecycleState = 'stopped';
+            }
+            catch (cleanupError) {
+                this.lifecycleState = 'failed';
+                throw new AggregateError([error, cleanupError], 'CoreMail startup and cleanup both failed.');
+            }
+            throw error;
+        }
+        finally {
+            if (this.startPromise === startPromise) {
+                this.startPromise = null;
+            }
+        }
+    }
+    async startInternal() {
+        await this.database.init();
+        this.databaseStarted = true;
+        await Promise.all(Object.values(this.models).map((modelArg) => modelArg.init()));
+        await prepareCoreMailModelsForTransactions(this.models);
+        await this.storage.start();
+        this.storageStarted = true;
+        await this.desiredState.start();
+        this.gateway.start();
+        this.gatewayStarted = true;
+        await this.server.start();
+        this.serverStarted = true;
+        this.maintenance.start();
+        this.maintenanceStarted = true;
+        this.outboundWorker.start();
+        this.workerStarted = true;
+    }
+    async stop() {
+        if (this.lifecycleState === 'stopped')
+            return;
+        if (this.lifecycleState === 'stopping') {
+            await this.stopPromise;
+            return;
+        }
+        if (this.lifecycleState === 'starting') {
+            await this.startPromise?.catch(() => undefined);
+        }
+        this.lifecycleState = 'stopping';
+        const stopPromise = this.stopStartedResources();
+        this.stopPromise = stopPromise;
+        try {
+            await stopPromise;
+            this.lifecycleState = 'stopped';
+        }
+        catch (error) {
+            this.lifecycleState = 'failed';
+            throw error;
+        }
+        finally {
+            if (this.stopPromise === stopPromise) {
+                this.stopPromise = null;
+            }
+        }
+    }
+    async stopStartedResources() {
+        const errors = [];
+        const stopOne = async (startedArg, stopArg, markStoppedArg) => {
+            if (!startedArg)
+                return;
+            try {
+                await stopArg();
+                markStoppedArg();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        };
+        await stopOne(this.workerStarted, () => this.outboundWorker.stop(), () => { this.workerStarted = false; });
+        await stopOne(this.serverStarted, () => this.server.stop(), () => { this.serverStarted = false; });
+        await stopOne(this.maintenanceStarted, () => this.maintenance.stop(), () => { this.maintenanceStarted = false; });
+        await stopOne(this.gatewayStarted, () => this.gateway.stop(), () => { this.gatewayStarted = false; });
+        await this.transfers.stop().catch((error) => errors.push(error));
+        await stopOne(this.storageStarted, () => this.storage.stop(), () => { this.storageStarted = false; });
+        await stopOne(this.databaseStarted, () => this.database.close(), () => { this.databaseStarted = false; });
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'CoreMail lifecycle shutdown failed.');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.coremail.js","sourceRoot":"","sources":["../ts/classes.coremail.ts"],"names":[],"mappings":"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"}