@mtcute/core 0.25.1 → 0.25.2

package/highlevel/methods/misc/normalize-text.cjs

@@ -7,6 +7,19 @@ if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WAR
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const resolvePeer = require("../users/resolve-peer.cjs");
 const empty = ["", void 0];
+function adjustOffsets(entities, from, by) {
+  for (const ent of entities) {
+    if (ent.offset < from) continue;
+    if (by >= 0) {
+      ent.offset += by;
+      continue;
+    }
+    const adjustTotal = Math.min(ent.offset, Math.abs(by));
+    const adjustInternal = Math.max(Math.abs(by) - ent.offset, 0);
+    ent.offset -= adjustTotal;
+    ent.length -= adjustInternal;
+  }
+}
 async function _normalizeInputText(client, input) {
   if (!input) {
     return empty;
@@ -14,8 +27,10 @@ async function _normalizeInputText(client, input) {
   if (typeof input === "string") {
     return [input, void 0];
   }
-  const { text, entities } = input;
+  let text = input.text;
+  const entities = input.entities;
   if (!entities) return [text, void 0];
+  let canTrimStart = true;
   for (const ent of entities) {
     if (ent._ === "messageEntityMentionName") {
       try {
@@ -27,6 +42,20 @@ async function _normalizeInputText(client, input) {
         client.log.warn("Failed to resolve mention entity for %s: %s", ent.userId, e);
       }
     }
+    if (ent._ === "messageEntityPre" && ent.offset === 0) {
+      canTrimStart = false;
+    }
+  }
+  if (canTrimStart) {
+    const resultTrimmed = text.trimStart();
+    const numCharsTrimmed = text.length - resultTrimmed.length;
+    text = resultTrimmed;
+    adjustOffsets(entities, 0, -numCharsTrimmed);
+  }
+  text = text.trimEnd();
+  for (const ent of entities) {
+    const end = ent.offset + ent.length;
+    if (end > text.length) ent.length = text.length - ent.offset;
   }
   return [text, entities];
 }

package/highlevel/methods/misc/normalize-text.js

@@ -1,5 +1,18 @@
 import { resolveUser } from "../users/resolve-peer.js";
 const empty = ["", void 0];
+function adjustOffsets(entities, from, by) {
+  for (const ent of entities) {
+    if (ent.offset < from) continue;
+    if (by >= 0) {
+      ent.offset += by;
+      continue;
+    }
+    const adjustTotal = Math.min(ent.offset, Math.abs(by));
+    const adjustInternal = Math.max(Math.abs(by) - ent.offset, 0);
+    ent.offset -= adjustTotal;
+    ent.length -= adjustInternal;
+  }
+}
 async function _normalizeInputText(client, input) {
   if (!input) {
     return empty;
@@ -7,8 +20,10 @@ async function _normalizeInputText(client, input) {
   if (typeof input === "string") {
     return [input, void 0];
   }
-  const { text, entities } = input;
+  let text = input.text;
+  const entities = input.entities;
   if (!entities) return [text, void 0];
+  let canTrimStart = true;
   for (const ent of entities) {
     if (ent._ === "messageEntityMentionName") {
       try {
@@ -20,6 +35,20 @@ async function _normalizeInputText(client, input) {
         client.log.warn("Failed to resolve mention entity for %s: %s", ent.userId, e);
       }
     }
+    if (ent._ === "messageEntityPre" && ent.offset === 0) {
+      canTrimStart = false;
+    }
+  }
+  if (canTrimStart) {
+    const resultTrimmed = text.trimStart();
+    const numCharsTrimmed = text.length - resultTrimmed.length;
+    text = resultTrimmed;
+    adjustOffsets(entities, 0, -numCharsTrimmed);
+  }
+  text = text.trimEnd();
+  for (const ent of entities) {
+    const end = ent.offset + ent.length;
+    if (end > text.length) ent.length = text.length - ent.offset;
   }
   return [text, entities];
 }

package/highlevel/methods/misc/normalize-text.test.d.cts

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

package/highlevel/methods/misc/normalize-text.test.d.ts

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

package/highlevel/worker/invoker.cjs

@@ -9,14 +9,16 @@ const utils = require("@fuman/utils");
 const errors = require("./errors.cjs");
 const protocol = require("./protocol.cjs");
 class WorkerInvoker {
-  constructor(send) {
+  constructor(send, workerId) {
     this.send = send;
+    this.workerId = workerId;
   }
   _nextId = 0;
   _pending = /* @__PURE__ */ new Map();
   _invoke(target, method, args, isVoid, abortSignal) {
     const id = this._nextId++;
     this.send({
+      _mtcuteWorkerId: this.workerId,
       type: "invoke",
       id,
       target,
@@ -27,6 +29,7 @@ class WorkerInvoker {
     });
     abortSignal?.addEventListener("abort", () => {
       this.send({
+        _mtcuteWorkerId: this.workerId,
         type: "abort",
         id
       });

package/highlevel/worker/invoker.d.cts

@@ -4,7 +4,8 @@ export type InvokeTarget = Extract<WorkerInboundMessage, {
 }>['target'];
 export declare class WorkerInvoker {
     private send;
-    constructor(send: SendFn);
+    private readonly workerId;
+    constructor(send: SendFn, workerId: string);
     private _nextId;
     private _pending;
     private _invoke;

package/highlevel/worker/invoker.d.ts

@@ -4,7 +4,8 @@ export type InvokeTarget = Extract<WorkerInboundMessage, {
 }>['target'];
 export declare class WorkerInvoker {
     private send;
-    constructor(send: SendFn);
+    private readonly workerId;
+    constructor(send: SendFn, workerId: string);
     private _nextId;
     private _pending;
     private _invoke;

package/highlevel/worker/invoker.js

@@ -2,14 +2,16 @@ import { Deferred } from "@fuman/utils";
 import { deserializeError } from "./errors.js";
 import { serializeResult, deserializeResult } from "./protocol.js";
 class WorkerInvoker {
-  constructor(send) {
+  constructor(send, workerId) {
     this.send = send;
+    this.workerId = workerId;
   }
   _nextId = 0;
   _pending = /* @__PURE__ */ new Map();
   _invoke(target, method, args, isVoid, abortSignal) {
     const id = this._nextId++;
     this.send({
+      _mtcuteWorkerId: this.workerId,
       type: "invoke",
       id,
       target,
@@ -20,6 +22,7 @@ class WorkerInvoker {
     });
     abortSignal?.addEventListener("abort", () => {
       this.send({
+        _mtcuteWorkerId: this.workerId,
         type: "abort",
         id
       });

package/highlevel/worker/port.cjs

@@ -19,8 +19,9 @@ class TelegramWorkerPort {
     this.options = options;
     this.log = new logger.LogManager("worker", options.platform);
     this.platform = options.platform;
+    this.workerId = options.workerId ?? protocol.DEFAULT_WORKER_ID;
     this._connection = this.connectToWorker(this.options.worker, this._onMessage);
-    this._invoker = new invoker.WorkerInvoker(this._connection[0]);
+    this._invoker = new invoker.WorkerInvoker(this._connection[0], this.workerId);
     this.storage = new storage.TelegramStorageProxy(this._invoker);
     this.appConfig = new appConfig.AppConfigManagerProxy(this._invoker);
     const bind = this._invoker.makeBinder("client");
@@ -82,6 +83,7 @@ class TelegramWorkerPort {
   recreateDc;
   _abortController = new AbortController();
   stopSignal = this._abortController.signal;
+  workerId;
   call(message, params) {
     if (params?.abortSignal) {
       const { abortSignal, ...rest } = params;
@@ -94,6 +96,7 @@ class TelegramWorkerPort {
   onConnectionState = new utils.Emitter();
   onError = new utils.Emitter();
   _onMessage = (message) => {
+    if (message._mtcuteWorkerId !== this.workerId) return;
     switch (message.type) {
       case "log":
         this.log.handler(message.color, message.level, message.tag, message.fmt, message.args);

package/highlevel/worker/port.d.cts

@@ -12,6 +12,7 @@ import { AppConfigManagerProxy } from './app-config.js';
 import { TelegramStorageProxy } from './storage.js';
 export interface TelegramWorkerPortOptions {
     worker: SomeWorker;
+    workerId?: string;
     platform: ICorePlatform;
 }
 export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMethods> implements ITelegramClient {
@@ -46,6 +47,7 @@ export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMeth
     readonly recreateDc: ITelegramClient['recreateDc'];
     private _abortController;
     readonly stopSignal: AbortSignal;
+    readonly workerId: string;
     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];

package/highlevel/worker/port.d.ts

@@ -12,6 +12,7 @@ import { AppConfigManagerProxy } from './app-config.js';
 import { TelegramStorageProxy } from './storage.js';
 export interface TelegramWorkerPortOptions {
     worker: SomeWorker;
+    workerId?: string;
     platform: ICorePlatform;
 }
 export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMethods> implements ITelegramClient {
@@ -46,6 +47,7 @@ export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMeth
     readonly recreateDc: ITelegramClient['recreateDc'];
     private _abortController;
     readonly stopSignal: AbortSignal;
+    readonly workerId: string;
     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];

package/highlevel/worker/port.js

@@ -5,15 +5,16 @@ import { PeersIndex } from "../types/peers/peers-index.js";
 import { AppConfigManagerProxy } from "./app-config.js";
 import { deserializeError } from "./errors.js";
 import { WorkerInvoker } from "./invoker.js";
-import { deserializeResult } from "./protocol.js";
+import { DEFAULT_WORKER_ID, deserializeResult } from "./protocol.js";
 import { TelegramStorageProxy } from "./storage.js";
 class TelegramWorkerPort {
   constructor(options) {
     this.options = options;
     this.log = new LogManager("worker", options.platform);
     this.platform = options.platform;
+    this.workerId = options.workerId ?? DEFAULT_WORKER_ID;
     this._connection = this.connectToWorker(this.options.worker, this._onMessage);
-    this._invoker = new WorkerInvoker(this._connection[0]);
+    this._invoker = new WorkerInvoker(this._connection[0], this.workerId);
     this.storage = new TelegramStorageProxy(this._invoker);
     this.appConfig = new AppConfigManagerProxy(this._invoker);
     const bind = this._invoker.makeBinder("client");
@@ -75,6 +76,7 @@ class TelegramWorkerPort {
   recreateDc;
   _abortController = new AbortController();
   stopSignal = this._abortController.signal;
+  workerId;
   call(message, params) {
     if (params?.abortSignal) {
       const { abortSignal, ...rest } = params;
@@ -87,6 +89,7 @@ class TelegramWorkerPort {
   onConnectionState = new Emitter();
   onError = new Emitter();
   _onMessage = (message) => {
+    if (message._mtcuteWorkerId !== this.workerId) return;
     switch (message.type) {
       case "log":
         this.log.handler(message.color, message.level, message.tag, message.fmt, message.args);

package/highlevel/worker/protocol.cjs

@@ -6,6 +6,7 @@ if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WAR
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const Long = require("long");
+const DEFAULT_WORKER_ID = "default";
 function serializeResult(result) {
   if (ArrayBuffer.isView(result)) return result;
   if (Array.isArray(result)) {
@@ -59,5 +60,6 @@ function deserializeResult(result) {
   }
   return result;
 }
+exports.DEFAULT_WORKER_ID = DEFAULT_WORKER_ID;
 exports.deserializeResult = deserializeResult;
 exports.serializeResult = serializeResult;

package/highlevel/worker/protocol.d.cts

@@ -3,6 +3,7 @@ import { Worker as NodeWorker } from 'node:worker_threads';
 import { ConnectionState } from '../client.types.js';
 import { SerializedError } from './errors.js';
 export type WorkerInboundMessage = {
+    _mtcuteWorkerId: string;
     type: 'invoke';
     id: number;
     target: 'custom' | 'client' | 'storage' | 'storage-self' | 'storage-peers' | 'app-config';
@@ -11,27 +12,34 @@ export type WorkerInboundMessage = {
     void: boolean;
     withAbort: boolean;
 } | {
+    _mtcuteWorkerId: string;
     type: 'abort';
     id: number;
 };
 export type WorkerOutboundMessage = {
+    _mtcuteWorkerId: string;
     type: 'server_update';
     update: SerializedResult<tl.TypeUpdates>;
 } | {
+    _mtcuteWorkerId: string;
     type: 'update';
     update: SerializedResult<tl.TypeUpdate>;
     users: SerializedResult<Map<number, tl.TypeUser>>;
     chats: SerializedResult<Map<number, tl.TypeChat>>;
     hasMin: boolean;
 } | {
+    _mtcuteWorkerId: string;
     type: 'error';
     error: SerializedError;
 } | {
+    _mtcuteWorkerId: string;
     type: 'stop';
 } | {
+    _mtcuteWorkerId: string;
     type: 'conn_state';
     state: ConnectionState;
 } | {
+    _mtcuteWorkerId: string;
     type: 'log';
     color: number;
     level: number;
@@ -39,11 +47,13 @@ export type WorkerOutboundMessage = {
     fmt: string;
     args: unknown[];
 } | {
+    _mtcuteWorkerId: string;
     type: 'result';
     id: number;
     result?: SerializedResult<unknown>;
     error?: SerializedError;
 };
+export declare const DEFAULT_WORKER_ID = "default";
 export type SomeWorker = NodeWorker | Worker | SharedWorker;
 export type SendFn = (message: WorkerInboundMessage) => void;
 export type ClientMessageHandler = (message: WorkerOutboundMessage) => void;

package/highlevel/worker/protocol.d.ts

@@ -3,6 +3,7 @@ import { Worker as NodeWorker } from 'node:worker_threads';
 import { ConnectionState } from '../client.types.js';
 import { SerializedError } from './errors.js';
 export type WorkerInboundMessage = {
+    _mtcuteWorkerId: string;
     type: 'invoke';
     id: number;
     target: 'custom' | 'client' | 'storage' | 'storage-self' | 'storage-peers' | 'app-config';
@@ -11,27 +12,34 @@ export type WorkerInboundMessage = {
     void: boolean;
     withAbort: boolean;
 } | {
+    _mtcuteWorkerId: string;
     type: 'abort';
     id: number;
 };
 export type WorkerOutboundMessage = {
+    _mtcuteWorkerId: string;
     type: 'server_update';
     update: SerializedResult<tl.TypeUpdates>;
 } | {
+    _mtcuteWorkerId: string;
     type: 'update';
     update: SerializedResult<tl.TypeUpdate>;
     users: SerializedResult<Map<number, tl.TypeUser>>;
     chats: SerializedResult<Map<number, tl.TypeChat>>;
     hasMin: boolean;
 } | {
+    _mtcuteWorkerId: string;
     type: 'error';
     error: SerializedError;
 } | {
+    _mtcuteWorkerId: string;
     type: 'stop';
 } | {
+    _mtcuteWorkerId: string;
     type: 'conn_state';
     state: ConnectionState;
 } | {
+    _mtcuteWorkerId: string;
     type: 'log';
     color: number;
     level: number;
@@ -39,11 +47,13 @@ export type WorkerOutboundMessage = {
     fmt: string;
     args: unknown[];
 } | {
+    _mtcuteWorkerId: string;
     type: 'result';
     id: number;
     result?: SerializedResult<unknown>;
     error?: SerializedError;
 };
+export declare const DEFAULT_WORKER_ID = "default";
 export type SomeWorker = NodeWorker | Worker | SharedWorker;
 export type SendFn = (message: WorkerInboundMessage) => void;
 export type ClientMessageHandler = (message: WorkerOutboundMessage) => void;

package/highlevel/worker/protocol.js

@@ -1,4 +1,5 @@
 import Long from "long";
+const DEFAULT_WORKER_ID = "default";
 function serializeResult(result) {
   if (ArrayBuffer.isView(result)) return result;
   if (Array.isArray(result)) {
@@ -53,6 +54,7 @@ function deserializeResult(result) {
   return result;
 }
 export {
+  DEFAULT_WORKER_ID,
   deserializeResult,
   serializeResult
 };

package/highlevel/worker/worker.cjs

@@ -10,7 +10,9 @@ const protocol = require("./protocol.cjs");
 class TelegramWorker {
   constructor(params) {
     this.params = params;
-    this.broadcast = this.registerWorker((message, respond) => {
+    this.workerId = params.workerId ?? protocol.DEFAULT_WORKER_ID;
+    const [broadcast, cleanup] = this.registerWorker((message, respond) => {
+      if (message._mtcuteWorkerId !== this.workerId) return;
       switch (message.type) {
         case "invoke":
           this.onInvoke(message, respond);
@@ -24,9 +26,12 @@ class TelegramWorker {
         }
       }
     });
+    this.broadcast = broadcast;
+    this._cleanup = cleanup;
     const client = params.client;
     this.client = client;
     client.log.mgr.handler = (color, level, tag, fmt, args) => this.broadcast({
+      _mtcuteWorkerId: this.workerId,
       type: "log",
       color,
       level,
@@ -36,20 +41,26 @@ class TelegramWorker {
     });
     client.onError.add(
       (err) => this.broadcast({
+        _mtcuteWorkerId: this.workerId,
         type: "error",
         error: errors.serializeError(err)
       })
     );
     client.onConnectionState.add(
       (state) => this.broadcast({
+        _mtcuteWorkerId: this.workerId,
         type: "conn_state",
         state
       })
     );
-    client.stopSignal.addEventListener("abort", () => this.broadcast({ type: "stop" }));
+    client.stopSignal.addEventListener("abort", () => this.broadcast({
+      _mtcuteWorkerId: this.workerId,
+      type: "stop"
+    }));
     if (client.updates) {
       client.onRawUpdate.add(
         ({ update, peers }) => this.broadcast({
+          _mtcuteWorkerId: this.workerId,
           type: "update",
           update: protocol.serializeResult(update),
           users: protocol.serializeResult(peers.users),
@@ -60,6 +71,7 @@ class TelegramWorker {
     } else {
       client.onServerUpdate.add(
         (update) => this.broadcast({
+          _mtcuteWorkerId: this.workerId,
           type: "server_update",
           update: protocol.serializeResult(update)
         })
@@ -68,7 +80,9 @@ class TelegramWorker {
   }
   client;
   broadcast;
+  _cleanup;
   pendingAborts = /* @__PURE__ */ new Map();
+  workerId;
   onInvoke(msg, respond) {
     let target;
     switch (msg.target) {
@@ -92,6 +106,7 @@ class TelegramWorker {
         break;
       default: {
         respond({
+          _mtcuteWorkerId: this.workerId,
           type: "result",
           id: msg.id,
           error: new Error(`Unknown target ${msg.target}`)
@@ -102,6 +117,7 @@ class TelegramWorker {
     const method = target[msg.method];
     if (!method) {
       respond({
+        _mtcuteWorkerId: this.workerId,
         type: "result",
         id: msg.id,
         error: new Error(`Method ${msg.method} not found on ${msg.target}`)
@@ -128,6 +144,7 @@ class TelegramWorker {
       }
       if (msg.void) return;
       respond({
+        _mtcuteWorkerId: this.workerId,
         type: "result",
         id: msg.id,
         result: protocol.serializeResult(res)
@@ -137,11 +154,15 @@ class TelegramWorker {
         this.pendingAborts.delete(msg.id);
       }
       respond({
+        _mtcuteWorkerId: this.workerId,
         type: "result",
         id: msg.id,
         error: errors.serializeError(err)
       });
     });
   }
+  destroy() {
+    this._cleanup?.();
+  }
 }
 exports.TelegramWorker = TelegramWorker;

package/highlevel/worker/worker.d.cts

@@ -2,14 +2,18 @@ import { BaseTelegramClient } from '../base.js';
 import { RespondFn, WorkerCustomMethods, WorkerMessageHandler } from './protocol.js';
 export interface TelegramWorkerOptions<T extends WorkerCustomMethods> {
     client: BaseTelegramClient;
+    workerId?: string;
     customMethods?: T;
 }
 export declare abstract class TelegramWorker<T extends WorkerCustomMethods> {
     readonly params: TelegramWorkerOptions<T>;
     readonly client: BaseTelegramClient;
     readonly broadcast: RespondFn;
-    abstract registerWorker(handler: WorkerMessageHandler): RespondFn;
+    private _cleanup;
+    abstract registerWorker(handler: WorkerMessageHandler): [RespondFn, VoidFunction];
     readonly pendingAborts: Map<number, AbortController>;
+    readonly workerId: string;
     constructor(params: TelegramWorkerOptions<T>);
     private onInvoke;
+    destroy(): void;
 }

package/highlevel/worker/worker.d.ts

@@ -2,14 +2,18 @@ import { BaseTelegramClient } from '../base.js';
 import { RespondFn, WorkerCustomMethods, WorkerMessageHandler } from './protocol.js';
 export interface TelegramWorkerOptions<T extends WorkerCustomMethods> {
     client: BaseTelegramClient;
+    workerId?: string;
     customMethods?: T;
 }
 export declare abstract class TelegramWorker<T extends WorkerCustomMethods> {
     readonly params: TelegramWorkerOptions<T>;
     readonly client: BaseTelegramClient;
     readonly broadcast: RespondFn;
-    abstract registerWorker(handler: WorkerMessageHandler): RespondFn;
+    private _cleanup;
+    abstract registerWorker(handler: WorkerMessageHandler): [RespondFn, VoidFunction];
     readonly pendingAborts: Map<number, AbortController>;
+    readonly workerId: string;
     constructor(params: TelegramWorkerOptions<T>);
     private onInvoke;
+    destroy(): void;
 }

package/highlevel/worker/worker.js

@@ -1,9 +1,11 @@
 import { serializeError } from "./errors.js";
-import { serializeResult, deserializeResult } from "./protocol.js";
+import { DEFAULT_WORKER_ID, serializeResult, deserializeResult } from "./protocol.js";
 class TelegramWorker {
   constructor(params) {
     this.params = params;
-    this.broadcast = this.registerWorker((message, respond) => {
+    this.workerId = params.workerId ?? DEFAULT_WORKER_ID;
+    const [broadcast, cleanup] = this.registerWorker((message, respond) => {
+      if (message._mtcuteWorkerId !== this.workerId) return;
       switch (message.type) {
         case "invoke":
           this.onInvoke(message, respond);
@@ -17,9 +19,12 @@ class TelegramWorker {
         }
       }
     });
+    this.broadcast = broadcast;
+    this._cleanup = cleanup;
     const client = params.client;
     this.client = client;
     client.log.mgr.handler = (color, level, tag, fmt, args) => this.broadcast({
+      _mtcuteWorkerId: this.workerId,
       type: "log",
       color,
       level,
@@ -29,20 +34,26 @@ class TelegramWorker {
     });
     client.onError.add(
       (err) => this.broadcast({
+        _mtcuteWorkerId: this.workerId,
         type: "error",
         error: serializeError(err)
       })
     );
     client.onConnectionState.add(
       (state) => this.broadcast({
+        _mtcuteWorkerId: this.workerId,
         type: "conn_state",
         state
       })
     );
-    client.stopSignal.addEventListener("abort", () => this.broadcast({ type: "stop" }));
+    client.stopSignal.addEventListener("abort", () => this.broadcast({
+      _mtcuteWorkerId: this.workerId,
+      type: "stop"
+    }));
     if (client.updates) {
       client.onRawUpdate.add(
         ({ update, peers }) => this.broadcast({
+          _mtcuteWorkerId: this.workerId,
           type: "update",
           update: serializeResult(update),
           users: serializeResult(peers.users),
@@ -53,6 +64,7 @@ class TelegramWorker {
     } else {
       client.onServerUpdate.add(
         (update) => this.broadcast({
+          _mtcuteWorkerId: this.workerId,
           type: "server_update",
           update: serializeResult(update)
         })
@@ -61,7 +73,9 @@ class TelegramWorker {
   }
   client;
   broadcast;
+  _cleanup;
   pendingAborts = /* @__PURE__ */ new Map();
+  workerId;
   onInvoke(msg, respond) {
     let target;
     switch (msg.target) {
@@ -85,6 +99,7 @@ class TelegramWorker {
         break;
       default: {
         respond({
+          _mtcuteWorkerId: this.workerId,
           type: "result",
           id: msg.id,
           error: new Error(`Unknown target ${msg.target}`)
@@ -95,6 +110,7 @@ class TelegramWorker {
     const method = target[msg.method];
     if (!method) {
       respond({
+        _mtcuteWorkerId: this.workerId,
         type: "result",
         id: msg.id,
         error: new Error(`Method ${msg.method} not found on ${msg.target}`)
@@ -121,6 +137,7 @@ class TelegramWorker {
       }
       if (msg.void) return;
       respond({
+        _mtcuteWorkerId: this.workerId,
         type: "result",
         id: msg.id,
         result: serializeResult(res)
@@ -130,12 +147,16 @@ class TelegramWorker {
         this.pendingAborts.delete(msg.id);
       }
       respond({
+        _mtcuteWorkerId: this.workerId,
         type: "result",
         id: msg.id,
         error: serializeError(err)
       });
     });
   }
+  destroy() {
+    this._cleanup?.();
+  }
 }
 export {
   TelegramWorker

package/network/network-manager.cjs

@@ -225,7 +225,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.25.1",
+      appVersion: "0.25.2",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"

package/network/network-manager.js

@@ -218,7 +218,7 @@ class NetworkManager {
       _: "initConnection",
       deviceModel,
       systemVersion: "1.0",
-      appVersion: "0.25.1",
+      appVersion: "0.25.2",
       systemLangCode: "en",
       langPack: "",
       // "langPacks are for official apps only"

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@mtcute/core",
     "type": "module",
-    "version": "0.25.1",
+    "version": "0.25.2",
     "description": "Type-safe library for MTProto (Telegram API)",
     "license": "MIT",
     "scripts": {},

package/worker.cjs

@@ -9,6 +9,7 @@ const port = require("./highlevel/worker/port.cjs");
 const protocol = require("./highlevel/worker/protocol.cjs");
 const worker = require("./highlevel/worker/worker.cjs");
 exports.TelegramWorkerPort = port.TelegramWorkerPort;
+exports.DEFAULT_WORKER_ID = protocol.DEFAULT_WORKER_ID;
 exports.deserializeResult = protocol.deserializeResult;
 exports.serializeResult = protocol.serializeResult;
 exports.TelegramWorker = worker.TelegramWorker;

package/worker.js

@@ -1,7 +1,8 @@
 import { TelegramWorkerPort } from "./highlevel/worker/port.js";
-import { deserializeResult, serializeResult } from "./highlevel/worker/protocol.js";
+import { DEFAULT_WORKER_ID, deserializeResult, serializeResult } from "./highlevel/worker/protocol.js";
 import { TelegramWorker } from "./highlevel/worker/worker.js";
 export {
+  DEFAULT_WORKER_ID,
   TelegramWorker,
   TelegramWorkerPort,
   deserializeResult,