simplex-chat 7.1.0-beta.2 → 7.1.0-beta.4.2

package/README.md

@@ -24,13 +24,13 @@ Simple bot that replies with squares of numbers you send to it:
   const {bot} = await import("simplex-chat")
   // if you are running from this GitHub repo:
   // const {bot} = await import("../dist/index.js")
-  const [chat, _user, _address] = await bot.run({
+  await bot.run({
     profile: {displayName: "Squaring bot example", fullName: ""},
     dbOpts: {type: "sqlite", filePrefix: "./squaring_bot"},
     options: {
       addressSettings: {welcomeMessage: "Send a number, I will square it.",
     },
-    onMessage: async (ci, content) => {
+    onMessage: async (ci, content, chat) => {
       const n = +content.text
       const reply = typeof n === "number" && !isNaN(n)
                     ? `${n} * ${n} = ${n * n}`
@@ -62,6 +62,8 @@ There is an example with more options in [./examples/squaring-bot.ts](./examples
 
 You can run it with: `npx ts-node ./examples/squaring-bot.ts`
 
+A larger example, with a business address and commands as keys: [SimpleX Calculator](../../apps/simplex-calculator-bot/).
+
 ## PostgreSQL backend
 
 By default, the package uses SQLite. To use PostgreSQL instead:

package/binding.gyp

@@ -11,6 +11,8 @@
       ],
       "cflags!": [ "-fno-exceptions" ],
       "cflags_cc!": [ "-fno-exceptions" ],
+      "xcode_settings": { "GCC_ENABLE_CPP_EXCEPTIONS": "YES" },
+      "msvs_settings": { "VCCLCompilerTool": { "ExceptionHandling": 1 } },
       "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ],
       "conditions": [
         ["OS=='mac'", {

package/cpp/simplex.cc

@@ -3,6 +3,14 @@
 #include <string>
 #include <functional>
 #include <cstdlib>
+#include <climits>
+#include <memory>
+#include <thread>
+#include <system_error>
+#include <mutex>
+#include <condition_variable>
+#include <deque>
+#include <unordered_map>
 #include "simplex.h"
 
 namespace simplex {
@@ -81,6 +89,11 @@ class ResultAsyncWorker : public AsyncWorker {
     return ctrl_;
   }
 
+  // the worker thread reads this object's memory until the worker completes
+  void KeepAlive(Object obj) {
+    keep_alive_ = Persistent(obj);
+  }
+
  protected:
   std::string result_;
   uintptr_t ctrl_ = 0;
@@ -88,6 +101,7 @@ class ResultAsyncWorker : public AsyncWorker {
  private:
   ExecuteFn execute_fn_;
   ResultProcessor result_processor_;
+  ObjectReference keep_alive_;
 };
 
 class BinaryAsyncWorker : public AsyncWorker {
@@ -97,21 +111,25 @@ class BinaryAsyncWorker : public AsyncWorker {
   BinaryAsyncWorker(Function& callback, ExecuteFn execute_fn)
       : AsyncWorker(callback), execute_fn_(std::move(execute_fn)) {}
 
+  ~BinaryAsyncWorker() {
+    free(original_buf);
+  }
+
   void Execute() override {
     execute_fn_(this);
   }
 
   void OnOK() override {
     HandleScope scope(Env());
-    if (original_buf == nullptr || binary_len == 0) {
-      Callback().Call({Env().Null(), Env().Undefined()});
+    char* buf = original_buf;
+    original_buf = nullptr;
+    if (binary_len == 0) {
+      free(buf);
+      Callback().Call({Env().Null(), Buffer<char>::New(Env(), 0)});
       return;
     }
-    char* data_ptr = original_buf + 5;
-    auto finalizer = [](Napi::Env env, char* finalize_data, char* orig) {
-      free(orig);
-    };
-    Napi::Buffer<char> buffer = Napi::Buffer<char>::New(Env(), data_ptr, binary_len, finalizer, original_buf);
+    // Copies when the runtime forbids external buffers (Electron); the finalizer then runs immediately.
+    Buffer<char> buffer = Buffer<char>::NewOrCopy(Env(), buf + 5, binary_len, [](Napi::Env, char*, char* orig) { free(orig); }, buf);
     Callback().Call({Env().Null(), buffer});
   }
 
@@ -176,6 +194,159 @@ Napi::Promise CreatePromiseAndCallback(Env env, Function& cb_out) {
   return deferred.Promise();
 }
 
+const char* const RECEIVER_STOPPED = "chat receiver stopped";
+
+struct RecvRequest {
+  int wait = 0;
+  std::shared_ptr<Promise::Deferred> deferred;
+};
+
+// Holds the event loop open only while receives are pending; used only on the JS main thread.
+class PendingReceives {
+ public:
+  explicit PendingReceives(ThreadSafeFunction tsfn) : tsfn_(tsfn) {}
+
+  const ThreadSafeFunction& Tsfn() const {
+    return tsfn_;
+  }
+
+  void Add(Napi::Env env) {
+    if (count_++ == 0) tsfn_.Ref(env);
+  }
+
+  void Remove(Napi::Env env) {
+    if (--count_ == 0) tsfn_.Unref(env);
+  }
+
+ private:
+  ThreadSafeFunction tsfn_;
+  size_t count_ = 0;
+};
+
+// A blocking receive would hold a libuv pool thread for up to `wait`, stalling fs, dns and crypto.
+class Receiver {
+ public:
+  // Returns nullptr with a pending JS exception if the TSFN cannot be created, throws std::system_error if the thread cannot start.
+  static std::shared_ptr<Receiver> Start(Napi::Env env, chat_ctrl ctrl) {
+    ThreadSafeFunction tsfn = ThreadSafeFunction::New(env, Function::New(env, [](const CallbackInfo&) {}), "chat_recv_msg_wait", 0, 1);
+    if (env.IsExceptionPending()) {
+      return nullptr;
+    }
+    auto receiver = std::make_shared<Receiver>(ctrl, tsfn);
+    try {
+      receiver->thread_ = std::thread(&Receiver::Run, receiver.get());
+    } catch (const std::system_error&) {
+      tsfn.Release();
+      throw;
+    }
+    return receiver;
+  }
+
+  Receiver(chat_ctrl ctrl, ThreadSafeFunction tsfn) : ctrl_(ctrl), pending_(std::make_shared<PendingReceives>(tsfn)) {}
+
+  Receiver(const Receiver&) = delete;
+  Receiver& operator=(const Receiver&) = delete;
+
+  ~Receiver() {
+    Stop();
+  }
+
+  void Enqueue(Napi::Env env, RecvRequest request) {
+    pending_->Add(env);
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      queue_.push_back(std::move(request));
+    }
+    cv_.notify_one();
+  }
+
+  void RequestStop() {
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      stop_ = true;
+    }
+    cv_.notify_one();
+  }
+
+  // Waits for the receive in progress, so it must not run on the JS main thread outside env teardown.
+  void Stop() {
+    RequestStop();
+    if (thread_.joinable()) {
+      thread_.join();
+    }
+  }
+
+ private:
+  void Run() {
+    for (;;) {
+      RecvRequest request;
+      {
+        std::unique_lock<std::mutex> lock(mutex_);
+        cv_.wait(lock, [this] { return stop_ || !queue_.empty(); });
+        if (stop_) break;
+        request = std::move(queue_.front());
+        queue_.pop_front();
+      }
+      char* c_res = chat_recv_msg_wait(ctrl_, request.wait);
+      napi_status status = Settle(request.deferred, [c_res](Napi::Env env, Promise::Deferred& deferred) {
+        if (c_res == nullptr) {
+          deferred.Reject(Error::New(env, "chat_recv_msg_wait failed").Value());
+        } else {
+          deferred.Resolve(String::New(env, c_res));
+          free(c_res);
+        }
+      });
+      if (status != napi_ok) {
+        free(c_res);
+      }
+    }
+    std::deque<RecvRequest> unserved;
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      unserved.swap(queue_);
+    }
+    for (RecvRequest& request : unserved) {
+      Settle(request.deferred, [](Napi::Env env, Promise::Deferred& deferred) {
+        deferred.Reject(Error::New(env, RECEIVER_STOPPED).Value());
+      });
+    }
+    pending_->Tsfn().Release();
+    // Each OS thread that enters Haskell keeps an RTS task record until it calls hs_thread_done.
+    hs_thread_done();
+  }
+
+  template <typename SettleFn>
+  napi_status Settle(std::shared_ptr<Promise::Deferred> deferred, SettleFn settle) {
+    // The callback may run after this Receiver is destroyed, so it owns the pending count.
+    std::shared_ptr<PendingReceives> pending = pending_;
+    return pending->Tsfn().BlockingCall([pending, deferred, settle](Napi::Env env, Function) {
+      settle(env, *deferred);
+      pending->Remove(env);
+    });
+  }
+
+  const chat_ctrl ctrl_;
+  const std::shared_ptr<PendingReceives> pending_;
+  std::mutex mutex_;
+  std::condition_variable cv_;
+  std::deque<RecvRequest> queue_;
+  bool stop_ = false;
+  std::thread thread_;
+};
+
+// Keyed by chat_ctrl, accessed only on the JS main thread.
+using Receivers = std::unordered_map<uintptr_t, std::shared_ptr<Receiver>>;
+
+std::shared_ptr<Receiver> TakeReceiver(Receivers& receivers, chat_ctrl ctrl) {
+  auto it = receivers.find(reinterpret_cast<uintptr_t>(ctrl));
+  if (it == receivers.end()) {
+    return nullptr;
+  }
+  std::shared_ptr<Receiver> receiver = std::move(it->second);
+  receivers.erase(it);
+  return receiver;
+}
+
 // Common result processors
 ResultAsyncWorker::ResultProcessor MigrateResultProcessor() {
   return [](ResultAsyncWorker* worker, Napi::Env env) {
@@ -215,6 +386,39 @@ Value ChatMigrateInit(const CallbackInfo& args) {
   return promise;
 }
 
+Value ChatMigrateInitQueue(const CallbackInfo& args) {
+  Env env = args.Env();
+  if (args.Length() < 4 || !args[0].IsString() || !args[1].IsString() || !args[2].IsString() || !args[3].IsNumber()) {
+    TypeError::New(env, "Expected three string arguments and number").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  std::string path = args[0].As<String>().Utf8Value();
+  std::string key = args[1].As<String>().Utf8Value();
+  std::string confirm = args[2].As<String>().Utf8Value();
+  Number queue_size_arg = args[3].As<Number>();
+  int queue_size = queue_size_arg.Int32Value();
+  if (static_cast<double>(queue_size) != queue_size_arg.DoubleValue()) {
+    RangeError::New(env, "Expected 32-bit integer queue size").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  Function cb;
+  Promise promise = CreatePromiseAndCallback(env, cb);
+
+  auto execute_fn = [path, key, confirm, queue_size](ResultAsyncWorker* worker) {
+    chat_ctrl ctrl = nullptr;
+    char* c_res = chat_migrate_init_queue(path.c_str(), key.c_str(), confirm.c_str(), queue_size, &ctrl);
+    worker->SetCtrl(reinterpret_cast<uintptr_t>(ctrl));
+    HandleCResult(worker, c_res, "chat_migrate_init_queue");
+  };
+
+  ResultAsyncWorker* worker = new ResultAsyncWorker(cb, std::move(execute_fn), MigrateResultProcessor());
+  worker->Queue();
+
+  return promise;
+}
+
 Value ChatCloseStore(const CallbackInfo& args) {
   Env env = args.Env();
   if (args.Length() < 1 || !args[0].IsBigInt()) {
@@ -223,11 +427,15 @@ Value ChatCloseStore(const CallbackInfo& args) {
   }
 
   chat_ctrl ctrl = FromChatCtrlBigInt(args[0]);
+  std::shared_ptr<Receiver> receiver = TakeReceiver(*static_cast<Receivers*>(args.Data()), ctrl);
 
   Function cb;
   Promise promise = CreatePromiseAndCallback(env, cb);
 
-  auto execute_fn = [ctrl](ResultAsyncWorker* worker) {
+  auto execute_fn = [ctrl, receiver](ResultAsyncWorker* worker) {
+    if (receiver) {
+      receiver->Stop();
+    }
     char* c_res = chat_close_store(ctrl);
     HandleCResult(worker, c_res, "chat_close_store");
   };
@@ -271,44 +479,63 @@ Value ChatRecvMsgWait(const CallbackInfo& args) {
 
   chat_ctrl ctrl = FromChatCtrlBigInt(args[0]);
   int wait = static_cast<int>(args[1].As<Number>().Int32Value());
+  Receivers& receivers = *static_cast<Receivers*>(args.Data());
+
+  auto deferred = std::make_shared<Promise::Deferred>(Promise::Deferred::New(env));
+  auto it = receivers.find(reinterpret_cast<uintptr_t>(ctrl));
+  if (it == receivers.end()) {
+    std::shared_ptr<Receiver> receiver;
+    try {
+      receiver = Receiver::Start(env, ctrl);
+    } catch (const std::system_error& e) {
+      deferred->Reject(Error::New(env, e.what()).Value());
+      return deferred->Promise();
+    }
+    if (!receiver) {
+      return env.Undefined();
+    }
+    it = receivers.emplace(reinterpret_cast<uintptr_t>(ctrl), std::move(receiver)).first;
+  }
+  it->second->Enqueue(env, {wait, deferred});
 
-  Function cb;
-  Promise promise = CreatePromiseAndCallback(env, cb);
-
-  auto execute_fn = [ctrl, wait](ResultAsyncWorker* worker) {
-    char* c_res = chat_recv_msg_wait(ctrl, wait);
-    HandleCResult(worker, c_res, "chat_recv_msg_wait");
-  };
-
-  ResultAsyncWorker* worker = new ResultAsyncWorker(cb, std::move(execute_fn));
-  worker->Queue();
-
-  return promise;
+  return deferred->Promise();
 }
 
 Value ChatWriteFile(const CallbackInfo& args) {
   Env env = args.Env();
-  if (args.Length() < 3 || !args[0].IsBigInt() || !args[1].IsString() || !args[2].IsArrayBuffer()) {
-    TypeError::New(env, "Expected bigint (ctrl), string (path), ArrayBuffer").ThrowAsJavaScriptException();
+  if (args.Length() < 3 || !args[0].IsBigInt() || !args[1].IsString() || !(args[2].IsArrayBuffer() || args[2].IsTypedArray())) {
+    TypeError::New(env, "Expected bigint (ctrl), string (path), ArrayBuffer or Uint8Array").ThrowAsJavaScriptException();
     return env.Undefined();
   }
 
   chat_ctrl ctrl = FromChatCtrlBigInt(args[0]);
   std::string path = args[1].As<String>().Utf8Value();
-  ArrayBuffer ab = args[2].As<ArrayBuffer>();
-  char* data = static_cast<char*>(ab.Data());
-  size_t len = ab.ByteLength();
+  char* data;
+  size_t len;
+  if (args[2].IsArrayBuffer()) {
+    ArrayBuffer ab = args[2].As<ArrayBuffer>();
+    data = static_cast<char*>(ab.Data());
+    len = ab.ByteLength();
+  } else {
+    TypedArray view = args[2].As<TypedArray>();
+    data = static_cast<char*>(view.ArrayBuffer().Data()) + view.ByteOffset();
+    len = view.ByteLength();
+  }
+  if (len > static_cast<size_t>(INT_MAX)) {
+    RangeError::New(env, "Buffer is too large").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
 
   Function cb;
   Promise promise = CreatePromiseAndCallback(env, cb);
 
-  auto execute_fn = [ctrl, path, ab, data, len](ResultAsyncWorker* worker) {
-    (void)ab; // to keep ArrayBuffer alive
+  auto execute_fn = [ctrl, path, data, len](ResultAsyncWorker* worker) {
     char* c_res = chat_write_file(ctrl, path.c_str(), data, static_cast<int>(len));
     HandleCResult(worker, c_res, "chat_write_file");
   };
 
   ResultAsyncWorker* worker = new ResultAsyncWorker(cb, std::move(execute_fn));
+  worker->KeepAlive(args[2].As<Object>());
   worker->Queue();
 
   return promise;
@@ -410,10 +637,19 @@ Value ChatDecryptFile(const CallbackInfo& args) {
 
 Object Init(Env env, Object exports) {
   haskell_init();
+  auto* receivers = new Receivers();
+  // Stopping all receivers before joining any bounds teardown by the longest in-flight receive.
+  env.AddCleanupHook([receivers]() {
+    for (auto& entry : *receivers) {
+      entry.second->RequestStop();
+    }
+    delete receivers;
+  });
   exports.Set("chat_migrate_init", Function::New(env, ChatMigrateInit));
-  exports.Set("chat_close_store", Function::New(env, ChatCloseStore));
+  exports.Set("chat_migrate_init_queue", Function::New(env, ChatMigrateInitQueue));
+  exports.Set("chat_close_store", Function::New(env, ChatCloseStore, "chat_close_store", receivers));
   exports.Set("chat_send_cmd", Function::New(env, ChatSendCmd));
-  exports.Set("chat_recv_msg_wait", Function::New(env, ChatRecvMsgWait));
+  exports.Set("chat_recv_msg_wait", Function::New(env, ChatRecvMsgWait, "chat_recv_msg_wait", receivers));
   exports.Set("chat_write_file", Function::New(env, ChatWriteFile));
   exports.Set("chat_read_file", Function::New(env, ChatReadFile));
   exports.Set("chat_encrypt_file", Function::New(env, ChatEncryptFile));

package/cpp/simplex.h

@@ -11,11 +11,13 @@
 
 extern "C" void hs_init(int argc, char **argv[]);
 extern "C" void hs_init_with_rtsopts(int * argc, char **argv[]);
+extern "C" void hs_thread_done(void);
 
 typedef long* chat_ctrl;
 
 // the last parameter is used to return the pointer to chat controller
 extern "C" char *chat_migrate_init(const char *path, const char *key, const char *confirm, chat_ctrl *ctrl);
+extern "C" char *chat_migrate_init_queue(const char *path, const char *key, const char *confirm, const int queueSize, chat_ctrl *ctrl);
 extern "C" char *chat_close_store(chat_ctrl ctrl);
 extern "C" char *chat_reopen_store(chat_ctrl ctrl);
 extern "C" char *chat_send_cmd(chat_ctrl ctrl, const char *cmd);

package/dist/api.d.ts

@@ -37,7 +37,7 @@ export interface BotAddressSettings {
 export declare const defaultBotAddressSettings: BotAddressSettings;
 export type EventSubscriberFunc<K extends CEvt.Tag> = (event: ChatEvent & {
     type: K;
-}) => void | Promise<void>;
+}, chat: ChatApi) => void | Promise<void>;
 export type EventSubscribers = {
     [K in CEvt.Tag]?: EventSubscriberFunc<K>;
 };
@@ -76,23 +76,26 @@ export declare class ChatApi {
      * Initializes the ChatApi.
      * @param {DbConfig} db - Database configuration (sqlite or postgres).
      * @param {core.MigrationConfirmation} [confirm=core.MigrationConfirmation.YesUp] - Migration confirmation mode.
+     * @param {number} [queueSize] - Size of internal queues, the core default is used when omitted.
      */
-    static init(db: DbConfig, confirm?: core.MigrationConfirmation): Promise<ChatApi>;
+    static init(db: DbConfig, confirm?: core.MigrationConfirmation, queueSize?: number): Promise<ChatApi>;
     /**
      * Start chat controller. Must be called with the existing user profile.
      */
     startChat(): Promise<void>;
     /**
      * Stop chat controller.
-     * Must be called before closing the database.
+     * `close` calls it before closing the database.
      * Usually doesn't need to be called in chat bots.
      */
     stopChat(): Promise<void>;
     /**
-     * Close chat database.
+     * Stop chat controller and close chat database.
+     * The database is not closed if stopping fails.
      * Usually doesn't need to be called in chat bots.
      */
     close(): Promise<void>;
+    private stopEventsLoop;
     private runEventsLoop;
     /**
      * Subscribe multiple event handlers at once.
@@ -225,7 +228,7 @@ export declare class ChatApi {
      * Add/remove message reaction.
      * Network usage: background.
      */
-    apiChatItemReaction(chatType: T.ChatType, chatId: number, chatItemId: number, add: boolean, reaction: T.MsgReaction): Promise<T.ChatItemDeletion[]>;
+    apiChatItemReaction(chatType: T.ChatType, chatId: number, chatItemId: number, add: boolean, reaction: T.MsgReaction): Promise<T.ACIReaction>;
     /**
      * Receive file.
      * Network usage: no.
@@ -321,7 +324,7 @@ export declare class ChatApi {
      * Connect via prepared SimpleX link. The link can be 1-time invitation link, contact address or group link
      * Network usage: interactive.
      */
-    apiConnect(userId: number, incognito: boolean, preparedLink?: T.CreatedConnLink): Promise<ConnReqType>;
+    apiConnect(userId: number, incognito: boolean, preparedLink: T.CreatedConnLink): Promise<ConnReqType>;
     /**
      * Connect via SimpleX link as string in the active user profile.
      * Network usage: interactive.

package/dist/api.js

@@ -52,48 +52,62 @@ class ChatApi {
      * Initializes the ChatApi.
      * @param {DbConfig} db - Database configuration (sqlite or postgres).
      * @param {core.MigrationConfirmation} [confirm=core.MigrationConfirmation.YesUp] - Migration confirmation mode.
+     * @param {number} [queueSize] - Size of internal queues, the core default is used when omitted.
      */
-    static async init(db, confirm = core.MigrationConfirmation.YesUp) {
+    static async init(db, confirm = core.MigrationConfirmation.YesUp, queueSize) {
         const [path, key] = dbConfigToMigrateArgs(db);
-        const ctrl = await core.chatMigrateInit(path, key, confirm);
+        const ctrl = await core.chatMigrateInit(path, key, confirm, queueSize);
         return new ChatApi(ctrl);
     }
     /**
      * Start chat controller. Must be called with the existing user profile.
      */
     async startChat() {
+        if (this.eventsLoop)
+            throw new Error("chat already started");
+        const ctrl = this.ctrl;
         this.receiveEvents = true;
         this.eventsLoop = this.runEventsLoop();
-        const r = await this.sendChatCmd(types_1.CC.StartChat.cmdString({ mainApp: true, enableSndFiles: true, serviceRequests: false }));
+        let r;
+        try {
+            r = await core.chatSendCmd(ctrl, types_1.CC.StartChat.cmdString({ mainApp: true, enableSndFiles: true, serviceRequests: false }));
+        }
+        catch (e) {
+            await this.stopEventsLoop();
+            throw e;
+        }
         if (r.type !== "chatStarted" && r.type !== "chatRunning") {
+            await this.stopEventsLoop();
             throw new ChatCommandError("error starting chat", r);
         }
     }
     /**
      * Stop chat controller.
-     * Must be called before closing the database.
+     * `close` calls it before closing the database.
      * Usually doesn't need to be called in chat bots.
      */
     async stopChat() {
         const r = await this.sendChatCmd("/_stop");
         if (r.type !== "chatStopped")
-            throw new ChatCommandError("error starting chat", r);
-        this.receiveEvents = false;
-        if (this.eventsLoop)
-            await this.eventsLoop;
-        this.eventsLoop = undefined;
+            throw new ChatCommandError("error stopping chat", r);
+        await this.stopEventsLoop();
     }
     /**
-     * Close chat database.
+     * Stop chat controller and close chat database.
+     * The database is not closed if stopping fails.
      * Usually doesn't need to be called in chat bots.
      */
     async close() {
+        // a running controller keeps using the database connections that closing frees
+        await this.stopChat();
+        await core.chatCloseStore(this.ctrl);
+        this.ctrl_ = undefined;
+    }
+    async stopEventsLoop() {
         this.receiveEvents = false;
         if (this.eventsLoop)
             await this.eventsLoop;
         this.eventsLoop = undefined;
-        await core.chatCloseStore(this.ctrl);
-        this.ctrl_ = undefined;
     }
     async runEventsLoop() {
         while (this.receiveEvents) {
@@ -105,7 +119,7 @@ class ChatApi {
                 if (subs) {
                     for (const { subscriber, once } of [...subs]) {
                         try {
-                            const p = subscriber(event);
+                            const p = subscriber(event, this);
                             if (p instanceof Promise)
                                 await p;
                         }
@@ -118,7 +132,7 @@ class ChatApi {
                 }
                 for (const r of [...this.receivers]) {
                     try {
-                        const p = r(event);
+                        const p = r(event, this);
                         if (p instanceof Promise)
                             await p;
                     }
@@ -270,7 +284,7 @@ class ChatApi {
     async sendChatCmd(cmd) {
         return await core.chatSendCmd(this.ctrl, cmd);
     }
-    async recvChatEvent(wait = 5000000) {
+    async recvChatEvent(wait = 500000) {
         return await core.chatRecvMsgWait(this.ctrl, wait);
     }
     /**
@@ -322,8 +336,10 @@ class ChatApi {
         switch (r.type) {
             case "userProfileUpdated":
                 return r.updateSummary;
+            case "userProfileNoChange":
+                return { updateSuccesses: 0, updateFailures: 0, changedContacts: [] };
             default:
-                throw new ChatCommandError("error loading user address", r);
+                throw new ChatCommandError("error setting profile address", r);
         }
     }
     /**
@@ -389,7 +405,7 @@ class ChatApi {
             liveMessage,
             updatedMessage: { msgContent, mentions: {} },
         }));
-        if (r.type === "chatItemUpdated")
+        if (r.type === "chatItemUpdated" || r.type === "chatItemNotChanged")
             return r.chatItem.chatItem;
         throw new ChatCommandError("error updating chat item", r);
     }
@@ -419,8 +435,8 @@ class ChatApi {
      */
     async apiChatItemReaction(chatType, chatId, chatItemId, add, reaction) {
         const r = await this.sendChatCmd(types_1.CC.APIChatItemReaction.cmdString({ chatRef: { chatType, chatId }, chatItemId, add, reaction }));
-        if (r.type === "chatItemsDeleted")
-            return r.chatItemDeletions;
+        if (r.type === "chatItemReaction")
+            return r.reaction;
         throw new ChatCommandError("error setting item reaction", r);
     }
     /**
@@ -431,6 +447,8 @@ class ChatApi {
         const r = await this.sendChatCmd(types_1.CC.ReceiveFile.cmdString({ fileId, userApprovedRelays: true }));
         if (r.type === "rcvFileAccepted")
             return r.chatItem;
+        if (r.type === "rcvFileAcceptedSndCancelled")
+            throw new ChatCommandError("file cancelled by sender", r);
         throw new ChatCommandError("error receiving file", r);
     }
     /**