notifkit 0.1.0

package/dist/src-DrSN2wCg.mjs

@@ -0,0 +1,3424 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { registerTransport } from "./index.mjs";
+import { config } from "dotenv";
+import { resolve } from "node:path";
+import { z } from "zod";
+import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+import postgres from "postgres";
+import { drizzle } from "drizzle-orm/postgres-js";
+import { boolean, check, index, integer, jsonb, pgEnum, pgTable, primaryKey, text, time, timestamp, unique, uuid, varchar } from "drizzle-orm/pg-core";
+import { and, desc, eq, inArray, sql } from "drizzle-orm";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import { migrate } from "drizzle-orm/postgres-js/migrator";
+import { fileURLToPath } from "url";
+import path from "path";
+import fs from "fs";
+import pino from "pino";
+import promClient from "prom-client";
+import { EventEmitter } from "node:events";
+import { randomUUID as randomUUID$1 } from "crypto";
+import { Redis } from "ioredis";
+//#region src/config/index.ts
+var config_exports = /* @__PURE__ */ __exportAll({
+	AI_DEFAULTS: () => AI_DEFAULTS,
+	baseConfigSchema: () => baseConfigSchema,
+	getAiConfig: () => getAiConfig,
+	loadEnv: () => loadEnv,
+	parseConfig: () => parseConfig,
+	readBaseConfig: () => readBaseConfig,
+	setAiConfig: () => setAiConfig,
+	setGlobalConfig: () => setGlobalConfig
+});
+function loadEnv(path) {
+	const envPath = path ?? resolve(process.cwd(), ".env");
+	config({
+		path: envPath,
+		override: false
+	});
+}
+function parseConfig(schema, data) {
+	const result = schema.safeParse(data);
+	if (!result.success) {
+		const fields = {};
+		for (const issue of result.error.issues) {
+			const key = issue.path.join(".");
+			fields[key] ??= [];
+			fields[key].push(issue.message);
+		}
+		throw new ValidationError("Configuration validation failed", fields);
+	}
+	return result.data;
+}
+const baseConfigSchema = z.object({
+	NODE_ENV: z.enum([
+		"development",
+		"test",
+		"production"
+	]).default("development"),
+	LOG_LEVEL: z.enum([
+		"fatal",
+		"error",
+		"warn",
+		"info",
+		"debug",
+		"trace",
+		"silent"
+	]).default("info"),
+	PORT: z.coerce.number().int().min(1).max(65535).default(3e3),
+	HOST: z.string().default("127.0.0.1"),
+	REDIS_URL: z.string().url().default("redis://localhost:6379"),
+	DATABASE_URL: z.string().url().default("postgres://platform:platform@localhost:5432/notifkit"),
+	ADMIN_API_KEY: z.string().optional(),
+	WORKER_CONCURRENCY: z.coerce.number().int().min(1).default(10),
+	QUEUE_MAX_LEN: z.coerce.number().int().min(1).default(1e7),
+	DB_MAX_CONNECTIONS: z.coerce.number().int().min(1).default(2),
+	LOG_FLUSH_INTERVAL_MS: z.coerce.number().int().min(50).default(500),
+	LOG_BUFFER_MAX_SIZE: z.coerce.number().int().min(100).default(5e3),
+	SEGMENT_MAX_USERS: z.coerce.number().int().min(1).default(1e4),
+	/**
+	* Externally reachable base URL of this API. Unsubscribe links are built from
+	* it, so it must be what an inbox can actually reach — not `HOST`/`PORT`,
+	* which describe the bind address behind your proxy.
+	*/
+	PUBLIC_URL: z.string().url().optional(),
+	/**
+	* Signing key for unsubscribe tokens. Rotating it invalidates every
+	* unsubscribe link already sitting in someone's inbox, so treat it as
+	* permanent: a dead link means the recipient reaches for the spam button
+	* instead, which costs far more than the key ever protected.
+	*/
+	UNSUBSCRIBE_SECRET: z.string().min(16).optional()
+});
+let globalConfig = null;
+function setGlobalConfig(config) {
+	globalConfig = config;
+}
+function readBaseConfig(data = process.env) {
+	if (globalConfig) return globalConfig;
+	return parseConfig(baseConfigSchema, data);
+}
+const AI_DEFAULTS = {
+	maxOutputTokens: 1e3,
+	timeoutMs: 3e4,
+	maxPromptsPerNotification: 5
+};
+let globalAiConfig = {};
+function setAiConfig(config) {
+	globalAiConfig = config;
+}
+function getAiConfig() {
+	return globalAiConfig;
+}
+//#endregion
+//#region src/contracts/common.ts
+const NotificationChannelSchema = z.enum([
+	"email",
+	"sms",
+	"push",
+	"webhook",
+	"in-app"
+]);
+const NotificationPrioritySchema = z.enum([
+	"low",
+	"normal",
+	"high",
+	"critical"
+]);
+const NotificationStatusSchema = z.enum([
+	"pending",
+	"queued",
+	"processing",
+	"delivered",
+	"failed",
+	"bounced",
+	"suppressed"
+]);
+//#endregion
+//#region src/contracts/metadata.ts
+const EventMetadataSchema = z.object({
+	traceId: z.string(),
+	source: z.string(),
+	retryCount: z.number().int().nonnegative().default(0),
+	correlationId: z.string().optional(),
+	causationId: z.string().optional()
+});
+//#endregion
+//#region src/contracts/registry.ts
+var EventRegistry = class {
+	schemas = /* @__PURE__ */ new Map();
+	define(type, schema) {
+		if (this.schemas.has(type)) throw new Error(`Event type "${type}" is already registered`);
+		this.schemas.set(type, schema);
+	}
+	getSchema(type) {
+		return this.schemas.get(type);
+	}
+	has(type) {
+		return this.schemas.has(type);
+	}
+	types() {
+		return [...this.schemas.keys()];
+	}
+	parsePayload(type, payload) {
+		const schema = this.schemas.get(type);
+		if (!schema) throw new Error(`Unknown event type: "${type}"`);
+		return schema.parse(payload);
+	}
+	safeParsePayload(type, payload) {
+		const schema = this.schemas.get(type);
+		if (!schema) return {
+			success: false,
+			error: new z.ZodError([{
+				code: "custom",
+				message: `Unknown event type: "${type}"`,
+				path: []
+			}])
+		};
+		const result = schema.safeParse(payload);
+		if (result.success) return {
+			success: true,
+			data: result.data
+		};
+		return {
+			success: false,
+			error: result.error
+		};
+	}
+};
+const registry = new EventRegistry();
+//#endregion
+//#region src/contracts/envelope.ts
+/**
+* Wire format written to Redis Streams. The payload field is an opaque record
+* at the envelope level — use registry.parsePayload() to get a typed payload.
+*/
+const EventEnvelopeSchema = z.object({
+	id: z.string().uuid(),
+	type: z.string(),
+	timestamp: z.string().datetime(),
+	payload: z.record(z.string(), z.unknown()),
+	metadata: EventMetadataSchema
+});
+const StreamEventSchema = EventEnvelopeSchema;
+const StreamEventMetadataSchema = EventMetadataSchema;
+//#endregion
+//#region src/contracts/streams.ts
+const STREAMS = {
+	INBOUND_CRITICAL: "notifkit:stream:inbound:critical",
+	INBOUND_NORMAL: "notifkit:stream:inbound:normal",
+	INBOUND_LOW: "notifkit:stream:inbound:low",
+	ENRICHED_CRITICAL: "notifkit:stream:enriched:critical",
+	ENRICHED_NORMAL: "notifkit:stream:enriched:normal",
+	ENRICHED_LOW: "notifkit:stream:enriched:low",
+	AI_PENDING: "notifkit:stream:ai:pending",
+	SCHEDULED: "notifkit:stream:scheduled",
+	OUTBOUND_CRITICAL: "notifkit:stream:outbound:critical",
+	OUTBOUND_NORMAL: "notifkit:stream:outbound:normal",
+	OUTBOUND_LOW: "notifkit:stream:outbound:low",
+	DEAD_LETTER: "notifkit:stream:dlq",
+	WORKFLOW_INBOUND: "notifkit:stream:workflow:inbound",
+	EVENTS_INBOUND: "notifkit:stream:events:inbound"
+};
+const INBOUND_STREAMS = [
+	STREAMS.INBOUND_CRITICAL,
+	STREAMS.INBOUND_NORMAL,
+	STREAMS.INBOUND_LOW
+];
+const ENRICHED_STREAMS = [
+	STREAMS.ENRICHED_CRITICAL,
+	STREAMS.ENRICHED_NORMAL,
+	STREAMS.ENRICHED_LOW
+];
+const OUTBOUND_STREAMS = [
+	STREAMS.OUTBOUND_CRITICAL,
+	STREAMS.OUTBOUND_NORMAL,
+	STREAMS.OUTBOUND_LOW
+];
+/**
+* Redis pub/sub channels used to drop cached state across every process.
+*
+* Each cache also carries a TTL, so these only shorten the window in which a
+* worker can act on stale data — they are not the sole correctness mechanism.
+*/
+const PUBSUB_CHANNELS = {
+	/** Payload: `{projectId}:{templateId}`. */
+	TEMPLATE_INVALIDATED: "template.invalidated",
+	/** Payload: `{projectId}`. Published when project settings change. */
+	PROJECT_INVALIDATED: "project.invalidated",
+	/** Payload: a token hash, or `*` for the whole cache. */
+	API_KEY_INVALIDATED: "apikey.invalidated"
+};
+const CONSUMER_GROUPS = {
+	ENRICHER: "notifkit:group:enricher",
+	ENGINE: "notifkit:group:engine",
+	DELIVERY: "notifkit:group:delivery",
+	SCHEDULER: "notifkit:group:scheduler",
+	AI: "notifkit:group:ai",
+	WORKFLOW: "notifkit:group:workflow",
+	EVENTS: "notifkit:group:events"
+};
+//#endregion
+//#region src/contracts/helpers.ts
+function buildStreamEvent(type, payload, source, traceId) {
+	return {
+		type,
+		payload,
+		metadata: {
+			traceId: traceId ?? randomUUID(),
+			source,
+			retryCount: 0
+		}
+	};
+}
+//#endregion
+//#region src/contracts/sdk.ts
+const QuietHoursSchema = z.object({
+	start: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "expected HH:MM (24h, UTC)"),
+	end: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "expected HH:MM (24h, UTC)")
+});
+const PreferencesSchema = z.object({
+	channels: z.record(z.string(), z.boolean()).optional(),
+	topics: z.record(z.string(), z.boolean()).optional(),
+	quietHours: z.array(QuietHoursSchema).optional()
+});
+/** Channels that carry an addressable target (email address, phone, push token, url). */
+const ContactChannelSchema = z.enum([
+	"email",
+	"sms",
+	"push",
+	"webhook"
+]);
+/** Accept a single value or an array; always normalise to a non-empty array. */
+const stringOrArray = z.union([z.string().min(1), z.array(z.string().min(1))]).transform((v) => Array.isArray(v) ? v : [v]);
+/**
+* addUser({ id, email, phone, pushToken, segments, preferences })
+* email / phone / pushToken accept a single string or an array.
+*/
+const AddUserSchema = z.object({
+	id: z.string().min(1),
+	language: z.string().optional(),
+	timezone: z.string().optional(),
+	email: stringOrArray.optional(),
+	phone: stringOrArray.optional(),
+	pushToken: stringOrArray.optional(),
+	segments: z.array(z.string().min(1)).optional(),
+	preferences: PreferencesSchema.optional()
+});
+/** updateUser(id, patch) — every field optional; id comes from the path. */
+const UpdateUserSchema = z.object({
+	language: z.string().optional(),
+	timezone: z.string().optional(),
+	email: stringOrArray.optional(),
+	phone: stringOrArray.optional(),
+	pushToken: stringOrArray.optional(),
+	segments: z.array(z.string().min(1)).optional(),
+	preferences: PreferencesSchema.optional()
+});
+/** addUserContact(userId, channel, { target, preferences }) — channel carried in body. */
+const AddContactSchema = z.object({
+	channel: ContactChannelSchema,
+	target: z.string().min(1),
+	preferences: PreferencesSchema.optional()
+});
+const TemplateSchema = z.object({
+	id: z.string().min(1),
+	channel: NotificationChannelSchema,
+	topic: z.union([z.string().min(1), z.array(z.string().min(1))]).transform((v) => Array.isArray(v) ? v : [v]).optional(),
+	content: z.record(z.string(), z.unknown()),
+	aiPrompts: z.record(z.string(), z.string()).optional()
+});
+const SyncTemplatesSchema = z.object({ templates: z.array(TemplateSchema).min(1) });
+/** Inline user object accepted by notify({ user: {...} }). */
+const InlineUserSchema = z.object({
+	id: z.string().min(1),
+	language: z.string().optional(),
+	timezone: z.string().optional(),
+	email: stringOrArray.optional(),
+	phone: stringOrArray.optional(),
+	pushToken: stringOrArray.optional(),
+	segments: z.array(z.string().min(1)).optional(),
+	preferences: PreferencesSchema.optional()
+});
+/**
+* notify(...) request body.
+*
+* Exactly one of `user` / `segment` / `topic` must be provided.
+*/
+/**
+* The field set shared by `notify()` and a workflow's `notify` step. The two
+* differ only in whether naming a target is mandatory, so the fields live here
+* once and each schema layers its own target rule on top.
+*/
+const NotifyRequestFields = z.object({
+	user: z.union([
+		z.string().min(1),
+		InlineUserSchema,
+		z.array(z.union([z.string().min(1), InlineUserSchema])).nonempty()
+	]).optional(),
+	segment: z.string().min(1).optional(),
+	topic: z.string().min(1).optional(),
+	template: z.string().min(1),
+	data: z.record(z.string(), z.unknown()).optional(),
+	aiPrompts: z.record(z.string(), z.string()).optional(),
+	priority: NotificationPrioritySchema.optional(),
+	channels: z.array(NotificationChannelSchema).nonempty().optional(),
+	fallback: z.boolean().optional(),
+	sendAt: z.string().datetime().optional(),
+	/**
+	* A label grouping every message this call produces, so the send can be
+	* reported on later via `/v1/campaigns/:id/stats`. Free-form, but reusing one
+	* label across calls merges them into a single campaign — which is either
+	* what you want (a send split into batches) or a reporting bug.
+	*/
+	campaign: z.string().min(1).max(128).optional()
+});
+function countTargets(val) {
+	return [
+		val.user,
+		val.segment,
+		val.topic
+	].filter((t) => t !== void 0).length;
+}
+const NotifyRequestSchema = NotifyRequestFields.superRefine((val, ctx) => {
+	const targets = countTargets(val);
+	if (targets === 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "one of `user`, `segment`, or `topic` is required",
+		path: ["user"]
+	});
+	else if (targets > 1) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "provide exactly one of `user`, `segment`, or `topic`",
+		path: ["user"]
+	});
+});
+/**
+* The payload of a workflow `notify` step — every field `notify()` takes.
+*
+* The one difference is that a target is optional here: a step naming none
+* inherits the instance's own user, which is the ordinary case. Naming one
+* overrides that, so a step can notify a different user, a segment, or a topic.
+*/
+const WorkflowNotifyPayloadSchema = NotifyRequestFields.superRefine((val, ctx) => {
+	if (countTargets(val) > 1) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "provide at most one of `user`, `segment`, or `topic`",
+		path: ["user"]
+	});
+});
+const TriggerWorkflowSchema = z.object({
+	name: z.string().min(1),
+	input: z.record(z.string(), z.unknown()).optional(),
+	user: z.union([z.string().min(1), InlineUserSchema]).optional()
+});
+const IngestEventSchema = z.object({
+	name: z.string().min(1),
+	properties: z.record(z.string(), z.unknown())
+});
+const WorkflowStepSchema = z.discriminatedUnion("action", [
+	z.object({
+		action: z.literal("notify"),
+		payload: WorkflowNotifyPayloadSchema
+	}),
+	z.object({
+		action: z.literal("wait"),
+		duration: z.string()
+	}),
+	z.object({
+		action: z.literal("waitForEvent"),
+		event: z.string(),
+		options: z.object({ timeout: z.string().optional() }).optional()
+	})
+]);
+const CreateWorkflowSchema = z.object({
+	name: z.string().min(1),
+	steps: z.array(WorkflowStepSchema).min(1)
+});
+const UpdateProjectSchema = z.object({
+	rateLimitRpm: z.number().nullable().optional(),
+	throttleLimit: z.number().nullable().optional(),
+	throttleWindowHours: z.number().nullable().optional()
+});
+//#endregion
+//#region src/contracts/events/notification-requested.ts
+/**
+* A high-level notification request as issued by the SDK's `notify()` call.
+*
+* Unlike `notification.created` (which targets a single resolved recipient),
+* this event carries the *unresolved* target — a user id, a segment, or a
+* topic. A downstream resolver stage fans it out into one
+* `notification.created` per matching recipient, applying preference filters.
+*/
+const NotificationTargetSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("user"),
+		userId: z.string().min(1)
+	}),
+	z.object({
+		type: z.literal("segment"),
+		segment: z.string().min(1)
+	}),
+	z.object({
+		type: z.literal("topic"),
+		topic: z.string().min(1)
+	})
+]);
+const NotificationRequestedPayloadSchema = z.object({
+	projectId: z.string().uuid(),
+	target: NotificationTargetSchema,
+	templateId: z.string().min(1),
+	priority: NotificationPrioritySchema.default("normal"),
+	channels: z.array(NotificationChannelSchema).nonempty().optional(),
+	data: z.record(z.string(), z.unknown()).default({}),
+	fallback: z.boolean().default(false),
+	aiPrompts: z.record(z.string(), z.string()).optional(),
+	scheduledAt: z.string().datetime().optional(),
+	idempotencyKey: z.string().optional(),
+	/**
+	* Groups every message this request fans out into, so the send can be
+	* reported on afterwards. Carried unchanged to the delivery log.
+	*/
+	campaignId: z.string().min(1).max(128).optional()
+});
+//#endregion
+//#region src/contracts/events/notification-created.ts
+const NotificationCreatedPayloadSchema = z.object({
+	projectId: z.string().uuid(),
+	recipientId: z.string().min(1),
+	channel: NotificationChannelSchema,
+	priority: NotificationPrioritySchema.default("normal"),
+	templateId: z.string().min(1).optional(),
+	payload: z.record(z.string(), z.unknown()),
+	scheduledAt: z.string().datetime().optional(),
+	idempotencyKey: z.string().optional()
+});
+//#endregion
+//#region src/contracts/events/notification-enriched.ts
+const RecipientProfileSchema = z.object({
+	id: z.string(),
+	email: z.string().email().optional(),
+	phone: z.string().optional(),
+	webhook: z.string().url().optional(),
+	pushTokens: z.array(z.string()).optional(),
+	pushToken: z.string().optional(),
+	locale: z.string().default("en"),
+	timezone: z.string().default("UTC"),
+	preferences: z.object({
+		optedOut: z.boolean().default(false),
+		channels: z.array(NotificationChannelSchema).default([]),
+		quietHours: z.array(z.object({
+			start: z.string(),
+			end: z.string()
+		})).optional()
+	})
+});
+const NotificationEnrichedPayloadSchema = z.object({
+	projectId: z.string().uuid(),
+	rawEventId: z.string().uuid(),
+	recipientId: z.string().min(1),
+	channel: NotificationChannelSchema,
+	priority: NotificationPrioritySchema,
+	templateId: z.string().min(1).optional(),
+	templateVariables: z.record(z.string(), z.unknown()),
+	recipient: RecipientProfileSchema,
+	aiPrompts: z.record(z.string(), z.string()).optional(),
+	scheduledAt: z.string().datetime().optional(),
+	fallbackChain: z.array(NotificationChannelSchema).optional(),
+	/** Campaign this message belongs to, carried from the originating request. */
+	campaignId: z.string().min(1).max(128).optional()
+});
+//#endregion
+//#region src/contracts/events/notification-scheduled.ts
+const NotificationScheduledPayloadSchema = z.object({
+	projectId: z.string().uuid(),
+	enrichedEventId: z.string().uuid(),
+	taskId: z.string().min(1),
+	scheduledAt: z.string().datetime()
+});
+//#endregion
+//#region src/contracts/events/notification-dispatched.ts
+const RenderedContentSchema = z.object({
+	content: z.record(z.string(), z.unknown()),
+	attachments: z.array(z.object({
+		name: z.string(),
+		contentType: z.string(),
+		url: z.string().url()
+	})).optional()
+});
+const DeliveryOptionsSchema = z.object({
+	maxAttempts: z.number().int().positive().default(3),
+	timeoutMs: z.number().int().positive().default(1e4),
+	headers: z.record(z.string(), z.string()).optional()
+});
+const NotificationDispatchedPayloadSchema = z.object({
+	projectId: z.string().uuid(),
+	taskId: z.string().min(1),
+	enrichedEventId: z.string().uuid(),
+	recipientId: z.string().min(1),
+	channel: NotificationChannelSchema,
+	priority: NotificationPrioritySchema,
+	templateId: z.string().min(1).optional(),
+	templateVariables: z.record(z.string(), z.unknown()).default({}),
+	aiPrompts: z.record(z.string(), z.string()).optional(),
+	recipient: RecipientProfileSchema.optional(),
+	renderedContent: RenderedContentSchema,
+	destination: z.string().min(1).optional(),
+	deliveryOptions: DeliveryOptionsSchema,
+	fallbackChain: z.array(NotificationChannelSchema).optional(),
+	throttleAttemptCount: z.number().int().nonnegative().optional(),
+	/** Campaign this message belongs to, carried from the originating request. */
+	campaignId: z.string().min(1).max(128).optional()
+});
+//#endregion
+//#region src/contracts/events/notification-delivered.ts
+const NotificationDeliveredPayloadSchema = z.object({
+	projectId: z.string().uuid(),
+	taskId: z.string().min(1),
+	enrichedEventId: z.string().uuid(),
+	channel: NotificationChannelSchema,
+	deliveredAt: z.string().datetime(),
+	providerMessageId: z.string().optional(),
+	providerResponse: z.record(z.string(), z.unknown()).optional(),
+	templateId: z.string().uuid().optional(),
+	workflowInstanceId: z.string().uuid().optional(),
+	/** Campaign this message belongs to, carried from the originating request. */
+	campaignId: z.string().min(1).max(128).optional()
+});
+//#endregion
+//#region src/contracts/events/notification-failed.ts
+const NotificationFailedPayloadSchema = z.object({
+	projectId: z.string().uuid(),
+	taskId: z.string().min(1),
+	enrichedEventId: z.string().uuid(),
+	channel: NotificationChannelSchema,
+	failureReason: z.string(),
+	failureCode: z.string(),
+	retryable: z.boolean(),
+	attempt: z.number().int().positive(),
+	providerResponse: z.record(z.string(), z.unknown()).optional(),
+	templateId: z.string().uuid().optional(),
+	workflowInstanceId: z.string().uuid().optional(),
+	/** Campaign this message belongs to, carried from the originating request. */
+	campaignId: z.string().min(1).max(128).optional()
+});
+//#endregion
+//#region src/contracts/events/notification-skipped.ts
+const NotificationSkippedPayloadSchema = z.object({
+	projectId: z.string().uuid(),
+	eventId: z.string().uuid(),
+	recipientId: z.string(),
+	reason: z.string()
+});
+//#endregion
+//#region src/contracts/events/notification-canceled.ts
+const NotificationCanceledPayloadSchema = z.object({
+	projectId: z.string().uuid(),
+	taskId: z.string().min(1)
+});
+//#endregion
+//#region src/contracts/events/notification-ai-pending.ts
+const NotificationAiPendingPayloadSchema = z.object({
+	projectId: z.string().uuid(),
+	enrichedEventId: z.string().uuid(),
+	recipientId: z.string().min(1),
+	channel: NotificationChannelSchema,
+	priority: NotificationPrioritySchema,
+	templateId: z.string().min(1).optional(),
+	templateVariables: z.record(z.string(), z.unknown()),
+	recipient: RecipientProfileSchema,
+	aiPrompts: z.record(z.string(), z.string()),
+	scheduledAt: z.string().datetime().optional(),
+	fallbackChain: z.array(NotificationChannelSchema).optional()
+});
+//#endregion
+//#region src/contracts/index.ts
+registry.define("notification.requested", NotificationRequestedPayloadSchema);
+registry.define("notification.created", NotificationCreatedPayloadSchema);
+registry.define("notification.enriched", NotificationEnrichedPayloadSchema);
+registry.define("notification.scheduled", NotificationScheduledPayloadSchema);
+registry.define("notification.dispatched", NotificationDispatchedPayloadSchema);
+registry.define("notification.delivered", NotificationDeliveredPayloadSchema);
+registry.define("notification.failed", NotificationFailedPayloadSchema);
+registry.define("notification.skipped", NotificationSkippedPayloadSchema);
+registry.define("notification.canceled", NotificationCanceledPayloadSchema);
+registry.define("notification.ai_pending", NotificationAiPendingPayloadSchema);
+//#endregion
+//#region src/db/schema.ts
+var schema_exports = /* @__PURE__ */ __exportAll({
+	apiKeyRoleEnum: () => apiKeyRoleEnum,
+	channelEnum: () => channelEnum,
+	contactTopicPreferences: () => contactTopicPreferences,
+	deliveryOutbox: () => deliveryOutbox,
+	insertDeliveryOutboxSchema: () => insertDeliveryOutboxSchema,
+	insertMessageLogSchema: () => insertMessageLogSchema,
+	insertProjectApiKeySchema: () => insertProjectApiKeySchema,
+	insertProjectSchema: () => insertProjectSchema,
+	insertScheduledPayloadSchema: () => insertScheduledPayloadSchema,
+	insertSuppressionSchema: () => insertSuppressionSchema,
+	insertUserChannelPreferenceSchema: () => insertUserChannelPreferenceSchema,
+	insertUserContactSchema: () => insertUserContactSchema,
+	insertUserSchema: () => insertUserSchema,
+	insertUserSegmentSchema: () => insertUserSegmentSchema,
+	insertUserTopicPreferenceSchema: () => insertUserTopicPreferenceSchema,
+	insertWorkflowInstanceSchema: () => insertWorkflowInstanceSchema,
+	insertWorkflowStepSchema: () => insertWorkflowStepSchema,
+	insertWorkflowWaiterSchema: () => insertWorkflowWaiterSchema,
+	messageLogs: () => messageLogs,
+	projectApiKeys: () => projectApiKeys,
+	projects: () => projects,
+	quietHours: () => quietHours,
+	scheduledPayloads: () => scheduledPayloads,
+	selectDeliveryOutboxSchema: () => selectDeliveryOutboxSchema,
+	selectMessageLogSchema: () => selectMessageLogSchema,
+	selectProjectApiKeySchema: () => selectProjectApiKeySchema,
+	selectProjectSchema: () => selectProjectSchema,
+	selectScheduledPayloadSchema: () => selectScheduledPayloadSchema,
+	selectSuppressionSchema: () => selectSuppressionSchema,
+	selectUserChannelPreferenceSchema: () => selectUserChannelPreferenceSchema,
+	selectUserContactSchema: () => selectUserContactSchema,
+	selectUserSchema: () => selectUserSchema,
+	selectUserSegmentSchema: () => selectUserSegmentSchema,
+	selectUserTopicPreferenceSchema: () => selectUserTopicPreferenceSchema,
+	selectWorkflowInstanceSchema: () => selectWorkflowInstanceSchema,
+	selectWorkflowStepSchema: () => selectWorkflowStepSchema,
+	selectWorkflowWaiterSchema: () => selectWorkflowWaiterSchema,
+	suppressions: () => suppressions,
+	templates: () => templates,
+	userChannelPreferences: () => userChannelPreferences,
+	userContacts: () => userContacts,
+	userSegments: () => userSegments,
+	userTopicPreferences: () => userTopicPreferences,
+	users: () => users,
+	workflowDefinitions: () => workflowDefinitions,
+	workflowInstances: () => workflowInstances,
+	workflowStatusEnum: () => workflowStatusEnum,
+	workflowSteps: () => workflowSteps,
+	workflowWaiters: () => workflowWaiters
+});
+const channelEnum = pgEnum("channel", [
+	"email",
+	"sms",
+	"push",
+	"webhook",
+	"in-app"
+]);
+const projects = pgTable("projects", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	name: varchar("name").notNull(),
+	rateLimitRpm: integer("rate_limit_rpm"),
+	throttleLimit: integer("throttle_limit"),
+	throttleWindowHours: integer("throttle_window_hours"),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+});
+const users = pgTable("users", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	projectId: uuid("project_id").notNull(),
+	externalId: text("external_id").notNull(),
+	attributes: jsonb("attributes").notNull().default({}),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
+}, (table) => ({ unq: unique().on(table.projectId, table.externalId) }));
+const apiKeyRoleEnum = pgEnum("api_key_role", ["admin", "read_only"]);
+const projectApiKeys = pgTable("project_api_keys", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+	keyHash: varchar("key_hash").notNull().unique(),
+	role: apiKeyRoleEnum("role").notNull().default("admin"),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+});
+const userSegments = pgTable("user_segments", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+	segment: varchar("segment").notNull()
+}, (table) => ({
+	unq: unique().on(table.userId, table.segment),
+	segmentIdx: index("segment_idx").on(table.segment)
+}));
+const userContacts = pgTable("user_contacts", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+	channel: channelEnum("channel").notNull(),
+	target: text("target").notNull(),
+	label: text("label"),
+	isPrimary: boolean("is_primary").notNull().default(false),
+	enabled: boolean("enabled").notNull().default(true),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+}, (table) => ({ unq: unique().on(table.userId, table.channel, table.target) }));
+const userChannelPreferences = pgTable("user_channel_preferences", {
+	userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+	channel: channelEnum("channel").notNull(),
+	enabled: boolean("enabled").notNull()
+}, (table) => ({ pk: primaryKey({ columns: [table.userId, table.channel] }) }));
+const userTopicPreferences = pgTable("user_topic_preferences", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+	topic: varchar("topic").notNull(),
+	enabled: boolean("enabled").notNull()
+}, (table) => ({ unq: unique().on(table.userId, table.topic) }));
+const contactTopicPreferences = pgTable("contact_topic_preferences", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	contactId: uuid("contact_id").notNull().references(() => userContacts.id, { onDelete: "cascade" }),
+	topic: varchar("topic").notNull(),
+	enabled: boolean("enabled").notNull()
+}, (table) => ({ unq: unique().on(table.contactId, table.topic) }));
+const quietHours = pgTable("quiet_hours", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	userId: uuid("user_id").references(() => users.id, { onDelete: "cascade" }),
+	contactId: uuid("contact_id").references(() => userContacts.id, { onDelete: "cascade" }),
+	startTime: time("start_time").notNull(),
+	endTime: time("end_time").notNull()
+}, (table) => ({
+	checkOwner: check("check_owner", sql`num_nonnulls(user_id, contact_id) = 1`),
+	userIdIdx: index("quiet_hours_user_idx").on(table.userId)
+}));
+const templates = pgTable("templates", {
+	projectId: uuid("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+	id: varchar("id").notNull(),
+	channel: channelEnum("channel").notNull(),
+	topics: text("topics").array().notNull(),
+	content: jsonb("content").notNull(),
+	aiPrompts: jsonb("ai_prompts"),
+	updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
+}, (table) => ({ pk: primaryKey({ columns: [table.projectId, table.id] }) }));
+const messageLogs = pgTable("message_logs", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	projectId: uuid("project_id").notNull(),
+	taskId: varchar("task_id").notNull(),
+	providerMessageId: varchar("provider_message_id"),
+	templateId: varchar("template_id"),
+	workflowInstanceId: uuid("workflow_instance_id"),
+	channel: channelEnum("channel").notNull(),
+	attempt: integer("attempt").default(1).notNull(),
+	/**
+	* Discriminates a delivery attempt ("attempt") from a provider engagement
+	* event ("opened", "clicked", "bounced", …). Without it an engagement row
+	* collides with the delivery row for the same (task, channel, attempt).
+	*/
+	kind: varchar("kind").notNull().default("attempt"),
+	status: varchar("status").notNull(),
+	/**
+	* Groups every message produced by one `notify()` call. Null for sends that
+	* did not name a campaign, which is every send made before this column
+	* existed — treat null as "unattributed", not as a campaign of its own.
+	*/
+	campaignId: varchar("campaign_id"),
+	/**
+	* Provider-specific detail that would otherwise be discarded: the clicked
+	* URL on a click event, the bounce subtype on a bounce. Deliberately loose
+	* — every provider reports these differently.
+	*/
+	metadata: jsonb("metadata"),
+	timestamp: timestamp("timestamp", { withTimezone: true }).defaultNow().notNull()
+}, (table) => ({
+	projectIdx: index("message_logs_project_idx").on(table.projectId),
+	taskIdx: index("task_idx").on(table.taskId),
+	projectIdTaskIdIdx: index("message_logs_project_task_idx").on(table.projectId, table.taskId),
+	providerMsgIdx: index("provider_msg_idx").on(table.providerMessageId),
+	projectTimeIdx: index("msg_log_proj_time_idx").on(table.projectId, table.timestamp),
+	templateIdx: index("msg_log_template_idx").on(table.projectId, table.templateId),
+	workflowIdx: index("msg_log_workflow_idx").on(table.projectId, table.workflowInstanceId),
+	campaignIdx: index("msg_log_campaign_idx").on(table.projectId, table.campaignId),
+	taskChannelAttemptUidx: unique("task_channel_attempt_uidx").on(table.taskId, table.channel, table.attempt, table.kind)
+}));
+/**
+* Addresses that must not be contacted again on a given channel.
+*
+* Rows are written from provider webhooks (an unsubscribe, a spam complaint, a
+* hard bounce) and by hand through the API. The engine consults this table
+* before dispatching, so a suppression is a hard stop rather than a preference
+* — `priority: "critical"` does not override it. Removing a row is the only way
+* back, and that is deliberately a manual act.
+*/
+const suppressions = pgTable("suppressions", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	projectId: uuid("project_id").notNull(),
+	channel: channelEnum("channel").notNull(),
+	/** The address itself, normalised: email is lower-cased, others stored verbatim. */
+	target: varchar("target").notNull(),
+	/** `unsubscribed` | `complained` | `bounced` | `manual`. */
+	reason: varchar("reason").notNull(),
+	/** Where it came from — a provider name, or `api` for a manual entry. */
+	source: varchar("source"),
+	/** The delivery that triggered it, when a provider webhook is the origin. */
+	taskId: varchar("task_id"),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+}, (table) => ({
+	projectChannelTargetUidx: unique("suppression_project_channel_target_uidx").on(table.projectId, table.channel, table.target),
+	projectIdx: index("suppression_project_idx").on(table.projectId),
+	lookupIdx: index("suppression_lookup_idx").on(table.projectId, table.channel, table.target)
+}));
+const workflowStatusEnum = pgEnum("workflow_status", [
+	"pending",
+	"running",
+	"completed",
+	"failed"
+]);
+const workflowDefinitions = pgTable("workflow_definitions", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	projectId: uuid("project_id").notNull(),
+	name: varchar("name").notNull(),
+	steps: jsonb("steps").notNull(),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+}, (table) => ({ nameUnq: unique().on(table.projectId, table.name) }));
+const workflowInstances = pgTable("workflow_instances", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	projectId: uuid("project_id").notNull(),
+	name: varchar("name").notNull(),
+	status: workflowStatusEnum("status").notNull().default("pending"),
+	input: jsonb("input").default({}),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+	updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
+}, (table) => ({ nameIdx: index("workflow_name_idx").on(table.name) }));
+const workflowSteps = pgTable("workflow_steps", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	projectId: uuid("project_id").notNull(),
+	instanceId: uuid("instance_id").notNull().references(() => workflowInstances.id, { onDelete: "cascade" }),
+	stepIndex: varchar("step_index").notNull(),
+	action: varchar("action").notNull(),
+	output: jsonb("output"),
+	error: text("error"),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+}, (table) => ({ unq: unique().on(table.instanceId, table.stepIndex) }));
+const workflowWaiters = pgTable("workflow_waiters", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	projectId: uuid("project_id").notNull(),
+	instanceId: uuid("instance_id").notNull().references(() => workflowInstances.id, { onDelete: "cascade" }),
+	eventName: varchar("event_name").notNull(),
+	matchCriteria: jsonb("match_criteria").notNull(),
+	expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+}, (table) => ({
+	eventIdx: index("waiter_event_idx").on(table.eventName),
+	instanceIdx: index("waiter_instance_idx").on(table.instanceId),
+	compositeWaitIdx: index("waiter_comp_idx").on(table.eventName, table.projectId, table.expiresAt),
+	matchCriteriaIdx: index("waiter_match_idx").using("gin", table.matchCriteria)
+}));
+const deliveryOutbox = pgTable("delivery_outbox", {
+	taskId: varchar("task_id").notNull(),
+	channel: channelEnum("channel").notNull(),
+	destination: text("destination").notNull(),
+	providerMessageId: varchar("provider_message_id"),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+}, (table) => ({ pk: primaryKey({ columns: [
+	table.taskId,
+	table.channel,
+	table.destination
+] }) }));
+const scheduledPayloads = pgTable("scheduled_payloads", {
+	taskId: varchar("task_id").primaryKey(),
+	payload: jsonb("payload").notNull(),
+	createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+});
+const insertProjectSchema = createInsertSchema(projects);
+const selectProjectSchema = createSelectSchema(projects);
+const insertProjectApiKeySchema = createInsertSchema(projectApiKeys);
+const selectProjectApiKeySchema = createSelectSchema(projectApiKeys);
+const insertUserSchema = createInsertSchema(users);
+const selectUserSchema = createSelectSchema(users);
+const insertUserSegmentSchema = createInsertSchema(userSegments);
+const selectUserSegmentSchema = createSelectSchema(userSegments);
+const insertUserContactSchema = createInsertSchema(userContacts);
+const selectUserContactSchema = createSelectSchema(userContacts);
+const insertUserChannelPreferenceSchema = createInsertSchema(userChannelPreferences);
+const selectUserChannelPreferenceSchema = createSelectSchema(userChannelPreferences);
+const insertUserTopicPreferenceSchema = createInsertSchema(userTopicPreferences);
+const selectUserTopicPreferenceSchema = createSelectSchema(userTopicPreferences);
+const insertMessageLogSchema = createInsertSchema(messageLogs);
+const selectMessageLogSchema = createSelectSchema(messageLogs);
+const insertSuppressionSchema = createInsertSchema(suppressions);
+const selectSuppressionSchema = createSelectSchema(suppressions);
+const insertWorkflowInstanceSchema = createInsertSchema(workflowInstances);
+const selectWorkflowInstanceSchema = createSelectSchema(workflowInstances);
+const insertWorkflowStepSchema = createInsertSchema(workflowSteps);
+const selectWorkflowStepSchema = createSelectSchema(workflowSteps);
+const insertWorkflowWaiterSchema = createInsertSchema(workflowWaiters);
+const selectWorkflowWaiterSchema = createSelectSchema(workflowWaiters);
+const insertDeliveryOutboxSchema = createInsertSchema(deliveryOutbox);
+const selectDeliveryOutboxSchema = createSelectSchema(deliveryOutbox);
+const insertScheduledPayloadSchema = createInsertSchema(scheduledPayloads);
+const selectScheduledPayloadSchema = createSelectSchema(scheduledPayloads);
+//#endregion
+//#region src/db/index.ts
+var db_exports = /* @__PURE__ */ __exportAll({
+	createDatabase: () => createDatabase,
+	runMigrations: () => runMigrations
+});
+/**
+* Create a postgres.js connection pool and initialize Drizzle ORM.
+* Call once at application startup; pass db into repositories.
+* Call sql.end() during graceful shutdown.
+*/
+function createDatabase({ url, applicationName = "notifkit", maxConnections, idleTimeoutSeconds = 30, logger }) {
+	const finalMaxConnections = maxConnections ?? readBaseConfig().DB_MAX_CONNECTIONS;
+	const sql = postgres(url, {
+		max: finalMaxConnections,
+		idle_timeout: idleTimeoutSeconds,
+		connection: {
+			application_name: applicationName,
+			statement_timeout: 1e4
+		},
+		onnotice: (notice) => {
+			logger?.debug({ notice }, "postgres notice");
+		}
+	});
+	return {
+		sql,
+		db: drizzle(sql, { schema: schema_exports })
+	};
+}
+async function runMigrations(db) {
+	const __filename = fileURLToPath(import.meta.url);
+	const __dirname = path.dirname(__filename);
+	let migrationsFolder = path.resolve(__dirname, "../../drizzle");
+	if (!fs.existsSync(migrationsFolder)) migrationsFolder = path.resolve(__dirname, "../drizzle");
+	await migrate(db, { migrationsFolder });
+}
+//#endregion
+//#region src/idempotency/index.ts
+/**
+* SETNX-based idempotency guard.
+* Returns true from checkAndMark() only the first time a given ID is seen
+* within the TTL window; subsequent calls return false (duplicate / retry).
+*/
+var IdempotencyGuard = class {
+	redis;
+	keyPrefix;
+	ttlSeconds;
+	constructor({ redis, keyPrefix, ttlSeconds = 86400 }) {
+		this.redis = redis;
+		this.keyPrefix = keyPrefix;
+		this.ttlSeconds = ttlSeconds;
+	}
+	key(id) {
+		return `${this.keyPrefix}:${id}`;
+	}
+	/** Atomically mark id as processed. Returns true on first call; false if already seen. */
+	async checkAndMark(id, customTtlSeconds) {
+		const ttl = customTtlSeconds ?? this.ttlSeconds;
+		return await this.redis.set(this.key(id), "1", "EX", ttl, "NX") === "OK";
+	}
+	/** Unconditionally mark id as processed (e.g. to upgrade a short-lived lock). */
+	async markProcessed(id, customTtlSeconds) {
+		const ttl = customTtlSeconds ?? this.ttlSeconds;
+		await this.redis.set(this.key(id), "1", "EX", ttl);
+	}
+	async isProcessed(id) {
+		return await this.redis.get(this.key(id)) !== null;
+	}
+	/** Remove the idempotency marker (useful in tests or manual rollbacks). */
+	async unmark(id) {
+		await this.redis.del(this.key(id));
+	}
+};
+//#endregion
+//#region src/logger/index.ts
+function createLogger({ name, level = "info", pretty, context }) {
+	const usePretty = pretty ?? process.env["NODE_ENV"] !== "production";
+	const options = {
+		name,
+		level,
+		formatters: { level(label) {
+			return { level: label };
+		} },
+		timestamp: pino.stdTimeFunctions.isoTime,
+		serializers: {
+			err: pino.stdSerializers.err,
+			error: pino.stdSerializers.err,
+			req: pino.stdSerializers.req,
+			res: pino.stdSerializers.res
+		},
+		base: {
+			service: name,
+			...context
+		}
+	};
+	if (usePretty) options.transport = {
+		target: "pino-pretty",
+		options: {
+			colorize: true,
+			translateTime: "SYS:standard",
+			ignore: "pid,hostname",
+			messageFormat: "{service} | {msg}"
+		}
+	};
+	return pino(options);
+}
+function withRequestId(logger, requestId) {
+	return logger.child({ requestId });
+}
+function withContext(logger, context) {
+	return logger.child(context);
+}
+function childLogger(logger, bindings) {
+	return logger.child(bindings);
+}
+//#endregion
+//#region src/metrics/index.ts
+const register = new promClient.Registry();
+promClient.collectDefaultMetrics({ register });
+const metrics = {
+	messagesPublished: new promClient.Counter({
+		name: "notifkit_messages_published_total",
+		help: "Total messages published to inbound streams",
+		labelNames: ["channel", "priority"],
+		registers: [register]
+	}),
+	messagesProcessed: new promClient.Counter({
+		name: "notifkit_messages_processed_total",
+		help: "Total messages processed by workers",
+		labelNames: ["worker", "status"],
+		registers: [register]
+	}),
+	deliverySuccess: new promClient.Counter({
+		name: "notifkit_delivery_success_total",
+		help: "Total successful deliveries",
+		labelNames: ["channel"],
+		registers: [register]
+	}),
+	deliveryFailed: new promClient.Counter({
+		name: "notifkit_delivery_failed_total",
+		help: "Total failed deliveries",
+		labelNames: ["channel", "reason"],
+		registers: [register]
+	}),
+	workerActiveTasks: new promClient.Gauge({
+		name: "notifkit_worker_active_tasks",
+		help: "Number of currently active tasks per worker",
+		labelNames: ["worker"],
+		registers: [register]
+	}),
+	queueSize: new promClient.Gauge({
+		name: "notifkit_queue_size",
+		help: "Current size of streams",
+		labelNames: ["stream"],
+		registers: [register]
+	}),
+	pendingAcks: new promClient.Gauge({
+		name: "notifkit_pending_acks",
+		help: "Number of pending un-acked messages per group",
+		labelNames: ["group"],
+		registers: [register]
+	})
+};
+function getMetricsRegistry() {
+	return register;
+}
+//#endregion
+//#region src/queue/index.ts
+function parseMessage(id, fields, logger) {
+	if (!fields) return null;
+	const dataIndex = fields.indexOf("data");
+	if (dataIndex === -1) return null;
+	const raw = fields[dataIndex + 1];
+	if (!raw) return null;
+	let decoded;
+	try {
+		decoded = JSON.parse(raw);
+	} catch (err) {
+		logger?.warn({
+			id,
+			err
+		}, "failed to parse stream event JSON");
+		return null;
+	}
+	const parsed = StreamEventSchema.safeParse(decoded);
+	if (!parsed.success) {
+		logger?.warn({
+			id,
+			error: parsed.error.issues
+		}, "failed to parse stream event");
+		return null;
+	}
+	return {
+		id,
+		event: parsed.data
+	};
+}
+var StreamProducer = class {
+	redis;
+	stream;
+	logger;
+	maxLen;
+	constructor({ redis, stream, logger, maxLen }) {
+		this.redis = redis;
+		this.stream = stream;
+		this.logger = logger;
+		this.maxLen = maxLen ?? readBaseConfig().QUEUE_MAX_LEN;
+	}
+	async publish(partial) {
+		const event = {
+			...partial,
+			id: crypto.randomUUID(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		const messageId = await this.redis.xadd(this.stream, "MAXLEN", "~", String(this.maxLen), "*", "data", JSON.stringify(event));
+		if (!messageId) throw new Error(`XADD to ${this.stream} returned null`);
+		this.logger?.debug({
+			stream: this.stream,
+			messageId,
+			eventType: event.type,
+			eventId: event.id
+		}, "event published");
+		return messageId;
+	}
+	async monitorMaxLen(stream) {
+		if (Math.random() < .05) try {
+			const len = await this.redis.xlen(stream);
+			metrics.queueSize.set({ stream }, len);
+			if (len > this.maxLen * .8) this.logger?.warn({
+				stream,
+				len,
+				maxLen: this.maxLen
+			}, "stream is nearing MAXLEN limit (80%+)");
+			const dlqLen = await this.redis.xlen(STREAMS.DEAD_LETTER);
+			metrics.queueSize.set({ stream: STREAMS.DEAD_LETTER }, dlqLen);
+		} catch (err) {
+			this.logger?.debug({ err }, "failed to monitor stream length");
+		}
+	}
+	async publishBatch(partials) {
+		if (partials.length === 0) return {
+			messageIds: [],
+			eventIds: []
+		};
+		const pipeline = this.redis.pipeline();
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		const eventIds = [];
+		for (const partial of partials) {
+			const id = crypto.randomUUID();
+			eventIds.push(id);
+			const event = {
+				...partial,
+				id,
+				timestamp
+			};
+			pipeline.xadd(this.stream, "MAXLEN", "~", String(this.maxLen), "*", "data", JSON.stringify(event));
+		}
+		const results = await pipeline.exec();
+		if (!results) throw new Error(`Pipeline execution failed for ${this.stream}`);
+		const messageIds = [];
+		for (let i = 0; i < results.length; i++) {
+			const result = results[i];
+			if (!result) throw new Error("Pipeline result is undefined");
+			const [err, msgId] = result;
+			if (err) throw err;
+			messageIds.push(msgId);
+		}
+		this.logger?.debug({
+			stream: this.stream,
+			count: partials.length
+		}, "batch events published");
+		this.monitorMaxLen(this.stream).catch(() => {});
+		return {
+			messageIds,
+			eventIds
+		};
+	}
+};
+var StreamConsumer = class {
+	redis;
+	blockingRedis;
+	streams;
+	group;
+	consumer;
+	dlqStream;
+	logger;
+	batchSize;
+	blockMs;
+	running = false;
+	constructor({ redis, stream, group, consumer, dlqStream, logger, batchSize = 10, blockMs = 5e3 }) {
+		this.redis = redis;
+		this.blockingRedis = redis.duplicate();
+		this.streams = Array.isArray(stream) ? stream : [stream];
+		this.group = group;
+		this.consumer = consumer;
+		this.dlqStream = dlqStream;
+		this.logger = logger;
+		this.batchSize = batchSize;
+		this.blockMs = blockMs;
+	}
+	async ensureGroup() {
+		for (const s of this.streams) try {
+			await this.redis.xgroup("CREATE", s, this.group, "0", "MKSTREAM");
+			this.logger?.info({
+				stream: s,
+				group: this.group
+			}, "consumer group created");
+		} catch (err) {
+			if (err instanceof Error && err.message.includes("BUSYGROUP")) {
+				this.logger?.debug({
+					stream: s,
+					group: this.group
+				}, "consumer group already exists");
+				continue;
+			}
+			throw err;
+		}
+	}
+	async *readBatch() {
+		this.running = true;
+		let retryDelay = 1e3;
+		while (this.running) try {
+			let currentStreams = [...this.streams];
+			if (currentStreams.length > 1 && Math.random() < .1) {
+				const offset = Math.floor(Math.random() * (currentStreams.length - 1)) + 1;
+				for (let i = 0; i < offset; i++) currentStreams.push(currentStreams.shift());
+			}
+			let results;
+			let deadConnectionTimer;
+			try {
+				results = await Promise.race([this.blockingRedis.xreadgroup("GROUP", this.group, this.consumer, "COUNT", String(this.batchSize), "BLOCK", String(this.blockMs), "STREAMS", ...currentStreams, ...currentStreams.map(() => ">")), new Promise((_, reject) => {
+					deadConnectionTimer = setTimeout(() => reject(/* @__PURE__ */ new Error("XREADGROUP_TIMEOUT_DEAD_CONNECTION")), this.blockMs + 5e3);
+				})]);
+			} catch (err) {
+				if (err.message === "XREADGROUP_TIMEOUT_DEAD_CONNECTION") {
+					this.logger?.warn("XREADGROUP took too long, assuming dead connection. Disconnecting...");
+					this.blockingRedis.disconnect();
+					throw err;
+				}
+				throw err;
+			} finally {
+				clearTimeout(deadConnectionTimer);
+			}
+			retryDelay = 1e3;
+			if (!results) continue;
+			const batch = [];
+			for (const [streamName, messages] of results) for (const [id, fields] of messages) {
+				const msg = parseMessage(id, fields, this.logger);
+				if (!msg) {
+					await this.redis.xack(streamName, this.group, id);
+					continue;
+				}
+				msg.stream = streamName;
+				batch.push(msg);
+			}
+			if (batch.length > 0) yield batch;
+		} catch (err) {
+			if (!this.running && err instanceof Error && err?.message?.toLowerCase?.().includes("connection is closed")) break;
+			this.logger?.error({ err }, "error reading from stream");
+			await new Promise((resolve) => setTimeout(resolve, retryDelay));
+			retryDelay = Math.min(retryDelay * 2, 3e4);
+		}
+	}
+	async ack(messageId, stream) {
+		const s = stream ?? this.streams[0];
+		const ids = Array.isArray(messageId) ? messageId : [messageId];
+		if (ids.length === 0) return;
+		await this.redis.xack(s, this.group, ...ids);
+		this.logger?.debug({
+			stream: s,
+			count: ids.length
+		}, "messages acknowledged");
+	}
+	async nack(messageId, event, stream) {
+		const s = stream ?? this.streams[0];
+		if (this.dlqStream) {
+			const dlqId = await this.redis.xadd(this.dlqStream, "*", "data", JSON.stringify({
+				...event,
+				dlq: {
+					originalStream: s,
+					ackedAt: (/* @__PURE__ */ new Date()).toISOString()
+				}
+			}));
+			if (!dlqId) throw new Error(`XADD to dead-letter stream ${this.dlqStream} returned null`);
+			await this.redis.xack(s, this.group, messageId);
+			this.logger?.warn({
+				stream: s,
+				dlqStream: this.dlqStream,
+				messageId,
+				eventId: event.id,
+				dlqId
+			}, "message moved to dead-letter queue and acked");
+		} else await this.ack(messageId, s);
+	}
+	async stop() {
+		this.running = false;
+		try {
+			await this.blockingRedis.quit();
+		} catch (err) {
+			if (!err?.message?.toLowerCase?.().includes("connection is closed")) throw err;
+		}
+	}
+};
+var PendingMessageScanner = class {
+	redis;
+	streams;
+	group;
+	consumer;
+	logger;
+	constructor({ redis, stream, group, consumer, logger }) {
+		this.redis = redis;
+		this.streams = Array.isArray(stream) ? stream : [stream];
+		this.group = group;
+		this.consumer = consumer;
+		this.logger = logger;
+	}
+	async getPendingCount() {
+		let total = 0;
+		for (const s of this.streams) {
+			const summary = await this.redis.xpending(s, this.group);
+			if (Array.isArray(summary) && summary.length > 0) {
+				const count = summary[0];
+				if (typeof count === "number") total += count;
+			}
+		}
+		return total;
+	}
+	/** Pending entries for one stream, or across all of them when `stream` is omitted. */
+	async getPendingEntries(limit = 100, stream) {
+		const streams = stream ? [stream] : this.streams;
+		const allEntries = [];
+		for (const s of streams) {
+			const result = await this.redis.xpending(s, this.group, "-", "+", limit);
+			if (Array.isArray(result)) {
+				for (const item of result) if (Array.isArray(item)) allEntries.push({
+					id: item[0],
+					consumer: item[1],
+					idleMs: item[2],
+					deliveryCount: item[3],
+					stream: s
+				});
+			}
+			if (allEntries.length >= limit) break;
+		}
+		return allEntries.slice(0, limit);
+	}
+	async autoclaim(minIdleMs, limit = 10) {
+		const recovered = [];
+		for (const s of this.streams) {
+			if (recovered.length >= limit) break;
+			const toClaim = (await this.getPendingEntries(limit * 2, s)).filter((p) => p.idleMs > minIdleMs * Math.pow(2, p.deliveryCount - 1)).slice(0, limit - recovered.length);
+			if (toClaim.length === 0) continue;
+			const ids = toClaim.map((p) => p.id);
+			const result = await this.redis.xclaim(s, this.group, this.consumer, minIdleMs, ...ids);
+			for (const raw of result) {
+				if (!raw) continue;
+				const [id, fields] = raw;
+				const msg = parseMessage(id, fields, this.logger);
+				if (msg) {
+					msg.stream = s;
+					recovered.push(msg);
+				}
+			}
+		}
+		if (recovered.length > 0) this.logger?.info({
+			group: this.group,
+			count: recovered.length
+		}, "autoclaimed pending messages");
+		return recovered;
+	}
+};
+//#endregion
+//#region src/shared/events.ts
+const globalEmitter = new EventEmitter();
+//#endregion
+//#region src/shared/cache.ts
+var LRUCache = class {
+	cache = /* @__PURE__ */ new Map();
+	maxSize;
+	defaultTtlMs;
+	constructor(maxSize = 1e3, defaultTtlMs = 3e5) {
+		this.maxSize = maxSize;
+		this.defaultTtlMs = defaultTtlMs;
+	}
+	get(key) {
+		const item = this.cache.get(key);
+		if (!item) return void 0;
+		if (Date.now() > item.expiresAt) {
+			this.cache.delete(key);
+			return;
+		}
+		this.cache.delete(key);
+		this.cache.set(key, item);
+		return item.value;
+	}
+	set(key, value, ttlMs = this.defaultTtlMs) {
+		if (this.cache.has(key)) this.cache.delete(key);
+		else if (this.cache.size >= this.maxSize) {
+			const oldestKey = this.cache.keys().next().value;
+			if (oldestKey !== void 0) this.cache.delete(oldestKey);
+		}
+		this.cache.set(key, {
+			value,
+			expiresAt: Date.now() + ttlMs
+		});
+	}
+	delete(key) {
+		this.cache.delete(key);
+	}
+	clear() {
+		this.cache.clear();
+	}
+};
+//#endregion
+//#region src/shared/utils.ts
+function getPriorityBucket(priority) {
+	const p = priority || "normal";
+	return p === "critical" || p === "high" ? "critical" : p === "low" ? "low" : "normal";
+}
+/**
+* Canonical form of a destination, for suppression lookups.
+*
+* Both the writer (the provider webhook) and the reader (the engine's
+* pre-dispatch gate) must agree on this, or an unsubscribe recorded as
+* `Bob@Example.com` will not match a send addressed to `bob@example.com` and
+* the person keeps receiving mail. Case folding is safe for email domains and
+* for the local part in every mailbox provider in practice; phone numbers and
+* push tokens are case-sensitive and are only trimmed.
+*/
+function normaliseTarget(target) {
+	const trimmed = target.trim();
+	return trimmed.includes("@") ? trimmed.toLowerCase() : trimmed;
+}
+const LUA_SCHEDULER_POLL = `
+  local key = KEYS[1]
+  local maxScore = tonumber(ARGV[1])
+  local limit = tonumber(ARGV[2])
+  local visibilityTimeout = tonumber(ARGV[3]) or 0
+  local tasks = redis.call('ZRANGE', key, 0, maxScore, 'BYSCORE', 'LIMIT', 0, limit)
+  if #tasks > 0 then
+    for i, task in ipairs(tasks) do
+      redis.call('ZADD', key, maxScore + visibilityTimeout, task)
+    end
+  end
+  return tasks
+`;
+const LUA_SCHEDULER_CLAIM = `
+  local payloadKey = KEYS[1]
+  local claimedKey = KEYS[2]
+  
+  if redis.call('EXISTS', payloadKey) == 1 then
+    redis.call('RENAME', payloadKey, claimedKey)
+    return redis.call('GET', claimedKey)
+  elseif redis.call('EXISTS', claimedKey) == 1 then
+    return redis.call('GET', claimedKey)
+  else
+    return nil
+  end
+`;
+/** Release a lock only if we still hold it (value matches our token). */
+const LUA_RELEASE_LOCK = `
+  if redis.call('GET', KEYS[1]) == ARGV[1] then
+    return redis.call('DEL', KEYS[1])
+  end
+  return 0
+`;
+/** Extend a lock's TTL only if we still hold it. */
+const LUA_RENEW_LOCK = `
+  if redis.call('GET', KEYS[1]) == ARGV[1] then
+    return redis.call('EXPIRE', KEYS[1], ARGV[2])
+  end
+  return 0
+`;
+//#endregion
+//#region src/shared/semaphore.ts
+var AsyncSemaphore = class {
+	max;
+	count = 0;
+	queue = [];
+	constructor(max) {
+		this.max = max;
+	}
+	async acquire() {
+		if (this.count < this.max) {
+			this.count++;
+			return Promise.resolve();
+		}
+		return new Promise((resolve) => {
+			this.queue.push(resolve);
+		});
+	}
+	release() {
+		if (this.queue.length > 0) this.queue.shift()();
+		else if (this.count > 0) this.count--;
+	}
+	get activeCount() {
+		return this.count;
+	}
+};
+//#endregion
+//#region src/shared/batch-processor.ts
+var BatchProcessor = class {
+	maxSize;
+	maxWaitMs;
+	flushFn;
+	buffer = [];
+	timer = null;
+	isFlushing = false;
+	constructor(maxSize, maxWaitMs, flushFn) {
+		this.maxSize = maxSize;
+		this.maxWaitMs = maxWaitMs;
+		this.flushFn = flushFn;
+	}
+	add(item) {
+		return new Promise((resolve, reject) => {
+			this.buffer.push({
+				item,
+				resolve,
+				reject
+			});
+			if (this.buffer.length >= this.maxSize && !this.isFlushing) {
+				if (this.timer) {
+					clearTimeout(this.timer);
+					this.timer = null;
+				}
+				this.flush();
+			} else if (!this.timer && !this.isFlushing) this.timer = setTimeout(() => {
+				this.timer = null;
+				this.flush();
+			}, this.maxWaitMs);
+		});
+	}
+	async flush() {
+		if (this.isFlushing || this.buffer.length === 0) return;
+		this.isFlushing = true;
+		const batch = this.buffer;
+		this.buffer = [];
+		try {
+			const items = batch.map((b) => b.item);
+			const results = await this.flushFn(items);
+			for (let i = 0; i < batch.length; i++) batch[i].resolve(results[i]);
+		} catch (err) {
+			for (const b of batch) b.reject(err);
+		} finally {
+			this.isFlushing = false;
+			if (this.buffer.length > 0 && !this.timer) if (this.buffer.length >= this.maxSize) this.flush();
+			else this.timer = setTimeout(() => {
+				this.timer = null;
+				this.flush();
+			}, this.maxWaitMs);
+		}
+	}
+};
+//#endregion
+//#region src/shared/circuit-breaker.ts
+var CircuitBreaker = class {
+	state = "CLOSED";
+	failures = 0;
+	nextAttemptAt = 0;
+	/** True while one caller is testing whether the dependency has recovered. */
+	probeInFlight = false;
+	threshold;
+	timeout;
+	constructor(options) {
+		this.threshold = options.failureThreshold;
+		this.timeout = options.resetTimeoutMs;
+	}
+	async execute(action) {
+		let isProbe = false;
+		if (this.state === "OPEN") if (Date.now() > this.nextAttemptAt && !this.probeInFlight) {
+			this.state = "HALF_OPEN";
+			this.probeInFlight = true;
+			isProbe = true;
+		} else throw new Error("Circuit breaker is OPEN");
+		else if (this.state === "HALF_OPEN") {
+			if (this.probeInFlight) throw new Error("Circuit breaker is OPEN");
+			this.probeInFlight = true;
+			isProbe = true;
+		}
+		try {
+			const result = await action();
+			this.onSuccess();
+			return result;
+		} catch (err) {
+			this.onFailure();
+			throw err;
+		} finally {
+			if (isProbe) this.probeInFlight = false;
+		}
+	}
+	onSuccess() {
+		this.failures = 0;
+		this.state = "CLOSED";
+	}
+	onFailure() {
+		this.failures++;
+		if (this.failures >= this.threshold) {
+			this.state = "OPEN";
+			this.nextAttemptAt = Date.now() + this.timeout;
+		}
+	}
+	getState() {
+		return this.state;
+	}
+};
+//#endregion
+//#region src/shared/dataloader.ts
+var DataLoader = class {
+	batchLoadFn;
+	keys = [];
+	promises = [];
+	currentTick = null;
+	constructor(batchLoadFn) {
+		this.batchLoadFn = batchLoadFn;
+	}
+	load(key) {
+		return new Promise((resolve, reject) => {
+			this.keys.push(key);
+			this.promises.push({ resolve: (value) => {
+				if (value instanceof Error) reject(value);
+				else resolve(value);
+			} });
+			if (!this.currentTick) this.currentTick = Promise.resolve().then(() => {
+				const keysToLoad = this.keys;
+				const currentPromises = this.promises;
+				this.keys = [];
+				this.promises = [];
+				this.currentTick = null;
+				this.batchLoadFn(keysToLoad).then((results) => {
+					for (let i = 0; i < currentPromises.length; i++) currentPromises[i].resolve(results[i]);
+				}).catch((err) => {
+					for (const p of currentPromises) p.resolve(err);
+				});
+			});
+		});
+	}
+};
+//#endregion
+//#region src/shared/index.ts
+function generateId() {
+	return randomUUID();
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var AppError = class extends Error {
+	code;
+	constructor(message, code, options) {
+		super(message, options);
+		this.name = "AppError";
+		this.code = code;
+	}
+};
+var ValidationError = class extends AppError {
+	fields;
+	constructor(message, fields, options) {
+		super(message, "VALIDATION_ERROR", options);
+		this.name = "ValidationError";
+		this.fields = fields;
+	}
+};
+//#endregion
+//#region src/rate-limiter/index.ts
+const NO_OVERRIDES = {
+	throttleLimit: null,
+	throttleWindowHours: null
+};
+/**
+* Caches per-project throttle overrides for the engine.
+*
+* The throttle check runs once per notification, so an uncached lookup here
+* would put a Postgres round trip on the hot path. Projects with no overrides
+* are cached as well — the common case must not cost a query per message.
+*
+* The TTL bounds staleness on its own; `invalidate()` exists so a settings
+* change published over pub/sub applies immediately rather than at expiry.
+*/
+var ProjectSettingsCache = class {
+	load;
+	cache;
+	/**
+	* Lookups already on the wire, keyed by project.
+	*
+	* The cache only fills once a query has come back, so without this a cold
+	* project at the start of a campaign puts one query per in-flight message on
+	* Postgres before the first answer lands — exactly when the database is
+	* busiest. Followers wait on the leader's promise instead.
+	*/
+	inFlight = /* @__PURE__ */ new Map();
+	constructor(load, { maxSize = 1e3, ttlMs = 6e4 } = {}) {
+		this.load = load;
+		this.cache = new LRUCache(maxSize, ttlMs);
+	}
+	/**
+	* Throws whatever the loader throws. The caller decides whether a settings
+	* lookup failure should drop the message or fall back to defaults.
+	*/
+	async get(projectId) {
+		const cached = this.cache.get(projectId);
+		if (cached) return cached;
+		const existing = this.inFlight.get(projectId);
+		if (existing) return existing;
+		let pending;
+		pending = this.load(projectId).then((settings) => {
+			const resolved = settings ?? NO_OVERRIDES;
+			if (this.inFlight.get(projectId) === pending) this.cache.set(projectId, resolved);
+			return resolved;
+		}).finally(() => {
+			if (this.inFlight.get(projectId) === pending) this.inFlight.delete(projectId);
+		});
+		this.inFlight.set(projectId, pending);
+		return pending;
+	}
+	invalidate(projectId) {
+		this.cache.delete(projectId);
+		this.inFlight.delete(projectId);
+	}
+	clear() {
+		this.cache.clear();
+		this.inFlight.clear();
+	}
+};
+/** Reject stored values that would make the window meaningless. */
+function positiveOrNull(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+/** A limit of 0 is a legitimate kill switch, so zero is allowed here. */
+function nonNegativeOrNull(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+var UserThrottle = class {
+	redis;
+	maxPerHour;
+	windowHours;
+	constructor({ redis, maxPerHour = 3, windowHours = 1 }) {
+		this.redis = redis;
+		this.maxPerHour = maxPerHour;
+		this.windowHours = windowHours;
+	}
+	/**
+	* @param projectId Tenant that owns `userId`. User ids are caller-supplied
+	*   external ids, so they collide across tenants and MUST be namespaced —
+	*   otherwise one tenant's traffic throttles another's.
+	* @param options Per-project overrides. Values that are absent, null, or
+	*   nonsensical fall back to this instance's defaults.
+	*/
+	async check(projectId, userId, priority, options = {}) {
+		const limit = nonNegativeOrNull(options.limit) ?? this.maxPerHour;
+		const windowHours = positiveOrNull(options.windowHours) ?? this.windowHours;
+		if (priority === "critical") return {
+			allowed: true,
+			count: 0,
+			limit
+		};
+		const windowMs = windowHours * 36e5;
+		const key = `throttle:${projectId}:user:${userId}`;
+		const targetTime = options.scheduledAt ? new Date(options.scheduledAt).getTime() : Date.now();
+		const windowStart = targetTime - windowMs;
+		const memberId = randomUUID$1();
+		const LUA_THROTTLE = `
+      redis.call("ZREMRANGEBYSCORE", KEYS[1], "-inf", ARGV[1])
+      local count = redis.call("ZCARD", KEYS[1])
+      if tonumber(count) < tonumber(ARGV[2]) then
+        redis.call("ZADD", KEYS[1], tonumber(ARGV[3]), ARGV[4])
+        redis.call("EXPIRE", KEYS[1], tonumber(ARGV[5]))
+        return tonumber(count) + 1
+      end
+      return tonumber(count) + 1
+    `;
+		const windowSeconds = Math.ceil(windowMs / 1e3);
+		const ttlSeconds = Math.max(windowSeconds, Math.ceil((targetTime - Date.now()) / 1e3) + windowSeconds);
+		const count = await this.redis.eval(LUA_THROTTLE, 1, key, windowStart, limit, targetTime, memberId, ttlSeconds);
+		return {
+			allowed: count <= limit,
+			count,
+			limit
+		};
+	}
+};
+//#endregion
+//#region src/redis/index.ts
+var RedisClient = class {
+	native;
+	logger;
+	isClosing = false;
+	constructor({ url, name = "notifkit", logger, redisOptions }) {
+		this.logger = logger;
+		this.native = new Redis(url, {
+			maxRetriesPerRequest: null,
+			enableReadyCheck: true,
+			lazyConnect: false,
+			connectionName: name,
+			...redisOptions
+		});
+		this.native.on("connect", () => {
+			this.logger?.info({ url: redactUrl(url) }, "redis connected");
+		});
+		this.native.on("ready", () => {
+			this.logger?.debug("redis ready");
+		});
+		this.native.on("error", (err) => {
+			this.logger?.error({ err }, "redis client error");
+		});
+		this.native.on("close", () => {
+			if (!this.isClosing) this.logger?.warn("redis connection closed unexpectedly");
+		});
+		this.native.on("reconnecting", () => {
+			this.logger?.warn("redis reconnecting");
+		});
+	}
+	async healthCheck() {
+		try {
+			return await this.native.ping() === "PONG";
+		} catch {
+			return false;
+		}
+	}
+	async disconnect() {
+		this.isClosing = true;
+		this.logger?.info("disconnecting redis");
+		await this.native.quit();
+		this.logger?.info("redis disconnected");
+	}
+};
+function redactUrl(url) {
+	try {
+		const parsed = new URL(url);
+		if (parsed.password) parsed.password = "***";
+		return parsed.toString();
+	} catch {
+		return "[invalid-url]";
+	}
+}
+//#endregion
+//#region src/repositories/index.ts
+var UserRepository = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	async findById(projectId, userId) {
+		const rows = await this.db.select().from(users).where(and(eq(users.externalId, userId), eq(users.projectId, projectId))).limit(1);
+		if (!rows[0]) return null;
+		const attrs = rows[0].attributes;
+		return {
+			userId: rows[0].externalId,
+			language: attrs.language,
+			timezone: attrs.timezone,
+			email: attrs.email
+		};
+	}
+	async findRecordById(projectId, userId) {
+		const userRows = await this.db.select().from(users).where(and(eq(users.externalId, userId), eq(users.projectId, projectId)));
+		if (!userRows[0]) return null;
+		const userRow = userRows[0];
+		const internalId = userRow.id;
+		const attrs = userRow.attributes;
+		const [segmentRows, topicRows, channelRows, qhRows] = await Promise.all([
+			this.db.select().from(userSegments).where(eq(userSegments.userId, internalId)),
+			this.db.select().from(userTopicPreferences).where(eq(userTopicPreferences.userId, internalId)),
+			this.db.select().from(userChannelPreferences).where(eq(userChannelPreferences.userId, internalId)),
+			this.db.select().from(quietHours).where(eq(quietHours.userId, internalId))
+		]);
+		const segments = segmentRows.map((r) => r.segment);
+		const topics = {};
+		for (const r of topicRows) topics[r.topic] = r.enabled;
+		const channels = {};
+		for (const r of channelRows) channels[r.channel] = r.enabled;
+		const quietHoursList = qhRows.map((r) => ({
+			start: r.startTime.slice(0, 5),
+			end: r.endTime.slice(0, 5)
+		}));
+		return {
+			userId: userRow.externalId,
+			language: attrs.language,
+			timezone: attrs.timezone,
+			email: attrs.email,
+			segments,
+			preferences: {
+				channels,
+				topics,
+				quietHours: quietHoursList.length > 0 ? quietHoursList : void 0
+			}
+		};
+	}
+	async findRecordsByIds(projectId, userIds) {
+		if (userIds.length === 0) return [];
+		const usersRows = await this.db.select().from(users).where(and(inArray(users.externalId, userIds), eq(users.projectId, projectId)));
+		if (usersRows.length === 0) return [];
+		const internalIds = usersRows.map((r) => r.id);
+		const [segmentRows, topicRows, channelRows, qhRows] = await Promise.all([
+			this.db.select().from(userSegments).where(inArray(userSegments.userId, internalIds)),
+			this.db.select().from(userTopicPreferences).where(inArray(userTopicPreferences.userId, internalIds)),
+			this.db.select().from(userChannelPreferences).where(inArray(userChannelPreferences.userId, internalIds)),
+			this.db.select().from(quietHours).where(inArray(quietHours.userId, internalIds))
+		]);
+		const segmentsByUserId = /* @__PURE__ */ new Map();
+		for (const r of segmentRows) {
+			if (!segmentsByUserId.has(r.userId)) segmentsByUserId.set(r.userId, []);
+			segmentsByUserId.get(r.userId).push(r.segment);
+		}
+		const topicsByUserId = /* @__PURE__ */ new Map();
+		for (const r of topicRows) {
+			if (!topicsByUserId.has(r.userId)) topicsByUserId.set(r.userId, {});
+			topicsByUserId.get(r.userId)[r.topic] = r.enabled;
+		}
+		const channelsByUserId = /* @__PURE__ */ new Map();
+		for (const r of channelRows) {
+			if (!channelsByUserId.has(r.userId)) channelsByUserId.set(r.userId, {});
+			channelsByUserId.get(r.userId)[r.channel] = r.enabled;
+		}
+		const qhByUserId = /* @__PURE__ */ new Map();
+		for (const r of qhRows) {
+			if (r.userId == null) continue;
+			if (!qhByUserId.has(r.userId)) qhByUserId.set(r.userId, []);
+			qhByUserId.get(r.userId).push({
+				start: r.startTime.slice(0, 5),
+				end: r.endTime.slice(0, 5)
+			});
+		}
+		const userRecords = [];
+		for (const userRow of usersRows) {
+			const attrs = userRow.attributes;
+			const internalId = userRow.id;
+			userRecords.push({
+				userId: userRow.externalId,
+				language: attrs.language,
+				timezone: attrs.timezone,
+				email: attrs.email,
+				segments: segmentsByUserId.get(internalId) || [],
+				preferences: {
+					channels: channelsByUserId.get(internalId) || {},
+					topics: topicsByUserId.get(internalId) || {},
+					quietHours: qhByUserId.get(internalId)
+				}
+			});
+		}
+		return userRecords;
+	}
+	async upsertFull(projectId, user) {
+		await this.db.transaction(async (tx) => {
+			await tx.insert(users).values({
+				projectId,
+				externalId: user.userId,
+				attributes: {
+					language: user.language,
+					timezone: user.timezone,
+					email: user.email
+				}
+			}).onConflictDoUpdate({
+				target: [users.projectId, users.externalId],
+				set: {
+					attributes: {
+						language: user.language,
+						timezone: user.timezone,
+						email: user.email
+					},
+					updatedAt: /* @__PURE__ */ new Date()
+				}
+			});
+			const internalId = (await tx.select({ id: users.id }).from(users).where(and(eq(users.externalId, user.userId), eq(users.projectId, projectId))))[0]?.id;
+			if (!internalId) return;
+			if (user.segments && user.segments.length > 0) await tx.insert(userSegments).values(user.segments.map((s) => ({
+				userId: internalId,
+				segment: s
+			}))).onConflictDoNothing();
+			if (user.preferences && user.preferences.topics) {
+				const topicInserts = Object.entries(user.preferences.topics).map(([topic, enabled]) => ({
+					userId: internalId,
+					topic,
+					enabled
+				}));
+				if (topicInserts.length > 0) await tx.insert(userTopicPreferences).values(topicInserts).onConflictDoUpdate({
+					target: [userTopicPreferences.userId, userTopicPreferences.topic],
+					set: { enabled: sql`excluded.enabled` }
+				});
+			}
+			if (user.preferences?.channels) {
+				const channelInserts = Object.entries(user.preferences.channels).map(([channel, enabled]) => ({
+					userId: internalId,
+					channel,
+					enabled
+				}));
+				if (channelInserts.length > 0) await tx.insert(userChannelPreferences).values(channelInserts).onConflictDoUpdate({
+					target: [userChannelPreferences.userId, userChannelPreferences.channel],
+					set: { enabled: sql`excluded.enabled` }
+				});
+			}
+			if (user.preferences?.quietHours !== void 0) {
+				await tx.delete(quietHours).where(eq(quietHours.userId, internalId));
+				if (user.preferences.quietHours.length > 0) await tx.insert(quietHours).values(user.preferences.quietHours.map((window) => ({
+					userId: internalId,
+					startTime: window.start,
+					endTime: window.end
+				})));
+			}
+		});
+	}
+	async upsertManyFull(projectId, usersList) {
+		if (usersList.length === 0) return;
+		let attempts = 0;
+		while (attempts < 3) try {
+			await this.db.transaction(async (tx) => {
+				await tx.insert(users).values(usersList.map((u) => ({
+					projectId,
+					externalId: u.userId,
+					attributes: {
+						language: u.language,
+						timezone: u.timezone,
+						email: u.email
+					}
+				}))).onConflictDoUpdate({
+					target: [users.projectId, users.externalId],
+					set: {
+						attributes: sql`excluded.attributes`,
+						updatedAt: /* @__PURE__ */ new Date()
+					}
+				});
+				const internalIdRows = await tx.select({
+					id: users.id,
+					externalId: users.externalId
+				}).from(users).where(and(inArray(users.externalId, usersList.map((u) => u.userId)), eq(users.projectId, projectId)));
+				const idMap = new Map(internalIdRows.map((r) => [r.externalId, r.id]));
+				const segmentInserts = [];
+				const topicInserts = [];
+				const channelInserts = [];
+				const quietHoursInserts = [];
+				for (const u of usersList) {
+					const internalId = idMap.get(u.userId);
+					if (!internalId) continue;
+					if (u.segments && u.segments.length > 0) for (const s of u.segments) segmentInserts.push({
+						userId: internalId,
+						segment: s
+					});
+					if (u.preferences?.topics) for (const [topic, enabled] of Object.entries(u.preferences.topics)) topicInserts.push({
+						userId: internalId,
+						topic,
+						enabled
+					});
+					if (u.preferences?.channels) for (const [channel, enabled] of Object.entries(u.preferences.channels)) channelInserts.push({
+						userId: internalId,
+						channel,
+						enabled
+					});
+					if (u.preferences?.quietHours && u.preferences.quietHours.length > 0) for (const window of u.preferences.quietHours) quietHoursInserts.push({
+						userId: internalId,
+						startTime: window.start,
+						endTime: window.end
+					});
+				}
+				const segmentSet = /* @__PURE__ */ new Set();
+				const dedupedSegmentInserts = [];
+				for (const s of segmentInserts) {
+					const key = `${s.userId}:${s.segment}`;
+					if (!segmentSet.has(key)) {
+						segmentSet.add(key);
+						dedupedSegmentInserts.push(s);
+					}
+				}
+				const topicMap = /* @__PURE__ */ new Map();
+				for (const t of topicInserts) topicMap.set(`${t.userId}:${t.topic}`, t);
+				const dedupedTopicInserts = Array.from(topicMap.values());
+				const channelMap = /* @__PURE__ */ new Map();
+				for (const c of channelInserts) channelMap.set(`${c.userId}:${c.channel}`, c);
+				const dedupedChannelInserts = Array.from(channelMap.values());
+				if (dedupedSegmentInserts.length > 0) await tx.insert(userSegments).values(dedupedSegmentInserts).onConflictDoNothing();
+				if (dedupedTopicInserts.length > 0) await tx.insert(userTopicPreferences).values(dedupedTopicInserts).onConflictDoUpdate({
+					target: [userTopicPreferences.userId, userTopicPreferences.topic],
+					set: { enabled: sql`excluded.enabled` }
+				});
+				if (dedupedChannelInserts.length > 0) await tx.insert(userChannelPreferences).values(dedupedChannelInserts).onConflictDoUpdate({
+					target: [userChannelPreferences.userId, userChannelPreferences.channel],
+					set: { enabled: sql`excluded.enabled` }
+				});
+				const internalIdsToClearQuietHours = usersList.filter((u) => u.preferences?.quietHours !== void 0).map((u) => idMap.get(u.userId)).filter(Boolean);
+				if (internalIdsToClearQuietHours.length > 0) await tx.delete(quietHours).where(inArray(quietHours.userId, internalIdsToClearQuietHours));
+				if (quietHoursInserts.length > 0) await tx.insert(quietHours).values(quietHoursInserts);
+			});
+			return;
+		} catch (err) {
+			attempts++;
+			if (attempts >= 3 || err.code !== "40001" && err.code !== "40P01") throw err;
+			await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempts) * 100));
+		}
+	}
+	async updatePartial(projectId, userId, patch) {
+		const existing = await this.findById(projectId, userId);
+		if (!existing) return false;
+		const attrs = {
+			language: patch.language ?? existing.language,
+			timezone: patch.timezone ?? existing.timezone,
+			email: patch.email ?? existing.email
+		};
+		await this.db.transaction(async (tx) => {
+			await tx.update(users).set({
+				attributes: attrs,
+				updatedAt: /* @__PURE__ */ new Date()
+			}).where(and(eq(users.externalId, userId), eq(users.projectId, projectId)));
+			const internalId = (await tx.select({ id: users.id }).from(users).where(and(eq(users.externalId, userId), eq(users.projectId, projectId))))[0]?.id;
+			if (!internalId) return;
+			if (patch.segments) {
+				await tx.delete(userSegments).where(eq(userSegments.userId, internalId));
+				if (patch.segments.length > 0) await tx.insert(userSegments).values(patch.segments.map((s) => ({
+					userId: internalId,
+					segment: s
+				}))).onConflictDoNothing();
+			}
+			if (patch.preferences && patch.preferences.topics) {
+				const topicInserts = Object.entries(patch.preferences.topics).map(([topic, enabled]) => ({
+					userId: internalId,
+					topic,
+					enabled
+				}));
+				if (topicInserts.length > 0) await tx.insert(userTopicPreferences).values(topicInserts).onConflictDoUpdate({
+					target: [userTopicPreferences.userId, userTopicPreferences.topic],
+					set: { enabled: sql`excluded.enabled` }
+				});
+			}
+			if (patch.preferences?.channels) {
+				const channelInserts = Object.entries(patch.preferences.channels).map(([channel, enabled]) => ({
+					userId: internalId,
+					channel,
+					enabled
+				}));
+				if (channelInserts.length > 0) await tx.insert(userChannelPreferences).values(channelInserts).onConflictDoUpdate({
+					target: [userChannelPreferences.userId, userChannelPreferences.channel],
+					set: { enabled: sql`excluded.enabled` }
+				});
+			}
+			if (patch.preferences?.quietHours !== void 0) {
+				await tx.delete(quietHours).where(eq(quietHours.userId, internalId));
+				if (patch.preferences.quietHours.length > 0) await tx.insert(quietHours).values(patch.preferences.quietHours.map((window) => ({
+					userId: internalId,
+					startTime: window.start,
+					endTime: window.end
+				})));
+			}
+		});
+		return true;
+	}
+	async delete(projectId, userId) {
+		return (await this.db.delete(users).where(and(eq(users.externalId, userId), eq(users.projectId, projectId))).returning()).length > 0;
+	}
+	async list(projectId, limit, cursor) {
+		let query = this.db.select().from(users).where(eq(users.projectId, projectId)).orderBy(desc(users.createdAt)).limit(limit);
+		if (cursor) {
+			const cursorDate = new Date(parseInt(cursor, 10));
+			query = this.db.select().from(users).where(and(eq(users.projectId, projectId), sql`${users.createdAt} < ${cursorDate.toISOString()}`)).orderBy(desc(users.createdAt)).limit(limit);
+		}
+		const items = (await query).map((r) => {
+			const attrs = r.attributes;
+			return {
+				userId: r.externalId,
+				language: attrs.language,
+				timezone: attrs.timezone,
+				email: attrs.email,
+				createdAt: r.createdAt.getTime()
+			};
+		});
+		return {
+			users: items,
+			nextCursor: items.length === limit ? items[items.length - 1].createdAt.toString() : null
+		};
+	}
+	async findUsersBySegment(projectId, segmentName) {
+		return (await this.db.select({ externalId: users.externalId }).from(users).innerJoin(userSegments, eq(users.id, userSegments.userId)).where(and(eq(userSegments.segment, segmentName), eq(users.projectId, projectId)))).map((r) => r.externalId);
+	}
+	async findUsersByTopic(projectId, topicName) {
+		return (await this.db.select({ externalId: users.externalId }).from(users).innerJoin(userTopicPreferences, eq(users.id, userTopicPreferences.userId)).where(and(eq(userTopicPreferences.topic, topicName), eq(userTopicPreferences.enabled, true), eq(users.projectId, projectId)))).map((r) => r.externalId);
+	}
+};
+var PreferenceRepository = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	async isOptedIn(projectId, userId, eventType) {
+		const pref = (await this.findByUserId(projectId, userId)).find((p) => p.eventType === eventType);
+		return pref ? pref.optedIn : true;
+	}
+	async findByUserId(projectId, userId) {
+		const internalId = (await this.db.select({ id: users.id }).from(users).where(and(eq(users.externalId, userId), eq(users.projectId, projectId))))[0]?.id;
+		if (!internalId) return [];
+		return (await this.db.select().from(userTopicPreferences).where(eq(userTopicPreferences.userId, internalId))).map((r) => ({
+			userId,
+			eventType: r.topic,
+			optedIn: r.enabled
+		}));
+	}
+};
+var ContactRepository = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	async findByUserId(projectId, userId) {
+		const internalId = (await this.db.select({ id: users.id }).from(users).where(and(eq(users.externalId, userId), eq(users.projectId, projectId))))[0]?.id;
+		if (!internalId) return [];
+		const rows = await this.db.select().from(userContacts).where(eq(userContacts.userId, internalId));
+		if (rows.length === 0) return [];
+		const topicRows = await this.db.select().from(contactTopicPreferences).where(inArray(contactTopicPreferences.contactId, rows.map((r) => r.id)));
+		const topicsByContact = /* @__PURE__ */ new Map();
+		for (const t of topicRows) {
+			if (!topicsByContact.has(t.contactId)) topicsByContact.set(t.contactId, {});
+			topicsByContact.get(t.contactId)[t.topic] = t.enabled;
+		}
+		return rows.map((r) => ({
+			id: r.id,
+			userId,
+			channel: r.channel,
+			target: r.target,
+			preferences: { topics: topicsByContact.get(r.id) ?? {} },
+			active: r.enabled
+		}));
+	}
+	/** Resolve active addressable contacts for a batch without an N+1 query. */
+	async findActiveByUserIds(projectId, userIds) {
+		const byUser = /* @__PURE__ */ new Map();
+		if (userIds.length === 0) return byUser;
+		const rows = await this.db.select({
+			userId: users.externalId,
+			id: userContacts.id,
+			channel: userContacts.channel,
+			target: userContacts.target,
+			enabled: userContacts.enabled
+		}).from(users).innerJoin(userContacts, eq(users.id, userContacts.userId)).where(and(eq(users.projectId, projectId), inArray(users.externalId, userIds), eq(userContacts.enabled, true)));
+		for (const row of rows) {
+			const contacts = byUser.get(row.userId) ?? [];
+			contacts.push({
+				id: row.id,
+				userId: row.userId,
+				channel: row.channel,
+				target: row.target,
+				preferences: {},
+				active: row.enabled
+			});
+			byUser.set(row.userId, contacts);
+		}
+		return byUser;
+	}
+	async upsert(projectId, userId, channel, target, preferences = {}) {
+		const internalId = (await this.db.select({ id: users.id }).from(users).where(and(eq(users.externalId, userId), eq(users.projectId, projectId))))[0]?.id;
+		if (!internalId) return;
+		const contactId = (await this.db.insert(userContacts).values({
+			userId: internalId,
+			channel,
+			target,
+			enabled: true
+		}).onConflictDoUpdate({
+			target: [
+				userContacts.userId,
+				userContacts.channel,
+				userContacts.target
+			],
+			set: { enabled: true }
+		}).returning({ id: userContacts.id }))[0]?.id;
+		if (!contactId) return;
+		const topics = Object.entries(preferences.topics ?? {});
+		if (topics.length > 0) await this.db.insert(contactTopicPreferences).values(topics.map(([topic, enabled]) => ({
+			contactId,
+			topic,
+			enabled
+		}))).onConflictDoUpdate({
+			target: [contactTopicPreferences.contactId, contactTopicPreferences.topic],
+			set: { enabled: sql`excluded.enabled` }
+		});
+	}
+	async upsertMany(projectId, contactsList) {
+		if (contactsList.length === 0) return;
+		const internalUserIdRows = await this.db.select({
+			id: users.id,
+			externalId: users.externalId
+		}).from(users).where(and(inArray(users.externalId, contactsList.map((c) => c.userId)), eq(users.projectId, projectId)));
+		const idMap = new Map(internalUserIdRows.map((r) => [r.externalId, r.id]));
+		const validContacts = contactsList.filter((c) => idMap.has(c.userId));
+		if (validContacts.length === 0) return;
+		const inserted = await this.db.insert(userContacts).values(validContacts.map((c) => ({
+			userId: idMap.get(c.userId),
+			channel: c.channel,
+			target: c.target,
+			enabled: true
+		}))).onConflictDoUpdate({
+			target: [
+				userContacts.userId,
+				userContacts.channel,
+				userContacts.target
+			],
+			set: { enabled: true }
+		}).returning({
+			id: userContacts.id,
+			userId: userContacts.userId,
+			channel: userContacts.channel,
+			target: userContacts.target
+		});
+		const contactIdMap = /* @__PURE__ */ new Map();
+		for (const row of inserted) contactIdMap.set(`${row.userId}:${row.channel}:${row.target}`, row.id);
+		const topicInserts = [];
+		for (const c of validContacts) {
+			const internalId = idMap.get(c.userId);
+			const contactId = contactIdMap.get(`${internalId}:${c.channel}:${c.target}`);
+			if (!contactId || !c.preferences?.topics) continue;
+			for (const [topic, enabled] of Object.entries(c.preferences.topics)) topicInserts.push({
+				contactId,
+				topic,
+				enabled
+			});
+		}
+		if (topicInserts.length > 0) await this.db.insert(contactTopicPreferences).values(topicInserts).onConflictDoUpdate({
+			target: [contactTopicPreferences.contactId, contactTopicPreferences.topic],
+			set: { enabled: sql`excluded.enabled` }
+		});
+	}
+	/**
+	* Mark a contact unusable without destroying it — used when a provider
+	* reports an invalid push token. Deleting the row would lose the user's
+	* device permanently on what is often a transient provider response.
+	*/
+	async deactivate(projectId, userId, channel, target) {
+		const internalId = (await this.db.select({ id: users.id }).from(users).where(and(eq(users.externalId, userId), eq(users.projectId, projectId))))[0]?.id;
+		if (!internalId) return false;
+		return (await this.db.update(userContacts).set({ enabled: false }).where(and(eq(userContacts.userId, internalId), eq(userContacts.channel, channel), eq(userContacts.target, target))).returning()).length > 0;
+	}
+	async delete(projectId, userId, channel, target) {
+		const internalId = (await this.db.select({ id: users.id }).from(users).where(and(eq(users.externalId, userId), eq(users.projectId, projectId))))[0]?.id;
+		if (!internalId) return false;
+		return (await this.db.delete(userContacts).where(and(eq(userContacts.userId, internalId), eq(userContacts.channel, channel), eq(userContacts.target, target))).returning()).length > 0;
+	}
+};
+var TemplateRepository = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	async findById(projectId, id) {
+		const rows = await this.db.select().from(templates).where(and(eq(templates.id, id), eq(templates.projectId, projectId))).limit(1);
+		if (!rows[0]) return null;
+		return {
+			id: rows[0].id,
+			channel: rows[0].channel,
+			content: rows[0].content,
+			topics: rows[0].topics ?? [],
+			aiPrompts: rows[0].aiPrompts
+		};
+	}
+	async list(projectId) {
+		return (await this.db.select().from(templates).where(eq(templates.projectId, projectId))).map((r) => ({
+			id: r.id,
+			channel: r.channel,
+			content: r.content,
+			topics: r.topics ?? [],
+			aiPrompts: r.aiPrompts
+		}));
+	}
+	async upsertMany(projectId, templateList) {
+		if (templateList.length === 0) return 0;
+		const values = templateList.map((t) => ({
+			projectId,
+			id: t.id,
+			channel: t.channel,
+			topics: t.topics ?? [],
+			content: t.content,
+			aiPrompts: t.aiPrompts
+		}));
+		await this.db.insert(templates).values(values).onConflictDoUpdate({
+			target: [templates.projectId, templates.id],
+			set: {
+				channel: sql`excluded.channel`,
+				topics: sql`excluded.topics`,
+				content: sql`excluded.content`,
+				aiPrompts: sql`excluded.ai_prompts`,
+				updatedAt: /* @__PURE__ */ new Date()
+			}
+		});
+		return templateList.length;
+	}
+	async delete(projectId, id) {
+		return (await this.db.delete(templates).where(and(eq(templates.id, id), eq(templates.projectId, projectId))).returning()).length > 0;
+	}
+};
+var ProjectRepository = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	async list() {
+		return this.db.select({
+			id: projects.id,
+			name: projects.name,
+			rateLimitRpm: projects.rateLimitRpm,
+			throttleLimit: projects.throttleLimit,
+			throttleWindowHours: projects.throttleWindowHours,
+			createdAt: projects.createdAt
+		}).from(projects).orderBy(desc(projects.createdAt));
+	}
+	async delete(id) {
+		return await this.db.transaction(async (tx) => {
+			const userIds = (await tx.select({ id: users.id }).from(users).where(eq(users.projectId, id))).map((u) => u.id);
+			if (userIds.length > 0) {
+				await tx.delete(userContacts).where(inArray(userContacts.userId, userIds));
+				await tx.delete(userSegments).where(inArray(userSegments.userId, userIds));
+				await tx.delete(userTopicPreferences).where(inArray(userTopicPreferences.userId, userIds));
+				await tx.delete(userChannelPreferences).where(inArray(userChannelPreferences.userId, userIds));
+				await tx.delete(quietHours).where(inArray(quietHours.userId, userIds));
+				await tx.delete(users).where(eq(users.projectId, id));
+			}
+			await tx.delete(suppressions).where(eq(suppressions.projectId, id));
+			await tx.delete(messageLogs).where(eq(messageLogs.projectId, id));
+			await tx.delete(workflowInstances).where(eq(workflowInstances.projectId, id));
+			return (await tx.delete(projects).where(eq(projects.id, id)).returning()).length > 0;
+		});
+	}
+	/**
+	* Throttle overrides only. Kept narrow because the engine calls this once per
+	* notification (behind a cache) and has no use for the rest of the row.
+	*/
+	async findThrottleSettings(id) {
+		return (await this.db.select({
+			throttleLimit: projects.throttleLimit,
+			throttleWindowHours: projects.throttleWindowHours
+		}).from(projects).where(eq(projects.id, id)).limit(1))[0] ?? null;
+	}
+	async updateSettings(id, settings) {
+		return (await this.db.update(projects).set(settings).where(eq(projects.id, id)).returning()).length > 0;
+	}
+	async createApiKey(projectId, keyHash, role = "admin") {
+		return { id: (await this.db.insert(projectApiKeys).values({
+			projectId,
+			keyHash,
+			role
+		}).returning())[0].id };
+	}
+	async listApiKeys(projectId) {
+		return this.db.select({
+			id: projectApiKeys.id,
+			role: projectApiKeys.role,
+			createdAt: projectApiKeys.createdAt
+		}).from(projectApiKeys).where(eq(projectApiKeys.projectId, projectId)).orderBy(desc(projectApiKeys.createdAt));
+	}
+	async deleteApiKey(projectId, keyId) {
+		return (await this.db.delete(projectApiKeys).where(and(eq(projectApiKeys.id, keyId), eq(projectApiKeys.projectId, projectId))).returning()).length > 0;
+	}
+};
+var WorkflowRepository = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	async listDefinitions(projectId) {
+		return this.db.select().from(workflowDefinitions).where(eq(workflowDefinitions.projectId, projectId)).orderBy(desc(workflowDefinitions.createdAt));
+	}
+	async getInstance(projectId, instanceId) {
+		const instances = await this.db.select().from(workflowInstances).where(and(eq(workflowInstances.id, instanceId), eq(workflowInstances.projectId, projectId))).limit(1);
+		if (!instances[0]) return null;
+		const steps = await this.db.select().from(workflowSteps).where(eq(workflowSteps.instanceId, instanceId)).orderBy(workflowSteps.createdAt);
+		const waiters = await this.db.select().from(workflowWaiters).where(eq(workflowWaiters.instanceId, instanceId));
+		return {
+			...instances[0],
+			steps,
+			waiters
+		};
+	}
+	async cancelInstance(projectId, instanceId) {
+		return await this.db.transaction(async (tx) => {
+			if ((await tx.update(workflowInstances).set({ status: "canceled" }).where(and(eq(workflowInstances.id, instanceId), eq(workflowInstances.projectId, projectId), inArray(workflowInstances.status, ["pending", "running"]))).returning()).length === 0) return false;
+			await tx.delete(workflowWaiters).where(eq(workflowWaiters.instanceId, instanceId));
+			return true;
+		});
+	}
+};
+var SegmentRepository = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	async listSegments(projectId) {
+		return (await this.db.execute(sql`
+      SELECT DISTINCT s.segment
+      FROM user_segments s
+      JOIN users u ON u.id = s.user_id
+      WHERE u.project_id = ${projectId}
+    `)).map((r) => r.segment);
+	}
+};
+//#endregion
+//#region src/templates/render.ts
+function escapeHtml(unsafe) {
+	return String(unsafe).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+/** Strip CR/LF so an interpolated value cannot inject extra headers. */
+function escapeHeader(unsafe) {
+	return String(unsafe).replace(/[\r\n]+/g, " ").trim();
+}
+function interpolate(tmpl, variables, sanitize = true) {
+	return tmpl.replace(/\{\{(\w+)\}\}/g, (_, k) => {
+		const val = String(variables[k] ?? "");
+		return sanitize ? escapeHtml(val) : val;
+	});
+}
+const HTML_FIELDS = /* @__PURE__ */ new Set([
+	"html",
+	"htmlbody",
+	"bodyhtml",
+	"htmlcontent"
+]);
+const HEADER_FIELDS = /* @__PURE__ */ new Set([
+	"subject",
+	"title",
+	"from",
+	"replyto",
+	"cc",
+	"bcc",
+	"preheader",
+	"preview"
+]);
+function escapeModeFor(key, inherited) {
+	const k = key.toLowerCase().replace(/[-_]/g, "");
+	if (HTML_FIELDS.has(k)) return "html";
+	if (HEADER_FIELDS.has(k)) return "header";
+	return inherited;
+}
+function applyEscape(value, mode) {
+	if (mode === "html") return escapeHtml(value);
+	if (mode === "header") return escapeHeader(value);
+	return value;
+}
+/**
+* Interpolate `{{var}}` placeholders in a single leaf string.
+*
+* Escaping is applied to the SUBSTITUTED VALUE only — never to the surrounding
+* template — so template authors keep their own markup while caller-supplied
+* data cannot break out of it.
+*/
+function interpolateLeaf(tmpl, variables, mode) {
+	return tmpl.replace(/\{\{(\w+)\}\}/g, (_, k) => {
+		const raw = variables[k];
+		if (raw === void 0 || raw === null) return "";
+		return applyEscape(typeof raw === "string" ? raw : JSON.stringify(raw), mode);
+	});
+}
+/**
+* Walk a template content tree and interpolate every leaf string in place.
+*
+* Values are substituted into the already-parsed structure. Interpolating into
+* serialised JSON and re-parsing (the previous approach) let a value containing
+* a quote either break JSON.parse outright or forge sibling fields such as
+* `htmlBody`.
+*/
+function renderNode(node, variables, mode) {
+	if (typeof node === "string") return interpolateLeaf(node, variables, mode);
+	if (Array.isArray(node)) return node.map((item) => renderNode(item, variables, mode));
+	if (node && typeof node === "object") {
+		const out = {};
+		for (const [key, value] of Object.entries(node)) out[key] = renderNode(value, variables, escapeModeFor(key, mode));
+		return out;
+	}
+	return node;
+}
+function renderWithTemplate(dbTemplate, templateVariables) {
+	const vars = templateVariables ?? {};
+	if (dbTemplate) return { content: renderNode(dbTemplate.content ?? {}, vars, "text") };
+	return { content: {
+		subject: "Notification",
+		body: JSON.stringify(vars, null, 2)
+	} };
+}
+//#endregion
+//#region src/templates/cache.ts
+var TemplateCache = class {
+	templateRepo;
+	cache = new LRUCache(1e3, 3e5);
+	constructor(templateRepo) {
+		this.templateRepo = templateRepo;
+	}
+	async getCachedTemplate(projectId, id) {
+		const key = `${projectId}:${id}`;
+		const cached = this.cache.get(key);
+		if (cached) return cached;
+		const dbTemplate = await this.templateRepo.findById(projectId, id);
+		if (dbTemplate) this.cache.set(key, dbTemplate);
+		return dbTemplate;
+	}
+	invalidate(projectId, id) {
+		this.cache.delete(`${projectId}:${id}`);
+	}
+	invalidateKey(key) {
+		this.cache.delete(key);
+	}
+	clear() {
+		this.cache.clear();
+	}
+};
+//#endregion
+//#region src/templates/index.ts
+/** Coerce a template variable to a non-empty string, or undefined. */
+function asText(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+var TemplateRegistry = class {
+	renderers = /* @__PURE__ */ new Map();
+	/**
+	* Register a custom renderer for an event type.
+	* Overwrites any previous registration for the same type.
+	*/
+	register(eventType, renderer) {
+		this.renderers.set(eventType, renderer);
+	}
+	/** Render content for the given context, falling back to the i18n table. */
+	render(ctx) {
+		const renderer = this.renderers.get(ctx.eventType);
+		if (renderer) return renderer(ctx);
+		return defaultRenderer(ctx);
+	}
+	has(eventType) {
+		return this.renderers.has(eventType);
+	}
+	registeredTypes() {
+		return [...this.renderers.keys()];
+	}
+};
+function defaultRenderer(ctx) {
+	const vars = ctx.templateVariables;
+	return { content: {
+		subject: asText(vars.subject ?? vars.title),
+		body: asText(vars.body ?? vars.message) ?? `Notification: ${ctx.eventType}`
+	} };
+}
+const templateRegistry = new TemplateRegistry();
+function renderTemplate(ctx) {
+	return templateRegistry.render(ctx);
+}
+//#endregion
+//#region src/unsubscribe/index.ts
+function b64url(input) {
+	return Buffer.from(input).toString("base64url");
+}
+/**
+* Sign a claim into a URL-safe token.
+*
+* The signature covers the exact encoded payload rather than a re-serialisation
+* of it, so a verifier never has to reproduce this function's JSON key order to
+* get a matching MAC.
+*/
+function signUnsubscribeToken(claim, secret) {
+	const wire = {
+		p: claim.projectId,
+		u: claim.userId,
+		c: claim.channel,
+		t: claim.target,
+		k: claim.topics
+	};
+	const payload = b64url(JSON.stringify(wire));
+	return `${payload}.${b64url(createHmac("sha256", secret).update(payload).digest())}`;
+}
+/**
+* Verify and decode a token. Returns null for anything not signed by `secret`.
+*
+* Every failure returns the same null rather than a reason: the caller is an
+* unauthenticated endpoint, and distinguishing "malformed" from "bad signature"
+* hands an attacker a probe.
+*/
+function verifyUnsubscribeToken(token, secret) {
+	const dot = token.indexOf(".");
+	if (dot <= 0 || dot === token.length - 1) return null;
+	const payload = token.slice(0, dot);
+	const provided = Buffer.from(token.slice(dot + 1), "base64url");
+	const expected = createHmac("sha256", secret).update(payload).digest();
+	if (provided.length !== expected.length) return null;
+	if (!timingSafeEqual(provided, expected)) return null;
+	try {
+		const wire = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+		if (typeof wire.p !== "string" || typeof wire.u !== "string" || typeof wire.c !== "string" || typeof wire.t !== "string" || !Array.isArray(wire.k)) return null;
+		return {
+			projectId: wire.p,
+			userId: wire.u,
+			channel: wire.c,
+			target: wire.t,
+			topics: wire.k.filter((t) => typeof t === "string")
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* The two headers that make an inbox render a real unsubscribe button.
+*
+* `List-Unsubscribe-Post` is what upgrades the link from "open this URL" to
+* one-click: the mail client POSTs directly and never shows the recipient a
+* landing page. Sending the URL without it means the recipient has to click
+* through and confirm, which mailbox providers do not count as compliant.
+*/
+function buildUnsubscribeHeaders(options) {
+	const token = signUnsubscribeToken(options.claim, options.secret);
+	return {
+		"List-Unsubscribe": `<${`${options.publicUrl.replace(/\/$/, "")}/v1/unsubscribe?token=${encodeURIComponent(token)}`}>`,
+		"List-Unsubscribe-Post": "List-Unsubscribe=One-Click"
+	};
+}
+//#endregion
+//#region src/workers/health.ts
+function startHealthReporter(serviceName, worker, redis, logger, intervalMs = 1e3) {
+	return setInterval(() => {
+		(async () => {
+			try {
+				const redisOk = await redis.healthCheck();
+				await redis.native.set(`notif:health:${serviceName}`, JSON.stringify({
+					service: serviceName,
+					redis: redisOk,
+					...worker.health(),
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				}), "EX", 15);
+			} catch {}
+		})();
+	}, intervalMs);
+}
+//#endregion
+//#region src/workers/index.ts
+var NonRetryableError = class extends Error {
+	nonRetryable = true;
+	constructor(message) {
+		super(message);
+		this.name = "NonRetryableError";
+	}
+};
+var BaseWorker = class {
+	logger;
+	consumer;
+	pendingScanner;
+	concurrency;
+	recoveryIntervalMs;
+	maxRetriesBeforeDlq;
+	state = "idle";
+	stopping = false;
+	processedCount = 0;
+	errorCount = 0;
+	lastProcessedAt = null;
+	lastErrorAt = null;
+	recoveryTimer = null;
+	lastPendingCount = null;
+	active = /* @__PURE__ */ new Set();
+	semaphore;
+	runLoop;
+	constructor({ consumer, pendingScanner, logger, concurrency = 10, recoveryIntervalMs = 6e4, maxRetriesBeforeDlq = 3 }) {
+		this.consumer = consumer;
+		this.pendingScanner = pendingScanner;
+		this.logger = logger.child({ component: this.constructor.name });
+		this.concurrency = concurrency;
+		this.recoveryIntervalMs = recoveryIntervalMs;
+		this.maxRetriesBeforeDlq = maxRetriesBeforeDlq;
+		this.semaphore = new AsyncSemaphore(concurrency);
+	}
+	async start() {
+		if (this.state !== "idle") throw new Error(`Worker cannot start from state: ${this.state}`);
+		this.state = "running";
+		this.logger.info({ concurrency: this.concurrency }, "worker starting");
+		await this.consumer.ensureGroup();
+		this.startRecoveryLoop();
+		this.runLoop = this.consume();
+	}
+	async consume() {
+		for await (const batch of this.consumer.readBatch()) {
+			if (this.stopping) break;
+			for (const message of batch) {
+				if (this.stopping) break;
+				await this.semaphore.acquire();
+				const task = this.processWithTracking(message).finally(() => {
+					this.active.delete(task);
+					this.semaphore.release();
+				});
+				this.active.add(task);
+			}
+		}
+		await Promise.allSettled([...this.active]);
+		this.state = "stopped";
+		this.logger.info("worker stopped");
+	}
+	async stop() {
+		if (this.stopping || this.state !== "running") return;
+		this.logger.info("worker stopping");
+		this.stopping = true;
+		this.state = "stopping";
+		await this.consumer.stop();
+		this.stopRecoveryLoop();
+		if (this.runLoop) await Promise.race([this.runLoop, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Worker stop timeout")), 3e4))]).catch((err) => this.logger.warn({ err }, "Worker shutdown timeout or error"));
+		this.logger.info("worker shutdown complete");
+	}
+	async recover() {
+		this.logger.debug("scanning for stale pending messages");
+		const pendingCount = await this.pendingScanner.getPendingCount();
+		this.lastPendingCount = pendingCount;
+		if (pendingCount === 0) return;
+		this.logger.info({ pendingCount }, "found pending messages, attempting autoclaim");
+		const BATCH_SIZE = 1e3;
+		while (!this.stopping) {
+			const messages = await this.pendingScanner.autoclaim(this.recoveryIntervalMs, BATCH_SIZE);
+			if (messages.length === 0) break;
+			for (const message of messages) {
+				if (this.stopping) break;
+				await this.semaphore.acquire();
+				const task = this.processWithTracking(message).finally(() => {
+					this.active.delete(task);
+					this.semaphore.release();
+				});
+				this.active.add(task);
+			}
+		}
+	}
+	health() {
+		return {
+			state: this.state,
+			processedCount: this.processedCount,
+			errorCount: this.errorCount,
+			lastProcessedAt: this.lastProcessedAt,
+			lastErrorAt: this.lastErrorAt,
+			pendingCount: this.lastPendingCount
+		};
+	}
+	async processWithTracking(message) {
+		const start = Date.now();
+		const stream = message.stream;
+		const retryKey = `notif:worker:retries:${this.constructor.name}:${stream ?? "default"}:${message.id}`;
+		try {
+			const retryCount = (await this.consumer.redis.multi().incr(retryKey).expire(retryKey, 7200).exec())?.[0]?.[1] ?? 1;
+			if (retryCount > this.maxRetriesBeforeDlq) {
+				this.logger.warn({
+					messageId: message.id,
+					retryCount
+				}, "max retries exceeded, moving to dead-letter queue");
+				await this.consumer.nack(message.id, message.event, stream);
+				await this.consumer.redis.del(retryKey);
+				globalEmitter.emit("notification:failed", message.id, "Poison pill: max retries exceeded", message.event.type);
+				return;
+			}
+			await this.process(message, retryCount);
+			await this.consumer.ack(message.id, stream);
+			await this.consumer.redis.del(retryKey);
+			this.processedCount += 1;
+			this.lastProcessedAt = (/* @__PURE__ */ new Date()).toISOString();
+			metrics.messagesProcessed.inc({
+				worker: this.constructor.name,
+				status: "success"
+			});
+			this.logger.debug({
+				messageId: message.id,
+				eventType: message.event.type,
+				durationMs: Date.now() - start
+			}, "message processed");
+		} catch (err) {
+			this.errorCount += 1;
+			this.lastErrorAt = (/* @__PURE__ */ new Date()).toISOString();
+			metrics.messagesProcessed.inc({
+				worker: this.constructor.name,
+				status: "error"
+			});
+			if (err instanceof NonRetryableError || err?.nonRetryable) {
+				this.logger.warn({
+					err,
+					messageId: message.id
+				}, "non-retryable error encountered, immediately moving to dead-letter queue without retry loop");
+				await this.consumer.nack(message.id, message.event, stream);
+				await this.consumer.redis.del(retryKey);
+				globalEmitter.emit("notification:failed", message.id, err.message, message.event.type);
+				return;
+			}
+			this.logger.error({
+				err,
+				messageId: message.id,
+				eventType: message.event.type
+			}, "failed to process message");
+		}
+	}
+	startRecoveryLoop() {
+		this.recoveryTimer = setInterval(() => {
+			if (this.state === "running") this.recover().catch((err) => {
+				this.logger.error({ err }, "recovery loop error");
+			});
+		}, this.recoveryIntervalMs);
+	}
+	stopRecoveryLoop() {
+		if (this.recoveryTimer) {
+			clearInterval(this.recoveryTimer);
+			this.recoveryTimer = null;
+		}
+	}
+};
+//#endregion
+//#region src/workflows/sdk.ts
+var SuspendExecutionError = class extends Error {
+	reason;
+	payload;
+	constructor(reason, payload) {
+		super(`Execution suspended for ${reason}`);
+		this.reason = reason;
+		this.payload = payload;
+		this.name = "SuspendExecutionError";
+	}
+};
+/**
+* Works out who a `step.notify()` call is for.
+*
+* A target named in the step payload wins. Only when the step names none does
+* the notification fall back to the instance's own user — the common case, and
+* the reason most steps carry no target at all.
+*/
+function resolveStepTarget(args, instanceInput) {
+	if (args.segment !== void 0) return {
+		type: "segment",
+		segment: args.segment
+	};
+	if (args.topic !== void 0) return {
+		type: "topic",
+		topic: args.topic
+	};
+	if (args.user !== void 0) {
+		if (Array.isArray(args.user)) throw new Error("step.notify() takes a single `user`. To reach several people from one workflow, use one notify step each, or target a `segment`.");
+		return {
+			type: "user",
+			userId: typeof args.user === "string" ? args.user : args.user.id
+		};
+	}
+	const inherited = instanceInput?.user?.id;
+	if (!inherited) throw new Error("step.notify() has no target: the step payload names no `user`, `segment` or `topic`, and the workflow instance was triggered without `input.user.id`.");
+	return {
+		type: "user",
+		userId: inherited
+	};
+}
+/**
+* Maps a `step.notify()` payload onto the wire event the pipeline consumes.
+*
+* The field names differ either side of the boundary — `template` becomes
+* `templateId`, `sendAt` becomes `scheduledAt` — so this translation is
+* deliberate rather than a spread, and the return type keeps it honest.
+*/
+function buildStepNotifyPayload(args, instanceInput, projectId, idempotencyKey) {
+	return {
+		projectId,
+		target: resolveStepTarget(args, instanceInput),
+		templateId: args.template,
+		priority: args.priority ?? "normal",
+		channels: args.channels,
+		data: args.data ?? {},
+		aiPrompts: args.aiPrompts,
+		fallback: args.fallback ?? false,
+		scheduledAt: args.sendAt,
+		idempotencyKey
+	};
+}
+//#endregion
+//#region src/workflows/registry.ts
+var WorkflowRegistry = class {
+	workflows = /* @__PURE__ */ new Map();
+	register(name, handler) {
+		this.workflows.set(name, handler);
+	}
+	get(name) {
+		return this.workflows.get(name);
+	}
+};
+const workflowRegistry = new WorkflowRegistry();
+function workflow(name, handler) {
+	workflowRegistry.register(name, handler);
+}
+//#endregion
+//#region src/client.ts
+var NotifkitClient = class {
+	options;
+	baseUrl;
+	headers;
+	constructor(options) {
+		this.options = options;
+		this.baseUrl = options.baseUrl.replace(/\/$/, "");
+		this.headers = {
+			"Content-Type": "application/json",
+			...options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {},
+			...options.headers
+		};
+	}
+	async request(path, method, body) {
+		const url = `${this.baseUrl}${path}`;
+		const res = await fetch(url, {
+			method,
+			headers: this.headers,
+			body: body ? JSON.stringify(body) : void 0
+		});
+		if (res.status === 204) return;
+		const data = await res.json();
+		if (!res.ok) {
+			const errorMsg = data.message || data.error || `Request failed with status ${res.status}`;
+			throw new Error(errorMsg);
+		}
+		return data;
+	}
+	/** Sync templates with the server. */
+	async syncTemplates(input) {
+		return this.request("/v1/templates", "PUT", input);
+	}
+	/** Create/upsert a user profile and contacts. */
+	async addUser(input) {
+		return this.request("/v1/users", "POST", input);
+	}
+	/** Update user profile. */
+	async updateUser(id, input) {
+		return this.request(`/v1/users/${id}`, "PATCH", input);
+	}
+	/** Delete user profile. */
+	async deleteUser(id) {
+		return this.request(`/v1/users/${id}`, "DELETE");
+	}
+	/** Add contact targets to user profile. */
+	async addContact(userId, input) {
+		return this.request(`/v1/users/${userId}/contacts`, "POST", input);
+	}
+	/** Delete a specific contact channel target. */
+	async deleteContact(userId, channel, target) {
+		return this.request(`/v1/users/${userId}/contacts/${channel}/${target}`, "DELETE");
+	}
+	/** Request a notification dispatch. */
+	async notify(input) {
+		return this.request("/v1/notify", "POST", input);
+	}
+	/** Trigger a registered background workflow. */
+	async triggerWorkflow(input) {
+		return this.request("/v1/workflows/trigger", "POST", input);
+	}
+	/** Create a dynamic JSON workflow definition. */
+	async createWorkflow(input) {
+		return this.request("/v1/workflows", "POST", input);
+	}
+	/** Ingest an external event into the system to resume workflows or trigger automations. */
+	async ingestEvent(input) {
+		return this.request("/v1/events", "POST", input);
+	}
+	/** Sync templates configured on the client options to the server. */
+	async sync() {
+		if (!this.options.templates || this.options.templates.length === 0) return { synced: 0 };
+		return this.syncTemplates({ templates: this.options.templates });
+	}
+	/** List registered workflow definitions. */
+	async listWorkflows() {
+		return this.request("/v1/workflows", "GET");
+	}
+	/** Get a workflow instance by ID. */
+	async getWorkflow(instanceId) {
+		return this.request(`/v1/workflows/instances/${instanceId}`, "GET");
+	}
+	/** Cancel a running/suspended workflow instance. */
+	async cancelWorkflow(instanceId) {
+		return this.request(`/v1/workflows/instances/${instanceId}`, "DELETE");
+	}
+	/** Get notification logs for the project. */
+	async getNotificationLogs(options) {
+		let url = "/v1/notifications/logs";
+		if (options) {
+			const params = new URLSearchParams();
+			if (options.limit !== void 0) params.append("limit", options.limit.toString());
+			if (options.cursor) params.append("cursor", options.cursor);
+			if (options.templateId) params.append("templateId", options.templateId);
+			if (options.workflowInstanceId) params.append("workflowInstanceId", options.workflowInstanceId);
+			if (options.channel) params.append("channel", options.channel);
+			if (options.status) params.append("status", options.status);
+			const str = params.toString();
+			if (str) url += `?${str}`;
+		}
+		return this.request(url, "GET");
+	}
+	/** List/paginate users. */
+	async listUsers(options) {
+		const params = new URLSearchParams();
+		if (options?.limit) params.set("limit", options.limit.toString());
+		if (options?.cursor) params.set("cursor", options.cursor);
+		const qs = params.toString();
+		return this.request(`/v1/users${qs ? `?${qs}` : ""}`, "GET");
+	}
+	/** Delete a template. */
+	async deleteTemplate(id) {
+		return this.request(`/v1/templates/${id}`, "DELETE");
+	}
+	/** Get a user's contacts. */
+	async getUserContacts(userId) {
+		return this.request(`/v1/users/${userId}/contacts`, "GET");
+	}
+	/** List projects (Admin only). */
+	async listProjects() {
+		return this.request("/v1/projects", "GET");
+	}
+	/** Delete a project (Admin only). */
+	async deleteProject(id) {
+		return this.request(`/v1/projects/${id}`, "DELETE");
+	}
+	/** Create a new project API key (Admin only). */
+	async createProjectKey(id, input) {
+		return this.request(`/v1/projects/${id}/keys`, "POST", input || {});
+	}
+	/** List project API keys (Admin only). */
+	async listProjectKeys(id) {
+		return this.request(`/v1/projects/${id}/keys`, "GET");
+	}
+	/** Delete a project API key (Admin only). */
+	async deleteProjectKey(id, keyId) {
+		return this.request(`/v1/projects/${id}/keys/${keyId}`, "DELETE");
+	}
+	/** Update project settings (Admin only). */
+	async updateProject(id, input) {
+		return this.request(`/v1/projects/${id}`, "PATCH", input);
+	}
+	/** List unique segment tags. */
+	async listSegments() {
+		return this.request("/v1/segments", "GET");
+	}
+	/** List campaign labels seen in the delivery log, most recent activity first. */
+	async listCampaigns(options) {
+		const qs = options?.limit ? `?limit=${options.limit}` : "";
+		return this.request(`/v1/campaigns${qs}`, "GET");
+	}
+	/** Delivery and engagement funnel for one campaign. */
+	async getCampaignStats(campaign) {
+		return this.request(`/v1/campaigns/${encodeURIComponent(campaign)}/stats`, "GET");
+	}
+	/** List suppressed destinations. */
+	async listSuppressions(options) {
+		const params = new URLSearchParams();
+		if (options?.limit) params.set("limit", options.limit.toString());
+		if (options?.channel) params.set("channel", options.channel);
+		if (options?.reason) params.set("reason", options.reason);
+		const qs = params.toString();
+		return this.request(`/v1/suppressions${qs ? `?${qs}` : ""}`, "GET");
+	}
+	/** Suppress a destination by hand. */
+	async createSuppression(input) {
+		return this.request("/v1/suppressions", "POST", input);
+	}
+	/** Remove a suppression, re-enabling sends to that destination. */
+	async deleteSuppression(channel, target) {
+		return this.request(`/v1/suppressions/${encodeURIComponent(channel)}/${encodeURIComponent(target)}`, "DELETE");
+	}
+	/** Get real-time status and delivery logs for a specific notification task. */
+	async getNotificationStatus(taskId) {
+		return this.request(`/v1/notifications/${encodeURIComponent(taskId)}`, "GET");
+	}
+	/** Cancel a scheduled notification task. */
+	async cancelNotification(taskId) {
+		return this.request(`/v1/notifications/${encodeURIComponent(taskId)}`, "DELETE");
+	}
+	/** List pending scheduled messages. */
+	async getScheduledMessages() {
+		return this.request("/v1/notifications/scheduled", "GET");
+	}
+	/** Get user profile and contacts by ID. */
+	async getUser(id) {
+		return this.request(`/v1/users/${encodeURIComponent(id)}`, "GET");
+	}
+	/** Get user details including contacts and recent message logs. */
+	async getUserDetails(id) {
+		return this.request(`/v1/users/${encodeURIComponent(id)}/details`, "GET");
+	}
+	/** Get user preferences. */
+	async getUserPreferences(id) {
+		return this.request(`/v1/users/${encodeURIComponent(id)}/preferences`, "GET");
+	}
+	/** Update user preferences. */
+	async updateUserPreferences(id, preferences) {
+		return this.request(`/v1/users/${encodeURIComponent(id)}/preferences`, "PATCH", preferences);
+	}
+	/** List all templates for the project. */
+	async listTemplates() {
+		return this.request("/v1/templates", "GET");
+	}
+	/** Get a template by ID. */
+	async getTemplate(id) {
+		return this.request(`/v1/templates/${encodeURIComponent(id)}`, "GET");
+	}
+	/** Get system health and worker status. */
+	async getSystemHealth() {
+		return this.request("/v1/system/health", "GET");
+	}
+	/** Get system metrics and queue lengths. */
+	async getSystemMetrics() {
+		return this.request("/v1/system/metrics", "GET");
+	}
+	/** Get dead-letter queue messages. */
+	async getDLQMessages() {
+		return this.request("/v1/dlq", "GET");
+	}
+	/** Replay a dead-letter queue message. */
+	async replayDLQMessage(id) {
+		return this.request("/v1/dlq/replay", "POST", { id });
+	}
+	/** Delete a dead-letter queue message. */
+	async deleteDLQMessage(id) {
+		return this.request(`/v1/dlq/${encodeURIComponent(id)}`, "DELETE");
+	}
+};
+//#endregion
+//#region src/server.ts
+var NotifkitServer = class extends EventEmitter {
+	options;
+	pgContainer = null;
+	redisContainer = null;
+	eventCleanupFns = [];
+	signalHandlersAttached = false;
+	logger;
+	constructor(options) {
+		super();
+		this.options = options;
+		this.logger = createLogger({
+			name: "server",
+			level: options.logLevel || process.env.LOG_LEVEL || "info"
+		});
+		for (const name of [
+			"delivery:delivered",
+			"delivery:failed",
+			"notification:throttled",
+			"notification:failed",
+			"notification:skipped",
+			"notification:canceled"
+		]) {
+			const listener = (...args) => {
+				this.emit(name, ...args);
+			};
+			globalEmitter.on(name, listener);
+			this.eventCleanupFns.push(() => {
+				globalEmitter.off(name, listener);
+			});
+		}
+	}
+	async start() {
+		const { setGlobalConfig, readBaseConfig } = await Promise.resolve().then(() => config_exports);
+		if (this.options.port) process.env.PORT = String(this.options.port);
+		if (this.options.logLevel) process.env.LOG_LEVEL = this.options.logLevel;
+		if (this.options.nodeEnv) process.env.NODE_ENV = this.options.nodeEnv;
+		if (this.options.workerConcurrency) process.env.WORKER_CONCURRENCY = String(this.options.workerConcurrency);
+		if (this.options.redisOptions?.maxQueueLength) process.env.QUEUE_MAX_LEN = String(this.options.redisOptions.maxQueueLength);
+		if (this.options.dbOptions?.maxConnections) process.env.DB_MAX_CONNECTIONS = String(this.options.dbOptions.maxConnections);
+		const isProduction = process.env.NODE_ENV === "production";
+		if (!this.options.redisUrl) if (process.env.REDIS_URL) this.options.redisUrl = process.env.REDIS_URL;
+		else if (!isProduction) {
+			this.logger.info("No redisUrl provided, spinning up Redis container for development/testing...");
+			const { RedisContainer } = await import("@testcontainers/redis");
+			this.redisContainer = await new RedisContainer("redis:alpine").start();
+			this.options.redisUrl = this.redisContainer.getConnectionUrl();
+		} else throw new Error("Missing required configuration: REDIS_URL must be provided when running in production mode.");
+		if (!this.options.databaseUrl) if (process.env.DATABASE_URL) this.options.databaseUrl = process.env.DATABASE_URL;
+		else if (!isProduction) {
+			this.logger.info("No databaseUrl provided, spinning up PostgreSQL container for development/testing...");
+			const { PostgreSqlContainer } = await import("@testcontainers/postgresql");
+			this.pgContainer = await new PostgreSqlContainer("postgres:15-alpine").start();
+			this.options.databaseUrl = this.pgContainer.getConnectionUri();
+		} else throw new Error("Missing required configuration: DATABASE_URL must be provided when running in production mode.");
+		if (this.options.redisUrl) process.env.REDIS_URL = this.options.redisUrl;
+		if (this.options.databaseUrl) process.env.DATABASE_URL = this.options.databaseUrl;
+		setGlobalConfig(readBaseConfig());
+		if (this.options.aiModel) {
+			const { setAiConfig } = await Promise.resolve().then(() => config_exports);
+			setAiConfig({ aiModel: this.options.aiModel });
+		}
+		if (this.options.autoMigrate !== false) {
+			this.logger.info("Running database migrations...");
+			const { createDatabase, runMigrations } = await Promise.resolve().then(() => db_exports);
+			const { db, sql } = createDatabase({ url: this.options.databaseUrl });
+			await runMigrations(db);
+			await sql.end();
+			this.logger.info("Database migrations complete");
+		}
+		const services = this.options.services.includes("all") ? [
+			"api",
+			"delivery",
+			"engine",
+			"enricher",
+			"scheduler",
+			"ai",
+			"workflow",
+			"events"
+		] : this.options.services;
+		if (this.options.providers) {
+			for (const provider of this.options.providers) registerTransport(provider);
+			this.logger.info(`Registered ${this.options.providers.length} custom providers`);
+		}
+		const startupPromises = [];
+		if (services.includes("api")) {
+			const { startApiServer } = await import("./main-Ok9cQJ7q.mjs");
+			startupPromises.push(startApiServer());
+		}
+		if (services.includes("delivery")) {
+			const { startDeliveryWorker } = await import("./main-ClEeP5qw.mjs");
+			startupPromises.push(startDeliveryWorker());
+		}
+		if (services.includes("engine")) {
+			const { startEngineWorker } = await import("./main-Dlfy9mWs.mjs");
+			startupPromises.push(startEngineWorker());
+		}
+		if (services.includes("enricher")) {
+			const { startEnricherWorker } = await import("./main-BIcKzWHE.mjs");
+			startupPromises.push(startEnricherWorker());
+		}
+		if (services.includes("scheduler")) {
+			const { startSchedulerWorker } = await import("./main-BHYZfBBq.mjs");
+			startupPromises.push(startSchedulerWorker());
+		}
+		if (services.includes("ai")) {
+			const { startAiWorker } = await import("./main-Dztc2dqR.mjs");
+			startupPromises.push(startAiWorker());
+		}
+		if (services.includes("workflow")) {
+			const { startWorkflowWorker } = await import("./main-4H6vNXvy.mjs");
+			startupPromises.push(startWorkflowWorker());
+		}
+		if (services.includes("events")) {
+			const { startEventWorker } = await import("./main-D-oWWzR3.mjs");
+			startupPromises.push(startEventWorker());
+		}
+		const handleSignal = async (signal) => {
+			this.logger.info(`Received ${signal}, starting graceful shutdown...`);
+			await this.stop();
+			process.exit(0);
+		};
+		if (!this.signalHandlersAttached) {
+			process.once("SIGINT", () => {
+				handleSignal("SIGINT");
+			});
+			process.once("SIGTERM", () => {
+				handleSignal("SIGTERM");
+			});
+			this.signalHandlersAttached = true;
+		}
+		await Promise.all(startupPromises);
+	}
+	async stop() {
+		for (const cleanup of this.eventCleanupFns) cleanup();
+		this.eventCleanupFns = [];
+		const services = this.options.services.includes("all") ? [
+			"api",
+			"delivery",
+			"engine",
+			"enricher",
+			"scheduler",
+			"ai",
+			"workflow",
+			"events"
+		] : this.options.services;
+		if (services.includes("api")) {
+			const { stopApiServer } = await import("./main-Ok9cQJ7q.mjs");
+			await stopApiServer();
+		}
+		if (services.includes("delivery")) {
+			const { stopDeliveryWorker } = await import("./main-ClEeP5qw.mjs");
+			await stopDeliveryWorker();
+		}
+		if (services.includes("engine")) {
+			const { stopEngineWorker } = await import("./main-Dlfy9mWs.mjs");
+			await stopEngineWorker();
+		}
+		if (services.includes("enricher")) {
+			const { stopEnricherWorker } = await import("./main-BIcKzWHE.mjs");
+			await stopEnricherWorker();
+		}
+		if (services.includes("scheduler")) {
+			const { stopSchedulerWorker } = await import("./main-BHYZfBBq.mjs");
+			await stopSchedulerWorker();
+		}
+		if (services.includes("ai")) {
+			const { stopAiWorker } = await import("./main-Dztc2dqR.mjs");
+			await stopAiWorker();
+		}
+		if (services.includes("workflow")) {
+			const { stopWorkflowWorker } = await import("./main-4H6vNXvy.mjs");
+			await stopWorkflowWorker();
+		}
+		if (services.includes("events")) {
+			const { stopEventWorker } = await import("./main-D-oWWzR3.mjs");
+			await stopEventWorker();
+		}
+		if (this.pgContainer) {
+			this.logger.info("Stopping PostgreSQL container...");
+			await this.pgContainer.stop();
+		}
+		if (this.redisContainer) {
+			this.logger.info("Stopping Redis container...");
+			await this.redisContainer.stop();
+		}
+	}
+};
+//#endregion
+export { childLogger as $, PUBSUB_CHANNELS as $t, ProjectSettingsCache as A, NotificationRequestedPayloadSchema as At, LUA_RELEASE_LOCK as B, QuietHoursSchema as Bt, ProjectRepository as C, DeliveryOptionsSchema as Ct, WorkflowRepository as D, NotificationEnrichedPayloadSchema as Dt, UserRepository as E, NotificationScheduledPayloadSchema as Et, sleep as F, CreateWorkflowSchema as Ft, normaliseTarget as G, UpdateUserSchema as Gt, LUA_SCHEDULER_CLAIM as H, TemplateSchema as Ht, DataLoader as I, IngestEventSchema as It, PendingMessageScanner as J, buildStreamEvent as Jt, LRUCache as K, WorkflowNotifyPayloadSchema as Kt, CircuitBreaker as L, InlineUserSchema as Lt, AppError as M, AddContactSchema as Mt, ValidationError as N, AddUserSchema as Nt, Redis as O, RecipientProfileSchema as Ot, generateId as P, ContactChannelSchema as Pt, metrics as Q, OUTBOUND_STREAMS as Qt, BatchProcessor as R, NotifyRequestSchema as Rt, PreferenceRepository as S, NotificationDeliveredPayloadSchema as St, TemplateRepository as T, RenderedContentSchema as Tt, LUA_SCHEDULER_POLL as U, TriggerWorkflowSchema as Ut, LUA_RENEW_LOCK as V, SyncTemplatesSchema as Vt, getPriorityBucket as W, UpdateProjectSchema as Wt, StreamProducer as X, ENRICHED_STREAMS as Xt, StreamConsumer as Y, CONSUMER_GROUPS as Yt, getMetricsRegistry as Z, INBOUND_STREAMS as Zt, escapeHeader as _, setGlobalConfig as _n, workflowWaiters as _t, SuspendExecutionError as a, registry as an, runMigrations as at, renderWithTemplate as b, NotificationSkippedPayloadSchema as bt, BaseWorker as c, NotificationPrioritySchema as cn, projectApiKeys as ct, buildUnsubscribeHeaders as d, baseConfigSchema as dn, suppressions as dt, STREAMS as en, createLogger as et, signUnsubscribeToken as f, getAiConfig as fn, userTopicPreferences as ft, TemplateCache as g, setAiConfig as gn, workflowSteps as gt, templateRegistry as h, readBaseConfig as hn, workflowInstances as ht, workflowRegistry as i, EventRegistry as in, createDatabase as it, UserThrottle as j, NotificationTargetSchema as jt, RedisClient as k, NotificationCreatedPayloadSchema as kt, NonRetryableError as l, NotificationStatusSchema as ln, projects as lt, renderTemplate as m, parseConfig as mn, workflowDefinitions as mt, NotifkitClient as n, StreamEventMetadataSchema as nn, withRequestId as nt, buildStepNotifyPayload as o, EventMetadataSchema as on, deliveryOutbox as ot, verifyUnsubscribeToken as p, loadEnv as pn, users as pt, globalEmitter as q, WorkflowStepSchema as qt, workflow as r, StreamEventSchema as rn, IdempotencyGuard as rt, resolveStepTarget as s, NotificationChannelSchema as sn, messageLogs as st, NotifkitServer as t, EventEnvelopeSchema as tn, withContext as tt, startHealthReporter as u, AI_DEFAULTS as un, scheduledPayloads as ut, escapeHtml as v, NotificationAiPendingPayloadSchema as vt, SegmentRepository as w, NotificationDispatchedPayloadSchema as wt, ContactRepository as x, NotificationFailedPayloadSchema as xt, interpolate as y, NotificationCanceledPayloadSchema as yt, AsyncSemaphore as z, PreferencesSchema as zt };
+
+//# sourceMappingURL=src-DrSN2wCg.mjs.map