@mtcute/core 0.28.2 → 0.29.0

package/highlevel/utils/peer-utils.cjs

@@ -5,12 +5,12 @@ if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WAR
 }
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const tl = require("@mtcute/tl");
 const utils = require("../../types/utils.cjs");
 const errors = require("../types/errors.cjs");
+const innerTl = require("../../tl/inner-tl.cjs");
 const INVITE_LINK_REGEX = /^(?:https?:\/\/)?(?:www\.)?t(?:elegram)?\.(?:org|me|dog)\/(?:joinchat\/|\+)([\w-]+)$/i;
 function toInputPeer(res) {
-  if (tl.tl.isAnyInputPeer(res)) return res;
+  if (innerTl.isAnyInputPeer(res)) return res;
   switch (res._) {
     case "inputChannelEmpty":
     case "inputUserEmpty":
@@ -48,7 +48,7 @@ function toInputPeer(res) {
   }
 }
 function toInputUser(res, input) {
-  if (tl.tl.isAnyInputUser(res)) return res;
+  if (innerTl.isAnyInputUser(res)) return res;
   switch (res._) {
     case "inputPeerSelf":
       return { _: "inputUserSelf" };
@@ -69,7 +69,7 @@ function toInputUser(res, input) {
   throw new errors.MtInvalidPeerTypeError(input ?? res, "user");
 }
 function toInputChannel(res, input) {
-  if (tl.tl.isAnyInputChannel(res)) return res;
+  if (innerTl.isAnyInputChannel(res)) return res;
   switch (res._) {
     case "inputPeerChannel":
       return {

package/highlevel/utils/peer-utils.d.cts

@@ -1,5 +1,5 @@
 import { InputPeerLike } from '../types/peers/index.js';
-import { tl } from '@mtcute/tl';
+import { tl } from '../../tl/index.js';
 export declare const INVITE_LINK_REGEX: RegExp;
 export declare function toInputPeer(res: tl.TypeInputPeer | tl.TypeInputUser | tl.TypeInputChannel): tl.TypeInputPeer;
 export declare function toInputUser(res: tl.TypeInputPeer | tl.TypeInputUser | tl.TypeInputChannel, input?: InputPeerLike): tl.TypeInputUser;

package/highlevel/utils/peer-utils.d.ts

@@ -1,5 +1,5 @@
 import { InputPeerLike } from '../types/peers/index.js';
-import { tl } from '@mtcute/tl';
+import { tl } from '../../tl/index.js';
 export declare const INVITE_LINK_REGEX: RegExp;
 export declare function toInputPeer(res: tl.TypeInputPeer | tl.TypeInputUser | tl.TypeInputChannel): tl.TypeInputPeer;
 export declare function toInputUser(res: tl.TypeInputPeer | tl.TypeInputUser | tl.TypeInputChannel, input?: InputPeerLike): tl.TypeInputUser;

package/highlevel/utils/peer-utils.js

@@ -1,9 +1,9 @@
-import { tl } from "@mtcute/tl";
 import { assertNever } from "../../types/utils.js";
 import { MtInvalidPeerTypeError } from "../types/errors.js";
+import { isAnyInputPeer, isAnyInputUser, isAnyInputChannel } from "../../tl/inner-tl.js";
 const INVITE_LINK_REGEX = /^(?:https?:\/\/)?(?:www\.)?t(?:elegram)?\.(?:org|me|dog)\/(?:joinchat\/|\+)([\w-]+)$/i;
 function toInputPeer(res) {
-  if (tl.isAnyInputPeer(res)) return res;
+  if (isAnyInputPeer(res)) return res;
   switch (res._) {
     case "inputChannelEmpty":
     case "inputUserEmpty":
@@ -41,7 +41,7 @@ function toInputPeer(res) {
   }
 }
 function toInputUser(res, input) {
-  if (tl.isAnyInputUser(res)) return res;
+  if (isAnyInputUser(res)) return res;
   switch (res._) {
     case "inputPeerSelf":
       return { _: "inputUserSelf" };
@@ -62,7 +62,7 @@ function toInputUser(res, input) {
   throw new MtInvalidPeerTypeError(input ?? res, "user");
 }
 function toInputChannel(res, input) {
-  if (tl.isAnyInputChannel(res)) return res;
+  if (isAnyInputChannel(res)) return res;
   switch (res._) {
     case "inputPeerChannel":
       return {

package/highlevel/worker/errors.cjs

@@ -5,9 +5,9 @@ if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WAR
 }
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const tl = require("@mtcute/tl");
 const errors$1 = require("../../types/errors.cjs");
 const errors = require("../types/errors.cjs");
+const innerTl = require("../../tl/inner-tl.cjs");
 function serializeError(error) {
   if (!(error instanceof Error)) return { name: "Error", message: String(error) };
   const res = {
@@ -38,7 +38,7 @@ function serializeError(error) {
       messageId: _error.messageId,
       context: _error.context
     };
-  } else if (ctor === tl.tl.RpcError) {
+  } else if (ctor === innerTl.RpcError) {
     res.name = "RpcError";
     res.custom = { ...error };
   } else if (ctor === errors$1.MtArgumentError) {
@@ -78,7 +78,7 @@ function deserializeError(error) {
     }
     case "RpcError": {
       const custom = error.custom;
-      err2 = new tl.tl.RpcError(custom.code, custom.text);
+      err2 = new innerTl.RpcError(custom.code, custom.text);
       err2.message = error.message;
       for (const key in custom) {
         if (key === "code" || key === "text") continue;

package/highlevel/worker/errors.js

@@ -1,6 +1,6 @@
-import { tl } from "@mtcute/tl";
 import { MtUnsupportedError, MtSecurityError, MtArgumentError, MtTimeoutError, MtTypeAssertionError, MtcuteError } from "../../types/errors.js";
 import { MtEmptyError, MtInvalidPeerTypeError, MtPeerNotFoundError, MtMessageNotFoundError } from "../types/errors.js";
+import { RpcError } from "../../tl/inner-tl.js";
 function serializeError(error) {
   if (!(error instanceof Error)) return { name: "Error", message: String(error) };
   const res = {
@@ -31,7 +31,7 @@ function serializeError(error) {
       messageId: _error.messageId,
       context: _error.context
     };
-  } else if (ctor === tl.RpcError) {
+  } else if (ctor === RpcError) {
     res.name = "RpcError";
     res.custom = { ...error };
   } else if (ctor === MtArgumentError) {
@@ -71,7 +71,7 @@ function deserializeError(error) {
     }
     case "RpcError": {
       const custom = error.custom;
-      err2 = new tl.RpcError(custom.code, custom.text);
+      err2 = new RpcError(custom.code, custom.text);
       err2.message = error.message;
       for (const key in custom) {
         if (key === "code" || key === "text") continue;

package/highlevel/worker/invoker.cjs

@@ -9,16 +9,61 @@ const utils = require("@fuman/utils");
 const errors = require("./errors.cjs");
 const protocol = require("./protocol.cjs");
 class WorkerInvoker {
-  constructor(send, workerId) {
+  constructor(send, workerId, connectionId) {
     this.send = send;
     this.workerId = workerId;
+    this.connectionId = connectionId;
   }
   _nextId = 0;
+  _released = false;
+  _releasedError = new Error("Worker connection closed");
   _pending = /* @__PURE__ */ new Map();
+  _close(error, shouldRelease) {
+    if (this._released) return;
+    this._released = true;
+    this._releasedError = error;
+    if (shouldRelease) {
+      this.send({
+        _mtcuteWorkerId: this.workerId,
+        connectionId: this.connectionId,
+        type: "release"
+      });
+    }
+    for (const pending of this._pending.values()) {
+      pending.reject(error);
+    }
+    this._pending.clear();
+  }
+  connect() {
+    this.send({
+      _mtcuteWorkerId: this.workerId,
+      connectionId: this.connectionId,
+      type: "connect"
+    });
+  }
+  heartbeat() {
+    if (this._released) return;
+    this.send({
+      _mtcuteWorkerId: this.workerId,
+      connectionId: this.connectionId,
+      type: "heartbeat"
+    });
+  }
+  release() {
+    this._close(new Error("Worker connection closed"), true);
+  }
+  expire() {
+    this._close(new Error("Worker connection expired"), false);
+  }
   _invoke(target, method, args, isVoid, abortSignal) {
+    if (this._released) {
+      if (isVoid) throw this._releasedError;
+      return Promise.reject(this._releasedError);
+    }
     const id = this._nextId++;
     this.send({
       _mtcuteWorkerId: this.workerId,
+      connectionId: this.connectionId,
       type: "invoke",
       id,
       target,
@@ -27,13 +72,26 @@ class WorkerInvoker {
       void: isVoid,
       withAbort: Boolean(abortSignal)
     });
-    abortSignal?.addEventListener("abort", () => {
-      this.send({
-        _mtcuteWorkerId: this.workerId,
-        type: "abort",
-        id
-      });
-    });
+    if (abortSignal) {
+      const onAbort = () => {
+        if (this._released) return;
+        this.send({
+          _mtcuteWorkerId: this.workerId,
+          connectionId: this.connectionId,
+          type: "abort",
+          id
+        });
+      };
+      abortSignal.addEventListener("abort", onAbort, { once: true });
+      if (!isVoid) {
+        const promise = new utils.Deferred();
+        this._pending.set(id, promise);
+        return promise.promise.finally(() => {
+          abortSignal.removeEventListener("abort", onAbort);
+        });
+      }
+      return;
+    }
     if (!isVoid) {
       const promise = new utils.Deferred();
       this._pending.set(id, promise);
@@ -44,7 +102,7 @@ class WorkerInvoker {
     return this._invoke(target, method, args, false);
   }
   invokeVoid(target, method, args) {
-    this._invoke(target, method, args, true);
+    void this._invoke(target, method, args, true);
   }
   invokeWithAbort(target, method, args, abortSignal) {
     if (abortSignal.aborted) return Promise.reject(abortSignal.reason);

package/highlevel/worker/invoker.d.cts

@@ -5,9 +5,17 @@ export type InvokeTarget = Extract<WorkerInboundMessage, {
 export declare class WorkerInvoker {
     private send;
     private readonly workerId;
-    constructor(send: SendFn, workerId: string);
+    private readonly connectionId;
+    constructor(send: SendFn, workerId: string, connectionId: string);
     private _nextId;
+    private _released;
+    private _releasedError;
     private _pending;
+    private _close;
+    connect(): void;
+    heartbeat(): void;
+    release(): void;
+    expire(): void;
     private _invoke;
     invoke(target: InvokeTarget, method: string, args: unknown[]): Promise<unknown>;
     invokeVoid(target: InvokeTarget, method: string, args: unknown[]): void;

package/highlevel/worker/invoker.d.ts

@@ -5,9 +5,17 @@ export type InvokeTarget = Extract<WorkerInboundMessage, {
 export declare class WorkerInvoker {
     private send;
     private readonly workerId;
-    constructor(send: SendFn, workerId: string);
+    private readonly connectionId;
+    constructor(send: SendFn, workerId: string, connectionId: string);
     private _nextId;
+    private _released;
+    private _releasedError;
     private _pending;
+    private _close;
+    connect(): void;
+    heartbeat(): void;
+    release(): void;
+    expire(): void;
     private _invoke;
     invoke(target: InvokeTarget, method: string, args: unknown[]): Promise<unknown>;
     invokeVoid(target: InvokeTarget, method: string, args: unknown[]): void;

package/highlevel/worker/invoker.js

@@ -2,16 +2,61 @@ import { Deferred } from "@fuman/utils";
 import { deserializeError } from "./errors.js";
 import { serializeResult, deserializeResult } from "./protocol.js";
 class WorkerInvoker {
-  constructor(send, workerId) {
+  constructor(send, workerId, connectionId) {
     this.send = send;
     this.workerId = workerId;
+    this.connectionId = connectionId;
   }
   _nextId = 0;
+  _released = false;
+  _releasedError = new Error("Worker connection closed");
   _pending = /* @__PURE__ */ new Map();
+  _close(error, shouldRelease) {
+    if (this._released) return;
+    this._released = true;
+    this._releasedError = error;
+    if (shouldRelease) {
+      this.send({
+        _mtcuteWorkerId: this.workerId,
+        connectionId: this.connectionId,
+        type: "release"
+      });
+    }
+    for (const pending of this._pending.values()) {
+      pending.reject(error);
+    }
+    this._pending.clear();
+  }
+  connect() {
+    this.send({
+      _mtcuteWorkerId: this.workerId,
+      connectionId: this.connectionId,
+      type: "connect"
+    });
+  }
+  heartbeat() {
+    if (this._released) return;
+    this.send({
+      _mtcuteWorkerId: this.workerId,
+      connectionId: this.connectionId,
+      type: "heartbeat"
+    });
+  }
+  release() {
+    this._close(new Error("Worker connection closed"), true);
+  }
+  expire() {
+    this._close(new Error("Worker connection expired"), false);
+  }
   _invoke(target, method, args, isVoid, abortSignal) {
+    if (this._released) {
+      if (isVoid) throw this._releasedError;
+      return Promise.reject(this._releasedError);
+    }
     const id = this._nextId++;
     this.send({
       _mtcuteWorkerId: this.workerId,
+      connectionId: this.connectionId,
       type: "invoke",
       id,
       target,
@@ -20,13 +65,26 @@ class WorkerInvoker {
       void: isVoid,
       withAbort: Boolean(abortSignal)
     });
-    abortSignal?.addEventListener("abort", () => {
-      this.send({
-        _mtcuteWorkerId: this.workerId,
-        type: "abort",
-        id
-      });
-    });
+    if (abortSignal) {
+      const onAbort = () => {
+        if (this._released) return;
+        this.send({
+          _mtcuteWorkerId: this.workerId,
+          connectionId: this.connectionId,
+          type: "abort",
+          id
+        });
+      };
+      abortSignal.addEventListener("abort", onAbort, { once: true });
+      if (!isVoid) {
+        const promise = new Deferred();
+        this._pending.set(id, promise);
+        return promise.promise.finally(() => {
+          abortSignal.removeEventListener("abort", onAbort);
+        });
+      }
+      return;
+    }
     if (!isVoid) {
       const promise = new Deferred();
       this._pending.set(id, promise);
@@ -37,7 +95,7 @@ class WorkerInvoker {
     return this._invoke(target, method, args, false);
   }
   invokeVoid(target, method, args) {
-    this._invoke(target, method, args, true);
+    void this._invoke(target, method, args, true);
   }
   invokeWithAbort(target, method, args, abortSignal) {
     if (abortSignal.aborted) return Promise.reject(abortSignal.reason);

package/highlevel/worker/invoker.test.d.cts

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

package/highlevel/worker/invoker.test.d.ts

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

package/highlevel/worker/port.cjs

@@ -7,28 +7,41 @@ if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WAR
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const utils = require("@fuman/utils");
 const logger = require("../../utils/logger.cjs");
-const timers = require("../managers/timers.cjs");
 const peersIndex = require("../types/peers/peers-index.cjs");
 const appConfig = require("./app-config.cjs");
 const errors = require("./errors.cjs");
 const invoker = require("./invoker.cjs");
 const protocol = require("./protocol.cjs");
 const storage = require("./storage.cjs");
+const timers = require("./timers.cjs");
+const WORKER_HEARTBEAT_INTERVAL = 1e4;
+let _nextConnectionId = 0;
+function makeConnectionId() {
+  return `${Date.now().toString(36)}-${(_nextConnectionId++).toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
 class TelegramWorkerPort {
   constructor(options) {
     this.options = options;
     this.log = new logger.LogManager("worker", options.platform);
     this.platform = options.platform;
     this.workerId = options.workerId ?? protocol.DEFAULT_WORKER_ID;
+    this.connectionId = makeConnectionId();
     this._connection = this.connectToWorker(this.options.worker, this._onMessage);
-    this._invoker = new invoker.WorkerInvoker(this._connection[0], this.workerId);
+    this._invoker = new invoker.WorkerInvoker(this._connection[0], this.workerId, this.connectionId);
+    this._invoker.connect();
+    this._heartbeatTimer = setInterval(() => {
+      this._invoker.heartbeat();
+    }, WORKER_HEARTBEAT_INTERVAL);
+    this._cancelBeforeExit = this.platform.beforeExit(() => {
+      void this.destroy();
+    });
     this.storage = new storage.TelegramStorageProxy(this._invoker);
     this.appConfig = new appConfig.AppConfigManagerProxy(this._invoker);
     const bind = this._invoker.makeBinder("client");
     this.prepare = bind("prepare");
     this._connect = bind("connect");
     this.disconnect = bind("disconnect");
-    this.destroy_ = bind("destroy");
+    this.unsafeForceDestroy = bind("destroy");
     this.notifyLoggedIn = bind("notifyLoggedIn");
     this.notifyLoggedOut = bind("notifyLoggedOut");
     this.notifyChannelOpened = bind("notifyChannelOpened");
@@ -46,8 +59,7 @@ class TelegramWorkerPort {
     this.stopUpdatesLoop = bind("stopUpdatesLoop");
     this.getMtprotoMessageId = bind("getMtprotoMessageId");
     this.recreateDc = bind("recreateDc");
-    this.timers = new timers.TimersManager();
-    this.timers.onError((err) => this.onError.emit(utils.unknownToError(err)));
+    this.timers = new timers.WorkerTimersManager(this._invoker);
   }
   log;
   platform;
@@ -55,15 +67,12 @@ class TelegramWorkerPort {
   _invoker;
   storage;
   appConfig;
-  // todo: ideally timers should be handled on the worker side,
-  // but i'm not sure yet of the best way to handle multiple clients (e.g. in SharedWorker-s)
-  // (with one worker client it's not that big of a deal)
   timers;
   // bound methods
   prepare;
   _connect;
   disconnect;
-  destroy_;
+  unsafeForceDestroy;
   notifyLoggedIn;
   notifyLoggedOut;
   notifyChannelOpened;
@@ -84,6 +93,9 @@ class TelegramWorkerPort {
   _abortController = new AbortController();
   stopSignal = this._abortController.signal;
   workerId;
+  connectionId;
+  _cancelBeforeExit;
+  _heartbeatTimer;
   call(message, params) {
     if (params?.abortSignal) {
       const { abortSignal, ...rest } = params;
@@ -96,7 +108,9 @@ class TelegramWorkerPort {
   onConnectionState = new utils.Emitter();
   onError = new utils.Emitter();
   _onMessage = (message) => {
+    if (this._closed) return;
     if (message._mtcuteWorkerId !== this.workerId) return;
+    if ("connectionId" in message && message.connectionId !== this.connectionId) return;
     switch (message.type) {
       case "log":
         this.log.handler(message.color, message.level, message.tag, message.fmt, message.args);
@@ -104,6 +118,15 @@ class TelegramWorkerPort {
       case "server_update":
         this.onServerUpdate.emit(protocol.deserializeResult(message.update));
         break;
+      case "self_sync":
+        this.storage.self.setCached(protocol.deserializeResult(message.self));
+        break;
+      case "connection_expired": {
+        const error = new Error("Worker connection expired");
+        this.onError.emit(error);
+        this._close(false);
+        break;
+      }
       case "conn_state":
         this.onConnectionState.emit(message.state);
         break;
@@ -120,17 +143,28 @@ class TelegramWorkerPort {
         this.onError.emit(errors.deserializeError(message.error));
         break;
       case "stop":
-        this._abortController.abort();
+        this._close(false);
         break;
     }
   };
-  _destroyed = false;
+  _closed = false;
+  _close(sendRelease) {
+    if (this._closed) return;
+    this._closed = true;
+    if (this._heartbeatTimer !== void 0) {
+      clearInterval(this._heartbeatTimer);
+    }
+    this._cancelBeforeExit?.();
+    if (sendRelease) {
+      this._invoker.release();
+    } else {
+      this._invoker.expire();
+    }
+    this._abortController.abort();
+    queueMicrotask(() => this._connection[1]());
+  }
   async destroy(terminate = false) {
-    if (this._destroyed) return;
-    await this.destroy_();
-    this.timers.destroy();
-    this._connection[1]();
-    this._destroyed = true;
+    this._close(true);
     if (terminate && "terminate" in this.options.worker) {
       await Promise.resolve(this.options.worker.terminate());
     }

package/highlevel/worker/port.d.cts

@@ -1,5 +1,5 @@
-import { tl } from '@mtcute/tl';
 import { RpcCallOptions } from '../../network/network-manager.js';
+import { tl } from '../../tl/index.js';
 import { ICorePlatform } from '../../types/platform.js';
 import { MustEqual } from '../../types/utils.js';
 import { ConnectionState, ITelegramClient } from '../client.types.js';
@@ -7,9 +7,9 @@ import { RawUpdateInfo } from '../updates/types.js';
 import { ClientMessageHandler, SendFn, SomeWorker, WorkerCustomMethods } from './protocol.js';
 import { Emitter } from '@fuman/utils';
 import { LogManager } from '../../utils/logger.js';
-import { TimersManager } from '../managers/timers.js';
 import { AppConfigManagerProxy } from './app-config.js';
 import { TelegramStorageProxy } from './storage.js';
+import { WorkerTimersManager } from './timers.js';
 export interface TelegramWorkerPortOptions {
     worker: SomeWorker;
     workerId?: string;
@@ -23,11 +23,11 @@ export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMeth
     private _invoker;
     readonly storage: TelegramStorageProxy;
     readonly appConfig: AppConfigManagerProxy;
-    readonly timers: TimersManager;
+    readonly timers: WorkerTimersManager;
     readonly prepare: ITelegramClient['prepare'];
     private _connect;
     readonly disconnect: ITelegramClient['disconnect'];
-    readonly destroy_: ITelegramClient['destroy'];
+    readonly unsafeForceDestroy: () => Promise<void>;
     readonly notifyLoggedIn: ITelegramClient['notifyLoggedIn'];
     readonly notifyLoggedOut: ITelegramClient['notifyLoggedOut'];
     readonly notifyChannelOpened: ITelegramClient['notifyChannelOpened'];
@@ -48,6 +48,9 @@ export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMeth
     private _abortController;
     readonly stopSignal: AbortSignal;
     readonly workerId: string;
+    readonly connectionId: string;
+    private _cancelBeforeExit;
+    private _heartbeatTimer;
     constructor(options: TelegramWorkerPortOptions);
     call<T extends tl.RpcMethod>(message: MustEqual<T, tl.RpcMethod>, params?: RpcCallOptions): Promise<tl.RpcCallReturn[T['_']]>;
     abstract connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void];
@@ -56,7 +59,8 @@ export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMeth
     onConnectionState: Emitter<ConnectionState>;
     onError: Emitter<Error>;
     private _onMessage;
-    private _destroyed;
+    private _closed;
+    private _close;
     destroy(terminate?: boolean): Promise<void>;
     invokeCustom<T extends keyof Custom>(method: T, ...args: Parameters<Custom[T]>): Promise<ReturnType<Custom[T]>>;
     connect(): Promise<void>;

package/highlevel/worker/port.d.ts

@@ -1,5 +1,5 @@
-import { tl } from '@mtcute/tl';
 import { RpcCallOptions } from '../../network/network-manager.js';
+import { tl } from '../../tl/index.js';
 import { ICorePlatform } from '../../types/platform.js';
 import { MustEqual } from '../../types/utils.js';
 import { ConnectionState, ITelegramClient } from '../client.types.js';
@@ -7,9 +7,9 @@ import { RawUpdateInfo } from '../updates/types.js';
 import { ClientMessageHandler, SendFn, SomeWorker, WorkerCustomMethods } from './protocol.js';
 import { Emitter } from '@fuman/utils';
 import { LogManager } from '../../utils/logger.js';
-import { TimersManager } from '../managers/timers.js';
 import { AppConfigManagerProxy } from './app-config.js';
 import { TelegramStorageProxy } from './storage.js';
+import { WorkerTimersManager } from './timers.js';
 export interface TelegramWorkerPortOptions {
     worker: SomeWorker;
     workerId?: string;
@@ -23,11 +23,11 @@ export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMeth
     private _invoker;
     readonly storage: TelegramStorageProxy;
     readonly appConfig: AppConfigManagerProxy;
-    readonly timers: TimersManager;
+    readonly timers: WorkerTimersManager;
     readonly prepare: ITelegramClient['prepare'];
     private _connect;
     readonly disconnect: ITelegramClient['disconnect'];
-    readonly destroy_: ITelegramClient['destroy'];
+    readonly unsafeForceDestroy: () => Promise<void>;
     readonly notifyLoggedIn: ITelegramClient['notifyLoggedIn'];
     readonly notifyLoggedOut: ITelegramClient['notifyLoggedOut'];
     readonly notifyChannelOpened: ITelegramClient['notifyChannelOpened'];
@@ -48,6 +48,9 @@ export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMeth
     private _abortController;
     readonly stopSignal: AbortSignal;
     readonly workerId: string;
+    readonly connectionId: string;
+    private _cancelBeforeExit;
+    private _heartbeatTimer;
     constructor(options: TelegramWorkerPortOptions);
     call<T extends tl.RpcMethod>(message: MustEqual<T, tl.RpcMethod>, params?: RpcCallOptions): Promise<tl.RpcCallReturn[T['_']]>;
     abstract connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void];
@@ -56,7 +59,8 @@ export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMeth
     onConnectionState: Emitter<ConnectionState>;
     onError: Emitter<Error>;
     private _onMessage;
-    private _destroyed;
+    private _closed;
+    private _close;
     destroy(terminate?: boolean): Promise<void>;
     invokeCustom<T extends keyof Custom>(method: T, ...args: Parameters<Custom[T]>): Promise<ReturnType<Custom[T]>>;
     connect(): Promise<void>;