@tgsnake/skema 1.13.0 → 2.0.0

package/dist/src/raw/core/Message.js

@@ -0,0 +1,105 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { TLObject } from './TLObject.js';
+import { BytesIO, Buffer } from '../../deps.js';
+import * as Primitive from './primitive/index.js';
+/**
+ * Utility helper converting a 64-bit integer into a little-endian byte representation.
+ *
+ * @param value - The bigint value to convert.
+ * @returns A Buffer representing the little-endian bytes of the bigint.
+ */
+function toBytes(value) {
+    const bytesArray = [];
+    for (let i = 0; i < 8; i++) {
+        let shift = value >> BigInt(8 * i);
+        shift &= BigInt(255);
+        bytesArray[i] = Number(String(shift));
+    }
+    return Buffer.from(bytesArray);
+}
+/**
+ * Represents a standard MTProto transport container message.
+ *
+ * @remarks
+ * Every message transmitted or received over the MTProto protocol is wrapped in a `Message` envelope.
+ * The envelope includes metadata crucial for routing and ordering: the message ID (which indicates
+ * client/server time synchronization), the message sequence number, the body byte length, and the actual
+ * serialized payload/body TLObject.
+ *
+ * @extends TLObject
+ */
+export class Message extends TLObject {
+    /**
+     * The unique class ID identifier representing `Message` (0x5bb8e511).
+     */
+    static ID = 0x5bb8e511; // hex(crc32(b"message msg_id:long seqno:int bytes:int body:Object = Message"))
+    /**
+     * The unique 64-bit message identifier, representing the creation time of the message in seconds multiplied by 2^32.
+     */
+    msgId;
+    /**
+     * The message sequence number, indicating the order of the message in the session.
+     */
+    seqNo;
+    /**
+     * The length of the serialized message body in bytes.
+     */
+    length;
+    /**
+     * The inner body deserialized as a `TLObject`.
+     */
+    body;
+    /**
+     * Constructs a new Message envelope.
+     *
+     * @param body - The inner body payload of the message.
+     * @param msgId - The 64-bit message identifier.
+     * @param seqNo - The session message sequence number.
+     * @param length - The byte length of the body.
+     */
+    constructor(body, msgId, seqNo, length) {
+        super();
+        this.className = 'Message';
+        this._slots = ['body', 'msgId', 'seqNo', 'length'];
+        this.msgId = msgId;
+        this.seqNo = seqNo;
+        this.length = length;
+        this.body = body;
+    }
+    /**
+     * Reads and deserializes a `Message` envelope from a binary stream.
+     *
+     * @param data - The `BytesIO` stream containing the serialized message envelope.
+     * @param _args - Unused additional parameters.
+     * @returns A promise resolving to the deserialized `Message` instance.
+     */
+    static async read(data, ..._args) {
+        const msgId = await Primitive.Long.read(data);
+        const seqNo = await Primitive.Int.read(data);
+        const length = await Primitive.Int.read(data);
+        const body = data.read(length);
+        return new Message(await TLObject.read(new BytesIO(body)), msgId, seqNo, length);
+    }
+    /**
+     * Serializes the message envelope and its body into a raw binary buffer.
+     *
+     * @override
+     * @returns A Buffer representing the complete message envelope structure.
+     */
+    write() {
+        const bytes = new BytesIO();
+        bytes.write(toBytes(this.msgId));
+        bytes.write(Primitive.Int.write(this.seqNo));
+        bytes.write(Primitive.Int.write(this.length));
+        bytes.write(this.body.write());
+        return Buffer.from(bytes.buffer);
+    }
+}

package/dist/src/raw/core/MsgContainer.d.ts

@@ -0,0 +1,56 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { TLObject } from './TLObject.js';
+import { BytesIO, Buffer } from '../../deps.js';
+import { Message } from './Message.js';
+/**
+ * Represents a standard MTProto Message Container (`msg_container`).
+ *
+ * @remarks
+ * A message container is a core MTProto concept allowing multiple independent messages (requests or updates)
+ * to be grouped together and sent within a single network transaction. This reduces overhead and enables
+ * parallel execution or efficient state synchronization between client and server.
+ *
+ * @extends TLObject
+ */
+export declare class MsgContainer extends TLObject {
+    /**
+     * The unique class ID identifier representing `MsgContainer` (0x73f1f8dc).
+     */
+    static ID: number;
+    /**
+     * The list of MTProto `Message` envelopes packaged inside this container.
+     */
+    messages: Array<Message>;
+    /**
+     * Constructs a new MsgContainer.
+     *
+     * @param messages - An array of `Message` instances to package.
+     */
+    constructor(messages: Array<Message>);
+    /**
+     * Reads, unpacks, and deserializes a `MsgContainer` from a binary stream.
+     *
+     * @remarks
+     * Reads the message count prefix, then iterates sequentially to deserialize each nested `Message` envelope.
+     *
+     * @param data - The `BytesIO` stream containing the serialized message container.
+     * @param _args - Unused additional parameters.
+     * @returns A promise resolving to the deserialized `MsgContainer` instance.
+     */
+    static read(data: BytesIO, ..._args: Array<any>): Promise<MsgContainer>;
+    /**
+     * Serializes the container header, message counts, and nested envelopes into a raw binary buffer.
+     *
+     * @override
+     * @returns A Buffer containing the serialized representation of the message container.
+     */
+    write(): Buffer;
+}

package/dist/src/raw/core/MsgContainer.js

@@ -0,0 +1,77 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { TLObject } from './TLObject.js';
+import { BytesIO, Buffer } from '../../deps.js';
+import * as Primitive from './primitive/index.js';
+import { Message } from './Message.js';
+/**
+ * Represents a standard MTProto Message Container (`msg_container`).
+ *
+ * @remarks
+ * A message container is a core MTProto concept allowing multiple independent messages (requests or updates)
+ * to be grouped together and sent within a single network transaction. This reduces overhead and enables
+ * parallel execution or efficient state synchronization between client and server.
+ *
+ * @extends TLObject
+ */
+export class MsgContainer extends TLObject {
+    /**
+     * The unique class ID identifier representing `MsgContainer` (0x73f1f8dc).
+     */
+    static ID = 0x73f1f8dc;
+    /**
+     * The list of MTProto `Message` envelopes packaged inside this container.
+     */
+    messages;
+    /**
+     * Constructs a new MsgContainer.
+     *
+     * @param messages - An array of `Message` instances to package.
+     */
+    constructor(messages) {
+        super();
+        this._slots = ['messages'];
+        this.className = 'MsgContainer';
+        this.messages = messages;
+    }
+    /**
+     * Reads, unpacks, and deserializes a `MsgContainer` from a binary stream.
+     *
+     * @remarks
+     * Reads the message count prefix, then iterates sequentially to deserialize each nested `Message` envelope.
+     *
+     * @param data - The `BytesIO` stream containing the serialized message container.
+     * @param _args - Unused additional parameters.
+     * @returns A promise resolving to the deserialized `MsgContainer` instance.
+     */
+    static async read(data, ..._args) {
+        const count = await Primitive.Int.read(data);
+        const messages = [];
+        for (let i = 0; i < count; i++) {
+            messages.push(await Message.read(data));
+        }
+        return new MsgContainer(messages);
+    }
+    /**
+     * Serializes the container header, message counts, and nested envelopes into a raw binary buffer.
+     *
+     * @override
+     * @returns A Buffer containing the serialized representation of the message container.
+     */
+    write() {
+        const bytes = new BytesIO();
+        bytes.write(Primitive.Int.write(MsgContainer.ID, false));
+        bytes.write(Primitive.Int.write(this.messages.length));
+        for (const message of this.messages) {
+            bytes.write(message.write());
+        }
+        return Buffer.from(bytes.buffer);
+    }
+}

package/dist/src/raw/core/TLObject.d.ts

@@ -0,0 +1,108 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { BytesIO, Buffer } from '../../deps.js';
+/**
+ * Base abstract class for all Type Language (TL) schema objects within the MTProto protocol.
+ *
+ * @remarks
+ * In the Telegram MTProto protocol, messages and API payloads are defined in a custom ID-based schema language
+ * called Type Language (TL). `TLObject` is the root class providing fundamental binary serialization (`write`)
+ * and deserialization (`read`) interfaces, alongside custom console print formatters and standard JSON serializers.
+ */
+export declare class TLObject {
+    /**
+     * The internal slot list storing serialization field property names.
+     *
+     * @internal
+     */
+    _slots: Array<string>;
+    /**
+     * A dynamic reference to the current subclass constructor.
+     * Enables late static binding for instance methods to access static helper operations.
+     */
+    cls: any;
+    /**
+     * The unique 32-bit integer identifier (CRC32 checksum) of this TL constructor.
+     */
+    constructorId: number;
+    /**
+     * The unique 32-bit integer identifier of the parent/abstract type this TL subclass represents.
+     */
+    subclassOfId: number;
+    /**
+     * The canonical string name of this class representation.
+     */
+    className: string;
+    /**
+     * The underlying classification type (e.g. `request`, `constructor`, `function`).
+     */
+    classType: string;
+    /**
+     * Constructs a new TLObject instance, initializing slots and late-bound constructors.
+     */
+    constructor();
+    /**
+     * Reads and deserializes a generic TLObject from a binary stream.
+     *
+     * @remarks
+     * This method first reads the leading 32-bit little-endian integer from the stream, which is
+     * treated as the unique `constructorId` (or Class ID). It resolves the constructor class dynamically
+     * from the global TL object map (`AllTLObject`) and delegates parsing to the subclass's static `read` method.
+     *
+     * @param data - The `BytesIO` buffer stream containing the serialized TLObject.
+     * @param args - Additional arguments passed down to the resolved subclass's static read implementation.
+     * @returns A promise resolving to the parsed class instance.
+     */
+    static read(data: BytesIO, ...args: Array<any>): Promise<any>;
+    /**
+     * Serializes constructor arguments into a raw binary buffer.
+     *
+     * @remarks
+     * This base implementation acts as an abstract stub returning an empty Buffer. Subclasses override
+     * this static method to handle specific binary serialization layouts.
+     *
+     * @param _args - Arguments to be serialized.
+     * @returns An empty `Buffer` of size 0.
+     */
+    static write(..._args: Array<any>): Buffer;
+    /**
+     * Deserializes a binary stream into this specific TLObject instance.
+     *
+     * @param data - The `BytesIO` buffer stream containing the serialized TLObject.
+     * @param args - Additional arguments passed down to the read parser.
+     * @returns A promise resolving to the parsed instance.
+     */
+    read(data: BytesIO, ...args: Array<any>): Promise<any>;
+    /**
+     * Serializes the current class instance into a raw binary buffer.
+     *
+     * @param args - Arguments passed down to the writer.
+     * @returns A Buffer containing the serialized representation of this object.
+     */
+    write(...args: Array<any>): Buffer;
+    /**
+     * Serializes the TLObject instance to a clean JSON-compatible representation.
+     *
+     * @remarks
+     * Correctly stringifies extremely large fields (e.g. bigints) that are normally not
+     * serializable in standard `JSON.stringify` calls.
+     *
+     * @returns A plain object containing class attributes and values.
+     */
+    toJSON(): {
+        [key: string]: any;
+    };
+    /**
+     * Formats the TLObject into a structured string.
+     *
+     * @returns A string starting with the constructor name followed by a pretty JSON payload.
+     */
+    toString(): string;
+}

package/dist/src/raw/core/TLObject.js

@@ -0,0 +1,209 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+import { AllTLObject } from '../All.js';
+import { Buffer, inspect } from '../../deps.js';
+import { Logger } from '../../Logger.js';
+import { Raw, Message, GzipPacked, Primitive, MsgContainer } from '../index.js';
+function getModule(name) {
+    if (!name) {
+        throw new Error("name of module can't be undefined");
+    }
+    if (name === 'Message') {
+        return Message;
+    }
+    else if (name === 'GzipPacked') {
+        return GzipPacked;
+    }
+    else if (name === 'MsgContainer') {
+        return MsgContainer;
+    }
+    else if (name.startsWith('Primitive')) {
+        return Primitive[name.split('.')[1]];
+    }
+    else {
+        const split = name.split('.');
+        if (split.length == 3) {
+            return Raw[split[1]][split[2]];
+        }
+        return Raw[split[1]];
+    }
+}
+/**
+ * Base abstract class for all Type Language (TL) schema objects within the MTProto protocol.
+ *
+ * @remarks
+ * In the Telegram MTProto protocol, messages and API payloads are defined in a custom ID-based schema language
+ * called Type Language (TL). `TLObject` is the root class providing fundamental binary serialization (`write`)
+ * and deserialization (`read`) interfaces, alongside custom console print formatters and standard JSON serializers.
+ */
+export class TLObject {
+    /**
+     * The internal slot list storing serialization field property names.
+     *
+     * @internal
+     */
+    _slots;
+    /**
+     * A dynamic reference to the current subclass constructor.
+     * Enables late static binding for instance methods to access static helper operations.
+     */
+    cls = this.constructor;
+    /**
+     * The unique 32-bit integer identifier (CRC32 checksum) of this TL constructor.
+     */
+    constructorId;
+    /**
+     * The unique 32-bit integer identifier of the parent/abstract type this TL subclass represents.
+     */
+    subclassOfId;
+    /**
+     * The canonical string name of this class representation.
+     */
+    className;
+    /**
+     * The underlying classification type (e.g. `request`, `constructor`, `function`).
+     */
+    classType;
+    /**
+     * Constructs a new TLObject instance, initializing slots and late-bound constructors.
+     */
+    constructor() {
+        this._slots = [];
+        this.constructorId = this.cls.ID ?? 0;
+        this.className = 'TLObject';
+    }
+    /**
+     * Reads and deserializes a generic TLObject from a binary stream.
+     *
+     * @remarks
+     * This method first reads the leading 32-bit little-endian integer from the stream, which is
+     * treated as the unique `constructorId` (or Class ID). It resolves the constructor class dynamically
+     * from the global TL object map (`AllTLObject`) and delegates parsing to the subclass's static `read` method.
+     *
+     * @param data - The `BytesIO` buffer stream containing the serialized TLObject.
+     * @param args - Additional arguments passed down to the resolved subclass's static read implementation.
+     * @returns A promise resolving to the parsed class instance.
+     */
+    static async read(data, ...args) {
+        const id = data.readUInt32LE(4);
+        Logger.debug(`[10] Reading TLObject with id: ${id.toString(16)} (${AllTLObject[id]})`);
+        const _class = getModule(AllTLObject[id]);
+        return await _class.read(data, ...args);
+    }
+    /**
+     * Serializes constructor arguments into a raw binary buffer.
+     *
+     * @remarks
+     * This base implementation acts as an abstract stub returning an empty Buffer. Subclasses override
+     * this static method to handle specific binary serialization layouts.
+     *
+     * @param _args - Arguments to be serialized.
+     * @returns An empty `Buffer` of size 0.
+     */
+    static write(..._args) {
+        return Buffer.alloc(0);
+    }
+    /**
+     * Deserializes a binary stream into this specific TLObject instance.
+     *
+     * @param data - The `BytesIO` buffer stream containing the serialized TLObject.
+     * @param args - Additional arguments passed down to the read parser.
+     * @returns A promise resolving to the parsed instance.
+     */
+    read(data, ...args) {
+        return this.cls.read(data, ...args);
+    }
+    /**
+     * Serializes the current class instance into a raw binary buffer.
+     *
+     * @param args - Arguments passed down to the writer.
+     * @returns A Buffer containing the serialized representation of this object.
+     */
+    write(...args) {
+        return this.cls.write(...args);
+    }
+    /**
+     * Custom inspect handler for Node.js console output (`util.inspect`).
+     * Omits private properties (prefixed with `_`) and structural metadata to keep console outputs clean.
+     *
+     * @ignore
+     * @returns An object containing enumerable public properties to display.
+     */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        const toPrint = {
+            _: this.className,
+        };
+        const ignore = ['slots', 'className', 'constructorId', 'subclassOfId', 'classType', 'cls'];
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (ignore.includes(key))
+                    continue;
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    toPrint[key] = value;
+                }
+            }
+        }
+        return toPrint;
+    }
+    /**
+     * Custom inspect handler for Deno runtime terminal output (`Deno.inspect`).
+     * Wraps the Node.js inspect output and enables terminal colors.
+     *
+     * @ignore
+     * @returns The colorized, formatted representation of the TLObject.
+     */
+    [Symbol.for('Deno.customInspect')]() {
+        // @ts-ignore: deno compatibility
+        return String(inspect(this[Symbol.for('nodejs.util.inspect.custom')](), { colors: true }));
+    }
+    /**
+     * Serializes the TLObject instance to a clean JSON-compatible representation.
+     *
+     * @remarks
+     * Correctly stringifies extremely large fields (e.g. bigints) that are normally not
+     * serializable in standard `JSON.stringify` calls.
+     *
+     * @returns A plain object containing class attributes and values.
+     */
+    toJSON() {
+        const toPrint = {
+            _: this.className,
+        };
+        const ignore = ['slots', 'className', 'constructorId', 'subclassOfId', 'classType', 'cls'];
+        for (const key in this) {
+            if (Object.prototype.hasOwnProperty.call(this, key)) {
+                const value = this[key];
+                if (ignore.includes(key))
+                    continue;
+                if (!key.startsWith('_') && value !== undefined && value !== null) {
+                    if (typeof value === 'bigint') {
+                        toPrint[key] = String(value);
+                    }
+                    else if (Array.isArray(value)) {
+                        toPrint[key] = value.map((v) => (typeof v === 'bigint' ? String(v) : v));
+                    }
+                    else {
+                        toPrint[key] = value;
+                    }
+                }
+            }
+        }
+        return toPrint;
+    }
+    /**
+     * Formats the TLObject into a structured string.
+     *
+     * @returns A string starting with the constructor name followed by a pretty JSON payload.
+     */
+    toString() {
+        return `[constructor of ${this.className}] ${JSON.stringify(this, null, 2)}`;
+    }
+}

package/dist/src/raw/core/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+/**
+ * Re-exports core MTProto primitive builders, zlib compression packer,
+ * message envelopes, message containers, and the base TLObject class.
+ */
+import * as Primitive from './primitive/index.js';
+export { Primitive };
+export { TLObject } from './TLObject.js';
+export { GzipPacked } from './GzipPacked.js';
+export { Message } from './Message.js';
+export { MsgContainer } from './MsgContainer.js';

package/dist/src/raw/core/index.js

@@ -0,0 +1,19 @@
+/**
+ * tgsnake - Telegram MTProto library for javascript or typescript.
+ * Copyright (C) 2026 tgsnake <https://github.com/tgsnake>
+ *
+ * THIS FILE IS PART OF TGSNAKE
+ *
+ * tgsnake is a free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License as published.
+ */
+/**
+ * Re-exports core MTProto primitive builders, zlib compression packer,
+ * message envelopes, message containers, and the base TLObject class.
+ */
+import * as Primitive from './primitive/index.js';
+export { Primitive };
+export { TLObject } from './TLObject.js';
+export { GzipPacked } from './GzipPacked.js';
+export { Message } from './Message.js';
+export { MsgContainer } from './MsgContainer.js';