@wirecat/cli-core 0.484.0 → 0.485.0

package/CHANGELOG.md

@@ -7,6 +7,16 @@ shape of this file.
 
 ## Unreleased
 
+## 0.485.0 — 30.10.2026
+
+### Fixed
+
+- **A store write no longer fails with "database is locked" while another process writes steadily.** SQLite's own wait
+  for the write lock sleeps up to 100 ms between tries, so a process that commits and begins again at once was never
+  seen free, and the waiter failed after the 5 s `busy_timeout` (`mail sync` against `memo sync`). A write now tries
+  for the lock every millisecond within the same `busy_timeout`. `saveAccount` takes the lock the same way instead
+  of as a bare statement.
+
 ## 0.484.0 — 30.10.2026
 
 ### Fixed

package/dist/store/accounts.js

@@ -11,8 +11,11 @@ export const accountAccountsOver = (context) => {
     const { accountPk, findAccountPk } = keysOver(context);
     return {
         saveAccount: async (key, { name }) => {
-            const pk = accountPk(key, name);
-            linkInbox(database, `${key.provider}:${key.account}`, pk);
+            const pk = write(database, () => {
+                const made = accountPk(key, name);
+                linkInbox(database, `${key.provider}:${key.account}`, made);
+                return made;
+            });
             linkOwnIdentities(context);
             return pk;
         },

package/dist/store/sqlite/transaction.js

@@ -1,6 +1,39 @@
 import { drainInvolvementQueue } from "./involvement-queue.js";
 import { drainMentions } from "./mention-drain.js";
 import { drainStems, stemmerCache } from "./stems.js";
+const SQLITE_BUSY = 5;
+const pause = new Int32Array(new SharedArrayBuffer(4));
+const isBusy = (error) => {
+    const { errcode, errno } = (error ?? {});
+    const code = errcode ?? errno;
+    return typeof code === "number" && (code & 0xff) === SQLITE_BUSY;
+};
+/**
+ * Takes the write lock, waiting as long as the connection's `busy_timeout`. SQLite's own wait sleeps 1 ms, then up to
+ * 100 ms between tries, so a process that commits and begins again at once is never seen free and the waiter fails
+ * with "database is locked" after the full timeout. Trying every millisecond sees the gap between two writes.
+ */
+const beginImmediate = (database) => {
+    const timeout = Number(database.prepare("PRAGMA busy_timeout").get()?.timeout ?? 0);
+    const deadline = Date.now() + timeout;
+    database.exec("PRAGMA busy_timeout = 0");
+    try {
+        for (;;) {
+            try {
+                database.exec("BEGIN IMMEDIATE");
+                return;
+            }
+            catch (error) {
+                if (!isBusy(error) || Date.now() >= deadline)
+                    throw error;
+                Atomics.wait(pause, 0, 0, 1);
+            }
+        }
+    }
+    finally {
+        database.exec(`PRAGMA busy_timeout = ${timeout}`);
+    }
+};
 const connections = new WeakMap();
 const connectionOf = (database) => {
     let connection = connections.get(database);
@@ -29,7 +62,10 @@ const transact = (database, body, drain, beforeCommit) => {
         throw new Error("a store write cannot run inside a read");
     const outer = connection.depth === 0;
     const name = `w${connection.depth + 1}`;
-    database.exec(outer ? "BEGIN IMMEDIATE" : `SAVEPOINT ${name}`);
+    if (outer)
+        beginImmediate(database);
+    else
+        database.exec(`SAVEPOINT ${name}`);
     connection.depth += 1;
     try {
         const result = body();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.484.0",
+  "version": "0.485.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",