@serve.zone/dcrouter 16.5.0 → 17.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@serve.zone/dcrouter",
   "private": false,
-  "version": "16.5.0",
+  "version": "17.0.0",
   "description": "A multifaceted routing service handling mail and SMS delivery functions.",
   "type": "module",
   "bin": {
@@ -37,6 +37,7 @@
     "@push.rocks/projectinfo": "^5.1.0",
     "@push.rocks/qenv": "^6.1.4",
     "@push.rocks/smartacme": "^9.5.0",
+    "@push.rocks/smartbucket": "^4.6.1",
     "@push.rocks/smartchallenge": "^1.1.0",
     "@push.rocks/smartdata": "^7.2.0",
     "@push.rocks/smartdb": "^2.12.3",
@@ -48,7 +49,7 @@
     "@push.rocks/smartmcp": "^0.2.0",
     "@push.rocks/smartmetrics": "^3.0.3",
     "@push.rocks/smartmigration": "1.4.1",
-    "@push.rocks/smartmta": "^6.5.2",
+    "@push.rocks/smartmta": "^7.0.0",
     "@push.rocks/smartnetwork": "^4.8.0",
     "@push.rocks/smartpath": "^6.0.0",
     "@push.rocks/smartpromise": "^4.2.4",

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '16.5.0',
+  version: '17.0.0',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }

package/ts/classes.dcrouter.ts

@@ -37,7 +37,7 @@ import { DnsManager } from './dns/manager.dns.js';
 import { DnsServerRuntime } from './dns/classes.dns-server-runtime.js';
 import { AcmeConfigManager } from './acme/manager.acme-config.js';
 import { SmartAcmeLifecycle } from './acme/classes.smartacme-lifecycle.js';
-import { AcceptedEmailSpool, EmailDomainManager, EmailRouteBuilder, EmailSettingsManager, MailDnsSync, MailEdgeEligibility, MailEgressCoordinator, ReleasedRemoteIngressEgressIdentitySource, SmartMtaStorageManager, WorkAppMailManager, type TSmartMtaQueueItemLike } from './email/index.js';
+import { AcceptedEmailSpool, EmailDomainManager, EmailRouteBuilder, EmailSettingsManager, MailDnsSync, MailEdgeEligibility, MailEgressCoordinator, ReleasedRemoteIngressEgressIdentitySource, SmartMtaBlobStorageManager, SmartMtaStorageManager, WorkAppMailManager, type ISmartMtaBlobStorageConfig, type TSmartMtaQueueItemLike } from './email/index.js';
 import type { IRoute } from '../ts_interfaces/data/route-management.js';
 import type { IEmailOutboundEgressStatus, IEmailPortConfig, IEmailServerSettings, IEmailServerSettingsSeed, TEmailOutboundMode, TEmailServerSettingsUpdate } from '../ts_interfaces/data/email-settings.js';
 import type { IDcRouterRouteConfig, IRemoteIngressHubSettings, IRemoteIngressPerformanceConfig, TRemoteIngressHubSettingsUpdate } from '../ts_interfaces/data/remoteingress.js';
@@ -62,6 +62,9 @@ export interface IDcRouterOptions {
    */
   emailConfig?: IUnifiedEmailServerOptions;
 
+  /** SmartBucket configuration for durable SmartMTA queue and attachment blobs. */
+  emailBlobStorage?: ISmartMtaBlobStorageConfig;
+
   /** Outbound SMTP connection mode. Defaults to direct unless DB settings override it. */
   emailOutboundMode?: TEmailOutboundMode;
 
@@ -278,7 +281,8 @@ export class DcRouter {
     listener: (...args: any[]) => void;
   }> = [];
 
-  public storageManager: IStorageManagerLike;
+  public storageManager!: IStorageManagerLike;
+  private smartMtaBlobStorageManager?: SmartMtaBlobStorageManager;
 
   // Unified database (smartdata + LocalSmartDb or external MongoDB)
   public dcRouterDb?: DcRouterDb;
@@ -373,9 +377,6 @@ export class DcRouter {
     // Resolve all data paths from baseDir
     this.resolvedPaths = paths.resolvePaths(this.options.baseDir);
     paths.ensureDataDirectories(this.resolvedPaths);
-    this.storageManager = new SmartMtaStorageManager(
-      plugins.path.join(this.resolvedPaths.dataDir, 'smartmta-storage')
-    );
     this.workAppMailManager = new WorkAppMailManager(this);
     this.acceptedEmailSpool = new AcceptedEmailSpool(this);
     const mailEgressIdentitySource = new ReleasedRemoteIngressEgressIdentitySource(this);
@@ -1030,6 +1031,10 @@ export class DcRouter {
     const migration = await createMigrationRunner(this.dcRouterDb.getDb(), commitinfo.version, {
       remoteIngressHubSettings: this.getRemoteIngressHubSettingsMigrationSeed(),
       emailServerSettings: this.getEmailSettingsMigrationSeed(),
+      legacySmartMtaStoragePath: plugins.path.join(
+        this.resolvedPaths.dataDir,
+        'smartmta-storage',
+      ),
     });
     const migrationResult = await migration.run();
     if (migrationResult.stepsApplied.length > 0) {
@@ -1041,6 +1046,8 @@ export class DcRouter {
       logger.log('info', `smartmigration: fresh install stamped to ${migrationResult.currentVersionAfter}`);
     }
 
+    this.storageManager = new SmartMtaStorageManager(this.dcRouterDb.getDb());
+
     // Start the cache cleaner for TTL-based document cleanup
     const cleanupIntervalMs = (dbConfig.cleanupIntervalHours || 1) * 60 * 60 * 1000;
     this.cacheCleaner = new CacheCleaner(this.dcRouterDb, {
@@ -1648,14 +1655,32 @@ export class DcRouter {
       : mappedEmailPorts.includes(configuredSecurePort) && !baseEmailConfig.ports.includes(configuredSecurePort)
         ? configuredSecurePort
         : portMapping[configuredSecurePort] || configuredSecurePort + 10000;
+    const queueBehavior = { ...baseEmailConfig.queue } as Record<string, unknown>;
+    delete queueBehavior.storageMode;
+    delete queueBehavior.storageManager;
+    delete queueBehavior.storageType;
+    delete queueBehavior.persistentPath;
+    if (this.options.emailBlobStorage && !this.smartMtaBlobStorageManager) {
+      this.smartMtaBlobStorageManager = await SmartMtaBlobStorageManager.create(
+        this.options.emailBlobStorage,
+      );
+    }
+    const queueOptions: IUnifiedEmailServerOptions['queue'] = this.smartMtaBlobStorageManager
+      ? {
+          ...queueBehavior,
+          storageMode: 'managed',
+          storageManager: this.smartMtaBlobStorageManager,
+        }
+      : {
+          ...queueBehavior,
+          storageMode: 'memory',
+        };
+
     const emailConfig: IUnifiedEmailServerOptions = await this.workAppMailManager.applyStoredIdentitiesToEmailConfig({
       ...this.options.emailConfig,
       ports: mappedEmailPorts,
       persistRoutes: this.options.emailConfig.persistRoutes ?? false,
-      queue: {
-        ...this.options.emailConfig.queue,
-        storageType: 'memory',
-      },
+      queue: queueOptions,
       outbound: {
         ...baseEmailConfig.outbound,
         connectionProxyProvider: (context) => this.mailEgressCoordinator.provideConnectionProxy(context),

package/ts/db/documents/classes.smartmta-storage.doc.ts

@@ -0,0 +1,25 @@
+import * as plugins from '../../plugins.js';
+import { DcRouterDb } from '../classes.dcrouter-db.js';
+
+const getDb = () => DcRouterDb.getInstance().getDb();
+
+@plugins.smartdata.Collection(() => getDb())
+export class SmartMtaStorageDoc extends plugins.smartdata.SmartDataDbDoc<
+  SmartMtaStorageDoc,
+  SmartMtaStorageDoc
+> {
+  @plugins.smartdata.svDb()
+  public id!: string;
+
+  @plugins.smartdata.svDb()
+  public key!: string;
+
+  @plugins.smartdata.svDb()
+  public value!: string;
+
+  @plugins.smartdata.svDb()
+  public createdAt!: string;
+
+  @plugins.smartdata.svDb()
+  public updatedAt!: string;
+}

package/ts/db/documents/index.ts

@@ -41,3 +41,4 @@ export * from './classes.acme-config.doc.js';
 // Email domain management
 export * from './classes.email-domain.doc.js';
 export * from './classes.email-server-settings.doc.js';
+export * from './classes.smartmta-storage.doc.js';

package/ts/email/classes.email-settings.manager.ts

@@ -155,6 +155,7 @@ export class EmailSettingsManager {
     const nextConfig: IUnifiedEmailServerOptions | undefined = clonePlain(existingConfig) || (nextEnabled ? {
       hostname: 'localhost',
       ports: [...defaultEmailPorts],
+      queue: { storageMode: 'memory' },
       domains: [],
       routes: [],
     } : undefined);

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

@@ -0,0 +1,138 @@
+import * as plugins from '../plugins.js';
+import type { IBlobStorageManager } from '@push.rocks/smartmta';
+
+const SMARTMTA_BLOB_NAMESPACES = [
+  '/email/queue/',
+  '/email/attachments/',
+] as const;
+const DEFAULT_OBJECT_PREFIX = 'dcrouter/smartmta/';
+const MAX_STORAGE_KEY_BYTES = 1024;
+
+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;
+}
+
+function normalizeObjectPrefix(prefixArg = DEFAULT_OBJECT_PREFIX): string {
+  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: string, allowNamespaceRoot = false): string {
+  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 implements IBlobStorageManager {
+  private readonly objectPrefix: string;
+
+  public constructor(
+    private readonly bucketRef: TBlobBucket,
+    objectPrefix = DEFAULT_OBJECT_PREFIX,
+  ) {
+    this.objectPrefix = normalizeObjectPrefix(objectPrefix);
+  }
+
+  public static async create(
+    configArg: ISmartMtaBlobStorageConfig,
+  ): Promise<SmartMtaBlobStorageManager> {
+    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: plugins.smartbucket.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);
+  }
+
+  public async get(keyArg: string): Promise<Buffer | null> {
+    const objectKey = this.toObjectKey(normalizeBlobKey(keyArg));
+    if (!(await this.bucketRef.fastExists({ path: objectKey }))) {
+      return null;
+    }
+    return Buffer.from(await this.bucketRef.fastGet({ path: objectKey }));
+  }
+
+  public async set(keyArg: string, valueArg: Buffer): Promise<void> {
+    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,
+    });
+  }
+
+  public async list(prefixArg: string): Promise<string[]> {
+    const prefix = normalizeBlobKey(prefixArg, true);
+    const objectPrefix = this.toObjectKey(prefix);
+    const keys: string[] = [];
+    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();
+  }
+
+  public async delete(keyArg: string): Promise<void> {
+    const objectKey = this.toObjectKey(normalizeBlobKey(keyArg));
+    await this.bucketRef.fastRemove({ path: objectKey });
+  }
+
+  private toObjectKey(keyArg: string): string {
+    return `${this.objectPrefix}${keyArg.slice(1)}`;
+  }
+}

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

@@ -1,108 +1,111 @@
 import * as plugins from '../plugins.js';
-import type { IStorageManagerLike } from '@push.rocks/smartmta';
+import type { IStorageManager } from '@push.rocks/smartmta';
+import {
+  getSmartMtaTextNamespace,
+  hashSmartMtaStorageKey,
+  normalizeSmartMtaStorageKey,
+  validateSmartMtaTextValue,
+} from './smartmta-storage-policy.js';
 
-export class SmartMtaStorageManager implements IStorageManagerLike {
-  private readonly resolvedRootDir: string;
+interface ISmartMtaStorageDocument {
+  _id: string;
+  id: string;
+  key: string;
+  value: string;
+  createdAt: string;
+  updatedAt: string;
+}
 
-  constructor(private rootDir: string) {
-    this.resolvedRootDir = plugins.path.resolve(rootDir);
-    plugins.fsUtils.ensureDirSync(this.resolvedRootDir);
-  }
+export class SmartMtaStorageManager implements IStorageManager {
+  private readonly collection: any;
 
-  private normalizeKey(key: string): string {
-    return key.replace(/^\/+/, '').replace(/\\/g, '/');
+  constructor(smartdataDb: plugins.smartdata.SmartdataDb) {
+    this.collection = smartdataDb.mongoDb.collection('SmartMtaStorageDoc');
   }
 
-  private resolvePathForKey(key: string): string {
-    const normalizedKey = this.normalizeKey(key);
-    const resolvedPath = plugins.path.resolve(this.resolvedRootDir, normalizedKey);
+  private validateDocument(
+    document: ISmartMtaStorageDocument,
+    expectedKey?: string,
+  ): ISmartMtaStorageDocument {
+    const normalizedKey = normalizeSmartMtaStorageKey(document.key);
+    const expectedId = hashSmartMtaStorageKey(normalizedKey);
     if (
-      resolvedPath !== this.resolvedRootDir
-      && !resolvedPath.startsWith(`${this.resolvedRootDir}${plugins.path.sep}`)
+      document._id !== expectedId
+      || document.id !== expectedId
+      || document.key !== normalizedKey
+      || (expectedKey && document.key !== expectedKey)
+      || typeof document.value !== 'string'
     ) {
-      throw new Error(`Storage key escapes root directory: ${key}`);
+      throw new Error(`Corrupt SmartMTA storage document: ${document._id}`);
     }
-    return resolvedPath;
-  }
-
-  private toStorageKey(filePath: string): string {
-    const relativePath = plugins.path.relative(this.resolvedRootDir, filePath).split(plugins.path.sep).join('/');
-    return `/${relativePath}`;
+    validateSmartMtaTextValue(document.key, document.value);
+    return document;
   }
 
   public async get(key: string): Promise<string | null> {
-    const filePath = this.resolvePathForKey(key);
-    try {
-      return await plugins.fs.promises.readFile(filePath, 'utf8');
-    } catch (error: unknown) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        return null;
-      }
-      throw error;
-    }
+    const normalizedKey = normalizeSmartMtaStorageKey(key);
+    getSmartMtaTextNamespace(normalizedKey);
+    const id = hashSmartMtaStorageKey(normalizedKey);
+    const document = await this.collection.findOne({ _id: id });
+    return document ? this.validateDocument(document, normalizedKey).value : null;
   }
 
   public async set(key: string, value: string): Promise<void> {
-    const filePath = this.resolvePathForKey(key);
-    await plugins.fs.promises.mkdir(plugins.path.dirname(filePath), { recursive: true });
-    await plugins.fs.promises.writeFile(filePath, value, 'utf8');
-  }
+    const normalizedKey = normalizeSmartMtaStorageKey(key);
+    validateSmartMtaTextValue(normalizedKey, value);
+    const id = hashSmartMtaStorageKey(normalizedKey);
+    const existing = await this.collection.findOne({ _id: id });
+    if (existing) {
+      this.validateDocument(existing, normalizedKey);
+    }
 
-  public async list(prefix: string): Promise<string[]> {
-    const prefixPath = this.resolvePathForKey(prefix);
-    try {
-      const stat = await plugins.fs.promises.stat(prefixPath);
-      if (stat.isFile()) {
-        return [this.toStorageKey(prefixPath)];
-      }
-    } catch (error: unknown) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        return [];
-      }
-      throw error;
+    const now = new Date().toISOString();
+    await this.collection.updateOne(
+      { _id: id },
+      {
+        $set: {
+          id,
+          key: normalizedKey,
+          value,
+          updatedAt: now,
+        },
+        $setOnInsert: {
+          createdAt: now,
+        },
+      },
+      { upsert: true },
+    );
+
+    const stored = await this.collection.findOne({ _id: id });
+    if (!stored || this.validateDocument(stored, normalizedKey).value !== value) {
+      throw new Error(`SmartMTA storage write verification failed: ${normalizedKey}`);
     }
+  }
 
-    const results: string[] = [];
-    const walk = async (currentPath: string): Promise<void> => {
-      const entries = await plugins.fs.promises.readdir(currentPath, { withFileTypes: true });
-      for (const entry of entries) {
-        const entryPath = plugins.path.join(currentPath, entry.name);
-        if (entry.isDirectory()) {
-          await walk(entryPath);
-        } else if (entry.isFile()) {
-          results.push(this.toStorageKey(entryPath));
-        }
-      }
-    };
+  public async list(prefix: string): Promise<string[]> {
+    const normalizedPrefix = normalizeSmartMtaStorageKey(prefix);
+    getSmartMtaTextNamespace(normalizedPrefix);
+    const documents = await this.collection.find({
+      key: {
+        $gte: normalizedPrefix,
+        $lt: `${normalizedPrefix}\uffff`,
+      },
+    }).toArray();
 
-    await walk(prefixPath);
-    return results.sort();
+    return documents
+      .map((document: ISmartMtaStorageDocument) => this.validateDocument(document).key)
+      .filter((key: string) => key.startsWith(normalizedPrefix))
+      .sort();
   }
 
   public async delete(key: string): Promise<void> {
-    const targetPath = this.resolvePathForKey(key);
-    try {
-      const stat = await plugins.fs.promises.stat(targetPath);
-      if (stat.isDirectory()) {
-        await plugins.fs.promises.rm(targetPath, { recursive: true, force: true });
-      } else {
-        await plugins.fs.promises.unlink(targetPath);
-      }
-    } catch (error: unknown) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        return;
-      }
-      throw error;
-    }
-
-    let currentDir = plugins.path.dirname(targetPath);
-    while (currentDir.startsWith(this.resolvedRootDir) && currentDir !== this.resolvedRootDir) {
-      const entries = await plugins.fs.promises.readdir(currentDir);
-      if (entries.length > 0) {
-        break;
-      }
-      await plugins.fs.promises.rmdir(currentDir);
-      currentDir = plugins.path.dirname(currentDir);
+    const normalizedKey = normalizeSmartMtaStorageKey(key);
+    getSmartMtaTextNamespace(normalizedKey);
+    const id = hashSmartMtaStorageKey(normalizedKey);
+    const existing = await this.collection.findOne({ _id: id });
+    if (existing) {
+      this.validateDocument(existing, normalizedKey);
+      await this.collection.deleteOne({ _id: id });
     }
   }
 }

package/ts/email/classes.workapp-mail-manager.ts

@@ -4,6 +4,7 @@ import type {
   IMessageAcceptanceContext,
   IMessageAcceptanceDecision,
   IUnifiedEmailServerOptions,
+  IStorageManagerLike,
 } from '@push.rocks/smartmta';
 import type { Buffer } from 'node:buffer';
 import * as plugins from '../plugins.js';
@@ -611,11 +612,20 @@ export class WorkAppMailManager {
     await storageManager.set(this.storageKey, JSON.stringify(state, null, 2));
   }
 
-  private getRequiredStorageManager() {
-    if (!plugins.smartmta.hasStorageManagerMethods(this.dcRouterRef.storageManager, ['get', 'set'])) {
+  private getRequiredStorageManager(): IStorageManagerLike & Required<
+    Pick<IStorageManagerLike, 'get' | 'set'>
+  > {
+    const storageManager = this.dcRouterRef.storageManager;
+    if (
+      !storageManager
+      || typeof storageManager.get !== 'function'
+      || typeof storageManager.set !== 'function'
+    ) {
       throw new Error('DcRouter storage manager does not support managed mail identity persistence');
     }
-    return this.dcRouterRef.storageManager;
+    return storageManager as IStorageManagerLike & Required<
+      Pick<IStorageManagerLike, 'get' | 'set'>
+    >;
   }
 
   private mergeIdentitiesIntoEmailConfig<TConfig extends IUnifiedEmailServerOptions>(

package/ts/email/index.ts

@@ -5,6 +5,8 @@ export * from './classes.mail-dns-sync.js';
 export * from './classes.mail-egress-coordinator.js';
 export * from './classes.mail-edge-eligibility.js';
 export * from './classes.email-settings.manager.js';
+export * from './classes.smartmta-blob-storage-manager.js';
 export * from './classes.smartmta-storage-manager.js';
+export * from './smartmta-storage-policy.js';
 export * from './classes.workapp-mail-manager.js';
 export * from './email-dns-records.js';

package/ts/email/smartmta-storage-policy.ts

@@ -0,0 +1,73 @@
+import * as plugins from '../plugins.js';
+
+export interface ISmartMtaTextNamespace {
+  prefix: string;
+  maxBytes: number;
+}
+
+export const smartMtaTextNamespaces: readonly ISmartMtaTextNamespace[] = Object.freeze([
+  { prefix: '/email/dkim/', maxBytes: 128 * 1024 },
+  { prefix: '/email/dns/', maxBytes: 1024 * 1024 },
+  { prefix: '/email/bounces/', maxBytes: 8 * 1024 * 1024 },
+  { prefix: '/email/templates/', maxBytes: 4 * 1024 * 1024 },
+  { prefix: '/email/routes/config.json', maxBytes: 4 * 1024 * 1024 },
+  { prefix: '/security/ip-reputation-cache.json', maxBytes: 8 * 1024 * 1024 },
+  { prefix: '/workhosters/mail-identities.json', maxBytes: 4 * 1024 * 1024 },
+]);
+
+export function normalizeSmartMtaStorageKey(key: string): string {
+  if (typeof key !== 'string' || key.length === 0) {
+    throw new Error('SmartMTA storage key must be a non-empty string');
+  }
+  if (key.includes('\\') || key.includes('\0')) {
+    throw new Error(`Invalid SmartMTA storage key: ${key}`);
+  }
+
+  const withLeadingSlash = key.startsWith('/') ? key : `/${key}`;
+  const segments = withLeadingSlash.split('/').slice(1);
+  if (
+    segments.length === 0
+    || segments.some((segment, index) => segment === '.' || segment === '..' || (segment === '' && index < segments.length - 1))
+  ) {
+    throw new Error(`Invalid SmartMTA storage key: ${key}`);
+  }
+
+  const normalized = `/${segments.filter(Boolean).join('/')}`;
+  if (normalized.length > 1024) {
+    throw new Error('SmartMTA storage key exceeds 1024 characters');
+  }
+  return normalized;
+}
+
+export function getSmartMtaTextNamespace(key: string): ISmartMtaTextNamespace {
+  const normalizedKey = normalizeSmartMtaStorageKey(key);
+  const namespace = smartMtaTextNamespaces.find((candidate) => {
+    return candidate.prefix.endsWith('/')
+      ? normalizedKey.startsWith(candidate.prefix)
+      : normalizedKey === candidate.prefix;
+  });
+  if (!namespace) {
+    throw new Error(`Unsupported SmartMTA text storage namespace: ${normalizedKey}`);
+  }
+  return namespace;
+}
+
+export function validateSmartMtaTextValue(key: string, value: string): void {
+  if (typeof value !== 'string') {
+    throw new Error('SmartMTA text storage only accepts string values');
+  }
+  const namespace = getSmartMtaTextNamespace(key);
+  const size = Buffer.byteLength(value, 'utf8');
+  if (size > namespace.maxBytes) {
+    throw new Error(
+      `SmartMTA storage value for ${normalizeSmartMtaStorageKey(key)} exceeds ${namespace.maxBytes} bytes`,
+    );
+  }
+}
+
+export function hashSmartMtaStorageKey(key: string): string {
+  return plugins.crypto
+    .createHash('sha256')
+    .update(normalizeSmartMtaStorageKey(key))
+    .digest('hex');
+}

package/ts/opsserver/handlers/stats.handler.ts

@@ -562,10 +562,8 @@ export class StatsHandler {
         const emailLike = item.processingResult;
         const recipients = Array.isArray(emailLike?.to)
           ? emailLike.to
-          : Array.isArray(emailLike?.email?.to)
-            ? emailLike.email.to
-            : [];
-        const subject = emailLike?.subject || emailLike?.email?.subject || '';
+          : [];
+        const subject = emailLike?.subject || '';
         return {
           id: item.id,
           recipient: recipients[0] || '',

package/ts/plugins.ts

@@ -54,6 +54,7 @@ export {
 import * as projectinfo from '@push.rocks/projectinfo';
 import * as qenv from '@push.rocks/qenv';
 import * as smartacme from '@push.rocks/smartacme';
+import * as smartbucket from '@push.rocks/smartbucket';
 import * as smartchallenge from '@push.rocks/smartchallenge';
 import * as smartdata from '@push.rocks/smartdata';
 import * as smartdns from '@push.rocks/smartdns';
@@ -76,7 +77,7 @@ import * as smartrx from '@push.rocks/smartrx';
 import * as smartunique from '@push.rocks/smartunique';
 import * as taskbuffer from '@push.rocks/taskbuffer';
 
-export { projectinfo, qenv, smartacme, smartchallenge, smartdata, smartdns, smartfs, smartguard, smartjwt, smartlog, smartmetrics, smartmcp, smartdb, smartmta, smartnetwork, smartpath, smartproxy, smartpromise, smartradius, smartrequest, smartrx, smartunique, smartvpn, taskbuffer };
+export { projectinfo, qenv, smartacme, smartbucket, smartchallenge, smartdata, smartdns, smartfs, smartguard, smartjwt, smartlog, smartmetrics, smartmcp, smartdb, smartmta, smartnetwork, smartpath, smartproxy, smartpromise, smartradius, smartrequest, smartrx, smartunique, smartvpn, taskbuffer };
 
 // Define SmartLog types for use in error handling
 export type TLogLevel = 'error' | 'warn' | 'info' | 'success' | 'debug';

package/ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/dcrouter',
-  version: '16.5.0',
+  version: '17.0.0',
   description: 'A multifaceted routing service handling mail and SMS delivery functions.'
 }