@mtcute/core 0.30.0 → 0.30.1

package/highlevel/utils/entities.js

@@ -1,3 +1,5 @@
+import Long from "long";
+import { getMarkedPeerId } from "../../utils/peer-utils.js";
 function joinTextWithEntities(parts, delim = "") {
   const textParts = [];
   const newEntities = [];
@@ -29,6 +31,180 @@ function joinTextWithEntities(parts, delim = "") {
     entities: newEntities
   };
 }
+function _entityToRichTextWrapper(entity, text) {
+  const covered = () => text.slice(entity.offset, entity.offset + entity.length);
+  switch (entity._) {
+    case "messageEntityBold":
+      return (inner) => ({ _: "textBold", text: inner });
+    case "messageEntityItalic":
+      return (inner) => ({ _: "textItalic", text: inner });
+    case "messageEntityUnderline":
+      return (inner) => ({ _: "textUnderline", text: inner });
+    case "messageEntityStrike":
+      return (inner) => ({ _: "textStrike", text: inner });
+    case "messageEntityCode":
+    case "messageEntityPre":
+      return (inner) => ({ _: "textFixed", text: inner });
+    case "messageEntitySpoiler":
+      return (inner) => ({ _: "textSpoiler", text: inner });
+    case "messageEntityMention":
+      return (inner) => ({ _: "textMention", text: inner });
+    case "messageEntityHashtag":
+      return (inner) => ({ _: "textHashtag", text: inner });
+    case "messageEntityCashtag":
+      return (inner) => ({ _: "textCashtag", text: inner });
+    case "messageEntityBotCommand":
+      return (inner) => ({ _: "textBotCommand", text: inner });
+    case "messageEntityBankCard":
+      return (inner) => ({ _: "textBankCard", text: inner });
+    case "messageEntityUrl":
+      return (inner) => ({ _: "textUrl", text: inner, url: covered(), webpageId: Long.ZERO });
+    case "messageEntityTextUrl":
+      return (inner) => ({ _: "textUrl", text: inner, url: entity.url, webpageId: Long.ZERO });
+    case "messageEntityEmail":
+      return (inner) => ({ _: "textEmail", text: inner, email: covered() });
+    case "messageEntityPhone":
+      return (inner) => ({ _: "textPhone", text: inner, phone: covered() });
+    case "messageEntityMentionName":
+      return (inner) => ({ _: "textMentionName", text: inner, userId: entity.userId });
+    case "inputMessageEntityMentionName":
+      return (inner) => ({ _: "textMentionName", text: inner, userId: getMarkedPeerId(entity.userId) });
+    case "messageEntityCustomEmoji":
+      return () => ({ _: "textCustomEmoji", documentId: entity.documentId, alt: covered() });
+    case "messageEntityFormattedDate":
+      return (inner) => ({
+        _: "textDate",
+        text: inner,
+        date: entity.date,
+        relative: entity.relative,
+        shortTime: entity.shortTime,
+        longTime: entity.longTime,
+        shortDate: entity.shortDate,
+        longDate: entity.longDate,
+        dayOfWeek: entity.dayOfWeek
+      });
+    default:
+      return null;
+  }
+}
+function textWithEntitiesToRichText(input) {
+  const { text, entities } = input;
+  if (!text) return { _: "textEmpty" };
+  if (!entities?.length) return { _: "textPlain", text };
+  const bounds = /* @__PURE__ */ new Set([0, text.length]);
+  for (const e of entities) {
+    bounds.add(e.offset);
+    bounds.add(e.offset + e.length);
+  }
+  const sorted = [...bounds].filter((b) => b >= 0 && b <= text.length).sort((a, b) => a - b);
+  const segments = [];
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const start = sorted[i];
+    const end = sorted[i + 1];
+    if (start === end) continue;
+    let node = { _: "textPlain", text: text.slice(start, end) };
+    const active = entities.filter((e) => e.offset <= start && e.offset + e.length >= end).sort((a, b) => a.length - b.length);
+    for (const e of active) {
+      const wrap = _entityToRichTextWrapper(e, text);
+      if (wrap) node = wrap(node);
+    }
+    segments.push(node);
+  }
+  if (segments.length === 0) return { _: "textEmpty" };
+  if (segments.length === 1) return segments[0];
+  return { _: "textConcat", texts: segments };
+}
+function _richTextNodeToEntity(node, offset, length) {
+  switch (node._) {
+    case "textBold":
+      return { _: "messageEntityBold", offset, length };
+    case "textItalic":
+      return { _: "messageEntityItalic", offset, length };
+    case "textUnderline":
+      return { _: "messageEntityUnderline", offset, length };
+    case "textStrike":
+      return { _: "messageEntityStrike", offset, length };
+    case "textFixed":
+      return { _: "messageEntityCode", offset, length };
+    case "textSpoiler":
+      return { _: "messageEntitySpoiler", offset, length };
+    case "textMention":
+      return { _: "messageEntityMention", offset, length };
+    case "textHashtag":
+      return { _: "messageEntityHashtag", offset, length };
+    case "textCashtag":
+      return { _: "messageEntityCashtag", offset, length };
+    case "textBotCommand":
+      return { _: "messageEntityBotCommand", offset, length };
+    case "textBankCard":
+      return { _: "messageEntityBankCard", offset, length };
+    case "textUrl":
+      return { _: "messageEntityTextUrl", offset, length, url: node.url };
+    case "textEmail":
+      return { _: "messageEntityEmail", offset, length };
+    case "textPhone":
+      return { _: "messageEntityPhone", offset, length };
+    case "textMentionName":
+      return { _: "messageEntityMentionName", offset, length, userId: node.userId };
+    case "textDate":
+      return {
+        _: "messageEntityFormattedDate",
+        offset,
+        length,
+        date: node.date,
+        relative: node.relative,
+        shortTime: node.shortTime,
+        longTime: node.longTime,
+        shortDate: node.shortDate,
+        longDate: node.longDate,
+        dayOfWeek: node.dayOfWeek
+      };
+    default:
+      return null;
+  }
+}
+function richTextToTextWithEntities(rich) {
+  const entities = [];
+  let text = "";
+  const walk = (node) => {
+    switch (node._) {
+      case "textEmpty":
+        return;
+      case "textPlain":
+        text += node.text;
+        return;
+      case "textConcat":
+        for (const t of node.texts) walk(t);
+        return;
+      case "textImage":
+        return;
+      case "textMath":
+        text += node.source;
+        return;
+      case "textCustomEmoji": {
+        const start = text.length;
+        text += node.alt;
+        entities.push({
+          _: "messageEntityCustomEmoji",
+          offset: start,
+          length: text.length - start,
+          documentId: node.documentId
+        });
+        return;
+      }
+      default: {
+        const start = text.length;
+        walk(node.text);
+        const entity = _richTextNodeToEntity(node, start, text.length - start);
+        if (entity) entities.push(entity);
+      }
+    }
+  };
+  walk(rich);
+  return { text, entities };
+}
 export {
-  joinTextWithEntities
+  joinTextWithEntities,
+  richTextToTextWithEntities,
+  textWithEntitiesToRichText
 };

package/index.cjs

@@ -56,7 +56,8 @@ const messageReactions = require("./highlevel/types/messages/message-reactions.c
 const messageReplies = require("./highlevel/types/messages/message-replies.cjs");
 const message = require("./highlevel/types/messages/message.cjs");
 const repliedMessage = require("./highlevel/types/messages/replied-message.cjs");
-const richMessage = require("./highlevel/types/messages/rich-message.cjs");
+const richMessage = require("./highlevel/types/messages/rich/rich-message.cjs");
+const inner$1 = require("./highlevel/types/messages/rich/inner.cjs");
 const searchFilters = require("./highlevel/types/messages/search-filters.cjs");
 const suggestedPost = require("./highlevel/types/messages/suggested-post.cjs");
 const collectibleInfo = require("./highlevel/types/misc/collectible-info.cjs");
@@ -227,6 +228,7 @@ exports.MessageRepliesInfo = messageReplies.MessageRepliesInfo;
 exports.Message = message.Message;
 exports.RepliedMessageInfo = repliedMessage.RepliedMessageInfo;
 exports.RichMessage = richMessage.RichMessage;
+exports.Rich = inner$1;
 exports.SearchFilters = searchFilters.SearchFilters;
 exports.SuggestedPostInfo = suggestedPost.SuggestedPostInfo;
 exports.CollectibleInfo = collectibleInfo.CollectibleInfo;

package/index.js

@@ -49,7 +49,8 @@ import { MessageReactions } from "./highlevel/types/messages/message-reactions.j
 import { MessageRepliesInfo } from "./highlevel/types/messages/message-replies.js";
 import { Message } from "./highlevel/types/messages/message.js";
 import { RepliedMessageInfo } from "./highlevel/types/messages/replied-message.js";
-import { RichMessage } from "./highlevel/types/messages/rich-message.js";
+import { RichMessage } from "./highlevel/types/messages/rich/rich-message.js";
+import * as inner$1 from "./highlevel/types/messages/rich/inner.js";
 import { SearchFilters } from "./highlevel/types/messages/search-filters.js";
 import { SuggestedPostInfo } from "./highlevel/types/messages/suggested-post.js";
 import { CollectibleInfo } from "./highlevel/types/misc/collectible-info.js";
@@ -272,6 +273,7 @@ export {
   RawUpdateInfo,
   ReactionCount,
   RepliedMessageInfo,
+  inner$1 as Rich,
   RichMessage,
   SavedStarGift,
   SearchFilters,

package/methods.cjs

@@ -157,6 +157,7 @@ const iterInviteLinks = require("./highlevel/methods/invite-links/iter-invite-li
 const revokeInviteLink = require("./highlevel/methods/invite-links/revoke-invite-link.cjs");
 const appendTodoList = require("./highlevel/methods/messages/append-todo-list.cjs");
 const closePoll = require("./highlevel/methods/messages/close-poll.cjs");
+const createRichStreamingDraft = require("./highlevel/methods/messages/create-rich-streaming-draft.cjs");
 const createStreamingDraft = require("./highlevel/methods/messages/create-streaming-draft.cjs");
 const deleteMessages = require("./highlevel/methods/messages/delete-messages.cjs");
 const deleteScheduledMessages = require("./highlevel/methods/messages/delete-scheduled-messages.cjs");
@@ -199,6 +200,7 @@ const sendPaidReaction = require("./highlevel/methods/messages/send-paid-reactio
 const sendQuote = require("./highlevel/methods/messages/send-quote.cjs");
 const sendReaction = require("./highlevel/methods/messages/send-reaction.cjs");
 const sendReply = require("./highlevel/methods/messages/send-reply.cjs");
+const sendRichMessage = require("./highlevel/methods/messages/send-rich-message.cjs");
 const sendScheduled = require("./highlevel/methods/messages/send-scheduled.cjs");
 const sendText = require("./highlevel/methods/messages/send-text.cjs");
 const sendTyping = require("./highlevel/methods/messages/send-typing.cjs");
@@ -444,6 +446,7 @@ exports.iterInviteLinks = iterInviteLinks.iterInviteLinks;
 exports.revokeInviteLink = revokeInviteLink.revokeInviteLink;
 exports.appendTodoList = appendTodoList.appendTodoList;
 exports.closePoll = closePoll.closePoll;
+exports.createRichStreamingDraft = createRichStreamingDraft.createRichStreamingDraft;
 exports.createStreamingDraft = createStreamingDraft.createStreamingDraft;
 exports.deleteMessages = deleteMessages.deleteMessages;
 exports.deleteMessagesById = deleteMessages.deleteMessagesById;
@@ -498,6 +501,7 @@ exports.sendReaction = sendReaction.sendReaction;
 exports.replyMedia = sendReply.replyMedia;
 exports.replyMediaGroup = sendReply.replyMediaGroup;
 exports.replyText = sendReply.replyText;
+exports.sendRichMessage = sendRichMessage.sendRichMessage;
 exports.sendScheduled = sendScheduled.sendScheduled;
 exports.sendText = sendText.sendText;
 exports.sendTyping = sendTyping.sendTyping;

package/methods.js

@@ -150,6 +150,7 @@ import { iterInviteLinks } from "./highlevel/methods/invite-links/iter-invite-li
 import { revokeInviteLink } from "./highlevel/methods/invite-links/revoke-invite-link.js";
 import { appendTodoList } from "./highlevel/methods/messages/append-todo-list.js";
 import { closePoll } from "./highlevel/methods/messages/close-poll.js";
+import { createRichStreamingDraft } from "./highlevel/methods/messages/create-rich-streaming-draft.js";
 import { createStreamingDraft } from "./highlevel/methods/messages/create-streaming-draft.js";
 import { deleteMessages, deleteMessagesById } from "./highlevel/methods/messages/delete-messages.js";
 import { deleteScheduledMessages } from "./highlevel/methods/messages/delete-scheduled-messages.js";
@@ -192,6 +193,7 @@ import { sendPaidReaction } from "./highlevel/methods/messages/send-paid-reactio
 import { quoteWithMedia, quoteWithMediaGroup, quoteWithText } from "./highlevel/methods/messages/send-quote.js";
 import { sendReaction } from "./highlevel/methods/messages/send-reaction.js";
 import { replyMedia, replyMediaGroup, replyText } from "./highlevel/methods/messages/send-reply.js";
+import { sendRichMessage } from "./highlevel/methods/messages/send-rich-message.js";
 import { sendScheduled } from "./highlevel/methods/messages/send-scheduled.js";
 import { sendText } from "./highlevel/methods/messages/send-text.js";
 import { sendTyping } from "./highlevel/methods/messages/send-typing.js";
@@ -320,6 +322,7 @@ export {
   createForumTopic,
   createGroup,
   createInviteLink,
+  createRichStreamingDraft,
   createStickerSet,
   createStreamingDraft,
   createSupergroup,
@@ -520,6 +523,7 @@ export {
   sendPaidReaction,
   sendReaction,
   sendRecoveryCode,
+  sendRichMessage,
   sendScheduled,
   sendStarGift,
   sendStarGiftOffer,

package/network/mtproxy/_fake-tls.cjs

@@ -8,6 +8,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const io = require("@fuman/io");
 const utils = require("@fuman/utils");
 const MAX_TLS_PACKET_LENGTH = 2878;
+const MAX_TLS_HELLO_SIZE = 4096;
 const KEY_MOD = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEDn;
 const QUAD_RES_MOD = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEDn;
 const QUAD_RES_POW = 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF6n;
@@ -34,7 +35,11 @@ function _isQuadraticResidue(a) {
   return r === 1n;
 }
 function executeTlsOperations(h) {
-  h.string([22, 3, 1, 2, 0, 1, 0, 1, 252, 3, 3]);
+  h.string([22, 3, 1]);
+  h.beginScope();
+  h.string([1, 0]);
+  h.beginScope();
+  h.string([3, 3]);
   h.zero(32);
   h.string([32]);
   h.random(32);
@@ -72,67 +77,34 @@ function executeTlsOperations(h) {
     0,
     53,
     1,
-    0,
-    1,
-    147
+    0
   ]);
-  h.grease(2);
-  h.string([0, 0, 0, 0]);
-  h.beginScope();
   h.beginScope();
-  h.string([0]);
-  h.beginScope();
-  h.domain();
-  h.endScope();
-  h.endScope();
-  h.endScope();
-  h.string([0, 23, 0, 0, 255, 1, 0, 1, 0, 0, 10, 0, 10, 0, 8]);
-  h.grease(4);
-  h.string(
-    [
-      0,
-      29,
-      0,
-      23,
-      0,
-      24,
-      0,
-      11,
-      0,
-      2,
-      1,
-      0,
-      0,
-      35,
-      0,
-      0,
-      0,
-      16,
-      0,
-      14,
-      0,
-      12,
-      2,
-      104,
-      50,
-      8,
-      104,
-      116,
-      116,
-      112,
-      47,
-      49,
-      46,
-      49,
-      0,
-      5,
-      0,
-      5,
-      1,
-      0,
-      0,
-      0,
-      0,
+  h.grease(2);
+  h.string([0, 0]);
+  h.permutation([
+    (w) => {
+      w.string([0, 0]);
+      w.beginScope();
+      w.beginScope();
+      w.string([0]);
+      w.beginScope();
+      w.domain();
+      w.endScope();
+      w.endScope();
+      w.endScope();
+    },
+    (w) => w.string([0, 5, 0, 5, 1, 0, 0, 0, 0]),
+    // status_request
+    (w) => {
+      w.string([0, 10, 0, 12, 0, 10]);
+      w.grease(4);
+      w.string([17, 236, 0, 29, 0, 23, 0, 24]);
+    },
+    (w) => w.string([0, 11, 0, 2, 1, 0]),
+    // ec_point_formats
+    (w) => w.string([
+      // signature_algorithms
       0,
       13,
       0,
@@ -154,27 +126,76 @@ function executeTlsOperations(h) {
       8,
       6,
       6,
-      1,
+      1
+    ]),
+    (w) => w.string([
+      // application_layer_protocol_negotiation (ALPN)
       0,
-      18,
-      0,
-      0,
-      0,
-      51,
+      16,
       0,
-      43,
+      14,
       0,
-      41
-    ]
-  );
-  h.grease(4);
-  h.string([0, 1, 0, 0, 29, 0, 32]);
-  h.key();
-  h.string([0, 45, 0, 2, 1, 1, 0, 43, 0, 11, 10]);
-  h.grease(6);
-  h.string([3, 4, 3, 3, 3, 2, 3, 1, 0, 27, 0, 3, 2, 0, 2]);
+      12,
+      2,
+      104,
+      50,
+      8,
+      104,
+      116,
+      116,
+      112,
+      47,
+      49,
+      46,
+      49
+    ]),
+    (w) => w.string([0, 18, 0, 0]),
+    // signed_certificate_timestamp
+    (w) => w.string([0, 23, 0, 0]),
+    // extended_master_secret
+    (w) => w.string([0, 27, 0, 3, 2, 0, 2]),
+    // compress_certificate
+    (w) => w.string([0, 35, 0, 0]),
+    // session_ticket
+    (w) => {
+      w.string([0, 43, 0, 7, 6]);
+      w.grease(6);
+      w.string([3, 4, 3, 3]);
+    },
+    (w) => w.string([0, 45, 0, 2, 1, 1]),
+    // psk_key_exchange_modes
+    (w) => {
+      w.string([0, 51, 4, 239, 4, 237]);
+      w.grease(4);
+      w.string([0, 1, 0, 17, 236, 4, 192]);
+      w.mlKem768Key();
+      w.key();
+      w.string([0, 29, 0, 32]);
+      w.key();
+    },
+    (w) => w.string([68, 205, 0, 5, 0, 3, 2, 104, 50]),
+    // application_settings (ALPS)
+    (w) => {
+      w.string([254, 13]);
+      w.beginScope();
+      w.string([0, 0, 1, 0, 1]);
+      w.random(1);
+      w.string([0, 32]);
+      w.random(32);
+      w.beginScope();
+      w.echPayload();
+      w.endScope();
+      w.endScope();
+    },
+    (w) => w.string([255, 1, 0, 1, 0])
+    // renegotiation_info
+  ]);
   h.grease(3);
-  h.string([0, 1, 0, 0, 21]);
+  h.string([0, 1, 0]);
+  h.padding();
+  h.endScope();
+  h.endScope();
+  h.endScope();
 }
 function initGrease(crypto, size) {
   const buf = crypto.randomBytes(size);
@@ -189,12 +210,12 @@ function initGrease(crypto, size) {
   return buf;
 }
 class TlsHelloWriter {
-  constructor(crypto, size, domain) {
+  constructor(crypto, domain, grease) {
     this.crypto = crypto;
     this._domain = domain;
-    this.buf = utils.u8.alloc(size);
+    this.buf = utils.u8.alloc(MAX_TLS_HELLO_SIZE);
     this.dv = utils.typed.toDataView(this.buf);
-    this._grease = initGrease(this.crypto, 7);
+    this._grease = grease ?? initGrease(this.crypto, 7);
   }
   buf;
   dv;
@@ -235,6 +256,24 @@ class TlsHelloWriter {
       }
     }
   }
+  // fake X25519MLKEM768 hybrid keyshare's ml-kem-768 part: 384 coefficients
+  // (mod 3329) packed 3 bytes per 2 coefficients, followed by 32 random bytes
+  mlKem768Key() {
+    const rnd = this.crypto.randomBytes(384 * 8);
+    const dv = utils.typed.toDataView(rnd);
+    for (let i = 0; i < 384; i++) {
+      const a = dv.getUint32(i * 8, true) % 3329;
+      const b = dv.getUint32(i * 8 + 4, true) % 3329;
+      this.buf[this.pos++] = a & 255;
+      this.buf[this.pos++] = (a >> 8) + ((b & 15) << 4);
+      this.buf[this.pos++] = b >> 4;
+    }
+    this.random(32);
+  }
+  // GREASE ECH payload: random bytes of length 144/176/208/240
+  echPayload() {
+    this.random(this._randomInt(4) * 32 + 144);
+  }
   beginScope() {
     this._scopes.push(this.pos);
     this.pos += 2;
@@ -244,29 +283,55 @@ class TlsHelloWriter {
     if (begin === void 0) {
       throw new Error("endScope called without beginScope");
     }
-    const end = this.pos;
-    const size = end - begin - 2;
-    this.dv.setUint16(begin, size);
+    this.dv.setUint16(begin, this.pos - begin - 2);
   }
-  async finish(secret) {
-    const padSize = 515 - this.pos;
-    const unixTime = ~~(Date.now() / 1e3);
+  // render each part into its own buffer, then emit them in random order —
+  // mimics chrome's per-connection tls extension shuffling
+  permutation(parts) {
+    const rendered = parts.map((fn) => {
+      const sub = new TlsHelloWriter(this.crypto, this._domain, this._grease);
+      fn(sub);
+      return sub.buf.subarray(0, sub.pos);
+    });
+    for (let i = rendered.length - 1; i > 0; i--) {
+      const j = this._randomInt(i + 1);
+      const tmp = rendered[i];
+      rendered[i] = rendered[j];
+      rendered[j] = tmp;
+    }
+    for (const part of rendered) {
+      this.string(part);
+    }
+  }
+  // tls padding extension, only emitted for hellos smaller than 513 bytes
+  padding() {
+    if (this.pos >= 513) return;
+    const size = 513 - this.pos;
+    this.string([0, 21]);
     this.beginScope();
-    this.zero(padSize);
+    this.zero(size);
     this.endScope();
-    const hash = await this.crypto.hmacSha256(this.buf, secret);
+  }
+  _randomInt(max) {
+    return utils.typed.toDataView(this.crypto.randomBytes(4)).getUint32(0, true) % max;
+  }
+  async finish(secret) {
+    const data = this.buf.subarray(0, this.pos);
+    const unixTime = ~~(Date.now() / 1e3);
+    const hash = await this.crypto.hmacSha256(data, secret);
     const dv = utils.typed.toDataView(hash);
     const old = dv.getInt32(28, true);
     dv.setInt32(28, old ^ unixTime, true);
-    this.buf.set(hash, 11);
-    return this.buf;
+    data.set(hash, 11);
+    return data;
   }
 }
 async function generateFakeTlsHeader(domain, secret, crypto) {
-  const writer = new TlsHelloWriter(crypto, 517, domain);
+  const writer = new TlsHelloWriter(crypto, domain);
   executeTlsOperations(writer);
   return writer.finish(secret);
 }
+const EMPTY_BYTES = io.Bytes.from(utils.u8.empty);
 class FakeTlsPacketCodec {
   // protected _stream: Buffer = Buffer.alloc(0)
   constructor(_inner) {
@@ -301,23 +366,20 @@ class FakeTlsPacketCodec {
   }
   async decode(reader, eof) {
     if (eof) return null;
-    if (reader.available < 5) return null;
-    const header = reader.readSync(3);
-    if (header[0] !== 23 || header[1] !== 3 || header[2] !== 3) {
-      throw new Error("Invalid TLS header");
-    }
-    const length = io.read.uint16be(reader);
-    if (length < reader.available - 5) {
-      reader.rewind(5);
-      return null;
-    }
-    const packet = reader.readSync(length);
-    const inner = await this._inner.decode(io.Bytes.from(packet), eof);
-    if (!inner) {
-      reader.rewind(5 + length);
-      return null;
+    while (reader.available >= 5) {
+      const header = reader.readSync(3);
+      if (header[0] !== 23 || header[1] !== 3 || header[2] !== 3) {
+        throw new Error("Invalid TLS header");
+      }
+      const length = io.read.uint16be(reader);
+      if (reader.available < length) {
+        reader.rewind(5);
+        break;
+      }
+      const inner = await this._inner.decode(io.Bytes.from(reader.readSync(length)), eof);
+      if (inner) return inner;
     }
-    return inner;
+    return this._inner.decode(EMPTY_BYTES, eof);
   }
   reset() {
     this._isFirstTls = true;