whatsappd 0.1.0

package/dist/adapter-BES4PRA9.mjs

@@ -0,0 +1,1778 @@
+import pino from "pino";
+import makeWASocket, { Browsers, BufferJSON, DisconnectReason, downloadMediaMessage, fetchLatestBaileysVersion, getContentType, initAuthCreds, isJidGroup, makeCacheableSignalKeyStore, normalizeMessageContent, proto } from "baileys";
+import { Readable } from "node:stream";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+//#region src/errors.ts
+const DISPOSITION = {
+	restart_required: "retryable",
+	connection_lost: "retryable",
+	timed_out: "retryable",
+	service_unavailable: "retryable",
+	unknown: "retryable",
+	logged_out_remote: "logged_out",
+	connection_replaced: "logged_out",
+	pairing_rejected: "logged_out",
+	credentials_invalid: "suspended",
+	multidevice_mismatch: "suspended",
+	bad_session: "suspended",
+	intentional: "retryable"
+};
+/** Which sink this reason lands in. */
+function dispositionFor(reason) {
+	return DISPOSITION[reason];
+}
+/** Reconnect only what is genuinely retryable. No fix-by-retry. */
+function isRetryable(reason) {
+	if (reason === "intentional") return false;
+	return dispositionFor(reason) === "retryable";
+}
+/**
+* Classify a disconnect into a sanitized domain {@link WhatsAppFault}.
+*
+* @param error - The transport error that closed the connection, or a falsy
+* value for an intentional teardown. The raw payload is never surfaced on the
+* result — only its mapped status code.
+* @param intentional - `true` when the caller closed the connection on purpose;
+* such a close is never treated as a fault.
+* @returns The classified fault, including its {@link Disposition}.
+*/
+function classifyDisconnect(error, intentional) {
+	if (intentional) return {
+		reason: "intentional",
+		retryable: false,
+		disposition: "retryable"
+	};
+	const statusCode = error?.output?.statusCode;
+	const reason = reasonFromStatus(statusCode);
+	return {
+		reason,
+		statusCode,
+		retryable: isRetryable(reason),
+		disposition: dispositionFor(reason)
+	};
+}
+function reasonFromStatus(statusCode) {
+	switch (statusCode) {
+		case DisconnectReason.restartRequired: return "restart_required";
+		case DisconnectReason.connectionClosed:
+		case DisconnectReason.timedOut: return "connection_lost";
+		case DisconnectReason.unavailableService: return "service_unavailable";
+		case DisconnectReason.loggedOut: return "logged_out_remote";
+		case DisconnectReason.connectionReplaced: return "connection_replaced";
+		case DisconnectReason.forbidden: return "credentials_invalid";
+		case DisconnectReason.multideviceMismatch: return "multidevice_mismatch";
+		case DisconnectReason.badSession: return "bad_session";
+		default: return "unknown";
+	}
+}
+/**
+* A tagged error for the pairing flow. Carries only safe metadata (the reason
+* and an optional status code); the underlying error is logged, never attached.
+*/
+var PairingError = class extends Error {
+	_tag = "PairingError";
+	reason;
+	statusCode;
+	constructor(reason, statusCode) {
+		super(`PairingError(${reason}${statusCode ? `, ${statusCode}` : ""})`);
+		this.name = "PairingError";
+		this.reason = reason;
+		this.statusCode = statusCode;
+	}
+};
+/** Validate E.164 at the edge so bad input fails loudly before reaching Baileys. */
+function assertE164(input) {
+	if (!/^\+[1-9]\d{7,14}$/.test(input)) throw new PairingError("invalid_phone");
+	return input;
+}
+//#endregion
+//#region src/pacer.ts
+/**
+* Send pacing. WhatsApp can flag accounts that emit bursts of messages, so
+* outbound sends are funnelled through a FIFO queue that guarantees a minimum
+* gap between them. Serializing also gives a caller firing many sends
+* concurrently a predictable order rather than a thundering herd.
+*
+* Pure timing mechanism. A `minGapMs` of `0` or less disables the wait (each
+* call still chains in order).
+*/
+const delay$1 = (ms) => new Promise((r) => setTimeout(r, ms));
+function createPacer(minGapMs, now = Date.now) {
+	let last = -Infinity;
+	let tail = Promise.resolve();
+	return { run(fn) {
+		const result = tail.then(async () => {
+			const wait = minGapMs > 0 ? last + minGapMs - now() : 0;
+			if (wait > 0) await delay$1(wait);
+			last = now();
+			return fn();
+		});
+		tail = result.catch(() => {});
+		return result;
+	} };
+}
+//#endregion
+//#region src/machine.ts
+const initialState = { phase: "disconnected" };
+/** Exponential backoff with cap. Pure: caller supplies `now`. */
+function backoffDelay(attempt, ctx) {
+	const base = ctx.reconnectBaseMs ?? 1e3;
+	const max = ctx.reconnectMaxMs ?? 3e4;
+	return Math.min(max, base * 2 ** attempt);
+}
+/** Route a terminal/retry close into the next state. */
+function onClose(state, fault, ctx, now, attempt) {
+	if (fault.reason === "intentional") return { phase: "disconnected" };
+	switch (dispositionFor(fault.reason)) {
+		case "logged_out": return {
+			phase: "logged_out",
+			reason: fault.reason
+		};
+		case "suspended": return {
+			phase: "suspended",
+			reason: fault.reason
+		};
+		case "retryable": return enterBackoff(fault.reason, ctx, now, attempt);
+	}
+}
+function enterBackoff(reason, ctx, now, attempt) {
+	return {
+		phase: "backing_off",
+		reason,
+		retryAttempt: attempt,
+		nextRetryAt: now + backoffDelay(attempt, ctx)
+	};
+}
+/**
+* The reducer. Unhandled (state, input) pairs are no-ops — the machine simply
+* stays put, so out-of-order or duplicate inputs can never push it into an
+* invalid state.
+*/
+function transition(state, input, ctx, now) {
+	if (input.t === "stop") return state.phase === "logged_out" || state.phase === "suspended" ? state : { phase: "disconnected" };
+	if (input.t === "close") {
+		if (state.phase === "logged_out" || state.phase === "suspended") return state;
+		if (state.phase === "pairing" && state.pairing.step === "restart_pending") return dispositionFor(input.fault.reason) === "retryable" ? {
+			phase: "connecting",
+			retryAttempt: 0
+		} : onClose(state, input.fault, ctx, now, 0);
+		const attempt = state.phase === "connecting" ? state.retryAttempt ?? 0 : 0;
+		return onClose(state, input.fault, ctx, now, attempt);
+	}
+	switch (state.phase) {
+		case "disconnected":
+			if (input.t === "start") return {
+				phase: "connecting",
+				retryAttempt: 0
+			};
+			return state;
+		case "connecting":
+			if (input.t === "open") return {
+				phase: "authenticated",
+				sync: { step: "draining" }
+			};
+			if (input.t === "code_ready" && ctx.method === "pairing_code") return {
+				phase: "pairing",
+				pairing: {
+					step: "challenge_live",
+					method: "pairing_code",
+					code: input.code,
+					expiresAt: input.expiresAt
+				}
+			};
+			if (input.t === "ready") return ctx.method === "qr" ? {
+				phase: "pairing",
+				pairing: {
+					step: "challenge_live",
+					method: "qr",
+					qr: input.qr,
+					expiresAt: input.expiresAt
+				}
+			} : {
+				phase: "pairing",
+				pairing: { step: "awaiting_ready" }
+			};
+			return state;
+		case "pairing": {
+			const p = state.pairing;
+			if (input.t === "paired") return {
+				phase: "pairing",
+				pairing: { step: "restart_pending" }
+			};
+			if (p.step === "awaiting_ready") {
+				if (input.t === "code_ready") return {
+					phase: "pairing",
+					pairing: {
+						step: "challenge_live",
+						method: "pairing_code",
+						code: input.code,
+						expiresAt: input.expiresAt
+					}
+				};
+				return state;
+			}
+			if (p.step === "challenge_live") {
+				if (input.t === "pairing_rejected") return {
+					phase: "logged_out",
+					reason: "pairing_rejected"
+				};
+				if (input.t === "qr_refresh" && p.method === "qr") return {
+					phase: "pairing",
+					pairing: {
+						...p,
+						qr: input.qr,
+						expiresAt: input.expiresAt
+					}
+				};
+				return state;
+			}
+			if (input.t === "open") return {
+				phase: "authenticated",
+				sync: { step: "draining" }
+			};
+			return state;
+		}
+		case "authenticated": {
+			const s = state.sync;
+			if (input.t === "synced") return { phase: "online" };
+			if (s.step === "draining" && input.t === "pending_drained") return {
+				phase: "authenticated",
+				sync: { step: "syncing" }
+			};
+			if (input.t === "sync_progress") {
+				if (s.step === "syncing" && s.progress === input.progress) return state;
+				return {
+					phase: "authenticated",
+					sync: {
+						step: "syncing",
+						progress: input.progress
+					}
+				};
+			}
+			return state;
+		}
+		case "online": return state;
+		case "backing_off":
+			if (input.t === "retry_due") return {
+				phase: "connecting",
+				retryAttempt: state.retryAttempt + 1
+			};
+			return state;
+		case "logged_out":
+		case "suspended": return state;
+	}
+}
+//#endregion
+//#region src/model/status.ts
+/** True once a status is terminal (the `connection` stream ends here). */
+function isTerminal(status) {
+	return status.phase === "logged_out" || status.phase === "suspended";
+}
+/** True once the device is genuinely sendable. */
+function isOnline(status) {
+	return status.phase === "online";
+}
+//#endregion
+//#region src/baileys/authState.ts
+/**
+* Builds a Baileys auth state (creds + signal key store) backed by the opaque
+* `SessionStore` KV port. This is the ONLY place that knows both Baileys' auth
+* shapes AND how they serialize — so no Baileys type ever crosses the port. A
+* direct re-implementation of `useMultiFileAuthState` over `read/write` instead
+* of files; values are BufferJSON strings, keys are `"creds"` / `"type:id"`.
+*/
+const keyOf = (type, id) => `${type}:${id}`;
+async function loadAuth(store) {
+	const rawCreds = await store.read("creds");
+	const creds = rawCreds ? JSON.parse(rawCreds, BufferJSON.reviver) : initAuthCreds();
+	return {
+		creds,
+		keys: {
+			get: async (type, ids) => {
+				const out = {};
+				await Promise.all(ids.map(async (id) => {
+					const raw = await store.read(keyOf(type, id));
+					let value = raw ? JSON.parse(raw, BufferJSON.reviver) : null;
+					if (type === "app-state-sync-key" && value) value = proto.Message.AppStateSyncKeyData.fromObject(value);
+					out[id] = value;
+				}));
+				return out;
+			},
+			set: async (data) => {
+				const entries = {};
+				for (const type of Object.keys(data)) {
+					const bucket = data[type];
+					if (!bucket) continue;
+					for (const id of Object.keys(bucket)) {
+						const value = bucket[id];
+						entries[keyOf(type, id)] = value ? JSON.stringify(value, BufferJSON.replacer) : null;
+					}
+				}
+				await store.write(entries);
+			}
+		},
+		saveCreds: () => store.write({ creds: JSON.stringify(creds, BufferJSON.replacer) }),
+		registered: Boolean(creds.registered),
+		initialSyncComplete: Number(creds.accountSyncCounter ?? 0) > 0
+	};
+}
+//#endregion
+//#region src/baileys/contacts.ts
+function text$1(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function unique(values) {
+	const out = [];
+	for (const value of values) {
+		if (!value || out.includes(value)) continue;
+		out.push(value);
+	}
+	return out;
+}
+function mapContactUpdates(contacts, at = Date.now()) {
+	const out = [];
+	for (const contact of contacts) {
+		const nativeIds = unique([
+			text$1(contact.id),
+			text$1(contact.phoneNumber),
+			text$1(contact.lid)
+		]);
+		const id = nativeIds[0];
+		if (!id) continue;
+		out.push({
+			id,
+			nativeIds,
+			...text$1(contact.name) ? { displayName: text$1(contact.name) } : {},
+			...text$1(contact.notify) ? { profileName: text$1(contact.notify) } : {},
+			...text$1(contact.verifiedName) ? { verifiedName: text$1(contact.verifiedName) } : {},
+			...text$1(contact.username) ? { username: text$1(contact.username) } : {},
+			...contact.imgUrl !== void 0 ? { imgUrl: contact.imgUrl } : {},
+			...text$1(contact.status) ? { status: text$1(contact.status) } : {},
+			at
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/baileys/groups.ts
+const participantActions = /* @__PURE__ */ new Set([
+	"add",
+	"remove",
+	"promote",
+	"demote",
+	"modify"
+]);
+function text(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function roleOf(participant) {
+	const admin = text(participant.admin);
+	if (admin) return admin;
+	if (participant.isSuperAdmin) return "superadmin";
+	if (participant.isAdmin) return "admin";
+}
+function mapParticipant(participant) {
+	const id = text(participant.id);
+	if (!id) return void 0;
+	const role = roleOf(participant);
+	return {
+		id,
+		...role ? { role } : {}
+	};
+}
+function mapParticipants(participants) {
+	if (!participants) return void 0;
+	const out = [];
+	for (const participant of participants) {
+		const mapped = mapParticipant(participant);
+		if (mapped) out.push(mapped);
+	}
+	return out;
+}
+function isParticipantAction(value) {
+	return participantActions.has(value);
+}
+function mapGroupMetadataUpdates(groups, at = Date.now()) {
+	const out = [];
+	for (const group of groups) {
+		const id = text(group.id);
+		if (!id) continue;
+		const participants = mapParticipants(group.participants);
+		out.push({
+			kind: "metadata",
+			id,
+			...text(group.subject) ? { subject: text(group.subject) } : {},
+			...participants ? { participants } : {},
+			at
+		});
+	}
+	return out;
+}
+function mapGroupParticipantsUpdate(update, at = Date.now()) {
+	const id = text(update.id);
+	const action = text(update.action);
+	if (!id || !action || !isParticipantAction(action)) return void 0;
+	const participants = mapParticipants(update.participants) ?? [];
+	if (participants.length === 0) return void 0;
+	return {
+		kind: "participants",
+		id,
+		action,
+		participants,
+		at
+	};
+}
+//#endregion
+//#region src/baileys/download.ts
+/**
+* Media download-handle factory. Bytes never sit in the event stream — each
+* inbound media message carries a `download()` thunk that fetches and decrypts
+* on demand. The thunk closes over the live socket so expired media is
+* transparently re-uploaded via `updateMediaMessage` (the only way to recover a
+* stale `directPath`). This is the one impure piece; the inbound mapper stays
+* pure and just receives the factory.
+*/
+/** Given the live socket, produce a per-message download-thunk factory. */
+function mediaDownloader(sock, logger) {
+	return (raw) => () => downloadMediaMessage(raw, "buffer", {}, {
+		logger,
+		reuploadRequest: sock.updateMediaMessage
+	});
+}
+/** Default when no socket is wired (pure tests): the handle exists but won't fetch. */
+const noDownloader = (_raw) => {
+	return () => Promise.reject(/* @__PURE__ */ new Error("no downloader bound to this message"));
+};
+//#endregion
+//#region src/baileys/inbound.ts
+/**
+* WAMessage → InboundMessage. The ONLY file that reads the message proto.
+*
+* Detection follows Baileys exactly: `normalizeMessageContent` unwraps the
+* wrapper layers (viewOnce / ephemeral / edited / documentWithCaption), then
+* `getContentType` names the variant. We peel the wrappers ourselves first to
+* keep the flags, then map the inner content. Anything we don't model becomes
+* `unsupported` — a message is never dropped or thrown on.
+*/
+/** Long | number | null → number. */
+function num$1(v) {
+	if (v == null) return void 0;
+	return typeof v === "number" ? v : v.toNumber();
+}
+function toMillis(ts) {
+	const s = num$1(ts);
+	return s == null ? 0 : s * 1e3;
+}
+/** Peel the known wrapper layers, recording flags as we go. */
+function unwrapFlags(message) {
+	const flags = {};
+	let m = message;
+	for (let i = 0; m && i < 5; i++) if (m.ephemeralMessage) {
+		flags.ephemeral = true;
+		m = m.ephemeralMessage.message;
+	} else if (m.viewOnceMessage ?? m.viewOnceMessageV2 ?? m.viewOnceMessageV2Extension) {
+		flags.viewOnce = true;
+		m = (m.viewOnceMessage ?? m.viewOnceMessageV2 ?? m.viewOnceMessageV2Extension)?.message;
+	} else if (m.editedMessage) {
+		flags.edited = true;
+		m = m.editedMessage.message;
+	} else if (m.documentWithCaptionMessage) m = m.documentWithCaptionMessage.message;
+	else break;
+	return flags;
+}
+function context(content) {
+	const ci = content.imageMessage?.contextInfo ?? content.videoMessage?.contextInfo ?? content.audioMessage?.contextInfo ?? content.documentMessage?.contextInfo ?? content.stickerMessage?.contextInfo ?? content.extendedTextMessage?.contextInfo ?? content.locationMessage?.contextInfo ?? content.contactMessage?.contextInfo;
+	if (!ci) return void 0;
+	const quoted = ci.stanzaId ? {
+		id: ci.stanzaId,
+		from: ci.participant ?? ci.remoteJid ?? ""
+	} : void 0;
+	const mentions = ci.mentionedJid && ci.mentionedJid.length > 0 ? ci.mentionedJid : void 0;
+	if (!quoted && !mentions) return void 0;
+	return {
+		...quoted && { quoted },
+		...mentions && { mentions }
+	};
+}
+function media(m) {
+	return {
+		...m.mimetype != null && { mimetype: m.mimetype },
+		...num$1(m.fileLength) != null && { fileLength: num$1(m.fileLength) },
+		...m.fileName != null && { fileName: m.fileName },
+		...m.seconds != null && { seconds: m.seconds },
+		...m.ptt != null && { ptt: m.ptt },
+		...m.width != null && { width: m.width },
+		...m.height != null && { height: m.height },
+		...m.caption != null && { caption: m.caption }
+	};
+}
+/** Resolve the sender's addressing mode and alternate identity. */
+function addressing(raw) {
+	const key = raw.key;
+	const mode = key.addressingMode === "lid" ? "lid" : key.addressingMode === "pn" ? "pn" : void 0;
+	const alt = key.participantAlt || key.remoteJidAlt || void 0;
+	if (!mode && !alt) return void 0;
+	return {
+		mode: mode ?? "pn",
+		...alt && { alt }
+	};
+}
+function toInbound(raw, live, makeDownload = noDownloader) {
+	/** Attach the on-demand byte fetcher to the media metadata. */
+	const handle = (meta) => ({
+		...meta,
+		download: makeDownload(raw)
+	});
+	const chatId = raw.key.remoteJid;
+	const id = raw.key.id;
+	if (!chatId || !id) return void 0;
+	const flags = unwrapFlags(raw.message);
+	const content = normalizeMessageContent(raw.message);
+	if (!content) return void 0;
+	const kind = getContentType(content);
+	const base = {
+		id,
+		chatId,
+		from: raw.key.participant || chatId,
+		...raw.pushName && { pushName: raw.pushName },
+		fromMe: raw.key.fromMe ?? false,
+		timestamp: toMillis(raw.messageTimestamp),
+		live,
+		isGroup: isJidGroup(chatId) ?? false,
+		...context(content) && { context: context(content) },
+		...addressing(raw) && { addressing: addressing(raw) },
+		...Object.keys(flags).length > 0 && { flags }
+	};
+	switch (kind) {
+		case "conversation": return {
+			...base,
+			kind: "text",
+			text: content.conversation ?? ""
+		};
+		case "extendedTextMessage": return {
+			...base,
+			kind: "text",
+			text: content.extendedTextMessage?.text ?? ""
+		};
+		case "imageMessage": return {
+			...base,
+			kind: "image",
+			media: handle(media(content.imageMessage)),
+			...textOf(content.imageMessage?.caption)
+		};
+		case "videoMessage": return {
+			...base,
+			kind: "video",
+			media: handle(media(content.videoMessage)),
+			...textOf(content.videoMessage?.caption)
+		};
+		case "audioMessage": return {
+			...base,
+			kind: "audio",
+			media: handle(media(content.audioMessage))
+		};
+		case "documentMessage": return {
+			...base,
+			kind: "document",
+			media: handle(media(content.documentMessage)),
+			...textOf(content.documentMessage?.caption)
+		};
+		case "stickerMessage": return {
+			...base,
+			kind: "sticker",
+			media: handle(media(content.stickerMessage))
+		};
+		case "locationMessage": {
+			const l = content.locationMessage;
+			return {
+				...base,
+				kind: "location",
+				lat: l.degreesLatitude ?? 0,
+				lng: l.degreesLongitude ?? 0,
+				...l.name != null && { name: l.name },
+				...l.address != null && { address: l.address }
+			};
+		}
+		case "contactMessage": {
+			const c = content.contactMessage;
+			return {
+				...base,
+				kind: "contacts",
+				contacts: [{
+					...c.displayName != null && { name: c.displayName },
+					vcard: c.vcard ?? ""
+				}]
+			};
+		}
+		case "contactsArrayMessage": {
+			const arr = content.contactsArrayMessage?.contacts ?? [];
+			return {
+				...base,
+				kind: "contacts",
+				contacts: arr.map((c) => ({
+					...c.displayName != null && { name: c.displayName },
+					vcard: c.vcard ?? ""
+				}))
+			};
+		}
+		case "pollCreationMessage":
+		case "pollCreationMessageV2":
+		case "pollCreationMessageV3": {
+			const p = content[kind];
+			return {
+				...base,
+				kind: "poll",
+				name: p.name ?? "",
+				options: (p.options ?? []).map((o) => o.optionName ?? ""),
+				selectableCount: p.selectableOptionsCount ?? 0
+			};
+		}
+		default: return {
+			...base,
+			kind: "unsupported",
+			rawType: kind ?? "unknown"
+		};
+	}
+}
+const textOf = (caption) => caption != null && caption !== "" ? { text: caption } : {};
+//#endregion
+//#region src/baileys/history.ts
+function num(v) {
+	if (v == null) return void 0;
+	return typeof v === "number" ? v : v.toNumber();
+}
+function secondsToMillis(v) {
+	const seconds = num(v);
+	return seconds == null ? void 0 : seconds * 1e3;
+}
+function firstText(...values) {
+	return values.find((v) => typeof v === "string" && v.length > 0);
+}
+function toHistoryParticipants(participants) {
+	if (!participants) return void 0;
+	const out = [];
+	for (const participant of participants) {
+		if (!participant.id) continue;
+		out.push({
+			id: participant.id,
+			...participant.admin ? { role: participant.admin } : {}
+		});
+	}
+	return out.length > 0 ? out : void 0;
+}
+function toHistoryChat(chat) {
+	if (!chat.id) return void 0;
+	const subject = firstText(chat.name, chat.displayName);
+	const lastMessageAt = secondsToMillis(chat.lastMsgTimestamp ?? chat.lastMessageRecvTimestamp ?? chat.conversationTimestamp);
+	const participants = toHistoryParticipants(chat.participants);
+	return {
+		id: chat.id,
+		...subject && { subject },
+		isGroup: isJidGroup(chat.id) ?? false,
+		...lastMessageAt != null && { lastMessageAt },
+		...participants ? { participants } : {}
+	};
+}
+function toHistoryContact(contact) {
+	if (!contact.id) return void 0;
+	const displayName = firstText(contact.name, contact.notify, contact.verifiedName, contact.username);
+	return {
+		id: contact.id,
+		...displayName && { displayName }
+	};
+}
+function toConversationSyncBatch(payload, makeDownload = noDownloader) {
+	return {
+		chats: payload.chats.flatMap((chat) => {
+			const mapped = toHistoryChat(chat);
+			return mapped ? [mapped] : [];
+		}),
+		contacts: payload.contacts.flatMap((contact) => {
+			const mapped = toHistoryContact(contact);
+			return mapped ? [mapped] : [];
+		}),
+		messages: toConversationSyncMessages(payload.messages, makeDownload)
+	};
+}
+function toConversationSyncMessages(messages, makeDownload = noDownloader) {
+	return messages.flatMap((raw) => {
+		const msg = toInbound(raw, false, makeDownload);
+		return msg ? [msg] : [];
+	});
+}
+//#endregion
+//#region src/baileys/outbound.ts
+/**
+* Outbound → Baileys. The pure mirror of `inbound.ts`: our `Outbound` union →
+* `AnyMessageContent`, and `SendOptions` → `MiscMessageGenerationOptions`. The
+* Baileys types stay sealed in this dir. Quoting needs the original `WAMessage`,
+* which the surface must never see — so the caller passes a `MessageRef` and a
+* `resolveQuoted` lookup (the socket's recent-message LRU) turns it back into a
+* `WAMessage` inside this wall.
+*/
+const VOICE_NOTE_MIME = "audio/ogg; codecs=opus";
+/** BinaryInput → WAMediaUpload (Buffer | {url} | {stream}). */
+function upload(b) {
+	if (Buffer.isBuffer(b)) return b;
+	if ("url" in b) return { url: b.url };
+	return { stream: Readable.from(b.stream) };
+}
+/** MessageRef → WAMessageKey — plain reconstruction, no proto needed. */
+function refToKey(ref) {
+	return {
+		remoteJid: ref.chatId,
+		id: ref.id,
+		fromMe: ref.fromMe,
+		...ref.participant && { participant: ref.participant }
+	};
+}
+/** WAMessageKey → MessageRef — what `send` returns so the caller can edit/delete/react it. */
+function keyToRef(key) {
+	return {
+		id: key.id ?? "",
+		chatId: key.remoteJid ?? "",
+		fromMe: key.fromMe ?? true,
+		...key.participant && { participant: key.participant }
+	};
+}
+/** Our union → Baileys content. Pure. */
+function toContent(out) {
+	if ("text" in out) return { text: out.text };
+	if ("image" in out) return {
+		image: upload(out.image),
+		...out.caption && { caption: out.caption }
+	};
+	if ("video" in out) return {
+		video: upload(out.video),
+		...out.caption && { caption: out.caption },
+		...out.gifPlayback && { gifPlayback: true }
+	};
+	if ("audio" in out) return {
+		audio: upload(out.audio),
+		...out.ptt && { ptt: true },
+		...out.seconds != null && { seconds: out.seconds },
+		mimetype: out.mimetype ?? (out.ptt ? VOICE_NOTE_MIME : "audio/mp4")
+	};
+	if ("document" in out) return {
+		document: upload(out.document),
+		fileName: out.fileName,
+		mimetype: out.mimetype,
+		...out.caption && { caption: out.caption }
+	};
+	if ("sticker" in out) return { sticker: upload(out.sticker) };
+	if ("location" in out) return { location: {
+		degreesLatitude: out.location.lat,
+		degreesLongitude: out.location.lng,
+		...out.location.name && { name: out.location.name },
+		...out.location.address && { address: out.location.address }
+	} };
+	if ("contacts" in out) return { contacts: {
+		...out.contacts.displayName && { displayName: out.contacts.displayName },
+		contacts: out.contacts.vcards.map((vcard) => ({ vcard }))
+	} };
+	if ("react" in out) return { react: {
+		text: out.react.emoji,
+		key: refToKey(out.react.to)
+	} };
+	if ("edit" in out) return {
+		text: out.edit.text,
+		edit: refToKey(out.edit.target)
+	};
+	return { delete: refToKey(out.delete) };
+}
+/** SendOptions → Baileys generation options; resolves a quote via the LRU. */
+function toOptions(opts, resolveQuoted) {
+	if (!opts) return {};
+	const quoted = opts.quote ? resolveQuoted(opts.quote) : void 0;
+	return {
+		...quoted && { quoted },
+		...opts.mentions && opts.mentions.length > 0 && { mentions: [...opts.mentions] }
+	};
+}
+//#endregion
+//#region src/baileys/updates.ts
+/**
+* Update protos → `Update`. The companion to the inbound mapper, for the
+* updates stream. Three socket events feed it (all confined here):
+*
+*   - `messages.update`        — multiplexed: per-message status (receipt),
+*                                 plus edits and revokes (both arrive rewritten
+*                                 into this event).
+*   - `message-receipt.update` — per-participant receipts (the group case).
+*   - `messages.reaction`      — a reaction added or cleared.
+*
+* All pure: proto in, `Update` out. Edits reuse the inbound mapper so the new
+* content lands in the exact same shape as anything on the inbound stream.
+*/
+const Status = proto.WebMessageInfo.Status;
+/** Long | number | null → ms epoch (receipts are in seconds). */
+function secsToMs(v) {
+	if (v == null) return void 0;
+	return (typeof v === "number" ? v : v.toNumber()) * 1e3;
+}
+/** WebMessageInfo.Status enum → our ladder. SERVER_ACK is "sent to server". */
+function statusOf(s) {
+	switch (s) {
+		case Status.ERROR: return "error";
+		case Status.PENDING: return "pending";
+		case Status.SERVER_ACK: return "server_ack";
+		case Status.DELIVERY_ACK: return "delivered";
+		case Status.READ: return "read";
+		case Status.PLAYED: return "played";
+		default: return;
+	}
+}
+/**
+* Map one `messages.update`. It carries three distinct things; we discriminate:
+*   revoke  → update.messageStubType === REVOKE (Baileys nulls the message)
+*   edit    → update.message.editedMessage present (the rewritten content)
+*   receipt → update.status is a known Status
+* Returns undefined for updates we don't model (e.g. starred, label changes).
+*/
+function mapMessageUpdate(u, makeDownload = noDownloader) {
+	const ref = keyToRef(u.key);
+	const up = u.update;
+	if (up.messageStubType === proto.WebMessageInfo.StubType.REVOKE) {
+		const by = up.key?.participant ?? up.key?.remoteJid ?? void 0;
+		return {
+			kind: "revoke",
+			ref,
+			...by != null && { by }
+		};
+	}
+	const edited = up.message?.editedMessage?.message;
+	if (edited) {
+		const message = toInbound({
+			key: u.key,
+			message: edited,
+			messageTimestamp: up.messageTimestamp ?? void 0
+		}, true, makeDownload);
+		if (!message) return void 0;
+		return {
+			kind: "edit",
+			ref,
+			message
+		};
+	}
+	const status = statusOf(up.status);
+	if (status) return {
+		kind: "receipt",
+		ref,
+		status
+	};
+}
+/** Map a per-participant receipt (`message-receipt.update`, the group case). */
+function mapReceiptUpdate(r) {
+	const ref = keyToRef(r.key);
+	const rc = r.receipt;
+	const at = secsToMs(rc.playedTimestamp) ?? secsToMs(rc.readTimestamp) ?? secsToMs(rc.receiptTimestamp);
+	const status = rc.playedTimestamp ? "played" : rc.readTimestamp ? "read" : "delivered";
+	const by = rc.userJid ?? void 0;
+	return {
+		kind: "receipt",
+		ref,
+		status,
+		...by != null && { by },
+		...at != null && { at }
+	};
+}
+/** Map a reaction (`messages.reaction`). Falsey `text` means it was cleared. */
+function mapReaction(r) {
+	const ref = keyToRef(r.key);
+	const emoji = r.reaction.text || void 0;
+	const by = r.reaction.key?.participant ?? r.reaction.key?.remoteJid ?? void 0;
+	const ms = r.reaction.senderTimestampMs;
+	const at = ms == null ? void 0 : typeof ms === "number" ? ms : ms.toNumber();
+	return {
+		kind: "reaction",
+		ref,
+		removed: !emoji,
+		...emoji != null && { emoji },
+		...by != null && { by },
+		...at != null && { at }
+	};
+}
+//#endregion
+//#region src/baileys/presence.ts
+function kindOf(value) {
+	switch (value) {
+		case "composing": return "typing";
+		case "recording": return "recording";
+		case "available": return "available";
+		case "paused": return "idle";
+		case "unavailable": return "unavailable";
+		default: return;
+	}
+}
+function mapPresenceUpdate(update, at = Date.now()) {
+	const chatId = update.id ?? void 0;
+	if (!chatId || !update.presences) return [];
+	const out = [];
+	for (const [participant, presence] of Object.entries(update.presences)) {
+		const kind = kindOf(presence?.lastKnownPresence);
+		if (!kind) continue;
+		out.push({
+			chatId,
+			participant,
+			kind,
+			at
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/baileys/socket.ts
+/**
+* The single protocol-facing layer. Wraps the WhatsApp socket and turns the raw
+* protocol into a typed `RawEvent` stream plus a few imperative verbs. Socket
+* library types never escape this directory — that boundary is what keeps the
+* rest of the codebase protocol-free. The session orchestrator consumes
+* `RawEvent` and makes all decisions.
+*/
+/** How many recent raw messages to retain for quote resolution. */
+const RECENT_CAP = 500;
+/** Track recent raw messages in an LRU Map for quote/reply resolution. */
+function rememberRecent(recent, messages) {
+	for (const m of messages) if (m.key.id) {
+		recent.set(m.key.id, m);
+		if (recent.size > RECENT_CAP) recent.delete(recent.keys().next().value);
+	}
+}
+function toMessagesUpsertEvents(payload, makeDownload = noDownloader) {
+	if (payload.type !== "notify") {
+		const sync = toConversationSyncBatch({
+			chats: [],
+			contacts: [],
+			messages: payload.messages
+		}, makeDownload);
+		return sync.messages.length > 0 ? [{
+			t: "conversation_sync",
+			sync
+		}] : [];
+	}
+	return payload.messages.flatMap((raw) => {
+		const msg = toInbound(raw, true, makeDownload);
+		return msg ? [{
+			t: "message",
+			msg
+		}] : [];
+	});
+}
+function toMessagingHistoryEvents(payload, makeDownload = noDownloader) {
+	const events = [];
+	const complete = payload.progress === 100;
+	if (!complete && typeof payload.progress === "number" && Number.isFinite(payload.progress)) events.push({
+		t: "conversation_sync_progress",
+		progress: payload.progress
+	});
+	const sync = toConversationSyncBatch(payload, makeDownload);
+	if (sync.chats.length > 0 || sync.contacts.length > 0 || sync.messages.length > 0) events.push({
+		t: "conversation_sync",
+		sync
+	});
+	if (complete) events.push({ t: "conversation_sync_complete" });
+	return events;
+}
+function toMessagingHistoryStatusEvents(payload) {
+	if (payload.syncType === proto.HistorySync.HistorySyncType.RECENT && (payload.status === "complete" || payload.status === "paused")) return [{ t: "conversation_sync_complete" }];
+	return [];
+}
+function historySetTelemetry(payload) {
+	const chatsWithInlineMessage = payload.chats.filter((chat) => (chat.messages?.length ?? 0) > 0).length;
+	return {
+		syncType: payload.syncType ?? null,
+		chunkOrder: payload.chunkOrder ?? null,
+		progress: payload.progress ?? null,
+		isLatest: payload.isLatest ?? null,
+		chats: payload.chats.length,
+		contacts: payload.contacts.length,
+		messages: payload.messages.length,
+		chatsWithInlineMessage,
+		chatsWithoutInlineMessage: payload.chats.length - chatsWithInlineMessage,
+		peerDataRequestSessionId: payload.peerDataRequestSessionId ?? null
+	};
+}
+function shouldRequestFullHistoryOnOpen(auth) {
+	return auth.creds.registered === true;
+}
+const promiseWithResolvers = Promise;
+/** Minimal async queue: push events, await them one at a time, close to end. */
+var EventQueue = class {
+	buffer = [];
+	resolve;
+	done = false;
+	push(ev) {
+		if (this.done) return;
+		if (this.resolve) {
+			this.resolve({
+				value: ev,
+				done: false
+			});
+			this.resolve = void 0;
+		} else this.buffer.push(ev);
+	}
+	close() {
+		this.done = true;
+		if (this.resolve) {
+			this.resolve({
+				value: void 0,
+				done: true
+			});
+			this.resolve = void 0;
+		}
+	}
+	[Symbol.asyncIterator]() {
+		return { next: () => {
+			const queued = this.buffer.shift();
+			if (queued) return Promise.resolve({
+				value: queued,
+				done: false
+			});
+			if (this.done) return Promise.resolve({
+				value: void 0,
+				done: true
+			});
+			const { promise, resolve } = promiseWithResolvers.withResolvers();
+			this.resolve = resolve;
+			return promise;
+		} };
+	}
+};
+function summarizeLogValue(value, depth = 0) {
+	if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (typeof value === "bigint") return value.toString();
+	if (Buffer.isBuffer(value)) return {
+		type: "Buffer",
+		bytes: value.length
+	};
+	if (Array.isArray(value)) {
+		if (depth >= 2) return {
+			type: "Array",
+			length: value.length
+		};
+		return value.slice(0, 10).map((item) => summarizeLogValue(item, depth + 1));
+	}
+	if (typeof value !== "object") return String(value);
+	if (depth >= 2) return { type: "Object" };
+	const out = {};
+	for (const [key, child] of Object.entries(value)) {
+		if (typeof child === "function") continue;
+		out[key] = summarizeLogValue(child, depth + 1);
+	}
+	return out;
+}
+function disconnectTelemetry(error) {
+	const err = error;
+	return {
+		name: err?.name,
+		message: err?.message,
+		statusCode: err?.output?.statusCode,
+		payload: summarizeLogValue(err?.output?.payload),
+		data: summarizeLogValue(err?.data)
+	};
+}
+function connectionUpdateTelemetry(update) {
+	return {
+		connection: update.connection,
+		hasQr: Boolean(update.qr),
+		qrChars: typeof update.qr === "string" ? update.qr.length : void 0,
+		isNewLogin: update.isNewLogin,
+		receivedPendingNotifications: update.receivedPendingNotifications,
+		lastDisconnect: update.lastDisconnect ? disconnectTelemetry(update.lastDisconnect.error) : void 0
+	};
+}
+async function openSocket(opts) {
+	const { auth, saveCreds, logger } = opts;
+	const { version } = await fetchLatestBaileysVersion();
+	const queue = new EventQueue();
+	let intentional = false;
+	const requestFullHistory = shouldRequestFullHistoryOnOpen(auth);
+	logger.info({
+		version,
+		requestFullHistory,
+		credsRegistered: auth.creds.registered === true,
+		hasCredsMe: Boolean(auth.creds.me),
+		browser: "macOS Desktop"
+	}, "opening baileys socket");
+	const sock = makeWASocket({
+		version,
+		logger,
+		browser: Browsers.macOS("Desktop"),
+		syncFullHistory: requestFullHistory,
+		shouldSyncHistoryMessage: () => true,
+		auth: {
+			creds: auth.creds,
+			keys: makeCacheableSignalKeyStore(auth.keys, logger)
+		}
+	});
+	sock.ev.on("creds.update", () => void saveCreds());
+	const makeDownload = mediaDownloader(sock, logger);
+	const recent = /* @__PURE__ */ new Map();
+	const resolveQuoted = (ref) => recent.get(ref.id);
+	sock.ev.on("messages.upsert", (payload) => {
+		rememberRecent(recent, payload.messages);
+		for (const event of toMessagesUpsertEvents(payload, makeDownload)) queue.push(event);
+	});
+	sock.ev.on("messages.update", (updates) => {
+		for (const u of updates) {
+			const update = mapMessageUpdate(u, makeDownload);
+			if (update) queue.push({
+				t: "update",
+				update
+			});
+		}
+	});
+	sock.ev.on("message-receipt.update", (receipts) => {
+		for (const r of receipts) queue.push({
+			t: "update",
+			update: mapReceiptUpdate(r)
+		});
+	});
+	sock.ev.on("messages.reaction", (reactions) => {
+		for (const r of reactions) queue.push({
+			t: "update",
+			update: mapReaction(r)
+		});
+	});
+	sock.ev.on("contacts.upsert", (contacts) => {
+		for (const contact of mapContactUpdates(contacts)) queue.push({
+			t: "contact",
+			contact
+		});
+	});
+	sock.ev.on("contacts.update", (contacts) => {
+		for (const contact of mapContactUpdates(contacts)) queue.push({
+			t: "contact",
+			contact
+		});
+	});
+	sock.ev.on("groups.upsert", (groups) => {
+		for (const group of mapGroupMetadataUpdates(groups)) queue.push({
+			t: "group",
+			group
+		});
+	});
+	sock.ev.on("groups.update", (groups) => {
+		for (const group of mapGroupMetadataUpdates(groups)) queue.push({
+			t: "group",
+			group
+		});
+	});
+	sock.ev.on("group-participants.update", (update) => {
+		const group = mapGroupParticipantsUpdate(update);
+		if (group) queue.push({
+			t: "group",
+			group
+		});
+	});
+	sock.ev.on("presence.update", (update) => {
+		for (const presence of mapPresenceUpdate(update)) queue.push({
+			t: "presence",
+			presence
+		});
+	});
+	sock.ev.on("messaging-history.set", (payload) => {
+		logger.info(historySetTelemetry(payload), "messaging history set");
+		rememberRecent(recent, payload.messages);
+		for (const event of toMessagingHistoryEvents(payload, makeDownload)) queue.push(event);
+	});
+	sock.ev.on("messaging-history.status", (payload) => {
+		logger.info({
+			syncType: payload.syncType,
+			status: payload.status,
+			explicit: payload.explicit
+		}, "messaging history status");
+		for (const event of toMessagingHistoryStatusEvents(payload)) queue.push(event);
+	});
+	sock.ev.on("connection.update", (u) => {
+		logger.info(connectionUpdateTelemetry(u), "connection update");
+		if (u.connection === "connecting") queue.push({ t: "connecting" });
+		if (u.qr) queue.push({
+			t: "qr",
+			qr: u.qr
+		});
+		if (u.isNewLogin) queue.push({ t: "paired" });
+		if (u.connection === "open") queue.push({ t: "open" });
+		if (u.receivedPendingNotifications) queue.push({ t: "pending_drained" });
+		if (u.connection === "close") {
+			const fault = classifyDisconnect(u.lastDisconnect?.error, intentional);
+			queue.push({
+				t: "close",
+				fault
+			});
+			queue.close();
+		}
+	});
+	return {
+		events: queue,
+		requestPairingCode: (digits) => sock.requestPairingCode(digits),
+		send: async (to, out, opts) => {
+			return keyToRef((await sock.sendMessage(to, toContent(out), toOptions(opts, resolveQuoted)))?.key ?? {
+				remoteJid: to,
+				fromMe: true
+			});
+		},
+		markRead: (refs) => sock.readMessages(refs.map(refToKey)),
+		setTyping: (chatId, on) => sock.sendPresenceUpdate(on ? "composing" : "paused", chatId),
+		groupMetadata: async (chatId) => {
+			const metadata = await sock.groupMetadata(chatId);
+			return {
+				id: metadata.id ?? chatId,
+				...metadata.subject ? { subject: metadata.subject } : {},
+				participants: metadata.participants.map((participant) => ({
+					id: participant.id,
+					...participant.admin ? { role: participant.admin } : {}
+				}))
+			};
+		},
+		profilePictureUrl: (jid, type) => sock.profilePictureUrl(jid, type),
+		identity: () => {
+			const u = sock.user;
+			if (!u?.id) return void 0;
+			const digits = u.id.split(/[:@]/)[0] ?? "";
+			const phoneE164 = /^\d+$/.test(digits) ? `+${digits}` : void 0;
+			return {
+				jid: u.id,
+				pushName: u.name ?? void 0,
+				phoneE164
+			};
+		},
+		end: () => {
+			intentional = true;
+			sock.end(void 0);
+		}
+	};
+}
+//#endregion
+//#region src/session.ts
+/**
+* The session orchestrator. Feeds raw socket events through the pure connection
+* state machine, owns the timers the machine cannot (the pairing verdict window
+* and reconnect backoff), drives reconnection, and exposes the public surface:
+* a set of async-iterable streams plus `start`/`send`/`stop`. It makes only
+* timing decisions — never protocol ones.
+*/
+const QR_FIRST_MS = 6e4;
+const QR_REFRESH_MS = 2e4;
+/** Minimal single-consumer async stream. */
+var Stream = class {
+	buffer = [];
+	resolve;
+	done = false;
+	push(v) {
+		if (this.done) return;
+		if (this.resolve) {
+			this.resolve({
+				value: v,
+				done: false
+			});
+			this.resolve = void 0;
+		} else this.buffer.push(v);
+	}
+	close() {
+		this.done = true;
+		if (this.resolve) {
+			this.resolve({
+				value: void 0,
+				done: true
+			});
+			this.resolve = void 0;
+		}
+	}
+	[Symbol.asyncIterator]() {
+		return { next: () => {
+			const q = this.buffer.shift();
+			if (q !== void 0) return Promise.resolve({
+				value: q,
+				done: false
+			});
+			if (this.done) return Promise.resolve({
+				value: void 0,
+				done: true
+			});
+			return new Promise((r) => this.resolve = r);
+		} };
+	}
+};
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+* Create a single WhatsApp account session.
+*
+* @remarks
+* The returned session is inert until {@link WhatsAppSession.start | start} is
+* called. Consume its streams to observe the connection lifecycle and incoming
+* messages; call its command methods to send and interact.
+*
+* @param config - Store, auth strategy, and optional tuning — see
+* {@link SessionConfig}.
+* @returns A not-yet-connected {@link WhatsAppSession}.
+*
+* @example
+* ```ts
+* import { createSession, qrAuth, fileStore, refOf } from "whatsappd";
+*
+* const session = createSession({
+*   store: fileStore("./.wa-auth"),
+*   auth: qrAuth(),
+* });
+*
+* for await (const status of session.connection) {
+*   if (status.phase === "pairing" && status.pairing.step === "challenge_live") {
+*     console.log("scan:", status.pairing.qr ?? status.pairing.code);
+*   }
+* }
+*
+* await session.start();
+* ```
+*/
+function createSession(config) {
+	const { store, auth } = config;
+	const logger = config.logger ?? pino({ level: process.env.WA_LOG_LEVEL ?? "warn" });
+	const receiveStatusBroadcast = config.receiveStatusBroadcast ?? false;
+	const pacer = createPacer(config.sendMinGapMs ?? 1e3);
+	const emit = (event) => {
+		try {
+			config.metrics?.(event);
+		} catch (err) {
+			logger.warn({ err }, "metrics hook threw");
+		}
+	};
+	const ctx = {
+		method: auth.method,
+		reconnectBaseMs: config.reconnectBaseMs,
+		reconnectMaxMs: config.reconnectMaxMs
+	};
+	const verdictWindowMs = config.verdictWindowMs ?? 3e4;
+	const syncGraceMs = config.syncGraceMs ?? 3e3;
+	const connection = new Stream();
+	const inbound = new Stream();
+	const conversationSync = new Stream();
+	const updates = new Stream();
+	const contacts = new Stream();
+	const groups = new Stream();
+	const presence = new Stream();
+	let status = initialState;
+	let stopped = false;
+	let conn;
+	let firstQrSeen = false;
+	let verdictTimer;
+	let verdictFired = false;
+	let initialSyncComplete = false;
+	let syncTimer;
+	async function apply(input) {
+		const next = transition(status, input, ctx, Date.now());
+		if (next === status) return;
+		emit({
+			type: "transition",
+			from: status.phase,
+			to: next.phase
+		});
+		if (next.phase === "logged_out") await store.clear().catch(() => {});
+		status = next;
+		connection.push(status);
+		if (isTerminal(status)) {
+			connection.close();
+			inbound.close();
+			conversationSync.close();
+			updates.close();
+			contacts.close();
+			groups.close();
+			presence.close();
+		}
+	}
+	function clearVerdict() {
+		if (verdictTimer) clearTimeout(verdictTimer);
+		verdictTimer = void 0;
+	}
+	function clearSync() {
+		if (syncTimer) clearTimeout(syncTimer);
+		syncTimer = void 0;
+	}
+	function armSync() {
+		clearSync();
+		syncTimer = setTimeout(() => void apply({ t: "synced" }), syncGraceMs);
+	}
+	function fireVerdict() {
+		if (verdictFired) return;
+		verdictFired = true;
+		clearVerdict();
+		apply({ t: "pairing_rejected" });
+	}
+	async function handle(ev) {
+		switch (ev.t) {
+			case "connecting": return;
+			case "qr":
+				if (!firstQrSeen) {
+					firstQrSeen = true;
+					await apply({
+						t: "ready",
+						qr: ev.qr,
+						expiresAt: Date.now() + QR_FIRST_MS
+					});
+					return;
+				}
+				if (auth.method === "qr") await apply({
+					t: "qr_refresh",
+					qr: ev.qr,
+					expiresAt: Date.now() + QR_REFRESH_MS
+				});
+				else fireVerdict();
+				return;
+			case "paired":
+				clearVerdict();
+				await apply({ t: "paired" });
+				return;
+			case "open":
+				await apply({ t: "open" });
+				if (initialSyncComplete) armSync();
+				return;
+			case "pending_drained":
+				await apply({ t: "pending_drained" });
+				if (initialSyncComplete) {
+					clearSync();
+					await apply({ t: "synced" });
+				}
+				return;
+			case "conversation_sync_progress":
+				await apply({
+					t: "sync_progress",
+					progress: ev.progress
+				});
+				return;
+			case "conversation_sync_complete":
+				clearSync();
+				await apply({ t: "synced" });
+				return;
+			case "conversation_sync":
+				conversationSync.push(ev.sync);
+				return;
+			case "message":
+				if (!receiveStatusBroadcast && ev.msg.chatId === "status@broadcast") return;
+				inbound.push(ev.msg);
+				emit({
+					type: "message_in",
+					kind: ev.msg.kind,
+					live: ev.msg.live
+				});
+				return;
+			case "update":
+				updates.push(ev.update);
+				emit({
+					type: "update_in",
+					kind: ev.update.kind
+				});
+				return;
+			case "contact":
+				contacts.push(ev.contact);
+				emit({
+					type: "contact_in",
+					hasDisplayName: Boolean(ev.contact.displayName),
+					identityCount: ev.contact.nativeIds.length
+				});
+				return;
+			case "group":
+				groups.push(ev.group);
+				emit({
+					type: "group_in",
+					kind: ev.group.kind
+				});
+				return;
+			case "presence":
+				presence.push(ev.presence);
+				emit({
+					type: "presence_in",
+					kind: ev.presence.kind
+				});
+				return;
+			case "close":
+				clearVerdict();
+				clearSync();
+				await apply({
+					t: "close",
+					fault: ev.fault
+				});
+				return;
+		}
+	}
+	async function runOnce() {
+		firstQrSeen = false;
+		verdictFired = false;
+		clearVerdict();
+		clearSync();
+		const auth = await loadAuth(store);
+		initialSyncComplete = auth.initialSyncComplete;
+		conn = await openSocket({
+			auth: {
+				creds: auth.creds,
+				keys: auth.keys
+			},
+			saveCreds: auth.saveCreds,
+			logger
+		});
+		if (config.auth.method === "pairing_code" && !auth.creds.me) {
+			await apply({
+				t: "code_ready",
+				code: await conn.requestPairingCode(assertE164(config.auth.phone).replace(/^\+/, "")),
+				expiresAt: Date.now() + verdictWindowMs
+			});
+			verdictTimer = setTimeout(fireVerdict, verdictWindowMs);
+		}
+		for await (const ev of conn.events) await handle(ev);
+	}
+	async function supervise() {
+		await apply({ t: "start" });
+		while (!stopped) {
+			await runOnce().catch(async (err) => {
+				logger.error({ err }, "session run errored");
+				await apply({
+					t: "close",
+					fault: {
+						reason: "unknown",
+						retryable: true,
+						disposition: "retryable"
+					}
+				});
+			});
+			if (isTerminal(status)) break;
+			if (status.phase === "disconnected") break;
+			if (status.phase === "backing_off") {
+				const attempt = status.retryAttempt;
+				await delay(Math.max(0, status.nextRetryAt - Date.now()));
+				if (stopped) break;
+				emit({
+					type: "reconnect",
+					attempt
+				});
+				await apply({ t: "retry_due" });
+			}
+		}
+		connection.close();
+		inbound.close();
+		conversationSync.close();
+		updates.close();
+		contacts.close();
+		groups.close();
+		presence.close();
+	}
+	return {
+		get status() {
+			return status;
+		},
+		connection,
+		inbound,
+		conversationSync,
+		updates,
+		contacts,
+		groups,
+		presence,
+		start: supervise,
+		async send(to, msg, opts) {
+			if (status.phase !== "online" || !conn) throw new Error(`not online (phase: ${status.phase})`);
+			const c = conn;
+			const ref = await pacer.run(() => c.send(to, msg, opts));
+			emit({ type: "message_out" });
+			return ref;
+		},
+		async markRead(refs) {
+			if (status.phase !== "online" || !conn) throw new Error(`not online (phase: ${status.phase})`);
+			return conn.markRead(refs);
+		},
+		async setTyping(chatId, on) {
+			if (status.phase !== "online" || !conn) throw new Error(`not online (phase: ${status.phase})`);
+			return conn.setTyping(chatId, on);
+		},
+		async groupMetadata(chatId) {
+			if (status.phase !== "online" || !conn) throw new Error(`not online (phase: ${status.phase})`);
+			return conn.groupMetadata(chatId);
+		},
+		async profilePictureUrl(jid, type) {
+			if (status.phase !== "online" || !conn) throw new Error(`not online (phase: ${status.phase})`);
+			return conn.profilePictureUrl(jid, type);
+		},
+		identity: () => conn?.identity(),
+		async stop() {
+			stopped = true;
+			clearVerdict();
+			clearSync();
+			conn?.end();
+		}
+	};
+}
+//#endregion
+//#region src/ports.ts
+/**
+* The two pluggable seams — where credentials live and how login happens. Both
+* are deliberately free of any WhatsApp-protocol types, so a custom store or a
+* host adapter needs no knowledge of the underlying socket library.
+*
+* @packageDocumentation
+*/
+/**
+* Log in by scanning a QR code shown to the user.
+*
+* @returns A QR {@link AuthStrategy}.
+*/
+function qrAuth() {
+	return { method: "qr" };
+}
+/**
+* Log in with a pairing code delivered to a known phone number.
+*
+* @param phone - The phone number in E.164 format (e.g. `+15551234567`).
+* @returns A pairing-code {@link AuthStrategy}.
+* @throws {@link PairingError} with reason `"invalid_phone"` when `phone` is
+* not valid E.164 — validated here so bad input fails before any network call.
+*/
+function pairingAuth(phone) {
+	return {
+		method: "pairing_code",
+		phone: assertE164(phone)
+	};
+}
+//#endregion
+//#region src/stores/file.ts
+/**
+* A file-backed {@link SessionStore} — one file per key under a directory.
+* Durable across restarts; a good default for a single sidecar process.
+*/
+/** Make a key safe to use as a filename. */
+const fileName = (key) => `${key.replace(/[^0-9A-Za-z._-]/g, "_")}.json`;
+function fileStore(dir) {
+	const path = (key) => join(dir, fileName(key));
+	let ensured = false;
+	const ensureDir = async () => {
+		if (ensured) return;
+		await mkdir(dir, { recursive: true });
+		ensured = true;
+	};
+	return {
+		async read(key) {
+			try {
+				return await readFile(path(key), "utf-8");
+			} catch {
+				return null;
+			}
+		},
+		async write(entries) {
+			await ensureDir();
+			await Promise.all(Object.entries(entries).map(([key, value]) => value === null ? rm(path(key), { force: true }) : writeFile(path(key), value)));
+		},
+		async clear() {
+			ensured = false;
+			await rm(dir, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+//#endregion
+//#region src/channel/adapter.ts
+/** Build a ConversationRef from an inbound message. */
+function refFromMessage(msg) {
+	return {
+		chatId: msg.chatId,
+		isGroup: msg.isGroup,
+		from: msg.from,
+		pushName: msg.pushName
+	};
+}
+/** Build a ConversationRef from an update's ref. */
+function refFromUpdate(update) {
+	const chatId = update.ref.chatId;
+	if (!chatId) return void 0;
+	return {
+		chatId,
+		isGroup: chatId.includes("@g.us"),
+		from: update.ref.participant
+	};
+}
+/**
+* Create a `WhatsAppChannelAdapter` over one session.
+*
+* Construction does NOT connect — call `start()` to begin pumping the
+* session's streams and open the socket to WhatsApp.
+*/
+function createChannelAdapter(opts) {
+	const { session } = opts;
+	const accountId = opts.accountId ?? "default";
+	const log = opts.logger;
+	const subscribers = /* @__PURE__ */ new Set();
+	let started = false;
+	function emit(event) {
+		for (const h of subscribers) if (h.onEvent(event) instanceof Promise);
+	}
+	/** Pump the session's streams into ChannelEvents (they end on stop/terminal). */
+	function startPump() {
+		const tasks = [
+			(async () => {
+				for await (const message of session.inbound) emit({
+					type: "message",
+					ref: refFromMessage(message),
+					message
+				});
+			})(),
+			(async () => {
+				for await (const update of session.updates) {
+					const ref = refFromUpdate(update);
+					if (ref) emit({
+						type: "update",
+						ref,
+						update
+					});
+				}
+			})(),
+			(async () => {
+				for await (const status of session.connection) emit({
+					type: "status",
+					accountId,
+					status
+				});
+			})()
+		];
+		Promise.all(tasks).catch((err) => {
+			log?.error({ err }, "channel adapter stream pump error");
+		});
+	}
+	function requireStarted() {
+		if (!started) throw new Error(`adapter for account ${accountId} — call start() first`);
+		return session;
+	}
+	return {
+		accountId,
+		async start() {
+			if (started) return;
+			started = true;
+			startPump();
+			await session.start();
+		},
+		async send(chatId, content, opts) {
+			return requireStarted().send(chatId, content, opts);
+		},
+		async markRead(chatId) {
+			await requireStarted().markRead([{
+				id: "",
+				chatId,
+				fromMe: false
+			}]);
+		},
+		async setTyping(chatId, kind) {
+			const on = kind === "typing" || kind === "recording";
+			await requireStarted().setTyping(chatId, on);
+		},
+		subscribe(handler) {
+			subscribers.add(handler);
+			return () => {
+				subscribers.delete(handler);
+			};
+		},
+		async stop() {
+			await session.stop();
+		}
+	};
+}
+//#endregion
+export { createSession as a, PairingError as c, dispositionFor as d, isRetryable as f, qrAuth as i, assertE164 as l, fileStore as n, isOnline as o, pairingAuth as r, isTerminal as s, createChannelAdapter as t, classifyDisconnect as u };