notifkit 0.1.0

package/dist/main-Ok9cQJ7q.mjs

@@ -0,0 +1,1636 @@
+import { $t as PUBSUB_CHANNELS, C as ProjectRepository, D as WorkflowRepository, E as UserRepository, Ft as CreateWorkflowSchema, G as normaliseTarget, Gt as UpdateUserSchema, Jt as buildStreamEvent, K as LRUCache, Mt as AddContactSchema, Nt as AddUserSchema, Pt as ContactChannelSchema, Q as metrics, Rt as NotifyRequestSchema, T as TemplateRepository, Ut as TriggerWorkflowSchema, Vt as SyncTemplatesSchema, W as getPriorityBucket, X as StreamProducer, Z as getMetricsRegistry, ct as projectApiKeys, dt as suppressions, en as STREAMS, et as createLogger, ft as userTopicPreferences, hn as readBaseConfig, it as createDatabase, k as RedisClient, lt as projects, mt as workflowDefinitions, p as verifyUnsubscribeToken, pn as loadEnv, pt as users, q as globalEmitter, st as messageLogs, ut as scheduledPayloads, w as SegmentRepository, x as ContactRepository, zt as PreferencesSchema } from "./src-DrSN2wCg.mjs";
+import { z } from "zod";
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { and, desc, eq, inArray, isNotNull, like, lt, or, sql } from "drizzle-orm";
+import { createServer } from "node:http";
+//#region src/services/api/http.ts
+async function readRawBody(req) {
+	return await new Promise((resolve, reject) => {
+		const chunks = [];
+		let totalLength = 0;
+		const MAX_PAYLOAD_SIZE = 5242880;
+		req.on("data", (chunk) => {
+			totalLength += chunk.length;
+			if (totalLength > MAX_PAYLOAD_SIZE) {
+				req.destroy();
+				reject(new HttpError(413, "payload_too_large"));
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+		req.on("error", reject);
+	});
+}
+async function readJsonBody(req) {
+	const raw = await readRawBody(req);
+	if (raw.trim() === "") return void 0;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		throw new HttpError(400, "malformed_json");
+	}
+}
+function sendJson(res, status, body) {
+	const payload = JSON.stringify(body);
+	res.writeHead(status, {
+		"Content-Type": "application/json",
+		"Content-Length": Buffer.byteLength(payload)
+	});
+	res.end(payload);
+}
+function sendNoContent(res) {
+	res.writeHead(204).end();
+}
+/** Turn a Zod error into a 400 response with field-level issues. */
+function sendValidationError(res, error) {
+	sendJson(res, 400, {
+		error: "validation_error",
+		issues: error.issues.map((i) => ({
+			path: i.path.join("."),
+			message: i.message
+		}))
+	});
+}
+/** A thrown HttpError short-circuits a handler with a specific status/body. */
+var HttpError = class extends Error {
+	status;
+	code;
+	constructor(status, code, message) {
+		super(message ?? code);
+		this.status = status;
+		this.code = code;
+	}
+};
+//#endregion
+//#region src/services/api/router.ts
+/**
+* Minimal path router with `:param` capture — enough for the REST surface here
+* without pulling in a framework. First match wins.
+*/
+var Router = class {
+	routes = [];
+	add(method, pattern, handler) {
+		this.routes.push({
+			method,
+			segments: split(pattern),
+			handler
+		});
+		return this;
+	}
+	get(p, h) {
+		return this.add("GET", p, h);
+	}
+	post(p, h) {
+		return this.add("POST", p, h);
+	}
+	patch(p, h) {
+		return this.add("PATCH", p, h);
+	}
+	put(p, h) {
+		return this.add("PUT", p, h);
+	}
+	delete(p, h) {
+		return this.add("DELETE", p, h);
+	}
+	/** Returns the matched handler + captured params, or null. */
+	match(method, pathname) {
+		const parts = split(pathname);
+		for (const route of this.routes) {
+			if (route.method !== method) continue;
+			if (route.segments.length !== parts.length) continue;
+			const params = {};
+			let ok = true;
+			for (let i = 0; i < route.segments.length; i++) {
+				const seg = route.segments[i];
+				const part = parts[i];
+				if (seg.startsWith(":")) params[seg.slice(1)] = decodeURIComponent(part);
+				else if (seg !== part) {
+					ok = false;
+					break;
+				}
+			}
+			if (ok) return {
+				handler: route.handler,
+				params
+			};
+		}
+		return null;
+	}
+};
+function split(path) {
+	return path.split("/").filter((s) => s.length > 0);
+}
+//#endregion
+//#region src/services/api/handlers.ts
+const IngestEventSchema = z.object({
+	name: z.string().min(1),
+	properties: z.record(z.string(), z.unknown())
+});
+/** Map an inline user's contact arrays into (channel, target) pairs. */
+function contactsOf(user) {
+	return [
+		...(user.email ?? []).map((target) => ({
+			channel: "email",
+			target
+		})),
+		...(user.phone ?? []).map((target) => ({
+			channel: "sms",
+			target
+		})),
+		...(user.pushToken ?? []).map((target) => ({
+			channel: "push",
+			target
+		}))
+	];
+}
+/** Persist user records + their contacts in bulk. Shared by addUser and inline notify. */
+async function persistUsers(deps, users, projectId) {
+	const usersList = users.map((u) => ({
+		userId: u.id,
+		language: u.language ?? "en",
+		timezone: u.timezone ?? "UTC",
+		email: u.email?.[0] ?? null,
+		segments: u.segments ?? [],
+		preferences: u.preferences ?? {}
+	}));
+	const contactsList = [];
+	for (const u of users) for (const c of contactsOf(u)) contactsList.push({
+		userId: u.id,
+		channel: c.channel,
+		target: c.target,
+		preferences: {}
+	});
+	await deps.db.transaction(async (tx) => {
+		const txUserRepo = deps.userRepo.constructor.name === "Object" ? deps.userRepo : new deps.userRepo.constructor(tx);
+		const txContactRepo = deps.contactRepo.constructor.name === "Object" ? deps.contactRepo : new deps.contactRepo.constructor(tx);
+		await txUserRepo.upsertManyFull(projectId, usersList);
+		await txContactRepo.upsertMany(projectId, contactsList);
+	});
+}
+function getQueryParam(ctx, key) {
+	if (!ctx.query) return void 0;
+	if (typeof ctx.query.get === "function") return ctx.query.get(key) ?? void 0;
+	return ctx.query[key] ?? void 0;
+}
+function createHandlers(deps) {
+	const { logger } = deps;
+	async function syncTemplates(req, res, ctx) {
+		const parsed = SyncTemplatesSchema.safeParse(await readJsonBody(req));
+		if (!parsed.success) return sendValidationError(res, parsed.error);
+		const synced = await deps.templateRepo.upsertMany(ctx.projectId, parsed.data.templates.map((t) => ({
+			id: t.id,
+			channel: t.channel,
+			topics: t.topic ?? [],
+			content: t.content,
+			aiPrompts: t.aiPrompts
+		})));
+		for (const t of parsed.data.templates) await deps.redis.native.publish("template.invalidated", `${ctx.projectId}:${t.id}`);
+		logger.info({ synced }, "templates synced");
+		sendJson(res, 200, { synced });
+	}
+	async function addUser(req, res, ctx) {
+		const parsed = AddUserSchema.safeParse(await readJsonBody(req));
+		if (!parsed.success) return sendValidationError(res, parsed.error);
+		await persistUsers(deps, [parsed.data], ctx.projectId);
+		logger.info({ userId: parsed.data.id }, "user upserted");
+		sendJson(res, 201, { id: parsed.data.id });
+	}
+	async function updateUser(req, res, ctx) {
+		const userId = ctx.params.id;
+		const parsed = UpdateUserSchema.safeParse(await readJsonBody(req));
+		if (!parsed.success) return sendValidationError(res, parsed.error);
+		const patch = parsed.data;
+		if (!await deps.userRepo.updatePartial(ctx.projectId, userId, {
+			language: patch.language,
+			timezone: patch.timezone,
+			email: patch.email?.[0],
+			segments: patch.segments,
+			preferences: patch.preferences
+		})) return sendJson(res, 404, {
+			error: "user_not_found",
+			id: userId
+		});
+		for (const c of contactsOf({
+			id: userId,
+			...patch
+		})) await deps.contactRepo.upsert(ctx.projectId, userId, c.channel, c.target);
+		logger.info({ userId }, "user updated");
+		sendJson(res, 200, { id: userId });
+	}
+	async function deleteUser(_req, res, ctx) {
+		const userId = ctx.params.id;
+		if (!await deps.userRepo.delete(ctx.projectId, userId)) return sendJson(res, 404, {
+			error: "user_not_found",
+			id: userId
+		});
+		logger.info({ userId }, "user deleted");
+		sendNoContent(res);
+	}
+	async function addContact(req, res, ctx) {
+		const userId = ctx.params.id;
+		const parsed = AddContactSchema.safeParse(await readJsonBody(req));
+		if (!parsed.success) return sendValidationError(res, parsed.error);
+		if (!await deps.userRepo.findById(ctx.projectId, userId)) return sendJson(res, 404, {
+			error: "user_not_found",
+			id: userId
+		});
+		await deps.contactRepo.upsert(ctx.projectId, userId, parsed.data.channel, parsed.data.target, parsed.data.preferences ?? {});
+		logger.info({
+			userId,
+			channel: parsed.data.channel
+		}, "contact added");
+		sendJson(res, 201, {
+			userId,
+			channel: parsed.data.channel,
+			target: parsed.data.target
+		});
+	}
+	async function deleteContact(_req, res, ctx) {
+		const userId = ctx.params.id;
+		const channelResult = ContactChannelSchema.safeParse(ctx.params.channel);
+		if (!channelResult.success) return sendJson(res, 400, {
+			error: "invalid_channel",
+			channel: ctx.params.channel
+		});
+		if (!await deps.contactRepo.delete(ctx.projectId, userId, channelResult.data, ctx.params.target)) return sendJson(res, 404, { error: "contact_not_found" });
+		logger.info({
+			userId,
+			channel: channelResult.data
+		}, "contact deleted");
+		sendNoContent(res);
+	}
+	async function notify(req, res, ctx) {
+		const parsed = NotifyRequestSchema.safeParse(await readJsonBody(req));
+		if (!parsed.success) return sendValidationError(res, parsed.error);
+		const body = parsed.data;
+		let targets = [];
+		if (body.user !== void 0) {
+			const users = Array.isArray(body.user) ? body.user : [body.user];
+			const inlineUsersToSync = [];
+			for (const u of users) if (typeof u === "string") targets.push({
+				type: "user",
+				userId: u
+			});
+			else {
+				inlineUsersToSync.push(u);
+				targets.push({
+					type: "user",
+					userId: u.id
+				});
+			}
+			if (inlineUsersToSync.length > 0) try {
+				await persistUsers(deps, inlineUsersToSync, ctx.projectId);
+			} catch (err) {
+				deps.logger.error({ err }, "inline user bulk sync failed");
+			}
+		} else if (body.segment !== void 0) targets.push({
+			type: "segment",
+			segment: body.segment
+		});
+		else targets.push({
+			type: "topic",
+			topic: body.topic
+		});
+		const baseNotificationId = req.headers["x-idempotency-key"] || randomUUID();
+		const priority = body.priority ?? "normal";
+		const p = getPriorityBucket(priority);
+		const producer = deps.producers[p] ?? deps.producers.normal;
+		const messageIds = [];
+		let lastNotificationId = "";
+		const CHUNK_SIZE = 1e3;
+		for (let chunkStart = 0; chunkStart < targets.length; chunkStart += CHUNK_SIZE) {
+			const events = targets.slice(chunkStart, chunkStart + CHUNK_SIZE).map((target, idx) => {
+				const i = chunkStart + idx;
+				const notificationId = targets.length > 1 ? `${baseNotificationId}-${i}` : baseNotificationId;
+				lastNotificationId = notificationId;
+				const payload = {
+					projectId: ctx.projectId,
+					target,
+					templateId: body.template,
+					priority,
+					channels: body.channels,
+					data: body.data ?? {},
+					aiPrompts: body.aiPrompts,
+					fallback: body.fallback ?? false,
+					scheduledAt: body.sendAt,
+					idempotencyKey: notificationId,
+					campaignId: body.campaign
+				};
+				return buildStreamEvent("notification.requested", payload, "api", notificationId);
+			});
+			const { messageIds: chunkMessageIds } = await producer.publishBatch(events);
+			messageIds.push(...chunkMessageIds);
+		}
+		logger.info({
+			count: targets.length,
+			priority: p
+		}, "notification requested");
+		metrics.messagesPublished.inc({
+			channel: "api",
+			priority: p
+		}, targets.length);
+		if (targets.length === 1) sendJson(res, 202, {
+			messageId: messageIds[0],
+			notificationId: lastNotificationId,
+			target: targets[0],
+			...body.campaign ? { campaign: body.campaign } : {}
+		});
+		else sendJson(res, 202, {
+			messageIds,
+			notificationIdsBase: baseNotificationId,
+			batchSize: targets.length,
+			...body.campaign ? { campaign: body.campaign } : {}
+		});
+	}
+	async function cancelNotification(req, res, ctx) {
+		const { taskId } = ctx.params;
+		if (!taskId) return sendJson(res, 400, { error: "missing_task_id" });
+		const rows = await deps.db.select({ payload: scheduledPayloads.payload }).from(scheduledPayloads).where(eq(scheduledPayloads.taskId, taskId)).limit(1);
+		if (rows.length === 0) return sendJson(res, 404, {
+			error: "not_found",
+			message: "Task not found or already processed"
+		});
+		if (rows[0].payload.projectId !== ctx.projectId) return sendJson(res, 404, {
+			error: "not_found",
+			message: "Task not found or already processed"
+		});
+		if ((await deps.db.delete(scheduledPayloads).where(eq(scheduledPayloads.taskId, taskId)).returning({ taskId: scheduledPayloads.taskId })).length > 0) {
+			globalEmitter.emit("notification:canceled", {
+				projectId: ctx.projectId,
+				taskId
+			});
+			sendJson(res, 200, { success: true });
+		} else sendJson(res, 404, {
+			error: "not_found",
+			message: "Task not found or already processed"
+		});
+	}
+	async function triggerWorkflow(req, res, ctx) {
+		const parsed = TriggerWorkflowSchema.safeParse(await readJsonBody(req));
+		if (!parsed.success) return sendValidationError(res, parsed.error);
+		const input = { ...parsed.data.input ?? {} };
+		if (parsed.data.user) if (typeof parsed.data.user === "string") input.user = {
+			id: parsed.data.user,
+			...typeof input.user === "object" && input.user ? input.user : {}
+		};
+		else {
+			try {
+				await persistUsers(deps, [parsed.data.user], ctx.projectId);
+			} catch (err) {
+				deps.logger.error({ err }, "inline user sync for workflow failed");
+			}
+			input.user = {
+				id: parsed.data.user.id,
+				...typeof input.user === "object" && input.user ? input.user : {}
+			};
+		}
+		const instanceId = randomUUID();
+		const messageId = await deps.producers.workflow.publish(buildStreamEvent("workflow.triggered", {
+			projectId: ctx.projectId,
+			instanceId,
+			name: parsed.data.name,
+			input
+		}, "api", instanceId));
+		logger.info({
+			messageId,
+			instanceId,
+			workflowName: parsed.data.name
+		}, "workflow triggered");
+		sendJson(res, 202, {
+			messageId,
+			instanceId
+		});
+	}
+	async function ingestEvent(req, res, ctx) {
+		const tsStr = req.headers["x-timestamp"];
+		const expiryStr = req.headers["x-expiry"];
+		if (tsStr && expiryStr) {
+			if (Date.now() > new Date(tsStr).getTime() + parseInt(expiryStr, 10) * 1e3) {
+				sendJson(res, 400, {
+					error: "event_expired",
+					message: "Webhook event is expired"
+				});
+				return;
+			}
+		}
+		const parsed = IngestEventSchema.safeParse(await readJsonBody(req));
+		if (!parsed.success) return sendValidationError(res, parsed.error);
+		const eventId = randomUUID();
+		const messageId = await deps.producers.events.publish(buildStreamEvent("event.received", {
+			projectId: ctx.projectId,
+			eventName: parsed.data.name,
+			payload: parsed.data.properties
+		}, "api", eventId));
+		logger.info({
+			messageId,
+			eventId,
+			eventName: parsed.data.name
+		}, "event received");
+		sendJson(res, 202, {
+			messageId,
+			eventId
+		});
+	}
+	async function getEventsStream(req, res, ctx) {
+		res.writeHead(200, {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive"
+		});
+		res.write("retry: 10000\n\n");
+		const onDelivered = (taskId, providerMessageId, channel, eventProjectId) => {
+			if (eventProjectId && eventProjectId !== ctx.projectId) return;
+			res.write(`event: delivery:delivered\n`);
+			res.write(`data: ${JSON.stringify({
+				taskId,
+				providerMessageId,
+				channel
+			})}\n\n`);
+		};
+		const onFailed = (taskId, error, channel, eventProjectId) => {
+			if (eventProjectId && eventProjectId !== ctx.projectId) return;
+			res.write(`event: delivery:failed\n`);
+			res.write(`data: ${JSON.stringify({
+				taskId,
+				error,
+				channel
+			})}\n\n`);
+		};
+		globalEmitter.on("delivery:delivered", onDelivered);
+		globalEmitter.on("delivery:failed", onFailed);
+		req.on("close", () => {
+			globalEmitter.off("delivery:delivered", onDelivered);
+			globalEmitter.off("delivery:failed", onFailed);
+		});
+	}
+	async function getNotificationLogs(req, res, ctx) {
+		const limitParam = parseInt(ctx.query.get("limit") || "50", 10);
+		const limit = isNaN(limitParam) ? 50 : Math.min(limitParam, 100);
+		const cursor = ctx.query.get("cursor");
+		const templateId = ctx.query.get("templateId");
+		const workflowInstanceId = ctx.query.get("workflowInstanceId");
+		const channel = ctx.query.get("channel");
+		const status = ctx.query.get("status");
+		const taskId = ctx.query.get("taskId");
+		const search = ctx.query.get("search");
+		const conditions = [eq(messageLogs.projectId, ctx.projectId)];
+		if (templateId) conditions.push(eq(messageLogs.templateId, templateId));
+		if (workflowInstanceId) conditions.push(eq(messageLogs.workflowInstanceId, workflowInstanceId));
+		if (channel) conditions.push(eq(messageLogs.channel, channel));
+		if (status) conditions.push(eq(messageLogs.status, status));
+		if (taskId) conditions.push(eq(messageLogs.taskId, taskId));
+		if (search) conditions.push(or(like(messageLogs.taskId, `%${search}%`), like(messageLogs.templateId, `%${search}%`), like(messageLogs.providerMessageId, `%${search}%`)));
+		if (cursor) {
+			const cursorDate = new Date(parseInt(cursor, 10));
+			conditions.push(lt(messageLogs.timestamp, cursorDate));
+		}
+		const logs = await deps.db.select().from(messageLogs).where(and(...conditions)).orderBy(desc(messageLogs.timestamp)).limit(limit * 2);
+		const deduplicatedMap = /* @__PURE__ */ new Map();
+		for (const log of logs) if (!deduplicatedMap.has(log.taskId)) deduplicatedMap.set(log.taskId, log);
+		else if (deduplicatedMap.get(log.taskId).status === "dispatched" && log.status !== "dispatched") deduplicatedMap.set(log.taskId, log);
+		sendJson(res, 200, {
+			logs: Array.from(deduplicatedMap.values()).slice(0, limit),
+			nextCursor: logs.length === limit * 2 ? logs[logs.length - 1].timestamp.getTime().toString() : null
+		});
+	}
+	async function getNotificationStatus(req, res, ctx) {
+		const { taskId } = ctx.params;
+		if (!taskId) return sendJson(res, 400, { error: "missing_task_id" });
+		const logs = await deps.db.select().from(messageLogs).where(and(eq(messageLogs.taskId, taskId), eq(messageLogs.projectId, ctx.projectId))).orderBy(desc(messageLogs.timestamp));
+		if (logs.length === 0) return sendJson(res, 404, {
+			error: "not_found",
+			message: "Task not found or not processed yet"
+		});
+		sendJson(res, 200, {
+			status: logs[0]?.status,
+			logs
+		});
+	}
+	async function getUser(req, res, ctx) {
+		const userId = ctx.params.id;
+		const user = await deps.userRepo.findRecordById(ctx.projectId, userId);
+		if (!user) return sendJson(res, 404, {
+			error: "user_not_found",
+			id: userId
+		});
+		const contacts = await deps.contactRepo.findByUserId(ctx.projectId, userId);
+		sendJson(res, 200, {
+			...user,
+			contacts
+		});
+	}
+	async function getUserPreferences(req, res, ctx) {
+		const userId = ctx.params.id;
+		const user = await deps.userRepo.findRecordById(ctx.projectId, userId);
+		if (!user) return sendJson(res, 404, {
+			error: "user_not_found",
+			id: userId
+		});
+		sendJson(res, 200, user.preferences);
+	}
+	async function updateUserPreferences(req, res, ctx) {
+		const userId = ctx.params.id;
+		const parsed = PreferencesSchema.safeParse(await readJsonBody(req));
+		if (!parsed.success) return sendValidationError(res, parsed.error);
+		if (!await deps.userRepo.updatePartial(ctx.projectId, userId, { preferences: parsed.data })) return sendJson(res, 404, {
+			error: "user_not_found",
+			id: userId
+		});
+		logger.info({ userId }, "user preferences updated");
+		sendJson(res, 200, {
+			id: userId,
+			preferences: parsed.data
+		});
+	}
+	async function createWorkflow(req, res, ctx) {
+		const body = await readJsonBody(req);
+		const parsed = CreateWorkflowSchema.safeParse(body);
+		if (!parsed.success) return sendValidationError(res, parsed.error);
+		const input = parsed.data;
+		try {
+			await deps.db.insert(workflowDefinitions).values({
+				projectId: ctx.projectId,
+				name: input.name,
+				steps: input.steps
+			}).onConflictDoUpdate({
+				target: [workflowDefinitions.projectId, workflowDefinitions.name],
+				set: { steps: input.steps }
+			});
+			sendJson(res, 201, { name: input.name });
+		} catch (error) {
+			deps.logger.error({ err: error }, "Failed to create workflow definition");
+			sendJson(res, 500, {
+				error: "internal_error",
+				message: error.message
+			});
+		}
+	}
+	async function listTemplates(req, res, ctx) {
+		const limitParam = getQueryParam(ctx, "limit");
+		const limit = limitParam ? Math.min(parseInt(limitParam, 10), 100) : void 0;
+		const channel = getQueryParam(ctx, "channel");
+		const topic = getQueryParam(ctx, "topic");
+		let templates = await deps.templateRepo.list(ctx.projectId);
+		if (channel) templates = templates.filter((t) => t.channel === channel);
+		if (topic) templates = templates.filter((t) => t.topics?.includes(topic));
+		if (limit) templates = templates.slice(0, limit);
+		sendJson(res, 200, { templates });
+	}
+	async function getTemplate(req, res, ctx) {
+		const templateId = ctx.params.id;
+		const template = await deps.templateRepo.findById(ctx.projectId, templateId);
+		if (!template) return sendJson(res, 404, {
+			error: "template_not_found",
+			id: templateId
+		});
+		sendJson(res, 200, template);
+	}
+	async function deleteTemplate(req, res, ctx) {
+		const templateId = ctx.params.id;
+		if (!await deps.templateRepo.delete(ctx.projectId, templateId)) return sendJson(res, 404, {
+			error: "template_not_found",
+			id: templateId
+		});
+		await deps.redis.native.publish("template.invalidated", `${ctx.projectId}:${templateId}`);
+		logger.info({ templateId }, "template deleted");
+		sendNoContent(res);
+	}
+	async function listWorkflows(req, res, ctx) {
+		const limitParam = getQueryParam(ctx, "limit");
+		const limit = limitParam ? Math.min(parseInt(limitParam, 10), 100) : void 0;
+		let workflows = await deps.workflowRepo.listDefinitions(ctx.projectId);
+		if (limit) workflows = workflows.slice(0, limit);
+		sendJson(res, 200, { workflows });
+	}
+	async function getWorkflow(req, res, ctx) {
+		const instanceId = ctx.params.id;
+		const workflow = await deps.workflowRepo.getInstance(ctx.projectId, instanceId);
+		if (!workflow) return sendJson(res, 404, {
+			error: "workflow_not_found",
+			id: instanceId
+		});
+		sendJson(res, 200, workflow);
+	}
+	async function cancelWorkflow(req, res, ctx) {
+		const instanceId = ctx.params.id;
+		if (!await deps.workflowRepo.cancelInstance(ctx.projectId, instanceId)) return sendJson(res, 400, {
+			error: "workflow_not_cancelable",
+			id: instanceId
+		});
+		logger.info({ instanceId }, "workflow canceled");
+		sendNoContent(res);
+	}
+	async function listUsers(req, res, ctx) {
+		const limitParam = parseInt(ctx.query.get("limit") || "50", 10);
+		const limit = isNaN(limitParam) ? 50 : Math.min(limitParam, 100);
+		const cursor = ctx.query.get("cursor") ?? void 0;
+		sendJson(res, 200, await deps.userRepo.list(ctx.projectId, limit, cursor));
+	}
+	async function getUserContacts(req, res, ctx) {
+		const userId = ctx.params.id;
+		sendJson(res, 200, { contacts: await deps.contactRepo.findByUserId(ctx.projectId, userId) });
+	}
+	async function listSegments(req, res, ctx) {
+		sendJson(res, 200, { segments: await deps.segmentRepo.listSegments(ctx.projectId) });
+	}
+	async function listProjects(req, res, _ctx) {
+		sendJson(res, 200, { projects: await deps.projectRepo.list() });
+	}
+	async function deleteProject(req, res, ctx) {
+		const id = ctx.params.id;
+		if (!await deps.projectRepo.delete(id)) return sendJson(res, 404, { error: "project_not_found" });
+		sendNoContent(res);
+	}
+	async function updateProject(req, res, ctx) {
+		const id = ctx.params.id;
+		const parsed = z.object({
+			rateLimitRpm: z.number().nullable().optional(),
+			throttleLimit: z.number().nullable().optional(),
+			throttleWindowHours: z.number().nullable().optional()
+		}).safeParse(await readJsonBody(req));
+		if (!parsed.success) return sendValidationError(res, parsed.error);
+		if (!await deps.projectRepo.updateSettings(id, parsed.data)) return sendJson(res, 404, { error: "project_not_found" });
+		await deps.redis.native.publish(PUBSUB_CHANNELS.PROJECT_INVALIDATED, id);
+		if (parsed.data.rateLimitRpm !== void 0) await deps.redis.native.publish(PUBSUB_CHANNELS.API_KEY_INVALIDATED, "*");
+		logger.info({ projectId: id }, "project settings updated");
+		sendJson(res, 200, { id });
+	}
+	async function createProjectKey(req, res, ctx) {
+		const id = ctx.params.id;
+		const parsed = z.object({ role: z.enum(["admin", "read_only"]).default("admin") }).safeParse(await readJsonBody(req));
+		const role = parsed.success ? parsed.data.role : "admin";
+		const { randomBytes, createHash } = await import("node:crypto");
+		const apiKey = `nk_live_${randomBytes(32).toString("hex")}`;
+		const apiKeyHash = createHash("sha256").update(apiKey).digest("hex");
+		sendJson(res, 201, {
+			id: (await deps.projectRepo.createApiKey(id, apiKeyHash, role)).id,
+			apiKey,
+			role
+		});
+	}
+	async function listProjectKeys(req, res, ctx) {
+		const id = ctx.params.id;
+		sendJson(res, 200, { keys: await deps.projectRepo.listApiKeys(id) });
+	}
+	async function deleteProjectKey(req, res, ctx) {
+		const { id, keyId } = ctx.params;
+		if (!await deps.projectRepo.deleteApiKey(id, keyId)) return sendJson(res, 404, { error: "key_not_found" });
+		await deps.redis.native.publish("apikey.invalidated", "*");
+		sendJson(res, 204, {});
+	}
+	async function getSystemHealth(_req, res, _ctx) {
+		const keys = [
+			"enricher",
+			"engine",
+			"scheduler",
+			"delivery",
+			"ai",
+			"workflow",
+			"events"
+		];
+		const workers = {};
+		let redisOk = false;
+		let dbOk = false;
+		let redisLatency = 0;
+		let dbLatency = 0;
+		const startRedis = Date.now();
+		try {
+			await deps.redis.native.ping();
+			redisOk = true;
+			redisLatency = Date.now() - startRedis;
+		} catch {
+			redisOk = false;
+		}
+		const startDb = Date.now();
+		try {
+			await deps.db.execute(sql`SELECT 1`);
+			dbOk = true;
+			dbLatency = Date.now() - startDb;
+		} catch {
+			dbOk = false;
+		}
+		if (redisOk) try {
+			const vals = await deps.redis.native.mget(keys.map((k) => `notif:health:${k}`));
+			for (let i = 0; i < keys.length; i++) {
+				const key = keys[i];
+				const val = vals[i];
+				if (val) workers[key] = JSON.parse(val);
+				else workers[key] = {
+					status: "unknown",
+					message: "No heartbeat"
+				};
+			}
+		} catch (err) {
+			for (const key of keys) workers[key] = {
+				status: "error",
+				error: err.message
+			};
+		}
+		sendJson(res, 200, {
+			status: redisOk && dbOk ? "healthy" : "degraded",
+			redis: {
+				ok: redisOk,
+				latencyMs: redisLatency
+			},
+			db: {
+				ok: dbOk,
+				latencyMs: dbLatency
+			},
+			workers
+		});
+	}
+	async function getSystemMetrics(_req, res, ctx) {
+		const streamMap = {
+			INBOUND_CRITICAL: STREAMS.INBOUND_CRITICAL,
+			INBOUND_NORMAL: STREAMS.INBOUND_NORMAL,
+			INBOUND_LOW: STREAMS.INBOUND_LOW,
+			ENRICHED_NORMAL: STREAMS.ENRICHED_NORMAL,
+			OUTBOUND_CRITICAL: STREAMS.OUTBOUND_CRITICAL,
+			OUTBOUND_NORMAL: STREAMS.OUTBOUND_NORMAL,
+			OUTBOUND_LOW: STREAMS.OUTBOUND_LOW,
+			WORKFLOW_INBOUND: STREAMS.WORKFLOW_INBOUND,
+			EVENTS_INBOUND: STREAMS.EVENTS_INBOUND,
+			DEAD_LETTER: STREAMS.DEAD_LETTER
+		};
+		const streamDepths = {};
+		for (const [key, realRedisKey] of Object.entries(streamMap)) try {
+			streamDepths[key] = await deps.redis.native.xlen(realRedisKey);
+		} catch {
+			streamDepths[key] = 0;
+		}
+		const totalTasksRes = await deps.db.select({ count: sql`count(distinct ${messageLogs.taskId})` }).from(messageLogs).where(eq(messageLogs.projectId, ctx.projectId));
+		const deliveredTasksRes = await deps.db.select({ count: sql`count(distinct ${messageLogs.taskId})` }).from(messageLogs).where(and(eq(messageLogs.projectId, ctx.projectId), eq(messageLogs.status, "delivered")));
+		const total = Number(totalTasksRes[0]?.count ?? 0);
+		const delivered = Number(deliveredTasksRes[0]?.count ?? 0);
+		sendJson(res, 200, {
+			streams: streamDepths,
+			deliveryStats: {
+				total,
+				delivered,
+				failed: streamDepths.DEAD_LETTER || 0,
+				successRate: total > 0 ? Number((delivered / total * 100).toFixed(2)) : 100
+			}
+		});
+	}
+	async function getDLQMessages(_req, res, _ctx) {
+		try {
+			sendJson(res, 200, { messages: (await deps.redis.native.xrevrange(STREAMS.DEAD_LETTER, "+", "-", "COUNT", "50") || []).map(([id, fields]) => {
+				const fieldMap = {};
+				for (let i = 0; i < fields.length; i += 2) fieldMap[fields[i]] = fields[i + 1];
+				return {
+					id,
+					eventType: fieldMap.eventType || fieldMap.event_type || "unknown",
+					payload: fieldMap.payload ? JSON.parse(fieldMap.payload) : fieldMap,
+					error: fieldMap.error || fieldMap.reason || "Dead letter payload",
+					timestamp: fieldMap.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+				};
+			}) });
+		} catch {
+			sendJson(res, 200, { messages: [] });
+		}
+	}
+	async function replayDLQMessage(req, res, _ctx) {
+		const messageId = (await readJsonBody(req).catch(() => ({})))?.id;
+		if (!messageId) {
+			sendJson(res, 400, { error: "missing_message_id" });
+			return;
+		}
+		try {
+			const rawEntries = await deps.redis.native.xrange(STREAMS.DEAD_LETTER, messageId, messageId);
+			if (!rawEntries || rawEntries.length === 0 || !rawEntries[0]) {
+				sendJson(res, 404, { error: "dlq_message_not_found" });
+				return;
+			}
+			const fields = rawEntries[0][1];
+			const fieldMap = {};
+			for (let i = 0; i < fields.length; i += 2) fieldMap[fields[i]] = fields[i + 1];
+			const priority = fieldMap.priority || "normal";
+			const p = getPriorityBucket(priority);
+			const targetStream = STREAMS[`INBOUND_${p.toUpperCase()}`] || STREAMS.INBOUND_NORMAL;
+			const xaddArgs = [];
+			for (const [k, v] of Object.entries(fieldMap)) xaddArgs.push(k, v);
+			await deps.redis.native.xadd(targetStream, "*", ...xaddArgs);
+			await deps.redis.native.xdel(STREAMS.DEAD_LETTER, messageId);
+			sendJson(res, 200, {
+				success: true,
+				replayedId: messageId
+			});
+		} catch (err) {
+			sendJson(res, 500, {
+				error: "replay_failed",
+				message: err.message
+			});
+		}
+	}
+	async function deleteDLQMessage(_req, res, ctx) {
+		const messageId = ctx.params.id;
+		if (!messageId) return sendJson(res, 400, { error: "missing_id" });
+		try {
+			await deps.redis.native.xdel(STREAMS.DEAD_LETTER, messageId);
+			sendJson(res, 200, { success: true });
+		} catch (err) {
+			sendJson(res, 500, {
+				error: "delete_failed",
+				message: err.message
+			});
+		}
+	}
+	async function getScheduledMessages(_req, res, ctx) {
+		const limitParam = getQueryParam(ctx, "limit");
+		const limit = limitParam ? Math.min(parseInt(limitParam, 10), 100) : 50;
+		const cursor = getQueryParam(ctx, "cursor");
+		const channel = getQueryParam(ctx, "channel");
+		const conditions = [sql`(payload->>'projectId') = ${ctx.projectId}`];
+		if (cursor) conditions.push(sql`task_id > ${cursor}`);
+		if (channel) conditions.push(sql`(payload->>'channel') = ${channel}`);
+		const rows = await deps.db.select().from(scheduledPayloads).where(and(...conditions)).orderBy(scheduledPayloads.taskId).limit(limit + 1);
+		const hasNext = rows.length > limit;
+		const scheduled = hasNext ? rows.slice(0, limit) : rows;
+		sendJson(res, 200, {
+			scheduled,
+			nextCursor: hasNext && scheduled.length > 0 ? scheduled[scheduled.length - 1].taskId : null
+		});
+	}
+	async function getUserDetails(_req, res, ctx) {
+		const userId = ctx.params.id;
+		const user = await deps.userRepo.findRecordById(ctx.projectId, userId);
+		if (!user) return sendJson(res, 404, {
+			error: "user_not_found",
+			id: userId
+		});
+		const contacts = await deps.contactRepo.findByUserId(ctx.projectId, userId);
+		const logs = await deps.db.select().from(messageLogs).where(eq(messageLogs.projectId, ctx.projectId)).orderBy(desc(messageLogs.timestamp)).limit(50);
+		sendJson(res, 200, {
+			...user,
+			contacts,
+			logs
+		});
+	}
+	function sendHtml(res, status, body) {
+		res.writeHead(status, {
+			"Content-Type": "text/html; charset=utf-8",
+			"Cache-Control": "no-store",
+			"X-Content-Type-Options": "nosniff",
+			"Referrer-Policy": "no-referrer"
+		});
+		res.end(body);
+	}
+	function escapeHtml(value) {
+		return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+	}
+	function page(title, message) {
+		return `<!doctype html><html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${escapeHtml(title)}</title>
+<style>body{font:16px/1.6 system-ui,sans-serif;max-width:34rem;margin:12vh auto;padding:0 1.5rem;color:#111}
+h1{font-size:1.4rem;margin:0 0 .75rem}p{margin:0 0 1rem;color:#444}
+button{font:inherit;padding:.6rem 1.2rem;border:0;border-radius:6px;background:#111;color:#fff;cursor:pointer}
+code{background:#f4f4f5;padding:.1rem .35rem;border-radius:4px}</style>
+</head><body><h1>${escapeHtml(title)}</h1>${message}</body></html>`;
+	}
+	/**
+	* GET — the page a human lands on after clicking the link in the mail body.
+	*
+	* Deliberately does not unsubscribe anything. Corporate mail scanners and
+	* link prescanners issue a GET against every URL in a message; performing the
+	* opt-out here would unsubscribe people who never clicked. The mutation lives
+	* behind the POST.
+	*/
+	async function unsubscribePage(_req, res, ctx) {
+		const cfg = readBaseConfig();
+		const token = ctx.query.get("token") ?? "";
+		if (!cfg.UNSUBSCRIBE_SECRET) deps.logger.warn("UNSUBSCRIBE_SECRET is not configured — unable to verify unsubscribe tokens");
+		const claim = cfg.UNSUBSCRIBE_SECRET ? verifyUnsubscribeToken(token, cfg.UNSUBSCRIBE_SECRET) : null;
+		if (!claim) return sendHtml(res, 400, page("This link is not valid", "<p>It may have been altered in transit, or this server may have been reconfigured since the message was sent. Replying to the message and asking to be removed will still work.</p>"));
+		sendHtml(res, 200, page("Unsubscribe", `<p>Stop sending ${claim.topics.length > 0 ? `<code>${claim.topics.map(escapeHtml).join("</code>, <code>")}</code> messages` : "all messages"} to <code>${escapeHtml(claim.target)}</code>?</p>
+<form method="post" action="/v1/unsubscribe?token=${encodeURIComponent(token)}">
+<button type="submit">Unsubscribe</button></form>`));
+	}
+	/**
+	* POST — the real opt-out.
+	*
+	* Serves two callers with one handler: a mail client doing RFC 8058 one-click
+	* (body `List-Unsubscribe=One-Click`, token in the query string, no
+	* confirmation possible), and the form on the page above. Neither can carry a
+	* CSRF token, and the one-click spec forbids an interstitial, so the signed
+	* token is the whole of the authorisation.
+	*/
+	async function unsubscribe(req, res, ctx) {
+		req.resume();
+		const cfg = readBaseConfig();
+		const token = ctx.query.get("token") ?? "";
+		if (!cfg.UNSUBSCRIBE_SECRET) deps.logger.warn("UNSUBSCRIBE_SECRET is not configured — unable to verify unsubscribe tokens");
+		const claim = cfg.UNSUBSCRIBE_SECRET ? verifyUnsubscribeToken(token, cfg.UNSUBSCRIBE_SECRET) : null;
+		if (!claim) return sendHtml(res, 400, page("This link is not valid", "<p>It may have been altered in transit, or this server may have been reconfigured since the message was sent.</p>"));
+		const target = normaliseTarget(claim.target);
+		try {
+			const internalId = (await deps.db.select({ id: users.id }).from(users).where(and(eq(users.projectId, claim.projectId), eq(users.externalId, claim.userId))).limit(1))[0]?.id;
+			if (claim.topics.length > 0 && internalId) await deps.db.insert(userTopicPreferences).values(claim.topics.map((topic) => ({
+				userId: internalId,
+				topic,
+				enabled: false
+			}))).onConflictDoUpdate({
+				target: [userTopicPreferences.userId, userTopicPreferences.topic],
+				set: { enabled: sql`excluded.enabled` }
+			});
+			else await deps.db.insert(suppressions).values({
+				projectId: claim.projectId,
+				channel: claim.channel,
+				target,
+				reason: "unsubscribed",
+				source: "unsubscribe-link"
+			}).onConflictDoNothing();
+			logger.info({
+				projectId: claim.projectId,
+				channel: claim.channel,
+				topics: claim.topics,
+				scoped: claim.topics.length > 0 && Boolean(internalId)
+			}, "unsubscribe honoured");
+		} catch (err) {
+			logger.error({
+				err,
+				projectId: claim.projectId
+			}, "unsubscribe failed to apply");
+			return sendHtml(res, 500, page("Something went wrong", "<p>We could not record that just now. Please try again in a moment.</p>"));
+		}
+		sendHtml(res, 200, page("You're unsubscribed", `<p>We've stopped sending ${claim.topics.length > 0 ? "these messages" : "messages"} to <code>${escapeHtml(claim.target)}</code>. It may take a few minutes to take effect for mail already on its way.</p>`));
+	}
+	async function listCampaigns(_req, res, ctx) {
+		const limitParam = parseInt(ctx.query.get("limit") || "20", 10);
+		const limit = isNaN(limitParam) ? 20 : Math.min(Math.max(limitParam, 1), 100);
+		sendJson(res, 200, { campaigns: (await deps.db.select({
+			campaign: messageLogs.campaignId,
+			messages: sql`count(distinct ${messageLogs.taskId})`,
+			firstSentAt: sql`min(${messageLogs.timestamp})`,
+			lastActivityAt: sql`max(${messageLogs.timestamp})`
+		}).from(messageLogs).where(and(eq(messageLogs.projectId, ctx.projectId), isNotNull(messageLogs.campaignId))).groupBy(messageLogs.campaignId).orderBy(desc(sql`max(${messageLogs.timestamp})`)).limit(limit)).map((r) => ({
+			campaign: r.campaign,
+			messages: Number(r.messages ?? 0),
+			firstSentAt: r.firstSentAt,
+			lastActivityAt: r.lastActivityAt
+		})) });
+	}
+	async function getCampaignStats(_req, res, ctx) {
+		const campaign = ctx.params.campaign;
+		if (!campaign) return sendJson(res, 400, { error: "missing_campaign" });
+		const rows = await deps.db.select({
+			channel: messageLogs.channel,
+			kind: messageLogs.kind,
+			status: messageLogs.status,
+			tasks: sql`count(distinct ${messageLogs.taskId})`
+		}).from(messageLogs).where(and(eq(messageLogs.projectId, ctx.projectId), eq(messageLogs.campaignId, campaign))).groupBy(messageLogs.channel, messageLogs.kind, messageLogs.status);
+		if (rows.length === 0) return sendJson(res, 404, {
+			error: "not_found",
+			message: `No messages recorded for campaign '${campaign}'`
+		});
+		const ENGAGEMENT = [
+			"opened",
+			"clicked",
+			"bounced",
+			"complained",
+			"unsubscribed"
+		];
+		const blank = () => ({
+			sent: 0,
+			delivered: 0,
+			failed: 0,
+			opened: 0,
+			clicked: 0,
+			bounced: 0,
+			complained: 0,
+			unsubscribed: 0
+		});
+		const byChannel = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const bucket = byChannel.get(row.channel) ?? blank();
+			const n = Number(row.tasks ?? 0);
+			if (ENGAGEMENT.includes(row.kind)) bucket[row.kind] += n;
+			else {
+				bucket.sent += n;
+				if (row.status === "delivered") bucket.delivered += n;
+				if (row.status === "failed") bucket.failed += n;
+			}
+			byChannel.set(row.channel, bucket);
+		}
+		const total = blank();
+		for (const bucket of byChannel.values()) for (const key of Object.keys(total)) total[key] += bucket[key];
+		const pct = (n, d) => d > 0 ? Number((n / d * 100).toFixed(2)) : null;
+		const channels = [...byChannel.keys()];
+		const engagementCapable = channels.some((c) => c === "email");
+		const sawEngagement = ENGAGEMENT.some((k) => total[k] > 0);
+		const warnings = [];
+		if (!engagementCapable) warnings.push(`Opens and clicks are not reported on ${channels.join(", ")} — those figures are not tracked, not zero.`);
+		else if (!sawEngagement && total.delivered > 0) warnings.push("No engagement events recorded. If the provider webhook is not configured, opens and clicks cannot be tracked and will stay at zero.");
+		sendJson(res, 200, {
+			campaign,
+			totals: {
+				...total,
+				deliveryRate: pct(total.delivered, total.sent),
+				openRate: pct(total.opened, total.delivered),
+				clickRate: pct(total.clicked, total.delivered),
+				bounceRate: pct(total.bounced, total.sent),
+				complaintRate: pct(total.complained, total.delivered),
+				unsubscribeRate: pct(total.unsubscribed, total.delivered)
+			},
+			byChannel: Object.fromEntries(byChannel),
+			engagementTracked: engagementCapable && sawEngagement,
+			warnings
+		});
+	}
+	async function listSuppressions(_req, res, ctx) {
+		const limitParam = parseInt(ctx.query.get("limit") || "100", 10);
+		const limit = isNaN(limitParam) ? 100 : Math.min(Math.max(limitParam, 1), 500);
+		const channel = ctx.query.get("channel");
+		const reason = ctx.query.get("reason");
+		const conditions = [eq(suppressions.projectId, ctx.projectId)];
+		if (channel) conditions.push(eq(suppressions.channel, channel));
+		if (reason) conditions.push(eq(suppressions.reason, reason));
+		sendJson(res, 200, { suppressions: await deps.db.select().from(suppressions).where(and(...conditions)).orderBy(desc(suppressions.createdAt)).limit(limit) });
+	}
+	async function createSuppression(req, res, ctx) {
+		const parsed = z.object({
+			channel: ContactChannelSchema,
+			target: z.string().min(1),
+			reason: z.enum([
+				"unsubscribed",
+				"complained",
+				"bounced",
+				"manual"
+			]).default("manual")
+		}).safeParse(await readJsonBody(req));
+		if (!parsed.success) return sendValidationError(res, parsed.error);
+		const { channel, target, reason } = parsed.data;
+		await deps.db.insert(suppressions).values({
+			projectId: ctx.projectId,
+			channel,
+			target: normaliseTarget(target),
+			reason,
+			source: "api"
+		}).onConflictDoNothing();
+		sendJson(res, 201, {
+			channel,
+			target: normaliseTarget(target),
+			reason
+		});
+	}
+	async function deleteSuppression(_req, res, ctx) {
+		const { channel, target } = ctx.params;
+		if (!channel || !target) return sendJson(res, 400, { error: "missing_channel_or_target" });
+		await deps.db.delete(suppressions).where(and(eq(suppressions.projectId, ctx.projectId), eq(suppressions.channel, channel), eq(suppressions.target, normaliseTarget(decodeURIComponent(target)))));
+		sendNoContent(res);
+	}
+	return {
+		syncTemplates,
+		addUser,
+		updateUser,
+		deleteUser,
+		addContact,
+		deleteContact,
+		notify,
+		cancelNotification,
+		triggerWorkflow,
+		ingestEvent,
+		getEventsStream,
+		getNotificationLogs,
+		getNotificationStatus,
+		getUser,
+		getUserDetails,
+		unsubscribePage,
+		unsubscribe,
+		listCampaigns,
+		getCampaignStats,
+		listSuppressions,
+		createSuppression,
+		deleteSuppression,
+		getUserPreferences,
+		updateUserPreferences,
+		listTemplates,
+		getTemplate,
+		deleteTemplate,
+		createWorkflow,
+		listWorkflows,
+		getWorkflow,
+		cancelWorkflow,
+		listUsers,
+		getUserContacts,
+		listSegments,
+		listProjects,
+		deleteProject,
+		updateProject,
+		createProjectKey,
+		listProjectKeys,
+		deleteProjectKey,
+		getSystemHealth,
+		getSystemMetrics,
+		getDLQMessages,
+		replayDLQMessage,
+		deleteDLQMessage,
+		getScheduledMessages
+	};
+}
+//#endregion
+//#region src/services/api/main.ts
+/** Pub/sub channel used to drop a cached API key across every API process. */
+const API_KEY_INVALIDATION_CHANNEL = "apikey.invalidated";
+loadEnv();
+const config = readBaseConfig();
+let logger;
+let redis;
+let sql$1;
+let db;
+let producers;
+let deps;
+let h;
+const AUTH_CACHE_TTL_MS = 6e4;
+let authCache = new LRUCache(1e3, AUTH_CACHE_TTL_MS);
+let authSubscriber = null;
+let router;
+function extractAuthToken(req) {
+	const authHeader = req.headers["authorization"];
+	if (typeof authHeader === "string" && authHeader.toLowerCase().startsWith("bearer ")) return authHeader.slice(7).trim();
+	const apiKeyHeader = req.headers["x-api-key"];
+	if (typeof apiKeyHeader === "string") return apiKeyHeader.trim();
+}
+async function handleCreateProject(req, res) {
+	const parsed = z.object({ name: z.string().min(1) }).safeParse(await readJsonBody(req));
+	if (!parsed.success) {
+		sendJson(res, 400, {
+			error: "validation_error",
+			issues: parsed.error.issues
+		});
+		return;
+	}
+	const apiKey = `nk_live_${randomBytes(32).toString("hex")}`;
+	const apiKeyHash = createHash("sha256").update(apiKey).digest("hex");
+	const projectId = (await db.insert(projects).values({ name: parsed.data.name }).returning())[0].id;
+	await db.insert(projectApiKeys).values({
+		projectId,
+		keyHash: apiKeyHash,
+		role: "admin"
+	});
+	sendJson(res, 201, {
+		id: projectId,
+		apiKey
+	});
+}
+let cachedHealth = null;
+async function handleHealth(_req, res) {
+	if (cachedHealth && cachedHealth.expiresAt > Date.now()) {
+		sendJson(res, cachedHealth.statusCode, cachedHealth.response);
+		return;
+	}
+	const [redisOk, dbOk] = await Promise.all([redis.healthCheck(), dbHealthCheck()]);
+	const workers = {};
+	let overallOk = redisOk && dbOk;
+	if (redisOk) {
+		const keys = [
+			"enricher",
+			"engine",
+			"scheduler",
+			"delivery",
+			"ai",
+			"workflow",
+			"events"
+		];
+		try {
+			const vals = await redis.native.mget(keys.map((k) => `notif:health:${k}`));
+			for (let i = 0; i < keys.length; i++) {
+				const key = keys[i];
+				const val = vals[i];
+				if (val) {
+					const parsed = JSON.parse(val);
+					workers[key] = parsed;
+					if (parsed.redis === false || parsed.state === "error") overallOk = false;
+				} else workers[key] = {
+					status: "unknown",
+					message: "No report received from worker"
+				};
+			}
+		} catch (err) {
+			for (const key of keys) workers[key] = {
+				status: "error",
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+	const statusCode = overallOk ? 200 : 503;
+	const response = {
+		service: "api",
+		status: overallOk ? "ok" : "degraded",
+		redis: redisOk,
+		database: dbOk,
+		workers
+	};
+	cachedHealth = {
+		response,
+		statusCode,
+		expiresAt: Date.now() + 1e3
+	};
+	sendJson(res, statusCode, response);
+}
+async function handleMetrics(_req, res) {
+	const registry = getMetricsRegistry();
+	res.writeHead(200, { "Content-Type": registry.contentType });
+	res.end(await registry.metrics());
+}
+async function handleLive(_req, res) {
+	sendJson(res, 200, { status: "ok" });
+}
+async function handleReady(_req, res) {
+	if (cachedHealth && cachedHealth.expiresAt > Date.now()) {
+		sendJson(res, cachedHealth.statusCode === 200 ? 200 : 503, { status: cachedHealth.statusCode === 200 ? "ready" : "unready" });
+		return;
+	}
+	const [redisOk, dbOk] = await Promise.all([redis.healthCheck(), dbHealthCheck()]);
+	const isReady = redisOk && dbOk;
+	sendJson(res, isReady ? 200 : 503, { status: isReady ? "ready" : "unready" });
+}
+async function dbHealthCheck() {
+	try {
+		await sql$1`SELECT 1`;
+		return true;
+	} catch {
+		return false;
+	}
+}
+let server;
+async function startApiServer() {
+	logger = createLogger({
+		name: "api",
+		level: config.LOG_LEVEL
+	});
+	redis = new RedisClient({
+		url: config.REDIS_URL,
+		name: "api",
+		logger
+	});
+	const dbData = createDatabase({
+		url: config.DATABASE_URL,
+		applicationName: "api",
+		logger
+	});
+	sql$1 = dbData.sql;
+	db = dbData.db;
+	producers = {
+		critical: new StreamProducer({
+			redis: redis.native,
+			stream: STREAMS.INBOUND_CRITICAL,
+			logger
+		}),
+		normal: new StreamProducer({
+			redis: redis.native,
+			stream: STREAMS.INBOUND_NORMAL,
+			logger
+		}),
+		low: new StreamProducer({
+			redis: redis.native,
+			stream: STREAMS.INBOUND_LOW,
+			logger
+		}),
+		workflow: new StreamProducer({
+			redis: redis.native,
+			stream: STREAMS.WORKFLOW_INBOUND,
+			logger
+		}),
+		events: new StreamProducer({
+			redis: redis.native,
+			stream: STREAMS.EVENTS_INBOUND,
+			logger
+		})
+	};
+	deps = {
+		logger,
+		redis,
+		producers,
+		userRepo: new UserRepository(db),
+		contactRepo: new ContactRepository(db),
+		templateRepo: new TemplateRepository(db),
+		projectRepo: new ProjectRepository(db),
+		workflowRepo: new WorkflowRepository(db),
+		segmentRepo: new SegmentRepository(db),
+		db
+	};
+	h = createHandlers(deps);
+	router = new Router();
+	router.put("/v1/templates", h.syncTemplates).get("/v1/templates", h.listTemplates).get("/v1/templates/:id", h.getTemplate).delete("/v1/templates/:id", h.deleteTemplate).post("/v1/users", h.addUser).get("/v1/users", h.listUsers).get("/v1/users/:id", h.getUser).get("/v1/users/:id/details", h.getUserDetails).patch("/v1/users/:id", h.updateUser).delete("/v1/users/:id", h.deleteUser).post("/v1/users/:id/contacts", h.addContact).get("/v1/users/:id/contacts", h.getUserContacts).delete("/v1/users/:id/contacts/:channel/:target", h.deleteContact).get("/v1/users/:id/preferences", h.getUserPreferences).patch("/v1/users/:id/preferences", h.updateUserPreferences).post("/v1/notify", h.notify).get("/v1/notifications/scheduled", h.getScheduledMessages).get("/v1/notifications/logs", h.getNotificationLogs).get("/v1/notifications/:taskId", h.getNotificationStatus).delete("/v1/notifications/:taskId", h.cancelNotification).get("/v1/unsubscribe", h.unsubscribePage).post("/v1/unsubscribe", h.unsubscribe).get("/v1/campaigns", h.listCampaigns).get("/v1/campaigns/:campaign/stats", h.getCampaignStats).get("/v1/suppressions", h.listSuppressions).post("/v1/suppressions", h.createSuppression).delete("/v1/suppressions/:channel/:target", h.deleteSuppression).get("/v1/system/health", h.getSystemHealth).get("/v1/system/metrics", h.getSystemMetrics).get("/v1/dlq", h.getDLQMessages).post("/v1/dlq/replay", h.replayDLQMessage).delete("/v1/dlq/:id", h.deleteDLQMessage).post("/v1/workflows", h.createWorkflow).get("/v1/workflows", h.listWorkflows).get("/v1/workflows/instances/:id", h.getWorkflow).delete("/v1/workflows/instances/:id", h.cancelWorkflow).post("/v1/workflows/trigger", h.triggerWorkflow).get("/v1/segments", h.listSegments).post("/v1/events", h.ingestEvent).get("/v1/events/stream", h.getEventsStream).get("/v1/projects", h.listProjects).post("/v1/projects", handleCreateProject).delete("/v1/projects/:id", h.deleteProject).patch("/v1/projects/:id", h.updateProject).post("/v1/projects/:id/keys", h.createProjectKey).get("/v1/projects/:id/keys", h.listProjectKeys).delete("/v1/projects/:id/keys/:keyId", h.deleteProjectKey).get("/health", handleHealth).get("/metrics", handleMetrics).get("/live", handleLive).get("/ready", handleReady);
+	server = createServer((req, res) => {
+		handleRequest(req, res);
+	});
+	server.requestTimeout = 3e4;
+	server.headersTimeout = 1e4;
+	server.keepAliveTimeout = 5e3;
+	async function handleRequest(req, res) {
+		res.setHeader("Access-Control-Allow-Origin", "*");
+		res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
+		res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, x-api-key, x-project-id");
+		if (req.method === "OPTIONS") {
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+		const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+		let projectId = void 0;
+		let projectRateLimitRpm = 600;
+		let keyRole = "admin";
+		const isProjectManagement = url.pathname === "/v1/projects" || url.pathname.startsWith("/v1/projects/");
+		const isPublicUnsubscribe = url.pathname === "/v1/unsubscribe";
+		if (url.pathname.startsWith("/v1/") && !isProjectManagement && !isPublicUnsubscribe) {
+			let token = extractAuthToken(req);
+			if (!token && url.searchParams.has("token")) token = url.searchParams.get("token") || void 0;
+			if (!token) {
+				sendJson(res, 401, {
+					error: "unauthorized",
+					message: "Invalid or missing API key"
+				});
+				return;
+			}
+			let isAdminToken = false;
+			if (config.ADMIN_API_KEY) {
+				const expectedBuffer = Buffer.from(config.ADMIN_API_KEY);
+				const providedBuffer = Buffer.from(token);
+				if (expectedBuffer.length === providedBuffer.length && timingSafeEqual(expectedBuffer, providedBuffer)) isAdminToken = true;
+			}
+			if (isAdminToken) {
+				const headerProjectId = req.headers["x-project-id"] || url.searchParams.get("projectId") || void 0;
+				if (!headerProjectId) {
+					sendJson(res, 400, {
+						error: "bad_request",
+						message: "x-project-id header or projectId query param required when using admin token"
+					});
+					return;
+				}
+				projectId = headerProjectId;
+				projectRateLimitRpm = 6e3;
+				keyRole = "admin";
+			} else {
+				const tokenHash = createHash("sha256").update(token).digest("hex");
+				const cached = authCache.get(tokenHash);
+				if (cached) {
+					const parts = cached.split(":");
+					projectId = parts[0];
+					projectRateLimitRpm = parseInt(parts[1] || "600", 10);
+					keyRole = parts[2];
+				} else {
+					const rows = await db.select({
+						id: projects.id,
+						rateLimitRpm: projects.rateLimitRpm,
+						role: projectApiKeys.role
+					}).from(projectApiKeys).innerJoin(projects, eq(projects.id, projectApiKeys.projectId)).where(eq(projectApiKeys.keyHash, tokenHash)).limit(1);
+					if (!rows.length) {
+						sendJson(res, 401, {
+							error: "unauthorized",
+							message: "Invalid or missing API key"
+						});
+						return;
+					}
+					projectId = rows[0].id;
+					projectRateLimitRpm = rows[0].rateLimitRpm ?? 600;
+					keyRole = rows[0].role;
+					authCache.set(tokenHash, `${projectId}:${projectRateLimitRpm}:${keyRole}`);
+				}
+			}
+			if (keyRole === "read_only") {
+				if (req.method !== "GET" && req.method !== "OPTIONS") {
+					sendJson(res, 403, {
+						error: "forbidden",
+						message: "API key is read-only"
+					});
+					return;
+				}
+			}
+			const LUA_LIMIT = `
+        local key = KEYS[1]
+        local now = tonumber(ARGV[1])
+        local window = tonumber(ARGV[2])
+        local maxReqs = tonumber(ARGV[3])
+        local cutoff = now - window
+        redis.call("ZREMRANGEBYSCORE", key, "-inf", cutoff)
+        local count = redis.call("ZCARD", key)
+        if count < maxReqs then
+          redis.call("ZADD", key, now, now .. "-" .. ARGV[4])
+          redis.call("EXPIRE", key, math.ceil(window / 1000))
+          return count + 1
+        end
+        return -1
+      `;
+			const rlKey = `rate-limit:api:req:${projectId}`;
+			const nowMs = Date.now();
+			if (await redis.native.eval(LUA_LIMIT, 1, rlKey, nowMs, 6e4, projectRateLimitRpm, randomBytes(4).toString("hex")) === -1) {
+				if (!res.headersSent) {
+					res.setHeader("Retry-After", "60");
+					sendJson(res, 429, {
+						error: "too_many_requests",
+						message: `Project rate limit exceeded (max ${projectRateLimitRpm} req/min)`
+					});
+				}
+				return;
+			}
+		} else if (isProjectManagement) {
+			const token = extractAuthToken(req);
+			if (!config.ADMIN_API_KEY) {
+				sendJson(res, 403, {
+					error: "forbidden",
+					message: "Project management disabled (no ADMIN_API_KEY set)"
+				});
+				return;
+			}
+			if (!token) {
+				sendJson(res, 401, {
+					error: "unauthorized",
+					message: "Missing admin token"
+				});
+				return;
+			}
+			const expectedBuffer = Buffer.from(config.ADMIN_API_KEY);
+			const providedBuffer = Buffer.from(token);
+			if (expectedBuffer.length !== providedBuffer.length || !timingSafeEqual(expectedBuffer, providedBuffer)) {
+				sendJson(res, 401, {
+					error: "unauthorized",
+					message: "Invalid admin token"
+				});
+				return;
+			}
+		}
+		if (isPublicUnsubscribe) {
+			const clientIp = req.headers["x-forwarded-for"]?.split(",")[0]?.trim() || req.socket.remoteAddress || "unknown";
+			try {
+				const key = `rate-limit:api:unsub:${clientIp}`;
+				const count = await redis.native.incr(key);
+				if (count === 1) await redis.native.expire(key, 60);
+				if (count > 60) {
+					res.setHeader("Retry-After", "60");
+					sendJson(res, 429, { error: "too_many_requests" });
+					return;
+				}
+			} catch (err) {
+				logger.warn({ err }, "unsubscribe rate limit unavailable — allowing request");
+			}
+		}
+		const route = router.match(req.method ?? "GET", url.pathname);
+		if (!route) {
+			sendJson(res, 404, { error: "not_found" });
+			return;
+		}
+		const ctx = {
+			params: route.params,
+			query: url.searchParams,
+			projectId,
+			role: keyRole
+		};
+		Promise.resolve(route.handler(req, res, ctx)).catch((err) => {
+			if (err instanceof HttpError) {
+				if (!res.headersSent) sendJson(res, err.status, {
+					error: err.code,
+					message: err.message
+				});
+				return;
+			}
+			logger.error({
+				err,
+				path: url.pathname
+			}, "unhandled request error");
+			if (!res.headersSent) sendJson(res, 500, { error: "internal_error" });
+		});
+	}
+	authSubscriber = redis.native.duplicate();
+	await authSubscriber.subscribe(API_KEY_INVALIDATION_CHANNEL);
+	authSubscriber.on("message", (channel, tokenHash) => {
+		if (channel !== "apikey.invalidated") return;
+		if (tokenHash === "*") authCache.clear();
+		else authCache.delete(tokenHash);
+		logger.info({ tokenHash }, "api key cache invalidated");
+	});
+	const { transportRegistry } = await import("./index.mjs").then((n) => n.t);
+	for (const channel of transportRegistry.registeredChannels()) {
+		const transport = transportRegistry.get(channel);
+		if (transport?.webhookPath && transport?.parseWebhook) {
+			router.post(transport.webhookPath, async (req, res) => {
+				try {
+					await Promise.race([(async () => {
+						const rawBody = await readRawBody(req);
+						if (!transport.verifyWebhook) {
+							if (!res.headersSent) sendJson(res, 501, {
+								error: "not_implemented",
+								message: "Webhook signature verification is not implemented for this provider"
+							});
+							return;
+						}
+						if (!await transport.verifyWebhook(rawBody, req.headers)) {
+							if (!res.headersSent) sendJson(res, 401, {
+								error: "unauthorized",
+								message: "Invalid webhook signature"
+							});
+							return;
+						}
+						let body;
+						try {
+							body = rawBody ? JSON.parse(rawBody) : {};
+						} catch {
+							body = {};
+						}
+						const events = await transport.parseWebhook(body, rawBody, req.headers);
+						if (events.length > 0) {
+							const providerIds = events.map((e) => e.providerMessageId).filter(Boolean);
+							const logsToProject = /* @__PURE__ */ new Map();
+							const logsToTask = /* @__PURE__ */ new Map();
+							const logsToCampaign = /* @__PURE__ */ new Map();
+							if (providerIds.length > 0) {
+								const existing = await db.select({
+									providerMessageId: messageLogs.providerMessageId,
+									projectId: messageLogs.projectId,
+									taskId: messageLogs.taskId,
+									campaignId: messageLogs.campaignId
+								}).from(messageLogs).where(inArray(messageLogs.providerMessageId, providerIds));
+								for (const row of existing) if (row.providerMessageId) {
+									logsToProject.set(row.providerMessageId, row.projectId);
+									logsToTask.set(row.providerMessageId, row.taskId);
+									logsToCampaign.set(row.providerMessageId, row.campaignId);
+								}
+							}
+							const attributable = events.filter((e) => e.providerMessageId && logsToProject.has(e.providerMessageId));
+							const rows = attributable.map((e) => ({
+								projectId: logsToProject.get(e.providerMessageId),
+								taskId: logsToTask.get(e.providerMessageId),
+								providerMessageId: e.providerMessageId,
+								channel: transport.channel,
+								attempt: 0,
+								kind: e.status,
+								status: e.status,
+								campaignId: logsToCampaign.get(e.providerMessageId) ?? null,
+								metadata: e.metadata ?? null
+							}));
+							const skipped = events.length - rows.length;
+							if (skipped > 0) logger.warn({
+								channel,
+								skipped
+							}, "webhook events skipped: unknown providerMessageId");
+							if (rows.length > 0) await db.insert(messageLogs).values(rows).onConflictDoNothing();
+							const suppressionRows = attributable.filter((e) => e.recipient && (e.status === "unsubscribed" || e.status === "complained" || e.status === "bounced" && e.bounceType === "hard")).map((e) => ({
+								projectId: logsToProject.get(e.providerMessageId),
+								channel: transport.channel,
+								target: normaliseTarget(e.recipient),
+								reason: e.status,
+								source: channel,
+								taskId: logsToTask.get(e.providerMessageId)
+							}));
+							if (suppressionRows.length > 0) {
+								await db.insert(suppressions).values(suppressionRows).onConflictDoNothing();
+								logger.info({
+									channel,
+									count: suppressionRows.length
+								}, "addresses suppressed from provider webhook");
+							}
+							const unsuppressable = attributable.filter((e) => !e.recipient && (e.status === "unsubscribed" || e.status === "complained" || e.status === "bounced")).length;
+							if (unsuppressable > 0) logger.warn({
+								channel,
+								count: unsuppressable
+							}, "suppression events carried no recipient address — transport must set WebhookEvent.recipient");
+						}
+						if (!res.headersSent) sendJson(res, 200, { success: true });
+					})(), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Webhook processing timeout")), 15e3))]);
+				} catch (err) {
+					logger.error({
+						err,
+						channel
+					}, "webhook processing error or timeout");
+					if (!res.headersSent) sendJson(res, 500, {
+						error: "internal_error",
+						message: err.message
+					});
+				}
+			});
+			logger.info(`Mounted webhook for ${channel} at ${transport.webhookPath}`);
+		}
+	}
+	server.listen(config.PORT, config.HOST, () => {
+		logger.info({
+			port: config.PORT,
+			host: config.HOST,
+			env: config.NODE_ENV
+		}, "api server listening");
+	});
+}
+async function stopApiServer() {
+	logger?.info("api shutdown initiated");
+	if (server) {
+		await new Promise((resolve, reject) => {
+			server.close((err) => err ? reject(err) : resolve());
+		});
+		server.closeIdleConnections?.();
+		server = null;
+	}
+	if (authSubscriber) {
+		authSubscriber.disconnect();
+		authSubscriber = null;
+	}
+	authCache = new LRUCache(1e3, AUTH_CACHE_TTL_MS);
+	cachedHealth = null;
+	if (sql$1) await sql$1.end();
+	if (redis) await redis.disconnect();
+	logger?.info("api stopped");
+}
+//#endregion
+export { startApiServer, stopApiServer };
+
+//# sourceMappingURL=main-Ok9cQJ7q.mjs.map