@voltro/plugin-webhooks 0.1.0

package/dist/index.js

@@ -0,0 +1,1009 @@
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c, u as l } from "./signing-BOUxHdAo.js";
+import { WebhookDeliveryNotFound as u, WebhookPayloadInvalid as d, WebhookPayloadUnrepresentable as f, WebhookPayloadVersionInvalid as p, WebhookSubscribeInvalid as m } from "./errors.js";
+import { webhookTables as h } from "./mixin.js";
+import { randomBytes as g, randomUUID as _ } from "node:crypto";
+import { Context as v, Effect as y, Either as b, Schema as x } from "effect";
+import { and as S, eq as C } from "@voltro/database";
+import { assertPublicUrl as w } from "@voltro/integration-http";
+import { publishServerError as ee } from "@voltro/protocol";
+import { createLogger as T } from "@voltro/logger";
+import { Activity as E, DurableClock as D, Workflow as te } from "@effect/workflow";
+//#region src/retry.ts
+var ne = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)?$/, O = (e) => {
+	let t = ne.exec(e);
+	if (!t) throw Error(`invalid duration literal: ${e}`);
+	let n = Number(t[1]), r = t[2] ?? "s";
+	switch (r) {
+		case "ms": return n;
+		case "s": return n * 1e3;
+		case "m": return n * 6e4;
+		case "h": return n * 36e5;
+		case "d": return n * 864e5;
+		default: throw Error(`unreachable unit: ${r}`);
+	}
+}, k = [
+	408,
+	425,
+	429,
+	500,
+	502,
+	503,
+	504
+], A = (e, t, n) => {
+	if (t >= e.maxAttempts || n?.status !== void 0 && !(e.retryOn ?? k).includes(n.status)) return null;
+	if (e.honourRetryAfter !== !1 && n?.retryAfterSeconds !== void 0) {
+		let t = n.retryAfterSeconds * 1e3, r = O(e.maxDelay), i = Math.min(t, r);
+		return {
+			delayMs: i,
+			baseDelayMs: i
+		};
+	}
+	let r = O(e.initialDelay), i = O(e.maxDelay), a;
+	switch (e.strategy) {
+		case "fixed":
+			a = r;
+			break;
+		case "linear":
+			a = r * t;
+			break;
+		case "exponential":
+			a = r * 2 ** (t - 1);
+			break;
+	}
+	a = Math.min(a, i);
+	let o = a;
+	return e.jitter === "full" && (o = Math.random() * a), {
+		delayMs: Math.max(1, Math.floor(o)),
+		baseDelayMs: a
+	};
+}, j = () => ({
+	strategy: "exponential",
+	maxAttempts: 8,
+	initialDelay: "5s",
+	maxDelay: "1h",
+	retryOn: k,
+	honourRetryAfter: !0,
+	jitter: "full"
+}), re = () => ({
+	strategy: "fixed",
+	maxAttempts: 120,
+	initialDelay: "30s",
+	maxDelay: "30s",
+	retryOn: k,
+	honourRetryAfter: !0,
+	jitter: "full"
+}), M = class extends v.Tag("@voltro/webhooks/WebhooksService")() {}, ie = 32, N = 32, P = () => g(ie).toString("hex"), F = (e) => {
+	let t;
+	try {
+		t = new URL(e.url);
+	} catch (e) {
+		throw new m({
+			field: "url",
+			reason: `invalid subscriber url: ${e.message}`
+		});
+	}
+	if (t.protocol !== "http:" && t.protocol !== "https:") throw new m({
+		field: "url",
+		reason: `url protocol must be http or https, got ${t.protocol}`
+	});
+	if (process.env.NODE_ENV === "production") try {
+		w(e.url);
+	} catch (e) {
+		throw new m({
+			field: "url",
+			reason: e.message
+		});
+	}
+	if (e.event.length === 0) throw new m({
+		field: "event",
+		reason: "event id required"
+	});
+	if (e.secret !== void 0 && e.secret.length < N) throw new m({
+		field: "secret",
+		reason: `secret must be at least ${N} chars`
+	});
+	if (e.retry !== void 0) {
+		if (e.retry.maxAttempts < 1) throw new m({
+			field: "retry",
+			reason: "retry.maxAttempts must be ≥ 1"
+		});
+		if (e.retry.maxAttempts > 1e3) throw new m({
+			field: "retry",
+			reason: "retry.maxAttempts must be ≤ 1000"
+		});
+	}
+	if (e.rateLimitPerMinute !== void 0 && e.rateLimitPerMinute < 1) throw new m({
+		field: "rateLimitPerMinute",
+		reason: "rateLimitPerMinute must be ≥ 1"
+	});
+	if (e.autoDisableAfter !== void 0 && (e.autoDisableAfter < 1 || !Number.isInteger(e.autoDisableAfter))) throw new m({
+		field: "autoDisableAfter",
+		reason: `autoDisableAfter must be a positive integer, got ${e.autoDisableAfter}`
+	});
+}, I = (e, t) => ({
+	id: _(),
+	event: e.event,
+	url: e.url,
+	secret: e.secret ?? P(),
+	signing: e.signing ?? t?.defaultSigning ?? c(),
+	retry: e.retry ?? t?.defaultRetry ?? j(),
+	filter: e.filter ?? null,
+	headers: e.headers ?? null,
+	rateLimitPerMinute: e.rateLimitPerMinute ?? null,
+	active: !0,
+	format: e.format ?? "json",
+	autoDisableAfter: e.autoDisableAfter ?? null,
+	consecutiveFailures: 0,
+	autoDisabledAt: null,
+	autoDisableReason: null,
+	payloadVersion: e.payloadVersion ?? t?.version ?? 1,
+	description: e.description ?? null
+}), ae = (e, t) => e === t ? "current" : e < t ? "behind" : "ahead", L = (e, t) => {
+	if (e === null) return !0;
+	let n = { payload: t };
+	for (let [t, r] of Object.entries(e)) if (!se(oe(n, t), r)) return !1;
+	return !0;
+}, oe = (e, t) => {
+	let n = t.split("."), r = e;
+	for (let e of n) {
+		if (typeof r != "object" || !r) return;
+		r = r[e];
+	}
+	return r;
+}, se = (e, t) => {
+	if (typeof t == "object" && t && !Array.isArray(t)) {
+		let n = t;
+		if ("eq" in n) return e === n.eq;
+		if ("gt" in n) return typeof e == "number" && typeof n.gt == "number" && e > n.gt;
+		if ("gte" in n) return typeof e == "number" && typeof n.gte == "number" && e >= n.gte;
+		if ("lt" in n) return typeof e == "number" && typeof n.lt == "number" && e < n.lt;
+		if ("lte" in n) return typeof e == "number" && typeof n.lte == "number" && e <= n.lte;
+		if ("in" in n && Array.isArray(n.in)) return n.in.includes(e);
+	}
+	return e === t;
+}, ce = (e, t, n = {}) => {
+	let r = new Map((n.events ?? []).map((e) => [e.id, e]));
+	return {
+		subscribe: async (t) => {
+			F(t);
+			let n = I(t, r.get(t.event));
+			return await e.store.insert("_voltro_webhook_targets", {
+				...n,
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			}), {
+				id: n.id,
+				event: n.event,
+				url: n.url,
+				secret: n.secret,
+				signing: n.signing,
+				retry: n.retry
+			};
+		},
+		emit: async (n, i) => {
+			let a = typeof n == "string" ? r.get(n) : n, o = typeof n == "string" ? n : n.id;
+			if (a !== void 0) {
+				let e = x.decodeUnknownEither(a.payload)(i, { errors: "all" });
+				if (b.isLeft(e)) throw new d({
+					event: o,
+					issues: e.left.message
+				});
+			}
+			let s = _(), c = (await e.store.query({
+				table: "_voltro_webhook_targets",
+				predicate: C("event", o),
+				order: [{
+					column: "createdAt",
+					direction: "asc"
+				}],
+				take: 1e3,
+				skip: void 0,
+				projection: void 0
+			})).filter((e) => L(e.filter, i)), l = [], u = JSON.stringify(i);
+			for (let n of c) {
+				let r = _();
+				n.active ? (await t({
+					deliveryId: r,
+					targetId: n.id,
+					event: o,
+					eventId: s,
+					payloadJson: u
+				}), l.push({
+					targetId: n.id,
+					deliveryId: r,
+					status: "dispatched"
+				})) : (await e.store.insert("_voltro_webhook_deliveries", {
+					id: `${r}:1`,
+					deliveryId: r,
+					targetId: n.id,
+					tenantId: n.tenantId ?? null,
+					event: o,
+					eventId: s,
+					attempt: 1,
+					status: "pending",
+					payload: u,
+					scheduledAt: /* @__PURE__ */ new Date(),
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				}), l.push({
+					targetId: n.id,
+					deliveryId: r,
+					status: "queued"
+				}));
+			}
+			return {
+				eventId: s,
+				deliveries: l
+			};
+		},
+		replay: async (n) => {
+			let r = (await e.store.query({
+				table: "_voltro_webhook_deliveries",
+				predicate: C("deliveryId", n),
+				order: [{
+					column: "attempt",
+					direction: "asc"
+				}],
+				take: 1,
+				skip: void 0,
+				projection: void 0
+			}))[0];
+			if (r === void 0) throw new u({ deliveryId: n });
+			await t({
+				deliveryId: r.deliveryId,
+				targetId: r.targetId,
+				event: r.event,
+				eventId: r.eventId ?? _(),
+				payloadJson: typeof r.payload == "string" ? r.payload : JSON.stringify(r.payload),
+				attemptEpoch: Date.now()
+			});
+		},
+		pauseTarget: async (t) => {
+			await e.store.update("_voltro_webhook_targets", t, {
+				active: !1,
+				updatedAt: /* @__PURE__ */ new Date()
+			});
+		},
+		resumeTarget: async (n) => {
+			await e.store.update("_voltro_webhook_targets", n, {
+				active: !0,
+				consecutiveFailures: 0,
+				autoDisabledAt: null,
+				autoDisableReason: null,
+				updatedAt: /* @__PURE__ */ new Date()
+			});
+			let r = await e.store.query({
+				table: "_voltro_webhook_deliveries",
+				predicate: S(C("targetId", n), C("status", "pending")),
+				order: [{
+					column: "createdAt",
+					direction: "asc"
+				}],
+				take: 1e4,
+				skip: void 0,
+				projection: void 0
+			}), i = Date.now();
+			for (let e of r) await t({
+				deliveryId: e.deliveryId,
+				targetId: n,
+				event: e.event,
+				eventId: e.eventId ?? _(),
+				payloadJson: typeof e.payload == "string" ? e.payload : JSON.stringify(e.payload),
+				attemptEpoch: i
+			});
+		},
+		deleteTarget: async (t) => {
+			await e.store.delete("_voltro_webhook_targets", t), await e.store.deleteMany("_voltro_webhook_deliveries", { where: S(C("targetId", t), C("status", "pending")) });
+		},
+		rotateSecret: async (t) => {
+			let n = P();
+			return await e.store.update("_voltro_webhook_targets", t, {
+				secret: n,
+				updatedAt: /* @__PURE__ */ new Date()
+			}), { secret: n };
+		},
+		updateTargetPayloadVersion: async (t, n) => {
+			if (n < 1 || !Number.isInteger(n)) throw new p({ version: n });
+			await e.store.update("_voltro_webhook_targets", t, {
+				payloadVersion: n,
+				updatedAt: /* @__PURE__ */ new Date()
+			});
+		},
+		listTargets: async (t) => (await e.store.query({
+			table: "_voltro_webhook_targets",
+			predicate: t === void 0 ? void 0 : C("event", t),
+			order: [{
+				column: "createdAt",
+				direction: "desc"
+			}],
+			take: 500,
+			skip: void 0,
+			projection: void 0
+		})).map((e) => ({
+			id: e.id,
+			event: e.event,
+			url: e.url,
+			active: e.active,
+			rateLimitPerMinute: e.rateLimitPerMinute,
+			description: e.description,
+			payloadVersion: e.payloadVersion,
+			autoDisableAfter: e.autoDisableAfter,
+			consecutiveFailures: e.consecutiveFailures ?? 0,
+			autoDisabledAt: e.autoDisabledAt === null || e.autoDisabledAt === void 0 ? null : e.autoDisabledAt instanceof Date ? e.autoDisabledAt.toISOString() : String(e.autoDisabledAt),
+			autoDisableReason: e.autoDisableReason
+		}))
+	};
+}, le = y.gen(function* () {
+	return yield* M;
+}), ue = (e) => {
+	if (e.webhooks === void 0) throw Error("useWebhooks: `ctx.webhooks` is not set. Add @voltro/plugin-webhooks to your app.config.ts plugin list and declare at least one *.webhook.tsx file.");
+	return e.webhooks;
+}, de = 1e4, R = class {
+	capacity;
+	cache = /* @__PURE__ */ new Map();
+	constructor(e = de) {
+		this.capacity = e;
+	}
+	evictExpired() {
+		let e = Date.now();
+		for (let [t, n] of this.cache) n.expiresAt < e && this.cache.delete(t);
+	}
+	claim(e, t) {
+		let n = this.cache.get(e);
+		if (n !== void 0 && n.expiresAt > Date.now()) return this.cache.delete(e), this.cache.set(e, n), n.value === "inflight" ? "inflight" : "duplicate";
+		if (this.cache.set(e, {
+			value: "inflight",
+			expiresAt: Date.now() + t
+		}), this.cache.size > this.capacity) {
+			let e = this.cache.keys().next().value;
+			e !== void 0 && this.cache.delete(e);
+		}
+		return "fresh";
+	}
+	commit(e) {
+		let t = this.cache.get(e);
+		t !== void 0 && this.cache.set(e, {
+			value: "processed",
+			expiresAt: t.expiresAt
+		});
+	}
+	release(e) {
+		this.cache.delete(e);
+	}
+	size() {
+		return this.evictExpired(), this.cache.size;
+	}
+	clear() {
+		this.cache.clear();
+	}
+}, z = null, B = () => (z === null && (z = new R()), z), V = {
+	"5m": 5 * 6e4,
+	"1h": 60 * 6e4,
+	"6h": 360 * 6e4,
+	"1d": 1440 * 6e4,
+	"7d": 10080 * 6e4,
+	"30d": 720 * 60 * 6e4
+}, H = (e) => e === void 0 ? V["7d"] : V[e] ?? V["7d"], U = (e, t) => ({
+	status: e,
+	contentType: "application/json; charset=utf-8",
+	body: JSON.stringify(t)
+}), fe = (e, t) => {
+	let n = e.provider, r = e.signature ?? n?.signature ?? null, i = e.idempotency ?? n?.idempotency ?? null, o = e.bodyType ?? n?.bodyType ?? "json", s = t.idempotencyCache ?? B(), c = H(i?.ttl), l = t.log ?? ((e) => {
+		T({ scope: `webhook:${e.webhookId}` }).debug("incoming webhook", {
+			status: e.status,
+			signatureOk: e.signatureOk,
+			idempotency: e.idempotency,
+			durationMs: e.durationMs,
+			...e.errorMessage === void 0 ? {} : { errorMessage: e.errorMessage }
+		});
+	});
+	return async (n) => {
+		let u = Date.now();
+		if (n.method !== "POST") {
+			let t = U(405, {
+				error: "method not allowed",
+				expected: "POST"
+			});
+			return l({
+				webhookId: e.id,
+				status: 405,
+				signatureOk: "skipped",
+				idempotency: "skipped",
+				durationMs: Date.now() - u
+			}), t;
+		}
+		let d = "skipped";
+		if (r !== null) {
+			let i = await t.resolveSecret(e.id);
+			if (i === null) d = "skipped";
+			else {
+				let t = n.headers[r.header.toLowerCase()], o = t;
+				r._tag === "custom" && n.headers["x-slack-request-timestamp"] && (o = `${n.headers["x-slack-request-timestamp"]}|${t ?? ""}`);
+				let s = a(r, n.rawBody, i, o);
+				if (d = s.ok, !s.ok) {
+					let t = U(401, {
+						error: "invalid signature",
+						reason: s.reason
+					});
+					return l({
+						webhookId: e.id,
+						status: 401,
+						signatureOk: !1,
+						idempotency: "skipped",
+						durationMs: Date.now() - u,
+						errorMessage: s.reason
+					}), t;
+				}
+			}
+		}
+		let f;
+		try {
+			if (o === "json") {
+				let e = new TextDecoder().decode(n.rawBody);
+				f = e.length === 0 ? null : JSON.parse(e);
+			} else if (o === "form") {
+				let e = new TextDecoder().decode(n.rawBody), t = new URLSearchParams(e), r = {};
+				for (let [e, n] of t.entries()) r[e] = n;
+				f = r;
+			} else f = n.rawBody;
+		} catch (t) {
+			let n = U(400, {
+				error: "malformed body",
+				reason: t.message
+			});
+			return l({
+				webhookId: e.id,
+				status: 400,
+				signatureOk: d,
+				idempotency: "skipped",
+				durationMs: Date.now() - u,
+				errorMessage: t.message
+			}), n;
+		}
+		let p;
+		try {
+			p = x.decodeUnknownSync(e.payload)(f);
+		} catch (t) {
+			let n = U(422, {
+				error: "schema validation failed",
+				reason: t.message
+			});
+			return l({
+				webhookId: e.id,
+				status: 422,
+				signatureOk: d,
+				idempotency: "skipped",
+				durationMs: Date.now() - u,
+				errorMessage: t.message
+			}), n;
+		}
+		let m, h = "skipped";
+		if (i !== null) {
+			let t = i.from;
+			if (m = typeof t == "string" ? n.headers[t.toLowerCase()] : t(n.headers, n.rawBody), m !== void 0 && m.length > 0) {
+				let t = s.claim(m, c);
+				if (h = t, t === "duplicate") {
+					let t = U(200, {
+						received: !0,
+						duplicate: !0
+					});
+					return l({
+						webhookId: e.id,
+						status: 200,
+						signatureOk: d,
+						idempotency: "duplicate",
+						durationMs: Date.now() - u
+					}), t;
+				}
+				if (t === "inflight") {
+					let t = U(409, {
+						error: "request already in flight",
+						idempotencyKey: m
+					});
+					return l({
+						webhookId: e.id,
+						status: 409,
+						signatureOk: d,
+						idempotency: "inflight",
+						durationMs: Date.now() - u
+					}), t;
+				}
+			}
+		}
+		try {
+			let r = t.resolveWorkflows?.();
+			await e.handler({
+				body: p,
+				rawBody: n.rawBody,
+				headers: n.headers,
+				idempotencyKey: m ?? "",
+				...r ? { workflows: r } : {}
+			}), m !== void 0 && s.commit(m);
+			let i = U(200, { received: !0 });
+			return l({
+				webhookId: e.id,
+				status: 200,
+				signatureOk: d,
+				idempotency: h,
+				durationMs: Date.now() - u
+			}), i;
+		} catch (t) {
+			m !== void 0 && s.release(m);
+			let n = U(500, {
+				error: "handler threw",
+				reason: t.message
+			});
+			return l({
+				webhookId: e.id,
+				status: 500,
+				signatureOk: d,
+				idempotency: h,
+				durationMs: Date.now() - u,
+				errorMessage: t.message
+			}), ee({
+				error: t,
+				source: "webhook",
+				name: e.id,
+				fields: { status: 500 }
+			}), n;
+		}
+	};
+}, pe = (e) => `/webhooks/${e}`, W = "_voltro_webhook_rate_windows", G = 6e4, me = (e, t) => `${e}@${t}`, K = async (e, t, n) => (await e.query({
+	table: "_voltro_webhook_rate_windows",
+	predicate: S(C("scope", t), C("bucket", n)),
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0
+}))[0] ?? null, q = 32, J = async (e, t, n) => {
+	for (let r = 0; r < q; r++) {
+		r > 0 && await new Promise((e) => setTimeout(e, r));
+		let i = await K(e, t.key, n);
+		if (i === null) {
+			await e.insertIgnore(W, {
+				id: me(t.key, n),
+				scope: t.key,
+				bucket: n,
+				count: 0,
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			}, { conflictColumns: ["id"] });
+			continue;
+		}
+		if (i.count >= t.limit) return !1;
+		if (await e.updateMany("_voltro_webhook_rate_windows", {
+			count: i.count + 1,
+			updatedAt: /* @__PURE__ */ new Date()
+		}, { where: S(C("id", i.id), C("count", i.count)) }) === 1) return !0;
+	}
+	throw Error(`webhook rate window: contention on (${t.key}, ${n}) exceeded ${q} attempts`);
+}, Y = async (e, t, n) => {
+	for (let r = 0; r < q; r++) {
+		r > 0 && await new Promise((e) => setTimeout(e, r));
+		let i = await K(e, t, n);
+		if (i === null || i.count <= 0 || await e.updateMany("_voltro_webhook_rate_windows", {
+			count: i.count - 1,
+			updatedAt: /* @__PURE__ */ new Date()
+		}, { where: S(C("id", i.id), C("count", i.count)) }) === 1) return;
+	}
+	throw Error(`webhook rate window: release contention on (${t}) exceeded ${q} attempts`);
+}, X = async (e, t, n, r = G) => {
+	if (t.length === 0) return {
+		acquired: !0,
+		retryInMs: 0
+	};
+	let i = Math.floor(n / r), a = [];
+	for (let o of t) {
+		if (await J(e, o, i)) {
+			a.push(o);
+			continue;
+		}
+		for (let t of a) await Y(e, t.key, i);
+		return {
+			acquired: !1,
+			retryInMs: (i + 1) * r - n
+		};
+	}
+	return {
+		acquired: !0,
+		retryInMs: 0
+	};
+}, Z = (e, t) => {
+	if (e === "json") return {
+		contentType: "application/json",
+		bytes: Buffer.from(t, "utf8")
+	};
+	let n;
+	try {
+		n = JSON.parse(t);
+	} catch (t) {
+		throw new f({
+			format: e,
+			reason: `payload is not valid JSON: ${t.message}`
+		});
+	}
+	return e === "form" ? {
+		contentType: "application/x-www-form-urlencoded",
+		bytes: Buffer.from(he(n), "utf8")
+	} : {
+		contentType: "application/xml",
+		bytes: Buffer.from(_e(n), "utf8")
+	};
+}, he = (e) => {
+	if (typeof e != "object" || !e || Array.isArray(e)) throw new f({
+		format: "form",
+		reason: `form encoding requires a JSON object at the top level, got ${be(e)}`
+	});
+	let t = new URLSearchParams();
+	for (let [n, r] of Object.entries(e)) Q(t, n, r);
+	return t.toString();
+}, Q = (e, t, n) => {
+	if (n === null) {
+		e.append(t, "");
+		return;
+	}
+	if (Array.isArray(n)) {
+		n.forEach((n, r) => Q(e, `${t}[${r}]`, n));
+		return;
+	}
+	if (typeof n == "object") {
+		for (let [r, i] of Object.entries(n)) Q(e, `${t}[${r}]`, i);
+		return;
+	}
+	e.append(t, String(n));
+}, ge = /^[A-Za-z_][A-Za-z0-9_.-]*$/, _e = (e) => `<?xml version="1.0" encoding="UTF-8"?>${$("webhook", e)}`, $ = (e, t) => {
+	if (!ge.test(e)) throw new f({
+		format: "xml",
+		reason: `object key ${JSON.stringify(e)} is not a valid XML element name`
+	});
+	return `<${e}>${ve(e, t)}</${e}>`;
+}, ve = (e, t) => t == null ? "" : Array.isArray(t) ? t.map((e) => $("item", e)).join("") : typeof t == "object" ? Object.entries(t).map(([e, t]) => $(e, t)).join("") : ye(String(t)), ye = (e) => e.replace(/[&<>"']/g, (e) => {
+	switch (e) {
+		case "&": return "&amp;";
+		case "<": return "&lt;";
+		case ">": return "&gt;";
+		case "\"": return "&quot;";
+		default: return "&apos;";
+	}
+}), be = (e) => e === null ? "null" : Array.isArray(e) ? "array" : typeof e, xe = "_voltro_webhook_targets", Se = 32, Ce = async (e, t) => (await e.query({
+	table: "_voltro_webhook_targets",
+	predicate: C("id", t),
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0
+}))[0] ?? null, we = async (e, t, n, r, i = /* @__PURE__ */ new Date()) => {
+	for (let a = 0; a < Se; a++) {
+		a > 0 && await new Promise((e) => setTimeout(e, a));
+		let o = await Ce(e, t);
+		if (o === null) return {
+			consecutiveFailures: 0,
+			autoDisabled: !1
+		};
+		let s = o.consecutiveFailures ?? 0;
+		if (n) {
+			if (s === 0 || await e.updateMany("_voltro_webhook_targets", {
+				consecutiveFailures: 0,
+				updatedAt: i
+			}, { where: S(C("id", t), C("consecutiveFailures", s)) }) === 1) return {
+				consecutiveFailures: 0,
+				autoDisabled: !1
+			};
+			continue;
+		}
+		let c = s + 1, l = o.autoDisableAfter, u = typeof l == "number" && l > 0 && o.active && c >= l, d = {
+			consecutiveFailures: c,
+			updatedAt: i
+		};
+		if (u && (d.active = !1, d.autoDisabledAt = i, d.autoDisableReason = r.slice(0, 500)), await e.updateMany("_voltro_webhook_targets", d, { where: S(C("id", t), C("consecutiveFailures", s)) }) === 1) return {
+			consecutiveFailures: c,
+			autoDisabled: u
+		};
+	}
+	throw Error(`webhook auto-disable: streak CAS contention on target ${t} exceeded ${Se} attempts`);
+}, Te = x.Struct({
+	status: x.Number,
+	body: x.String,
+	latencyMs: x.Number,
+	retryAfterSec: x.Union(x.Number, x.Undefined),
+	transportError: x.Union(x.String, x.Undefined),
+	encodeError: x.Union(x.String, x.Undefined)
+}), Ee = x.Struct({
+	outcome: x.Literal("succeeded", "failed", "retry"),
+	delayMs: x.Union(x.Number, x.Undefined),
+	reason: x.Union(x.String, x.Undefined),
+	autoDisabled: x.Union(x.Boolean, x.Undefined),
+	consecutiveFailures: x.Union(x.Number, x.Undefined)
+}), De = x.Struct({
+	acquired: x.Boolean,
+	retryInMs: x.Number
+}), Oe = te.make({
+	name: "voltro.deliverWebhook",
+	payload: {
+		deliveryId: x.String,
+		targetId: x.String,
+		event: x.String,
+		eventId: x.String,
+		payloadJson: x.String,
+		attemptEpoch: x.optionalWith(x.Number, { default: () => 0 })
+	},
+	success: x.Struct({
+		finalStatus: x.Literal("succeeded", "failed", "deferred"),
+		attempts: x.Number
+	}),
+	idempotencyKey: ({ deliveryId: e, attemptEpoch: t }) => `voltro.deliverWebhook:${e}:${t ?? 0}`
+}), ke = (e, t = {}) => (n, r) => {
+	let { deliveryId: i, targetId: a, event: s, eventId: c, payloadJson: l } = n, u = T({ scope: `webhook:${i}` });
+	return y.gen(function* () {
+		let n = yield* E.make({
+			name: "fetch-target",
+			success: x.Union(x.Null, x.Struct({
+				id: x.String,
+				event: x.String,
+				url: x.String,
+				secret: x.String,
+				signing: x.Any,
+				retry: x.Any,
+				headers: x.Union(x.Record({
+					key: x.String,
+					value: x.String
+				}), x.Null),
+				rateLimitPerMinute: x.Union(x.Number, x.Null),
+				active: x.Boolean,
+				format: x.Literal("json", "form", "xml"),
+				tenantId: x.Union(x.String, x.Null)
+			})),
+			execute: y.tryPromise({
+				try: async () => (await e.store.query({
+					table: "_voltro_webhook_targets",
+					predicate: C("id", a),
+					order: [{
+						column: "createdAt",
+						direction: "asc"
+					}],
+					take: 1,
+					skip: void 0,
+					projection: void 0
+				}))[0] ?? null,
+				catch: (e) => (u.debug("fetch-target raw error", {
+					targetId: a,
+					event: s,
+					cause: String(e)
+				}), /* @__PURE__ */ Error(`fetch-target failed: ${e.message}`))
+			}).pipe(y.orDie)
+		});
+		if (n === null) return {
+			finalStatus: "failed",
+			attempts: 0
+		};
+		let r = async (t, r, o) => {
+			await e.store.update("_voltro_webhook_deliveries", t, {
+				...o,
+				updatedAt: /* @__PURE__ */ new Date()
+			}) === null && await e.store.insert("_voltro_webhook_deliveries", {
+				id: t,
+				deliveryId: i,
+				targetId: a,
+				tenantId: n.tenantId ?? null,
+				event: s,
+				eventId: c,
+				attempt: r,
+				payload: l,
+				scheduledAt: /* @__PURE__ */ new Date(),
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date(),
+				...o
+			});
+		};
+		if (n.active !== !0) return yield* E.make({
+			name: "record-paused-pending",
+			success: x.Void,
+			execute: y.tryPromise({
+				try: () => r(`${i}:1`, 1, { status: "pending" }),
+				catch: (e) => /* @__PURE__ */ Error(`record-paused-pending failed: ${e.message}`)
+			}).pipe(y.orDie)
+		}), {
+			finalStatus: "deferred",
+			attempts: 0
+		};
+		let d = (e) => typeof e == "string" ? JSON.parse(e) : e, p = d(n.retry), m = d(n.signing), h = n.headers === null ? null : d(n.headers), g = t.rateWindowMs ?? 6e4, _ = t.events?.find((e) => e.id === s)?.globalRateLimit, v = [...typeof n.rateLimitPerMinute == "number" && n.rateLimitPerMinute > 0 ? [{
+			key: `target:${n.id}`,
+			limit: n.rateLimitPerMinute
+		}] : [], ..._ !== void 0 && _.perMinute > 0 ? [{
+			key: `event:${s}`,
+			limit: _.perMinute
+		}] : []];
+		for (let t = 1; t <= p.maxAttempts; t++) {
+			let d = `${i}:${t}`;
+			if (v.length > 0) for (let n = 0;; n++) {
+				let i = yield* E.make({
+					name: `rate-acquire-${t}-${n}`,
+					success: De,
+					execute: y.tryPromise({
+						try: () => X(e.store, v, Date.now(), g),
+						catch: (e) => (u.debug("rate-acquire raw error", {
+							targetId: a,
+							event: s,
+							attempt: t,
+							cause: String(e)
+						}), /* @__PURE__ */ Error(`rate-acquire failed: ${e.message}`))
+					}).pipe(y.orDie)
+				});
+				if (i.acquired) break;
+				yield* E.make({
+					name: `record-rate-deferral-${t}-${n}`,
+					success: x.Void,
+					execute: y.tryPromise({
+						try: () => r(d, t, {
+							status: "pending",
+							nextAttemptAt: new Date(Date.now() + i.retryInMs)
+						}),
+						catch: (e) => /* @__PURE__ */ Error(`record-rate-deferral failed: ${e.message}`)
+					}).pipe(y.orDie)
+				}), yield* D.sleep({
+					name: `rate-window-sleep-${t}-${n}`,
+					duration: `${i.retryInMs} millis`
+				});
+			}
+			yield* E.make({
+				name: `record-attempt-start-${t}`,
+				success: x.Void,
+				execute: y.tryPromise({
+					try: () => r(d, t, {
+						status: "inFlight",
+						nextAttemptAt: null,
+						scheduledAt: /* @__PURE__ */ new Date()
+					}),
+					catch: (e) => /* @__PURE__ */ Error(`record-attempt-start failed: ${e.message}`)
+				}).pipe(y.orDie)
+			});
+			let _ = yield* E.make({
+				name: `sign-and-post-${t}`,
+				success: Te,
+				execute: y.promise(async () => {
+					let e = Date.now(), r;
+					try {
+						r = Z(n.format, l);
+					} catch (t) {
+						if (t instanceof f) return {
+							status: 0,
+							body: "",
+							latencyMs: Date.now() - e,
+							retryAfterSec: void 0,
+							transportError: void 0,
+							encodeError: t.reason
+						};
+						throw t;
+					}
+					let a = Buffer.from(r.bytes), { headerName: u, headerValue: d } = o(m, a, n.secret);
+					process.env.NODE_ENV === "production" && w(n.url);
+					try {
+						let o = await fetch(n.url, {
+							method: "POST",
+							headers: {
+								"content-type": r.contentType,
+								[u]: d,
+								"x-voltro-event": s,
+								"x-voltro-event-id": c,
+								"x-voltro-delivery-id": i,
+								"x-voltro-attempt": String(t),
+								"idempotency-key": i,
+								...h ?? {}
+							},
+							body: a
+						}), l = (await o.text()).slice(0, 8192), f = o.headers.get("retry-after");
+						return {
+							status: o.status,
+							body: l,
+							latencyMs: Date.now() - e,
+							retryAfterSec: f !== null && /^\d+$/.test(f) ? Number(f) : void 0,
+							transportError: void 0,
+							encodeError: void 0
+						};
+					} catch (t) {
+						return {
+							status: 0,
+							body: "",
+							latencyMs: Date.now() - e,
+							retryAfterSec: void 0,
+							transportError: t.message,
+							encodeError: void 0
+						};
+					}
+				})
+			}), b = yield* E.make({
+				name: `classify-and-record-${t}`,
+				success: Ee,
+				execute: y.tryPromise({
+					try: async () => {
+						let r = _.status >= 200 && _.status < 300, i = _.transportError !== void 0, o = _.encodeError !== void 0, s = (t, n) => we(e.store, a, t, n);
+						if (r) {
+							await e.store.update("_voltro_webhook_deliveries", d, {
+								status: "succeeded",
+								responseStatus: _.status,
+								responseBody: _.body,
+								latencyMs: _.latencyMs,
+								updatedAt: /* @__PURE__ */ new Date()
+							});
+							let t = await s(!0, "");
+							return {
+								outcome: "succeeded",
+								delayMs: void 0,
+								reason: void 0,
+								autoDisabled: t.autoDisabled,
+								consecutiveFailures: t.consecutiveFailures
+							};
+						}
+						let c = o ? null : A(p, t, {
+							...i ? {} : { status: _.status },
+							..._.retryAfterSec === void 0 ? {} : { retryAfterSeconds: _.retryAfterSec }
+						});
+						if (c === null) {
+							let t = o ? `encode (${n.format}): ${_.encodeError}` : i ? `transport: ${_.transportError}` : `http ${_.status}: ${_.body.slice(0, 200)}`;
+							await e.store.update("_voltro_webhook_deliveries", d, {
+								status: "failed",
+								responseStatus: i || o ? null : _.status,
+								responseBody: i || o ? null : _.body,
+								errorMessage: o ? t : _.transportError ?? null,
+								latencyMs: _.latencyMs,
+								updatedAt: /* @__PURE__ */ new Date()
+							});
+							let r = await s(!1, t);
+							return {
+								outcome: "failed",
+								delayMs: void 0,
+								reason: t,
+								autoDisabled: r.autoDisabled,
+								consecutiveFailures: r.consecutiveFailures
+							};
+						}
+						return await e.store.update("_voltro_webhook_deliveries", d, {
+							status: "retryScheduled",
+							responseStatus: i ? null : _.status,
+							responseBody: i ? null : _.body,
+							errorMessage: _.transportError ?? null,
+							latencyMs: _.latencyMs,
+							nextAttemptAt: new Date(Date.now() + c.delayMs),
+							updatedAt: /* @__PURE__ */ new Date()
+						}), {
+							outcome: "retry",
+							delayMs: c.delayMs,
+							reason: void 0,
+							autoDisabled: void 0,
+							consecutiveFailures: void 0
+						};
+					},
+					catch: (e) => (u.debug("classify-and-record raw error", {
+						targetId: a,
+						event: s,
+						attempt: t,
+						cause: String(e)
+					}), /* @__PURE__ */ Error(`classify-and-record failed: ${e.message}`))
+				}).pipe(y.orDie)
+			});
+			if (b.autoDisabled === !0 && u.warn("target auto-disabled after consecutive failures", {
+				targetId: a,
+				event: s,
+				consecutiveFailures: b.consecutiveFailures ?? null,
+				reason: b.reason ?? null
+			}), b.outcome === "succeeded") return {
+				finalStatus: "succeeded",
+				attempts: t
+			};
+			if (b.outcome === "failed") return {
+				finalStatus: "failed",
+				attempts: t
+			};
+			b.delayMs !== void 0 && (yield* D.sleep({
+				name: `retry-sleep-${t}`,
+				duration: `${b.delayMs} millis`
+			}));
+		}
+		return {
+			finalStatus: "failed",
+			attempts: p.maxAttempts
+		};
+	});
+};
+//#endregion
+export { R as IdempotencyCache, G as RATE_WINDOW_MS, W as RATE_WINDOW_TABLE, xe as TARGETS_TABLE, u as WebhookDeliveryNotFound, d as WebhookPayloadInvalid, f as WebhookPayloadUnrepresentable, p as WebhookPayloadVersionInvalid, m as WebhookSubscribeInvalid, M as WebhooksService, X as acquireRateSlots, ke as buildDeliverWebhookExecute, ce as buildWebhooksService, ae as compareVersions, J as consumeRateSlot, pe as defaultIncomingPath, c as defaultOutgoingSignature, j as defaultRetryPolicy, s as defineIncomingWebhook, t as defineOutgoingEvent, r as defineWebhookProvider, Oe as deliverWebhookWorkflow, Z as encodePayload, re as fastRetryPolicy, P as generateSecret, B as getIdempotencyCache, i as githubSignature, l as isWebhookDescriptor, L as matchesFilter, fe as mountIncomingWebhook, A as nextRetry, O as parseDuration, H as parseTtl, we as recordDeliveryOutcome, Y as releaseRateSlot, I as resolveSubscribe, o as signPayload, n as slackSignature, e as stripeSignature, ue as useWebhooks, le as useWebhooksEffect, F as validateSubscribe, a as verifySignature, h as webhookTables };