better-supabase 0.5.0 → 0.6.0

package/dist/chat-sdk/index.js

@@ -0,0 +1,733 @@
+import { s as nowInstant } from "../temporal-BJGitm-h.js";
+import { n as rpcTransport, r as sqlTransport } from "../block-transport-BLr-ZgLc.js";
+import { C as run, O as textOf, _ as randomToken, c as errorText, d as isRecord, h as optionalText, i as blockCall, k as toInstant } from "../block-helpers-DWHxHsEQ.js";
+import { r as writeToStore } from "../tee-CoEppCER.js";
+import { BaseFormatConverter, Message, defaultEmojiResolver, parseMarkdown, stringifyMarkdown } from "chat";
+//#region src/chat-sdk/delivery.ts
+const STATUSES = {
+	accepted: "queued",
+	queued: "queued",
+	sending: "queued",
+	scheduled: "queued",
+	sent: "sent",
+	delivered: "delivered",
+	read: "read",
+	failed: "failed",
+	undelivered: "failed",
+	canceled: "failed"
+};
+const statusOf = (value) => typeof value === "string" ? STATUSES[value.toLowerCase()] : void 0;
+function json(body) {
+	try {
+		return JSON.parse(body);
+	} catch {
+		return;
+	}
+}
+const list = (value) => Array.isArray(value) ? value : [];
+/** WhatsApp Cloud API: `entry[].changes[].value.statuses[]`. */
+const whatsappDeliveries = ({ body }) => {
+	const payload = json(body);
+	if (!isRecord(payload) || payload["object"] !== "whatsapp_business_account") return null;
+	const updates = [];
+	let other = false;
+	for (const entry of list(payload["entry"])) for (const change of list(isRecord(entry) ? entry["changes"] : void 0)) {
+		const value = isRecord(change) ? change["value"] : void 0;
+		if (!isRecord(value)) continue;
+		if (list(value["messages"]).length > 0) other = true;
+		for (const item of list(value["statuses"])) {
+			if (!isRecord(item)) continue;
+			const status = statusOf(item["status"]);
+			const id = optionalText(item["id"]);
+			if (!status || id === void 0) continue;
+			const first = list(item["errors"])[0];
+			const error = isRecord(first) ? optionalText(first["title"]) ?? optionalText(first["message"]) : void 0;
+			updates.push({
+				externalId: id,
+				status,
+				...error === void 0 ? {} : { error }
+			});
+		}
+	}
+	return {
+		updates,
+		only: updates.length > 0 && !other
+	};
+};
+/** Messenger and Instagram: `entry[].messaging[].delivery.mids`. Read receipts carry no ids and are skipped. */
+const messengerDeliveries = ({ body }) => {
+	const payload = json(body);
+	if (!isRecord(payload) || payload["object"] !== "page" && payload["object"] !== "instagram") return null;
+	const events = list(payload["entry"]).flatMap((entry) => list(isRecord(entry) ? entry["messaging"] : void 0).filter(isRecord));
+	const receipts = events.filter((event) => isRecord(event["delivery"]) || isRecord(event["read"]));
+	return {
+		updates: receipts.flatMap((event) => {
+			const delivery = event["delivery"];
+			return isRecord(delivery) ? list(delivery["mids"]).flatMap((mid) => typeof mid === "string" ? [{
+				externalId: mid,
+				status: "delivered"
+			}] : []) : [];
+		}),
+		only: receipts.length > 0 && receipts.length === events.length
+	};
+};
+/** Twilio status callbacks: a form body with `MessageSid` and `MessageStatus` and no `Body`. */
+const twilioDeliveries = ({ body, headers }) => {
+	if (!(headers["content-type"] ?? "").includes("application/x-www-form-urlencoded")) return null;
+	const form = new URLSearchParams(body);
+	const id = form.get("MessageSid") ?? form.get("SmsSid");
+	const status = statusOf(form.get("MessageStatus") ?? form.get("SmsStatus"));
+	if (id === null || !status || form.has("Body")) return null;
+	const error = form.get("ErrorMessage") ?? form.get("ErrorCode");
+	return {
+		updates: [{
+			externalId: id,
+			status,
+			...error === null ? {} : { error }
+		}],
+		only: true
+	};
+};
+/** The parsers `inboundHandler` uses by default, keyed by adapter name. */
+const DELIVERY_PARSERS = {
+	whatsapp: whatsappDeliveries,
+	messenger: messengerDeliveries,
+	instagram: messengerDeliveries,
+	twilio: twilioDeliveries,
+	sms: twilioDeliveries
+};
+//#endregion
+//#region src/chat-sdk/channels.ts
+const APP$1 = { type: "app" };
+const ECHO_TTL_MS = 864e5;
+const echoKey = (adapter, id) => `better-supabase:inbox:echo:${adapter}:${id}`;
+/** A platform adapter built from the token the credential provider holds, so no secret sits in env. */
+async function channelAdapter(options) {
+	const token = await options.credentials.getToken(options.ref, { subject: options.subject ?? APP$1 }).orThrow();
+	return options.create(token);
+}
+const DROPPED_HEADERS = /* @__PURE__ */ new Set([
+	"cookie",
+	"authorization",
+	"x-forwarded-for"
+]);
+const defaultPassthrough = (request, body) => request.method === "GET" || body.includes("\"type\":\"url_verification\"");
+/**
+* A route handler that verifies a channel webhook, stores the raw event in
+* the inbox's `inbound_events` and answers 200 at once. `inboundHandler`
+* replays it into Chat SDK later, so a slow bot never makes the platform
+* retry.
+*/
+function webhook(options) {
+	const passthrough = options.passthrough ?? defaultPassthrough;
+	return async (request) => {
+		const body = await request.clone().text();
+		if (passthrough(request, body)) return options.passthroughHandler ? options.passthroughHandler(request) : new Response("not found", { status: 404 });
+		if (options.ref) {
+			const provider = options.credentials;
+			if (!provider?.verifyInbound) return new Response("the credential provider cannot verify inbound requests", { status: 500 });
+			const verified = await provider.verifyInbound(request, options.ref);
+			if (!verified.ok || !verified.data) return new Response("unauthorized", { status: 401 });
+		} else if (options.verify && !await options.verify(request, body)) return new Response("unauthorized", { status: 401 });
+		const headers = {};
+		request.headers.forEach((value, key) => {
+			if (!DROPPED_HEADERS.has(key)) headers[key] = value;
+		});
+		const externalId = options.externalId?.(body, request);
+		const stored = await options.inbox.inbound.store({
+			adapter: options.adapter,
+			body,
+			headers,
+			...externalId === void 0 ? {} : { externalId },
+			...options.inboxId === void 0 ? {} : { inboxId: options.inboxId },
+			...options.tenant === void 0 ? {} : { tenant: options.tenant }
+		});
+		if (!stored.ok) return new Response("could not store the event", { status: 503 });
+		options.after?.(stored.data);
+		return new Response("ok", { status: 200 });
+	};
+}
+/** Replays stored webhook events and mirrors channel messages into the inbox. */
+function inboundHandler(options) {
+	const { chat, inbox } = options;
+	const parsers = options.parsers ?? DELIVERY_PARSERS;
+	const baseUrl = options.baseUrl ?? "https://inbox.local";
+	const applyDeliveries = async (adapter, parsed) => {
+		for (const update of parsed.updates) await inbox.deliveries.setStatus({
+			channel: channelFor(adapter),
+			externalId: update.externalId,
+			status: update.status,
+			...update.error === void 0 ? {} : { error: update.error }
+		}).orThrow();
+	};
+	const process = async (event) => {
+		await inbox.inbound.setStatus(event.id, "processing").orThrow();
+		try {
+			const parsed = parsers[event.adapter]?.(event) ?? null;
+			if (parsed) await applyDeliveries(event.adapter, parsed);
+			if (parsed?.only) {
+				await inbox.inbound.setStatus(event.id, "processed").orThrow();
+				return;
+			}
+			const handle = chat.webhooks[event.adapter];
+			if (!handle) {
+				await inbox.inbound.setStatus(event.id, "ignored", `no adapter named ${event.adapter}`).orThrow();
+				return;
+			}
+			const tasks = [];
+			const response = await handle(new Request(`${baseUrl}/${encodeURIComponent(event.adapter)}`, {
+				method: "POST",
+				headers: event.headers,
+				body: event.body
+			}), { waitUntil: (task) => void tasks.push(task) });
+			await Promise.all(tasks);
+			if (response.status >= 400) throw new Error(`${event.adapter} answered ${String(response.status)}`);
+			await inbox.inbound.setStatus(event.id, "processed").orThrow();
+		} catch (error) {
+			await inbox.inbound.setStatus(event.id, "failed", errorText(error));
+			throw error;
+		}
+	};
+	const files = async (message, adapter, threadId) => {
+		const out = [];
+		for (const file of message.attachments) if (options.copyFile) {
+			const copied = await options.copyFile(file, {
+				adapter,
+				threadId
+			});
+			if (copied) out.push(copied);
+		} else if (file.url !== void 0) out.push({
+			url: file.url,
+			...file.name === void 0 ? {} : { name: file.name },
+			...file.mimeType === void 0 ? {} : { contentType: file.mimeType },
+			...file.size === void 0 ? {} : { size: file.size }
+		});
+		return out;
+	};
+	return {
+		process,
+		drain: async (drainOptions = {}) => {
+			const events = await inbox.inbound.pending({
+				limit: drainOptions.limit ?? 50,
+				...drainOptions.maxAttempts === void 0 ? {} : { maxAttempts: drainOptions.maxAttempts }
+			}).orThrow();
+			let processed = 0;
+			let failed = 0;
+			for (const event of events) try {
+				await process(event);
+				processed += 1;
+			} catch {
+				failed += 1;
+			}
+			return {
+				processed,
+				failed
+			};
+		},
+		mirror: async (thread, message) => {
+			const adapter = thread.adapter.name;
+			if (message.author.isMe || message.author.isBot === true) return null;
+			if (await chat.getState().get(echoKey(adapter, message.id)) !== null) return null;
+			const inboxId = options.inboxes[adapter];
+			if (inboxId === void 0) throw new Error(`inboundHandler: no inbox for adapter "${adapter}"`);
+			const attachments = await files(message, adapter, thread.id);
+			return inbox.inbound.record({
+				inboxId,
+				threadId: thread.id,
+				contact: {
+					externalId: message.author.userId,
+					name: message.author.fullName || message.author.userName,
+					...message.author.email === void 0 ? {} : { email: message.author.email }
+				},
+				message: {
+					body: message.text,
+					externalId: message.id,
+					...attachments.length > 0 ? { attachments } : {}
+				}
+			}).orThrow();
+		}
+	};
+}
+const CHANNELS = { twilio: "sms" };
+const channelFor = (adapter) => CHANNELS[adapter] ?? adapter;
+/** True while WhatsApp's customer service window is open: within 24 hours of the contact's last message. */
+async function whatsappWindowOpen(inbox, conversationId, now = nowInstant()) {
+	const last = (await inbox.messages.list(conversationId, { limit: 200 }).orThrow()).findLast((message) => message.direction === "inbound" && message.kind === "message");
+	return last !== void 0 && last.createdAt.add({ hours: 24 }).epochMilliseconds > now.epochMilliseconds;
+}
+/**
+* Posts a staff reply the `inbox` module queued on its channel, records
+* the delivery with the platform's message id, and remembers the id so
+* `mirror` skips the platform's echo. A failed post is recorded and thrown,
+* so the job retries.
+*/
+function deliver(options) {
+	const { chat, inbox } = options;
+	return async (job) => {
+		const message = await inbox.messages.get(job.message_id).orThrow();
+		if (message?.kind !== "message" || message.deletedAt !== null) return null;
+		const conversation = await inbox.conversations.get(message.conversationId).orThrow();
+		if (!conversation) return null;
+		const name = options.adapterFor?.(conversation) ?? (conversation.inbox?.channel === "sms" ? "twilio" : conversation.inbox?.channel);
+		const adapter = name === void 0 ? void 0 : chat.getAdapter(name);
+		if (!adapter || name === void 0) throw new Error(`deliver: no adapter for conversation ${conversation.id}`);
+		const channel = conversation.inbox?.channel ?? name;
+		try {
+			const template = await options.template?.({
+				conversation,
+				message,
+				adapter
+			});
+			const raw = await adapter.postMessage(conversation.threadId, template ?? (message.format === "markdown" ? { markdown: message.body } : message.body));
+			await chat.getState().set(echoKey(name, raw.id), true, ECHO_TTL_MS);
+			await inbox.deliveries.record({
+				messageId: message.id,
+				channel,
+				externalId: raw.id,
+				status: "sent"
+			}).orThrow();
+			return raw;
+		} catch (error) {
+			await inbox.deliveries.record({
+				messageId: message.id,
+				channel,
+				status: "failed",
+				error: errorText(error)
+			});
+			throw error;
+		}
+	};
+}
+/** The inbox's periodic work: wake snoozed conversations, replay and purge webhook events, sweep state. Run it from a cron job. */
+async function maintain(options) {
+	const woken = await options.inbox.wakeSnoozed().orThrow();
+	const replayed = options.handler ? await options.handler.drain() : {
+		processed: 0,
+		failed: 0
+	};
+	return {
+		woken,
+		purgedEvents: await options.inbox.inbound.purge({ olderThan: options.keepEvents ?? "7 days" }).orThrow(),
+		replayed,
+		purgedState: options.state ? await options.state.purge() : 0
+	};
+}
+//#endregion
+//#region src/chat-sdk/inbox-adapter.ts
+const PREFIX = "inbox:";
+var MarkdownConverter = class extends BaseFormatConverter {
+	fromAst(ast) {
+		return stringifyMarkdown(ast).trimEnd();
+	}
+	toAst(text) {
+		return parseMarkdown(text);
+	}
+};
+const converter = new MarkdownConverter();
+/** `inbox:<conversation id>` to the conversation id. */
+function conversationIdOf(threadId) {
+	if (!threadId.startsWith(PREFIX) || threadId.length === 6) throw new Error(`"${threadId}" is not an inbox thread id`);
+	return threadId.slice(6);
+}
+function bodyOf(message) {
+	if (typeof message === "string") return {
+		body: message,
+		format: "text"
+	};
+	if ("raw" in message) return {
+		body: message.raw,
+		format: "text"
+	};
+	if ("markdown" in message) return {
+		body: message.markdown,
+		format: "markdown"
+	};
+	return {
+		body: converter.renderPostable(message),
+		format: "markdown"
+	};
+}
+const emojiOf = (value) => typeof value === "string" ? value : defaultEmojiResolver.toGChat(value);
+function attachmentsOf(message) {
+	return message.attachments.flatMap((file) => {
+		const url = file.url;
+		if (url === void 0) return [];
+		return [{
+			type: file.contentType?.startsWith("image/") ? "image" : file.contentType?.startsWith("video/") ? "video" : file.contentType?.startsWith("audio/") ? "audio" : "file",
+			url,
+			...file.name === void 0 ? {} : { name: file.name },
+			...file.contentType === void 0 ? {} : { mimeType: file.contentType },
+			...file.size === void 0 ? {} : { size: file.size }
+		}];
+	});
+}
+async function* textOnly(source) {
+	for await (const chunk of source) if (typeof chunk === "string") yield chunk;
+	else if (chunk.type === "markdown_text") yield chunk.text;
+}
+/**
+* A Chat SDK adapter for the in-app inbox: the bot reads and writes the
+* `inbox` module's conversations, so one `Chat` instance answers the
+* widget and the other channels. Contact messages reach the bot as jobs
+* on the module's bot queue; pass them to `dispatch`.
+*/
+function inboxAdapter(options) {
+	const { inbox } = options;
+	const userName = options.userName ?? "bot";
+	let chat;
+	const parseMessage = (raw) => {
+		const isBot = raw.authorType === "bot" || raw.authorType === "system";
+		const userId = raw.authorType === "bot" ? userName : raw.authorId ?? raw.authorType;
+		const name = optionalText(raw.metadata["author_name"]) ?? (raw.authorType === "contact" ? "visitor" : userId);
+		return new Message({
+			id: raw.id,
+			threadId: `${PREFIX}${raw.conversationId}`,
+			text: raw.body,
+			formatted: raw.format === "markdown" ? parseMarkdown(raw.body) : {
+				type: "root",
+				children: [{
+					type: "paragraph",
+					children: [{
+						type: "text",
+						value: raw.body
+					}]
+				}]
+			},
+			raw,
+			author: {
+				userId,
+				userName: name,
+				fullName: name,
+				isBot,
+				isMe: raw.authorType === "bot",
+				...raw.authorType === "system" ? { isSystem: true } : {}
+			},
+			metadata: {
+				dateSent: new Date(raw.createdAt.epochMilliseconds),
+				edited: raw.editedAt !== null,
+				...raw.editedAt === null ? {} : { editedAt: new Date(raw.editedAt.epochMilliseconds) }
+			},
+			attachments: attachmentsOf(raw)
+		});
+	};
+	const rawOf = (message) => ({
+		id: message.id,
+		raw: message,
+		threadId: `${PREFIX}${message.conversationId}`
+	});
+	const post = async (threadId, body, format, metadata) => rawOf(await inbox.messages.send(conversationIdOf(threadId), {
+		body,
+		format,
+		authorType: "bot",
+		metadata: {
+			author_name: userName,
+			...metadata
+		}
+	}).orThrow());
+	const dispatch = async (job) => {
+		if (!chat) throw new Error("inboxAdapter: initialize() has not run");
+		const message = await inbox.messages.get(job.message_id).orThrow();
+		if (message?.conversationId !== job.conversation_id || message.authorType !== "contact" || message.kind !== "message") return;
+		await chat.processMessage(adapter, `${PREFIX}${message.conversationId}`, parseMessage(message));
+	};
+	const adapter = {
+		name: "inbox",
+		userName,
+		botUserId: userName,
+		lockScope: "thread",
+		initialize: (instance) => {
+			chat = instance;
+			return Promise.resolve();
+		},
+		encodeThreadId: (conversationId) => `${PREFIX}${conversationId}`,
+		decodeThreadId: conversationIdOf,
+		channelIdFromThreadId: () => "inbox",
+		isDM: () => true,
+		parseMessage,
+		renderFormatted: (content) => converter.fromAst(content),
+		dispatch,
+		handleWebhook: async (request) => {
+			if (!options.verify || !await options.verify(request)) return new Response("unauthorized", { status: 401 });
+			let job;
+			try {
+				job = await request.json();
+			} catch {
+				return new Response("invalid JSON", { status: 400 });
+			}
+			if (!isRecord(job) || typeof job["conversation_id"] !== "string" || typeof job["message_id"] !== "string") return new Response("expected conversation_id and message_id", { status: 400 });
+			await dispatch({
+				conversation_id: job["conversation_id"],
+				message_id: job["message_id"]
+			});
+			return new Response("ok", { status: 200 });
+		},
+		postMessage: (threadId, message) => {
+			const { body, format } = bodyOf(message);
+			return post(threadId, body, format);
+		},
+		editMessage: async (_threadId, messageId, message) => rawOf(await inbox.messages.edit(messageId, bodyOf(message).body).orThrow()),
+		deleteMessage: async (_threadId, messageId) => {
+			await inbox.messages.remove(messageId).orThrow();
+		},
+		addReaction: async (_threadId, messageId, value) => {
+			await inbox.messages.react(messageId, emojiOf(value), {
+				present: true,
+				actor: userName
+			}).orThrow();
+		},
+		removeReaction: async (_threadId, messageId, value) => {
+			await inbox.messages.react(messageId, emojiOf(value), {
+				present: false,
+				actor: userName
+			}).orThrow();
+		},
+		startTyping: async (threadId) => {
+			await inbox.conversations.typing(conversationIdOf(threadId), true, userName).orThrow();
+		},
+		endTyping: async (threadId) => {
+			await inbox.conversations.typing(conversationIdOf(threadId), false, userName).orThrow();
+		},
+		markAsRead: async (threadId) => {
+			await inbox.conversations.markRead(conversationIdOf(threadId)).orThrow();
+		},
+		fetchMessage: async (threadId, messageId) => {
+			const message = await inbox.messages.get(messageId).orThrow();
+			return message && message.conversationId === conversationIdOf(threadId) ? parseMessage(message) : null;
+		},
+		fetchMessages: async (threadId, fetchOptions = {}) => {
+			const limit = fetchOptions.limit ?? 50;
+			const before = fetchOptions.cursor === void 0 ? void 0 : toInstant(fetchOptions.cursor);
+			const page = await inbox.messages.list(conversationIdOf(threadId), {
+				limit,
+				...before === void 0 ? {} : { cursor: before }
+			}).orThrow();
+			const visible = page.filter((message) => message.kind === "message");
+			const oldest = page[0];
+			return {
+				messages: visible.map(parseMessage),
+				...oldest !== void 0 && page.length >= limit ? { nextCursor: oldest.createdAt.toString() } : {}
+			};
+		},
+		fetchThread: async (threadId) => {
+			const conversation = await inbox.conversations.get(conversationIdOf(threadId)).orThrow();
+			return {
+				id: threadId,
+				channelId: "inbox",
+				isDM: true,
+				metadata: conversation ? {
+					inboxId: conversation.inboxId,
+					contactId: conversation.contactId,
+					status: conversation.status,
+					botMode: conversation.botMode,
+					subject: conversation.subject
+				} : {}
+			};
+		},
+		stream: async (threadId, source, streamOptions) => {
+			const conversationId = conversationIdOf(threadId);
+			await inbox.conversations.typing(conversationId, true, userName);
+			let text = "";
+			const chunks = textOnly(source);
+			const store = options.streams;
+			const streamId = store ? `${PREFIX}${conversationId}:${randomToken(9)}` : void 0;
+			const readable = new ReadableStream({ async start(controller) {
+				for await (const chunk of chunks) {
+					if (streamOptions?.signal?.aborted) break;
+					text += chunk;
+					controller.enqueue(chunk);
+				}
+				controller.close();
+			} });
+			if (store && streamId) await writeToStore(store, streamId, readable);
+			else {
+				const reader = readable.getReader();
+				while (!(await reader.read()).done);
+			}
+			await inbox.conversations.typing(conversationId, false, userName);
+			if (text.trim().length === 0) return null;
+			return post(threadId, text, "markdown", streamId === void 0 ? void 0 : { stream_id: streamId });
+		}
+	};
+	return adapter;
+}
+//#endregion
+//#region src/chat-sdk/installations.ts
+function refOf(value) {
+	return isRecord(value) && typeof value["provider"] === "string" ? {
+		...value,
+		provider: value["provider"]
+	} : null;
+}
+function installationOf(value) {
+	if (!isRecord(value)) return null;
+	const metadata = value["metadata"];
+	const uninstalled = optionalText(value["uninstalled_at"]);
+	return {
+		id: textOf(value["id"]),
+		tenant: optionalText(value["tenant_id"]) ?? null,
+		adapter: textOf(value["adapter"]),
+		externalId: textOf(value["external_id"]),
+		credentialRef: refOf(value["credential_ref"]),
+		installedBy: optionalText(value["installed_by"]) ?? null,
+		metadata: isRecord(metadata) ? metadata : {},
+		installedAt: toInstant(textOf(value["installed_at"])),
+		uninstalledAt: uninstalled === void 0 ? null : toInstant(uninstalled)
+	};
+}
+const APP = { type: "app" };
+const sameRef = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+* The `chat_installations` registry with the credential lifecycle: every
+* ref an install drops is revoked through the `CredentialProvider`.
+*/
+function createChatInstallations(options) {
+	const call = blockCall(options.transport, options.schema ?? "better_supabase", options.mappers);
+	const revoke = async (ref) => {
+		if (ref) await options.credentials.revoke(ref, { subject: APP }).orThrow();
+	};
+	const list = (filter = {}) => call("list_chat_installations", {
+		tenant: filter.tenant,
+		adapter: filter.adapter,
+		include_uninstalled: filter.includeUninstalled
+	}, (value) => Array.isArray(value) ? value.flatMap((row) => {
+		const parsed = installationOf(row);
+		return parsed ? [parsed] : [];
+	}) : []);
+	const uninstall = (adapter, externalId) => call("chat_uninstall", {
+		adapter,
+		external_id: externalId
+	}, async (value) => {
+		if (!isRecord(value)) return false;
+		await revoke(refOf(value["previous_credential_ref"]));
+		return true;
+	});
+	return {
+		install: (input) => call("chat_install", {
+			adapter: input.adapter,
+			external_id: input.externalId,
+			tenant: input.tenant,
+			credential_ref: input.credentialRef,
+			installed_by: input.installedBy,
+			metadata: input.metadata
+		}, async (value) => {
+			const row = installationOf(value);
+			if (!row) throw new Error("chat_install returned no row");
+			const previous = isRecord(value) ? refOf(value["previous_credential_ref"]) : null;
+			if (!sameRef(previous, row.credentialRef)) await revoke(previous);
+			return row;
+		}),
+		uninstall,
+		uninstallTenant: (tenant) => run(async () => {
+			const rows = await list({ tenant }).orThrow();
+			let count = 0;
+			for (const row of rows) if (await uninstall(row.adapter, row.externalId).orThrow()) count += 1;
+			return count;
+		}),
+		get: (adapter, externalId) => call("chat_installation", {
+			adapter,
+			external_id: externalId
+		}, installationOf),
+		list
+	};
+}
+//#endregion
+//#region src/chat-sdk/state.ts
+const wrap = (value) => ({ v: value === void 0 ? null : value });
+const unwrap = (stored) => isRecord(stored) && "v" in stored ? stored["v"] : stored;
+function lockOf(value) {
+	if (!isRecord(value)) return null;
+	const expires = value["expires_at"];
+	return {
+		threadId: String(value["thread_id"]),
+		token: String(value["token"]),
+		expiresAt: typeof expires === "string" || expires instanceof Date ? new Date(expires).getTime() : Date.now()
+	};
+}
+const isSerializedMessage = (value) => isRecord(value) && value["_type"] === "chat:Message";
+function queueEntryOf(value) {
+	if (!isRecord(value)) return null;
+	const message = value["message"];
+	if (!isSerializedMessage(message)) return null;
+	return {
+		enqueuedAt: Number(value["enqueuedAt"]),
+		expiresAt: Number(value["expiresAt"]),
+		message: Message.fromJSON(message)
+	};
+}
+const ms = (value) => value === void 0 || value <= 0 ? void 0 : Math.ceil(value);
+/**
+* A Chat SDK `StateAdapter` on the `chat-sdk-state` SQL module: thread
+* subscriptions, locks, the cache, lists and the per-thread queue in
+* Postgres, so a bot needs no Redis. Service role only.
+*/
+function createSupabaseState(options) {
+	const prefix = options.keyPrefix ?? "chat-sdk";
+	const call = blockCall(options.transport, options.schema ?? "better_supabase", options.mappers);
+	const run = (fn, args, then) => call(fn, {
+		prefix,
+		...args
+	}, then).orThrow();
+	return {
+		keyPrefix: prefix,
+		connect: () => Promise.resolve(),
+		disconnect: () => Promise.resolve(),
+		subscribe: (threadId) => run("chat_state_subscribe", { thread_id: threadId }, () => void 0),
+		unsubscribe: (threadId) => run("chat_state_unsubscribe", { thread_id: threadId }, () => void 0),
+		isSubscribed: (threadId) => run("chat_state_is_subscribed", { thread_id: threadId }, (value) => value === true),
+		acquireLock: (threadId, ttlMs) => run("chat_state_acquire_lock", {
+			thread_id: threadId,
+			token: randomToken(),
+			ttl_ms: Math.max(1, Math.ceil(ttlMs))
+		}, lockOf),
+		extendLock: (lock, ttlMs) => run("chat_state_extend_lock", {
+			thread_id: lock.threadId,
+			token: lock.token,
+			ttl_ms: Math.max(1, Math.ceil(ttlMs))
+		}, (value) => value === true),
+		releaseLock: (lock) => run("chat_state_release_lock", {
+			thread_id: lock.threadId,
+			token: lock.token
+		}, () => void 0),
+		forceReleaseLock: (threadId) => run("chat_state_force_release_lock", { thread_id: threadId }, () => void 0),
+		get: (key) => run("chat_state_get", { key }, (value) => {
+			if (!isRecord(value)) return null;
+			return unwrap(value["value"]);
+		}),
+		set: (key, value, ttlMs) => run("chat_state_set", {
+			key,
+			value: wrap(value),
+			ttl_ms: ms(ttlMs)
+		}, () => void 0),
+		setIfNotExists: (key, value, ttlMs) => run("chat_state_set_if_not_exists", {
+			key,
+			value: wrap(value),
+			ttl_ms: ms(ttlMs)
+		}, (result) => result === true),
+		delete: (key) => run("chat_state_delete", { key }, () => void 0),
+		appendToList: (key, value, listOptions = {}) => run("chat_state_append_to_list", {
+			key,
+			value: wrap(value),
+			max_length: ms(listOptions.maxLength),
+			ttl_ms: ms(listOptions.ttlMs)
+		}, () => void 0),
+		getList: (key) => run("chat_state_get_list", { key }, (value) => {
+			if (!Array.isArray(value)) return [];
+			return value.map(unwrap);
+		}),
+		enqueue: (threadId, entry, maxSize) => run("chat_state_enqueue", {
+			thread_id: threadId,
+			entry: {
+				enqueuedAt: entry.enqueuedAt,
+				expiresAt: entry.expiresAt,
+				message: entry.message.toJSON()
+			},
+			expires_at: new Date(entry.expiresAt).toISOString(),
+			max_size: ms(maxSize)
+		}, Number),
+		dequeue: (threadId) => run("chat_state_dequeue", { thread_id: threadId }, queueEntryOf),
+		queueDepth: (threadId) => run("chat_state_queue_depth", { thread_id: threadId }, Number),
+		purge: (purgeOptions = {}) => call("purge_chat_state", { batch: purgeOptions.batch }, Number).orThrow()
+	};
+}
+//#endregion
+export { DELIVERY_PARSERS, channelAdapter, conversationIdOf, createChatInstallations, createSupabaseState, deliver, inboundHandler, inboxAdapter, maintain, messengerDeliveries, rpcTransport, sqlTransport, twilioDeliveries, webhook, whatsappDeliveries, whatsappWindowOpen };