notifkit 0.1.0

package/dist/main-BHYZfBBq.mjs

@@ -0,0 +1,224 @@
+import { J as PendingMessageScanner, Jt as buildStreamEvent, U as LUA_SCHEDULER_POLL, W as getPriorityBucket, X as StreamProducer, Y as StreamConsumer, Yt as CONSUMER_GROUPS, an as registry, c as BaseWorker, en as STREAMS, et as createLogger, hn as readBaseConfig, it as createDatabase, k as RedisClient, pn as loadEnv, u as startHealthReporter, ut as scheduledPayloads } from "./src-DrSN2wCg.mjs";
+import { randomUUID } from "node:crypto";
+import { inArray } from "drizzle-orm";
+//#region src/services/scheduler/main.ts
+loadEnv();
+const config = readBaseConfig();
+let logger;
+let redis;
+let sql$1;
+let db;
+let consumer;
+let pendingScanner;
+let worker;
+let healthInterval = null;
+let pollTimeout = null;
+let isPolling = false;
+var SchedulerWorker = class extends BaseWorker {
+	registry;
+	redisCli;
+	constructor(options) {
+		super(options);
+		this.registry = options.registry;
+		this.redisCli = options.redis;
+	}
+	async process(message) {
+		const { event } = message;
+		const payloadResult = this.registry.safeParsePayload("notification.scheduled", event.payload);
+		if (!payloadResult.success) {
+			this.logger.warn({
+				messageId: message.id,
+				issues: payloadResult.error.issues
+			}, "invalid notification.scheduled payload — skipping");
+			return;
+		}
+		const scheduled = payloadResult.data;
+		const scheduledAt = new Date(scheduled.scheduledAt).getTime();
+		const taskData = JSON.stringify({
+			taskId: scheduled.taskId,
+			enrichedEventId: scheduled.enrichedEventId,
+			traceId: event.metadata.traceId
+		});
+		const shard = parseInt(scheduled.taskId.slice(-1), 16) || 0;
+		const zsetKey = `notif:scheduled:zset:${shard}`;
+		await this.redisCli.zadd(zsetKey, scheduledAt, taskData);
+		this.logger.debug({
+			taskId: scheduled.taskId,
+			scheduledAt: scheduled.scheduledAt,
+			shard
+		}, "scheduled task queued in ZSET");
+	}
+};
+async function executeSchedulerPoll(redis, outboundProducers, logger, db) {
+	const lockKey = "notif:lock:scheduler:poll";
+	const lockOwner = randomUUID();
+	let acquired = false;
+	try {
+		if (await redis.set(lockKey, lockOwner, "EX", 30, "NX") !== "OK") return false;
+		acquired = true;
+		const now = Date.now();
+		const visibilityTimeout = 6e4;
+		const perShardLimit = 100;
+		const pipeline = redis.pipeline();
+		for (let i = 0; i < 16; i++) pipeline.eval(LUA_SCHEDULER_POLL, 1, `notif:scheduled:zset:${i}`, now, perShardLimit, visibilityTimeout);
+		const perShard = (await pipeline.exec())?.map((res) => res[0] ? [] : res[1] ?? []) ?? [];
+		const tasks = perShard.flat();
+		const anyShardFull = perShard.some((shard) => shard.length >= perShardLimit);
+		if (tasks.length === 0) return false;
+		const parsedTasks = tasks.map((t) => {
+			try {
+				return {
+					taskStr: t,
+					...JSON.parse(t)
+				};
+			} catch (err) {
+				logger.error({
+					taskStr: t,
+					err
+				}, "failed to parse scheduled task JSON");
+				return null;
+			}
+		}).filter(Boolean);
+		if (parsedTasks.length === 0) return false;
+		const taskIds = parsedTasks.map((t) => t.taskId);
+		const dbPayloads = await db.select().from(scheduledPayloads).where(inArray(scheduledPayloads.taskId, taskIds));
+		const payloadMap = new Map(dbPayloads.map((row) => [row.taskId, row.payload]));
+		const batchedEvents = {
+			critical: [],
+			high: [],
+			normal: [],
+			low: []
+		};
+		const cleanupPipeline = redis.pipeline();
+		const dbCleanupIds = [];
+		for (let i = 0; i < parsedTasks.length; i++) {
+			const { taskStr, taskId, traceId } = parsedTasks[i];
+			const payload = payloadMap.get(taskId);
+			if (!payload) {
+				logger.warn({ taskId }, "scheduled payload not found in Postgres — skipping release");
+				const shard = parseInt(taskId.slice(-1), 16) || 0;
+				cleanupPipeline.zrem(`notif:scheduled:zset:${shard}`, taskStr);
+				continue;
+			}
+			const dispatchPayload = payload;
+			batchedEvents[getPriorityBucket(dispatchPayload.priority)].push(buildStreamEvent("notification.dispatched", dispatchPayload, "scheduler", traceId));
+			dbCleanupIds.push(taskId);
+			const shard = parseInt(taskId.slice(-1), 16) || 0;
+			cleanupPipeline.zrem(`notif:scheduled:zset:${shard}`, taskStr);
+		}
+		for (const p of Object.keys(batchedEvents)) if (batchedEvents[p].length > 0) await (outboundProducers[p] ?? outboundProducers["normal"]).publishBatch(batchedEvents[p]);
+		if (dbCleanupIds.length > 0) try {
+			await db.delete(scheduledPayloads).where(inArray(scheduledPayloads.taskId, dbCleanupIds));
+		} catch (err) {
+			logger.error({ err }, "failed to delete scheduled payloads from Postgres, continuing with Redis cleanup");
+		}
+		await cleanupPipeline.exec();
+		logger.info({ count: parsedTasks.length }, "scheduled tasks released to outbound");
+		return anyShardFull;
+	} catch (err) {
+		logger.error({ err }, "error in scheduler polling loop");
+		return false;
+	} finally {
+		if (acquired) await redis.eval(`
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("del", KEYS[1])
+        else
+          return 0
+        end
+      `, 1, lockKey, lockOwner).catch(() => {});
+	}
+}
+async function startSchedulerWorker() {
+	logger = createLogger({
+		name: "scheduler",
+		level: config.LOG_LEVEL
+	});
+	redis = new RedisClient({
+		url: config.REDIS_URL,
+		name: "scheduler",
+		logger
+	});
+	const dbData = createDatabase({
+		url: config.DATABASE_URL,
+		applicationName: "scheduler",
+		logger
+	});
+	sql$1 = dbData.sql;
+	db = dbData.db;
+	consumer = new StreamConsumer({
+		redis: redis.native,
+		stream: STREAMS.SCHEDULED,
+		group: CONSUMER_GROUPS.SCHEDULER,
+		consumer: `scheduler-${process.pid}`,
+		dlqStream: STREAMS.DEAD_LETTER,
+		batchSize: config.WORKER_CONCURRENCY,
+		logger
+	});
+	pendingScanner = new PendingMessageScanner({
+		redis: redis.native,
+		stream: STREAMS.SCHEDULED,
+		group: CONSUMER_GROUPS.SCHEDULER,
+		consumer: `scheduler-${process.pid}`,
+		logger
+	});
+	const outboundProducers = {
+		critical: new StreamProducer({
+			redis: redis.native,
+			stream: STREAMS.OUTBOUND_CRITICAL,
+			logger
+		}),
+		normal: new StreamProducer({
+			redis: redis.native,
+			stream: STREAMS.OUTBOUND_NORMAL,
+			logger
+		}),
+		low: new StreamProducer({
+			redis: redis.native,
+			stream: STREAMS.OUTBOUND_LOW,
+			logger
+		})
+	};
+	worker = new SchedulerWorker({
+		consumer,
+		pendingScanner,
+		logger,
+		concurrency: config.WORKER_CONCURRENCY,
+		registry,
+		redis: redis.native
+	});
+	isPolling = true;
+	const pollLoop = async () => {
+		if (!isPolling) return;
+		try {
+			const hasMore = await executeSchedulerPoll(redis.native, outboundProducers, logger, db);
+			if (isPolling) pollTimeout = setTimeout(() => void pollLoop(), hasMore ? 0 : 5e3);
+		} catch (err) {
+			logger.error({ err }, "scheduler poll loop error");
+			if (isPolling) pollTimeout = setTimeout(() => void pollLoop(), 5e3);
+		}
+	};
+	pollLoop();
+	healthInterval = startHealthReporter("scheduler", worker, redis, logger);
+	logger.info({ env: config.NODE_ENV }, "scheduler starting");
+	await worker.start();
+}
+async function stopSchedulerWorker() {
+	logger?.info("shutdown initiated");
+	if (healthInterval) {
+		clearInterval(healthInterval);
+		healthInterval = null;
+	}
+	if (pollTimeout) {
+		clearTimeout(pollTimeout);
+		pollTimeout = null;
+	}
+	isPolling = false;
+	if (worker) await worker.stop();
+	if (sql$1) await sql$1.end();
+	if (redis) await redis.disconnect();
+	logger?.info("scheduler stopped");
+}
+//#endregion
+export { startSchedulerWorker, stopSchedulerWorker };
+
+//# sourceMappingURL=main-BHYZfBBq.mjs.map

package/dist/main-BHYZfBBq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"main-BHYZfBBq.mjs","names":["sql"],"sources":["../src/services/scheduler/main.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport { loadEnv, readBaseConfig } from \"@/index.js\";\nimport { createLogger } from \"@/index.js\";\nimport { RedisClient, type Redis } from \"@/index.js\";\nimport {\n  StreamConsumer,\n  PendingMessageScanner,\n  StreamProducer,\n  type StreamMessage,\n} from \"@/index.js\";\nimport { BaseWorker } from \"@/index.js\";\nimport {\n  STREAMS,\n  CONSUMER_GROUPS,\n  registry,\n  buildStreamEvent,\n  type NotificationScheduledPayload,\n} from \"@/index.js\";\nimport { getPriorityBucket, type WorkerOptions, LUA_SCHEDULER_POLL } from \"@/shared/index.js\";\nimport { createDatabase } from \"@/db/index.js\";\nimport { scheduledPayloads } from \"@/db/schema.js\";\nimport { inArray } from \"drizzle-orm\";\nimport { startHealthReporter } from \"@/workers/index.js\";\n// ─── Bootstrap ─────────────────────────────────────────────────────────────\n\nloadEnv();\nconst config = readBaseConfig();\n\nlet logger: ReturnType<typeof createLogger>;\nlet redis: RedisClient;\nlet sql: any;\nlet db: any;\n\nlet consumer: StreamConsumer;\nlet pendingScanner: PendingMessageScanner;\nlet worker: BaseWorker;\nlet healthInterval: NodeJS.Timeout | null = null;\nlet pollTimeout: ReturnType<typeof setTimeout> | null = null;\nlet isPolling = false;\n\nexport interface SchedulerWorkerOptions extends WorkerOptions {\n  registry: any;\n  redis: Redis;\n}\n\nexport class SchedulerWorker extends BaseWorker {\n  private readonly registry: any;\n  private readonly redisCli: Redis;\n\n  constructor(options: SchedulerWorkerOptions) {\n    super(options);\n    this.registry = options.registry;\n    this.redisCli = options.redis;\n  }\n  async process(message: StreamMessage): Promise<void> {\n    const { event } = message;\n\n    const payloadResult = this.registry.safeParsePayload(\"notification.scheduled\", event.payload);\n    if (!payloadResult.success) {\n      this.logger.warn(\n        { messageId: message.id, issues: payloadResult.error.issues },\n        \"invalid notification.scheduled payload — skipping\",\n      );\n      return;\n    }\n\n    const scheduled = payloadResult.data as NotificationScheduledPayload;\n    const scheduledAt = new Date(scheduled.scheduledAt).getTime();\n\n    const taskData = JSON.stringify({\n      taskId: scheduled.taskId,\n      enrichedEventId: scheduled.enrichedEventId,\n      traceId: event.metadata.traceId,\n    });\n\n    const shard = parseInt(scheduled.taskId.slice(-1), 16) || 0;\n    const zsetKey = `notif:scheduled:zset:${shard}`;\n    await this.redisCli.zadd(zsetKey, scheduledAt, taskData);\n    this.logger.debug(\n      { taskId: scheduled.taskId, scheduledAt: scheduled.scheduledAt, shard },\n      \"scheduled task queued in ZSET\",\n    );\n  }\n}\n\nexport async function executeSchedulerPoll(\n  redis: Redis,\n  outboundProducers: any,\n  logger: any,\n  db: any,\n): Promise<boolean> {\n  const lockKey = \"notif:lock:scheduler:poll\";\n  const lockOwner = randomUUID();\n  let acquired = false;\n  try {\n    const lockAcquired = await redis.set(lockKey, lockOwner, \"EX\", 30, \"NX\");\n    if (lockAcquired !== \"OK\") {\n      return false; // Another instance is currently polling\n    }\n    acquired = true;\n\n    const now = Date.now();\n    const visibilityTimeout = 60000; // 60 seconds\n    const perShardLimit = 100;\n    const pipeline = redis.pipeline();\n\n    for (let i = 0; i < 16; i++) {\n      pipeline.eval(\n        LUA_SCHEDULER_POLL,\n        1,\n        `notif:scheduled:zset:${i}`,\n        now,\n        perShardLimit,\n        visibilityTimeout,\n      );\n    }\n\n    const results = await pipeline.exec();\n    const perShard = results?.map((res: any) => (res[0] ? [] : ((res[1] ?? []) as string[]))) ?? [];\n    const tasks = perShard.flat();\n    // A shard that came back full may still have due tasks behind it, which is\n    // what tells the caller to poll again rather than wait for the next tick.\n    const anyShardFull = perShard.some((shard) => shard.length >= perShardLimit);\n\n    if (tasks.length === 0) return false;\n\n    const parsedTasks = tasks\n      .map((t) => {\n        try {\n          return { taskStr: t, ...JSON.parse(t) };\n        } catch (err) {\n          logger.error({ taskStr: t, err }, \"failed to parse scheduled task JSON\");\n          return null;\n        }\n      })\n      .filter(Boolean) as any[];\n    if (parsedTasks.length === 0) return false;\n\n    const taskIds = parsedTasks.map((t) => t.taskId);\n    const dbPayloads = await db\n      .select()\n      .from(scheduledPayloads)\n      .where(inArray(scheduledPayloads.taskId, taskIds));\n    const payloadMap = new Map(dbPayloads.map((row: any) => [row.taskId, row.payload]));\n\n    const batchedEvents: Record<\n      \"critical\" | \"high\" | \"normal\" | \"low\",\n      Omit<any, \"id\" | \"timestamp\">[]\n    > = {\n      critical: [],\n      high: [],\n      normal: [],\n      low: [],\n    };\n\n    const cleanupPipeline = redis.pipeline();\n    const dbCleanupIds: string[] = [];\n\n    for (let i = 0; i < parsedTasks.length; i++) {\n      const { taskStr, taskId, traceId } = parsedTasks[i];\n      const payload = payloadMap.get(taskId);\n\n      if (!payload) {\n        logger.warn({ taskId }, \"scheduled payload not found in Postgres — skipping release\");\n        const shard = parseInt(taskId.slice(-1), 16) || 0;\n        cleanupPipeline.zrem(`notif:scheduled:zset:${shard}`, taskStr);\n        continue;\n      }\n\n      const dispatchPayload = payload as any;\n      const p = getPriorityBucket(dispatchPayload.priority);\n\n      batchedEvents[p].push(\n        buildStreamEvent(\"notification.dispatched\", dispatchPayload, \"scheduler\", traceId),\n      );\n\n      dbCleanupIds.push(taskId);\n      const shard = parseInt(taskId.slice(-1), 16) || 0;\n      cleanupPipeline.zrem(`notif:scheduled:zset:${shard}`, taskStr);\n    }\n\n    // Every bucket, not a hardcoded subset: a task binned into one that is not\n    // published here has already been added to the cleanup list, so it would be\n    // deleted from Redis and Postgres without ever being sent.\n    for (const p of Object.keys(batchedEvents) as (keyof typeof batchedEvents)[]) {\n      if (batchedEvents[p].length > 0) {\n        const producer = outboundProducers[p] ?? outboundProducers[\"normal\"]!;\n        await producer!.publishBatch(batchedEvents[p]);\n      }\n    }\n\n    if (dbCleanupIds.length > 0) {\n      try {\n        await db.delete(scheduledPayloads).where(inArray(scheduledPayloads.taskId, dbCleanupIds));\n      } catch (err) {\n        logger.error(\n          { err },\n          \"failed to delete scheduled payloads from Postgres, continuing with Redis cleanup\",\n        );\n      }\n    }\n    await cleanupPipeline.exec();\n\n    logger.info({ count: parsedTasks.length }, \"scheduled tasks released to outbound\");\n\n    // \"Poll again immediately\" — the caller loops while this is true. The old\n    // test was `tasks.length === 100` against a total drawn from 16 shards, so\n    // a real backlog reported \"nothing more\" and waited for the next tick.\n    return anyShardFull;\n  } catch (err) {\n    logger.error({ err }, \"error in scheduler polling loop\");\n    return false;\n  } finally {\n    if (acquired) {\n      // Delete the lock only if we still own it\n      const lua = `\n        if redis.call(\"get\", KEYS[1]) == ARGV[1] then\n          return redis.call(\"del\", KEYS[1])\n        else\n          return 0\n        end\n      `;\n      await redis.eval(lua, 1, lockKey, lockOwner).catch(() => {});\n    }\n  }\n}\n\nexport async function startSchedulerWorker() {\n  logger = createLogger({ name: \"scheduler\", level: config.LOG_LEVEL });\n  redis = new RedisClient({ url: config.REDIS_URL, name: \"scheduler\", logger });\n  const dbData = createDatabase({ url: config.DATABASE_URL, applicationName: \"scheduler\", logger });\n  sql = dbData.sql;\n  db = dbData.db;\n  consumer = new StreamConsumer({\n    redis: redis.native,\n    stream: STREAMS.SCHEDULED,\n    group: CONSUMER_GROUPS.SCHEDULER,\n    consumer: `scheduler-${process.pid}`,\n    dlqStream: STREAMS.DEAD_LETTER,\n    batchSize: config.WORKER_CONCURRENCY,\n    logger,\n  });\n\n  pendingScanner = new PendingMessageScanner({\n    redis: redis.native,\n    stream: STREAMS.SCHEDULED,\n    group: CONSUMER_GROUPS.SCHEDULER,\n    consumer: `scheduler-${process.pid}`,\n    logger,\n  });\n\n  const outboundProducers = {\n    critical: new StreamProducer({\n      redis: redis.native,\n      stream: STREAMS.OUTBOUND_CRITICAL,\n      logger,\n    }),\n    normal: new StreamProducer({ redis: redis.native, stream: STREAMS.OUTBOUND_NORMAL, logger }),\n    low: new StreamProducer({ redis: redis.native, stream: STREAMS.OUTBOUND_LOW, logger }),\n  };\n\n  // ─── Stage 4a: Scheduled notification processor ─────────────────────────────\n  //\n  // Reads from SCHEDULED stream, parses, and queues tasks in a Redis ZSET.\n  // A background polling interval releases tasks when they are due.\n\n  worker = new SchedulerWorker({\n    consumer,\n    pendingScanner,\n    logger,\n    concurrency: config.WORKER_CONCURRENCY,\n    registry,\n    redis: redis.native,\n  });\n\n  // ─── Polling Loop ─────────────────────────────────────────────────────────\n  isPolling = true;\n  const pollLoop = async (): Promise<void> => {\n    if (!isPolling) return;\n    try {\n      const hasMore = await executeSchedulerPoll(redis.native, outboundProducers, logger, db);\n      if (isPolling) {\n        pollTimeout = setTimeout(() => void pollLoop(), hasMore ? 0 : 5000);\n      }\n    } catch (err) {\n      logger.error({ err }, \"scheduler poll loop error\");\n      if (isPolling) {\n        pollTimeout = setTimeout(() => void pollLoop(), 5000);\n      }\n    }\n  };\n  void pollLoop();\n\n  // ─── Health check interval ──────────────────────────────────────────────────\n\n  healthInterval = startHealthReporter(\"scheduler\", worker, redis, logger);\n\n  logger.info({ env: config.NODE_ENV }, \"scheduler starting\");\n  await worker.start();\n}\n\n// ─── Shutdown ──────────────────────────────────────────────────────────────\n\nexport async function stopSchedulerWorker(): Promise<void> {\n  logger?.info(\"shutdown initiated\");\n  if (healthInterval) {\n    clearInterval(healthInterval);\n    healthInterval = null;\n  }\n  if (pollTimeout) {\n    clearTimeout(pollTimeout);\n    pollTimeout = null;\n  }\n  isPolling = false;\n  if (worker) await worker.stop();\n  if (sql) await sql.end();\n  if (redis) await redis.disconnect();\n  logger?.info(\"scheduler stopped\");\n}\n"],"mappings":"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"}

package/dist/main-BIcKzWHE.mjs

@@ -0,0 +1,430 @@
+import { E as UserRepository, J as PendingMessageScanner, Jt as buildStreamEvent, S as PreferenceRepository, T as TemplateRepository, W as getPriorityBucket, X as StreamProducer, Y as StreamConsumer, Yt as CONSUMER_GROUPS, Zt as INBOUND_STREAMS, an as registry, c as BaseWorker, en as STREAMS, et as createLogger, g as TemplateCache, hn as readBaseConfig, it as createDatabase, k as RedisClient, pn as loadEnv, rt as IdempotencyGuard, u as startHealthReporter, x as ContactRepository } from "./src-DrSN2wCg.mjs";
+//#region src/services/enricher/main.ts
+loadEnv();
+const config = readBaseConfig();
+let logger;
+let redis;
+let sql;
+let db;
+let consumer;
+let pendingScanner;
+let worker;
+let healthInterval = null;
+var EnricherWorker = class extends BaseWorker {
+	producers;
+	idempotency;
+	userRepo;
+	prefRepo;
+	contactRepo;
+	templateCache;
+	userBatch = [];
+	batchTimer = null;
+	eventBuffer = [];
+	flushTimer = null;
+	contactBatch = [];
+	contactBatchTimer = null;
+	async loadContacts(projectId, userIds) {
+		return new Promise((resolve, reject) => {
+			this.contactBatch.push({
+				projectId,
+				userIds,
+				resolve,
+				reject
+			});
+			if (this.contactBatch.length >= 500) {
+				if (this.contactBatchTimer) clearTimeout(this.contactBatchTimer);
+				this.flushContactBatch();
+			} else if (!this.contactBatchTimer) this.contactBatchTimer = setTimeout(() => void this.flushContactBatch(), 10);
+		});
+	}
+	async flushContactBatch() {
+		const batch = this.contactBatch;
+		this.contactBatch = [];
+		this.contactBatchTimer = null;
+		if (batch.length === 0) return;
+		try {
+			const byProject = /* @__PURE__ */ new Map();
+			for (const b of batch) {
+				if (!byProject.has(b.projectId)) byProject.set(b.projectId, []);
+				byProject.get(b.projectId).push(b);
+			}
+			for (const [projectId, items] of byProject) {
+				const userIds = Array.from(new Set(items.flatMap((i) => i.userIds)));
+				const contactsMap = await this.contactRepo.findActiveByUserIds(projectId, userIds);
+				for (const item of items) item.resolve(contactsMap);
+			}
+		} catch (err) {
+			for (const b of batch) b.reject(err);
+		}
+	}
+	constructor(options) {
+		super(options);
+		this.producers = options.producers;
+		this.idempotency = options.idempotency;
+		this.userRepo = options.userRepo;
+		this.prefRepo = options.prefRepo;
+		this.contactRepo = options.contactRepo;
+		this.templateCache = options.templateCache;
+		this.flushTimer = setInterval(() => void this.flushWorkerBuffers(), 100);
+	}
+	async stop() {
+		if (this.batchTimer) {
+			clearTimeout(this.batchTimer);
+			this.batchTimer = null;
+		}
+		if (this.flushTimer) {
+			clearInterval(this.flushTimer);
+			this.flushTimer = null;
+		}
+		if (this.contactBatchTimer) {
+			clearTimeout(this.contactBatchTimer);
+			this.contactBatchTimer = null;
+		}
+		await this.flushContactBatch();
+		await this.flushUserBatch();
+		await this.flushWorkerBuffers();
+		await super.stop();
+	}
+	async flushWorkerBuffers() {
+		if (this.eventBuffer.length === 0) return;
+		const events = this.eventBuffer;
+		this.eventBuffer = [];
+		try {
+			const byProducer = /* @__PURE__ */ new Map();
+			for (const e of events) {
+				if (!byProducer.has(e.producer)) byProducer.set(e.producer, []);
+				byProducer.get(e.producer).push(e);
+			}
+			for (const [producer, batch] of byProducer) {
+				await producer.publishBatch(batch.map((b) => b.event));
+				for (const b of batch) b.resolve();
+			}
+		} catch (err) {
+			this.logger.error({ err }, "failed to flush events in EnricherWorker");
+			for (const e of events) e.reject(err);
+		}
+	}
+	async loadUser(projectId, userId) {
+		return new Promise((resolve, reject) => {
+			this.userBatch.push({
+				projectId,
+				userId,
+				resolve,
+				reject
+			});
+			if (this.userBatch.length >= 500) {
+				if (this.batchTimer) clearTimeout(this.batchTimer);
+				this.flushUserBatch();
+			} else if (!this.batchTimer) this.batchTimer = setTimeout(() => {
+				this.flushUserBatch();
+			}, 10);
+		});
+	}
+	async flushUserBatch() {
+		const batch = this.userBatch;
+		this.userBatch = [];
+		this.batchTimer = null;
+		const byProject = /* @__PURE__ */ new Map();
+		for (const b of batch) {
+			if (!byProject.has(b.projectId)) byProject.set(b.projectId, []);
+			byProject.get(b.projectId).push(b);
+		}
+		for (const [projectId, reqs] of byProject.entries()) try {
+			const uniqueIds = Array.from(new Set(reqs.map((r) => r.userId)));
+			const profiles = await this.userRepo.findRecordsByIds(projectId, uniqueIds);
+			const profileMap = new Map(profiles.map((p) => [p.userId, p]));
+			for (const req of reqs) req.resolve(profileMap.get(req.userId) || null);
+		} catch (err) {
+			for (const req of reqs) req.reject(err);
+		}
+	}
+	async process(message) {
+		const { event } = message;
+		const publishPromises = [];
+		let isRequested = true;
+		const requestedResult = registry.safeParsePayload("notification.requested", event.payload);
+		let createdResult = null;
+		if (!requestedResult.success) {
+			createdResult = registry.safeParsePayload("notification.created", event.payload);
+			isRequested = false;
+		}
+		if (!isRequested && (!createdResult || !createdResult.success)) {
+			const issues = createdResult ? createdResult.error.issues : requestedResult.error.issues;
+			this.logger.warn({
+				messageId: message.id,
+				issues
+			}, "invalid payload — skipping");
+			return;
+		}
+		if (!isRequested) {
+			const raw = createdResult.data;
+			const dedupeId = `${raw.projectId}:${raw.idempotencyKey ?? event.id}`;
+			if (!await this.idempotency.checkAndMark(dedupeId, 60)) return;
+			try {
+				const profile = await this.userRepo.findRecordById(raw.projectId, raw.recipientId);
+				if (!profile) return;
+				const prefs = await this.prefRepo.findByUserId(raw.projectId, raw.recipientId);
+				const optedOutTypes = new Set(prefs.filter((p) => !p.optedIn).map((p) => p.eventType));
+				const enrichedPayload = {
+					projectId: raw.projectId,
+					rawEventId: event.id,
+					recipientId: raw.recipientId,
+					channel: raw.channel,
+					priority: raw.priority,
+					templateId: raw.templateId,
+					templateVariables: raw.payload,
+					recipient: {
+						id: profile.userId,
+						email: profile.email ?? void 0,
+						locale: profile.language ?? "en",
+						timezone: profile.timezone ?? "UTC",
+						preferences: {
+							optedOut: optedOutTypes.has(event.type) || profile.preferences.topics?.[event.type] === false,
+							channels: Object.entries(profile.preferences.channels ?? {}).filter(([_, enabled]) => !enabled).map(([channel]) => channel),
+							quietHours: profile.preferences.quietHours
+						}
+					},
+					scheduledAt: raw.scheduledAt
+				};
+				const p = getPriorityBucket(raw.priority);
+				const producer = this.producers[p] ?? this.producers["normal"];
+				publishPromises.push(new Promise((resolve, reject) => {
+					this.eventBuffer.push({
+						producer,
+						event: buildStreamEvent("notification.enriched", enrichedPayload, "enricher", event.metadata.traceId),
+						resolve,
+						reject
+					});
+				}));
+				this.logger.info({
+					messageId: message.id,
+					eventId: event.id,
+					recipientId: raw.recipientId
+				}, "event enriched");
+			} catch (err) {
+				throw err;
+			}
+			await Promise.all(publishPromises).catch(async (err) => {
+				await this.idempotency.unmark(dedupeId).catch(() => {});
+				throw err;
+			});
+			await this.idempotency.markProcessed(dedupeId);
+			return;
+		}
+		const raw = requestedResult.data;
+		const dedupeId = `${raw.projectId}:${raw.idempotencyKey ?? event.id}`;
+		if (!await this.idempotency.checkAndMark(dedupeId, 60)) return;
+		try {
+			let userIds = [];
+			if (raw.target.type === "user") userIds = [raw.target.userId];
+			else if (raw.target.type === "segment") {
+				userIds = await this.userRepo.findUsersBySegment(raw.projectId, raw.target.segment);
+				this.logger.info({
+					segment: raw.target.segment,
+					count: userIds.length
+				}, "Resolved segment");
+			} else if (raw.target.type === "topic") {
+				userIds = await this.userRepo.findUsersByTopic(raw.projectId, raw.target.topic);
+				this.logger.info({
+					topic: raw.target.topic,
+					count: userIds.length
+				}, "Resolved topic");
+			} else this.logger.warn({ target: raw.target }, "Segment/topic resolution not fully implemented");
+			const maxUsers = readBaseConfig().SEGMENT_MAX_USERS;
+			if (userIds.length > maxUsers) {
+				this.logger.error({
+					count: userIds.length,
+					max: maxUsers,
+					projectId: raw.projectId,
+					eventId: event.id
+				}, "Segment fan-out exceeds maximum allowed limit");
+				const p = getPriorityBucket(raw.priority ?? "normal");
+				await (this.producers[p] ?? this.producers.normal).publish(buildStreamEvent("notification.failed", {
+					projectId: raw.projectId,
+					rawEventId: event.id,
+					error: `Segment fan-out of ${userIds.length} exceeds limit of ${maxUsers}`
+				}, "enricher", event.metadata.traceId));
+				return;
+			}
+			const topics = (raw.templateId ? await this.templateCache.getCachedTemplate(raw.projectId, raw.templateId) : null)?.topics ?? [];
+			const channels = raw.channels && raw.channels.length > 0 ? raw.channels : ["email"];
+			const isFallback = raw.fallback === true;
+			const channelsToProcess = isFallback ? [channels[0]] : channels;
+			const fallbackChain = isFallback ? channels.slice(1) : void 0;
+			const chunkArray = (arr, size) => Array.from({ length: Math.ceil(arr.length / size) }, (v, i) => arr.slice(i * size, i * size + size));
+			const chunks = chunkArray(userIds, 500);
+			for (const chunk of chunks) {
+				const profiles = (await Promise.all(chunk.map((id) => this.loadUser(raw.projectId, id)))).filter(Boolean);
+				const contactsByUser = await this.loadContacts(raw.projectId, profiles.map((profile) => profile.userId));
+				const batchedEvents = {
+					critical: [],
+					high: [],
+					normal: [],
+					low: []
+				};
+				for (const profile of profiles) for (const channel of channelsToProcess) {
+					const channelContacts = (contactsByUser.get(profile.userId) ?? []).filter((contact) => contact.channel === channel);
+					const destinations = channel === "push" ? [void 0] : channelContacts.map((c) => c.target);
+					if (destinations.length === 0) {
+						this.logger.info({
+							recipientId: profile.userId,
+							channel
+						}, "no active contact for channel");
+						continue;
+					}
+					for (const destination of destinations) {
+						const enrichedPayload = {
+							projectId: raw.projectId,
+							rawEventId: event.id,
+							recipientId: profile.userId,
+							channel,
+							priority: "normal",
+							templateId: raw.templateId,
+							templateVariables: raw.data,
+							aiPrompts: raw.aiPrompts,
+							recipient: {
+								id: profile.userId,
+								email: channel === "email" ? destination ?? profile.email ?? void 0 : profile.email ?? void 0,
+								phone: channel === "sms" ? destination : void 0,
+								webhook: channel === "webhook" ? destination : void 0,
+								locale: profile.language ?? "en",
+								timezone: profile.timezone ?? "UTC",
+								preferences: {
+									optedOut: topics.some((t) => profile.preferences.topics?.[t] === false),
+									channels: Object.entries(profile.preferences.channels ?? {}).filter(([_, enabled]) => !enabled).map(([channel]) => channel),
+									quietHours: profile.preferences.quietHours
+								}
+							},
+							scheduledAt: raw.scheduledAt,
+							fallbackChain: fallbackChain?.length ? fallbackChain : void 0,
+							campaignId: raw.campaignId
+						};
+						const msgPriority = raw.priority ?? "normal";
+						const p = getPriorityBucket(msgPriority);
+						enrichedPayload.priority = msgPriority;
+						batchedEvents[p].push(buildStreamEvent("notification.enriched", enrichedPayload, "enricher", event.metadata.traceId));
+					}
+				}
+				for (const p of [
+					"critical",
+					"normal",
+					"low"
+				]) if (batchedEvents[p].length > 0) {
+					const producer = this.producers[p] ?? this.producers.normal;
+					for (const ev of batchedEvents[p]) publishPromises.push(new Promise((resolve, reject) => {
+						this.eventBuffer.push({
+							producer,
+							event: ev,
+							resolve,
+							reject
+						});
+					}));
+				}
+			}
+			this.logger.info({
+				messageId: message.id,
+				eventId: event.id,
+				target: raw.target.type,
+				traceId: event.metadata.traceId
+			}, "event enriched");
+		} catch (err) {
+			throw err;
+		}
+		await Promise.all(publishPromises).catch(async (err) => {
+			await this.idempotency.unmark(dedupeId).catch(() => {});
+			throw err;
+		});
+		await this.idempotency.markProcessed(dedupeId);
+	}
+};
+async function startEnricherWorker() {
+	logger = createLogger({
+		name: "enricher",
+		level: config.LOG_LEVEL
+	});
+	redis = new RedisClient({
+		url: config.REDIS_URL,
+		name: "enricher",
+		logger
+	});
+	const dbData = createDatabase({
+		url: config.DATABASE_URL,
+		applicationName: "enricher",
+		logger
+	});
+	sql = dbData.sql;
+	db = dbData.db;
+	consumer = new StreamConsumer({
+		redis: redis.native,
+		stream: INBOUND_STREAMS,
+		group: CONSUMER_GROUPS.ENRICHER,
+		consumer: `enricher-${process.pid}`,
+		dlqStream: STREAMS.DEAD_LETTER,
+		batchSize: config.WORKER_CONCURRENCY,
+		logger
+	});
+	pendingScanner = new PendingMessageScanner({
+		redis: redis.native,
+		stream: INBOUND_STREAMS,
+		group: CONSUMER_GROUPS.ENRICHER,
+		consumer: `enricher-${process.pid}`,
+		logger
+	});
+	const producers = {
+		critical: new StreamProducer({
+			redis: redis.native,
+			stream: STREAMS.ENRICHED_CRITICAL,
+			logger
+		}),
+		normal: new StreamProducer({
+			redis: redis.native,
+			stream: STREAMS.ENRICHED_NORMAL,
+			logger
+		}),
+		low: new StreamProducer({
+			redis: redis.native,
+			stream: STREAMS.ENRICHED_LOW,
+			logger
+		})
+	};
+	const idempotency = new IdempotencyGuard({
+		redis: redis.native,
+		keyPrefix: "notif:processed:enricher",
+		ttlSeconds: 86400
+	});
+	const userRepo = new UserRepository(db);
+	const prefRepo = new PreferenceRepository(db);
+	const contactRepo = new ContactRepository(db);
+	const templateCache = new TemplateCache(new TemplateRepository(db));
+	worker = new EnricherWorker({
+		consumer,
+		pendingScanner,
+		logger,
+		maxRetriesBeforeDlq: 5,
+		concurrency: config.WORKER_CONCURRENCY,
+		producers,
+		idempotency,
+		userRepo,
+		prefRepo,
+		contactRepo,
+		templateCache
+	});
+	healthInterval = startHealthReporter("enricher", worker, redis, logger);
+	logger.info({ env: config.NODE_ENV }, "enricher starting");
+	await worker.start();
+}
+async function stopEnricherWorker() {
+	logger?.info("shutdown initiated");
+	if (healthInterval) {
+		clearInterval(healthInterval);
+		healthInterval = null;
+	}
+	if (worker) await worker.stop();
+	if (sql) await sql.end();
+	if (redis) await redis.disconnect();
+	logger?.info("enricher stopped");
+}
+//#endregion
+export { startEnricherWorker, stopEnricherWorker };
+
+//# sourceMappingURL=main-BIcKzWHE.mjs.map