stitchkit 0.95.3 → 0.96.0

package/dist/entrypoints/telegram.js

@@ -2,107 +2,179 @@ import {
   isRecord
 } from "../index-hffjpmq9.js";
 
-// src/telegram/init-data.ts
+// src/telegram/bot-api.ts
+var TELEGRAM_BOT_TOKEN_PATTERN = /\d{5,}:[A-Za-z0-9_-]{30,}/;
+var DEFAULT_API_ROOT = "https://api.telegram.org";
+
+class TelegramBotApiError extends Error {
+  method;
+  error_code;
+  description;
+  parameters;
+  constructor(method, answer) {
+    super(`Telegram ${method} failed: ${answer.error_code} ${answer.description}`);
+    this.name = "TelegramBotApiError";
+    this.method = method;
+    this.error_code = answer.error_code;
+    this.description = answer.description;
+    this.parameters = answer.parameters ?? {};
+  }
+}
+function numberField(value, key) {
+  if (!isRecord(value))
+    return;
+  const field = value[key];
+  return typeof field === "number" && Number.isFinite(field) ? field : undefined;
+}
+async function callTelegramBotApi(call) {
+  const root = (call.apiRoot ?? DEFAULT_API_ROOT).replace(/\/+$/, "");
+  let response;
+  try {
+    response = await (call.fetch ?? fetch)(`${root}/bot${call.token}/${call.method}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(call.params ?? {}),
+      ...call.signal && { signal: call.signal }
+    });
+  } catch (error) {
+    if (call.signal?.aborted)
+      throw call.signal.reason;
+    const kind = error instanceof Error ? error.name : "Error";
+    throw new Error(`Telegram ${call.method} request failed (${kind})`);
+  }
+  let answer;
+  try {
+    answer = await response.json();
+  } catch {
+    throw new TelegramBotApiError(call.method, {
+      error_code: response.status,
+      description: "response was not JSON"
+    });
+  }
+  if (isRecord(answer) && answer.ok === true)
+    return answer.result;
+  const parameters = isRecord(answer) ? answer.parameters : undefined;
+  const retryAfter = numberField(parameters, "retry_after");
+  const migrateTo = numberField(parameters, "migrate_to_chat_id");
+  throw new TelegramBotApiError(call.method, {
+    error_code: numberField(answer, "error_code") ?? response.status,
+    description: isRecord(answer) && typeof answer.description === "string" ? answer.description : "no description",
+    parameters: {
+      ...retryAfter !== undefined && { retry_after: retryAfter },
+      ...migrateTo !== undefined && { migrate_to_chat_id: migrateTo }
+    }
+  });
+}
+// src/telegram/broadcast-state.ts
+import { appendFile, mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
 import { z } from "zod";
-var TelegramInitDataUserSchema = z.object({
-  id: z.int(),
-  is_bot: z.boolean().optional(),
-  first_name: z.string(),
-  last_name: z.string().optional(),
-  username: z.string().optional(),
-  language_code: z.string().optional(),
-  is_premium: z.boolean().optional(),
-  allows_write_to_pm: z.boolean().optional(),
-  photo_url: z.string().optional()
-}).transform((user) => ({
-  id: user.id,
-  firstName: user.first_name,
-  ...user.is_bot !== undefined && { isBot: user.is_bot },
-  ...user.last_name !== undefined && { lastName: user.last_name },
-  ...user.username !== undefined && { username: user.username },
-  ...user.language_code !== undefined && { languageCode: user.language_code },
-  ...user.is_premium !== undefined && { isPremium: user.is_premium },
-  ...user.allows_write_to_pm !== undefined && { allowsWriteToPm: user.allows_write_to_pm },
-  ...user.photo_url !== undefined && { photoUrl: user.photo_url }
-}));
-var encoder = new TextEncoder;
-async function hmacSha256(key, message) {
-  const imported = await crypto.subtle.importKey("raw", key, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-  return crypto.subtle.sign("HMAC", imported, encoder.encode(message));
+var TelegramBroadcastOutcomeSchema = z.enum([
+  "delivered",
+  "unreachable",
+  "failed",
+  "uncertain"
+]);
+var ChatIdSchema = z.union([z.number().int(), z.string().min(1).max(64)]);
+var RecipientsSchema = z.array(ChatIdSchema);
+var JournalLineSchema = z.union([
+  z.object({ i: z.number().int().nonnegative(), s: z.enum(["sending", "released"]) }).strict(),
+  z.object({
+    i: z.number().int().nonnegative(),
+    o: TelegramBroadcastOutcomeSchema,
+    r: z.string().max(64).optional()
+  }).strict()
+]);
+var NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function assertBroadcastName(name) {
+  if (!NAME.test(name)) {
+    throw new TypeError("Telegram broadcast name must be 1–128 of [A-Za-z0-9._-] and start with a letter or digit");
+  }
 }
-function toHex(buffer) {
-  return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+var absent = (error) => error instanceof Error && ("code" in error) && error.code === "ENOENT";
+function broadcastFiles(directory, name) {
+  return {
+    recipients: join(directory, `${name}.recipients.json`),
+    journal: join(directory, `${name}.journal.ndjson`),
+    lock: join(directory, `${name}.lock`)
+  };
 }
-function digestsEqual(a, b) {
-  if (a.length !== b.length)
-    return false;
-  let difference = 0;
-  for (let index = 0;index < a.length; index += 1) {
-    difference |= a.charCodeAt(index) ^ b.charCodeAt(index);
+async function readRecipients(files) {
+  try {
+    return RecipientsSchema.parse(JSON.parse(await readFile(files.recipients, "utf8")));
+  } catch (error) {
+    if (absent(error))
+      return null;
+    throw error;
   }
-  return difference === 0;
 }
-function optionalUser(raw, key) {
-  const encoded = raw[key];
-  if (encoded === undefined)
-    return;
-  return TelegramInitDataUserSchema.parse(JSON.parse(encoded));
+async function writeRecipients(files, recipients) {
+  const temporary = `${files.recipients}.${process.pid}.tmp`;
+  await writeFile(temporary, JSON.stringify(recipients));
+  await rename(temporary, files.recipients);
 }
-async function verifyTelegramInitData(options) {
-  if (!options.botToken)
-    throw new TypeError("botToken is required to verify initData");
-  if (options.maxAgeSeconds !== undefined && (!Number.isFinite(options.maxAgeSeconds) || options.maxAgeSeconds < 0)) {
-    throw new TypeError("maxAgeSeconds must be a non-negative finite number");
+async function readProgress(files) {
+  const progress = new Map;
+  let text;
+  try {
+    text = await readFile(files.journal, "utf8");
+  } catch (error) {
+    if (absent(error))
+      return progress;
+    throw error;
   }
-  const params = new URLSearchParams(options.initData);
-  const hash = params.get("hash");
-  if (!hash)
-    return { valid: false, reason: "missing-hash" };
-  const signed = {};
-  for (const [key, value] of params) {
-    if (key === "hash")
+  for (const raw of text.split(`
+`)) {
+    if (raw.trim() === "")
       continue;
-    signed[key] = value;
+    let line;
+    try {
+      line = JournalLineSchema.parse(JSON.parse(raw));
+    } catch {
+      continue;
+    }
+    if ("o" in line)
+      progress.set(line.i, line.o);
+    else if (line.s === "sending")
+      progress.set(line.i, "sending");
+    else
+      progress.delete(line.i);
   }
-  const dataCheckString = Object.keys(signed).sort().map((key) => `${key}=${signed[key]}`).join(`
+  return progress;
+}
+function appendJournal(files, line) {
+  return appendFile(files.journal, `${JSON.stringify(line)}
 `);
-  const secretKey = await hmacSha256(encoder.encode("WebAppData"), options.botToken);
-  const expected = toHex(await hmacSha256(secretKey, dataCheckString));
-  if (!digestsEqual(expected, hash.toLowerCase())) {
-    return { valid: false, reason: "signature-mismatch" };
-  }
-  const authDateSeconds = Number(signed.auth_date);
-  if (!Number.isSafeInteger(authDateSeconds) || authDateSeconds <= 0) {
-    return { valid: false, reason: "malformed" };
-  }
-  const nowMs = options.now?.() ?? Date.now();
-  const ageSeconds = Math.floor(nowMs / 1000) - authDateSeconds;
-  if (options.maxAgeSeconds !== undefined && ageSeconds > options.maxAgeSeconds) {
-    return { valid: false, reason: "expired", ageSeconds };
-  }
-  let user;
-  let receiver;
+}
+function alive(pid) {
   try {
-    user = optionalUser(signed, "user");
-    receiver = optionalUser(signed, "receiver");
-  } catch {
-    return { valid: false, reason: "malformed" };
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
   }
-  return {
-    valid: true,
-    data: {
-      ...user !== undefined && { user },
-      ...receiver !== undefined && { receiver },
-      authDate: new Date(authDateSeconds * 1000),
-      ageSeconds,
-      ...signed.query_id !== undefined && { queryId: signed.query_id },
-      ...signed.start_param !== undefined && { startParam: signed.start_param },
-      ...signed.chat_type !== undefined && { chatType: signed.chat_type },
-      ...signed.chat_instance !== undefined && { chatInstance: signed.chat_instance },
-      raw: Object.freeze({ ...signed })
+}
+async function lockBroadcast(directory, files) {
+  await mkdir(directory, { recursive: true });
+  for (let attempt = 0;attempt < 2; attempt += 1) {
+    try {
+      const handle = await open(files.lock, "wx");
+      await handle.writeFile(String(process.pid));
+      await handle.close();
+      return () => rm(files.lock, { force: true });
+    } catch (error) {
+      if (!(error instanceof Error && ("code" in error) && error.code === "EEXIST"))
+        throw error;
+      const owner = Number.parseInt(await readFile(files.lock, "utf8").catch(() => ""), 10);
+      if (Number.isInteger(owner) && owner > 0 && alive(owner)) {
+        throw new Error("Telegram broadcast is already running in another process");
+      }
+      await rm(files.lock, { force: true });
     }
-  };
+  }
+  throw new Error("Telegram broadcast lock could not be taken");
 }
+
 // src/telegram/send-failure.ts
 var BY_DESCRIPTION = [
   [/bot was blocked by the user|bot was kicked/i, "blocked-by-user"],
@@ -218,7 +290,527 @@ function classifyTelegramSendFailure(error) {
     evidence: "none"
   };
 }
+
+// src/telegram/broadcast.ts
+function pause(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function tally(name, total, progress, outcome, halt) {
+  const counts = { delivered: 0, unreachable: 0, failed: 0, uncertain: 0 };
+  for (const state of progress.values())
+    if (state !== "sending")
+      counts[state] += 1;
+  return {
+    name,
+    outcome,
+    total,
+    ...counts,
+    pending: total - progress.size,
+    ...halt && { halt }
+  };
+}
+async function audience(config) {
+  const seen = new Set;
+  const list = [];
+  for await (const recipient of await config.recipients()) {
+    const key = `${typeof recipient}:${recipient}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    list.push(recipient);
+  }
+  return list;
+}
+async function runTelegramBroadcast(config) {
+  assertBroadcastName(config.name);
+  const files = broadcastFiles(config.directory, config.name);
+  const intervalMs = 1000 / (config.ratePerSecond ?? 25);
+  const maxAttempts = config.maxAttempts ?? 5;
+  const sleep = config.sleep ?? pause;
+  const now = config.now ?? Date.now;
+  let recipients = [];
+  let progress = new Map;
+  const report = (outcome, halt) => tally(config.name, recipients.length, progress, outcome, halt);
+  if (config.dryRun) {
+    recipients = await readRecipients(files) ?? await audience(config);
+    progress = await readProgress(files);
+    return report("dry-run");
+  }
+  const unlock = await lockBroadcast(config.directory, files);
+  try {
+    const snapshot = await readRecipients(files);
+    if (snapshot)
+      recipients = snapshot;
+    else {
+      recipients = await audience(config);
+      await writeRecipients(files, recipients);
+    }
+    progress = await readProgress(files);
+    for (const [index, state] of progress) {
+      if (state !== "sending")
+        continue;
+      await appendJournal(files, { i: index, o: "uncertain" });
+      progress.set(index, "uncertain");
+    }
+    const emit = (value) => {
+      try {
+        config.onProgress?.(value);
+      } catch {}
+      return value;
+    };
+    emit(report("running"));
+    let lastProgressAt = now();
+    let lastSendAt = Number.NEGATIVE_INFINITY;
+    let halted;
+    const halt = (failure) => {
+      halted = failure;
+      return "halt";
+    };
+    const deliver = async (recipient) => {
+      for (let attempt = 1;; attempt += 1) {
+        const wait = lastSendAt + intervalMs - now();
+        if (wait > 0)
+          await sleep(wait);
+        lastSendAt = now();
+        try {
+          await config.send({ recipient, attempt });
+          return { outcome: "delivered" };
+        } catch (error) {
+          const failure = classifyTelegramSendFailure(error);
+          if (failure.recipientUnreachable)
+            return { outcome: "unreachable", reason: failure.reason };
+          if (failure.reason === "message-invalid")
+            return halt(failure);
+          const transport = failure.reason === "unknown" && failure.status === undefined;
+          if (!failure.retryable && !transport)
+            return { outcome: "failed", reason: failure.reason };
+          if (attempt >= maxAttempts) {
+            return transport ? halt(failure) : { outcome: "failed", reason: failure.reason };
+          }
+          await sleep(failure.retryAfterSeconds !== undefined ? failure.retryAfterSeconds * 1000 : Math.min(60000, 1000 * 2 ** (attempt - 1)));
+        }
+      }
+    };
+    for (let index = 0;index < recipients.length; index += 1) {
+      if (progress.has(index))
+        continue;
+      if (config.signal?.aborted)
+        return emit(report("stopped"));
+      const recipient = recipients[index];
+      if (recipient === undefined)
+        continue;
+      await appendJournal(files, { i: index, s: "sending" });
+      const result = await deliver(recipient);
+      if (result === "halt") {
+        await appendJournal(files, { i: index, s: "released" });
+        return emit(report("halted", halted));
+      }
+      await appendJournal(files, {
+        i: index,
+        o: result.outcome,
+        ...result.reason && { r: result.reason }
+      });
+      progress.set(index, result.outcome);
+      if (now() - lastProgressAt >= (config.progressEveryMs ?? 1e4)) {
+        lastProgressAt = now();
+        emit(report("running"));
+      }
+    }
+    return emit(report("finished"));
+  } finally {
+    await unlock();
+  }
+}
+function telegramBroadcastSender(config) {
+  const message = config.message;
+  return ({ recipient }) => callTelegramBotApi({
+    token: config.token,
+    ..."copyFrom" in message ? {
+      method: "copyMessage",
+      params: {
+        chat_id: recipient,
+        from_chat_id: message.copyFrom.chatId,
+        message_id: message.copyFrom.messageId
+      }
+    } : {
+      method: "sendMessage",
+      params: {
+        chat_id: recipient,
+        text: message.text,
+        ...message.parseMode && { parse_mode: message.parseMode }
+      }
+    },
+    ...config.apiRoot && { apiRoot: config.apiRoot },
+    ...config.fetch && { fetch: config.fetch }
+  });
+}
+// src/telegram/init-data.ts
+import { z as z2 } from "zod";
+var TelegramInitDataUserSchema = z2.object({
+  id: z2.int(),
+  is_bot: z2.boolean().optional(),
+  first_name: z2.string(),
+  last_name: z2.string().optional(),
+  username: z2.string().optional(),
+  language_code: z2.string().optional(),
+  is_premium: z2.boolean().optional(),
+  allows_write_to_pm: z2.boolean().optional(),
+  photo_url: z2.string().optional()
+}).transform((user) => ({
+  id: user.id,
+  firstName: user.first_name,
+  ...user.is_bot !== undefined && { isBot: user.is_bot },
+  ...user.last_name !== undefined && { lastName: user.last_name },
+  ...user.username !== undefined && { username: user.username },
+  ...user.language_code !== undefined && { languageCode: user.language_code },
+  ...user.is_premium !== undefined && { isPremium: user.is_premium },
+  ...user.allows_write_to_pm !== undefined && { allowsWriteToPm: user.allows_write_to_pm },
+  ...user.photo_url !== undefined && { photoUrl: user.photo_url }
+}));
+var encoder = new TextEncoder;
+async function hmacSha256(key, message) {
+  const imported = await crypto.subtle.importKey("raw", key, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return crypto.subtle.sign("HMAC", imported, encoder.encode(message));
+}
+function toHex(buffer) {
+  return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function digestsEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let difference = 0;
+  for (let index = 0;index < a.length; index += 1) {
+    difference |= a.charCodeAt(index) ^ b.charCodeAt(index);
+  }
+  return difference === 0;
+}
+function optionalUser(raw, key) {
+  const encoded = raw[key];
+  if (encoded === undefined)
+    return;
+  return TelegramInitDataUserSchema.parse(JSON.parse(encoded));
+}
+async function verifyTelegramInitData(options) {
+  if (!options.botToken)
+    throw new TypeError("botToken is required to verify initData");
+  if (options.maxAgeSeconds !== undefined && (!Number.isFinite(options.maxAgeSeconds) || options.maxAgeSeconds < 0)) {
+    throw new TypeError("maxAgeSeconds must be a non-negative finite number");
+  }
+  const params = new URLSearchParams(options.initData);
+  const hash = params.get("hash");
+  if (!hash)
+    return { valid: false, reason: "missing-hash" };
+  const signed = {};
+  for (const [key, value] of params) {
+    if (key === "hash")
+      continue;
+    signed[key] = value;
+  }
+  const dataCheckString = Object.keys(signed).sort().map((key) => `${key}=${signed[key]}`).join(`
+`);
+  const secretKey = await hmacSha256(encoder.encode("WebAppData"), options.botToken);
+  const expected = toHex(await hmacSha256(secretKey, dataCheckString));
+  if (!digestsEqual(expected, hash.toLowerCase())) {
+    return { valid: false, reason: "signature-mismatch" };
+  }
+  const authDateSeconds = Number(signed.auth_date);
+  if (!Number.isSafeInteger(authDateSeconds) || authDateSeconds <= 0) {
+    return { valid: false, reason: "malformed" };
+  }
+  const nowMs = options.now?.() ?? Date.now();
+  const ageSeconds = Math.floor(nowMs / 1000) - authDateSeconds;
+  if (options.maxAgeSeconds !== undefined && ageSeconds > options.maxAgeSeconds) {
+    return { valid: false, reason: "expired", ageSeconds };
+  }
+  let user;
+  let receiver;
+  try {
+    user = optionalUser(signed, "user");
+    receiver = optionalUser(signed, "receiver");
+  } catch {
+    return { valid: false, reason: "malformed" };
+  }
+  return {
+    valid: true,
+    data: {
+      ...user !== undefined && { user },
+      ...receiver !== undefined && { receiver },
+      authDate: new Date(authDateSeconds * 1000),
+      ageSeconds,
+      ...signed.query_id !== undefined && { queryId: signed.query_id },
+      ...signed.start_param !== undefined && { startParam: signed.start_param },
+      ...signed.chat_type !== undefined && { chatType: signed.chat_type },
+      ...signed.chat_instance !== undefined && { chatInstance: signed.chat_instance },
+      raw: Object.freeze({ ...signed })
+    }
+  };
+}
+// src/telegram/local-files.ts
+import { constants } from "node:fs";
+import { access, lstat, realpath, stat, unlink } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+
+class TelegramLocalFileError extends Error {
+  reason;
+  constructor(reason) {
+    super(`Telegram local file refused: ${reason}`);
+    this.name = "TelegramLocalFileError";
+    this.reason = reason;
+  }
+}
+var absent2 = (error) => error instanceof Error && ("code" in error) && (error.code === "ENOENT" || error.code === "ENOTDIR");
+function inside(directory, candidate) {
+  const path = relative(directory, candidate);
+  return path !== "" && !path.startsWith(`..${sep}`) && path !== ".." && !isAbsolute(path);
+}
+function createTelegramLocalFiles(config) {
+  const rootIsAbsolute = isAbsolute(config.root);
+  const botDirectory = resolve(config.root, config.token);
+  const realBotDirectory = async () => {
+    if (!rootIsAbsolute)
+      throw new TelegramLocalFileError("root-not-absolute");
+    try {
+      return await realpath(botDirectory);
+    } catch (error) {
+      if (absent2(error))
+        throw new TelegramLocalFileError("bot-directory-unavailable");
+      throw error;
+    }
+  };
+  const locate = async (filePath) => {
+    const directory = await realBotDirectory();
+    const lexical = isAbsolute(filePath) ? resolve(filePath) : resolve(botDirectory, filePath);
+    if (!inside(botDirectory, lexical) && !inside(directory, lexical)) {
+      throw new TelegramLocalFileError("outside-bot-directory");
+    }
+    let real;
+    try {
+      real = await realpath(lexical);
+    } catch (error) {
+      if (absent2(error))
+        throw new TelegramLocalFileError("missing");
+      throw error;
+    }
+    if (!inside(directory, real))
+      throw new TelegramLocalFileError("outside-bot-directory");
+    return real;
+  };
+  return {
+    async resolve(filePath) {
+      const path = await locate(filePath);
+      const info = await stat(path);
+      if (!info.isFile())
+        throw new TelegramLocalFileError("not-a-file");
+      return path;
+    },
+    async remove(filePath) {
+      let path;
+      try {
+        path = await locate(filePath);
+      } catch (error) {
+        if (error instanceof TelegramLocalFileError && error.reason === "missing")
+          return;
+        throw error;
+      }
+      if (!(await lstat(path)).isFile())
+        throw new TelegramLocalFileError("not-a-file");
+      try {
+        await unlink(path);
+      } catch (error) {
+        if (!absent2(error))
+          throw error;
+      }
+    },
+    async check() {
+      try {
+        const directory = await realBotDirectory();
+        await access(directory, constants.R_OK | constants.W_OK | constants.X_OK);
+        return { ready: true };
+      } catch (error) {
+        if (error instanceof TelegramLocalFileError)
+          return { ready: false, reason: error.reason };
+        return { ready: false, reason: "bot-directory-unavailable" };
+      }
+    }
+  };
+}
+// src/telegram/operator-channel.ts
+var TEXT_LIMIT = 4096;
+function timer(milliseconds, signal) {
+  return new Promise((resolve2, reject) => {
+    if (signal.aborted)
+      return reject(signal.reason);
+    const handle = setTimeout(() => {
+      signal.removeEventListener("abort", stop);
+      resolve2();
+    }, milliseconds);
+    const stop = () => {
+      clearTimeout(handle);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", stop, { once: true });
+  });
+}
+function fitted(text) {
+  const points = Array.from(text);
+  return points.length <= TEXT_LIMIT ? text : `${points.slice(0, TEXT_LIMIT - 1).join("")}…`;
+}
+function createTelegramOperatorChannel(config) {
+  const maxQueued = config.maxQueued ?? 200;
+  const minIntervalMs = config.minIntervalMs ?? 3000;
+  const maxAttempts = config.maxAttempts ?? 3;
+  const sleep = config.sleep ?? timer;
+  const queue = [];
+  const idle = new Set;
+  let lifetime = new AbortController;
+  let running = false;
+  let closed = false;
+  let inFlight = 0;
+  const drop = (item, reason, failure) => {
+    try {
+      config.onDropped?.({
+        ...item.topic !== undefined && { topic: item.topic },
+        text: item.text,
+        reason,
+        ...failure && { failure }
+      });
+    } catch {}
+  };
+  const settleIdle = () => {
+    if (queue.length > 0 || inFlight > 0)
+      return;
+    for (const waiter of idle)
+      waiter();
+    idle.clear();
+  };
+  const attempt = async (item, signal) => {
+    item.attempts += 1;
+    const threadId = item.topic === undefined ? undefined : config.topics?.[item.topic];
+    try {
+      await config.send({
+        chatId: config.chatId,
+        ...threadId !== undefined && { threadId },
+        text: fitted(item.text)
+      }, signal);
+      return;
+    } catch (error) {
+      if (signal.aborted)
+        throw error;
+      const failure = classifyTelegramSendFailure(error);
+      if (!failure.retryable) {
+        drop(item, "refused", failure);
+        return;
+      }
+      if (item.attempts >= maxAttempts) {
+        drop(item, "attempts", failure);
+        return;
+      }
+      return Math.max(minIntervalMs, (failure.retryAfterSeconds ?? 0) * 1000);
+    }
+  };
+  const run = async (signal) => {
+    let current;
+    try {
+      for (let item = queue[0];item; item = queue[0]) {
+        current = item;
+        inFlight = 1;
+        queue.shift();
+        let retryIn = await attempt(item, signal);
+        while (retryIn !== undefined) {
+          await sleep(retryIn, signal);
+          retryIn = await attempt(item, signal);
+        }
+        current = undefined;
+        inFlight = 0;
+        settleIdle();
+        if (queue.length > 0)
+          await sleep(minIntervalMs, signal);
+      }
+    } catch {
+      if (current)
+        drop(current, "closed");
+    } finally {
+      inFlight = 0;
+      running = false;
+      settleIdle();
+    }
+  };
+  return {
+    post(text, topic) {
+      try {
+        const item = {
+          ...topic !== undefined && { topic },
+          text,
+          attempts: 0
+        };
+        if (closed) {
+          drop(item, "closed");
+          return;
+        }
+        queue.push(item);
+        while (queue.length > maxQueued) {
+          const oldest = queue.shift();
+          if (oldest)
+            drop(oldest, "overflow");
+        }
+        if (!running) {
+          running = true;
+          run(lifetime.signal);
+        }
+      } catch {}
+    },
+    get pending() {
+      return queue.length + inFlight;
+    },
+    drain(signal) {
+      if (queue.length === 0 && inFlight === 0)
+        return Promise.resolve();
+      return new Promise((resolve2) => {
+        const done = () => {
+          signal?.removeEventListener("abort", done);
+          idle.delete(done);
+          resolve2();
+        };
+        idle.add(done);
+        signal?.addEventListener("abort", done, { once: true });
+      });
+    },
+    close() {
+      closed = true;
+      lifetime.abort(new DOMException("Operator channel closed", "AbortError"));
+      lifetime = new AbortController;
+      for (const item of queue.splice(0))
+        drop(item, "closed");
+      settleIdle();
+    }
+  };
+}
+function telegramOperatorSender(config) {
+  return (message, signal) => callTelegramBotApi({
+    token: config.token,
+    method: "sendMessage",
+    params: {
+      chat_id: message.chatId,
+      text: message.text,
+      ...message.threadId !== undefined && { message_thread_id: message.threadId },
+      ...config.parseMode && { parse_mode: config.parseMode },
+      link_preview_options: { is_disabled: true }
+    },
+    signal,
+    ...config.apiRoot && { apiRoot: config.apiRoot },
+    ...config.fetch && { fetch: config.fetch }
+  });
+}
 export {
   verifyTelegramInitData,
-  classifyTelegramSendFailure
+  telegramOperatorSender,
+  telegramBroadcastSender,
+  runTelegramBroadcast,
+  createTelegramOperatorChannel,
+  createTelegramLocalFiles,
+  classifyTelegramSendFailure,
+  callTelegramBotApi,
+  TelegramLocalFileError,
+  TelegramBotApiError,
+  TELEGRAM_BOT_TOKEN_PATTERN
 };