@pmate/chat-sdk 0.12.0-next.71 → 0.12.0-next.73

package/lib/runtime/indexedDbRecovery.d.ts

@@ -0,0 +1,4 @@
+import type { Dexie } from "dexie";
+/** WebKit can invalidate an IDB connection while the application is suspended.
+ * Only replay a whole rejected transaction; never replay individual requests or clear data. */
+export declare function recoverableTransactions(db: Dexie, isClosed: () => boolean): Dexie["transaction"];

package/lib/runtime/indexedDbRecovery.js

@@ -0,0 +1,27 @@
+/** WebKit can invalidate an IDB connection while the application is suspended.
+ * Only replay a whole rejected transaction; never replay individual requests or clear data. */
+export function recoverableTransactions(db, isClosed) {
+    const transaction = (...args) => db.transaction.apply(db, args);
+    let recovery;
+    return (async (...args) => {
+        try {
+            return await transaction(...args);
+        }
+        catch (error) {
+            const failure = error;
+            if (isClosed() || !(failure.name === "UnknownError" || failure.inner?.name === "UnknownError") || !/without an in-progress transaction/i.test(failure.message ?? ""))
+                throw error;
+            if (!recovery) {
+                db.close({ disableAutoOpen: false });
+                const opening = db.open();
+                recovery = opening;
+                void opening.finally(() => { if (recovery === opening)
+                    recovery = undefined; }).catch(() => { });
+            }
+            await recovery;
+            if (isClosed())
+                throw error;
+            return transaction(...args);
+        }
+    });
+}

package/lib/runtime/messageStore.d.ts

@@ -35,12 +35,14 @@ export declare const messageScopeKey: (scope: MessageScope) => string;
 export declare class IndexedDbMessageStore<T extends StoredMessage> {
     private scope;
     private merge;
+    private transact;
     private db;
     private rows;
     private legacy;
     private coverage;
     private accessRows;
     private controls;
+    private closed;
     private key;
     constructor(scope: MessageScope, merge: (previous: T | undefined, incoming: T) => T, options?: {
         indexedDB?: IDBFactory;

package/lib/runtime/messageStore.js

@@ -1,3 +1,4 @@
+import { recoverableTransactions } from "./indexedDbRecovery.js";
 import { Dexie } from "dexie";
 import { quotedMessageIds, redactMessageQuotes } from "./messageQuotes.js";
 import { messageControls, controlKey, newerControl, applyMessageControls } from "./messageControls.js";
@@ -7,18 +8,21 @@ export const messageScopeKey = (scope) => JSON.stringify([scope.appId, scope.acc
 export class IndexedDbMessageStore {
     scope;
     merge;
+    transact;
     db;
     rows;
     legacy;
     coverage;
     accessRows;
     controls;
+    closed = false;
     key;
     constructor(scope, merge, options = {}) {
         this.scope = scope;
         this.merge = merge;
         this.key = messageScopeKey(scope);
         this.db = new Dexie(options.name ?? "pmate-chat-messages", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
+        this.transact = recoverableTransactions(this.db, () => this.closed);
         this.db.version(1).stores({ messages: "[scope+thread+id],[scope+thread+time+id],[scope+thread],scope", coverage: "[scope+thread],scope" });
         this.db.version(2).stores({ legacyMessages: "[scope+thread+id],[scope+thread+time+id],[scope+thread],scope" });
         this.db.version(3).stores({ scopeAccess: "scope" });
@@ -34,7 +38,7 @@ export class IndexedDbMessageStore {
     async read(thread, limit = 100, before) {
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
             throw new Error("INVALID_MESSAGE_LIMIT");
-        const page = await this.db.transaction("r", this.rows, this.coverage, this.accessRows, this.controls, async () => {
+        const page = await this.transact("r", this.rows, this.coverage, this.accessRows, this.controls, async () => {
             const access = await this.scopeAccess();
             if (access.revoked)
                 return { messages: [], hasEarlier: false, coverage: { complete: false, revoked: true, resetVersion: 0, scopeVersion: access.version } };
@@ -48,7 +52,7 @@ export class IndexedDbMessageStore {
     async readSelected(thread, ids) {
         if (ids.length > 100 || ids.some(id => !id || id.length > 256))
             throw new Error("INVALID_MESSAGE_SELECTION");
-        const page = await this.db.transaction("r", this.rows, this.coverage, this.accessRows, this.controls, async () => {
+        const page = await this.transact("r", this.rows, this.coverage, this.accessRows, this.controls, async () => {
             const access = await this.scopeAccess();
             const coverage = this.scopedCoverage(await this.coverage.get([this.key, thread]), access);
             if (access.revoked || coverage?.revoked || (coverage?.scopeVersion ?? 0) !== access.version)
@@ -70,7 +74,7 @@ export class IndexedDbMessageStore {
             if (bytes > 1_048_576)
                 throw new Error("MESSAGE_BATCH_TOO_LARGE");
         }
-        return this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+        return this.transact("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             const coverage = await this.coverage.get([this.key, thread]);
             if (access.revoked || coverage?.revoked)
@@ -109,7 +113,7 @@ export class IndexedDbMessageStore {
     async readFallback(thread, limit = 100, before) {
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
             throw new Error("INVALID_MESSAGE_LIMIT");
-        const page = await this.db.transaction("r", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+        const page = await this.transact("r", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             const coverage = access.revoked ? { complete: false, revoked: true, resetVersion: 0, scopeVersion: access.version } : this.scopedCoverage(await this.coverage.get([this.key, thread]), access);
             if (coverage?.revoked)
@@ -127,7 +131,7 @@ export class IndexedDbMessageStore {
                 throw new Error("MESSAGE_SCOPE_MISMATCH");
         if (messages.length > 1000)
             throw new Error("MESSAGE_BATCH_TOO_LARGE");
-        return this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+        return this.transact("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             if ((guard?.scopeVersion ?? 0) !== access.version)
                 throw new Error("MESSAGE_SCOPE_CHANGED");
@@ -207,7 +211,7 @@ export class IndexedDbMessageStore {
         // v3 caches migrate only source proofs from already-read pages, with no body
         // rewrite. Steady reads remain a single read-only IndexedDB transaction.
         if (pendingControls?.length)
-            await this.db.transaction("rw", this.controls, this.coverage, this.accessRows, async () => {
+            await this.transact("rw", this.controls, this.coverage, this.accessRows, async () => {
                 const access = await this.scopeAccess(), current = await this.coverage.get([this.key, thread]);
                 if (access.revoked || access.version !== (page.coverage?.scopeVersion ?? 0))
                     throw new Error("MESSAGE_SCOPE_CHANGED");
@@ -218,21 +222,22 @@ export class IndexedDbMessageStore {
         return result;
     }
     async windows() {
-        return this.db.transaction("r", this.coverage, this.accessRows, async () => {
+        return this.transact("r", this.coverage, this.accessRows, async () => {
             if ((await this.scopeAccess()).revoked)
                 return [];
             return this.coverage.where("scope").equals(this.key).toArray();
         });
     }
     async scopeAccess() {
-        const access = (await this.accessRows.get(this.key)) ?? { scope: this.key, version: 0, revoked: false };
+        const read = () => this.accessRows.get(this.key);
+        const access = (await (Dexie.currentTransaction?.db === this.db ? read() : this.transact("r", this.accessRows, read))) ?? { scope: this.key, version: 0, revoked: false };
         if (!Number.isSafeInteger(access.version) || access.version < 0 || typeof access.revoked !== "boolean")
             throw new Error("INVALID_MESSAGE_SCOPE_ACCESS");
         return access;
     }
     /** Only fresh, server-confirmed authorization may lift this durable tombstone. */
     async authorizeScope(expectedVersion) {
-        await this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+        await this.transact("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             if (access.version !== expectedVersion)
                 throw new Error("MESSAGE_SCOPE_CHANGED");
@@ -253,7 +258,7 @@ export class IndexedDbMessageStore {
     }
     /** Persist the denial first; failed cleanup must never make cached rows readable. */
     async revokeScope(expectedVersion) {
-        const access = await this.db.transaction("rw", this.accessRows, async () => {
+        const access = await this.transact("rw", this.accessRows, async () => {
             const old = await this.scopeAccess();
             if (expectedVersion !== undefined && old.version !== expectedVersion)
                 return old;
@@ -261,7 +266,7 @@ export class IndexedDbMessageStore {
             await this.accessRows.put(next);
             return next;
         });
-        await this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+        await this.transact("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const current = await this.scopeAccess();
             if (current.version === access.version && current.revoked)
                 await this.clearScopeRows();
@@ -270,7 +275,7 @@ export class IndexedDbMessageStore {
     }
     /** A durable epoch prevents another tab's pre-reset request from restoring rows. */
     async resetThread(thread, revoked = false, scopeVersion = 0) {
-        return this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+        return this.transact("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             if (access.version !== scopeVersion)
                 throw new Error("MESSAGE_SCOPE_CHANGED");
@@ -287,7 +292,7 @@ export class IndexedDbMessageStore {
         });
     }
     async removeThread(thread) {
-        await this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+        await this.transact("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             await this.controls.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.rows.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.legacy.where("[scope+thread]").equals([this.key, thread]).delete();
@@ -295,14 +300,14 @@ export class IndexedDbMessageStore {
         });
     }
     async clear() {
-        await this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+        await this.transact("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             await this.controls.where("scope").equals(this.key).delete();
             await this.legacy.where("scope").equals(this.key).delete();
             await this.rows.where("scope").equals(this.key).delete();
             await this.coverage.where("scope").equals(this.key).delete();
         });
     }
-    close() { this.db.close(); }
+    close() { this.closed = true; this.db.close(); }
 }
 /** Keep tombstones monotonic; applications can supply stricter domain reducers. */
 export function mergeStoredMessage(previous, incoming) {

package/lib/runtime/readCounts.js

@@ -238,7 +238,7 @@ export class ReadCountsClient {
                     this.heartbeat = undefined;
                 }
                 this.options.onError?.(error);
-                if (!isResponseCacheAuthorityError(error) && !/READ_COUNTS_HTTP_4\d\d|INVALID_READ_COUNTS/.test(String(error)) && this.retries < 3) {
+                if (!isResponseCacheAuthorityError(error) && (!/READ_COUNTS_HTTP_4\d\d|INVALID_READ_COUNTS/.test(String(error)) || /READ_COUNTS_HTTP_(409|429)/.test(String(error))) && this.retries < 3) {
                     retryDelay = 1000 * 2 ** this.retries++;
                     this.dirty = true;
                 }

package/lib/runtime/responseCache.d.ts

@@ -20,6 +20,7 @@ export type ResponseCacheOptions<T> = {
 export declare class IndexedDbResponseCache<T> {
     private scope;
     private options;
+    private transact;
     private db;
     private rows;
     private epochs;

package/lib/runtime/responseCache.js

@@ -1,3 +1,4 @@
+import { recoverableTransactions } from "./indexedDbRecovery.js";
 import { Dexie } from "dexie";
 import { WindowedTasks } from "./coalescer.js";
 export function isResponseCacheAuthorityError(error) {
@@ -18,6 +19,7 @@ export async function assertResponseCacheAccess(access, expectedVersion) {
 export class IndexedDbResponseCache {
     scope;
     options;
+    transact;
     db;
     rows;
     epochs;
@@ -34,6 +36,7 @@ export class IndexedDbResponseCache {
             if (!Number.isSafeInteger(value) || value < 1 || value > max)
                 throw new Error("INVALID_RESPONSE_CACHE_LIMIT");
         this.db = new Dexie(options.name ?? "pmate-chat-response-windows", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
+        this.transact = recoverableTransactions(this.db, () => this.closed);
         this.db.version(1).stores({ windows: "[scope+key],scope", epochs: "scope" });
         this.rows = this.db.table("windows");
         this.epochs = this.db.table("epochs");
@@ -45,14 +48,14 @@ export class IndexedDbResponseCache {
         if (!this.options.access)
             return;
         const access = await this.options.access();
-        const stored = await this.epochs.get(this.scope);
+        const stored = await this.transact("r", this.epochs, () => this.epochs.get(this.scope));
         const storedVersion = stored?.accessVersion ?? 0;
         if (access.version < storedVersion)
             throw new Error("RESPONSE_CACHE_SCOPE_CHANGED");
         // Ordinary cache reads must not take an IndexedDB write lock. Only an
         // authority transition needs the atomic epoch bump and range deletion.
         if (access.version > storedVersion)
-            await this.db.transaction("rw", this.rows, this.epochs, async () => {
+            await this.transact("rw", this.rows, this.epochs, async () => {
                 const current = await this.epochs.get(this.scope);
                 const version = current?.accessVersion ?? 0;
                 if (access.version < version)
@@ -69,7 +72,7 @@ export class IndexedDbResponseCache {
         if (this.closed)
             throw new Error("RESPONSE_CACHE_CLOSED");
         await this.synchronizeAccess();
-        return this.db.transaction("r", this.rows, this.epochs, async () => {
+        return this.transact("r", this.rows, this.epochs, async () => {
             const epoch = (await this.epochs.get(this.scope))?.epoch ?? 0;
             const row = await this.rows.get([this.scope, key]);
             return { epoch, cached: row?.epoch === epoch ? { value: row.value, time: row.time } : undefined };
@@ -82,7 +85,7 @@ export class IndexedDbResponseCache {
         if (keys.length > 128)
             throw new Error("RESPONSE_CACHE_SELECTION_TOO_LARGE");
         await this.synchronizeAccess();
-        return this.db.transaction("r", this.rows, this.epochs, async () => {
+        return this.transact("r", this.rows, this.epochs, async () => {
             const epoch = (await this.epochs.get(this.scope))?.epoch ?? 0, unique = [...new Set(keys)];
             const rows = await this.rows.bulkGet(unique.map(key => [this.scope, key]));
             return new Map(unique.map((key, index) => { const row = rows[index]; return [key, { epoch, cached: row?.epoch === epoch ? { value: row.value, time: row.time } : undefined }]; }));
@@ -109,7 +112,7 @@ export class IndexedDbResponseCache {
             return Promise.reject(new Error("RESPONSE_CACHE_CLOSED"));
         if (!Number.isSafeInteger(version) || version < 1)
             return Promise.reject(new Error("INVALID_RESPONSE_SCOPE_VERSION"));
-        const task = this.db.transaction("rw", this.rows, this.epochs, async () => {
+        const task = this.transact("rw", this.rows, this.epochs, async () => {
             const current = await this.epochs.get(this.scope);
             if ((current?.accessVersion ?? 0) >= version)
                 return;
@@ -123,7 +126,7 @@ export class IndexedDbResponseCache {
         if (this.closed)
             return Promise.reject(new Error("RESPONSE_CACHE_CLOSED"));
         const task = (async () => {
-            await this.db.transaction("rw", this.rows, this.epochs, async () => {
+            await this.transact("rw", this.rows, this.epochs, async () => {
                 const current = await this.epochs.get(this.scope);
                 const epoch = (current?.epoch ?? 0) + 1;
                 await this.epochs.put({ scope: this.scope, epoch, accessVersion: current?.accessVersion });
@@ -150,7 +153,7 @@ export class IndexedDbResponseCache {
                 const batch = this.pending.slice(0, this.options.batchRecords ?? 128);
                 try {
                     await this.synchronizeAccess();
-                    const outcome = await this.db.transaction("rw", this.rows, this.epochs, async () => {
+                    const outcome = await this.transact("rw", this.rows, this.epochs, async () => {
                         const epoch = (await this.epochs.get(this.scope))?.epoch ?? 0;
                         const valid = batch.filter(write => write.row.epoch === epoch);
                         const conditional = valid.filter(write => write.expectedRevision !== undefined);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.71",
+  "version": "0.12.0-next.73",
   "description": "Local-first chat SDK, message subscriptions, reading state, and shared chat UI primitives",
   "type": "module",
   "main": "./lib/index.js",