refactor!: renamed MaybeAsync -> MaybePromise

e2e/ts/utils.ts

@@ -1,7 +1,7 @@
 // eslint-disable-next-line no-restricted-imports
 import { join } from 'path'
 
-import { MaybeAsync, MemoryStorage } from '@mtcute/core'
+import { MaybePromise, MemoryStorage } from '@mtcute/core'
 import { LogManager, sleep } from '@mtcute/core/utils.js'
 import { SqliteStorage } from '@mtcute/sqlite'
 
@@ -19,7 +19,7 @@ export const getApiParams = (storage?: string) => {
     }
 }
 
-export async function waitFor(condition: () => MaybeAsync<void>, timeout = 5000): Promise<void> {
+export async function waitFor(condition: () => MaybePromise<void>, timeout = 5000): Promise<void> {
     const start = Date.now()
     let lastError
 

packages/core/src/highlevel/client.ts

@@ -8,7 +8,7 @@ import { tdFileId } from '@mtcute/file-id'
 import { tl } from '@mtcute/tl'
 
 import { MemoryStorage } from '../storage/providers/memory/index.js'
-import { MaybeArray, MaybeAsync, PartialExcept, PartialOnly } from '../types/index.js'
+import { MaybeArray, MaybePromise, PartialExcept, PartialOnly } from '../types/index.js'
 import { StringSessionData } from '../utils/string-session.js'
 import { BaseTelegramClient, BaseTelegramClientOptions } from './base.js'
 import { ITelegramClient } from './client.types.js'
@@ -672,7 +672,7 @@ export interface TelegramClient extends ITelegramClient {
      * This method handles both login and sign up, and also handles 2FV
      *
      * All parameters are `MaybeDynamic<T>`, meaning you
-     * can either supply `T`, or a function that returns `MaybeAsync<T>`
+     * can either supply `T`, or a function that returns `MaybePromise<T>`
      *
      * This method is intended for simple and fast use in automated
      * scripts and bots. If you are developing a custom client,
@@ -725,7 +725,7 @@ export interface TelegramClient extends ITelegramClient {
          * If provided `code`/`password` is a constant string, providing an
          * invalid one will interrupt authorization flow.
          */
-        invalidCodeCallback?: (type: 'code' | 'password') => MaybeAsync<void>
+        invalidCodeCallback?: (type: 'code' | 'password') => MaybePromise<void>
 
         /**
          * Whether to force code delivery through SMS
@@ -741,7 +741,7 @@ export interface TelegramClient extends ITelegramClient {
          * @param code
          * @default  `console.log`.
          */
-        codeSentCallback?: (code: SentCode) => MaybeAsync<void>
+        codeSentCallback?: (code: SentCode) => MaybePromise<void>
     }): Promise<User>
     /**
      * Check if the given peer/input peer is referring to the current user

packages/core/src/highlevel/methods/_imports.ts

@@ -6,7 +6,7 @@ import { tdFileId } from '@mtcute/file-id'
 import { tl } from '@mtcute/tl'
 
 // @copy
-import { MaybeArray, MaybeAsync, PartialExcept, PartialOnly } from '../../types/index.js'
+import { MaybeArray, MaybePromise, PartialExcept, PartialOnly } from '../../types/index.js'
 // @copy
 import { StringSessionData } from '../../utils/string-session.js'
 // @copy

packages/core/src/highlevel/methods/auth/start.ts

@@ -2,7 +2,7 @@
 import { tl } from '@mtcute/tl'
 
 import { MtArgumentError } from '../../../types/errors.js'
-import { MaybeAsync } from '../../../types/utils.js'
+import { MaybePromise } from '../../../types/utils.js'
 import { StringSessionData } from '../../../utils/string-session.js'
 import { ITelegramClient } from '../../client.types.js'
 import { SentCode } from '../../types/auth/sent-code.js'
@@ -24,7 +24,7 @@ import { signInBot } from './sign-in-bot.js'
  * This method handles both login and sign up, and also handles 2FV
  *
  * All parameters are `MaybeDynamic<T>`, meaning you
- * can either supply `T`, or a function that returns `MaybeAsync<T>`
+ * can either supply `T`, or a function that returns `MaybePromise<T>`
  *
  * This method is intended for simple and fast use in automated
  * scripts and bots. If you are developing a custom client,
@@ -77,7 +77,7 @@ export async function start(
          * If provided `code`/`password` is a constant string, providing an
          * invalid one will interrupt authorization flow.
          */
-        invalidCodeCallback?: (type: 'code' | 'password') => MaybeAsync<void>
+        invalidCodeCallback?: (type: 'code' | 'password') => MaybePromise<void>
 
         /**
          * Whether to force code delivery through SMS
@@ -93,7 +93,7 @@ export async function start(
          * @param code
          * @default  `console.log`.
          */
-        codeSentCallback?: (code: SentCode) => MaybeAsync<void>
+        codeSentCallback?: (code: SentCode) => MaybePromise<void>
     },
 ): Promise<User> {
     if (params.session) {

packages/core/src/highlevel/storage/repository/peers.ts

@@ -1,4 +1,4 @@
-import { MaybeAsync } from '../../../types/utils.js'
+import { MaybePromise } from '../../../types/utils.js'
 
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace IPeersRepository {
@@ -25,13 +25,13 @@ export namespace IPeersRepository {
 
 export interface IPeersRepository {
     /** Store the given peer*/
-    store(peer: IPeersRepository.PeerInfo): MaybeAsync<void>
+    store(peer: IPeersRepository.PeerInfo): MaybePromise<void>
     /** Find a peer by their `id` */
-    getById(id: number): MaybeAsync<IPeersRepository.PeerInfo | null>
+    getById(id: number): MaybePromise<IPeersRepository.PeerInfo | null>
     /** Find a peer by their username (where `usernames` includes `username`) */
-    getByUsername(username: string): MaybeAsync<IPeersRepository.PeerInfo | null>
+    getByUsername(username: string): MaybePromise<IPeersRepository.PeerInfo | null>
     /** Find a peer by their `phone` */
-    getByPhone(phone: string): MaybeAsync<IPeersRepository.PeerInfo | null>
+    getByPhone(phone: string): MaybePromise<IPeersRepository.PeerInfo | null>
 
-    deleteAll(): MaybeAsync<void>
+    deleteAll(): MaybePromise<void>
 }

packages/core/src/highlevel/storage/repository/ref-messages.ts

@@ -1,8 +1,8 @@
-import { MaybeAsync } from '../../../types/utils.js'
+import { MaybePromise } from '../../../types/utils.js'
 
 export interface IReferenceMessagesRepository {
     /** Store a reference message */
-    store(peerId: number, chatId: number, msgId: number): MaybeAsync<void>
+    store(peerId: number, chatId: number, msgId: number): MaybePromise<void>
     /**
      * Get the reference message for the given `peerId`.
      *
@@ -10,13 +10,13 @@ export interface IReferenceMessagesRepository {
      * the one with the highest `msgId` should be returned, but this is not
      * really important.
      */
-    getByPeer(peerId: number): MaybeAsync<[number, number] | null>
+    getByPeer(peerId: number): MaybePromise<[number, number] | null>
 
     /**
      * Delete reference messages given the `chatId`
      * where `msgId` is one of `msgIds`
      */
-    delete(chatId: number, msgIds: number[]): MaybeAsync<void>
+    delete(chatId: number, msgIds: number[]): MaybePromise<void>
-    deleteByPeer(peerId: number): MaybeAsync<void>
+    deleteByPeer(peerId: number): MaybePromise<void>
-    deleteAll(): MaybeAsync<void>
+    deleteAll(): MaybePromise<void>
 }

packages/core/src/highlevel/types/conversation.ts

@@ -1,7 +1,7 @@
 import { tl } from '@mtcute/tl'
 
 import { MtArgumentError, MtTimeoutError } from '../../types/errors.js'
-import { MaybeAsync } from '../../types/utils.js'
+import { MaybePromise } from '../../types/utils.js'
 import { AsyncLock } from '../../utils/async-lock.js'
 import { ControllablePromise, createControllablePromise } from '../../utils/controllable-promise.js'
 import { Deque } from '../../utils/deque.js'
@@ -20,7 +20,7 @@ import { ParametersSkip2 } from './utils.js'
 
 interface QueuedHandler<T> {
     promise: ControllablePromise<T>
-    check?: (update: T) => MaybeAsync<boolean>
+    check?: (update: T) => MaybePromise<boolean>
     timeout?: NodeJS.Timeout
 }
 
@@ -304,7 +304,7 @@ export class Conversation {
      *
      * @param handler
      */
-    async with<T>(handler: () => MaybeAsync<T>): Promise<T> {
+    async with<T>(handler: () => MaybePromise<T>): Promise<T> {
         await this.start()
 
         let err: unknown
@@ -332,7 +332,7 @@ export class Conversation {
      *   When the timeout is reached, `MtTimeoutError` is thrown.
      */
     waitForNewMessage(
-        filter?: (msg: Message) => MaybeAsync<boolean>,
+        filter?: (msg: Message) => MaybePromise<boolean>,
         timeout: number | null = 15000,
     ): Promise<Message> {
         if (!this._started) {
@@ -372,7 +372,7 @@ export class Conversation {
      * @param params
      */
     waitForResponse(
-        filter?: (msg: Message) => MaybeAsync<boolean>,
+        filter?: (msg: Message) => MaybePromise<boolean>,
         params?: {
             /**
              * Message for which to wait for response for.
@@ -408,7 +408,7 @@ export class Conversation {
      * @param params
      */
     waitForReply(
-        filter?: (msg: Message) => MaybeAsync<boolean>,
+        filter?: (msg: Message) => MaybePromise<boolean>,
         params?: {
             /**
              * Message for which to wait for reply for.
@@ -451,7 +451,7 @@ export class Conversation {
      * @param params
      */
     async waitForEdit(
-        filter?: (msg: Message) => MaybeAsync<boolean>,
+        filter?: (msg: Message) => MaybePromise<boolean>,
         params?: {
             /**
              * Message for which to wait for reply for.

packages/core/src/highlevel/types/utils.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { MaybeAsync } from '../../types/utils.js'
+import { MaybePromise } from '../../types/utils.js'
 
-export type MaybeDynamic<T> = MaybeAsync<T> | (() => MaybeAsync<T>)
+export type MaybeDynamic<T> = MaybePromise<T> | (() => MaybePromise<T>)
 
 export type ArrayWithTotal<T> = T[] & { total: number }
 export type ArrayPaginated<T, Offset> = T[] & { total: number; next?: Offset }

packages/core/src/highlevel/updates/manager.ts

@@ -2,7 +2,7 @@
 import { tl } from '@mtcute/tl'
 
 import { MtArgumentError } from '../../types/errors.js'
-import { assertNever, MaybeAsync } from '../../types/utils.js'
+import { assertNever, MaybePromise } from '../../types/utils.js'
 import {
     AsyncLock,
     ConditionVariable,
@@ -680,7 +680,7 @@ export class UpdatesManager {
 
         const channelId = toggleChannelIdMark(peerId.channelId)
 
-        const promises: MaybeAsync<void>[] = []
+        const promises: MaybePromise<void>[] = []
 
         function store(peer?: tl.TypePeer | number | number[]): void {
             if (!peer) return

packages/core/src/network/transports/abstract.ts

@@ -2,7 +2,7 @@ import EventEmitter from 'events'
 
 import { tl } from '@mtcute/tl'
 
-import { MaybeAsync } from '../../types/index.js'
+import { MaybePromise } from '../../types/index.js'
 import { BasicDcOption, ICryptoProvider, Logger } from '../../utils/index.js'
 
 /** Current state of the transport */
@@ -73,10 +73,10 @@ export type TransportFactory = () => ITelegramTransport
  */
 export interface IPacketCodec {
     /** Initial tag of the codec. Will be sent immediately once connected. */
-    tag(): MaybeAsync<Uint8Array>
+    tag(): MaybePromise<Uint8Array>
 
     /** Encodes and frames a single packet */
-    encode(packet: Uint8Array): MaybeAsync<Uint8Array>
+    encode(packet: Uint8Array): MaybePromise<Uint8Array>
 
     /** Feed packet to the codec. Once packet is processed, codec is supposed to emit `packet` or `error` */
     feed(data: Uint8Array): void

packages/core/src/storage/driver.ts

@@ -1,4 +1,4 @@
-import { MaybeAsync } from '../types/utils.js'
+import { MaybePromise } from '../types/utils.js'
 import { Logger } from '../utils/logger.js'
 
 /**
@@ -14,7 +14,7 @@ export interface IStorageDriver {
      * May be called more than once, handle this with care
      * (or use {@link BaseStorageDriver} that handles this for you)
      */
-    load?(): MaybeAsync<void>
+    load?(): MaybePromise<void>
     /**
      * Save session to some external storage.
      * Should be used to commit pending changes in the session.
@@ -24,14 +24,14 @@ export interface IStorageDriver {
      * It is safe to batch all changes and only commit them here,
      * unless stated otherwise in the method description
      */
-    save?(): MaybeAsync<void>
+    save?(): MaybePromise<void>
     /**
      * Cleanup session and release all used resources.
      *
      * May be called more than once, handle this with care
      * (or use {@link BaseStorageDriver} that handles this for you)
      */
-    destroy?(): MaybeAsync<void>
+    destroy?(): MaybePromise<void>
 
     /**
      * Setup the driver, passing the logger instance,
@@ -45,9 +45,9 @@ export interface IStorageDriver {
  * and handling the lifecycle for you
  */
 export abstract class BaseStorageDriver implements IStorageDriver {
-    abstract _load(): MaybeAsync<void>
+    abstract _load(): MaybePromise<void>
-    abstract _destroy(): MaybeAsync<void>
+    abstract _destroy(): MaybePromise<void>
-    abstract _save?(): MaybeAsync<void>
+    abstract _save?(): MaybePromise<void>
 
     private _loadedTimes = 0
     private _destroyed = false
@@ -84,7 +84,7 @@ export abstract class BaseStorageDriver implements IStorageDriver {
         }
     }
 
-    save(): MaybeAsync<void> {
+    save(): MaybePromise<void> {
         return this._save?.()
     }
 }

packages/core/src/storage/repository/auth-keys.ts

@@ -1,4 +1,4 @@
-import { MaybeAsync } from '../../types/utils.js'
+import { MaybePromise } from '../../types/utils.js'
 
 export interface IAuthKeysRepository {
     /**
@@ -8,9 +8,9 @@ export interface IAuthKeysRepository {
      *
      * **MUST** be applied immediately, without batching
      */
-    set(dc: number, key: Uint8Array | null): MaybeAsync<void>
+    set(dc: number, key: Uint8Array | null): MaybePromise<void>
     /** Get auth_key for the given DC */
-    get(dc: number): MaybeAsync<Uint8Array | null>
+    get(dc: number): MaybePromise<Uint8Array | null>
 
     /**
      * Store temp_auth_key for the given DC and idx,
@@ -20,13 +20,13 @@ export interface IAuthKeysRepository {
      *
      * **MUST** be applied immediately, without batching
      */
-    setTemp(dc: number, idx: number, key: Uint8Array | null, expires: number): MaybeAsync<void>
+    setTemp(dc: number, idx: number, key: Uint8Array | null, expires: number): MaybePromise<void>
     /**
      * Given the DC id, idx and point in time (in seconds),
      * return the temp_auth_key that should be used for the next request
      * (such that `now < key.expires`), or `null` if no such key exists
      */
-    getTemp(dc: number, idx: number, now: number): MaybeAsync<Uint8Array | null>
+    getTemp(dc: number, idx: number, now: number): MaybePromise<Uint8Array | null>
 
     /**
      * Delete all stored auth keys for the given DC, including
@@ -34,12 +34,12 @@ export interface IAuthKeysRepository {
      *
      * **MUST** be applied immediately, without batching
      */
-    deleteByDc(dc: number): MaybeAsync<void>
+    deleteByDc(dc: number): MaybePromise<void>
 
     /**
      * Delete all stored auth keys, including both permanent and temp keys
      *
      * **MUST** be applied immediately, without batching
      */
-    deleteAll(): MaybeAsync<void>
+    deleteAll(): MaybePromise<void>
 }

packages/core/src/storage/repository/key-value.ts

@@ -1,12 +1,12 @@
-import { MaybeAsync } from '../../types/utils.js'
+import { MaybePromise } from '../../types/utils.js'
 
 export interface IKeyValueRepository {
     /** Set a key-value pair */
-    set(key: string, value: Uint8Array): MaybeAsync<void>
+    set(key: string, value: Uint8Array): MaybePromise<void>
     /** Get a key-value pair */
-    get(key: string): MaybeAsync<Uint8Array | null>
+    get(key: string): MaybePromise<Uint8Array | null>
     /** Delete a key-value pair */
-    delete(key: string): MaybeAsync<void>
+    delete(key: string): MaybePromise<void>
 
-    deleteAll(): MaybeAsync<void>
+    deleteAll(): MaybePromise<void>
 }

packages/core/src/types/utils.ts

@@ -1,4 +1,4 @@
-export type MaybeAsync<T> = T | Promise<T>
+export type MaybePromise<T> = T | Promise<T>
 export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>
 export type PartialOnly<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>
 

packages/core/src/utils/crypto/abstract.ts

@@ -1,4 +1,4 @@
-import { MaybeAsync } from '../../types/index.js'
+import { MaybePromise } from '../../types/index.js'
 import { factorizePQSync } from './factorization.js'
 
 export interface IEncryptionScheme {
@@ -12,7 +12,7 @@ export interface IAesCtr {
 }
 
 export interface ICryptoProvider {
-    initialize?(): MaybeAsync<void>
+    initialize?(): MaybePromise<void>
 
     sha1(data: Uint8Array): Uint8Array
 
@@ -24,15 +24,15 @@ export interface ICryptoProvider {
         iterations: number,
         keylen?: number, // = 64
         algo?: string, // sha1 or sha512 (default sha512)
-    ): MaybeAsync<Uint8Array>
+    ): MaybePromise<Uint8Array>
 
-    hmacSha256(data: Uint8Array, key: Uint8Array): MaybeAsync<Uint8Array>
+    hmacSha256(data: Uint8Array, key: Uint8Array): MaybePromise<Uint8Array>
 
     createAesCtr(key: Uint8Array, iv: Uint8Array, encrypt: boolean): IAesCtr
 
     createAesIge(key: Uint8Array, iv: Uint8Array): IEncryptionScheme
 
-    factorizePQ(pq: Uint8Array): MaybeAsync<[Uint8Array, Uint8Array]>
+    factorizePQ(pq: Uint8Array): MaybePromise<[Uint8Array, Uint8Array]>
 
     gzip(data: Uint8Array, maxSize: number): Uint8Array | null
     gunzip(data: Uint8Array): Uint8Array

packages/core/src/utils/crypto/node.ts

@@ -4,7 +4,7 @@ import { deflateSync, gunzipSync } from 'zlib'
 
 import { ige256Decrypt, ige256Encrypt, initAsync, InitInput } from '@mtcute/wasm'
 
-import { MaybeAsync } from '../../types/index.js'
+import { MaybePromise } from '../../types/index.js'
 import { BaseCryptoProvider, IAesCtr, ICryptoProvider, IEncryptionScheme } from './abstract.js'
 
 export abstract class BaseNodeCryptoProvider extends BaseCryptoProvider {
@@ -24,7 +24,7 @@ export abstract class BaseNodeCryptoProvider extends BaseCryptoProvider {
         iterations: number,
         keylen = 64,
         algo = 'sha512',
-    ): MaybeAsync<Uint8Array> {
+    ): MaybePromise<Uint8Array> {
         return new Promise((resolve, reject) =>
             pbkdf2(password, salt, iterations, keylen, algo, (err: Error | null, buf: Uint8Array) =>
                 err !== null ? reject(err) : resolve(buf),

packages/dispatcher/src/context/callback-query.ts

@@ -1,4 +1,4 @@
-import { CallbackQuery, InlineCallbackQuery, MaybeAsync, Message, TelegramClient } from '@mtcute/core'
+import { CallbackQuery, InlineCallbackQuery, MaybePromise, Message, TelegramClient } from '@mtcute/core'
 
 import { UpdateContext } from './base.js'
 
@@ -46,7 +46,7 @@ export class CallbackQueryContext extends CallbackQuery implements UpdateContext
     /**
      * Shortcut for getting the message and editing it.
      */
-    async editMessageWith(handler: (msg: Message) => MaybeAsync<Parameters<CallbackQueryContext['editMessage']>[0]>) {
+    async editMessageWith(handler: (msg: Message) => MaybePromise<Parameters<CallbackQueryContext['editMessage']>[0]>) {
         const msg = await this.getMessage()
         if (!msg) return
 

packages/dispatcher/src/dispatcher.ts

@@ -12,7 +12,7 @@ import {
     DeleteMessageUpdate,
     DeleteStoryUpdate,
     HistoryReadUpdate,
-    MaybeAsync,
+    MaybePromise,
     MtArgumentError,
     ParsedUpdate,
     PeersIndex,
@@ -66,12 +66,7 @@ import {
 } from './handler.js'
 // end-codegen-imports
 import { PropagationAction } from './propagation.js'
-import {
+import { defaultStateKeyDelegate, IStateStorageProvider, StateKeyDelegate, UpdateState } from './state/index.js'
-    defaultStateKeyDelegate,
-    IStateStorageProvider,
-    StateKeyDelegate,
-    UpdateState,
-} from './state/index.js'
 import { StateService } from './state/service.js'
 
 export interface DispatcherParams {
@@ -121,18 +116,18 @@ export class Dispatcher<State extends object = never> {
         err: Error,
         update: ParsedUpdate & T,
         state?: UpdateState<State>,
-    ) => MaybeAsync<boolean>
+    ) => MaybePromise<boolean>
 
     private _preUpdateHandler?: <T = {}>(
         update: ParsedUpdate & T,
         state?: UpdateState<State>,
-    ) => MaybeAsync<PropagationAction | void>
+    ) => MaybePromise<PropagationAction | void>
 
     private _postUpdateHandler?: <T = {}>(
         handled: boolean,
         update: ParsedUpdate & T,
         state?: UpdateState<State>,
-    ) => MaybeAsync<void>
+    ) => MaybePromise<void>
 
     protected constructor(client?: TelegramClient, params?: DispatcherParams) {
         this.dispatchRawUpdate = this.dispatchRawUpdate.bind(this)
@@ -146,7 +141,7 @@ export class Dispatcher<State extends object = never> {
 
             if (storage) {
                 this._storage = new StateService(storage)
-                this._stateKeyDelegate = (key ?? defaultStateKeyDelegate)
+                this._stateKeyDelegate = key ?? defaultStateKeyDelegate
             }
         } else {
             // child dispatcher without client
@@ -597,7 +592,7 @@ export class Dispatcher<State extends object = never> {
      * @param handler  Error handler
      */
     onError<T = {}>(
-        handler: ((err: Error, update: ParsedUpdate & T, state?: UpdateState<State>) => MaybeAsync<boolean>) | null,
+        handler: ((err: Error, update: ParsedUpdate & T, state?: UpdateState<State>) => MaybePromise<boolean>) | null,
     ): void {
         if (handler) this._errorHandler = handler
         else this._errorHandler = undefined
@@ -617,7 +612,7 @@ export class Dispatcher<State extends object = never> {
      */
     onPreUpdate<T = {}>(
         handler:
-            | ((update: ParsedUpdate & T, state?: UpdateState<State>) => MaybeAsync<PropagationAction | void>)
+            | ((update: ParsedUpdate & T, state?: UpdateState<State>) => MaybePromise<PropagationAction | void>)
             | null,
     ): void {
         if (handler) this._preUpdateHandler = handler
@@ -637,7 +632,9 @@ export class Dispatcher<State extends object = never> {
      * @param handler  Pre-update middleware
      */
     onPostUpdate<T = {}>(
-        handler: ((handled: boolean, update: ParsedUpdate & T, state?: UpdateState<State>) => MaybeAsync<void>) | null,
+        handler:
+            | ((handled: boolean, update: ParsedUpdate & T, state?: UpdateState<State>) => MaybePromise<void>)
+            | null,
     ): void {
         if (handler) this._postUpdateHandler = handler
         else this._postUpdateHandler = undefined
@@ -647,7 +644,7 @@ export class Dispatcher<State extends object = never> {
      * Set error handler that will propagate
      * the error to the parent dispatcher
      */
-    propagateErrorToParent(err: Error, update: ParsedUpdate, state?: UpdateState<State>): MaybeAsync<boolean> {
+    propagateErrorToParent(err: Error, update: ParsedUpdate, state?: UpdateState<State>): MaybePromise<boolean> {
         if (!this.parent) {
             throw new MtArgumentError('This dispatcher is not a child')
         }
@@ -912,7 +909,7 @@ export class Dispatcher<State extends object = never> {
      * @template S  State type, defaults to dispatcher's state type. Only checked at compile-time
      */
     getState<S extends object = State>(object: Parameters<StateKeyDelegate>[0]): Promise<UpdateState<S>>
-    getState<S extends object = State>(object: string | Parameters<StateKeyDelegate>[0]): MaybeAsync<UpdateState<S>> {
+    getState<S extends object = State>(object: string | Parameters<StateKeyDelegate>[0]): MaybePromise<UpdateState<S>> {
         if (!this._storage) {
             throw new MtArgumentError('Cannot use getUpdateState() filter without state storage')
         }

packages/dispatcher/src/filters/bots.ts

@@ -1,4 +1,4 @@
-import { MaybeArray, MaybeAsync, Message } from '@mtcute/core'
+import { MaybeArray, MaybePromise, Message } from '@mtcute/core'
 
 import { MessageContext } from '../context/message.js'
 import { chat } from './chat.js'
@@ -51,7 +51,7 @@ export const command = (
 
     const _prefixes = prefixes
 
-    const check = (msg: MessageContext): MaybeAsync<boolean> => {
+    const check = (msg: MessageContext): MaybePromise<boolean> => {
         if (msg.isMessageGroup) return check(msg.messages[0])
 
         for (const pref of _prefixes) {

packages/dispatcher/src/filters/group.ts

@@ -1,4 +1,4 @@
-import { MaybeAsync, Message } from '@mtcute/core'
+import { MaybePromise, Message } from '@mtcute/core'
 
 import { MessageContext } from '../context/message.js'
 import { Modify, UpdateFilter } from './types.js'
@@ -26,7 +26,7 @@ export function every<Mod, State extends object>(
         const upds = ctx.messages
         const max = upds.length
 
-        const next = (): MaybeAsync<boolean> => {
+        const next = (): MaybePromise<boolean> => {
             if (i === max) return true
 
             const res = filter(upds[i++], state)
@@ -67,7 +67,7 @@ export function some<State extends object>(
         const upds = ctx.messages
         const max = upds.length
 
-        const next = (): MaybeAsync<boolean> => {
+        const next = (): MaybePromise<boolean> => {
             if (i === max) return false
 
             const res = filter(upds[i++], state)

packages/dispatcher/src/filters/logic.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // ^^ will be looked into in MTQ-29
 
-import { MaybeAsync } from '@mtcute/core'
+import { MaybePromise } from '@mtcute/core'
 
 import { ExtractBaseMany, ExtractMod, Invert, UnionToIntersection, UpdateFilter } from './types.js'
 
@@ -160,7 +160,7 @@ export function and(...fns: UpdateFilter<any, any, any>[]): UpdateFilter<any, an
         let i = 0
         const max = fns.length
 
-        const next = (): MaybeAsync<boolean> => {
+        const next = (): MaybePromise<boolean> => {
             if (i === max) return true
 
             const res = fns[i++](upd, state)
@@ -306,7 +306,7 @@ export function or(...fns: UpdateFilter<any, any, any>[]): UpdateFilter<any, any
         let i = 0
         const max = fns.length
 
-        const next = (): MaybeAsync<boolean> => {
+        const next = (): MaybePromise<boolean> => {
             if (i === max) return false
 
             const res = fns[i++](upd, state)

packages/dispatcher/src/filters/state.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { MaybeAsync } from '@mtcute/core'
+import { MaybePromise } from '@mtcute/core'
 
 import { UpdateFilter } from './types.js'
 
@@ -21,7 +21,7 @@ export const stateEmpty: UpdateFilter<any> = async (upd, state) => {
  * @param predicate  State predicate
  */
 export const state = <T extends object>(
-    predicate: (state: T) => MaybeAsync<boolean>,
+    predicate: (state: T) => MaybePromise<boolean>,
     // eslint-disable-next-line @typescript-eslint/ban-types
 ): UpdateFilter<any, {}, T> => {
     return async (upd, state) => {

packages/dispatcher/src/filters/types.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 // ^^ will be looked into in MTQ-29
 
-import { MaybeAsync } from '@mtcute/core'
+import { MaybePromise } from '@mtcute/core'
 
 import { UpdateState } from '../state/update-state.js'
 /**
@@ -78,7 +78,7 @@ import { UpdateState } from '../state/update-state.js'
 export type UpdateFilter<Base, Mod = {}, State extends object = never> = (
     update: Base,
     state?: UpdateState<State>,
-) => MaybeAsync<boolean>
+) => MaybePromise<boolean>
 
 export type Modify<Base, Mod> = Omit<Base, keyof Mod> & Mod
 export type Invert<Base, Mod> = {

packages/dispatcher/src/handler.ts

@@ -7,7 +7,7 @@ import {
     DeleteMessageUpdate,
     DeleteStoryUpdate,
     HistoryReadUpdate,
-    MaybeAsync,
+    MaybePromise,
     PeersIndex,
     PollUpdate,
     PollVoteUpdate,
@@ -39,8 +39,8 @@ export interface BaseUpdateHandler<Name, Handler, Checker> {
 
 export type ParsedUpdateHandler<Name, Update, State = never> = BaseUpdateHandler<
     Name,
-    (update: Update, state: State) => MaybeAsync<void | PropagationAction>,
+    (update: Update, state: State) => MaybePromise<void | PropagationAction>,
-    (update: Update, state: State) => MaybeAsync<boolean>
+    (update: Update, state: State) => MaybePromise<boolean>
 >
 
 export type RawUpdateHandler = BaseUpdateHandler<
@@ -49,8 +49,8 @@ export type RawUpdateHandler = BaseUpdateHandler<
         client: TelegramClient,
         update: tl.TypeUpdate | tl.TypeMessage,
         peers: PeersIndex,
-    ) => MaybeAsync<void | PropagationAction>,
+    ) => MaybePromise<void | PropagationAction>,
-    (client: TelegramClient, update: tl.TypeUpdate | tl.TypeMessage, peers: PeersIndex) => MaybeAsync<boolean>
+    (client: TelegramClient, update: tl.TypeUpdate | tl.TypeMessage, peers: PeersIndex) => MaybePromise<boolean>
 >
 
 // begin-codegen

packages/dispatcher/src/state/key.ts

@@ -1,4 +1,4 @@
-import { assertNever, MaybeAsync, Peer } from '@mtcute/core'
+import { assertNever, MaybePromise, Peer } from '@mtcute/core'
 
 import { CallbackQueryContext, MessageContext } from '../context/index.js'
 
@@ -10,7 +10,7 @@ import { CallbackQueryContext, MessageContext } from '../context/index.js'
  * @param msg  Message or callback from which to derive the key
  * @param scene  Current scene UID, or `null` if none
  */
-export type StateKeyDelegate = (upd: MessageContext | CallbackQueryContext | Peer) => MaybeAsync<string | null>
+export type StateKeyDelegate = (upd: MessageContext | CallbackQueryContext | Peer) => MaybePromise<string | null>
 
 /**
  * Default state key delegate.

packages/dispatcher/src/state/providers/memory.ts

@@ -1,4 +1,4 @@
-import { MaybeAsync, MemoryStorageDriver } from '@mtcute/core'
+import { MaybePromise, MemoryStorageDriver } from '@mtcute/core'
 
 import { IStateStorageProvider } from '../provider.js'
 import { IStateRepository } from '../repository.js'
@@ -91,15 +91,13 @@ class MemoryStateRepository implements IStateRepository {
         return [item.remaining, item.reset]
     }
 
-    resetRateLimit(key: string): MaybeAsync<void> {
+    resetRateLimit(key: string): MaybePromise<void> {
         this.rl.delete(key)
     }
 }
 
 export class MemoryStateStorage implements IStateStorageProvider {
-    constructor(
+    constructor(readonly driver: MemoryStorageDriver = new MemoryStorageDriver()) {}
-        readonly driver: MemoryStorageDriver = new MemoryStorageDriver(),
-    ) {}
 
     readonly state = new MemoryStateRepository(this.driver)
 }

packages/dispatcher/src/state/providers/sqlite.ts

@@ -1,4 +1,4 @@
-import { MaybeAsync } from '@mtcute/core'
+import { MaybePromise } from '@mtcute/core'
 import type { SqliteStorage, SqliteStorageDriver, Statement } from '@mtcute/sqlite'
 
 import { IStateStorageProvider } from '../provider.js'
@@ -46,12 +46,12 @@ class SqliteStateRepository implements IStateRepository {
     }
 
     private _setState!: Statement
-    setState(key: string, state: string, ttl?: number | undefined): MaybeAsync<void> {
+    setState(key: string, state: string, ttl?: number | undefined): MaybePromise<void> {
         this._setState.run(key, state, ttl ? Date.now() + ttl * 1000 : undefined)
     }
 
     private _getState!: Statement
-    getState(key: string, now: number): MaybeAsync<string | null> {
+    getState(key: string, now: number): MaybePromise<string | null> {
         const res_ = this._getState.get(key)
         if (!res_) return null
         const res = res_ as StateDto
@@ -66,13 +66,13 @@ class SqliteStateRepository implements IStateRepository {
     }
 
     private _deleteState!: Statement
-    deleteState(key: string): MaybeAsync<void> {
+    deleteState(key: string): MaybePromise<void> {
         this._deleteState.run(key)
     }
 
     private _deleteOldState!: Statement
     private _deleteOldRl!: Statement
-    vacuum(now: number): MaybeAsync<void> {
+    vacuum(now: number): MaybePromise<void> {
         this._deleteOldState.run(now)
         this._deleteOldRl.run(now)
     }
@@ -107,7 +107,7 @@ class SqliteStateRepository implements IStateRepository {
         return [val.remaining, val.reset]
     }
 
-    resetRateLimit(key: string): MaybeAsync<void> {
+    resetRateLimit(key: string): MaybePromise<void> {
         this._deleteRl.run(key)
     }
 }

packages/dispatcher/src/state/repository.ts

@@ -1,4 +1,4 @@
-import { MaybeAsync } from '@mtcute/core'
+import { MaybePromise } from '@mtcute/core'
 
 /**
  * Interface for FSM storage for the dispatcher.
@@ -19,7 +19,7 @@ export interface IStateRepository {
      *
      * @param key  Key of the state, as defined by {@link StateKeyDelegate}
      */
-    getState(key: string, now: number): MaybeAsync<string | null>
+    getState(key: string, now: number): MaybePromise<string | null>
 
     /**
      * Save state to the storage
@@ -28,21 +28,21 @@ export interface IStateRepository {
      * @param state  String representing the state
      * @param ttl  TTL for the state, in seconds
      */
-    setState(key: string, state: string, ttl?: number): MaybeAsync<void>
+    setState(key: string, state: string, ttl?: number): MaybePromise<void>
 
     /**
      * Delete state from the storage
      *
      * @param key  Key of the state, as defined by {@link StateKeyDelegate}
      */
-    deleteState(key: string): MaybeAsync<void>
+    deleteState(key: string): MaybePromise<void>
 
     /**
      * Clean up expired states and rate limits.
      *
      * @param now  Current unix time in ms
      */
-    vacuum(now: number): MaybeAsync<void>
+    vacuum(now: number): MaybePromise<void>
 
     /**
      * Get information about a rate limit.
@@ -57,12 +57,12 @@ export interface IStateRepository {
      * @returns  Tuple containing the number of remaining and
      *   unix time in ms when the user can try again
      */
-    getRateLimit(key: string, now: number, limit: number, window: number): MaybeAsync<[number, number]>
+    getRateLimit(key: string, now: number, limit: number, window: number): MaybePromise<[number, number]>
 
     /**
      * Reset a rate limit.
      *
      * @param key  Key of the rate limit
      */
-    resetRateLimit(key: string): MaybeAsync<void>
+    resetRateLimit(key: string): MaybePromise<void>
 }

packages/dispatcher/src/wizard.ts

@@ -1,4 +1,4 @@
-import { MaybeAsync } from '@mtcute/core'
+import { MaybePromise } from '@mtcute/core'
 
 import { MessageContext } from './context/message.js'
 import { Dispatcher } from './dispatcher.js'
@@ -94,7 +94,7 @@ export class WizardScene<State extends object> extends Dispatcher<State & Wizard
         handler: (
             msg: MessageContext,
             state: UpdateState<State & WizardInternalState>,
-        ) => MaybeAsync<WizardSceneAction | number>,
+        ) => MaybePromise<WizardSceneAction | number>,
     ): void {
         const step = this._steps++
 

packages/test/src/client.ts

@@ -1,4 +1,11 @@
-import { BaseTelegramClient, BaseTelegramClientOptions, MaybeAsync, MustEqual, RpcCallOptions, tl } from '@mtcute/core'
+import {
+    BaseTelegramClient,
+    BaseTelegramClientOptions,
+    MaybePromise,
+    MustEqual,
+    RpcCallOptions,
+    tl,
+} from '@mtcute/core'
 
 import { StubMemoryTelegramStorage } from './storage.js'
 import { StubTelegramTransport } from './transport.js'
@@ -174,7 +181,7 @@ export class StubTelegramClient extends BaseTelegramClient {
 
     respondWith<
         T extends tl.RpcMethod['_'],
-        Fn extends(data: tl.FindByName<tl.RpcMethod, T>) => MaybeAsync<tl.RpcCallReturn[T]>,
+        Fn extends(data: tl.FindByName<tl.RpcMethod, T>) => MaybePromise<tl.RpcCallReturn[T]>,
     >(method: T, response: Fn): Fn {
         // eslint-disable-next-line
         this._responders.set(method, response as any)
@@ -280,7 +287,7 @@ export class StubTelegramClient extends BaseTelegramClient {
 
     // helpers //
 
-    async with(fn: () => MaybeAsync<void>): Promise<void> {
+    async with(fn: () => MaybePromise<void>): Promise<void> {
         await this.connect()
 
         let error: unknown