@primitivedotdev/sdk 1.26.1 → 1.27.0

package/dist/{api-BEv_YML6.js → api-D4xf448r.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./chunk-pbuEa-1d.js";
-import { a as pushFile, i as pushBytes, o as loadNodeFsPromises } from "./payloads-BfJAtqW9.js";
-import { S as formatAddress, c as WebhookVerificationError } from "./errors-BVnAu5jX.js";
+import { L as WebhookVerificationError, _ as parseWebhookEvent, m as formatAddress } from "./trust-DBOnyTHV.js";
+import { a as pushFile, i as pushBytes, o as loadNodeFsPromises } from "./payloads-BMngnJlE.js";
 //#region ../packages/api-core/src/api/core/bodySerializer.gen.ts
 const jsonBodySerializer = { bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value) };
 //#endregion
@@ -3393,6 +3393,507 @@ function isMemoryJsonValue(value, seen = /* @__PURE__ */ new Set()) {
 	}
 }
 //#endregion
+//#region src/api/event-transport.ts
+var EventReceiverError = class extends Error {
+	constructor(message, code, status = 0, retryAfterMs = 0) {
+		super(message);
+		this.code = code;
+		this.status = status;
+		this.retryAfterMs = retryAfterMs;
+		this.name = "EventReceiverError";
+	}
+};
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validateOffer(value) {
+	if (!record(value) || !Number.isSafeInteger(value.backlog) || Number(value.backlog) < 0 || !Number.isSafeInteger(value.gap_count) || Number(value.gap_count) < 0 || value.last_gap_reason !== null && typeof value.last_gap_reason !== "string" || value.retention_seconds !== 86400 || value.handler_timeout_seconds !== 30) throw new EventReceiverError("Invalid event status response", "invalid_response");
+	const d = value.delivery;
+	if (d !== null && (!record(d) || ![
+		"queue_id",
+		"event_id",
+		"delivery_id",
+		"lease_token",
+		"event_type",
+		"body",
+		"lease_expires_at"
+	].every((key) => typeof d[key] === "string") || !Number.isFinite(Date.parse(String(d.lease_expires_at))) || !record(d.headers) || !Object.values(d.headers).every((header) => typeof header === "string"))) throw new EventReceiverError("Invalid event delivery response", "invalid_response");
+	return value;
+}
+function retryAfter(value) {
+	if (!value) return 0;
+	const ms = /^\d+(\.\d+)?$/.test(value) ? Number(value) * 1e3 : Date.parse(value) - Date.now();
+	return Number.isFinite(ms) ? Math.max(0, ms) : 0;
+}
+function unwrap(result) {
+	if (result.data !== void 0 && !result.error) return result.data;
+	const code = record(result.error) && record(result.error.error) && typeof result.error.error.code === "string" ? result.error.error.code : "request_failed";
+	throw new EventReceiverError(`Event request failed (${result.response?.status ?? 0}, ${code})`, code, result.response?.status ?? 0, retryAfter(result.response?.headers.get("retry-after") ?? null));
+}
+function delay(ms, signal) {
+	signal.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			clearTimeout(timer);
+			reject(signal.reason);
+		};
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", abort);
+			resolve();
+		}, Math.min(ms, 2147483647));
+		signal.addEventListener("abort", abort, { once: true });
+	});
+}
+async function eventRetry(operation, signal, onRetry) {
+	for (let attempt = 0;; attempt++) {
+		signal.throwIfAborted();
+		try {
+			return await operation();
+		} catch (error) {
+			signal.throwIfAborted();
+			if (error instanceof EventReceiverError && (!([
+				0,
+				408,
+				429
+			].includes(error.status) || error.status >= 500) || [
+				"invalid_response",
+				"unsupported",
+				"pull_unavailable",
+				"subscription_unavailable"
+			].includes(error.code))) throw error;
+			if (!(error instanceof EventReceiverError)) throw error;
+			onRetry?.();
+			await delay(Math.max(error instanceof EventReceiverError ? error.retryAfterMs : 0, Math.min(1e4, 250 * 2 ** Math.min(attempt, 6)) * (.8 + Math.random() * .4)), signal);
+		}
+	}
+}
+/** Shared by the SDK and CLI. Completion retries preserve the original evidence. */
+var EventConnection = class {
+	socket;
+	pending;
+	accountId;
+	touch;
+	constructor(client, endpointId, options = {}) {
+		this.client = client;
+		this.endpointId = endpointId;
+		this.options = options;
+	}
+	close() {
+		const socket = this.socket;
+		this.socket = void 0;
+		this.pending?.reject(new EventReceiverError("Event connection closed", "disconnected"));
+		this.pending = void 0;
+		socket?.close();
+	}
+	async open(signal) {
+		if (this.options.transport === "poll" || this.socket?.readyState === 1) return;
+		const account = unwrap(await getAccount({
+			client: this.client,
+			responseStyle: "fields",
+			throwOnError: false,
+			signal: AbortSignal.any([signal, AbortSignal.timeout(15e3)])
+		}));
+		if (!account.data?.id || this.accountId && account.data.id !== this.accountId) throw new EventReceiverError("The authenticated account changed; restart the receiver", "identity_changed", 403);
+		this.accountId = account.data.id;
+		const config = this.client.getConfig();
+		const auth = typeof config.auth === "function" ? await config.auth({
+			type: "http",
+			scheme: "bearer"
+		}) : config.auth;
+		const authorization = new Headers(config.headers).get("authorization");
+		const token = typeof auth === "string" ? auth.replace(/^Bearer /i, "") : authorization?.replace(/^Bearer /i, "");
+		if (!token) throw new EventReceiverError("Event receiver requires bearer credentials", "unauthorized", 401);
+		const url = new URL(`${config.baseUrl?.replace(/\/+$/, "")}/endpoints/${encodeURIComponent(this.endpointId)}/stream`);
+		if (url.protocol !== "https:" && !(url.protocol === "http:" && [
+			"localhost",
+			"127.0.0.1",
+			"[::1]"
+		].includes(url.hostname))) throw new EventReceiverError("Event connections require HTTPS (except loopback development)", "unsupported");
+		url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+		const socket = (this.options.webSocketFactory ?? ((address, protocol) => new WebSocket(address, protocol)))(url.href, "primitive.events.v1");
+		this.socket = socket;
+		socket.addEventListener("message", (message) => {
+			if (this.socket !== socket) return;
+			let frame;
+			try {
+				frame = JSON.parse(String(message.data));
+			} catch {
+				this.fail(new EventReceiverError("Invalid event frame", "invalid_response"));
+				return;
+			}
+			this.touch?.();
+			if (!record(frame)) {
+				this.fail(new EventReceiverError("Invalid event frame", "invalid_response"));
+				return;
+			}
+			if (frame.type === "ping") {
+				socket.send(JSON.stringify({ type: "pong" }));
+				return;
+			}
+			if (frame.type === "status") {
+				try {
+					this.options.onStatus?.(validateOffer(frame.data));
+				} catch (error) {
+					this.fail(error);
+				}
+				return;
+			}
+			if (frame.type === "error") {
+				this.fail(new EventReceiverError("Event stream request failed", typeof frame.code === "string" ? frame.code : "request_failed", typeof frame.status === "number" ? frame.status : 0, retryAfter(typeof frame.retry_after === "string" ? frame.retry_after : null)));
+				return;
+			}
+			this.pending?.resolve(frame);
+		});
+		socket.addEventListener("close", () => {
+			if (this.socket === socket) this.fail(new EventReceiverError("Event stream disconnected", "disconnected"));
+		});
+		socket.addEventListener("error", () => {
+			if (this.socket === socket) this.fail(new EventReceiverError("Event stream connection failed", "disconnected"));
+		});
+		const ready = await this.exchange(signal, void 0, () => {
+			socket.addEventListener("open", () => socket.send(JSON.stringify({
+				type: "authenticate",
+				token
+			})), { once: true });
+		}, 15e3);
+		if (!record(ready) || ready.type !== "ready" || ready.protocol !== "primitive.events.v1") {
+			this.close();
+			throw new EventReceiverError("Unsupported event stream protocol", "unsupported");
+		}
+	}
+	fail(error) {
+		this.pending?.reject(error);
+		this.pending = void 0;
+		this.close();
+	}
+	async exchange(signal, frame, start, timeoutMs = 6e4) {
+		signal.throwIfAborted();
+		if (this.pending) throw new EventReceiverError("Concurrent event operation", "busy", 409);
+		let cleanup = () => {};
+		try {
+			return await new Promise((resolve, reject) => {
+				const abort = () => {
+					reject(signal.reason);
+					this.close();
+				};
+				let timer;
+				this.touch = () => {
+					clearTimeout(timer);
+					timer = setTimeout(() => this.fail(new EventReceiverError("Event stream timed out", "disconnected")), timeoutMs);
+				};
+				this.touch();
+				cleanup = () => {
+					this.touch = void 0;
+					clearTimeout(timer);
+					signal.removeEventListener("abort", abort);
+					this.pending = void 0;
+				};
+				this.pending = {
+					resolve,
+					reject
+				};
+				signal.addEventListener("abort", abort, { once: true });
+				if (frame) this.socket?.send(JSON.stringify(frame));
+				start?.();
+			});
+		} finally {
+			cleanup();
+		}
+	}
+	async receive(signal) {
+		if (this.options.transport === "poll") return validateOffer(unwrap(await pullWebhookEvent({
+			client: this.client,
+			path: { id: this.endpointId },
+			body: { wait_seconds: 25 },
+			responseStyle: "fields",
+			throwOnError: false,
+			signal: AbortSignal.any([signal, AbortSignal.timeout(45e3)])
+		})).data);
+		await this.open(signal);
+		const frame = await this.exchange(signal, { type: "receive" }, void 0, 9e4);
+		if (!record(frame) || frame.type !== "event") throw new EventReceiverError("Invalid event frame", "invalid_response");
+		return validateOffer(frame.data);
+	}
+	async complete(body, signal) {
+		let receipt;
+		if (this.options.transport === "poll") receipt = unwrap(await completeWebhookEvent({
+			client: this.client,
+			path: { id: this.endpointId },
+			body,
+			responseStyle: "fields",
+			throwOnError: false,
+			signal: AbortSignal.any([signal, AbortSignal.timeout(15e3)])
+		})).data;
+		else {
+			await this.open(signal);
+			const frame = await this.exchange(signal, {
+				type: "complete",
+				body
+			}, void 0, 15e3);
+			if (!record(frame) || frame.type !== "receipt") throw new EventReceiverError("Invalid event receipt", "invalid_response");
+			receipt = frame.data;
+		}
+		if (!record(receipt) || !["completed", "already_completed"].includes(String(receipt.result))) throw new EventReceiverError("Invalid event receipt", "invalid_response");
+	}
+};
+//#endregion
+//#region src/api/events.ts
+var DeliveryExpired = class extends EventReceiverError {
+	constructor() {
+		super("Event acceptance deadline expired; the event may be delivered again", "delivery_expired", 409);
+	}
+};
+function validate(options) {
+	if (options.transport !== void 0 && options.transport !== "websocket" && options.transport !== "poll") throw new TypeError("transport must be websocket or poll");
+	if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(options.subscription)) throw new TypeError("subscription must be 1-64 letters, digits, underscores or hyphens, starting with a letter or digit");
+	if (options.events !== void 0 && (options.events.length === 0 || options.events.length > 50 || options.events.some((event) => typeof event !== "string" || !event.trim()))) throw new TypeError("events must contain 1-50 nonempty event names");
+	if (options.timeoutMs !== void 0 && (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0 || options.timeoutMs > 2147483647)) throw new TypeError("timeoutMs must be positive and at most 2147483647");
+}
+var EventsResource = class {
+	active = /* @__PURE__ */ new Set();
+	constructor(client) {
+		this.client = client;
+	}
+	reserve(options) {
+		validate(options);
+		options.signal?.throwIfAborted();
+		if (this.active.has(options.subscription)) throw new EventReceiverError("A receiver or unsettled delivery already uses this subscription on this client", "busy", 409);
+		this.active.add(options.subscription);
+		return () => {
+			this.active.delete(options.subscription);
+		};
+	}
+	async connect(options, signal) {
+		const config = this.client.getConfig();
+		const client = new PrimitiveApiClient({
+			...config,
+			headers: new Headers(config.headers),
+			apiBaseUrl: config.baseUrl
+		}).client;
+		let status = { type: "ready" };
+		const emit = (next) => {
+			status = {
+				...status,
+				...next
+			};
+			options.onStatus?.(status);
+		};
+		const retry = (operation, operationSignal = signal) => eventRetry(operation, operationSignal, () => emit({ type: "reconnecting" }));
+		const endpoint = (await retry(async () => unwrap(await createEndpoint({
+			client,
+			responseStyle: "fields",
+			throwOnError: false,
+			signal: AbortSignal.any([signal, AbortSignal.timeout(15e3)]),
+			body: {
+				kind: "pull",
+				name: options.subscription,
+				...options.events === void 0 ? {} : { rules: { event_types: [...new Set(options.events)] } }
+			}
+		})))).data;
+		if (!endpoint || endpoint.kind !== "pull" || endpoint.enabled === false) throw new EventReceiverError("Subscription is unavailable", "subscription_unavailable", 409);
+		if (!endpoint.receiver_capabilities?.completion_modes.includes("sdk") || options.transport !== "poll" && !endpoint.receiver_capabilities.stream_protocols.includes("primitive.events.v1")) throw new EventReceiverError("This API does not support SDK event receiving with the selected transport", "unsupported");
+		let gaps = -1;
+		const update = (data) => {
+			status = {
+				type: "ready",
+				backlog: data.backlog,
+				gapCount: data.gap_count,
+				lastGapReason: data.last_gap_reason
+			};
+			if (data.gap_count > 0 && data.gap_count !== gaps) {
+				gaps = data.gap_count;
+				emit({
+					...status,
+					type: "gap"
+				});
+				if (options.onGap === "error") throw new EventReceiverError("Subscription reports lost events", "event_gap", 409);
+			}
+		};
+		const connection = new EventConnection(client, endpoint.id, {
+			...options,
+			onStatus: update
+		});
+		try {
+			await retry(() => connection.open(signal));
+			emit(status);
+		} catch (error) {
+			connection.close();
+			throw error;
+		}
+		return {
+			connection,
+			emit,
+			retry,
+			update,
+			get status() {
+				return status;
+			}
+		};
+	}
+	async wait(options) {
+		const release = this.reserve(options);
+		const timeout = new AbortController();
+		const timeoutReason = new DOMException("Event wait timed out", "TimeoutError");
+		const timer = options.timeoutMs === void 0 ? void 0 : setTimeout(() => timeout.abort(timeoutReason), options.timeoutMs);
+		const signal = AbortSignal.any([timeout.signal, ...options.signal ? [options.signal] : []]);
+		let session;
+		let handedOff = false;
+		try {
+			session = await this.connect(options, signal);
+			const receiving = session;
+			while (true) {
+				const data = await receiving.retry(() => receiving.connection.receive(signal));
+				signal.throwIfAborted();
+				session.update(data);
+				if (!data.delivery) {
+					await delay(250, signal);
+					continue;
+				}
+				const selected = session;
+				const delivery = this.delivery(data.delivery, selected.connection, options.signal, () => {
+					selected.connection.close();
+					release();
+				});
+				handedOff = true;
+				return delivery;
+			}
+		} catch (error) {
+			if (timeout.signal.aborted && !options.signal?.aborted && error === timeoutReason) return null;
+			throw error;
+		} finally {
+			clearTimeout(timer);
+			if (!handedOff) {
+				session?.connection.close();
+				release();
+			}
+		}
+	}
+	async listen(handler, options) {
+		if (typeof handler !== "function") throw new TypeError("handler must be a function");
+		const release = this.reserve(options);
+		const stopping = new AbortController();
+		const signal = AbortSignal.any([stopping.signal, ...options.signal ? [options.signal] : []]);
+		let session;
+		try {
+			session = await this.connect(options, signal);
+		} catch (error) {
+			release();
+			throw error;
+		}
+		let ended = false;
+		let disposeDelivery = () => {};
+		const closed = (async () => {
+			try {
+				while (!signal.aborted) {
+					const offer = await session.retry(() => session.connection.receive(signal));
+					signal.throwIfAborted();
+					session.update(offer);
+					if (!offer.delivery) {
+						await delay(250, signal);
+						continue;
+					}
+					const delivery = this.delivery(offer.delivery, session.connection, options.signal, () => {});
+					disposeDelivery = delivery.dispose;
+					let removeAbort = () => {};
+					try {
+						await Promise.race([Promise.resolve().then(() => handler(delivery.event, { signal: delivery.signal })), new Promise((_, reject) => {
+							const aborted = () => reject(delivery.signal.reason);
+							delivery.signal.addEventListener("abort", aborted, { once: true });
+							removeAbort = () => delivery.signal.removeEventListener("abort", aborted);
+							if (delivery.signal.aborted) aborted();
+						})]);
+					} catch (error) {
+						if (delivery.signal.aborted) throw error;
+						session.emit({
+							type: "handler_error",
+							error
+						});
+						await delivery.retry();
+						continue;
+					} finally {
+						removeAbort();
+					}
+					await delivery.ack();
+				}
+			} catch (error) {
+				if (!signal.aborted) throw error;
+			} finally {
+				ended = true;
+				disposeDelivery();
+				session.connection.close();
+				release();
+				session.emit({ type: "closed" });
+			}
+		})();
+		closed.catch(() => {});
+		return {
+			closed,
+			get status() {
+				return ended ? { type: "closed" } : session.status;
+			},
+			close: async () => {
+				stopping.abort();
+				await closed;
+			}
+		};
+	}
+	delivery(raw, connection, callerSignal, release) {
+		callerSignal?.throwIfAborted();
+		const event = {
+			id: raw.event_id,
+			type: raw.event_type,
+			body: raw.body,
+			headers: raw.headers,
+			data: parseWebhookEvent(JSON.parse(raw.body), raw.event_type)
+		};
+		const started = performance.now();
+		const lifetime = new AbortController();
+		const signal = AbortSignal.any([lifetime.signal, ...callerSignal ? [callerSignal] : []]);
+		const remaining = Math.min(3e4, Date.parse(raw.lease_expires_at) - Date.now() - 5e3);
+		if (remaining <= 0) throw new DeliveryExpired();
+		let released = false;
+		let outcome;
+		let settled;
+		const cleanup = () => {
+			if (!released) {
+				released = true;
+				clearTimeout(timer);
+				signal.removeEventListener("abort", cleanup);
+				release();
+			}
+		};
+		const timer = setTimeout(() => lifetime.abort(new DeliveryExpired()), remaining);
+		signal.addEventListener("abort", cleanup, { once: true });
+		function complete(accepted) {
+			if (settled !== void 0) return outcome === accepted ? settled : Promise.reject(new EventReceiverError("Delivery outcome has already been chosen", "completion_conflict", 409));
+			if (signal.aborted) return Promise.reject(signal.reason);
+			outcome = accepted;
+			clearTimeout(timer);
+			const body = {
+				mode: "sdk",
+				accepted,
+				duration_ms: Math.min(3e4, Math.round(performance.now() - started)),
+				queue_id: raw.queue_id,
+				delivery_id: raw.delivery_id,
+				lease_token: raw.lease_token
+			};
+			const receiptSignal = AbortSignal.any([signal, AbortSignal.timeout(Math.min(6e4, Math.max(1, Date.parse(raw.lease_expires_at) - Date.now())))]);
+			settled = eventRetry(() => connection.complete(body, receiptSignal), receiptSignal).finally(cleanup);
+			return settled;
+		}
+		return {
+			event,
+			signal,
+			dispose: () => {
+				lifetime.abort();
+				cleanup();
+			},
+			ack: () => complete(true),
+			retry: () => complete(false)
+		};
+	}
+};
+//#endregion
 //#region src/api/verify-signature.ts
 /**
 * Workers-safe webhook signature verification.
@@ -3980,6 +4481,8 @@ var MemoriesResource = class {
 	}
 };
 var PrimitiveClient = class extends PrimitiveApiClient {
+	/** Receive durable events in this process, without a public URL. */
+	events = new EventsResource(this.client);
 	/** Agent-account lifecycle operations (create, claim/upgrade). */
 	agent = new AgentResource(this.client);
 	/** Inbound mail: long-poll stream + waitForNext over the forward tail. */
@@ -4303,4 +4806,4 @@ async function createAgent(options) {
 	};
 }
 //#endregion
-export { downloadEmailAttachmentPart as $, replayEmailWebhooks as $t, createOrgSecret as A, updateFunction as An, listFilters as At, deleteFilter as B, createClient as Bn, listSentEmails as Bt, createAgentClaimLink as C, testFunction as Cn, getWebhookSecret as Ct, createFilter as D, updateDomain as Dn, listDomains as Dt, createEndpoint as E, updateAccount as En, listDeliveries as Et, decideRegistryRequest as F, updateWakeSchedule as Fn, listPayoutAddresses as Ft, deleteRegistry as G, payChallenge as Gt, deleteFunctionSecret as H, listWakeAuthorizations as Ht, defineAgent as I, verifyAgentClaim as In, listRegistries as It, deleteWakeAuthorization as J, pullWebhookEvent as Jt, deleteRoute as K, pollCliLogin as Kt, deleteDomain as L, verifyAgentSignup as Ln, listRegistryAgents as Lt, createRoute as M, updateRoute as Mn, listFunctionSecrets as Mt, createWakeAuthorization as N, updateSpendPolicy as Nn, listFunctions as Nt, createFunction as O, updateEndpoint as On, listEmails as Ot, createWakeSchedule as P, updateWakeAuthorization as Pn, listOrgSecrets as Pt, downloadDomainZoneFile as Q, replayDelivery as Qt, deleteEmail as R, verifyCliSignup as Rn, listRegistryRequests as Rt, createAgentAccount as S, testEndpointRules as Sn, getWakeSchedule as St, createEmailChallenge as T, unsetFunctionRoute as Tn, listDeclinedPayments as Tt, deleteMemory as U, listWakeDispatches as Ut, deleteFunction as V, createConfig as Vn, listTemplates as Vt, deleteOrgSecret as W, listWakeSchedules as Wt, discardEmailContent as X, removeAgentConnection as Xt, deleteWakeSchedule as Y, registerPayoutAddress as Yt, downloadAttachments as Z, reorderRoutes as Zt, awaitReply as _, startAgentClaim as _n, getSpendPolicy as _t, PrimitiveClient as a, rotateWebhookSecret as an, getConversation as at, cliLogout as b, startCliSignup as bn, getTemplateInstall as bt, createPrimitiveClient as c, searchEmails as cn, getFunctionRouting as ct, isMemoryJsonValue as d, sendEmail as dn, getMemory as dt, replyToEmail as en, downloadRawEmail as et, DEFAULT_API_BASE_URL as f, setFunctionRoute as fn, getOrgRoutingTopology as ft, addDomain as g, simulateRoute as gn, getSentEmail as gt, createPrimitiveApiClient as h, setOrgSecret as hn, getSendPermissions as ht, MemoriesResource as i, resolveRegistryHandle as in, getChallenge as it, createRegistry as j, updateRegistry as jn, listFunctionLogs as jt, createFunctionSecret as k, updateFilter as kn, listEndpoints as kt, PRIMITIVE_SIGNATURE_HEADER as l, searchMemories as ln, getFunctionTestRunTrace as lt, PrimitiveApiError as m, setMemory as mn, getRegistry as mt, AgentResource as n, resendAgentSignupVerification as nn, getAccount as nt, client as o, runWakeSchedule as on, getEmail as ot, PrimitiveApiClient as p, setFunctionSecret as pn, getOutboundStatus as pt, deleteSentEmail as q, publishAgent as qt, InboxResource as r, resendCliSignupVerification as rn, getAgent as rt, createAgent as s, sdk_gen_exports as sn, getFunction as st, AccountResource as t, rescheduleSentEmail as tn, downloadSentAttachmentPart as tt, verifyWebhookSignature as u, semanticSearch as un, getInboxStatus as ut, cancelSentEmail as v, startAgentSignup as vn, getStorageStats as vt, createChallenge as w, unpublishAgent as wn, installTemplate as wt, completeWebhookEvent as x, testEndpoint as xn, getThread as xt, checkDomainDns as y, startCliLogin as yn, getTemplate as yt, deleteEndpoint as z, verifyDomain as zn, listRoutes as zt };
+export { deleteWakeSchedule as $, registerPayoutAddress as $t, createEndpoint as A, updateAccount as An, listDeliveries as At, defineAgent as B, verifyAgentClaim as Bn, listRegistries as Bt, checkDomainDns as C, startCliLogin as Cn, getTemplate as Ct, createAgentClaimLink as D, testFunction as Dn, getWebhookSecret as Dt, createAgentAccount as E, testEndpointRules as En, getWakeSchedule as Et, createRegistry as F, updateRegistry as Fn, listFunctionLogs as Ft, deleteFunction as G, createConfig as Gn, listTemplates as Gt, deleteEmail as H, verifyCliSignup as Hn, listRegistryRequests as Ht, createRoute as I, updateRoute as In, listFunctionSecrets as It, deleteOrgSecret as J, listWakeSchedules as Jt, deleteFunctionSecret as K, listWakeAuthorizations as Kt, createWakeAuthorization as L, updateSpendPolicy as Ln, listFunctions as Lt, createFunction as M, updateEndpoint as Mn, listEmails as Mt, createFunctionSecret as N, updateFilter as Nn, listEndpoints as Nt, createChallenge as O, unpublishAgent as On, installTemplate as Ot, createOrgSecret as P, updateFunction as Pn, listFilters as Pt, deleteWakeAuthorization as Q, pullWebhookEvent as Qt, createWakeSchedule as R, updateWakeAuthorization as Rn, listOrgSecrets as Rt, cancelSentEmail as S, startAgentSignup as Sn, getStorageStats as St, completeWebhookEvent as T, testEndpoint as Tn, getThread as Tt, deleteEndpoint as U, verifyDomain as Un, listRoutes as Ut, deleteDomain as V, verifyAgentSignup as Vn, listRegistryAgents as Vt, deleteFilter as W, createClient as Wn, listSentEmails as Wt, deleteRoute as X, pollCliLogin as Xt, deleteRegistry as Y, payChallenge as Yt, deleteSentEmail as Z, publishAgent as Zt, PrimitiveApiClient as _, setFunctionSecret as _n, getOutboundStatus as _t, PrimitiveClient as a, rescheduleSentEmail as an, downloadSentAttachmentPart as at, addDomain as b, simulateRoute as bn, getSentEmail as bt, createPrimitiveClient as c, resolveRegistryHandle as cn, getChallenge as ct, DeliveryExpired as d, sdk_gen_exports as dn, getFunction as dt, removeAgentConnection as en, discardEmailContent as et, EventsResource as f, searchEmails as fn, getFunctionRouting as ft, DEFAULT_API_BASE_URL as g, setFunctionRoute as gn, getOrgRoutingTopology as gt, isMemoryJsonValue as h, sendEmail as hn, getMemory as ht, MemoriesResource as i, replyToEmail as in, downloadRawEmail as it, createFilter as j, updateDomain as jn, listDomains as jt, createEmailChallenge as k, unsetFunctionRoute as kn, listDeclinedPayments as kt, PRIMITIVE_SIGNATURE_HEADER as l, rotateWebhookSecret as ln, getConversation as lt, EventReceiverError as m, semanticSearch as mn, getInboxStatus as mt, AgentResource as n, replayDelivery as nn, downloadDomainZoneFile as nt, client as o, resendAgentSignupVerification as on, getAccount as ot, EventConnection as p, searchMemories as pn, getFunctionTestRunTrace as pt, deleteMemory as q, listWakeDispatches as qt, InboxResource as r, replayEmailWebhooks as rn, downloadEmailAttachmentPart as rt, createAgent as s, resendCliSignupVerification as sn, getAgent as st, AccountResource as t, reorderRoutes as tn, downloadAttachments as tt, verifyWebhookSignature as u, runWakeSchedule as un, getEmail as ut, PrimitiveApiError as v, setMemory as vn, getRegistry as vt, cliLogout as w, startCliSignup as wn, getTemplateInstall as wt, awaitReply as x, startAgentClaim as xn, getSpendPolicy as xt, createPrimitiveApiClient as y, setOrgSecret as yn, getSendPermissions as yt, decideRegistryRequest as z, updateWakeSchedule as zn, listPayoutAddresses as zt };

package/dist/contract/index.d.ts

@@ -1,5 +1,5 @@
 import { A as RawContentInline, E as ParsedError, I as WebhookAttachment, T as ParsedDataFailed, d as EmailAuth, f as EmailReceivedEvent, k as RawContentDownloadOnly, l as EmailAddress, u as EmailAnalysis, w as ParsedDataComplete } from "../types-DcXtFARL.js";
-import { A as SignResult, M as signWebhookPayload, S as StandardWebhooksSignResult, _ as WEBHOOK_VERSION, w as signStandardWebhooksPayload } from "../index-JpXUV16f.js";
+import { A as SignResult, M as signWebhookPayload, S as StandardWebhooksSignResult, _ as WEBHOOK_VERSION, w as signStandardWebhooksPayload } from "../index-DCLGz6IH.js";
 
 //#region src/contract/contract.d.ts
 /** Maximum raw email size for inline inclusion (256 KB). */

package/dist/contract/index.js

@@ -1,4 +1,5 @@
-import { p as WEBHOOK_VERSION, v as signStandardWebhooksPayload, w as signWebhookPayload, z as validateEmailReceivedEvent } from "../webhook-CLVRgb-L.js";
+import { k as validateEmailReceivedEvent } from "../trust-DBOnyTHV.js";
+import { C as signWebhookPayload, _ as signStandardWebhooksPayload, f as WEBHOOK_VERSION } from "../webhook-B72YFapb.js";
 import { createHash } from "node:crypto";
 //#region src/contract/contract.ts
 /**

package/dist/{index-JpXUV16f.d.ts → index-DCLGz6IH.d.ts}

@@ -1395,42 +1395,10 @@ declare const emailReceivedEventJsonSchema: {
  */
 declare const WEBHOOK_VERSION = "2025-12-14";
 //#endregion
-//#region src/webhook/index.d.ts
-/**
- * Parse a webhook payload, returning typed events for known types
- * and UnknownEvent for future event types.
- *
- * This provides forward-compatibility: when Primitive adds new event types,
- * your code won't break - you'll receive an UnknownEvent that you can
- * handle or ignore.
- *
- * Known event types are validated against the canonical schema. Unknown
- * event types are returned as-is for forward compatibility.
- *
- * For most use cases, prefer `handleWebhook()` which also verifies the
- * signature before parsing the payload.
- *
- * @param input - The parsed JSON payload
- * @returns Typed event for known types, UnknownEvent for unknown types
- * @throws WebhookPayloadError if the input is not a valid webhook structure
- * @throws WebhookValidationError if a known event fails schema validation
- *
- * @example
- * ```typescript
- * import { parseWebhookEvent } from '@primitivedotdev/sdk';
- *
- * const event = parseWebhookEvent(JSON.parse(rawBody));
- *
- * if (event.event === "email.received") {
- *   // TypeScript knows this is EmailReceivedEvent
- *   console.log(event.email.headers.subject);
- * } else {
- *   // Handle or log unknown event types
- *   console.log("Unknown event:", event.event);
- * }
- * ```
- */
+//#region src/webhook/parse-event.d.ts
 declare function parseWebhookEvent(input: unknown, eventType?: string | null): WebhookEvent;
+//#endregion
+//#region src/webhook/index.d.ts
 /**
  * Request headers in any common format.
  *
@@ -1664,4 +1632,4 @@ declare function decodeRawEmail(event: EmailReceivedEvent, options?: DecodeRawEm
  */
 declare function verifyRawEmailDownload(downloaded: Buffer | ArrayBuffer | Uint8Array, event: EmailReceivedEvent): Buffer;
 //#endregion
-export { SignResult as A, validateEmailReceivedEvent as B, StandardWebhooksVerifyOptions as C, LEGACY_SIGNATURE_HEADER as D, LEGACY_CONFIRMED_HEADER as E, VerifyDownloadTokenOptions as F, VerifyDownloadTokenResult as I, generateDownloadToken as L, signWebhookPayload as M, verifyWebhookSignature as N, PRIMITIVE_CONFIRMED_HEADER as O, GenerateDownloadTokenOptions as P, verifyDownloadToken as R, StandardWebhooksSignResult as S, verifyStandardWebhooksSignature as T, WEBHOOK_VERSION as _, WebhookHeaders as a, STANDARD_WEBHOOK_SIGNATURE_HEADER as b, getDownloadTimeRemaining as c, handleWebhookEvent as d, isDownloadExpired as f, verifyRawEmailDownload as g, receive as h, WEBHOOK_EVENT_HEADER as i, VerifyOptions as j, PRIMITIVE_SIGNATURE_HEADER as k, getEventHeader as l, parseWebhookEvent as m, HandleWebhookOptions as n, confirmedHeaders as o, isRawIncluded as p, ReceiveRequestOptions as r, decodeRawEmail as s, DecodeRawEmailOptions as t, handleWebhook as u, emailReceivedEventJsonSchema as v, signStandardWebhooksPayload as w, STANDARD_WEBHOOK_TIMESTAMP_HEADER as x, STANDARD_WEBHOOK_ID_HEADER as y, safeValidateEmailReceivedEvent as z };
+export { SignResult as A, validateEmailReceivedEvent as B, StandardWebhooksVerifyOptions as C, LEGACY_SIGNATURE_HEADER as D, LEGACY_CONFIRMED_HEADER as E, VerifyDownloadTokenOptions as F, VerifyDownloadTokenResult as I, generateDownloadToken as L, signWebhookPayload as M, verifyWebhookSignature as N, PRIMITIVE_CONFIRMED_HEADER as O, GenerateDownloadTokenOptions as P, verifyDownloadToken as R, StandardWebhooksSignResult as S, verifyStandardWebhooksSignature as T, WEBHOOK_VERSION as _, WebhookHeaders as a, STANDARD_WEBHOOK_SIGNATURE_HEADER as b, getDownloadTimeRemaining as c, handleWebhookEvent as d, isDownloadExpired as f, parseWebhookEvent as g, verifyRawEmailDownload as h, WEBHOOK_EVENT_HEADER as i, VerifyOptions as j, PRIMITIVE_SIGNATURE_HEADER as k, getEventHeader as l, receive as m, HandleWebhookOptions as n, confirmedHeaders as o, isRawIncluded as p, ReceiveRequestOptions as r, decodeRawEmail as s, DecodeRawEmailOptions as t, handleWebhook as u, emailReceivedEventJsonSchema as v, signStandardWebhooksPayload as w, STANDARD_WEBHOOK_TIMESTAMP_HEADER as x, STANDARD_WEBHOOK_ID_HEADER as y, safeValidateEmailReceivedEvent as z };