@serve.zone/dcrouter 16.4.1 → 17.0.0

package/dist_ts/email/classes.mail-edge-eligibility.d.ts

@@ -0,0 +1,55 @@
+import type { IRemoteIngress } from '../../dist_ts_interfaces/data/remoteingress.js';
+import type { EmailDomainDoc } from '../db/documents/classes.email-domain.doc.js';
+import type { DcRouter } from '../classes.dcrouter.js';
+export declare const MAIL_EGRESS_IDENTITY_MAX_AGE_MS = 45000;
+export interface IMailEgressIdentity {
+    edgeId: string;
+    family: 4 | 6;
+    address: string;
+    heloHostname: string;
+    proof: 'sourceBound';
+    /** Edge-side time at which the configured source address was successfully bound. */
+    observedAt: number;
+    /** Hub-side heartbeat receipt time. */
+    hubReceivedAt: number;
+}
+export interface IMailEgressIdentitySnapshot {
+    supported: boolean;
+    reason?: string;
+    identities: IMailEgressIdentity[];
+}
+/** Boundary implemented against a released RemoteIngress identity-proof API. */
+export interface IEgressIdentitySource {
+    getSnapshot(): Promise<IMailEgressIdentitySnapshot>;
+}
+/**
+ * Reads the versioned RemoteIngress identity capability through TunnelManager.
+ * Older hubs do not expose `egressIdentityV1`; they remain explicitly
+ * unsupported instead of falling back to configured or peer addresses.
+ */
+export declare class ReleasedRemoteIngressEgressIdentitySource implements IEgressIdentitySource {
+    private dcRouterRef;
+    constructor(dcRouterRef: DcRouter);
+    getSnapshot(): Promise<IMailEgressIdentitySnapshot>;
+}
+export interface IEligibleMailEdge {
+    edge: IRemoteIngress;
+    hostname: string;
+    identities: IMailEgressIdentity[];
+}
+export interface IMailEdgeEligibilityResult {
+    supported: boolean;
+    reason?: string;
+    edges: IEligibleMailEdge[];
+}
+/** Shared topology predicate used by DNS publication and outbound selection. */
+export declare class MailEdgeEligibility {
+    private dcRouterRef;
+    private identitySource;
+    private lastUnscopedResult;
+    constructor(dcRouterRef: DcRouter, identitySource: IEgressIdentitySource);
+    resolveForDomain(doc?: EmailDomainDoc): Promise<IMailEdgeEligibilityResult>;
+    getLastUnscopedResult(): IMailEdgeEligibilityResult;
+    private recordUnscoped;
+    resolveActiveForDomain(doc: EmailDomainDoc): Promise<IMailEdgeEligibilityResult>;
+}

package/dist_ts/email/classes.mail-edge-eligibility.js

@@ -0,0 +1,168 @@
+import { REMOTE_INGRESS_MAIL_TAG } from '../../dist_ts_interfaces/data/remoteingress.js';
+export const MAIL_EGRESS_IDENTITY_MAX_AGE_MS = 45_000;
+/**
+ * Reads the versioned RemoteIngress identity capability through TunnelManager.
+ * Older hubs do not expose `egressIdentityV1`; they remain explicitly
+ * unsupported instead of falling back to configured or peer addresses.
+ */
+export class ReleasedRemoteIngressEgressIdentitySource {
+    dcRouterRef;
+    constructor(dcRouterRef) {
+        this.dcRouterRef = dcRouterRef;
+    }
+    async getSnapshot() {
+        const status = await this.dcRouterRef.tunnelManager?.getAuthoritativeHubStatus();
+        const connectedEdges = status?.connectedEdges ?? [];
+        const capableEdges = connectedEdges.filter((edge) => (Array.isArray(edge.capabilities) && edge.capabilities.includes('egressIdentityV1')));
+        if (capableEdges.length > 0) {
+            const identities = [];
+            for (const edge of capableEdges) {
+                const report = edge.egressIdentity;
+                if (!report || report.proofMethod !== 'localSocketBind')
+                    continue;
+                for (const [family, observation] of [[4, report.ipv4], [6, report.ipv6]]) {
+                    if (!observation || observation.stale === true)
+                        continue;
+                    if (typeof observation.address !== 'string'
+                        || !Number.isFinite(observation.edgeObservedAtUnixMs)
+                        || !Number.isFinite(observation.hubReceivedAtUnixMs))
+                        continue;
+                    const configured = this.dcRouterRef.remoteIngressManager?.getEdge(String(edge.edgeId));
+                    const heloHostname = configured?.mailHostname?.trim();
+                    if (!heloHostname)
+                        continue;
+                    identities.push({
+                        edgeId: String(edge.edgeId),
+                        family,
+                        address: observation.address,
+                        heloHostname,
+                        proof: 'sourceBound',
+                        observedAt: observation.edgeObservedAtUnixMs,
+                        hubReceivedAt: observation.hubReceivedAtUnixMs,
+                    });
+                }
+            }
+            return { supported: true, identities };
+        }
+        return {
+            supported: false,
+            reason: 'RemoteIngress egress identity proof is unavailable until the capability release is consumed',
+            identities: [],
+        };
+    }
+}
+/** Shared topology predicate used by DNS publication and outbound selection. */
+export class MailEdgeEligibility {
+    dcRouterRef;
+    identitySource;
+    lastUnscopedResult = {
+        supported: false,
+        reason: 'mail edge eligibility has not been evaluated yet',
+        edges: [],
+    };
+    constructor(dcRouterRef, identitySource) {
+        this.dcRouterRef = dcRouterRef;
+        this.identitySource = identitySource;
+    }
+    async resolveForDomain(doc) {
+        const snapshot = await this.identitySource.getSnapshot();
+        if (!snapshot.supported) {
+            return this.recordUnscoped(doc, { supported: false, reason: snapshot.reason, edges: [] });
+        }
+        const manager = this.dcRouterRef.remoteIngressManager;
+        const tunnelManager = this.dcRouterRef.tunnelManager;
+        if (!manager || !tunnelManager) {
+            return this.recordUnscoped(doc, { supported: true, reason: 'RemoteIngress hub is not running', edges: [] });
+        }
+        const pin = doc?.remoteIngress?.edgeFilter || [];
+        const pinIds = pin.length > 0
+            ? new Set(manager.resolveEdgesByFilter(pin).map((edge) => edge.id))
+            : undefined;
+        const identitiesByEdge = new Map();
+        const now = Date.now();
+        for (const identity of snapshot.identities) {
+            if (identity.proof !== 'sourceBound')
+                continue;
+            if (now - identity.observedAt > MAIL_EGRESS_IDENTITY_MAX_AGE_MS)
+                continue;
+            if (now - identity.hubReceivedAt > MAIL_EGRESS_IDENTITY_MAX_AGE_MS)
+                continue;
+            const entries = identitiesByEdge.get(identity.edgeId) || [];
+            entries.push(identity);
+            identitiesByEdge.set(identity.edgeId, entries);
+        }
+        const edges = [];
+        for (const edge of manager.getAllEdges()) {
+            if (!edge.enabled || !edge.tags?.includes(REMOTE_INGRESS_MAIL_TAG))
+                continue;
+            // A domain pin narrows the mail-tagged pool; it never replaces the mail tag.
+            if (pinIds && !pinIds.has(edge.id))
+                continue;
+            if (!edge.egress?.enabled || !edge.egress.allowedPorts?.includes(25))
+                continue;
+            const status = tunnelManager.getEdgeStatus(edge.id);
+            if (!status?.connected || !status.lastHeartbeat)
+                continue;
+            if (now - status.lastHeartbeat > MAIL_EGRESS_IDENTITY_MAX_AGE_MS)
+                continue;
+            if (status.egressEnabled !== true || !status.capabilities?.includes('egressTcpV1'))
+                continue;
+            const nativeQuic = status.transportMode === 'quic'
+                || (status.transportMode === 'quicWithFallback' && status.fallbackUsed === false);
+            if (!nativeQuic)
+                continue;
+            const hostname = edge.mailHostname?.toLowerCase().replace(/\.$/, '');
+            if (!hostname)
+                continue;
+            const identities = (identitiesByEdge.get(edge.id) || []).filter((identity) => {
+                if (identity.heloHostname.toLowerCase().replace(/\.$/, '') !== hostname)
+                    return false;
+                return identity.family === 4
+                    ? Boolean(edge.publicIp && edge.publicIp === identity.address)
+                    : Boolean(edge.publicIpV6 && edge.publicIpV6 === identity.address);
+            });
+            if (identities.length > 0) {
+                edges.push({ edge, hostname, identities });
+            }
+        }
+        edges.sort((left, right) => left.edge.id.localeCompare(right.edge.id));
+        return this.recordUnscoped(doc, {
+            supported: true,
+            ...(edges.length === 0 ? { reason: 'no live mail-tagged edge has a fresh source-bound identity' } : {}),
+            edges,
+        });
+    }
+    getLastUnscopedResult() {
+        return this.lastUnscopedResult;
+    }
+    recordUnscoped(doc, result) {
+        if (!doc)
+            this.lastUnscopedResult = result;
+        return result;
+    }
+    async resolveActiveForDomain(doc) {
+        const live = await this.resolveForDomain(doc);
+        const active = doc.reconciliation?.activeRevision;
+        if (!live.supported || !active) {
+            return {
+                supported: live.supported,
+                reason: live.reason || 'email domain has no validated active DNS revision',
+                edges: [],
+            };
+        }
+        const activeByEdge = new Map(active.edgeIdentities.map((identity) => [identity.edgeId, identity]));
+        const edges = live.edges.filter((candidate) => {
+            const activeIdentity = activeByEdge.get(candidate.edge.id);
+            if (!activeIdentity || activeIdentity.hostname !== candidate.hostname)
+                return false;
+            return candidate.identities.length > 0 && candidate.identities.every((identity) => ((identity.family === 4 && identity.address === activeIdentity.ipv4)
+                || (identity.family === 6 && identity.address === activeIdentity.ipv6)));
+        });
+        return {
+            supported: live.supported,
+            ...(edges.length === 0 ? { reason: 'no live edge is present in the validated active DNS revision' } : {}),
+            edges,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.mail-edge-eligibility.js","sourceRoot":"","sources":["../../../ts/email/classes.mail-edge-eligibility.ts"],"names":[],"mappings":"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"}

package/dist_ts/email/classes.mail-egress-coordinator.d.ts

@@ -1,6 +1,7 @@
 import type { IOutboundConnectionProxy, IOutboundConnectionProxyContext } from '@push.rocks/smartmta';
 import type { IEmailOutboundEgressStatus, TEmailOutboundMode } from '../../dist_ts_interfaces/data/email-settings.js';
 import type { DcRouter } from '../classes.dcrouter.js';
+import type { MailEdgeEligibility } from './classes.mail-edge-eligibility.js';
 /**
  * Routes outbound SMTP deliveries over RemoteIngress edges: resolves the
  * outbound mode per attempt (no silent direct fallback), maps sender-domain
@@ -9,8 +10,9 @@ import type { DcRouter } from '../classes.dcrouter.js';
  */
 export declare class MailEgressCoordinator {
     private dcRouterRef;
+    private edgeEligibility;
     private dnsClient?;
-    constructor(dcRouterRef: DcRouter);
+    constructor(dcRouterRef: DcRouter, edgeEligibility: MailEdgeEligibility);
     /**
      * smartmta connectionProxyProvider. Wired unconditionally so the outbound
      * mode is resolved per delivery attempt: a failed/late settings manager

package/dist_ts/email/classes.mail-egress-coordinator.js

@@ -1,6 +1,5 @@
 import * as plugins from '../plugins.js';
 import { logger } from '../logger.js';
-import { REMOTE_INGRESS_MAIL_TAG } from '../../dist_ts_interfaces/data/remoteingress.js';
 /**
  * Routes outbound SMTP deliveries over RemoteIngress edges: resolves the
  * outbound mode per attempt (no silent direct fallback), maps sender-domain
@@ -9,9 +8,11 @@ import { REMOTE_INGRESS_MAIL_TAG } from '../../dist_ts_interfaces/data/remoteing
  */
 export class MailEgressCoordinator {
     dcRouterRef;
+    edgeEligibility;
     dnsClient;
-    constructor(dcRouterRef) {
+    constructor(dcRouterRef, edgeEligibility) {
         this.dcRouterRef = dcRouterRef;
+        this.edgeEligibility = edgeEligibility;
     }
     /**
      * smartmta connectionProxyProvider. Wired unconditionally so the outbound
@@ -22,6 +23,9 @@ export class MailEgressCoordinator {
     async provideConnectionProxy(context) {
         const mode = this.resolveOutboundModeStrict();
         if (mode === 'direct') {
+            if (context.senderDomain && await this.dcRouterRef.emailDomainManager?.getByDomain(context.senderDomain)) {
+                throw new Error(`Managed sender domain ${context.senderDomain} has no validated direct-egress identity policy; refusing direct hub delivery`);
+            }
             return null;
         }
         return await this.createRemoteIngressConnectionProxy(context);
@@ -44,11 +48,14 @@ export class MailEgressCoordinator {
      * Readiness of the RemoteIngress outbound mail egress path (mail-tagged edges).
      */
     getOutboundEgressStatus() {
-        const tunnelManager = this.dcRouterRef.tunnelManager;
-        if (!tunnelManager) {
-            return { ready: false, eligibleEdgeCount: 0, reason: 'RemoteIngress hub is not running' };
-        }
-        return tunnelManager.getEgressReadiness([REMOTE_INGRESS_MAIL_TAG]);
+        const eligibility = this.edgeEligibility.getLastUnscopedResult();
+        return {
+            ready: eligibility.supported && eligibility.edges.length > 0,
+            eligibleEdgeCount: eligibility.edges.length,
+            ...(eligibility.edges.length === 0
+                ? { reason: eligibility.reason || 'no validated RemoteIngress mail edge is available' }
+                : {}),
+        };
     }
     /**
      * Post-start preflight: with remoteIngress outbound (the default), mail
@@ -74,15 +81,17 @@ export class MailEgressCoordinator {
             throw new Error('RemoteIngress outbound SMTP egress is enabled, but the hub is not running');
         }
         await this.assertTargetIsNotOwnMailEdge(context);
-        // Per-domain pinning: a sender domain with a configured edgeFilter uses only
-        // matching edges; everything else uses the mail-tagged edge pool.
-        let edgeFilter = [REMOTE_INGRESS_MAIL_TAG];
-        if (context.senderDomain && this.dcRouterRef.emailDomainManager) {
-            const domain = await this.dcRouterRef.emailDomainManager.getByDomain(context.senderDomain);
-            if (domain?.remoteIngress?.edgeFilter?.length) {
-                edgeFilter = domain.remoteIngress.edgeFilter;
-            }
+        const managedDoc = context.senderDomain
+            ? await (await import('../db/documents/classes.email-domain.doc.js')).EmailDomainDoc.findByDomain(context.senderDomain)
+            : null;
+        const eligible = managedDoc
+            ? await this.edgeEligibility.resolveActiveForDomain(managedDoc)
+            : await this.edgeEligibility.resolveForDomain();
+        if (!eligible.supported || eligible.edges.length === 0) {
+            throw new Error(`Outbound SMTP is not eligible${context.senderDomain ? ` for ${context.senderDomain}` : ''}: ${eligible.reason || 'no validated mail edge'}`);
         }
+        const eligibleById = new Map(eligible.edges.map((candidate) => [candidate.edge.id, candidate]));
+        const edgeFilter = [...eligibleById.keys()];
         const connectionTimeoutMs = this.dcRouterRef.options.emailConfig?.outbound?.connectionTimeout ?? 30_000;
         const proxy = await tunnelManager.startEgressTcpProxy({
             logicalHost: context.host,
@@ -92,12 +101,17 @@ export class MailEgressCoordinator {
             acceptTimeoutMs: connectionTimeoutMs,
             edgeFilter,
         });
+        const selected = eligibleById.get(proxy.edgeId);
+        if (!selected) {
+            await tunnelManager.stopEgressTcpProxy(proxy.proxyId).catch(() => undefined);
+            throw new Error(`RemoteIngress selected edge ${proxy.edgeId} outside the validated mail pool`);
+        }
         let closed = false;
         return {
             connectHost: proxy.listenHost,
             connectPort: proxy.listenPort,
             poolKey: `remoteIngress:${proxy.edgeId}:${context.host}:${context.port}`,
-            ehloHostname: this.dcRouterRef.remoteIngressManager?.getEdge(proxy.edgeId)?.mailHostname,
+            ehloHostname: selected.hostname,
             close: async () => {
                 if (closed) {
                     return;
@@ -122,9 +136,13 @@ export class MailEgressCoordinator {
      * allowed to become an availability hazard.
      */
     async assertTargetIsNotOwnMailEdge(context) {
-        const edgeIps = new Set((this.dcRouterRef.remoteIngressManager?.getAllEdges?.() || [])
-            .map((edge) => edge.publicIp)
-            .filter((ip) => Boolean(ip)));
+        const edgeIps = new Set();
+        for (const edge of this.dcRouterRef.remoteIngressManager?.getAllEdges?.() || []) {
+            if (edge.publicIp)
+                edgeIps.add(edge.publicIp);
+            if (edge.publicIpV6)
+                edgeIps.add(edge.publicIpV6);
+        }
         if (edgeIps.size === 0) {
             return;
         }
@@ -137,8 +155,11 @@ export class MailEgressCoordinator {
                 if (!this.dnsClient) {
                     this.dnsClient = new plugins.smartdns.dnsClientMod.Smartdns({});
                 }
-                const records = await this.dnsClient.getRecordsA(context.host);
-                targetIps = (records || []).map((record) => record.value);
+                const [aRecords, aaaaRecords] = await Promise.all([
+                    this.dnsClient.getRecordsA(context.host),
+                    this.dnsClient.getRecordsAAAA(context.host),
+                ]);
+                targetIps = [...(aRecords || []), ...(aaaaRecords || [])].map((record) => record.value);
             }
             catch {
                 return;
@@ -150,4 +171,4 @@ export class MailEgressCoordinator {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/email/classes.smartmta-blob-storage-manager.d.ts

@@ -0,0 +1,27 @@
+import * as plugins from '../plugins.js';
+import type { IBlobStorageManager } from '@push.rocks/smartmta';
+type TBlobBucket = Pick<plugins.smartbucket.Bucket, 'fastExists' | 'fastGet' | 'fastPut' | 'fastRemove' | 'listAllObjects'>;
+export interface ISmartMtaBlobStorageConfig {
+    storageDescriptor: plugins.tsclass.storage.IStorageDescriptor;
+    bucketName: string;
+    objectPrefix?: string;
+    createBucketIfMissing?: boolean;
+}
+/**
+ * SmartMTA blob persistence backed by a SmartBucket bucket.
+ *
+ * The adapter accepts only SmartMTA queue and attachment namespaces and never
+ * maps object keys to local filesystem paths.
+ */
+export declare class SmartMtaBlobStorageManager implements IBlobStorageManager {
+    private readonly bucketRef;
+    private readonly objectPrefix;
+    constructor(bucketRef: TBlobBucket, objectPrefix?: string);
+    static create(configArg: ISmartMtaBlobStorageConfig): Promise<SmartMtaBlobStorageManager>;
+    get(keyArg: string): Promise<Buffer | null>;
+    set(keyArg: string, valueArg: Buffer): Promise<void>;
+    list(prefixArg: string): Promise<string[]>;
+    delete(keyArg: string): Promise<void>;
+    private toObjectKey;
+}
+export {};

package/dist_ts/email/classes.smartmta-blob-storage-manager.js

@@ -0,0 +1,109 @@
+import * as plugins from '../plugins.js';
+const SMARTMTA_BLOB_NAMESPACES = [
+    '/email/queue/',
+    '/email/attachments/',
+];
+const DEFAULT_OBJECT_PREFIX = 'dcrouter/smartmta/';
+const MAX_STORAGE_KEY_BYTES = 1024;
+function normalizeObjectPrefix(prefixArg = DEFAULT_OBJECT_PREFIX) {
+    const prefix = prefixArg.trim().replace(/^\/+|\/+$/g, '');
+    if (!prefix || prefix.includes('\\') || prefix.includes('\0')) {
+        throw new Error('SmartMTA blob objectPrefix must be a non-empty object-key prefix');
+    }
+    const segments = prefix.split('/');
+    if (segments.some((segment) => !segment || segment === '.' || segment === '..')) {
+        throw new Error('SmartMTA blob objectPrefix contains an invalid path segment');
+    }
+    return `${prefix}/`;
+}
+function normalizeBlobKey(keyArg, allowNamespaceRoot = false) {
+    if (typeof keyArg !== 'string' ||
+        !keyArg.startsWith('/') ||
+        keyArg.includes('\\') ||
+        keyArg.includes('\0') ||
+        Buffer.byteLength(keyArg, 'utf8') > MAX_STORAGE_KEY_BYTES) {
+        throw new Error('Invalid SmartMTA blob storage key');
+    }
+    const namespace = SMARTMTA_BLOB_NAMESPACES.find((candidate) => keyArg.startsWith(candidate));
+    if (!namespace) {
+        throw new Error(`Unsupported SmartMTA blob storage namespace: ${keyArg}`);
+    }
+    const remainder = keyArg.slice(namespace.length);
+    if (!allowNamespaceRoot && !remainder) {
+        throw new Error('SmartMTA blob storage key must identify an object');
+    }
+    if (remainder && remainder.split('/').some((segment) => !segment || segment === '.' || segment === '..')) {
+        throw new Error('SmartMTA blob storage key contains an invalid path segment');
+    }
+    return keyArg;
+}
+/**
+ * SmartMTA blob persistence backed by a SmartBucket bucket.
+ *
+ * The adapter accepts only SmartMTA queue and attachment namespaces and never
+ * maps object keys to local filesystem paths.
+ */
+export class SmartMtaBlobStorageManager {
+    bucketRef;
+    objectPrefix;
+    constructor(bucketRef, objectPrefix = DEFAULT_OBJECT_PREFIX) {
+        this.bucketRef = bucketRef;
+        this.objectPrefix = normalizeObjectPrefix(objectPrefix);
+    }
+    static async create(configArg) {
+        const bucketName = configArg.bucketName?.trim();
+        if (!bucketName) {
+            throw new Error('SmartMTA blob storage requires a bucketName');
+        }
+        const smartBucket = new plugins.smartbucket.SmartBucket(configArg.storageDescriptor);
+        let bucket;
+        if (configArg.createBucketIfMissing) {
+            bucket = await smartBucket.bucketExists(bucketName)
+                ? await smartBucket.getBucketByName(bucketName)
+                : await smartBucket.createBucket(bucketName);
+        }
+        else {
+            bucket = await smartBucket.getBucketByName(bucketName);
+        }
+        return new SmartMtaBlobStorageManager(bucket, configArg.objectPrefix);
+    }
+    async get(keyArg) {
+        const objectKey = this.toObjectKey(normalizeBlobKey(keyArg));
+        if (!(await this.bucketRef.fastExists({ path: objectKey }))) {
+            return null;
+        }
+        return Buffer.from(await this.bucketRef.fastGet({ path: objectKey }));
+    }
+    async set(keyArg, valueArg) {
+        if (!Buffer.isBuffer(valueArg)) {
+            throw new TypeError('SmartMTA blob storage values must be Buffers');
+        }
+        const objectKey = this.toObjectKey(normalizeBlobKey(keyArg));
+        await this.bucketRef.fastPut({
+            path: objectKey,
+            contents: Buffer.from(valueArg),
+            overwrite: true,
+        });
+    }
+    async list(prefixArg) {
+        const prefix = normalizeBlobKey(prefixArg, true);
+        const objectPrefix = this.toObjectKey(prefix);
+        const keys = [];
+        for await (const objectKey of this.bucketRef.listAllObjects(objectPrefix)) {
+            if (!objectKey.startsWith(this.objectPrefix)) {
+                throw new Error(`SmartBucket returned an object outside the configured prefix: ${objectKey}`);
+            }
+            const key = `/${objectKey.slice(this.objectPrefix.length)}`;
+            keys.push(normalizeBlobKey(key));
+        }
+        return keys.sort();
+    }
+    async delete(keyArg) {
+        const objectKey = this.toObjectKey(normalizeBlobKey(keyArg));
+        await this.bucketRef.fastRemove({ path: objectKey });
+    }
+    toObjectKey(keyArg) {
+        return `${this.objectPrefix}${keyArg.slice(1)}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/email/classes.smartmta-storage-manager.d.ts

@@ -1,11 +1,9 @@
-import type { IStorageManagerLike } from '@push.rocks/smartmta';
-export declare class SmartMtaStorageManager implements IStorageManagerLike {
-    private rootDir;
-    private readonly resolvedRootDir;
-    constructor(rootDir: string);
-    private normalizeKey;
-    private resolvePathForKey;
-    private toStorageKey;
+import * as plugins from '../plugins.js';
+import type { IStorageManager } from '@push.rocks/smartmta';
+export declare class SmartMtaStorageManager implements IStorageManager {
+    private readonly collection;
+    constructor(smartdataDb: plugins.smartdata.SmartdataDb);
+    private validateDocument;
     get(key: string): Promise<string | null>;
     set(key: string, value: string): Promise<void>;
     list(prefix: string): Promise<string[]>;