spectrum-ts 4.2.0 → 5.1.0

package/dist/chunk-N6THJDZV.js

@@ -1,929 +0,0 @@
-import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-import {
-  fusor
-} from "./chunk-34FQGGD7.js";
-import {
-  asVoice
-} from "./chunk-FAIFTUV2.js";
-import {
-  asGroup
-} from "./chunk-LZXPLXZF.js";
-import {
-  toVCard
-} from "./chunk-6UZFVXQF.js";
-import {
-  UnsupportedError,
-  asMarkdown,
-  definePlatform,
-  renderInlineTokens
-} from "./chunk-B52VPQO3.js";
-import {
-  asAttachment,
-  asCustom,
-  asReaction,
-  asText
-} from "./chunk-UXAKIXVM.js";
-
-// src/providers/telegram/config.ts
-import z from "zod";
-var TELEGRAM_PLATFORM = "telegram";
-var DEFAULT_BASE_URL = "https://api.telegram.org";
-var SECRET_TOKEN_PATTERN = /^[A-Za-z0-9_-]{1,256}$/;
-var BOT_TOKEN_PATTERN = /^\d+:[A-Za-z0-9_-]+$/;
-var configSchema = z.object({
-  /** Bot token from @BotFather (outbound API calls + media downloads). */
-  botToken: z.string().regex(BOT_TOKEN_PATTERN, "botToken must be in the form '<id>:<token>'"),
-  /**
-   * The `secret_token` passed to `setWebhook`. When present, inbound webhooks
-   * are verified against the `X-Telegram-Bot-Api-Secret-Token` header; when
-   * omitted, the check is skipped. Telegram does not HMAC-sign the body, so
-   * this shared token is the only inbound authentication.
-   */
-  webhookSecret: z.string().regex(SECRET_TOKEN_PATTERN).optional(),
-  /** Override the Bot API base URL. Defaults to `https://api.telegram.org`. */
-  baseUrl: z.url().default(DEFAULT_BASE_URL)
-});
-var botIdFromToken = (botToken) => botToken.split(":")[0] ?? "";
-
-// src/providers/telegram/client.ts
-import { createTelegramClient, getFile } from "@photon-ai/telegram-ts";
-var REQUEST_TIMEOUT_MS = 3e4;
-var TRAILING_SLASHES = /\/+$/;
-var telegramClient = (config) => createTelegramClient({ token: config.botToken, baseUrl: config.baseUrl });
-var appendFormValue = (form, key, value) => {
-  if (typeof value === "string" || value instanceof Blob) {
-    form.append(key, value);
-  } else if (value instanceof Date) {
-    form.append(key, value.toISOString());
-  } else {
-    form.append(key, JSON.stringify(value));
-  }
-};
-var toFormData = (body) => {
-  const form = new FormData();
-  for (const [key, value] of Object.entries(body)) {
-    if (value === void 0 || value === null) {
-      continue;
-    }
-    appendFormValue(form, key, value);
-  }
-  return form;
-};
-var executeSpec = async (client, spec) => {
-  const url = `/${spec.method}`;
-  if (spec.file) {
-    const file = new File(
-      [new Uint8Array(spec.file.bytes)],
-      spec.file.filename,
-      { type: spec.file.mimeType }
-    );
-    const res2 = await client.post({
-      body: { ...spec.params, [spec.file.field]: file },
-      bodySerializer: toFormData,
-      headers: { "Content-Type": null },
-      throwOnError: true,
-      url
-    });
-    return res2.data.result;
-  }
-  const res = await client.post({ body: spec.params, throwOnError: true, url });
-  return res.data.result;
-};
-var downloadFile = async (config, fileId) => {
-  const client = telegramClient(config);
-  const meta = await getFile({
-    body: { file_id: fileId },
-    client,
-    throwOnError: true
-  });
-  const filePath = meta.result?.file_path;
-  if (!filePath) {
-    throw new Error(`Telegram getFile returned no file_path for ${fileId}`);
-  }
-  const base = config.baseUrl.replace(TRAILING_SLASHES, "");
-  const res = await fetch(`${base}/file/bot${config.botToken}/${filePath}`, {
-    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-  });
-  if (!res.ok) {
-    throw new Error(
-      `Telegram media download failed: ${res.status} ${res.statusText}`
-    );
-  }
-  return Buffer.from(await res.arrayBuffer());
-};
-
-// src/providers/telegram/inbound/media.ts
-var DEFAULT_VIDEO_MIME = "video/mp4";
-var DEFAULT_AUDIO_MIME = "audio/mpeg";
-var DEFAULT_VOICE_MIME = "audio/ogg";
-var DEFAULT_DOC_MIME = "application/octet-stream";
-var pixelArea = (photo) => photo.file_size ?? photo.width * photo.height;
-var pickLargestPhoto = (photos) => photos.reduce(
-  (best, next) => pixelArea(next) > pixelArea(best) ? next : best
-);
-var lazyRead = (config, fileId) => () => downloadFile(config, fileId);
-var fileAttachment = (config, file, fallbackExt, fallbackMime) => asAttachment({
-  id: file.file_id,
-  name: file.file_name ?? `${file.file_unique_id}.${fallbackExt}`,
-  mimeType: file.mime_type ?? fallbackMime,
-  size: file.file_size,
-  read: lazyRead(config, file.file_id)
-});
-var stickerAttachment = (config, sticker) => {
-  let ext = "webp";
-  let mimeType = "image/webp";
-  if (sticker.is_animated) {
-    ext = "tgs";
-    mimeType = "application/x-tgsticker";
-  } else if (sticker.is_video) {
-    ext = "webm";
-    mimeType = "video/webm";
-  }
-  return asAttachment({
-    id: sticker.file_id,
-    name: `${sticker.file_unique_id}.${ext}`,
-    mimeType,
-    size: sticker.file_size,
-    read: lazyRead(config, sticker.file_id)
-  });
-};
-var mediaToContent = (msg, config) => {
-  if (msg.voice) {
-    return asVoice({
-      mimeType: msg.voice.mime_type ?? DEFAULT_VOICE_MIME,
-      duration: msg.voice.duration,
-      size: msg.voice.file_size,
-      read: lazyRead(config, msg.voice.file_id)
-    });
-  }
-  if (msg.video_note) {
-    return fileAttachment(config, msg.video_note, "mp4", DEFAULT_VIDEO_MIME);
-  }
-  if (msg.animation) {
-    return fileAttachment(config, msg.animation, "mp4", DEFAULT_VIDEO_MIME);
-  }
-  if (msg.video) {
-    return fileAttachment(config, msg.video, "mp4", DEFAULT_VIDEO_MIME);
-  }
-  if (msg.audio) {
-    return fileAttachment(config, msg.audio, "mp3", DEFAULT_AUDIO_MIME);
-  }
-  if (msg.document) {
-    return fileAttachment(config, msg.document, "bin", DEFAULT_DOC_MIME);
-  }
-  if (msg.photo && msg.photo.length > 0) {
-    return fileAttachment(
-      config,
-      pickLargestPhoto(msg.photo),
-      "jpg",
-      "image/jpeg"
-    );
-  }
-  if (msg.sticker) {
-    return stickerAttachment(config, msg.sticker);
-  }
-  return;
-};
-var messageToContent = (msg, config) => {
-  const media = mediaToContent(msg, config);
-  if (media) {
-    const caption = msg.caption?.trim();
-    return caption ? [asText(caption), media] : [media];
-  }
-  const text = msg.text;
-  if (text !== void 0 && text.length > 0) {
-    return [asText(text)];
-  }
-  return [];
-};
-
-// src/providers/telegram/inbound/messages.ts
-var MILLIS_PER_SECOND = 1e3;
-var stubMessage = (id, content) => ({ id, content });
-var senderRef = (user) => ({
-  id: String(user.id),
-  ...user.username ? { handle: user.username } : {},
-  isMe: false
-});
-var toRecordContent = (contents, messageId) => {
-  if (contents.length === 0) {
-    return;
-  }
-  if (contents.length === 1) {
-    return contents[0];
-  }
-  return asGroup({
-    items: contents.map(
-      (content, index) => stubMessage(`${messageId}:${index}`, content)
-    )
-  });
-};
-var fromMessage = (msg, config) => {
-  if (msg.from && String(msg.from.id) === botIdFromToken(config.botToken)) {
-    return;
-  }
-  const content = toRecordContent(
-    messageToContent(msg, config),
-    String(msg.message_id)
-  );
-  if (!content) {
-    return;
-  }
-  return {
-    id: String(msg.message_id),
-    content,
-    ...msg.from ? { sender: senderRef(msg.from) } : {},
-    space: { id: String(msg.chat.id) },
-    timestamp: new Date(msg.date * MILLIS_PER_SECOND)
-  };
-};
-var emojiReactions = (reactions) => reactions.filter((r) => r.type === "emoji").map((r) => r.emoji);
-var fromReaction = (reaction) => {
-  const added = emojiReactions(reaction.new_reaction);
-  if (added.length === 0) {
-    return;
-  }
-  const previous = new Set(emojiReactions(reaction.old_reaction));
-  const emoji = added.find((e) => !previous.has(e)) ?? added[0];
-  if (!emoji) {
-    return;
-  }
-  const target = stubMessage(
-    String(reaction.message_id),
-    asCustom({ telegram: "reaction-target" })
-  );
-  const actorId = reaction.user ? String(reaction.user.id) : "anonymous";
-  return {
-    id: `reaction:${reaction.chat.id}:${reaction.message_id}:${reaction.date}:${actorId}:${emoji}`,
-    content: asReaction({ emoji, target }),
-    ...reaction.user ? { sender: senderRef(reaction.user) } : {},
-    space: { id: String(reaction.chat.id) },
-    timestamp: new Date(reaction.date * MILLIS_PER_SECOND)
-  };
-};
-var handleMessages = ({
-  payload: update,
-  config
-}) => {
-  const message = update.message ?? update.channel_post;
-  if (message) {
-    return fromMessage(message, config);
-  }
-  if (update.message_reaction) {
-    return fromReaction(update.message_reaction);
-  }
-  return;
-};
-
-// src/providers/telegram/outbound/send.ts
-import {
-  editMessageText,
-  sendChatAction,
-  setMessageReaction
-} from "@photon-ai/telegram-ts";
-
-// src/providers/telegram/reactions.ts
-var ALLOWED_REACTION_EMOJI = /* @__PURE__ */ new Set([
-  "\u{1F44D}",
-  "\u{1F44E}",
-  "\u2764",
-  "\u{1F525}",
-  "\u{1F970}",
-  "\u{1F44F}",
-  "\u{1F601}",
-  "\u{1F914}",
-  "\u{1F92F}",
-  "\u{1F631}",
-  "\u{1F92C}",
-  "\u{1F622}",
-  "\u{1F389}",
-  "\u{1F929}",
-  "\u{1F92E}",
-  "\u{1F4A9}",
-  "\u{1F64F}",
-  "\u{1F44C}",
-  "\u{1F54A}",
-  "\u{1F921}",
-  "\u{1F971}",
-  "\u{1F974}",
-  "\u{1F60D}",
-  "\u{1F433}",
-  "\u2764\u200D\u{1F525}",
-  "\u{1F31A}",
-  "\u{1F32D}",
-  "\u{1F4AF}",
-  "\u{1F923}",
-  "\u26A1",
-  "\u{1F34C}",
-  "\u{1F3C6}",
-  "\u{1F494}",
-  "\u{1F928}",
-  "\u{1F610}",
-  "\u{1F353}",
-  "\u{1F37E}",
-  "\u{1F48B}",
-  "\u{1F595}",
-  "\u{1F608}",
-  "\u{1F634}",
-  "\u{1F62D}",
-  "\u{1F913}",
-  "\u{1F47B}",
-  "\u{1F468}\u200D\u{1F4BB}",
-  "\u{1F440}",
-  "\u{1F383}",
-  "\u{1F648}",
-  "\u{1F607}",
-  "\u{1F628}",
-  "\u{1F91D}",
-  "\u270D",
-  "\u{1F917}",
-  "\u{1FAE1}",
-  "\u{1F385}",
-  "\u{1F384}",
-  "\u2603",
-  "\u{1F485}",
-  "\u{1F92A}",
-  "\u{1F5FF}",
-  "\u{1F192}",
-  "\u{1F498}",
-  "\u{1F649}",
-  "\u{1F984}",
-  "\u{1F618}",
-  "\u{1F48A}",
-  "\u{1F64A}",
-  "\u{1F60E}",
-  "\u{1F47E}",
-  "\u{1F937}\u200D\u2642",
-  "\u{1F937}",
-  "\u{1F937}\u200D\u2640",
-  "\u{1F621}"
-]);
-var VARIATION_SELECTOR_16 = /️/g;
-var stripVariationSelector = (emoji) => emoji.replace(VARIATION_SELECTOR_16, "");
-var isAllowedReactionEmoji = (emoji) => ALLOWED_REACTION_EMOJI.has(stripVariationSelector(emoji));
-var normalizeReactionEmoji = (emoji) => isAllowedReactionEmoji(emoji) ? stripVariationSelector(emoji) : emoji;
-
-// src/providers/telegram/outbound/markdown.ts
-import { Marked } from "marked";
-var markdownLexer = new Marked();
-var BULLET = "\u2022 ";
-var HR_LINE = "\u2014\u2014\u2014";
-var NESTED_LIST_INDENT = "  ";
-var BLOCK_SEPARATOR = "\n\n";
-var TABLE_CELL_SEPARATOR = " | ";
-var DEFAULT_LIST_START = 1;
-var AMP_PATTERN = /&/g;
-var LT_PATTERN = /</g;
-var GT_PATTERN = />/g;
-var QUOTE_PATTERN = /"/g;
-var escapeHtml = (value) => value.replace(AMP_PATTERN, "&amp;").replace(LT_PATTERN, "&lt;").replace(GT_PATTERN, "&gt;");
-var escapeAttribute = (value) => escapeHtml(value).replace(QUOTE_PATTERN, "&quot;");
-var asMarkedToken = (token) => token;
-var checkboxPrefix = (item) => {
-  if (!item.task) {
-    return "";
-  }
-  return item.checked ? "[x] " : "[ ] ";
-};
-var listMarker = (list, index) => {
-  if (!list.ordered) {
-    return BULLET;
-  }
-  const start = list.start === "" ? DEFAULT_LIST_START : list.start;
-  return `${start + index}. `;
-};
-var renderLink = (token) => {
-  if (token.text === token.href) {
-    return escapeHtml(token.href);
-  }
-  return `<a href="${escapeAttribute(token.href)}">${renderInlineTokens2(token.tokens)}</a>`;
-};
-var renderImage = (token) => `<a href="${escapeAttribute(token.href)}">${escapeHtml(token.text || token.href)}</a>`;
-var renderText = (token) => {
-  if (token.tokens) {
-    return renderInlineTokens2(token.tokens);
-  }
-  return token.escaped ? token.text : escapeHtml(token.text);
-};
-var renderInlineToken = (token) => {
-  switch (token.type) {
-    case "strong":
-      return `<b>${renderInlineTokens2(token.tokens)}</b>`;
-    case "em":
-      return `<i>${renderInlineTokens2(token.tokens)}</i>`;
-    case "del":
-      return `<s>${renderInlineTokens2(token.tokens)}</s>`;
-    case "codespan":
-      return `<code>${escapeHtml(token.text)}</code>`;
-    case "br":
-      return "\n";
-    case "link":
-      return renderLink(token);
-    case "image":
-      return renderImage(token);
-    case "escape":
-      return escapeHtml(token.text);
-    case "text":
-      return renderText(token);
-    // Raw HTML in markdown source renders literally, never passes through:
-    // a tag outside Telegram's whitelist would 400 the whole Bot API call
-    // (a TelegramApiError, not UnsupportedError — the plain-text fallback
-    // would not catch it). Escaping makes invalid output impossible.
-    case "html":
-      return escapeHtml(token.text);
-    // Task-item checkboxes are rendered from `ListItem.task`/`checked`.
-    case "checkbox":
-      return "";
-    default:
-      return "raw" in token ? escapeHtml(String(token.raw)) : "";
-  }
-};
-var renderInlineTokens2 = (tokens) => {
-  let out = "";
-  for (const token of tokens) {
-    out += renderInlineToken(asMarkedToken(token));
-  }
-  return out;
-};
-var renderCode = (token) => {
-  if (token.lang) {
-    return `<pre><code class="language-${escapeAttribute(token.lang)}">${escapeHtml(token.text)}</code></pre>`;
-  }
-  return `<pre>${escapeHtml(token.text)}</pre>`;
-};
-var renderQuoteBody = (tokens) => {
-  const blocks = [];
-  for (const token of tokens) {
-    const marked = asMarkedToken(token);
-    const rendered = marked.type === "blockquote" ? renderQuoteBody(marked.tokens) : renderBlockToken(marked);
-    if (rendered) {
-      blocks.push(rendered);
-    }
-  }
-  return blocks.join("\n");
-};
-var renderList = (list) => {
-  const lines = [];
-  for (const [index, item] of list.items.entries()) {
-    const prefix = `${listMarker(list, index)}${checkboxPrefix(item)}`;
-    const blocks = [];
-    for (const token of item.tokens) {
-      const rendered = renderBlockToken(asMarkedToken(token));
-      if (rendered) {
-        blocks.push(rendered);
-      }
-    }
-    const [first = "", ...rest] = blocks.join("\n").split("\n");
-    lines.push(`${prefix}${first}`);
-    for (const line of rest) {
-      lines.push(`${NESTED_LIST_INDENT}${line}`);
-    }
-  }
-  return lines.join("\n");
-};
-var renderTable = (table) => {
-  const renderRow = (cells) => cells.map((cell) => renderInlineTokens(cell.tokens)).join(TABLE_CELL_SEPARATOR);
-  const lines = [renderRow(table.header)];
-  for (const row of table.rows) {
-    lines.push(renderRow(row));
-  }
-  return `<pre>${escapeHtml(lines.join("\n"))}</pre>`;
-};
-var renderBlockToken = (token) => {
-  switch (token.type) {
-    // Telegram has no headings; bold is the conventional stand-in.
-    case "heading":
-      return `<b>${renderInlineTokens2(token.tokens)}</b>`;
-    case "paragraph":
-      return renderInlineTokens2(token.tokens);
-    case "code":
-      return renderCode(token);
-    case "blockquote":
-      return `<blockquote>${renderQuoteBody(token.tokens)}</blockquote>`;
-    case "list":
-      return renderList(token);
-    case "table":
-      return renderTable(token);
-    case "hr":
-      return HR_LINE;
-    case "space":
-    case "def":
-      return "";
-    default:
-      return renderInlineToken(token);
-  }
-};
-var markdownToTelegramHtml = (markdown) => {
-  const blocks = [];
-  for (const token of markdownLexer.lexer(markdown)) {
-    const rendered = renderBlockToken(asMarkedToken(token));
-    if (rendered) {
-      blocks.push(rendered);
-    }
-  }
-  return blocks.join(BLOCK_SEPARATOR).trim();
-};
-
-// src/providers/telegram/outbound/message.ts
-var VCARD_FILENAME = "contact.vcf";
-var VCARD_MIME = "text/vcard";
-var DEFAULT_VOICE_FILENAME = "voice.ogg";
-var parseMessageId = (id) => {
-  const messageId = Number(id);
-  if (!Number.isInteger(messageId) || messageId <= 0) {
-    throw new Error(
-      `Telegram message id must be a positive integer (got "${id}").`
-    );
-  }
-  return messageId;
-};
-var customToSpec = (raw) => {
-  if (typeof raw === "object" && raw !== null && typeof raw.method === "string") {
-    const value = raw;
-    const { params } = value;
-    if (params !== void 0 && (typeof params !== "object" || params === null || Array.isArray(params))) {
-      throw new Error(
-        "Telegram custom content `raw.params` must be an object when provided."
-      );
-    }
-    return {
-      method: value.method,
-      params: params ?? {}
-    };
-  }
-  throw new Error(
-    "Telegram custom content `raw` must be a `{ method, params }` Bot API call."
-  );
-};
-var attachmentSpec = async (content) => {
-  const bytes = await content.read();
-  const file = {
-    field: "document",
-    filename: content.name,
-    mimeType: content.mimeType,
-    bytes
-  };
-  if (content.mimeType.startsWith("image/")) {
-    return {
-      method: "sendPhoto",
-      params: {},
-      file: { ...file, field: "photo" }
-    };
-  }
-  if (content.mimeType.startsWith("video/")) {
-    return {
-      method: "sendVideo",
-      params: {},
-      file: { ...file, field: "video" }
-    };
-  }
-  return { method: "sendDocument", params: {}, file };
-};
-var buildSend = async (content) => {
-  switch (content.type) {
-    case "text":
-      return { method: "sendMessage", params: { text: content.text } };
-    case "markdown":
-      return {
-        method: "sendMessage",
-        params: {
-          text: markdownToTelegramHtml(content.markdown),
-          parse_mode: "HTML"
-        }
-      };
-    case "richlink":
-      return { method: "sendMessage", params: { text: content.url } };
-    case "attachment":
-      return await attachmentSpec(content);
-    case "voice": {
-      const bytes = await content.read();
-      return {
-        method: "sendVoice",
-        params: content.duration === void 0 ? {} : { duration: content.duration },
-        file: {
-          field: "voice",
-          filename: content.name ?? DEFAULT_VOICE_FILENAME,
-          mimeType: content.mimeType,
-          bytes
-        }
-      };
-    }
-    case "contact": {
-      const vcf = await toVCard(content);
-      return {
-        method: "sendDocument",
-        params: {},
-        file: {
-          field: "document",
-          filename: VCARD_FILENAME,
-          mimeType: VCARD_MIME,
-          bytes: Buffer.from(vcf, "utf8")
-        }
-      };
-    }
-    case "reply": {
-      const inner = await buildSend(content.content);
-      return {
-        ...inner,
-        params: {
-          ...inner.params,
-          reply_parameters: { message_id: parseMessageId(content.target.id) }
-        }
-      };
-    }
-    case "custom":
-      return customToSpec(content.raw);
-    default:
-      throw UnsupportedError.content(content.type, TELEGRAM_PLATFORM);
-  }
-};
-
-// src/providers/telegram/outbound/stream-text.ts
-import { sendMessageDraft } from "@photon-ai/telegram-ts";
-var MILLIS_PER_SECOND2 = 1e3;
-var DRAFT_THROTTLE_MS = 500;
-var nextDraftId = 1;
-var sendStreamText = async (client, space, content) => {
-  const chatId = Number(space.id);
-  if (!(Number.isInteger(chatId) && chatId > 0)) {
-    throw UnsupportedError.content(
-      "streamText",
-      TELEGRAM_PLATFORM,
-      `message drafts work only in private chats (got chat id "${space.id}").`
-    );
-  }
-  const draftId = nextDraftId;
-  nextDraftId += 1;
-  const renderBody = (text) => content.format === "markdown" ? { text: markdownToTelegramHtml(text), parse_mode: "HTML" } : { text };
-  let lastDraftText;
-  let lastDraftAt = 0;
-  let draftsAvailable = true;
-  const updateDraft = async (text) => {
-    if (!draftsAvailable || text === lastDraftText) {
-      return;
-    }
-    try {
-      await sendMessageDraft({
-        body: { chat_id: chatId, draft_id: draftId, ...renderBody(text) },
-        client
-      });
-      lastDraftText = text;
-      lastDraftAt = Date.now();
-    } catch {
-      draftsAvailable = false;
-    }
-  };
-  await updateDraft("");
-  let full = "";
-  for await (const delta of content.stream()) {
-    full += delta;
-    if (Date.now() - lastDraftAt >= DRAFT_THROTTLE_MS) {
-      await updateDraft(full);
-    }
-  }
-  if (!full) {
-    throw UnsupportedError.content(
-      "streamText",
-      TELEGRAM_PLATFORM,
-      "stream produced no text \u2014 nothing to send."
-    );
-  }
-  const sent = await executeSpec(client, {
-    method: "sendMessage",
-    params: { chat_id: space.id, ...renderBody(full) }
-  });
-  return {
-    id: String(sent.message_id),
-    content: content.format === "markdown" ? asMarkdown(full) : asText(full),
-    space: { id: space.id },
-    timestamp: new Date(sent.date * MILLIS_PER_SECOND2)
-  };
-};
-
-// src/providers/telegram/outbound/send.ts
-var MILLIS_PER_SECOND3 = 1e3;
-var sendContent = async (client, space, content) => {
-  const spec = await buildSend(content);
-  const sent = await executeSpec(client, {
-    ...spec,
-    params: { chat_id: space.id, ...spec.params }
-  });
-  return {
-    id: String(sent.message_id),
-    content,
-    space: { id: space.id },
-    timestamp: new Date(sent.date * MILLIS_PER_SECOND3)
-  };
-};
-var sendGroup = async (client, space, items) => {
-  let last;
-  for (const item of items) {
-    last = await sendContent(client, space, item.content);
-  }
-  return last;
-};
-var sendReaction = async (client, space, content) => {
-  const messageId = parseMessageId(content.target.id);
-  const emoji = normalizeReactionEmoji(content.emoji);
-  if (!isAllowedReactionEmoji(emoji)) {
-    throw UnsupportedError.content(
-      "reaction",
-      TELEGRAM_PLATFORM,
-      `"${content.emoji}" is not an allowed Telegram reaction emoji.`
-    );
-  }
-  await setMessageReaction({
-    body: {
-      chat_id: space.id,
-      message_id: messageId,
-      // `emoji` is runtime-validated above; cast to photon's allowed-emoji union.
-      reaction: [{ emoji, type: "emoji" }]
-    },
-    client
-  });
-  const timestamp = /* @__PURE__ */ new Date();
-  const unixSeconds = Math.floor(timestamp.getTime() / MILLIS_PER_SECOND3);
-  return {
-    id: `reaction:${space.id}:${messageId}:${unixSeconds}:bot:${emoji}`,
-    content,
-    space: { id: space.id },
-    timestamp
-  };
-};
-var sendTyping = async (client, space, state) => {
-  if (state === "start") {
-    await sendChatAction({
-      body: { action: "typing", chat_id: space.id },
-      client
-    });
-  }
-  return;
-};
-var sendEdit = async (client, space, content) => {
-  const inner = content.content;
-  if (inner.type !== "text" && inner.type !== "markdown") {
-    throw UnsupportedError.content(
-      "edit",
-      TELEGRAM_PLATFORM,
-      `only text and markdown content can be edited (got "${inner.type}").`
-    );
-  }
-  const body = inner.type === "markdown" ? {
-    text: markdownToTelegramHtml(inner.markdown),
-    parse_mode: "HTML"
-  } : { text: inner.text };
-  await editMessageText({
-    body: {
-      chat_id: space.id,
-      message_id: parseMessageId(content.target.id),
-      ...body
-    },
-    client
-  });
-  return;
-};
-var send = async ({
-  space,
-  content,
-  config
-}) => {
-  const client = telegramClient(config);
-  switch (content.type) {
-    case "reaction":
-      return await sendReaction(client, space, content);
-    case "typing":
-      return await sendTyping(client, space, content.state);
-    case "read":
-      return;
-    case "edit":
-      return await sendEdit(client, space, content);
-    case "group":
-      return await sendGroup(client, space, content.items);
-    case "streamText":
-      return await sendStreamText(client, space, content);
-    case "poll":
-    case "poll_option":
-    case "effect":
-    case "rename":
-    case "avatar":
-      throw UnsupportedError.content(content.type, TELEGRAM_PLATFORM);
-    default:
-      return await sendContent(client, space, content);
-  }
-};
-
-// src/providers/telegram/space.ts
-var resolveUser = ({
-  input
-}) => Promise.resolve({ id: input.userID });
-var createSpace = ({
-  input
-}) => {
-  const [first, ...rest] = input.users;
-  if (first && rest.length === 0) {
-    return Promise.resolve({ id: first.id });
-  }
-  if (!first) {
-    throw new Error("Telegram space creation requires a recipient user.");
-  }
-  throw new Error(
-    "Telegram bots cannot create group chats \u2014 use space.get(chatId) for an existing chat, or create a space with a single user (their private chat)."
-  );
-};
-
-// src/providers/telegram/verify.ts
-import { timingSafeEqual } from "crypto";
-var SECRET_TOKEN_HEADER = "x-telegram-bot-api-secret-token";
-var safeEqual = (a, b) => {
-  const left = Buffer.from(a, "utf8");
-  const right = Buffer.from(b, "utf8");
-  if (left.length === 0 || left.length !== right.length) {
-    return false;
-  }
-  return timingSafeEqual(left, right);
-};
-var verifySecret = (headers, secret) => {
-  const provided = headers[SECRET_TOKEN_HEADER];
-  if (!provided) {
-    throw new Error("Telegram webhook is missing the secret token header");
-  }
-  if (!safeEqual(provided, secret)) {
-    throw new Error("Telegram webhook secret token mismatch");
-  }
-};
-var isUpdate = (value) => typeof value === "object" && value !== null && "update_id" in value && typeof value.update_id === "number";
-var parseUpdate = (bodyText) => {
-  let json;
-  try {
-    json = JSON.parse(bodyText);
-  } catch {
-    throw new Error("Telegram webhook body is not valid JSON");
-  }
-  if (!isUpdate(json)) {
-    throw new Error("Telegram webhook payload is missing a numeric update_id");
-  }
-  return json;
-};
-var verify = (config) => (req) => {
-  if (config.webhookSecret) {
-    verifySecret(req.headers, config.webhookSecret);
-  }
-  return parseUpdate(new TextDecoder().decode(req.rawBody));
-};
-
-// src/providers/telegram/webhook.ts
-import { getWebhookInfo, setWebhook } from "@photon-ai/telegram-ts";
-var DEFAULT_SUPER_WEBHOOK_DOMAIN = "spctrm.dev";
-var webhookUrl = (slug) => {
-  const domain = process.env.SPECTRUM_SUPER_WEBHOOK ?? DEFAULT_SUPER_WEBHOOK_DOMAIN;
-  return `https://${slug}.${domain}/${TELEGRAM_PLATFORM}`;
-};
-var ensureWebhook = async (config, slug) => {
-  const client = telegramClient(config);
-  const url = webhookUrl(slug);
-  try {
-    const info = await getWebhookInfo({ client, throwOnError: true });
-    if (info.result?.url === url) {
-      return;
-    }
-    await setWebhook({
-      body: {
-        url,
-        ...config.webhookSecret ? { secret_token: config.webhookSecret } : {}
-      },
-      client,
-      throwOnError: true
-    });
-  } catch (error) {
-    throw new Error(`Telegram webhook registration failed for ${url}`, {
-      cause: error
-    });
-  }
-};
-
-// src/providers/telegram/index.ts
-var telegram = definePlatform(TELEGRAM_PLATFORM, {
-  config: configSchema,
-  lifecycle: {
-    // Annotate the return so overload selection sees the `FusorClient` brand
-    // without deferring this (context-sensitive) arrow — picks the fusor overload.
-    createClient: async ({
-      config,
-      projectConfig
-    }) => {
-      const slug = projectConfig?.slug;
-      if (slug) {
-        await ensureWebhook(config, slug);
-      }
-      return fusor(TELEGRAM_PLATFORM, verify(config));
-    }
-  },
-  user: { resolve: resolveUser },
-  space: { create: createSpace },
-  messages: handleMessages,
-  send
-});
-
-export {
-  telegram
-};