@usebridger/transport-web 0.0.0-stage → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,709 @@
+import { a as CLOSE_TOO_BIG, c as DEFAULT_CONVERSATION, i as CLOSE_INVALID_AUTH, l as MAX_ATTACHMENTS, n as CLOSE_FORBIDDEN, o as CLOSE_UNAUTHORIZED, r as CLOSE_GOING_AWAY, s as CONVERSATION_PATTERN, t as AUTH_TIMEOUT_MS, u as MAX_FRAME_BYTES } from "./protocol-a9D3CajG.mjs";
+import { createRemoteJWKSet, jwtVerify } from "jose";
+import { randomBytes, randomUUID } from "node:crypto";
+import { UnsupportedError } from "@usebridger/core";
+import { TypedEmitter, assertCanSend, createMessage, groupActionCapability } from "@usebridger/core/adapter";
+//#region src/jwt.ts
+/** Lançado para qualquer token recusado; a mensagem é do `jose` ou do transport. */
+var InvalidTokenError = class extends Error {
+	name = "InvalidTokenError";
+};
+const SECRET_ALGORITHMS = ["HS256"];
+const JWKS_ALGORITHMS = ["RS256", "ES256"];
+/** Monta o verificador. Valida a config na hora: a fábrica a chama, e o erro vira `BotConfigError`. */
+function createVerifier(auth) {
+	let key;
+	let algorithms;
+	if (typeof auth.secret === "string") {
+		if (Buffer.byteLength(auth.secret) < 32) throw new TypeError("web: auth.secret precisa de pelo menos 32 bytes");
+		key = new TextEncoder().encode(auth.secret);
+		algorithms = SECRET_ALGORITHMS;
+	} else if (typeof auth.jwksUrl === "string") {
+		key = createRemoteJWKSet(new URL(auth.jwksUrl));
+		algorithms = JWKS_ALGORITHMS;
+	} else throw new TypeError("web: auth precisa de `secret` ou de `jwksUrl`");
+	const options = {
+		algorithms,
+		requiredClaims: ["exp", "sub"],
+		...auth.issuer === void 0 ? null : { issuer: auth.issuer },
+		...auth.audience === void 0 ? null : { audience: auth.audience }
+	};
+	return async (token) => {
+		let payload;
+		try {
+			({payload} = key instanceof Uint8Array ? await jwtVerify(token, key, options) : await jwtVerify(token, key, options));
+		} catch (error) {
+			throw new InvalidTokenError(error instanceof Error ? error.message : String(error), { cause: error });
+		}
+		if (typeof payload.sub !== "string" || payload.sub === "" || typeof payload.exp !== "number") throw new InvalidTokenError("token sem `sub` em texto ou sem `exp` numérico");
+		return {
+			sub: payload.sub,
+			expiresAt: payload.exp * 1e3,
+			claims: payload
+		};
+	};
+}
+/** Token do header `Authorization: Bearer <jwt>`, ou `null`. */
+function bearerToken(request) {
+	const header = request.headers.get("authorization");
+	return (header === null ? null : /^Bearer\s+(\S+)$/i.exec(header))?.[1] ?? null;
+}
+//#endregion
+//#region src/media-store.ts
+const MEDIA_TTL_MS = 36e5;
+var MediaStore = class {
+	#entries = /* @__PURE__ */ new Map();
+	#bytes = 0;
+	#now;
+	#maxBytes;
+	constructor(options = {}) {
+		this.#now = options.now ?? Date.now;
+		this.#maxBytes = options.maxBytes ?? 268435456;
+	}
+	/** Guarda e devolve um ID aleatório de 128 bits, que serve de URL de download. */
+	put(media) {
+		this.#prune();
+		const id = randomBytes(16).toString("base64url");
+		this.#entries.set(id, {
+			...media,
+			expiresAt: this.#now() + MEDIA_TTL_MS
+		});
+		this.#bytes += media.bytes.length;
+		for (const [oldest, entry] of this.#entries) {
+			if (this.#bytes <= this.#maxBytes || oldest === id) break;
+			this.#delete(oldest, entry);
+		}
+		return id;
+	}
+	/** O arquivo, se ainda vale. */
+	get(id) {
+		const entry = this.#entries.get(id);
+		if (entry === void 0) return void 0;
+		if (entry.expiresAt <= this.#now()) {
+			this.#delete(id, entry);
+			return;
+		}
+		return entry;
+	}
+	/**
+	* Tira os uploads de `owner` do mapa, todos ou nenhum: a mensagem passa a segurar os bytes, e o
+	* mesmo upload não entra em duas mensagens. `undefined` se algum não existe, venceu ou é de
+	* outro contato.
+	*/
+	takeAll(ids, owner) {
+		const now = this.#now();
+		const found = [];
+		for (const id of ids) {
+			const entry = this.#entries.get(id);
+			if (entry === void 0 || entry.owner !== owner || entry.expiresAt <= now) return void 0;
+			found.push(entry);
+		}
+		for (const [index, id] of ids.entries()) if (this.#entries.delete(id)) this.#bytes -= found[index].bytes.length;
+		return found;
+	}
+	clear() {
+		this.#entries.clear();
+		this.#bytes = 0;
+	}
+	get size() {
+		return this.#entries.size;
+	}
+	#prune() {
+		const now = this.#now();
+		for (const [id, entry] of this.#entries) {
+			if (entry.expiresAt > now) break;
+			this.#delete(id, entry);
+		}
+	}
+	#delete(id, entry) {
+		this.#entries.delete(id);
+		this.#bytes -= entry.bytes.length;
+	}
+};
+const OUTBOX_TTL_MS = 36e5;
+var Outbox = class {
+	#chats = /* @__PURE__ */ new Map();
+	#now;
+	constructor(now = Date.now) {
+		this.#now = now;
+	}
+	push(chatId, frame) {
+		const now = this.#now();
+		this.#prune(now);
+		const pending = this.#chats.get(chatId) ?? [];
+		this.#chats.delete(chatId);
+		pending.push({
+			frame,
+			expiresAt: now + OUTBOX_TTL_MS
+		});
+		if (pending.length > 100) pending.shift();
+		this.#chats.set(chatId, pending);
+	}
+	/** Tira e devolve o que ainda vale para a conversa, em ordem. */
+	drain(chatId) {
+		const pending = this.#chats.get(chatId);
+		if (pending === void 0) return [];
+		this.#chats.delete(chatId);
+		const now = this.#now();
+		return pending.filter((item) => item.expiresAt > now).map((item) => item.frame);
+	}
+	clear() {
+		this.#chats.clear();
+	}
+	get size() {
+		return this.#chats.size;
+	}
+	/** Solta as conversas cujo frame mais novo já venceu: todos os outros venceram antes. */
+	#prune(now) {
+		for (const [chatId, pending] of this.#chats) {
+			const newest = pending.at(-1);
+			if (newest !== void 0 && newest.expiresAt > now) break;
+			this.#chats.delete(chatId);
+		}
+	}
+};
+//#endregion
+//#region src/transport.ts
+const DEFAULT_MEDIA_MAX_BYTES = 10485760;
+const CAPABILITIES = [
+	"send.text",
+	"send.image",
+	"send.video",
+	"send.audio",
+	"send.document",
+	"media.download",
+	"actions",
+	"quoted",
+	"typing",
+	"message.edit",
+	"message.delete"
+];
+const SELF = {
+	id: "bot",
+	name: null,
+	phone: null,
+	isBot: true
+};
+/** Maior atraso que o `setTimeout` aceita; acima dele, o timer dispara na hora. */
+const MAX_TIMER_MS = 2 ** 31 - 1;
+/** Token recusado por falta do claim de tenant: válido, mas sem lugar neste transport. */
+var ForbiddenError = class extends Error {
+	name = "ForbiddenError";
+};
+var WebTransport = class {
+	name = "web";
+	capabilities = new Set(CAPABILITIES);
+	native = null;
+	#options;
+	#verify;
+	#routes;
+	#log;
+	#events;
+	#maxBytes;
+	#connections = /* @__PURE__ */ new Set();
+	/** Conexões autenticadas por conversa; várias abas na mesma conversa recebem os mesmos frames. */
+	#chats = /* @__PURE__ */ new Map();
+	#outbox = new Outbox();
+	#media = new MediaStore();
+	#connected = false;
+	#self = null;
+	constructor(options, verify, routes, log) {
+		this.#options = options;
+		this.#verify = verify;
+		this.#routes = routes;
+		this.#log = log;
+		this.#maxBytes = options.media?.maxBytes ?? 10485760;
+		this.#events = new TypedEmitter((error, event) => this.#log.error("handler de evento do transport falhou", {
+			err: error,
+			event
+		}));
+		routes.ws("/chat", (request) => this.#accept(request));
+		routes.route("POST", "/media", (request) => this.#upload(request));
+		routes.route("OPTIONS", "/media", (request) => this.#preflight(request));
+		routes.route("GET", "/media/:id", (request, { params }) => this.#download(request, params["id"] ?? ""));
+	}
+	get self() {
+		return this.#self;
+	}
+	async connect() {
+		this.#connected = true;
+		this.#self = SELF;
+		this.#events.emit("connection.status", { status: "open" });
+	}
+	async disconnect() {
+		this.#connected = false;
+		for (const connection of this.#connections) {
+			clearTimeout(connection.timer);
+			connection.closed = true;
+			connection.socket?.close(CLOSE_GOING_AWAY, "transport desconectado");
+		}
+		this.#connections.clear();
+		this.#chats.clear();
+		this.#outbox.clear();
+		this.#media.clear();
+	}
+	on(event, handler) {
+		return this.#events.on(event, handler);
+	}
+	async send(chatId, content, options) {
+		this.#assertConnected();
+		assertCanSend(this, content, options);
+		const frame = this.#messageFrame(content, options);
+		this.#deliver(chatId, frame);
+		return {
+			chatId,
+			id: frame.id,
+			fromMe: true,
+			senderId: null
+		};
+	}
+	async react() {
+		throw new UnsupportedError("reactions", this.name);
+	}
+	async edit(key, text, formatted) {
+		this.#assertConnected();
+		this.#deliver(key.chatId, {
+			type: "edit",
+			id: key.id,
+			text,
+			...formatted === void 0 ? null : { formatted }
+		});
+	}
+	async delete(key) {
+		this.#assertConnected();
+		this.#deliver(key.chatId, {
+			type: "delete",
+			id: key.id
+		});
+	}
+	async sendTyping(chatId, kind) {
+		this.#assertConnected();
+		for (const connection of this.#chats.get(chatId) ?? []) this.#write(connection, {
+			type: "typing",
+			kind
+		});
+	}
+	async getGroupMetadata() {
+		throw new UnsupportedError("groups", this.name);
+	}
+	async updateGroupParticipants(_groupId, _participantIds, action) {
+		throw new UnsupportedError(groupActionCapability(action), this.name);
+	}
+	#accept(request) {
+		if (!this.#connected) return new Response("transport desconectado", { status: 503 });
+		if (!this.#originAllowed(request)) return new Response("origem recusada", { status: 403 });
+		const connection = {
+			socket: null,
+			chat: null,
+			sender: null,
+			authenticating: false,
+			timer: void 0,
+			closed: false
+		};
+		return {
+			onOpen: (socket) => {
+				connection.socket = socket;
+				this.#connections.add(connection);
+				connection.timer = setTimeout(() => this.#close(connection, CLOSE_UNAUTHORIZED, "auth não chegou"), AUTH_TIMEOUT_MS);
+			},
+			onMessage: (_socket, data) => this.#onFrame(connection, data),
+			onClose: () => this.#forget(connection)
+		};
+	}
+	async #onFrame(connection, data) {
+		if (connection.closed) return;
+		if ((typeof data === "string" ? Buffer.byteLength(data) : data.byteLength) > 65536) {
+			this.#close(connection, CLOSE_TOO_BIG, "frame grande demais");
+			return;
+		}
+		const frame = typeof data === "string" ? parseJson(data) : void 0;
+		if (connection.chat === null) {
+			await this.#authenticate(connection, frame);
+			return;
+		}
+		if (!isRecord(frame)) {
+			this.#reject(connection, "invalid-frame", "frame não é um objeto JSON");
+			return;
+		}
+		if (frame["type"] === "message") this.#onMessage(connection, frame);
+		else if (frame["type"] === "action") this.#onAction(connection, frame);
+		else this.#reject(connection, "invalid-frame", "tipo de frame desconhecido");
+	}
+	async #authenticate(connection, frame) {
+		if (connection.authenticating || !isRecord(frame) || frame["type"] !== "auth") {
+			this.#close(connection, CLOSE_INVALID_AUTH, "o primeiro frame deve ser `auth`");
+			return;
+		}
+		const { token, conversation = DEFAULT_CONVERSATION } = frame;
+		if (typeof token !== "string" || typeof conversation !== "string" || !CONVERSATION_PATTERN.test(conversation)) {
+			this.#close(connection, CLOSE_INVALID_AUTH, "`auth` com token ou conversa inválidos");
+			return;
+		}
+		connection.authenticating = true;
+		let identity;
+		try {
+			identity = await this.#identify(token);
+		} catch (error) {
+			this.#refuse(connection, error);
+			return;
+		}
+		if (connection.closed) return;
+		const chatId = `${identity.contact.id}/${conversation}`;
+		connection.chat = {
+			id: chatId,
+			isGroup: false,
+			kind: "dm",
+			...identity.tenantId === void 0 ? null : { tenantId: identity.tenantId }
+		};
+		connection.sender = identity.contact;
+		connection.authenticating = false;
+		clearTimeout(connection.timer);
+		this.#expireAt(connection, identity.expiresAt);
+		let peers = this.#chats.get(chatId);
+		if (peers === void 0) {
+			peers = /* @__PURE__ */ new Set();
+			this.#chats.set(chatId, peers);
+		}
+		peers.add(connection);
+		this.#write(connection, {
+			type: "ready",
+			chatId,
+			userId: identity.contact.id
+		});
+		for (const pending of this.#outbox.drain(chatId)) this.#write(connection, pending);
+	}
+	#refuse(connection, error) {
+		if (error instanceof ForbiddenError) {
+			this.#log.debug("conexão recusada sem o claim de tenant", { reason: error.message });
+			this.#close(connection, CLOSE_FORBIDDEN, error.message);
+			return;
+		}
+		if (error instanceof InvalidTokenError) {
+			this.#log.debug("token recusado", { reason: error.message });
+			this.#close(connection, CLOSE_UNAUTHORIZED, "token inválido");
+			return;
+		}
+		this.#log.warn("não deu para verificar o token", { err: error });
+		this.#close(connection, CLOSE_UNAUTHORIZED, "não deu para verificar o token");
+	}
+	/** Fecha a conexão no `exp`; o cliente reconecta com um token novo (ADR 0077). */
+	#expireAt(connection, expiresAt) {
+		const remaining = expiresAt - Date.now();
+		if (remaining <= 0) {
+			this.#close(connection, CLOSE_UNAUTHORIZED, "token venceu");
+			return;
+		}
+		connection.timer = setTimeout(() => this.#expireAt(connection, expiresAt), Math.min(remaining, MAX_TIMER_MS));
+	}
+	#onMessage(connection, frame) {
+		const { ref, text, attachments = [] } = frame;
+		const chat = connection.chat;
+		const sender = connection.sender;
+		if (ref !== void 0 && (typeof ref !== "string" || ref.length > 128)) {
+			this.#reject(connection, "invalid-frame", "`ref` deve ser texto de até 128 caracteres");
+			return;
+		}
+		if (text !== void 0 && typeof text !== "string" || !Array.isArray(attachments) || attachments.length > 10 || !attachments.every((id) => typeof id === "string") || (text ?? "") === "" && attachments.length === 0) {
+			this.#reject(connection, "invalid-frame", `mensagem precisa de \`text\` ou de até 10 \`attachments\``, ref);
+			return;
+		}
+		const media = this.#media.takeAll(attachments, sender.id);
+		if (media === void 0) {
+			this.#reject(connection, "media-not-found", "anexo inexistente, vencido ou de outro usuário", ref);
+			return;
+		}
+		const id = randomUUID();
+		this.#write(connection, {
+			type: "ack",
+			ref: ref ?? null,
+			id
+		});
+		const base = {
+			id,
+			chat,
+			sender,
+			timestamp: Date.now(),
+			fromMe: false
+		};
+		const sources = media.map(toSource);
+		const first = sources[0];
+		const message = first === void 0 ? createMessage({
+			...base,
+			type: "text",
+			text
+		}) : createMessage({
+			...base,
+			...mediaType(first.mimetype, first.fileName),
+			text: text || null,
+			media: first,
+			attachments: sources
+		});
+		this.#events.emit("message", message);
+	}
+	#onAction(connection, frame) {
+		const { actionId } = frame;
+		if (typeof actionId !== "string" || actionId === "" || actionId.length > 64) {
+			this.#reject(connection, "invalid-frame", "`actionId` deve ser texto de até 64 caracteres");
+			return;
+		}
+		this.#events.emit("interaction", {
+			id: randomUUID(),
+			chat: connection.chat,
+			sender: connection.sender,
+			timestamp: Date.now(),
+			actionId
+		});
+	}
+	#forget(connection) {
+		clearTimeout(connection.timer);
+		connection.closed = true;
+		this.#connections.delete(connection);
+		const chatId = connection.chat?.id;
+		if (chatId === void 0) return;
+		const peers = this.#chats.get(chatId);
+		peers?.delete(connection);
+		if (peers?.size === 0) this.#chats.delete(chatId);
+	}
+	#close(connection, code, reason) {
+		if (connection.closed) return;
+		this.#forget(connection);
+		connection.socket?.close(code, reason);
+	}
+	#reject(connection, code, message, ref) {
+		this.#write(connection, {
+			type: "error",
+			code,
+			message,
+			...typeof ref === "string" ? { ref } : null
+		});
+	}
+	#write(connection, frame) {
+		connection.socket?.send(JSON.stringify(frame));
+	}
+	/** Para quem está na conversa, ou para o buffer se ninguém estiver. */
+	#deliver(chatId, frame) {
+		const peers = this.#chats.get(chatId);
+		if (peers === void 0) {
+			this.#outbox.push(chatId, frame);
+			return;
+		}
+		for (const connection of peers) this.#write(connection, frame);
+	}
+	#messageFrame(content, options) {
+		const common = {
+			type: "message",
+			id: randomUUID(),
+			timestamp: Date.now(),
+			...options?.quoted === void 0 ? null : { quotedId: options.quoted.id }
+		};
+		switch (content.type) {
+			case "text": return {
+				...common,
+				kind: "text",
+				text: content.text,
+				...content.formatted === void 0 ? null : { formatted: content.formatted },
+				...options?.actions === void 0 || options.actions.length === 0 ? null : { actions: options.actions.map(({ id, label }) => ({
+					id,
+					label
+				})) }
+			};
+			case "image":
+			case "video":
+			case "audio":
+			case "document": {
+				const caption = "caption" in content ? content.caption : void 0;
+				const formatted = "formattedCaption" in content ? content.formattedCaption : void 0;
+				return {
+					...common,
+					kind: content.type,
+					media: this.#mediaRef(content),
+					...caption === void 0 ? null : { text: caption },
+					...formatted === void 0 ? null : { formatted }
+				};
+			}
+			default: throw new UnsupportedError("send.album", this.name);
+		}
+	}
+	#mediaRef(content) {
+		const named = content.fileName === void 0 ? null : { fileName: content.fileName };
+		const mimetype = content.mimetype ?? "application/octet-stream";
+		if (!Buffer.isBuffer(content.media)) return {
+			url: content.media.url,
+			mimetype,
+			...named
+		};
+		const id = this.#media.put({
+			bytes: content.media,
+			mimetype,
+			...named
+		});
+		return {
+			url: `${this.#routes.basePath}/media/${id}`,
+			mimetype,
+			...named
+		};
+	}
+	async #upload(request) {
+		if (!this.#connected) return new Response("transport desconectado", { status: 503 });
+		const cors = this.#cors(request);
+		if (cors === null) return new Response("origem recusada", { status: 403 });
+		const token = bearerToken(request);
+		if (token === null) return text("falta o header Authorization: Bearer", 401, cors);
+		let identity;
+		try {
+			identity = await this.#identify(token);
+		} catch (error) {
+			if (error instanceof ForbiddenError) return text(error.message, 403, cors);
+			if (error instanceof InvalidTokenError) return text("token inválido", 401, cors);
+			this.#log.warn("não deu para verificar o token do upload", { err: error });
+			return text("não deu para verificar o token", 503, cors);
+		}
+		const mimetype = request.headers.get("content-type")?.split(";")[0]?.trim();
+		if (!mimetype) return text("falta o Content-Type", 415, cors);
+		if (Number(request.headers.get("content-length") ?? 0) > this.#maxBytes) return text("arquivo grande demais", 413, cors);
+		const bytes = await readLimited(request, this.#maxBytes);
+		if (bytes === null) return text("arquivo grande demais", 413, cors);
+		if (bytes.length === 0) return text("arquivo vazio", 400, cors);
+		const name = new URL(request.url).searchParams.get("name");
+		const id = this.#media.put({
+			bytes,
+			mimetype,
+			owner: identity.contact.id,
+			...name ? { fileName: name.slice(0, 255) } : null
+		});
+		return Response.json({ id }, {
+			status: 201,
+			headers: cors
+		});
+	}
+	#preflight(request) {
+		const cors = this.#cors(request);
+		if (cors === null) return new Response("origem recusada", { status: 403 });
+		return new Response(null, {
+			status: 204,
+			headers: {
+				...cors,
+				"access-control-allow-methods": "POST",
+				"access-control-allow-headers": "authorization, content-type",
+				"access-control-max-age": "600"
+			}
+		});
+	}
+	#download(request, id) {
+		const cors = this.#cors(request) ?? {};
+		const media = this.#media.get(id);
+		if (media === void 0 || media.owner !== void 0) return text("não encontrado", 404, cors);
+		const inline = /^(image|video|audio)\//.test(media.mimetype);
+		const name = media.fileName === void 0 ? "" : `; filename*=UTF-8''${encodeURIComponent(media.fileName)}`;
+		return new Response(media.bytes, { headers: {
+			...cors,
+			"content-type": media.mimetype,
+			"content-disposition": `${inline ? "inline" : "attachment"}${name}`,
+			"x-content-type-options": "nosniff",
+			"content-security-policy": "sandbox",
+			"cache-control": "private, max-age=3600"
+		} });
+	}
+	async #identify(token) {
+		const verified = await this.#verify(token);
+		const claim = this.#options.tenantClaim;
+		let tenantId;
+		if (claim !== void 0) {
+			const value = verified.claims[claim];
+			if (typeof value !== "string" && typeof value !== "number" || value === "") throw new ForbiddenError(`token sem o claim de tenant "${claim}"`);
+			tenantId = String(value);
+		}
+		const sub = encodeURIComponent(verified.sub);
+		const id = tenantId === void 0 ? sub : `${encodeURIComponent(tenantId)}:${sub}`;
+		const name = verified.claims["name"];
+		return {
+			contact: {
+				id,
+				name: typeof name === "string" ? name : null,
+				phone: null,
+				claims: verified.claims
+			},
+			...tenantId === void 0 ? null : { tenantId },
+			expiresAt: verified.expiresAt
+		};
+	}
+	#originAllowed(request) {
+		const origin = request.headers.get("origin");
+		return origin === null || this.#options.origins === void 0 || this.#options.origins.includes(origin);
+	}
+	/** Headers de CORS para a origem do pedido; `null` se ela não é aceita. */
+	#cors(request) {
+		if (!this.#originAllowed(request)) return null;
+		const origin = request.headers.get("origin");
+		if (origin === null) return {};
+		return this.#options.origins === void 0 ? { "access-control-allow-origin": "*" } : {
+			"access-control-allow-origin": origin,
+			vary: "Origin"
+		};
+	}
+	#assertConnected() {
+		if (!this.#connected) throw new Error("web: transport desconectado");
+	}
+};
+function parseJson(data) {
+	try {
+		return JSON.parse(data);
+	} catch {
+		return;
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(body, status, headers) {
+	return new Response(body, {
+		status,
+		headers
+	});
+}
+/** Corpo inteiro, ou `null` se passar de `max` (o `Content-Length` pode mentir ou faltar). */
+async function readLimited(request, max) {
+	if (request.body === null) return Buffer.alloc(0);
+	const chunks = [];
+	let total = 0;
+	for await (const chunk of request.body) {
+		total += chunk.byteLength;
+		if (total > max) return null;
+		chunks.push(chunk);
+	}
+	return Buffer.concat(chunks);
+}
+function toSource(media) {
+	return {
+		mimetype: media.mimetype,
+		size: media.bytes.length,
+		...media.fileName === void 0 ? null : { fileName: media.fileName },
+		download: async () => media.bytes
+	};
+}
+/** Tipo da mensagem pelo mimetype do primeiro anexo (ADR 0065). */
+function mediaType(mimetype, fileName) {
+	if (mimetype.startsWith("image/")) return { type: "image" };
+	if (mimetype.startsWith("video/")) return { type: "video" };
+	if (mimetype.startsWith("audio/")) return { type: "audio" };
+	return {
+		type: "document",
+		fileName: fileName ?? null
+	};
+}
+//#endregion
+//#region src/index.ts
+function web(options) {
+	const verify = createVerifier(options.auth);
+	const maxBytes = options.media?.maxBytes;
+	if (maxBytes !== void 0 && (!Number.isInteger(maxBytes) || maxBytes <= 0)) throw new RangeError(`web: media.maxBytes deve ser inteiro positivo; recebido ${maxBytes}`);
+	if (options.tenantClaim === "") throw new TypeError("web: tenantClaim vazio");
+	return (deps) => {
+		if (deps.http === void 0) throw new TypeError("web: o transport precisa de `http` no createBot (ver createHttp)");
+		return new WebTransport(options, verify, deps.http, deps.log);
+	};
+}
+//#endregion
+export { AUTH_TIMEOUT_MS, CLOSE_FORBIDDEN, CLOSE_GOING_AWAY, CLOSE_INVALID_AUTH, CLOSE_TOO_BIG, CLOSE_UNAUTHORIZED, CONVERSATION_PATTERN, DEFAULT_CONVERSATION, DEFAULT_MEDIA_MAX_BYTES, MAX_ATTACHMENTS, MAX_FRAME_BYTES, web };
+
+//# sourceMappingURL=index.mjs.map