@zintrust/core 0.1.28 → 0.1.30

package/src/config/logging/HttpLogger.d.ts

@@ -0,0 +1,23 @@
+/**
+ * HTTP Endpoint Logger
+ * Sends logs to an external HTTP logging service.
+ *
+ * Enabled via env:
+ *  - HTTP_LOG_ENABLED (default: false)
+ *  - HTTP_LOG_ENDPOINT_URL
+ *  - HTTP_LOG_BATCH_SIZE (default: 50)
+ *  - HTTP_LOG_AUTH_TOKEN (optional)
+ */
+export type HttpLogEvent = {
+    timestamp: string;
+    level: 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+    message: string;
+    category?: string;
+    data?: unknown;
+    error?: string;
+};
+export declare const HttpLogger: Readonly<{
+    enqueue(event: HttpLogEvent): Promise<void>;
+}>;
+export default HttpLogger;
+//# sourceMappingURL=HttpLogger.d.ts.map

package/src/config/logging/HttpLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpLogger.d.ts","sourceRoot":"","sources":["../../../../src/config/logging/HttpLogger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,MAAM,MAAM,YAAY,GAAG;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAkFF,eAAO,MAAM,UAAU;mBACA,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;EAYjD,CAAC;AAEH,eAAe,UAAU,CAAC"}

package/src/config/logging/HttpLogger.js

@@ -0,0 +1,93 @@
+/**
+ * HTTP Endpoint Logger
+ * Sends logs to an external HTTP logging service.
+ *
+ * Enabled via env:
+ *  - HTTP_LOG_ENABLED (default: false)
+ *  - HTTP_LOG_ENDPOINT_URL
+ *  - HTTP_LOG_BATCH_SIZE (default: 50)
+ *  - HTTP_LOG_AUTH_TOKEN (optional)
+ */
+import { delay } from '../../common/index.js';
+import { Env } from '../env.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { HttpClient } from '../../tools/http/Http.js';
+const isEnabled = () => Env.getBool('HTTP_LOG_ENABLED', false);
+let buffer = [];
+let flushPromise;
+const postBatch = async (events) => {
+    const endpoint = Env.get('HTTP_LOG_ENDPOINT_URL').trim();
+    if (endpoint.length === 0) {
+        throw ErrorFactory.createConfigError('HTTP_LOG_ENDPOINT_URL is required when HTTP logging is enabled');
+    }
+    const token = Env.get('HTTP_LOG_AUTH_TOKEN').trim();
+    const builder = HttpClient.post(endpoint, {
+        sentAt: new Date().toISOString(),
+        count: events.length,
+        events,
+    });
+    if (token.length > 0) {
+        builder.withAuth(token, 'Bearer');
+    }
+    await builder.send();
+};
+const flushNow = async () => {
+    const toSend = buffer;
+    buffer = [];
+    if (!isEnabled())
+        return;
+    if (toSend.length === 0)
+        return;
+    const maxRetries = 3;
+    const attemptPost = async (attempt) => {
+        try {
+            await postBatch(toSend);
+        }
+        catch {
+            if (attempt >= maxRetries)
+                return;
+            const backoffMs = 100 * 2 ** attempt;
+            await delay(backoffMs);
+            await attemptPost(attempt + 1);
+        }
+    };
+    await attemptPost(0);
+};
+const scheduleFlush = async () => {
+    if (flushPromise !== undefined)
+        return flushPromise;
+    const promise = new Promise((resolve) => {
+        const run = async () => {
+            try {
+                await flushNow();
+            }
+            finally {
+                resolve(undefined);
+            }
+        };
+        if (typeof globalThis.setTimeout !== 'function') {
+            void run();
+            return;
+        }
+        globalThis.setTimeout(() => {
+            void run();
+        }, 0);
+    });
+    flushPromise = promise.finally(() => {
+        flushPromise = undefined;
+    });
+    return flushPromise;
+};
+export const HttpLogger = Object.freeze({
+    async enqueue(event) {
+        if (!isEnabled())
+            return Promise.resolve(); // NOSONAR
+        buffer.push(event);
+        const batchSize = Math.max(1, Env.getInt('HTTP_LOG_BATCH_SIZE', 50));
+        if (buffer.length >= batchSize) {
+            return scheduleFlush();
+        }
+        return scheduleFlush();
+    },
+});
+export default HttpLogger;

package/src/config/logging/KvLogger.d.ts

@@ -0,0 +1,22 @@
+/**
+ * KV Logger
+ * Writes batches of log events to a KV namespace (Cloudflare Workers compatible)
+ *
+ * Enabled via env:
+ *  - KV_LOG_ENABLED (default: false)
+ *  - KV_NAMESPACE (binding name; default: 'CACHE')
+ *  - KV_LOG_RETENTION_DAYS (default: 30)
+ */
+export type KvLogEvent = {
+    timestamp: string;
+    level: 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+    message: string;
+    category?: string;
+    data?: unknown;
+    error?: string;
+};
+export declare const KvLogger: Readonly<{
+    enqueue(event: KvLogEvent): Promise<void>;
+}>;
+export default KvLogger;
+//# sourceMappingURL=KvLogger.d.ts.map

package/src/config/logging/KvLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KvLogger.d.ts","sourceRoot":"","sources":["../../../../src/config/logging/KvLogger.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,MAAM,MAAM,UAAU,GAAG;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AA2IF,eAAO,MAAM,QAAQ;mBACE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;EAkB/C,CAAC;AAEH,eAAe,QAAQ,CAAC"}

package/src/config/logging/KvLogger.js

@@ -0,0 +1,143 @@
+/**
+ * KV Logger
+ * Writes batches of log events to a KV namespace (Cloudflare Workers compatible)
+ *
+ * Enabled via env:
+ *  - KV_LOG_ENABLED (default: false)
+ *  - KV_NAMESPACE (binding name; default: 'CACHE')
+ *  - KV_LOG_RETENTION_DAYS (default: 30)
+ */
+import { Cloudflare } from '../cloudflare.js';
+import { Env } from '../env.js';
+const getRetentionTtlSeconds = () => {
+    const days = Env.getInt('KV_LOG_RETENTION_DAYS', 30);
+    const safeDays = Number.isFinite(days) && days > 0 ? days : 30;
+    return safeDays * 24 * 60 * 60;
+};
+const getKvBindingName = () => {
+    const name = Env.get('KV_NAMESPACE', 'CACHE').trim();
+    return name.length > 0 ? name : 'CACHE';
+};
+const isEnabled = () => Env.getBool('KV_LOG_ENABLED', false);
+const safeRandom = () => {
+    try {
+        // Prefer crypto if available
+        const cryptoObj = globalThis.crypto;
+        if (cryptoObj?.getRandomValues) {
+            const bytes = new Uint8Array(8);
+            cryptoObj.getRandomValues(bytes);
+            return Array.from(bytes)
+                .map((b) => b.toString(16).padStart(2, '0'))
+                .join('');
+        }
+    }
+    catch {
+        // fall through
+    }
+    const generate = Math.random().toString(16).slice(2); // NOSONAR
+    const fallback = generate + Math.random().toString(16).slice(2); // NOSONAR this is not used for security
+    return fallback;
+};
+const buildKey = (timestampIso) => {
+    const date = timestampIso.slice(0, 10);
+    const hour = timestampIso.slice(11, 13);
+    return `logs:${date}:${hour}:${safeRandom()}`;
+};
+let buffer = [];
+let flushTimer;
+let flushPromise;
+const scheduleFlush = async () => {
+    if (flushPromise !== undefined)
+        return flushPromise;
+    // Fixed small batching window to reduce KV write volume.
+    const windowMs = 1000;
+    const promise = new Promise((resolve) => {
+        const run = async () => {
+            try {
+                await flushNow();
+            }
+            finally {
+                resolve(undefined);
+            }
+        };
+        if (typeof globalThis.setTimeout !== 'function') {
+            // microtask-ish
+            void run();
+            return;
+        }
+        flushTimer = globalThis.setTimeout(() => {
+            flushTimer = undefined;
+            void run();
+        }, windowMs);
+    });
+    flushPromise = promise.finally(() => {
+        flushPromise = undefined;
+    });
+    return flushPromise;
+};
+const getKv = () => {
+    const bindingName = getKvBindingName();
+    return Cloudflare.getKVBinding(bindingName);
+};
+const putBatch = async (kv, events) => {
+    if (events.length === 0)
+        return;
+    const timestamp = events.at(-1)?.timestamp ?? new Date().toISOString();
+    const key = buildKey(timestamp);
+    const payload = JSON.stringify({
+        version: 1,
+        createdAt: new Date().toISOString(),
+        count: events.length,
+        events,
+    });
+    const opts = { expirationTtl: getRetentionTtlSeconds() };
+    await kv.put(key, payload, opts);
+};
+const flushNow = async () => {
+    if (!isEnabled()) {
+        buffer = [];
+        return;
+    }
+    const kv = getKv();
+    if (kv === null) {
+        buffer = [];
+        return;
+    }
+    const toSend = buffer;
+    buffer = [];
+    try {
+        await putBatch(kv, toSend);
+    }
+    catch {
+        // Best-effort: never throw from logging.
+    }
+};
+const flushSoon = async () => {
+    if (flushPromise !== undefined)
+        return flushPromise;
+    flushPromise = Promise.resolve()
+        .then(async () => flushNow())
+        .finally(() => {
+        flushPromise = undefined;
+    });
+    return flushPromise;
+};
+export const KvLogger = Object.freeze({
+    async enqueue(event) {
+        if (!isEnabled())
+            return;
+        buffer.push(event);
+        // Basic size guard: flush if it gets too large
+        const maxBatch = 100;
+        if (buffer.length >= maxBatch) {
+            // Cancel scheduled flush and flush immediately
+            if (flushTimer !== undefined) {
+                globalThis.clearTimeout(flushTimer);
+                flushTimer = undefined;
+            }
+            return flushSoon();
+        }
+        return scheduleFlush();
+    },
+});
+export default KvLogger;

package/src/config/logging/SlackLogger.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Slack Notification Logger
+ * Sends warn/error/fatal log events to a Slack incoming webhook.
+ *
+ * Enabled via env:
+ *  - SLACK_LOG_ENABLED (default: false)
+ *  - SLACK_LOG_WEBHOOK_URL
+ *  - SLACK_LOG_LEVELS (comma-separated; default: "warn,error,fatal")
+ *  - SLACK_LOG_BATCH_WINDOW_MS (default: 5000)
+ */
+export type SlackLogEvent = {
+    timestamp: string;
+    level: 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+    message: string;
+    category?: string;
+    data?: unknown;
+    error?: string;
+};
+export declare const SlackLogger: Readonly<{
+    enqueue(event: SlackLogEvent): Promise<void>;
+}>;
+export default SlackLogger;
+//# sourceMappingURL=SlackLogger.d.ts.map

package/src/config/logging/SlackLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SlackLogger.d.ts","sourceRoot":"","sources":["../../../../src/config/logging/SlackLogger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAoHF,eAAO,MAAM,WAAW;mBACD,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;EAclD,CAAC;AAEH,eAAe,WAAW,CAAC"}

package/src/config/logging/SlackLogger.js

@@ -0,0 +1,119 @@
+/**
+ * Slack Notification Logger
+ * Sends warn/error/fatal log events to a Slack incoming webhook.
+ *
+ * Enabled via env:
+ *  - SLACK_LOG_ENABLED (default: false)
+ *  - SLACK_LOG_WEBHOOK_URL
+ *  - SLACK_LOG_LEVELS (comma-separated; default: "warn,error,fatal")
+ *  - SLACK_LOG_BATCH_WINDOW_MS (default: 5000)
+ */
+import { Env } from '../env.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { HttpClient } from '../../tools/http/Http.js';
+const isEnabled = () => Env.getBool('SLACK_LOG_ENABLED', false);
+const getLevels = () => {
+    const raw = Env.get('SLACK_LOG_LEVELS', 'warn,error,fatal');
+    return new Set(raw
+        .split(',')
+        .map((s) => s.trim().toLowerCase())
+        .filter((s) => s.length > 0));
+};
+const levelToColor = (level) => {
+    if (level === 'fatal' || level === 'error')
+        return '#D50200';
+    if (level === 'warn')
+        return '#D39E00';
+    return '#439FE0';
+};
+const formatEventText = (ev) => {
+    const header = `*${ev.level.toUpperCase()}* ${ev.message}`;
+    const metaParts = [];
+    if (ev.category !== undefined)
+        metaParts.push(`category=${ev.category}`);
+    metaParts.push(`ts=${ev.timestamp}`);
+    const meta = metaParts.length > 0 ? `\n_${metaParts.join(' ')}_` : '';
+    const err = ev.error === undefined ? '' : `\n*error:* ${String(ev.error)}`;
+    const data = ev.data === undefined ? '' : `\n*data:* \`${JSON.stringify(ev.data)}\``;
+    return `${header}${meta}${err}${data}`;
+};
+let buffer = [];
+let flushPromise;
+let dedupeKeys = new Set();
+const dedupeKeyFor = (ev) => {
+    const base = `${ev.level}:${ev.message}:${ev.error ?? ''}`;
+    return base.length > 500 ? base.slice(0, 500) : base;
+};
+const sendBatch = async (events) => {
+    const webhookUrl = Env.get('SLACK_LOG_WEBHOOK_URL').trim();
+    if (webhookUrl.length === 0) {
+        throw ErrorFactory.createConfigError('SLACK_LOG_WEBHOOK_URL is required when Slack logging is enabled');
+    }
+    const lines = events.map((e) => formatEventText(e)).join('\n\n');
+    const payload = {
+        attachments: [
+            {
+                color: levelToColor(events[0]?.level ?? 'warn'),
+                text: lines,
+            },
+        ],
+    };
+    await HttpClient.post(webhookUrl, payload).send();
+};
+const flushNow = async () => {
+    const toSend = buffer;
+    buffer = [];
+    dedupeKeys = new Set();
+    if (!isEnabled())
+        return;
+    if (toSend.length === 0)
+        return;
+    try {
+        await sendBatch(toSend);
+    }
+    catch {
+        // Best-effort: never throw from logging.
+    }
+};
+const scheduleFlush = async () => {
+    if (flushPromise !== undefined)
+        return flushPromise;
+    const windowMs = Math.max(0, Env.getInt('SLACK_LOG_BATCH_WINDOW_MS', 5000));
+    const promise = new Promise((resolve) => {
+        const run = async () => {
+            try {
+                await flushNow();
+            }
+            finally {
+                resolve(undefined);
+            }
+        };
+        if (windowMs === 0 || typeof globalThis.setTimeout !== 'function') {
+            void run();
+            return;
+        }
+        globalThis.setTimeout(() => {
+            void run();
+        }, windowMs);
+    });
+    flushPromise = promise.finally(() => {
+        flushPromise = undefined;
+    });
+    return flushPromise;
+};
+export const SlackLogger = Object.freeze({
+    async enqueue(event) {
+        if (!isEnabled())
+            return;
+        const levels = getLevels();
+        if (!levels.has(event.level))
+            return;
+        const key = dedupeKeyFor(event);
+        if (dedupeKeys.has(key))
+            return scheduleFlush();
+        dedupeKeys.add(key);
+        buffer.push(event);
+        return scheduleFlush();
+    },
+});
+export default SlackLogger;

package/src/config/mail.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Mail Configuration
+ * Runtime mail drivers and settings
+ * Sealed namespace for immutability
+ */
+import type { MailConfigInput, MailDriverConfig } from './type';
+export type MailConfigOverrides = Partial<{
+    default: string;
+    from: {
+        address: string;
+        name: string;
+    };
+    drivers: Record<string, MailDriverConfig>;
+}>;
+declare const createMailConfig: () => {
+    default: string;
+    from: {
+        address: string;
+        name: string;
+    };
+    drivers: Record<string, MailDriverConfig>;
+    getDriver: (this: MailConfigInput, name?: string) => MailDriverConfig;
+};
+export type MailConfig = ReturnType<typeof createMailConfig>;
+export declare const mailConfig: MailConfig;
+export {};
+//# sourceMappingURL=mail.d.ts.map

package/src/config/mail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mail.d.ts","sourceRoot":"","sources":["../../../src/config/mail.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAItE,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CAC3C,CAAC,CAAC;AAmCH,QAAA,MAAM,gBAAgB,QAAO;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC1C,SAAS,EAAE,CAAC,IAAI,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,gBAAgB,CAAC;CAgGvE,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAqB7D,eAAO,MAAM,UAAU,EAAE,UAYvB,CAAC"}

package/src/config/mail.js

@@ -0,0 +1,154 @@
+/**
+ * Mail Configuration
+ * Runtime mail drivers and settings
+ * Sealed namespace for immutability
+ */
+import { Env } from './env.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { StartupConfigFile, StartupConfigFileRegistry } from '../runtime/StartupConfigFileRegistry.js';
+const isMailDriverConfig = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    if (!('driver' in value))
+        return false;
+    const driver = value.driver;
+    return typeof driver === 'string' && driver.trim().length > 0;
+};
+const getMailDriver = (config, name) => {
+    const drivers = config.drivers;
+    const envSelectedRaw = Env.get('MAIL_CONNECTION', Env.get('MAIL_DRIVER', '')).trim();
+    const selected = (name ??
+        (envSelectedRaw.length > 0 ? envSelectedRaw : undefined) ??
+        config.default)
+        .toString()
+        .trim();
+    if (selected.length === 0) {
+        const disabled = drivers['disabled'];
+        if (isMailDriverConfig(disabled))
+            return disabled;
+        throw ErrorFactory.createConfigError('Mail driver not configured: disabled');
+    }
+    if (Object.hasOwn(drivers, selected)) {
+        const resolved = drivers[selected];
+        if (isMailDriverConfig(resolved))
+            return resolved;
+    }
+    throw ErrorFactory.createConfigError(`Mail driver not configured: ${selected}`);
+};
+const createMailConfig = () => {
+    const overrides = StartupConfigFileRegistry.get(StartupConfigFile.Mail) ?? {};
+    const baseDefault = Env.get('MAIL_CONNECTION', Env.get('MAIL_DRIVER', 'disabled'))
+        .trim()
+        .toLowerCase();
+    const baseFrom = {
+        address: Env.get('MAIL_FROM_ADDRESS', ''),
+        name: Env.get('MAIL_FROM_NAME', ''),
+    };
+    const baseDrivers = {
+        disabled: {
+            driver: 'disabled',
+        },
+        sendgrid: {
+            driver: 'sendgrid',
+            apiKey: Env.get('SENDGRID_API_KEY', ''),
+        },
+        mailgun: {
+            driver: 'mailgun',
+            apiKey: Env.get('MAILGUN_API_KEY', ''),
+            domain: Env.get('MAILGUN_DOMAIN', ''),
+            baseUrl: Env.get('MAILGUN_BASE_URL', 'https://api.mailgun.net').trim(),
+        },
+        smtp: {
+            driver: 'smtp',
+            host: Env.get('MAIL_HOST', ''),
+            port: Env.getInt('MAIL_PORT', 587),
+            username: Env.get('MAIL_USERNAME', ''),
+            password: Env.get('MAIL_PASSWORD', ''),
+            secure: (() => {
+                const raw = Env.get('MAIL_SECURE', '').trim().toLowerCase();
+                if (raw === 'starttls')
+                    return 'starttls';
+                if (raw === 'tls' || raw === 'ssl' || raw === 'smtps' || raw === 'implicit')
+                    return true;
+                if (raw === 'none' || raw === 'off' || raw === 'false' || raw === '0')
+                    return false;
+                return Env.getBool('MAIL_SECURE', false);
+            })(),
+        },
+        nodemailer: {
+            driver: 'nodemailer',
+            host: Env.get('MAIL_HOST', ''),
+            port: Env.getInt('MAIL_PORT', 587),
+            username: Env.get('MAIL_USERNAME', ''),
+            password: Env.get('MAIL_PASSWORD', ''),
+            secure: (() => {
+                const raw = Env.get('MAIL_SECURE', '').trim().toLowerCase();
+                if (raw === 'starttls')
+                    return 'starttls';
+                if (raw === 'tls' || raw === 'ssl' || raw === 'smtps' || raw === 'implicit')
+                    return true;
+                if (raw === 'none' || raw === 'off' || raw === 'false' || raw === '0')
+                    return false;
+                return Env.getBool('MAIL_SECURE', false);
+            })(),
+        },
+        ses: {
+            driver: 'ses',
+            region: Env.get('AWS_REGION', 'us-east-1'),
+        },
+    };
+    const mailConfigObj = {
+        /**
+         * Default mail driver
+         */
+        default: (overrides.default ?? baseDefault).trim().toLowerCase(),
+        /**
+         * Default "From" identity
+         */
+        from: {
+            ...baseFrom,
+            ...overrides.from,
+        },
+        /**
+         * Driver configs
+         */
+        drivers: {
+            ...baseDrivers,
+            ...overrides.drivers,
+        },
+        /**
+         * Get selected driver config
+         */
+        getDriver(name) {
+            return getMailDriver(this, name);
+        },
+    };
+    return Object.freeze(mailConfigObj);
+};
+let cached = null;
+const proxyTarget = {};
+const ensureMailConfig = () => {
+    if (cached)
+        return cached;
+    cached = createMailConfig();
+    try {
+        Object.defineProperties(proxyTarget, Object.getOwnPropertyDescriptors(cached));
+    }
+    catch {
+        // best-effort
+    }
+    return cached;
+};
+export const mailConfig = new Proxy(proxyTarget, {
+    get(_target, prop) {
+        return ensureMailConfig()[prop];
+    },
+    ownKeys() {
+        ensureMailConfig();
+        return Reflect.ownKeys(proxyTarget);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        ensureMailConfig();
+        return Object.getOwnPropertyDescriptor(proxyTarget, prop);
+    },
+});