@mtkruto/node 0.69.0 → 0.70.1

package/esm/deps/jsr.io/@std/encoding/1.0.7/hex.js

@@ -0,0 +1,109 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// https://github.com/golang/go/blob/master/LICENSE
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Port of the Go
+ * {@link https://github.com/golang/go/blob/go1.12.5/src/encoding/hex/hex.go | encoding/hex}
+ * library.
+ *
+ * ```ts
+ * import {
+ *   decodeHex,
+ *   encodeHex,
+ * } from "@std/encoding/hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeHex("abc"), "616263");
+ *
+ * assertEquals(
+ *   decodeHex("616263"),
+ *   new TextEncoder().encode("abc"),
+ * );
+ * ```
+ *
+ * @module
+ */
+import { validateBinaryLike } from "./_validate_binary_like.js";
+const hexTable = new TextEncoder().encode("0123456789abcdef");
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function errInvalidByte(byte) {
+    return new TypeError(`Invalid byte '${String.fromCharCode(byte)}'`);
+}
+function errLength(len) {
+    return new RangeError(`Cannot decode the hex string as the input length should be even: length is ${len}`);
+}
+/** Converts a hex character into its value. */
+function fromHexChar(byte) {
+    // '0' <= byte && byte <= '9'
+    if (48 <= byte && byte <= 57)
+        return byte - 48;
+    // 'a' <= byte && byte <= 'f'
+    if (97 <= byte && byte <= 102)
+        return byte - 97 + 10;
+    // 'A' <= byte && byte <= 'F'
+    if (65 <= byte && byte <= 70)
+        return byte - 65 + 10;
+    throw errInvalidByte(byte);
+}
+/**
+ * Converts data into a hex-encoded string.
+ *
+ * @param src The data to encode.
+ *
+ * @returns The hex-encoded string.
+ *
+ * @example Usage
+ * ```ts
+ * import { encodeHex } from "@std/encoding/hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(encodeHex("abc"), "616263");
+ * ```
+ */
+export function encodeHex(src) {
+    const u8 = validateBinaryLike(src);
+    const dst = new Uint8Array(u8.length * 2);
+    for (let i = 0; i < u8.length; i++) {
+        const v = u8[i];
+        dst[i * 2] = hexTable[v >> 4];
+        dst[i * 2 + 1] = hexTable[v & 0x0f];
+    }
+    return textDecoder.decode(dst);
+}
+/**
+ * Decodes the given hex-encoded string. If the input is malformed, an error is
+ * thrown.
+ *
+ * @param src The hex-encoded string to decode.
+ *
+ * @returns The decoded data.
+ *
+ * @example Usage
+ * ```ts
+ * import { decodeHex } from "@std/encoding/hex";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   decodeHex("616263"),
+ *   new TextEncoder().encode("abc"),
+ * );
+ * ```
+ */
+export function decodeHex(src) {
+    const u8 = textEncoder.encode(src);
+    const dst = new Uint8Array(u8.length / 2);
+    for (let i = 0; i < dst.length; i++) {
+        const a = fromHexChar(u8[i * 2]);
+        const b = fromHexChar(u8[i * 2 + 1]);
+        dst[i] = (a << 4) | b;
+    }
+    if (u8.length % 2 === 1) {
+        // Check for invalid char before reporting bad length,
+        // since the invalid char (if present) is an earlier problem.
+        fromHexChar(u8[dst.length * 2]);
+        throw errLength(u8.length);
+    }
+    return dst;
+}

package/esm/session/1_session.d.ts

@@ -21,6 +21,7 @@ export declare abstract class Session {
     get dc(): DC;
     get cdn(): boolean;
     set serverSalt(serverSalt: bigint);
+    get serverSalt(): bigint;
     get connected(): boolean;
     connect(): Promise<void>;
     protected waitUntilConnected(): Promise<void>;

package/esm/session/1_session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"1_session.d.ts","sourceRoot":"","sources":["../../src/session/1_session.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAoD,MAAM,mBAAmB,CAAC;AACtH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAQpD,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC;;OAEG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,8BAAsB,OAAO;;IAG3B,SAAS,CAAC,KAAK,EAAE,YAAY,CAAsB;IACnD,SAAS,CAAC,SAAS,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC;gBAMvC,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,aAAa;IAc1C,IAAI,uBAAuB,CAAC,uBAAuB,EAAE,UAAU,CAAC,oBAAoB,CAAC,EAEpF;IAED,IAAI,kBAAkB,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,SAAS,EAExE;IAED,IAAI,EAAE,IAAI,EAAE,CAEX;IAED,IAAI,GAAG,IAAI,OAAO,CAEjB;IAED,IAAI,UAAU,CAAC,UAAU,EAAE,MAAM,EAEhC;IA6BD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAGK,OAAO;cAeG,kBAAkB;IAIlC,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,UAAU;IAOV,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;CACjD"}
+{"version":3,"file":"1_session.d.ts","sourceRoot":"","sources":["../../src/session/1_session.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,iBAAiB,EAAoD,MAAM,mBAAmB,CAAC;AACtH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAQpD,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC;;OAEG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,8BAAsB,OAAO;;IAG3B,SAAS,CAAC,KAAK,EAAE,YAAY,CAAsB;IACnD,SAAS,CAAC,SAAS,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC;gBAMvC,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,aAAa;IAc1C,IAAI,uBAAuB,CAAC,uBAAuB,EAAE,UAAU,CAAC,oBAAoB,CAAC,EAEpF;IAED,IAAI,kBAAkB,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,SAAS,EAExE;IAED,IAAI,EAAE,IAAI,EAAE,CAEX;IAED,IAAI,GAAG,IAAI,OAAO,CAEjB;IAED,IAAI,UAAU,CAAC,UAAU,EAAE,MAAM,EAEhC;IAED,IAAI,UAAU,IAAI,MAAM,CAEvB;IA6BD,IAAI,SAAS,IAAI,OAAO,CAEvB;IAGK,OAAO;cAeG,kBAAkB;IAIlC,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED,UAAU;IAOV,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;CACjD"}

package/esm/session/1_session.js

@@ -62,6 +62,9 @@ export class Session {
     set serverSalt(serverSalt) {
         this.state.serverSalt = serverSalt;
     }
+    get serverSalt() {
+        return this.state.serverSalt;
+    }
     #lastState;
     async #stateChangeHandler(connected) {
         if (this.#lastState !== connected) {

package/esm/session/2_session_encrypted.d.ts

@@ -33,9 +33,9 @@ export declare class SessionEncrypted extends Session implements Session {
     handlers: Handlers;
     constructor(dc: DC, params?: SessionParams);
     setAuthKey(key: Uint8Array<ArrayBuffer>): Promise<void>;
-    get authKey(): Uint8Array;
+    get authKey(): Uint8Array<ArrayBuffer>;
     connect(): Promise<void>;
     disconnect(): void;
-    send(body: Uint8Array): Promise<bigint>;
+    send(body: Uint8Array<ArrayBuffer>): Promise<bigint>;
 }
 //# sourceMappingURL=2_session_encrypted.d.ts.map

package/esm/session/2_session_encrypted.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"2_session_encrypted.d.ts","sourceRoot":"","sources":["../../src/session/2_session_encrypted.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,EAAwD,OAAO,EAAuC,MAAM,YAAY,CAAC;AAChI,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAG5C,OAAO,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAS7D,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,eAAe,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,eAAe,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACxD,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,KAAK,IAAI,CAAC;IAC5D,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;CACxD;AAQD,qBAAa,gBAAiB,SAAQ,OAAQ,YAAW,OAAO;;IAI9D,QAAQ,EAAE,QAAQ,CAAM;gBAQZ,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,aAAa;IAMpC,UAAU,CAAC,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC;IAM7C,IAAI,OAAO,IAAI,UAAU,CAExB;IAEc,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAa9B,UAAU,IAAI,IAAI;IAuDrB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;CAyU9C"}
+{"version":3,"file":"2_session_encrypted.d.ts","sourceRoot":"","sources":["../../src/session/2_session_encrypted.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,EAAwD,OAAO,EAAuC,MAAM,YAAY,CAAC;AAChI,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAI5C,OAAO,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAa7D,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC,eAAe,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,eAAe,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACxD,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,KAAK,IAAI,CAAC;IAC5D,WAAW,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;CACxD;AAED,qBAAa,gBAAiB,SAAQ,OAAQ,YAAW,OAAO;;IAI9D,QAAQ,EAAE,QAAQ,CAAM;gBAiBZ,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,aAAa;IAQpC,UAAU,CAAC,GAAG,EAAE,UAAU,CAAC,WAAW,CAAC;IAM7C,IAAI,OAAO,IAAI,UAAU,CAAC,WAAW,CAAC,CAErC;IAEc,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAe9B,UAAU,IAAI,IAAI;IA6ErB,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CA6W3D"}

package/esm/session/2_session_encrypted.js

@@ -17,10 +17,11 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-import { assertEquals, concat, delay, ige256Decrypt, ige256Encrypt, initTgCrypto, SECOND } from "../0_deps.js";
+import { assertEquals, concat, delay, ige256Decrypt, ige256Encrypt, initTgCrypto, LruCache, SECOND } from "../0_deps.js";
 import { ConnectionError, TransportError } from "../0_errors.js";
 import { bigIntFromBuffer, bufferFromBigInt, drop, getLogger, getRandomId, gunzip, mod, sha1, sha256, toUnixTimestamp } from "../1_utilities.js";
 import { deserializeMessage, Mtproto, repr, serializeMessage, TLReader, X } from "../2_tl.js";
+import { AbortableLoop } from "../client/0_abortable_loop.js";
 import { TLWriter } from "../tl/1_tl_writer.js";
 import { SessionError } from "./0_session_error.js";
 import { Session } from "./1_session.js";
@@ -30,19 +31,27 @@ const GZIP_PACKED = 0x3072CFA1;
 const RPC_RESULT = 0xF35C6D01;
 const RPC_ERROR = Mtproto.schema.definitions["rpc_error"][0];
 export class SessionEncrypted extends Session {
+    static #TGCRYPTO_INITED = false;
     #id = getRandomId();
+    handlers = {};
+    #L;
+    #LsendLoop;
+    #LreceiveLoop;
+    #LpingLoop;
     #authKey = new Uint8Array();
     #authKeyId = 0n;
-    handlers = {};
-    #toAcknowledge = new Array();
-    #pendingMessages = new Set();
+    #sentMessages = new Set();
+    #pendingMessages = new Array();
+    #containers = new LruCache(20_000);
     #pendingPings = new Map();
-    #L;
-    static #TGCRYPTO_INITED = false;
+    #toAcknowledge = new Array();
+    #pendingAcks = new LruCache(100);
     constructor(dc, params) {
         super(dc, params);
         const L = this.#L = getLogger("SessionEncrypted").client(id++);
-        this.#LpingLoop = L.branch("#pingLoop");
+        this.#LsendLoop = L.branch("sendLoop");
+        this.#LreceiveLoop = L.branch("receiveLoop");
+        this.#LpingLoop = L.branch("pingLoop");
     }
     async setAuthKey(key) {
         const hash = await sha1(key);
@@ -61,14 +70,17 @@ export class SessionEncrypted extends Session {
             await initTgCrypto();
             SessionEncrypted.#TGCRYPTO_INITED = true;
         }
-        this.#startReceiveLoop();
-        this.#startPingLoop();
+        this.#receiveLoop.start();
+        this.#sendLoop.start();
+        this.#pingLoop.start();
+        this.#awakeSendLoop?.();
     }
     disconnect() {
         super.disconnect();
         this.state.reset();
         this.#id = getRandomId();
-        this.#pingLoopAbortController?.abort();
+        this.#pingLoop.abort();
+        this.#awakeSendLoop?.();
         this.#rejectAllPending(new ConnectionError("Not connected."));
     }
     #assertNotDisconnected() {
@@ -85,17 +97,34 @@ export class SessionEncrypted extends Session {
         this.#rejectAllPending(new SessionError("Session invalidated."));
     }
     #rejectAllPending(reason) {
-        for (const id of this.#pendingMessages) {
+        for (const id of this.#sentMessages) {
             this.#onMessageFailed(id, reason);
         }
-        this.#pendingMessages.clear();
         for (const pendingPing of this.#pendingPings.values()) {
-            pendingPing.reject(reason);
+            pendingPing.promiseWithResolvers.reject(reason);
         }
+        this.#sentMessages.clear();
         this.#pendingPings.clear();
+        this.#containers.clear();
     }
     #onMessageFailed(id, reason) {
-        this.#pendingMessages.delete(id);
+        this.#sentMessages.delete(id);
+        const pendingContainer = this.#containers.get(id);
+        if (pendingContainer) {
+            for (const id of pendingContainer) {
+                this.#onMessageFailed(id, reason);
+            }
+            this.#containers.delete(id);
+            return;
+        }
+        const pendingAck = this.#pendingAcks.get(id);
+        if (pendingAck) {
+            for (const id of pendingAck) {
+                this.#toAcknowledge.push(id);
+            }
+            this.#pendingAcks.delete(id);
+            return;
+        }
         const pendingPing = this.#pendingPings.get(id);
         if (pendingPing) {
             this.#pendingPings.delete(id);
@@ -103,13 +132,12 @@ export class SessionEncrypted extends Session {
                 drop(this.#resendPendingPing(pendingPing));
             }
             else {
-                pendingPing.reject(reason);
+                pendingPing.promiseWithResolvers.reject(reason);
             }
+            return;
         }
-        else {
-            // message was not sent by us
-            this.handlers.onMessageFailed?.(id, reason);
-        }
+        // message was not sent by us
+        this.handlers.onMessageFailed?.(id, reason);
     }
     #setServerSalt(newServerSalt) {
         this.state.serverSalt = newServerSalt;
@@ -120,36 +148,10 @@ export class SessionEncrypted extends Session {
             await super.waitUntilConnected();
         }
         this.#assertNotDisconnected();
-        const msg_id = this.state.nextMessageId();
-        const seqno = this.state.nextSeqNo(true);
-        let message = {
-            _: "message",
-            msg_id,
-            seqno,
-            body,
-        };
-        if (this.#toAcknowledge.length) {
-            const ack = {
-                _: "message",
-                msg_id: this.state.nextMessageId(),
-                seqno: this.state.nextSeqNo(false),
-                body: Mtproto.serializeObject({ _: "msgs_ack", msg_ids: this.#toAcknowledge.splice(0, 8192) }),
-            };
-            message = {
-                _: "message",
-                msg_id: this.state.nextMessageId(),
-                seqno: this.state.nextSeqNo(false),
-                body: {
-                    _: "msg_container",
-                    messages: [message, ack],
-                },
-            };
-        }
-        this.#L.out(message);
-        const payload = await this.#encryptMessage(message);
-        await this.transport.transport.send(payload);
-        this.#pendingMessages.add(msg_id);
-        return msg_id;
+        const pendingMessage = { body, promiseWithResolvers: Promise.withResolvers() };
+        this.#pendingMessages.push(pendingMessage);
+        this.#awakeSendLoop?.();
+        return await pendingMessage.promiseWithResolvers.promise;
     }
     async #receive() {
         this.#assertNotDisconnected();
@@ -202,60 +204,133 @@ export class SessionEncrypted extends Session {
         const _sessionId_ = plainReader.readInt64(false);
         return deserializeMessage(plainReader);
     }
-    //// RECEIVE LOOP ////
-    #startReceiveLoop() {
-        if (!this.#receiveLoopActive) {
-            drop(this.#receiveLoop());
+    //// SEND LOOP ////
+    #awakeSendLoop;
+    #sendLoop = new AbortableLoop(this.#sendLoopBody.bind(this), (err) => {
+        this.#LsendLoop.error("unhandled receive loop error:", err);
+    });
+    async #sendLoopBody(loop, signal) {
+        if (!this.connected) {
+            this.#LsendLoop.debug("aborting as not connected");
+            loop.abort();
+            return;
+        }
+        const pendingMessage = this.#pendingMessages.shift();
+        if (pendingMessage === undefined) {
+            this.#LsendLoop.debug("no pending messages");
+            return await new Promise((resolve) => {
+                const onAbort = () => {
+                    this.#LsendLoop.debug("got aborted while sleeping");
+                    resolve();
+                };
+                signal.addEventListener("abort", onAbort);
+                this.#awakeSendLoop = () => {
+                    this.#LsendLoop.debug("got awaken");
+                    resolve();
+                    signal.removeEventListener("abort", onAbort);
+                };
+            });
+        }
+        const msg_id = this.state.nextMessageId();
+        const seqno = this.state.nextSeqNo(true);
+        let message = {
+            _: "message",
+            msg_id,
+            seqno,
+            body: pendingMessage.body,
+        };
+        this.#LsendLoop.debug("msg_id =", msg_id, "seqno =", seqno);
+        if (this.#toAcknowledge.length) {
+            const msg_ids = this.#toAcknowledge.splice(0, 8192);
+            this.#LsendLoop.debug("acknowledging", msg_ids.length, "message(s) while sending this one");
+            const ack = {
+                _: "message",
+                msg_id: this.state.nextMessageId(),
+                seqno: this.state.nextSeqNo(false),
+                body: Mtproto.serializeObject({ _: "msgs_ack", msg_ids }),
+            };
+            this.#LsendLoop.debug("msgs_ack msg_id =", ack.msg_id, "seqno =", seqno);
+            this.#pendingAcks.set(ack.msg_id, msg_ids);
+            message = {
+                _: "message",
+                msg_id: this.state.nextMessageId(),
+                seqno: this.state.nextSeqNo(false),
+                body: {
+                    _: "msg_container",
+                    messages: [message, ack],
+                },
+            };
+            this.#LsendLoop.debug("container msg_id =", message.msg_id, "seqno =", message.seqno);
+        }
+        try {
+            const payload = await this.#encryptMessage(message);
+            await this.transport.transport.send(payload);
+            pendingMessage.promiseWithResolvers.resolve(msg_id);
+        }
+        catch (err) {
+            pendingMessage.promiseWithResolvers.reject(err);
+            return;
+        }
+        this.#LsendLoop.out(message);
+        this.#sentMessages.add(msg_id);
+        if (!(message.body instanceof Uint8Array)) {
+            const msg_ids = message.body.messages.map((v) => v.msg_id);
+            this.#LsendLoop.debug("sent container", message.msg_id, "with messages", ...msg_ids);
+            this.#containers.set(message.msg_id, msg_ids);
+        }
+        else {
+            this.#LsendLoop.debug("sent message", message.msg_id);
         }
     }
-    #receiveLoopActive = false;
-    async #receiveLoop() {
-        this.#receiveLoopActive = true;
+    //// RECEIVE LOOP ////
+    #receiveLoop = new AbortableLoop(this.#receiveLoopBody.bind(this), (err) => {
+        this.#LreceiveLoop.error("unhandled receive loop error:", err);
+    });
+    async #receiveLoopBody(loop) {
+        let message;
         try {
-            while (this.connected) {
-                let message;
-                try {
-                    message = await this.#receive();
-                }
-                catch (err) {
-                    this.#L.error("failed to receive message:", err);
-                    if (!this.connected) {
-                        break;
-                    }
-                    else {
-                        continue;
-                    }
-                }
-                try {
-                    if (message.body instanceof Uint8Array) {
-                        this.#onMessage(message.msg_id, message.body);
-                    }
-                    else {
-                        this.#onMessageContainer(message.msg_id, message.body);
-                    }
-                }
-                catch (err) {
-                    this.#L.error("failed to handle message:", err);
-                }
+            message = await this.#receive();
+        }
+        catch (err) {
+            this.#LreceiveLoop.error("failed to receive message:", err);
+            if (!this.connected) {
+                this.#LreceiveLoop.debug("aborting as not connected");
+                loop.abort();
+                return;
+            }
+            else {
+                return;
             }
         }
-        finally {
-            this.#receiveLoopActive = false;
+        try {
+            if (message.body instanceof Uint8Array) {
+                this.#onMessage(message.msg_id, message.body, null);
+            }
+            else {
+                this.#onMessageContainer(message.msg_id, message.body);
+            }
+        }
+        catch (err) {
+            this.#LreceiveLoop.error("failed to handle message:", err);
         }
     }
     //// RECEIVE LOOP HANDLERS ////
-    async #onMessage(msgId, body) {
+    async #onMessage(msgId, body, containerId) {
+        this.#LreceiveLoop.debug("received message with ID", msgId, "and size", body.length, "inside", ...(containerId === null ? ["no container"] : ["container", containerId]));
+        const logger = this.#LreceiveLoop.branch(msgId + "");
         let reader = new TLReader(body);
         let id = reader.readInt32(false);
         if (id === GZIP_PACKED) {
+            logger.debug("unpacking compressed body");
             reader = new TLReader(await gunzip(reader.readBytes()));
             id = reader.readInt32(false);
         }
         if (id === RPC_RESULT) {
-            this.#onRpcResult(msgId, reader.buffer);
+            this.#onRpcResult(msgId, reader.buffer, logger);
             return;
         }
         if (!Mtproto.schema.identifierToName[id]) {
+            logger.debug("identified body as a non-MTProto constructor");
             reader.unreadInt32();
             this.handlers.onUpdate?.(reader.buffer);
             return;
@@ -266,10 +341,10 @@ export class SessionEncrypted extends Session {
             type = await Mtproto.deserializeType(X, reader);
         }
         catch (err) {
-            this.#L.error("failed to deserialize MTProto type:", err);
+            logger.error("failed to deserialize MTProto type:", err);
             return;
         }
-        this.#L.debug("received", repr(type));
+        logger.debug("received", repr(type));
         if (Mtproto.is("new_session_created", type)) {
             this.#onNewSessionCreated(msgId, type);
         }
@@ -280,24 +355,26 @@ export class SessionEncrypted extends Session {
             this.#onBadServerSalt(type);
         }
         else if (Mtproto.is("bad_msg_notification", type)) {
-            await this.#onBadMsgNotification(msgId, type);
+            await this.#onBadMsgNotification(msgId, type, logger);
         }
         else if (Mtproto.is("msg_detailed_info", type)) {
-            this.#onMsgDetailedInfo(type);
+            this.#onMsgDetailedInfo(type, logger);
         }
         else if (Mtproto.is("msg_new_detailed_info", type)) {
-            this.#onMsgNewDetailedInfo(type);
+            this.#onMsgNewDetailedInfo(type, logger);
         }
         else {
-            this.#L.debug(`unhandled MTProto type: ${repr(type)}`);
+            logger.warning(`unhandled MTProto type: ${repr(type)}`);
         }
     }
-    async #onRpcResult(msgId, body) {
+    async #onRpcResult(msgId, body, logger) {
+        logger.debug("received rpc_result");
         this.#toAcknowledge.push(msgId);
         let reader = new TLReader(body);
         const reqMsgId = reader.readInt64();
         let id = reader.readInt32(false);
         if (id === GZIP_PACKED) {
+            logger.debug("unpacking compressed rpc_result");
             reader = new TLReader(await gunzip(reader.readBytes()));
             id = reader.readInt32(false);
             reader.unreadInt32();
@@ -306,6 +383,7 @@ export class SessionEncrypted extends Session {
             reader.unreadInt32();
         }
         if (id === RPC_ERROR) {
+            logger.debug("received rpc_error from message", msgId);
             const error = await Mtproto.deserializeType("rpc_error", reader);
             this.handlers.onRpcError?.(reqMsgId, error);
         }
@@ -313,13 +391,15 @@ export class SessionEncrypted extends Session {
             this.handlers.onRpcResult?.(reqMsgId, reader.buffer);
         }
     }
-    #onMsgDetailedInfo(msgDetailedInfo) {
+    #onMsgDetailedInfo(msgDetailedInfo, logger) {
+        logger.debug("scheduling the acknowledgement of", msgDetailedInfo.answer_msg_id, "because of", msgDetailedInfo._);
         this.#toAcknowledge.push(msgDetailedInfo.answer_msg_id);
     }
-    #onMsgNewDetailedInfo(msgNewDetailedInfo) {
+    #onMsgNewDetailedInfo(msgNewDetailedInfo, logger) {
+        logger.debug("scheduling the acknowledgement of", msgNewDetailedInfo.answer_msg_id, "because of", msgNewDetailedInfo._);
         this.#toAcknowledge.push(msgNewDetailedInfo.answer_msg_id);
     }
-    async #onBadMsgNotification(msgId, badMsgNotification) {
+    async #onBadMsgNotification(msgId, badMsgNotification, logger) {
         let low = false;
         switch (badMsgNotification.error_code) {
             case 16: // message ID too low
@@ -329,11 +409,12 @@ export class SessionEncrypted extends Session {
                 this.state.timeDifference = Math.abs(toUnixTimestamp(new Date()) - Number(msgId >> 32n));
                 if (!low) {
                     this.state.timeDifference = -this.state.timeDifference;
+                    logger.debug("resetting time difference to", -this.state.timeDifference, "because the ID of the message", badMsgNotification.bad_msg_id, "was too high");
                     await this.#invalidateSession("message ID too high");
                     return;
                 }
                 else {
-                    this.#L.debug("message ID too low, resending message");
+                    logger.debug("resending message", badMsgNotification.bad_msg_id, "because its ID was too low");
                 }
                 break;
             case 48: // bad server salt
@@ -354,7 +435,7 @@ export class SessionEncrypted extends Session {
         this.#toAcknowledge.push(msgId);
         const pendingPing = this.#pendingPings.get(pong.msg_id);
         if (pendingPing) {
-            pendingPing.resolve(pong);
+            pendingPing.promiseWithResolvers.resolve(pong);
             this.#pendingPings.delete(pong.msg_id);
         }
         else {
@@ -367,9 +448,10 @@ export class SessionEncrypted extends Session {
         this.#toAcknowledge.push(msgId);
     }
     #onMessageContainer(msgId, msgContainer) {
+        this.#LreceiveLoop.debug("received container with ID", msgId, "and", msgContainer.messages.length, "message(s)");
         for (const message of msgContainer.messages) {
             if (message.body instanceof Uint8Array) {
-                this.#onMessage(message.msg_id, message.body);
+                this.#onMessage(message.msg_id, message.body, msgId);
             }
             else {
                 this.#onMessageContainer(msgId, message.body);
@@ -378,49 +460,30 @@ export class SessionEncrypted extends Session {
     }
     //// PING LOOP ////
     #pingInterval = 56 * SECOND;
-    #startPingLoop() {
-        drop(this.#pingLoop());
-    }
-    #pingLoopAbortController;
-    #LpingLoop;
-    async #pingLoop() {
-        this.#pingLoopAbortController?.abort();
-        const controller = this.#pingLoopAbortController = new AbortController();
+    #pingLoop = new AbortableLoop(this.#pingLoopBody.bind(this), (err) => {
+        this.#LpingLoop.error(err);
+    });
+    async #pingLoopBody(_loop, signal) {
         let timeElapsed = 0;
-        while (this.connected) {
-            try {
-                await delay(Math.max(0, this.#pingInterval - timeElapsed), { signal: controller.signal });
-                if (!this.connected) {
-                    continue;
-                }
-                controller.signal.throwIfAborted();
-                const then = Date.now();
-                try {
-                    await this.#sendPingDelayDisconnect(this.#pingInterval / SECOND + 15);
-                }
-                finally {
-                    timeElapsed = Date.now() - then;
-                }
-                controller.signal.throwIfAborted();
-            }
-            catch (err) {
-                if (err instanceof DOMException && err.name === "AbortError") {
-                    break;
-                }
-                else if (!this.connected) {
-                    break;
-                }
-                this.#LpingLoop.error(err);
-            }
+        await delay(Math.max(0, this.#pingInterval - timeElapsed), { signal });
+        if (!this.connected) {
+            return;
+        }
+        signal.throwIfAborted();
+        const then = Date.now();
+        try {
+            await this.#sendPingDelayDisconnect(this.#pingInterval / SECOND + 15);
+        }
+        finally {
+            timeElapsed = Date.now() - then;
         }
+        signal.throwIfAborted();
     }
     async #sendPingDelayDisconnect(disconnect_delay) {
         const ping_id = getRandomId();
         const call = { _: "ping_delay_disconnect", ping_id, disconnect_delay };
         const messageId = await this.send(Mtproto.serializeObject(call));
-        await new Promise((resolve, reject) => {
-            this.#pendingPings.set(messageId, { call, resolve, reject });
-        });
+        this.#pendingPings.set(messageId, { call, promiseWithResolvers: Promise.withResolvers() });
     }
     async #resendPendingPing(pendingPing) {
         try {
@@ -428,7 +491,7 @@ export class SessionEncrypted extends Session {
             this.#pendingPings.set(messageId, pendingPing);
         }
         catch (err) {
-            pendingPing.reject(err);
+            pendingPing.promiseWithResolvers.reject(err);
         }
     }
 }