@zintrust/core 0.1.15 → 0.1.17

package/src/session/SessionManager.js

@@ -0,0 +1,149 @@
+import { generateSecureJobId } from '../common/uuid.js';
+const DEFAULT_OPTIONS = {
+    cookieName: 'ZIN_SESSION_ID',
+    headerName: 'x-session-id',
+    ttlMs: 7 * 24 * 60 * 60 * 1000,
+};
+function parseCookies(cookieHeader) {
+    const list = {};
+    if (cookieHeader.length === 0)
+        return list;
+    cookieHeader.split(';').forEach((cookie) => {
+        const parts = cookie.split('=');
+        const name = parts.shift()?.trim();
+        const value = parts.join('=');
+        if (name !== null && name !== undefined)
+            list[name] = decodeURIComponent(value);
+    });
+    return list;
+}
+function appendSetCookie(res, cookie) {
+    const existing = res.getHeader('Set-Cookie');
+    if (existing === undefined) {
+        res.setHeader('Set-Cookie', cookie);
+        return;
+    }
+    if (Array.isArray(existing)) {
+        const existingCookies = existing.map(String);
+        res.setHeader('Set-Cookie', [...existingCookies, cookie]);
+        return;
+    }
+    if (typeof existing === 'string') {
+        res.setHeader('Set-Cookie', [existing, cookie]);
+        return;
+    }
+    res.setHeader('Set-Cookie', cookie);
+}
+function buildSessionCookie(cookieName, sessionId) {
+    // Keep this minimal; callers can override behavior later.
+    // HttpOnly prevents JS access; SameSite=Lax is a reasonable default for app sessions.
+    return `${cookieName}=${encodeURIComponent(sessionId)}; Path=/; HttpOnly; SameSite=Lax`;
+}
+function createSessionApi(sessions, sessionId, ttlMs) {
+    const withoutKey = (data, key) => {
+        if (!Object.prototype.hasOwnProperty.call(data, key))
+            return data;
+        const record = data;
+        const { [key]: _removed, ...rest } = record;
+        return rest;
+    };
+    const ensureStored = () => {
+        const existing = sessions.get(sessionId);
+        const now = Date.now();
+        if (existing !== undefined && existing.expiresAt > now) {
+            return existing;
+        }
+        const created = { data: {}, expiresAt: now + ttlMs };
+        sessions.set(sessionId, created);
+        return created;
+    };
+    return {
+        id: sessionId,
+        get(key) {
+            return ensureStored().data[key];
+        },
+        set(key, value) {
+            const stored = ensureStored();
+            stored.data[key] = value;
+            stored.expiresAt = Date.now() + ttlMs;
+        },
+        has(key) {
+            return Object.prototype.hasOwnProperty.call(ensureStored().data, key);
+        },
+        forget(key) {
+            const stored = ensureStored();
+            stored.data = withoutKey(stored.data, key);
+            stored.expiresAt = Date.now() + ttlMs;
+        },
+        all() {
+            return { ...ensureStored().data };
+        },
+        clear() {
+            const stored = ensureStored();
+            stored.data = {};
+            stored.expiresAt = Date.now() + ttlMs;
+        },
+    };
+}
+export const SessionManager = Object.freeze({
+    create(options = {}) {
+        const config = { ...DEFAULT_OPTIONS, ...options };
+        const sessions = new Map();
+        return {
+            getIdFromCookieHeader(cookieHeader) {
+                if (cookieHeader === undefined || cookieHeader.length === 0)
+                    return undefined;
+                const cookies = parseCookies(cookieHeader);
+                return cookies[config.cookieName];
+            },
+            getIdFromRequest(req) {
+                const cookieHeader = req.getHeader('cookie');
+                if (typeof cookieHeader === 'string') {
+                    const fromCookie = this.getIdFromCookieHeader(cookieHeader);
+                    if (fromCookie !== undefined)
+                        return fromCookie;
+                }
+                const fromHeader = req.getHeader(config.headerName);
+                if (typeof fromHeader === 'string' && fromHeader.length > 0)
+                    return fromHeader;
+                if (typeof req.sessionId === 'string' && req.sessionId.length > 0)
+                    return req.sessionId;
+                const fromContext = req.context?.['sessionId'];
+                if (typeof fromContext === 'string' && fromContext.length > 0)
+                    return fromContext;
+                return undefined;
+            },
+            async ensureSessionId(req, res) {
+                const existing = this.getIdFromRequest(req);
+                const sessionId = existing ??
+                    (await Promise.resolve(generateSecureJobId('SessionManager: secure crypto API not available to generate a session id')));
+                req.context['sessionId'] = sessionId;
+                // If the cookie is missing, set it.
+                const cookieHeader = req.getHeader('cookie');
+                const fromCookie = typeof cookieHeader === 'string' ? this.getIdFromCookieHeader(cookieHeader) : undefined;
+                if (fromCookie === undefined) {
+                    appendSetCookie(res, buildSessionCookie(config.cookieName, sessionId));
+                }
+                return sessionId;
+            },
+            get(sessionId) {
+                return createSessionApi(sessions, sessionId, config.ttlMs);
+            },
+            destroy(sessionId) {
+                sessions.delete(sessionId);
+            },
+            cleanup() {
+                const now = Date.now();
+                let removed = 0;
+                for (const [id, stored] of sessions.entries()) {
+                    if (stored.expiresAt <= now) {
+                        sessions.delete(id);
+                        removed++;
+                    }
+                }
+                return removed;
+            },
+        };
+    },
+});
+export default SessionManager;

package/src/session/index.d.ts

@@ -0,0 +1,3 @@
+export { SessionManager } from './SessionManager';
+export type { ISession, ISessionManager, SessionData, SessionManagerOptions } from './SessionManager';
+//# sourceMappingURL=index.d.ts.map

package/src/session/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/session/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,YAAY,EAAE,QAAQ,EAAE,eAAe,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC"}

package/src/session/index.js

@@ -0,0 +1 @@
+export { SessionManager } from './SessionManager.js';

package/src/templates/features/Queue.ts.tpl

@@ -1,6 +1,7 @@
 // TEMPLATE_START
 
-import { generateSecureJobId, Logger } from '@zintrust/core';
+import { generateSecureJobId } from '@common/uuid';
+import { Logger } from '@config/logger';
 
 export interface QueueJob {
   id: string;
@@ -18,8 +19,8 @@ export const Queue = Object.freeze({
   /**
    * Add a job to the queue
    */
-  async add<T>(data: T): Promise<string> {
-    const id = await generateSecureJobId();
+  add<T>(data: T): string {
+    const id = generateSecureJobId();
     const job: QueueJob = {
       id,
       data,
@@ -43,4 +44,4 @@ export const Queue = Object.freeze({
   },
 });
 
-// TEMPLATE_END
+// TEMPLATE_END

package/src/templates/project/basic/config/FileLogWriter.ts.tpl

@@ -1,14 +1,15 @@
 /**
  * FileLogWriter (Node.js only)
- * Re-exports core FileLogWriter for optional use
+ *
+ * Provides best-effort file logging with daily + size-based rotation.
+ * This module imports Node built-ins and should be loaded only in Node environments.
  */
 
 import { ensureDirSafe } from '@zintrust/core';
+import { Env } from './env';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 
-import { Env } from './env';
-
 const getCwdSafe = (): string => {
   try {
     if (typeof process === 'undefined' || typeof process.cwd !== 'function') return '';

package/src/templates/project/basic/config/SecretsManager.ts.tpl

@@ -4,7 +4,7 @@
  * Supports: AWS Secrets Manager, Parameter Store, Cloudflare KV, Deno env
  */
 
-import { Logger } from '@zintrust/core';
+import { Logger } from './logger';
 import type {
   GetSecretOptions,
   SecretConfig,

package/src/templates/project/basic/config/broadcast.ts.tpl

@@ -5,7 +5,7 @@
  * Driver selection must be dynamic (tests may mutate process.env).
  */
 
-import { Env } from '@config/env';
+import { Env } from './env';
 import {
   BroadcastConfigInput,
   BroadcastDrivers,
@@ -14,7 +14,7 @@ import {
   PusherBroadcastDriverConfig,
   RedisBroadcastDriverConfig,
   RedisHttpsBroadcastDriverConfig,
-} from '@config/type';
+} from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const normalizeDriverName = (value: string): string => value.trim().toLowerCase();

package/src/templates/project/basic/config/cache.ts.tpl

@@ -4,8 +4,8 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from '@config/env';
-import { CacheConfigInput, CacheDriverConfig } from '@config/type';
+import { Env } from './env';
+import { CacheConfigInput, CacheDriverConfig } from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const getCacheDriver = (config: CacheConfigInput, name?: string): CacheDriverConfig => {

package/src/templates/project/basic/config/database.ts.tpl

@@ -4,8 +4,8 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from '@config/env';
-import { DatabaseConfigShape, DatabaseConnectionConfig, DatabaseConnections } from '@config/type';
+import { Env } from './env';
+import { DatabaseConfigShape, DatabaseConnectionConfig, DatabaseConnections } from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const hasOwn = (obj: Record<string, unknown>, key: string): boolean => {

package/src/templates/project/basic/config/env.ts.tpl

@@ -64,6 +64,8 @@ export const Env = Object.freeze({
   HOST: get('HOST', 'localhost'),
   APP_NAME: get('APP_NAME', 'ZinTrust'),
   APP_KEY: get('APP_KEY', ''),
+  // Optional key rotation support (comma-separated or JSON array of keys)
+  APP_PREVIOUS_KEYS: get('APP_PREVIOUS_KEYS', ''),
 
   // Database
   DB_CONNECTION: get('DB_CONNECTION', 'sqlite'),
@@ -124,6 +126,9 @@ export const Env = Object.freeze({
   TOKEN_TTL: getInt('TOKEN_TTL', 3600000),
   TOKEN_LENGTH: getInt('TOKEN_LENGTH', 32),
 
+  // Encryption interop
+  ENCRYPTION_CIPHER: get('ENCRYPTION_CIPHER', ''),
+
   // Deployment
   ENVIRONMENT: get('ENVIRONMENT', 'development'),
   REQUEST_TIMEOUT: getInt('REQUEST_TIMEOUT', 30000),

package/src/templates/project/basic/config/features.ts.tpl

@@ -1,5 +1,5 @@
-import { Env } from '@zintrust/core';
-import { Logger } from '@zintrust/core';
+import { Env } from './env';
+import { Logger } from './logger';
 
 /**
  * Feature Flags State

package/src/templates/project/basic/config/logger.ts.tpl

@@ -3,8 +3,6 @@
  * Sealed namespace pattern - all exports through Logger namespace
  * Replaces console.* calls throughout the codebase
  */
-import { Logger } from '@zintrust/core';
-
 import { appConfig } from './app';
 import { Env } from './env';
 

package/src/templates/project/basic/config/logging/HttpLogger.ts.tpl

@@ -10,7 +10,7 @@
  */
 
 import { delay } from '@zintrust/core';
-import { Env } from '@zintrust/core';
+import { Env } from '../env';
 import { ErrorFactory } from '@zintrust/core';
 import { HttpClient } from '@zintrust/core';
 

package/src/templates/project/basic/config/logging/SlackLogger.ts.tpl

@@ -9,7 +9,7 @@
  *  - SLACK_LOG_BATCH_WINDOW_MS (default: 5000)
  */
 
-import { Env } from '@zintrust/core';
+import { Env } from '../env';
 import { ErrorFactory } from '@zintrust/core';
 import { HttpClient } from '@zintrust/core';
 

package/src/templates/project/basic/config/mail.ts.tpl

@@ -4,8 +4,8 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from '@config/env';
-import type { MailConfigInput, MailDriverConfig } from '@config/type';
+import { Env } from './env';
+import type { MailConfigInput, MailDriverConfig } from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const isMailDriverConfig = (value: unknown): value is MailDriverConfig => {

package/src/templates/project/basic/config/microservices.ts.tpl

@@ -4,7 +4,7 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from '@zintrust/core';
+import { Env } from './env';
 
 const microservicesConfigObj = {
   /**

package/src/templates/project/basic/config/middleware.ts.tpl

@@ -1,13 +1,10 @@
-import {
-  CsrfMiddleware,
-  ErrorHandlerMiddleware,
-  LoggingMiddleware,
-  RateLimiter,
-  SecurityMiddleware,
-  type Middleware,
-} from '@zintrust/core';
-
 import { MiddlewareConfigType } from './type';
+import { CsrfMiddleware } from '@zintrust/core';
+import { ErrorHandlerMiddleware } from '@zintrust/core';
+import { LoggingMiddleware } from '@zintrust/core';
+import type { Middleware } from '@zintrust/core';
+import { RateLimiter } from '@zintrust/core';
+import { SecurityMiddleware } from '@zintrust/core';
 
 const shared = Object.freeze({
   log: LoggingMiddleware.create(),

package/src/templates/project/basic/config/notification.ts.tpl

@@ -5,13 +5,13 @@
  * Driver selection must be dynamic (tests may mutate process.env).
  */
 
-import { Env } from '@config/env';
+import { Env } from './env';
 import type {
   KnownNotificationDriverConfig,
   NotificationConfigInput,
   NotificationDrivers,
   NotificationProviders,
-} from '@config/type';
+} from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const normalizeName = (value: string): string => value.trim().toLowerCase();

package/src/templates/project/basic/config/security.ts.tpl

@@ -9,17 +9,16 @@
  * Security keys can be configured per domain:
  * - APP_KEY: Default encryption key for all operations (auto-generated)
  * - API_KEY_SECRET: Optional API key authentication (if API_KEY_ENABLED=true)
- * - ENCRYPTION_KEY: Optional separate encryption key (overrides APP_KEY if set)
+ * - ENCRYPTION_CIPHER: Cipher for encrypted envelope interoperability
  * - JWT_SECRET: JWT token signing key
  *
  * Developers can use a single APP_KEY or configure separate keys for different
  * security domains (e.g., different keys for different microservices).
  */
 
-import { Logger } from '@zintrust/core';
-
 import { appConfig } from './app';
 import { Env } from './env';
+import { Logger } from './logger';
 import { ErrorFactory } from '@zintrust/core';
 
 /**
@@ -77,6 +76,16 @@ const securityConfigObj = {
    * Encryption
    */
   encryption: {
+    // Required for framework-compatible encrypted payloads.
+    // Supported values: aes-256-cbc | aes-256-gcm (case-insensitive)
+    cipher: Env.get('ENCRYPTION_CIPHER', ''),
+
+    // Primary key used for encryption interoperability (framework-compatible envelopes).
+    // APP_KEY supports both `base64:...` and raw base64.
+    appKey: Env.get('APP_KEY', ''),
+    appPreviousKeys: Env.get('APP_PREVIOUS_KEYS', ''),
+
+    // Back-compat fields (not used by EncryptedEnvelope)
     algorithm: Env.get('ENCRYPTION_ALGORITHM', 'aes-256-cbc'),
     key: Env.get('ENCRYPTION_KEY', 'your-encryption-key'),
   },

package/src/templates/project/basic/config/storage.ts.tpl

@@ -4,8 +4,8 @@
  * Sealed namespace for immutability
  */
 
-import { Env } from '@config/env';
-import type { StorageConfigRuntime, StorageDriverConfig, StorageDrivers } from '@config/type';
+import { Env } from './env';
+import type { StorageConfigRuntime, StorageDriverConfig, StorageDrivers } from './type';
 import { ErrorFactory } from '@zintrust/core';
 
 const hasOwn = <T extends object>(obj: T, key: PropertyKey): key is keyof T => {

package/src/templates/project/basic/config/type.ts.tpl

@@ -1,5 +1,5 @@
-import { Env } from '@config/env';
-import type { Middleware as MiddlewareFn } from '@middleware/MiddlewareStack';
+import { Env } from './env';
+import type { Middleware as MiddlewareFn } from '@zintrust/core';
 
 export type Environment =
   | 'development'

package/src/tools/broadcast/Broadcast.d.ts

@@ -3,6 +3,14 @@ type Broadcaster = Readonly<{
 }>;
 export declare const Broadcast: Readonly<{
     send(channel: string, event: string, data: unknown): Promise<unknown>;
+    broadcastNow(channel: string, event: string, data: unknown): Promise<unknown>;
+    BroadcastLater(channel: string, event: string, data: unknown, options?: {
+        queueName?: string;
+        timestamp?: number;
+    }): Promise<string>;
+    queue(queueName: string): Readonly<{
+        BroadcastLater: (channel: string, event: string, data: unknown, options?: {}) => Promise<string>;
+    }>;
     broadcaster(name?: string): Broadcaster;
 }>;
 export default Broadcast;

package/src/tools/broadcast/Broadcast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Broadcast.d.ts","sourceRoot":"","sources":["../../../../src/tools/broadcast/Broadcast.ts"],"names":[],"mappings":"AAQA,KAAK,WAAW,GAAG,QAAQ,CAAC;IAC1B,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3E,CAAC,CAAC;AAyDH,eAAO,MAAM,SAAS;kBACA,MAAM,SAAS,MAAM,QAAQ,OAAO;uBAKrC,MAAM,GAAG,WAAW;EAQvC,CAAC;AAEH,eAAe,SAAS,CAAC"}
+{"version":3,"file":"Broadcast.d.ts","sourceRoot":"","sources":["../../../../src/tools/broadcast/Broadcast.ts"],"names":[],"mappings":"AAQA,KAAK,WAAW,GAAG,QAAQ,CAAC;IAC1B,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3E,CAAC,CAAC;AAyDH,eAAO,MAAM,SAAS;kBACA,MAAM,SAAS,MAAM,QAAQ,OAAO;0BAM5B,MAAM,SAAS,MAAM,QAAQ,OAAO;4BAMrD,MAAM,SACR,MAAM,QACP,OAAO,YACJ;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;qBAepC,MAAM;kCAEa,MAAM,SAAS,MAAM,QAAQ,OAAO;;uBAKrD,MAAM,GAAG,WAAW;EAQvC,CAAC;AAEH,eAAe,SAAS,CAAC"}

package/src/tools/broadcast/Broadcast.js

@@ -49,6 +49,29 @@ export const Broadcast = Object.freeze({
         const config = await resolveBroadcasterConfig();
         return sendWithConfig(config, channel, event, data);
     },
+    // Alias for send() - explicit intent for immediate broadcast
+    async broadcastNow(channel, event, data) {
+        return this.send(channel, event, data);
+    },
+    // Queue broadcast for async processing
+    async BroadcastLater(channel, event, data, options = {}) {
+        const { queueName = 'broadcasts', timestamp = Date.now() } = options;
+        const { Queue } = await import('../queue/Queue.js');
+        const messageId = await Queue.enqueue(queueName, {
+            type: 'broadcast',
+            channel,
+            event,
+            data,
+            timestamp,
+            attempts: 0,
+        });
+        return messageId;
+    },
+    queue(queueName) {
+        return Object.freeze({
+            BroadcastLater: async (channel, event, data, options = {}) => Broadcast.BroadcastLater(channel, event, data, { ...options, queueName }),
+        });
+    },
     broadcaster(name) {
         return Object.freeze({
             send: async (channel, event, data) => {

package/src/tools/notification/Notification.d.ts

@@ -5,6 +5,16 @@
  */
 export declare const Notification: Readonly<{
     send: (recipient: string, message: string, options?: Record<string, unknown>) => Promise<unknown>;
+    NotifyNow: (recipient: string, message: string, options?: Record<string, unknown>) => Promise<unknown>;
+    NotifyLater(recipient: string, message: string, notifyOptions?: Record<string, unknown>, queueOptions?: {
+        queueName?: string;
+        timestamp?: number;
+    }): Promise<string>;
+    queue(queueName: string): Readonly<{
+        NotifyLater: (recipient: string, message: string, notifyOptions?: Record<string, unknown>, queueOptions?: {
+            timestamp?: number;
+        }) => Promise<string>;
+    }>;
     channel: (name: string) => Readonly<{
         send: (recipient: string, message: string, options?: Record<string, unknown>) => Promise<unknown>;
     }>;

package/src/tools/notification/Notification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Notification.d.ts","sourceRoot":"","sources":["../../../../src/tools/notification/Notification.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,eAAO,MAAM,YAAY;;oBAEP,MAAM;0BAEM,MAAM,WAAW,MAAM,YAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;EAItF,CAAC;AAEH,eAAe,YAAY,CAAC"}
+{"version":3,"file":"Notification.d.ts","sourceRoot":"","sources":["../../../../src/tools/notification/Notification.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,eAAO,MAAM,YAAY;;;2BAQV,MAAM,WACR,MAAM,kBACA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,iBACxB;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GACvD,OAAO,CAAC,MAAM,CAAC;qBAcD,MAAM;iCAGN,MAAM,WACR,MAAM,kBACA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,iBACxB;YAAE,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE;;oBAM1B,MAAM;0BAEM,MAAM,WAAW,MAAM,YAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;EAItF,CAAC;AAEH,eAAe,YAAY,CAAC"}

package/src/tools/notification/Notification.js

@@ -6,6 +6,27 @@
 import { NotificationService } from './Service.js';
 export const Notification = Object.freeze({
     send: NotificationService.send,
+    // Alias for send() - explicit intent for immediate notification
+    NotifyNow: NotificationService.send,
+    // Queue notification for async processing
+    async NotifyLater(recipient, message, notifyOptions = {}, queueOptions = {}) {
+        const { queueName = 'notifications', timestamp = Date.now() } = queueOptions;
+        const { Queue } = await import('../queue/Queue.js');
+        const messageId = await Queue.enqueue(queueName, {
+            type: 'notification',
+            recipient,
+            message,
+            options: notifyOptions,
+            timestamp,
+            attempts: 0,
+        });
+        return messageId;
+    },
+    queue(queueName) {
+        return Object.freeze({
+            NotifyLater: async (recipient, message, notifyOptions = {}, queueOptions = {}) => Notification.NotifyLater(recipient, message, notifyOptions, { ...queueOptions, queueName }),
+        });
+    },
     channel: (name) => Object.freeze({
         send: async (recipient, message, options) => NotificationService.sendVia(name, recipient, message, options),
     }),

package/src/workers/BroadcastWorker.d.ts

@@ -0,0 +1,22 @@
+/**
+ * BroadcastWorker - Processes queued broadcasts
+ *
+ * This worker dequeues broadcast messages and sends them using the Broadcast service.
+ * Use with Queue.dequeue() in a background process or cron job.
+ */
+export declare const BroadcastWorker: Readonly<{
+    processOne: (queueName?: string, driverName?: string) => Promise<boolean>;
+    processAll: (queueName?: string, driverName?: string) => Promise<number>;
+    runOnce: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        maxItems?: number;
+    }) => Promise<number>;
+    startWorker: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        signal?: AbortSignal;
+    }) => Promise<number>;
+}>;
+export default BroadcastWorker;
+//# sourceMappingURL=BroadcastWorker.d.ts.map

package/src/workers/BroadcastWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BroadcastWorker.d.ts","sourceRoot":"","sources":["../../../src/workers/BroadcastWorker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,eAAO,MAAM,eAAe;0BAbrB,CAAC,oBAAoB,CAAC;0BAGf,CAAC,oBAAoB,CAAC;kBACnB,CAAC;iBAAiB,CAAC;kBAE3B,CAAC;gBACC,CAAA;;sBAGE,CAAC;iBAGP,CAAA;kBAAwB,CAAC;cAC3B,CAAC;;EAaJ,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/src/workers/BroadcastWorker.js

@@ -0,0 +1,24 @@
+/**
+ * BroadcastWorker - Processes queued broadcasts
+ *
+ * This worker dequeues broadcast messages and sends them using the Broadcast service.
+ * Use with Queue.dequeue() in a background process or cron job.
+ */
+import { createQueueWorker } from '../workers/createQueueWorker.js';
+import { Broadcast } from '../tools/broadcast/Broadcast.js';
+export const BroadcastWorker = Object.freeze({
+    ...createQueueWorker({
+        kindLabel: 'broadcast',
+        defaultQueueName: 'broadcasts',
+        maxAttempts: 3,
+        getLogFields: (payload) => ({
+            channel: payload.channel,
+            event: payload.event,
+            queuedAt: payload.timestamp,
+        }),
+        handle: async (payload) => {
+            await Broadcast.send(payload.channel, payload.event, payload.data);
+        },
+    }),
+});
+export default BroadcastWorker;

package/src/workers/NotificationWorker.d.ts

@@ -0,0 +1,22 @@
+/**
+ * NotificationWorker - Processes queued notifications
+ *
+ * This worker dequeues notification messages and sends them using the Notification service.
+ * Use with Queue.dequeue() in a background process or cron job.
+ */
+export declare const NotificationWorker: Readonly<{
+    processOne: (queueName?: string, driverName?: string) => Promise<boolean>;
+    processAll: (queueName?: string, driverName?: string) => Promise<number>;
+    runOnce: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        maxItems?: number;
+    }) => Promise<number>;
+    startWorker: (opts?: {
+        queueName?: string;
+        driverName?: string;
+        signal?: AbortSignal;
+    }) => Promise<number>;
+}>;
+export default NotificationWorker;
+//# sourceMappingURL=NotificationWorker.d.ts.map

package/src/workers/NotificationWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotificationWorker.d.ts","sourceRoot":"","sources":["../../../src/workers/NotificationWorker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAYH,eAAO,MAAM,kBAAkB;0BAdyD,CAAC,oBACzE,CAAC;0BAGf,CAAC,oBAAoB,CAAC;kBACnB,CAAC;iBAAkB,CAAA;kBAAwB,CAAC;gBAEtC,CAAC;;sBAGV,CAAC;iBAAiB,CAAC;kBACZ,CAAC;cAGL,CAAC;;EAaJ,CAAC;AAEH,eAAe,kBAAkB,CAAC"}

package/src/workers/NotificationWorker.js

@@ -0,0 +1,23 @@
+/**
+ * NotificationWorker - Processes queued notifications
+ *
+ * This worker dequeues notification messages and sends them using the Notification service.
+ * Use with Queue.dequeue() in a background process or cron job.
+ */
+import { createQueueWorker } from '../workers/createQueueWorker.js';
+import { Notification } from '../tools/notification/Notification.js';
+export const NotificationWorker = Object.freeze({
+    ...createQueueWorker({
+        kindLabel: 'notification',
+        defaultQueueName: 'notifications',
+        maxAttempts: 3,
+        getLogFields: (payload) => ({
+            recipient: payload.recipient,
+            queuedAt: payload.timestamp,
+        }),
+        handle: async (payload) => {
+            await Notification.send(payload.recipient, payload.message, payload.options);
+        },
+    }),
+});
+export default NotificationWorker;