@prajwalshete/telegram-plugin 0.0.0-stage → 0.1.1

package/dist/services/templates.js

@@ -0,0 +1,259 @@
+import { ReportLayout } from "../contracts/templates.js";
+import { SAFE_URL_RE } from "../core/template/tags.js";
+import { sql } from "../ports/sql.js";
+import { TelegramPluginError, featureDisabled } from "../engine/errors.js";
+import { checkBody, parseSource, renderBody, templateProblem } from "../engine/content/render.js";
+import { hostCan, parseProviderParams, requireProvider, sampleData } from "../engine/content/providers.js";
+import { buildButtons } from "../engine/content/buttons.js";
+import { renderReportFile, rendererFor } from "../engine/content/report-files.js";
+import { viewerData } from "./reports.js";
+import { audienceForPreview } from "../engine/content/audience.js";
+import { requireTemplate, templateDto, templateModel, templateVersionDto } from "../engine/content/template-rows.js";
+import { actorId } from "./bots.js";
+// src/services/templates.ts
+function issue(path, message) {
+	return new TelegramPluginError("validation_failed", message, { extensions: { issues: [{
+		path,
+		message
+	}] } });
+}
+/** Save-time checks: provider + params, every locale's syntax and variables, report spec, buttons. */
+function validateTemplateSave(rt, save) {
+	const def = save.provider ? requireProvider(rt, save.provider) : null;
+	if (def && save.providerParams) parseProviderParams(def, save.providerParams);
+	const errors = checkBody(save.body, save.format, {
+		filters: rt.filters,
+		...def ? { variables: def.variables } : {}
+	});
+	if (save.kind === "report") {
+		if (!rt.features.reports) throw featureDisabled("reports");
+		if (!save.report) throw issue("body.report", "report templates need a report spec");
+		rendererFor(rt, save.report.renderer);
+		const name = parseSource(save.report.fileName, "text");
+		for (const e of name.errors) errors.push({
+			...e,
+			locale: "fileName"
+		});
+		if (save.report.layout !== void 0 && !ReportLayout.safeParse(save.report.layout).success) throw issue("body.report.layout", "layout is not valid ({ rows?, columns?: [{ key, label, format }], title? })");
+	}
+	for (const [r, row] of (save.buttons ?? []).entries()) for (const [c, b] of row.entries()) {
+		const path = `body.buttons.${r}.${c}`;
+		if (b.action !== void 0 && !rt.registry.actions.has(b.action)) throw issue(path, `action "${b.action}" is not registered`);
+		if (b.url !== void 0) {
+			const parsed = parseSource(b.url, "text");
+			for (const e of parsed.errors) errors.push({
+				...e,
+				locale: path
+			});
+			const at = b.url.indexOf("{{");
+			const prefix = at === -1 ? b.url : b.url.slice(0, at);
+			if (parsed.errors.length === 0 && prefix !== "" && !SAFE_URL_RE.test(prefix)) throw issue(path, "url must start with http(s):// or tg://");
+		}
+	}
+	if (errors.length > 0) throw templateProblem(errors);
+}
+async function listTemplates(rt, q, page) {
+	return rt.db.all(sql`SELECT * FROM tg_template WHERE tenant = ${rt.tenant} AND deleted_at IS NULL
+        ${q.kind ? sql`AND kind = ${q.kind}` : sql.empty}
+        ${page.cursor ? sql`AND id < ${page.cursor}` : sql.empty} ORDER BY id DESC LIMIT ${page.limit + 1}`);
+}
+function versionInsert(rt, id, by, now) {
+	return sql`INSERT INTO tg_template_version (tenant, template_id, version, body_json, report_json, buttons_json, saved_by,
+               saved_at)
+             SELECT tenant, id, version, body_json, report_json, buttons_json, ${by}, ${now}
+             FROM tg_template WHERE tenant = ${rt.tenant} AND id = ${id}`;
+}
+const json = (v) => v === null || v === void 0 ? null : JSON.stringify(v);
+/**
+* Creates a template (version 1) with its version row and audit in one batch; a soft-deleted template with the same
+* key is renamed out of the way. Throws `validation_failed` (key taken, invalid body / provider / buttons). No
+* permission check: the admin routes require `telegram.templates.manage`.
+*/
+async function createTemplate(rt, actor, save) {
+	validateTemplateSave(rt, save);
+	const taken = await rt.db.first(sql`SELECT id, deleted_at FROM tg_template WHERE tenant = ${rt.tenant} AND key = ${save.key}`);
+	if (taken && taken.deleted_at === null) throw issue("body.key", "key is already used by another template");
+	const now = rt.clock.now();
+	const by = actorId(rt, actor);
+	const id = rt.ids.uuid();
+	await rt.db.batch([
+		...taken ? [sql`UPDATE tg_template SET key = ${`${save.key}~${taken.id}`} WHERE id = ${taken.id}`] : [],
+		sql`INSERT INTO tg_template (id, tenant, key, name, kind, provider, provider_params_json, body_json, format, report_json,
+          buttons_json, options_json, version, created_by, created_at, updated_by, updated_at)
+        VALUES (${id}, ${rt.tenant}, ${save.key}, ${save.name}, ${save.kind}, ${save.provider}, ${json(save.providerParams)},
+          ${JSON.stringify(save.body)}, ${save.format}, ${json(save.report)}, ${json(save.buttons)}, ${json(save.options)},
+          1, ${by}, ${now}, ${by}, ${now})`,
+		versionInsert(rt, id, by, now),
+		...rt.audit({
+			actor: by,
+			entity: "telegram_template",
+			entityId: id,
+			action: "create",
+			diff: { key: save.key },
+			at: now
+		})
+	]);
+	return templateDto(await requireTemplate(rt, id));
+}
+/**
+* Replaces a template and appends a new version (+ audit) in one batch. Throws `not_found` or `validation_failed`.
+* No permission check (the routes do it).
+*/
+async function updateTemplate(rt, actor, id, save) {
+	const old = await requireTemplate(rt, id);
+	validateTemplateSave(rt, save);
+	if (save.key !== old.key) {
+		if (await rt.db.first(sql`SELECT id FROM tg_template WHERE tenant = ${rt.tenant} AND key = ${save.key} AND id != ${id}`)) throw issue("body.key", "key is already used by another template");
+	}
+	const now = rt.clock.now();
+	const by = actorId(rt, actor);
+	await rt.db.batch([
+		sql`UPDATE tg_template SET key = ${save.key}, name = ${save.name}, kind = ${save.kind}, provider = ${save.provider},
+          provider_params_json = ${json(save.providerParams)}, body_json = ${JSON.stringify(save.body)},
+          format = ${save.format}, report_json = ${json(save.report)}, buttons_json = ${json(save.buttons)},
+          options_json = ${json(save.options)}, version = version + 1, updated_by = ${by}, updated_at = ${now}
+        WHERE tenant = ${rt.tenant} AND id = ${id} AND deleted_at IS NULL`,
+		versionInsert(rt, id, by, now),
+		...rt.audit({
+			actor: by,
+			entity: "telegram_template",
+			entityId: id,
+			action: "update",
+			diff: { version: old.version + 1 },
+			at: now
+		})
+	]);
+	return templateDto(await requireTemplate(rt, id));
+}
+async function deleteTemplate(rt, actor, id) {
+	const old = await requireTemplate(rt, id);
+	const now = rt.clock.now();
+	const by = actorId(rt, actor);
+	await rt.db.batch([sql`UPDATE tg_template SET deleted_at = ${now}, updated_by = ${by}, updated_at = ${now}
+        WHERE tenant = ${rt.tenant} AND id = ${id}`, ...rt.audit({
+		actor: by,
+		entity: "telegram_template",
+		entityId: id,
+		action: "delete",
+		diff: { key: old.key },
+		at: now
+	})]);
+}
+async function listVersions(rt, id) {
+	await requireTemplate(rt, id);
+	return (await rt.db.all(sql`SELECT * FROM tg_template_version WHERE tenant = ${rt.tenant} AND template_id = ${id} ORDER BY version DESC LIMIT 200`)).map(templateVersionDto);
+}
+/** Restores a saved version as a new version (history stays append-only). */
+async function restoreVersion(rt, actor, id, version) {
+	const current = await requireTemplate(rt, id);
+	const v = await rt.db.first(sql`SELECT * FROM tg_template_version WHERE tenant = ${rt.tenant} AND template_id = ${id} AND version = ${version}`);
+	if (!v) throw new TelegramPluginError("not_found", "version not found");
+	const dto = templateDto({
+		...current,
+		body_json: v.body_json,
+		report_json: v.report_json,
+		buttons_json: v.buttons_json
+	});
+	return updateTemplate(rt, actor, id, {
+		key: dto.key,
+		name: dto.name,
+		kind: dto.kind,
+		provider: dto.provider,
+		providerParams: dto.providerParams,
+		body: dto.body,
+		format: dto.format,
+		report: dto.report,
+		buttons: dto.buttons,
+		options: dto.options
+	});
+}
+/** Unsaved source or a saved template, as one model. */
+async function previewModel(rt, req) {
+	if (req.templateId) return templateModel(await requireTemplate(rt, req.templateId));
+	return {
+		id: "preview",
+		key: "preview",
+		name: "preview",
+		kind: "message",
+		provider: req.provider ?? null,
+		providerParams: null,
+		body: { [req.locale]: req.source ?? "" },
+		format: req.format ?? "html",
+		report: null,
+		layout: null,
+		buttons: req.buttons ?? null,
+		options: {},
+		version: 1
+	};
+}
+/** What the audience would get: rendered parts, buttons, file, render warnings. Writes nothing. */
+async function previewTemplate(rt, caller, req) {
+	const t = await previewModel(rt, req);
+	const def = t.provider ? requireProvider(rt, t.provider) : null;
+	const errors = checkBody(t.body, t.format, {
+		filters: rt.filters,
+		...def ? { variables: def.variables } : {}
+	});
+	if (errors.length > 0) throw templateProblem(errors);
+	const aud = await audienceForPreview(rt, req.as);
+	const tz = rt.settings.timezone;
+	const now = rt.clock.now();
+	let vars = {};
+	if (def) {
+		if (req.sample) vars = sampleData(rt, def);
+		else {
+			if (!await hostCan(rt, aud, def.permission)) throw new TelegramPluginError("provider_forbidden", `this audience may not read "${def.key}"`);
+			const params = parseProviderParams(def, {
+				...t.providerParams,
+				...req.params
+			});
+			vars = await viewerData(rt, {
+				def,
+				actor: aud,
+				viewer: caller,
+				params,
+				now,
+				tz,
+				locale: req.locale
+			});
+		}
+	}
+	const body = renderBody(rt, {
+		body: t.body,
+		format: t.format,
+		vars,
+		locales: [req.locale],
+		tz
+	});
+	const buttons = await buildButtons(rt, t.buttons, {
+		vars,
+		locale: body.locale,
+		tz,
+		botId: "",
+		chatRef: null,
+		userId: null,
+		now
+	});
+	let file = null;
+	if (t.kind === "report") {
+		const out = await renderReportFile(rt, {
+			template: t,
+			vars,
+			locale: body.locale,
+			tz,
+			html: body.html
+		});
+		file = {
+			name: out.name,
+			mime: out.mime,
+			size: out.size ?? null
+		};
+	}
+	return {
+		parts: body.parts,
+		buttons: buttons.preview,
+		file,
+		warnings: body.warnings
+	};
+}
+export { createTemplate, deleteTemplate, listTemplates, listVersions, previewTemplate, restoreVersion, updateTemplate, validateTemplateSave };

package/dist/telegram/classify.d.ts

@@ -0,0 +1,30 @@
+/** Coarse result of a Bot API call: what the sender does next (retry, mark chat blocked/left/migrated, fail). */
+export type TelegramOutcomeKind = "ok" | "retry_after" | "migrated" | "parse_error" | "bad_request" | "blocked" | "left" | "not_found_chat" | "unauthorized" | "server_error" | "network" | "timeout";
+/** Finer reason inside a kind (stable strings, safe to store in `error_code`). */
+export type TelegramOutcomeReason = "not_modified" | "message_gone" | "too_long" | "caption_too_long" | "empty_text" | "query_too_old" | "button_data_invalid" | "file_invalid" | "no_rights" | "thread_not_found" | "too_large" | "conflict" | "user_blocked" | "user_deactivated" | "cant_initiate" | "forbidden" | "kicked" | "not_member" | "bad_token" | "aborted" | "other";
+/** Classified Bot API result (see {@link classifyTelegramError}). */
+export interface TelegramOutcome {
+  kind: TelegramOutcomeKind;
+  reason?: TelegramOutcomeReason;
+  /** Worth retrying later (429, 5xx, network, timeout). */
+  retryable: boolean;
+  /** Milliseconds to wait (429). */
+  retryAfterMs?: number;
+  /** New supergroup id (400 migrate), as a string like `tg_chat.chat_id`. */
+  migrateToChatId?: string;
+  /** HTTP status, when Telegram answered. */
+  status?: number;
+  /** Telegram's description, safe to store (contains no token). */
+  description?: string;
+}
+/** Outcome of a failed call. Anything that is not a Telegram error is treated as a network failure. */
+export declare function classifyTelegramError(err: unknown): TelegramOutcome;
+/** Runs a call and returns its outcome next to the value (never throws for Telegram/network failures). */
+export declare function settle<T>(call: Promise<T>): Promise<{
+  outcome: TelegramOutcome;
+  value: T;
+} | {
+  outcome: TelegramOutcome;
+  value?: undefined;
+  error: unknown;
+}>;

package/dist/telegram/classify.js

@@ -0,0 +1,164 @@
+import { TelegramApiError, TelegramNetworkError } from "./errors.js";
+// src/telegram/classify.ts
+const OK = {
+	kind: "ok",
+	retryable: false
+};
+function has(desc, ...needles) {
+	const d = desc.toLowerCase();
+	return needles.some((n) => d.includes(n));
+}
+function bad(e, reason) {
+	return {
+		kind: "bad_request",
+		reason,
+		retryable: false,
+		status: e.status,
+		description: e.description
+	};
+}
+function classify400(e) {
+	const d = e.description;
+	const base = {
+		retryable: false,
+		status: e.status,
+		description: d
+	};
+	if (e.migrateToChatId !== void 0) return {
+		kind: "migrated",
+		...base,
+		migrateToChatId: String(e.migrateToChatId)
+	};
+	if (has(d, "can't parse entities", "can't find end of the entity", "unsupported start tag")) return {
+		kind: "parse_error",
+		...base
+	};
+	if (has(d, "chat not found", "peer_id_invalid", "chat_id is empty")) return {
+		kind: "not_found_chat",
+		...base
+	};
+	if (has(d, "message is not modified")) return {
+		...OK,
+		reason: "not_modified",
+		description: d
+	};
+	if (has(d, "message to edit not found", "message to delete not found", "message can't be edited", "message can't be deleted", "message_id_invalid")) return bad(e, "message_gone");
+	if (has(d, "message caption is too long")) return bad(e, "caption_too_long");
+	if (has(d, "message is too long")) return bad(e, "too_long");
+	if (has(d, "message text is empty")) return bad(e, "empty_text");
+	if (has(d, "query is too old", "query id is invalid")) return bad(e, "query_too_old");
+	if (has(d, "button_data_invalid")) return bad(e, "button_data_invalid");
+	if (has(d, "wrong file identifier", "failed to get http url content", "wrong type of the web page content")) return bad(e, "file_invalid");
+	if (has(d, "not enough rights", "have no rights", "chat_write_forbidden", "chat_restricted")) return bad(e, "no_rights");
+	if (has(d, "message thread not found", "topic_closed", "topic_deleted")) return bad(e, "thread_not_found");
+	return bad(e, "other");
+}
+function classify403(e) {
+	const d = e.description;
+	const base = {
+		retryable: false,
+		status: e.status,
+		description: d
+	};
+	if (has(d, "bot was kicked")) return {
+		kind: "left",
+		reason: "kicked",
+		...base
+	};
+	if (has(d, "bot is not a member", "chat_write_forbidden")) return {
+		kind: "left",
+		reason: "not_member",
+		...base
+	};
+	if (has(d, "bot was blocked by the user")) return {
+		kind: "blocked",
+		reason: "user_blocked",
+		...base
+	};
+	if (has(d, "user is deactivated")) return {
+		kind: "blocked",
+		reason: "user_deactivated",
+		...base
+	};
+	if (has(d, "can't initiate conversation")) return {
+		kind: "blocked",
+		reason: "cant_initiate",
+		...base
+	};
+	return {
+		kind: "blocked",
+		reason: "forbidden",
+		...base
+	};
+}
+/** Outcome of a failed call. Anything that is not a Telegram error is treated as a network failure. */
+function classifyTelegramError(err) {
+	if (err instanceof TelegramNetworkError) {
+		if (err.reason === "timeout") return {
+			kind: "timeout",
+			retryable: true
+		};
+		if (err.reason === "aborted") return {
+			kind: "network",
+			reason: "aborted",
+			retryable: false
+		};
+		return {
+			kind: "network",
+			retryable: true
+		};
+	}
+	if (!(err instanceof TelegramApiError)) return {
+		kind: "network",
+		retryable: true
+	};
+	const e = err;
+	const code = e.errorCode || e.status;
+	if (code === 429 || e.retryAfter !== void 0) return {
+		kind: "retry_after",
+		retryable: true,
+		retryAfterMs: Math.max(1, e.retryAfter ?? 1) * 1e3,
+		status: e.status,
+		description: e.description
+	};
+	if (code === 400) return classify400(e);
+	if (code === 401) return {
+		kind: "unauthorized",
+		retryable: false,
+		status: e.status,
+		description: e.description
+	};
+	if (code === 404) return {
+		kind: "unauthorized",
+		reason: "bad_token",
+		retryable: false,
+		status: e.status,
+		description: e.description
+	};
+	if (code === 403) return classify403(e);
+	if (code === 409) return bad(e, "conflict");
+	if (code === 413) return bad(e, "too_large");
+	if (code >= 500) return {
+		kind: "server_error",
+		retryable: true,
+		status: e.status,
+		description: e.description
+	};
+	return bad(e, "other");
+}
+/** Runs a call and returns its outcome next to the value (never throws for Telegram/network failures). */
+async function settle(call) {
+	try {
+		return {
+			outcome: OK,
+			value: await call
+		};
+	} catch (error) {
+		if (!(error instanceof TelegramApiError) && !(error instanceof TelegramNetworkError)) throw error;
+		return {
+			outcome: classifyTelegramError(error),
+			error
+		};
+	}
+}
+export { classifyTelegramError, settle };

package/dist/telegram/client.d.ts

@@ -0,0 +1,73 @@
+import { LogPort } from "../ports/ports.js";
+import { AnswerCallbackQueryParams, BotCommand, ChatId, CommandScopeParams, DeleteMessageParams, DeleteWebhookParams, EditMessageReplyMarkupParams, EditMessageTextParams, GetUpdatesParams, MethodResults, SendChatActionParams, SendDocumentParams, SendMessageParams, SendPhotoParams, SetMyCommandsParams, SetWebhookParams } from "./types.js";
+/** Default Bot API origin. */
+export declare const DEFAULT_TELEGRAM_BASE_URL = "https://api.telegram.org";
+/** Default per-request timeout (ms). */
+export declare const DEFAULT_TELEGRAM_TIMEOUT_MS = 15000;
+/** Any fetch-compatible function (global fetch, a service binding, or `FakeTelegram#fetch`). */
+export type FetchLike = (input: Request | string | URL, init?: RequestInit) => Promise<Response>;
+/** Returns the plaintext token for one request (for example by decrypting it with the keyring). */
+export type TokenGetter = () => string | Promise<string>;
+/** Options for {@link fetchTelegram}. */
+export interface TelegramClientOptions {
+  /** Fetch to use. Default: global `fetch`. */
+  fetch?: FetchLike;
+  /** Default `https://api.telegram.org` (a local Bot API server or a proxy also works). */
+  baseUrl?: string;
+  /** Per-request timeout. Default 15 s. `getUpdates` adds its long-poll `timeout` on top. */
+  timeoutMs?: number;
+  /** Gets `tg.api` debug lines with method, duration and error code only. */
+  log?: LogPort;
+}
+/** Per-call options: abort signal and a timeout override (ms). */
+export interface CallOptions {
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+/** Typed methods for one bot. Cheap to create; holds only the token getter. */
+export interface BotApi {
+  /** Any method by name (for methods without a typed wrapper). */
+  call<T = unknown>(method: string, params?: object, opts?: CallOptions): Promise<T>;
+  getMe(opts?: CallOptions): Promise<MethodResults["getMe"]>;
+  setWebhook(p: SetWebhookParams, opts?: CallOptions): Promise<true>;
+  deleteWebhook(p?: DeleteWebhookParams, opts?: CallOptions): Promise<true>;
+  getWebhookInfo(opts?: CallOptions): Promise<MethodResults["getWebhookInfo"]>;
+  /** Raw updates: validate each with `parseUpdate`. */
+  getUpdates(p?: GetUpdatesParams, opts?: CallOptions): Promise<unknown[]>;
+  setMyCommands(p: SetMyCommandsParams, opts?: CallOptions): Promise<true>;
+  deleteMyCommands(p?: CommandScopeParams, opts?: CallOptions): Promise<true>;
+  getMyCommands(p?: CommandScopeParams, opts?: CallOptions): Promise<BotCommand[]>;
+  sendMessage(p: SendMessageParams, opts?: CallOptions): Promise<MethodResults["sendMessage"]>;
+  sendDocument(p: SendDocumentParams, opts?: CallOptions): Promise<MethodResults["sendDocument"]>;
+  sendPhoto(p: SendPhotoParams, opts?: CallOptions): Promise<MethodResults["sendPhoto"]>;
+  sendChatAction(p: SendChatActionParams, opts?: CallOptions): Promise<true>;
+  editMessageText(p: EditMessageTextParams, opts?: CallOptions): Promise<MethodResults["editMessageText"]>;
+  editMessageReplyMarkup(p: EditMessageReplyMarkupParams, opts?: CallOptions): Promise<MethodResults["editMessageReplyMarkup"]>;
+  deleteMessage(p: DeleteMessageParams, opts?: CallOptions): Promise<true>;
+  answerCallbackQuery(p: AnswerCallbackQueryParams, opts?: CallOptions): Promise<true>;
+  getFile(p: {
+    file_id: string;
+  }, opts?: CallOptions): Promise<MethodResults["getFile"]>;
+  /** Download URL for a `getFile` path. It contains the token: use it at once, never log or store it. */
+  fileUrl(filePath: string): Promise<string>;
+  /** Downloads a file by its `getFile` path (≤ 20 MB on the cloud Bot API). */
+  downloadFile(filePath: string, opts?: CallOptions): Promise<Response>;
+  getChat(p: {
+    chat_id: ChatId;
+  }, opts?: CallOptions): Promise<MethodResults["getChat"]>;
+  getChatMember(p: {
+    chat_id: ChatId;
+    user_id: number;
+  }, opts?: CallOptions): Promise<MethodResults["getChatMember"]>;
+  leaveChat(p: {
+    chat_id: ChatId;
+  }, opts?: CallOptions): Promise<true>;
+}
+/** Creates `BotApi` handles per bot. This is the default `fetchTelegram` adapter. */
+export interface TelegramClient {
+  bot(getToken: TokenGetter): BotApi;
+  /** Runs `fn` with a handle for one bot; the handle should not outlive the call. */
+  withToken<T>(getToken: TokenGetter, fn: (api: BotApi) => Promise<T>): Promise<T>;
+}
+/** Bot API client on `fetch`. Errors are {@link TelegramApiError} or {@link TelegramNetworkError}, never raw fetch errors. */
+export declare function fetchTelegram(options?: TelegramClientOptions): TelegramClient;

package/dist/telegram/client.js

@@ -0,0 +1,135 @@
+import { TelegramApiError, TelegramNetworkError } from "./errors.js";
+import { encodeBody } from "./multipart.js";
+// src/telegram/client.ts
+/** Default Bot API origin. */
+const DEFAULT_TELEGRAM_BASE_URL = "https://api.telegram.org";
+/** Default per-request timeout (ms). */
+const DEFAULT_TELEGRAM_TIMEOUT_MS = 15e3;
+function signalFor(timeoutMs, outer) {
+	const timeout = AbortSignal.timeout(timeoutMs);
+	return {
+		signal: outer ? AbortSignal.any([outer, timeout]) : timeout,
+		timeout
+	};
+}
+async function readBody(res) {
+	try {
+		const body = await res.json();
+		return typeof body === "object" && body !== null ? body : null;
+	} catch {
+		return null;
+	}
+}
+/** Bot API client on `fetch`. Errors are {@link TelegramApiError} or {@link TelegramNetworkError}, never raw fetch errors. */
+function fetchTelegram(options = {}) {
+	const doFetch = options.fetch ?? ((input, init) => fetch(input, init));
+	const baseUrl = (options.baseUrl ?? "https://api.telegram.org").replace(/\/+$/, "");
+	const defaultTimeout = options.timeoutMs ?? 15e3;
+	const log = options.log;
+	async function send(method, getToken, build, opts, extraMs = 0) {
+		const { signal, timeout } = signalFor((opts.timeoutMs ?? defaultTimeout) + extraMs, opts.signal);
+		const { url, init } = build(await getToken());
+		try {
+			return await doFetch(url, {
+				...init,
+				signal
+			});
+		} catch {
+			throw new TelegramNetworkError(method, timeout.aborted ? "timeout" : signal.aborted ? "aborted" : "network");
+		}
+	}
+	function bot(getToken) {
+		async function call(method, params = {}, opts = {}) {
+			const started = Date.now();
+			const { body, contentType } = await encodeBody(params);
+			const extraMs = method === "getUpdates" ? Math.max(0, Number(params.timeout ?? 0)) * 1e3 : 0;
+			let res;
+			try {
+				res = await send(method, getToken, (token) => ({
+					url: `${baseUrl}/bot${token}/${method}`,
+					init: {
+						method: "POST",
+						body,
+						headers: contentType ? { "content-type": contentType } : {}
+					}
+				}), opts, extraMs);
+			} catch (e) {
+				log?.debug("tg.api", {
+					method,
+					ok: false,
+					error: e.reason,
+					ms: Date.now() - started
+				});
+				throw e;
+			}
+			const parsed = await readBody(res);
+			if (res.ok && parsed?.ok === true) {
+				log?.debug("tg.api", {
+					method,
+					ok: true,
+					ms: Date.now() - started
+				});
+				return parsed.result;
+			}
+			const err = new TelegramApiError({
+				method,
+				status: res.status,
+				errorCode: parsed?.error_code ?? res.status,
+				description: parsed?.description ?? `HTTP ${res.status}`,
+				retryAfter: parsed?.parameters?.retry_after,
+				migrateToChatId: parsed?.parameters?.migrate_to_chat_id
+			});
+			log?.debug("tg.api", {
+				method,
+				ok: false,
+				errorCode: err.errorCode,
+				ms: Date.now() - started
+			});
+			throw err;
+		}
+		const filePath = (path) => path.replace(/^\/+/, "");
+		return {
+			call,
+			getMe: (o) => call("getMe", {}, o),
+			setWebhook: (p, o) => call("setWebhook", p, o),
+			deleteWebhook: (p, o) => call("deleteWebhook", p ?? {}, o),
+			getWebhookInfo: (o) => call("getWebhookInfo", {}, o),
+			getUpdates: (p, o) => call("getUpdates", p ?? {}, o),
+			setMyCommands: (p, o) => call("setMyCommands", p, o),
+			deleteMyCommands: (p, o) => call("deleteMyCommands", p ?? {}, o),
+			getMyCommands: (p, o) => call("getMyCommands", p ?? {}, o),
+			sendMessage: (p, o) => call("sendMessage", p, o),
+			sendDocument: (p, o) => call("sendDocument", p, o),
+			sendPhoto: (p, o) => call("sendPhoto", p, o),
+			sendChatAction: (p, o) => call("sendChatAction", p, o),
+			editMessageText: (p, o) => call("editMessageText", p, o),
+			editMessageReplyMarkup: (p, o) => call("editMessageReplyMarkup", p, o),
+			deleteMessage: (p, o) => call("deleteMessage", p, o),
+			answerCallbackQuery: (p, o) => call("answerCallbackQuery", p, o),
+			getFile: (p, o) => call("getFile", p, o),
+			fileUrl: async (path) => `${baseUrl}/file/bot${await getToken()}/${filePath(path)}`,
+			async downloadFile(path, o = {}) {
+				const res = await send("downloadFile", getToken, (token) => ({
+					url: `${baseUrl}/file/bot${token}/${filePath(path)}`,
+					init: { method: "GET" }
+				}), o);
+				if (res.ok) return res;
+				const parsed = await readBody(res);
+				throw new TelegramApiError({
+					method: "downloadFile",
+					status: res.status,
+					errorCode: parsed?.error_code ?? res.status,
+					description: parsed?.description ?? `HTTP ${res.status}`
+				});
+			},
+			getChat: (p, o) => call("getChat", p, o),
+			getChatMember: (p, o) => call("getChatMember", p, o),
+			leaveChat: (p, o) => call("leaveChat", p, o)
+		};
+	}
+	return {
+		bot,
+		withToken: (getToken, fn) => fn(bot(getToken))
+	};
+}
+export { DEFAULT_TELEGRAM_BASE_URL, DEFAULT_TELEGRAM_TIMEOUT_MS, fetchTelegram };