@mtcute/core 0.30.3 → 0.32.0

package/highlevel/methods/ephemeral/edit-ephemeral-message.js

@@ -0,0 +1,36 @@
+import { MtArgumentError } from "../../../types/errors.js";
+import { _normalizeInputMedia } from "../files/normalize-input-media.js";
+import { _normalizeInputRichMessage } from "../messages/normalize-rich-message.js";
+import { _normalizeInputText } from "../misc/normalize-text.js";
+import { resolvePeer, resolveUser } from "../users/resolve-peer.js";
+import { _findEphemeralMessageInUpdate } from "./find-in-update.js";
+import { _convertToTl } from "../../types/bots/keyboards/factories.js";
+async function editEphemeralMessage(client, params) {
+  const { chatId, receiverId, messageId, text, media, richMessage, replyMarkup, shouldDispatch, uploadCache } = params;
+  let message;
+  let entities;
+  if (text !== void 0) {
+    [message, entities] = await _normalizeInputText(client, text);
+  }
+  const peer = chatId !== null ? await resolvePeer(client, chatId) : void 0;
+  if (richMessage && !peer) {
+    throw new MtArgumentError("richMessage requires chatId to be passed");
+  }
+  const res = await client.call({
+    _: "ephemeral.editMessage",
+    peer,
+    receiverId: await resolveUser(client, receiverId),
+    id: messageId,
+    message,
+    entities,
+    media: media ? await _normalizeInputMedia(client, media, { uploadPeer: peer }) : void 0,
+    richMessage: richMessage ? await _normalizeInputRichMessage(client, peer, richMessage, { uploadCache }) : void 0,
+    replyMarkup: _convertToTl(replyMarkup),
+    welcome: params.welcome,
+    invertMedia: params.invertMedia
+  });
+  return _findEphemeralMessageInUpdate(client, res, true, !shouldDispatch);
+}
+export {
+  editEphemeralMessage
+};

package/highlevel/methods/ephemeral/find-in-update.cjs

@@ -0,0 +1,27 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = require("../../../types/errors.cjs");
+const utils = require("../../updates/utils.cjs");
+const ephemeralMessage = require("../../types/messages/ephemeral-message.cjs");
+const peersIndex = require("../../types/peers/peers-index.cjs");
+function _findEphemeralMessageInUpdate(client, res, isEdit = false, noDispatch = true) {
+  utils.assertIsUpdatesGroup("_findEphemeralMessageInUpdate", res);
+  client.handleClientUpdate(res, noDispatch);
+  for (const u of res.updates) {
+    if (u._ !== "updateNewEphemeralMessage" && u._ !== "updateEditEphemeralMessage") continue;
+    if (isEdit !== (u._ === "updateEditEphemeralMessage")) continue;
+    const peers = peersIndex.PeersIndex.from(res);
+    return new ephemeralMessage.EphemeralMessage(u.message, peers);
+  }
+  throw new errors.MtTypeAssertionError(
+    "_findEphemeralMessageInUpdate (@ .updates[*])",
+    "updateNewEphemeralMessage | updateEditEphemeralMessage",
+    "none"
+  );
+}
+exports._findEphemeralMessageInUpdate = _findEphemeralMessageInUpdate;

package/highlevel/methods/ephemeral/find-in-update.d.cts

@@ -0,0 +1,8 @@
+import { tl } from '../../../tl/index.js';
+import { ITelegramClient } from '../../client.types.js';
+import { EphemeralMessage } from '../../types/index.js';
+/**
+ * @internal
+ * @noemit
+ */
+export declare function _findEphemeralMessageInUpdate(client: ITelegramClient, res: tl.TypeUpdates, isEdit?: boolean, noDispatch?: boolean): EphemeralMessage;

package/highlevel/methods/ephemeral/find-in-update.d.ts

@@ -0,0 +1,8 @@
+import { tl } from '../../../tl/index.js';
+import { ITelegramClient } from '../../client.types.js';
+import { EphemeralMessage } from '../../types/index.js';
+/**
+ * @internal
+ * @noemit
+ */
+export declare function _findEphemeralMessageInUpdate(client: ITelegramClient, res: tl.TypeUpdates, isEdit?: boolean, noDispatch?: boolean): EphemeralMessage;

package/highlevel/methods/ephemeral/find-in-update.js

@@ -0,0 +1,22 @@
+import { MtTypeAssertionError } from "../../../types/errors.js";
+import { assertIsUpdatesGroup } from "../../updates/utils.js";
+import { EphemeralMessage as EphemeralMessage$2 } from "../../types/messages/ephemeral-message.js";
+import { PeersIndex } from "../../types/peers/peers-index.js";
+function _findEphemeralMessageInUpdate(client, res, isEdit = false, noDispatch = true) {
+  assertIsUpdatesGroup("_findEphemeralMessageInUpdate", res);
+  client.handleClientUpdate(res, noDispatch);
+  for (const u of res.updates) {
+    if (u._ !== "updateNewEphemeralMessage" && u._ !== "updateEditEphemeralMessage") continue;
+    if (isEdit !== (u._ === "updateEditEphemeralMessage")) continue;
+    const peers = PeersIndex.from(res);
+    return new EphemeralMessage$2(u.message, peers);
+  }
+  throw new MtTypeAssertionError(
+    "_findEphemeralMessageInUpdate (@ .updates[*])",
+    "updateNewEphemeralMessage | updateEditEphemeralMessage",
+    "none"
+  );
+}
+export {
+  _findEphemeralMessageInUpdate
+};

package/highlevel/methods/ephemeral/get-ephemeral-callback-answer.cjs

@@ -0,0 +1,31 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const resolvePeer = require("../users/resolve-peer.cjs");
+async function getEphemeralCallbackAnswer(client, params) {
+  const { chatId, messageId, data, timeout = 1e4, fireAndForget } = params;
+  const promise = client.call(
+    {
+      _: "ephemeral.getCallbackAnswer",
+      peer: await resolvePeer.resolvePeer(client, chatId),
+      id: messageId,
+      data: typeof data === "string" ? utils.utf8.encoder.encode(data) : data
+    },
+    { timeout, throw503: true }
+  );
+  if (fireAndForget) {
+    promise.catch(() => {
+    });
+    return {
+      _: "messages.botCallbackAnswer",
+      cacheTime: 0
+    };
+  }
+  return promise;
+}
+exports.getEphemeralCallbackAnswer = getEphemeralCallbackAnswer;

package/highlevel/methods/ephemeral/get-ephemeral-callback-answer.d.cts

@@ -0,0 +1,29 @@
+import { tl } from '../../../tl/index.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Request a callback answer from a bot for an ephemeral message,
+ * i.e. click an inline button that contains data.
+ */
+export declare function getEphemeralCallbackAnswer(client: ITelegramClient, params: {
+    /** Chat where the ephemeral message was sent */
+    chatId: InputPeerLike;
+    /** ID of the ephemeral message containing the button */
+    messageId: number;
+    /** Data contained in the button */
+    data?: string | Uint8Array;
+    /**
+     * Timeout for the query in ms.
+     *
+     * @default  `10000` (10 sec)
+     */
+    timeout?: number;
+    /**
+     * Whether to "fire and forget" this request,
+     * in which case the promise will resolve as soon
+     * as the request is sent with an empty response.
+     *
+     * **Note**: any errors will be silently ignored.
+     */
+    fireAndForget?: boolean;
+}): Promise<tl.messages.TypeBotCallbackAnswer>;

package/highlevel/methods/ephemeral/get-ephemeral-callback-answer.d.ts

@@ -0,0 +1,29 @@
+import { tl } from '../../../tl/index.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Request a callback answer from a bot for an ephemeral message,
+ * i.e. click an inline button that contains data.
+ */
+export declare function getEphemeralCallbackAnswer(client: ITelegramClient, params: {
+    /** Chat where the ephemeral message was sent */
+    chatId: InputPeerLike;
+    /** ID of the ephemeral message containing the button */
+    messageId: number;
+    /** Data contained in the button */
+    data?: string | Uint8Array;
+    /**
+     * Timeout for the query in ms.
+     *
+     * @default  `10000` (10 sec)
+     */
+    timeout?: number;
+    /**
+     * Whether to "fire and forget" this request,
+     * in which case the promise will resolve as soon
+     * as the request is sent with an empty response.
+     *
+     * **Note**: any errors will be silently ignored.
+     */
+    fireAndForget?: boolean;
+}): Promise<tl.messages.TypeBotCallbackAnswer>;

package/highlevel/methods/ephemeral/get-ephemeral-callback-answer.js

@@ -0,0 +1,26 @@
+import { utf8 } from "@fuman/utils";
+import { resolvePeer } from "../users/resolve-peer.js";
+async function getEphemeralCallbackAnswer(client, params) {
+  const { chatId, messageId, data, timeout = 1e4, fireAndForget } = params;
+  const promise = client.call(
+    {
+      _: "ephemeral.getCallbackAnswer",
+      peer: await resolvePeer(client, chatId),
+      id: messageId,
+      data: typeof data === "string" ? utf8.encoder.encode(data) : data
+    },
+    { timeout, throw503: true }
+  );
+  if (fireAndForget) {
+    promise.catch(() => {
+    });
+    return {
+      _: "messages.botCallbackAnswer",
+      cacheTime: 0
+    };
+  }
+  return promise;
+}
+export {
+  getEphemeralCallbackAnswer
+};

package/highlevel/methods/ephemeral/get-welcome-messages.cjs

@@ -0,0 +1,29 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Long = require("long");
+const typeAssertions = require("../../../utils/type-assertions.cjs");
+const buildPeersIndex = require("../chats/build-peers-index.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+const ephemeralMessage = require("../../types/messages/ephemeral-message.cjs");
+async function getWelcomeMessages(client, chatId) {
+  const peer = await resolvePeer.resolvePeer(client, chatId);
+  const res = await client.call({
+    _: "ephemeral.getWelcomeMessages",
+    peer,
+    hash: Long.ZERO
+  });
+  typeAssertions.assertTypeIsNot("getWelcomeMessages", res, "ephemeral.welcomeMessagesNotModified");
+  const peersToFetch = [peer];
+  for (const msg of res.messages) {
+    peersToFetch.push(msg.fromId);
+    if (msg.peerId) peersToFetch.push(msg.peerId);
+  }
+  const peers = await buildPeersIndex._buildPeersIndex(client, "getWelcomeMessages", peersToFetch);
+  return res.messages.map((it) => new ephemeralMessage.EphemeralMessage(it, peers));
+}
+exports.getWelcomeMessages = getWelcomeMessages;

package/highlevel/methods/ephemeral/get-welcome-messages.d.cts

@@ -0,0 +1,8 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, EphemeralMessage } from '../../types/index.js';
+/**
+ * Get the welcome messages configured for a chat
+ *
+ * @param chatId  Chat to get the welcome messages for
+ */
+export declare function getWelcomeMessages(client: ITelegramClient, chatId: InputPeerLike): Promise<EphemeralMessage[]>;

package/highlevel/methods/ephemeral/get-welcome-messages.d.ts

@@ -0,0 +1,8 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, EphemeralMessage } from '../../types/index.js';
+/**
+ * Get the welcome messages configured for a chat
+ *
+ * @param chatId  Chat to get the welcome messages for
+ */
+export declare function getWelcomeMessages(client: ITelegramClient, chatId: InputPeerLike): Promise<EphemeralMessage[]>;

package/highlevel/methods/ephemeral/get-welcome-messages.js

@@ -0,0 +1,24 @@
+import Long from "long";
+import { assertTypeIsNot } from "../../../utils/type-assertions.js";
+import { _buildPeersIndex } from "../chats/build-peers-index.js";
+import { resolvePeer } from "../users/resolve-peer.js";
+import { EphemeralMessage as EphemeralMessage$2 } from "../../types/messages/ephemeral-message.js";
+async function getWelcomeMessages(client, chatId) {
+  const peer = await resolvePeer(client, chatId);
+  const res = await client.call({
+    _: "ephemeral.getWelcomeMessages",
+    peer,
+    hash: Long.ZERO
+  });
+  assertTypeIsNot("getWelcomeMessages", res, "ephemeral.welcomeMessagesNotModified");
+  const peersToFetch = [peer];
+  for (const msg of res.messages) {
+    peersToFetch.push(msg.fromId);
+    if (msg.peerId) peersToFetch.push(msg.peerId);
+  }
+  const peers = await _buildPeersIndex(client, "getWelcomeMessages", peersToFetch);
+  return res.messages.map((it) => new EphemeralMessage$2(it, peers));
+}
+export {
+  getWelcomeMessages
+};

package/highlevel/methods/ephemeral/send-ephemeral-message.cjs

@@ -0,0 +1,48 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/core] CommonJS bundles are deprecated. They will be removed completely in one of the upcoming releases. No support is provided for CommonJS users. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/core] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = require("../../../types/errors.cjs");
+const longUtils = require("../../../utils/long-utils.cjs");
+const normalizeInputMedia = require("../files/normalize-input-media.cjs");
+const normalizeRichMessage = require("../messages/normalize-rich-message.cjs");
+const normalizeText = require("../misc/normalize-text.cjs");
+const resolvePeer = require("../users/resolve-peer.cjs");
+const findInUpdate = require("./find-in-update.cjs");
+const factories = require("../../types/bots/keyboards/factories.cjs");
+async function sendEphemeralMessage(client, chatId, receiverId, text, params) {
+  const { media, richMessage, replyTo, replyToEphemeral, queryId, shouldDispatch, uploadCache } = params ?? {};
+  const [message, entities] = await normalizeText._normalizeInputText(client, text);
+  const peer = chatId !== null ? await resolvePeer.resolvePeer(client, chatId) : void 0;
+  if (richMessage && !peer) {
+    throw new errors.MtArgumentError("richMessage requires chatId to be passed");
+  }
+  let replyToTl;
+  if (replyTo !== void 0) {
+    replyToTl = { _: "inputReplyToMessage", replyToMsgId: replyTo };
+  } else if (replyToEphemeral !== void 0) {
+    replyToTl = { _: "inputReplyToEphemeralMessage", id: replyToEphemeral };
+  }
+  const res = await client.call({
+    _: "ephemeral.sendMessage",
+    peer,
+    receiverId: await resolvePeer.resolveUser(client, receiverId),
+    queryId,
+    message,
+    entities,
+    media: media ? await normalizeInputMedia._normalizeInputMedia(client, media, { uploadPeer: peer }) : void 0,
+    richMessage: richMessage ? await normalizeRichMessage._normalizeInputRichMessage(client, peer, richMessage, { uploadCache }) : void 0,
+    replyMarkup: factories._convertToTl(params?.replyMarkup),
+    randomId: longUtils.randomLong(),
+    replyTo: replyToTl,
+    welcome: params?.welcome,
+    anchor: params?.anchor,
+    invertMedia: params?.invertMedia,
+    noforwards: params?.forbidForwards
+  });
+  return findInUpdate._findEphemeralMessageInUpdate(client, res, false, !shouldDispatch);
+}
+exports.sendEphemeralMessage = sendEphemeralMessage;

package/highlevel/methods/ephemeral/send-ephemeral-message.d.cts

@@ -0,0 +1,47 @@
+import { tl } from '../../../tl/index.js';
+import { ITelegramClient } from '../../client.types.js';
+import { ReplyMarkup } from '../../types/bots/keyboards/index.js';
+import { EphemeralMessage, InputMediaLike, InputPeerLike, InputText } from '../../types/index.js';
+import { InputRichMessage, RichMediaUploadCache } from '../../types/messages/rich/types.js';
+/**
+ * Send an ephemeral message — a message that is only visible
+ * to a single user in a chat and is not persisted in the chat history.
+ *
+ * @param chatId  ID of the chat to send the message to (`null` for guest chats, where `queryId` is used instead)
+ * @param receiverId  ID of the user the message should be visible to
+ * @param text  Text of the message
+ */
+export declare function sendEphemeralMessage(client: ITelegramClient, chatId: InputPeerLike | null, receiverId: InputPeerLike, text: InputText, params?: {
+    /** Media to be attached to the message */
+    media?: InputMediaLike;
+    /** Rich message content to be sent instead of the plain text */
+    richMessage?: InputRichMessage;
+    /** Message to reply to */
+    replyTo?: number;
+    /** Ephemeral message to reply to */
+    replyToEphemeral?: number;
+    /** Reply markup to be attached to the message */
+    replyMarkup?: ReplyMarkup;
+    /** For guest chat bots, ID of the query that this message is sent in response to */
+    queryId?: tl.Long;
+    /** Whether to send this message as a welcome message template for the chat */
+    welcome?: boolean;
+    /** Whether to anchor this message to the message it replies to */
+    anchor?: boolean;
+    /**
+     * Whether to invert the media position.
+     *
+     * Currently only supported for web previews and makes the
+     * client render the preview above the caption and not below.
+     */
+    invertMedia?: boolean;
+    /** Whether to forbid forwarding this message */
+    forbidForwards?: boolean;
+    /** Cache for the uploaded rich message media, see {@link createRichStreamingDraft} */
+    uploadCache?: RichMediaUploadCache;
+    /**
+     * Whether to dispatch the returned updates
+     * to the client's update handler.
+     */
+    shouldDispatch?: true;
+}): Promise<EphemeralMessage>;

package/highlevel/methods/ephemeral/send-ephemeral-message.d.ts

@@ -0,0 +1,47 @@
+import { tl } from '../../../tl/index.js';
+import { ITelegramClient } from '../../client.types.js';
+import { ReplyMarkup } from '../../types/bots/keyboards/index.js';
+import { EphemeralMessage, InputMediaLike, InputPeerLike, InputText } from '../../types/index.js';
+import { InputRichMessage, RichMediaUploadCache } from '../../types/messages/rich/types.js';
+/**
+ * Send an ephemeral message — a message that is only visible
+ * to a single user in a chat and is not persisted in the chat history.
+ *
+ * @param chatId  ID of the chat to send the message to (`null` for guest chats, where `queryId` is used instead)
+ * @param receiverId  ID of the user the message should be visible to
+ * @param text  Text of the message
+ */
+export declare function sendEphemeralMessage(client: ITelegramClient, chatId: InputPeerLike | null, receiverId: InputPeerLike, text: InputText, params?: {
+    /** Media to be attached to the message */
+    media?: InputMediaLike;
+    /** Rich message content to be sent instead of the plain text */
+    richMessage?: InputRichMessage;
+    /** Message to reply to */
+    replyTo?: number;
+    /** Ephemeral message to reply to */
+    replyToEphemeral?: number;
+    /** Reply markup to be attached to the message */
+    replyMarkup?: ReplyMarkup;
+    /** For guest chat bots, ID of the query that this message is sent in response to */
+    queryId?: tl.Long;
+    /** Whether to send this message as a welcome message template for the chat */
+    welcome?: boolean;
+    /** Whether to anchor this message to the message it replies to */
+    anchor?: boolean;
+    /**
+     * Whether to invert the media position.
+     *
+     * Currently only supported for web previews and makes the
+     * client render the preview above the caption and not below.
+     */
+    invertMedia?: boolean;
+    /** Whether to forbid forwarding this message */
+    forbidForwards?: boolean;
+    /** Cache for the uploaded rich message media, see {@link createRichStreamingDraft} */
+    uploadCache?: RichMediaUploadCache;
+    /**
+     * Whether to dispatch the returned updates
+     * to the client's update handler.
+     */
+    shouldDispatch?: true;
+}): Promise<EphemeralMessage>;

package/highlevel/methods/ephemeral/send-ephemeral-message.js

@@ -0,0 +1,43 @@
+import { MtArgumentError } from "../../../types/errors.js";
+import { randomLong } from "../../../utils/long-utils.js";
+import { _normalizeInputMedia } from "../files/normalize-input-media.js";
+import { _normalizeInputRichMessage } from "../messages/normalize-rich-message.js";
+import { _normalizeInputText } from "../misc/normalize-text.js";
+import { resolvePeer, resolveUser } from "../users/resolve-peer.js";
+import { _findEphemeralMessageInUpdate } from "./find-in-update.js";
+import { _convertToTl } from "../../types/bots/keyboards/factories.js";
+async function sendEphemeralMessage(client, chatId, receiverId, text, params) {
+  const { media, richMessage, replyTo, replyToEphemeral, queryId, shouldDispatch, uploadCache } = params ?? {};
+  const [message, entities] = await _normalizeInputText(client, text);
+  const peer = chatId !== null ? await resolvePeer(client, chatId) : void 0;
+  if (richMessage && !peer) {
+    throw new MtArgumentError("richMessage requires chatId to be passed");
+  }
+  let replyToTl;
+  if (replyTo !== void 0) {
+    replyToTl = { _: "inputReplyToMessage", replyToMsgId: replyTo };
+  } else if (replyToEphemeral !== void 0) {
+    replyToTl = { _: "inputReplyToEphemeralMessage", id: replyToEphemeral };
+  }
+  const res = await client.call({
+    _: "ephemeral.sendMessage",
+    peer,
+    receiverId: await resolveUser(client, receiverId),
+    queryId,
+    message,
+    entities,
+    media: media ? await _normalizeInputMedia(client, media, { uploadPeer: peer }) : void 0,
+    richMessage: richMessage ? await _normalizeInputRichMessage(client, peer, richMessage, { uploadCache }) : void 0,
+    replyMarkup: _convertToTl(params?.replyMarkup),
+    randomId: randomLong(),
+    replyTo: replyToTl,
+    welcome: params?.welcome,
+    anchor: params?.anchor,
+    invertMedia: params?.invertMedia,
+    noforwards: params?.forbidForwards
+  });
+  return _findEphemeralMessageInUpdate(client, res, false, !shouldDispatch);
+}
+export {
+  sendEphemeralMessage
+};

package/highlevel/methods/files/download-iterable.cjs

@@ -230,12 +230,13 @@ async function* downloadAsIterable(client, input, params) {
   }).then(() => {
     client.log.debug("download workers finished");
   });
-  abortSignal$1?.addEventListener("abort", () => {
+  const onAbort = () => {
     client.log.debug("download aborted");
     error = abortSignal$1.reason;
     ended = true;
     nextChunkCv.notify();
-  });
+  };
+  abortSignal$1?.addEventListener("abort", onAbort);
   let position = offset;
   try {
     while (position < limitBytes) {
@@ -255,6 +256,10 @@ async function* downloadAsIterable(client, input, params) {
     }
   } finally {
     if (stallTimer) utils.timers.clearTimeout(stallTimer);
+    abortSignal$1?.removeEventListener("abort", onAbort);
+    ended = true;
+    for (const idx in buffer) delete buffer[Number(idx)];
+    nextChunkCv.notify();
   }
 }
 exports._normalizeFileDownloadLocation = _normalizeFileDownloadLocation;

package/highlevel/methods/files/download-iterable.js

@@ -223,12 +223,13 @@ async function* downloadAsIterable(client, input, params) {
   }).then(() => {
     client.log.debug("download workers finished");
   });
-  abortSignal?.addEventListener("abort", () => {
+  const onAbort = () => {
     client.log.debug("download aborted");
     error = abortSignal.reason;
     ended = true;
     nextChunkCv.notify();
-  });
+  };
+  abortSignal?.addEventListener("abort", onAbort);
   let position = offset;
   try {
     while (position < limitBytes) {
@@ -248,6 +249,10 @@ async function* downloadAsIterable(client, input, params) {
     }
   } finally {
     if (stallTimer) timers.clearTimeout(stallTimer);
+    abortSignal?.removeEventListener("abort", onAbort);
+    ended = true;
+    for (const idx in buffer) delete buffer[Number(idx)];
+    nextChunkCv.notify();
   }
 }
 export {

package/highlevel/methods/files/download-iterable.test.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/methods/files/download-iterable.test.d.ts

@@ -0,0 +1 @@
+export {};

package/highlevel/methods/files/download-stream.cjs

@@ -19,11 +19,9 @@ function downloadAsStream(client, location, params) {
     });
   }
   const cancel = new AbortController();
-  if (params?.abortSignal) {
-    params?.abortSignal.addEventListener("abort", () => {
-      cancel.abort();
-    });
-  }
+  const onAbort = () => cancel.abort();
+  params?.abortSignal?.addEventListener("abort", onAbort);
+  const removeAbortListener = () => params?.abortSignal?.removeEventListener("abort", onAbort);
   const backpressureCv = new utils.ConditionVariable();
   return new ReadableStream({
     start(controller) {
@@ -38,13 +36,14 @@ function downloadAsStream(client, location, params) {
           controller.enqueue(chunk);
         }
         controller.close();
-      })().catch((e) => controller.error(e));
+      })().catch((e) => controller.error(e)).finally(removeAbortListener);
     },
     pull() {
       backpressureCv.notify();
     },
     cancel() {
       cancel.abort();
+      removeAbortListener();
     }
   }, {
     highWaterMark: params?.highWaterMark,

package/highlevel/methods/files/download-stream.js

@@ -12,11 +12,9 @@ function downloadAsStream(client, location, params) {
     });
   }
   const cancel = new AbortController();
-  if (params?.abortSignal) {
-    params?.abortSignal.addEventListener("abort", () => {
-      cancel.abort();
-    });
-  }
+  const onAbort = () => cancel.abort();
+  params?.abortSignal?.addEventListener("abort", onAbort);
+  const removeAbortListener = () => params?.abortSignal?.removeEventListener("abort", onAbort);
   const backpressureCv = new ConditionVariable();
   return new ReadableStream({
     start(controller) {
@@ -31,13 +29,14 @@ function downloadAsStream(client, location, params) {
           controller.enqueue(chunk);
         }
         controller.close();
-      })().catch((e) => controller.error(e));
+      })().catch((e) => controller.error(e)).finally(removeAbortListener);
     },
     pull() {
       backpressureCv.notify();
     },
     cancel() {
       cancel.abort();
+      removeAbortListener();
     }
   }, {
     highWaterMark: params?.highWaterMark,