@pmate/chat-sdk 0.12.0-next.20 → 0.12.0-next.21

package/lib/runtime/responseCache.js

@@ -1,9 +1,23 @@
 import { Dexie } from "dexie";
 import { WindowedTasks } from "./coalescer.js";
+export function isResponseCacheAuthorityError(error) {
+    return /RESPONSE_CACHE_(ACCESS_REVOKED|SCOPE_CHANGED|INVALIDATED)/.test(String(error));
+}
+export async function assertResponseCacheAccess(access, expectedVersion) {
+    if (!access)
+        return undefined;
+    const current = await access();
+    if (!current.allowed)
+        throw new Error("RESPONSE_CACHE_ACCESS_REVOKED");
+    if (expectedVersion !== undefined && current.version !== expectedVersion)
+        throw new Error("RESPONSE_CACHE_SCOPE_CHANGED");
+    return current.version;
+}
 /** Small response windows, isolated by identity. Epochs fence late writes after
  * access withdrawal. No localStorage or synchronous writes on the read path. */
 export class IndexedDbResponseCache {
     scope;
+    options;
     db;
     rows;
     epochs;
@@ -15,14 +29,43 @@ export class IndexedDbResponseCache {
     closing;
     constructor(scope, options = {}) {
         this.scope = scope;
+        this.options = options;
         this.db = new Dexie(options.name ?? "pmate-chat-response-windows", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
         this.db.version(1).stores({ windows: "[scope+key],scope", epochs: "scope" });
         this.rows = this.db.table("windows");
         this.epochs = this.db.table("epochs");
     }
+    /** Resolve shared message-scope authority before opening our transaction.
+     * A newer authority version retires response windows exactly once; delayed
+     * callers can never roll the authority backwards or delete recovered data. */
+    async synchronizeAccess() {
+        if (!this.options.access)
+            return;
+        const access = await this.options.access();
+        const stored = await 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 () => {
+                const current = await this.epochs.get(this.scope);
+                const version = current?.accessVersion ?? 0;
+                if (access.version < version)
+                    throw new Error("RESPONSE_CACHE_SCOPE_CHANGED");
+                if (access.version > version) {
+                    await this.epochs.put({ scope: this.scope, epoch: (current?.epoch ?? 0) + 1, accessVersion: access.version });
+                    await this.rows.where("scope").equals(this.scope).delete();
+                }
+            });
+        if (!access.allowed)
+            throw new Error("RESPONSE_CACHE_ACCESS_REVOKED");
+    }
     async read(key) {
         if (this.closed)
             throw new Error("RESPONSE_CACHE_CLOSED");
+        await this.synchronizeAccess();
         return this.db.transaction("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]);
@@ -41,13 +84,31 @@ export class IndexedDbResponseCache {
         this.tasks.schedule("write", () => this.flush());
         return promise;
     }
+    /** Idempotent shared-scope retirement: an old cleanup cannot erase windows
+     * created after the same authority version was already recovered. */
+    retire(version) {
+        if (this.closed)
+            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 current = await this.epochs.get(this.scope);
+            if ((current?.accessVersion ?? 0) >= version)
+                return;
+            await this.epochs.put({ scope: this.scope, epoch: (current?.epoch ?? 0) + 1, accessVersion: version });
+            await this.rows.where("scope").equals(this.scope).delete();
+        });
+        this.invalidations.add(task);
+        return task.finally(() => this.invalidations.delete(task));
+    }
     invalidate() {
         if (this.closed)
             return Promise.reject(new Error("RESPONSE_CACHE_CLOSED"));
         const task = (async () => {
             await this.db.transaction("rw", this.rows, this.epochs, async () => {
-                const epoch = ((await this.epochs.get(this.scope))?.epoch ?? 0) + 1;
-                await this.epochs.put({ scope: this.scope, epoch });
+                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 });
                 await this.rows.where("scope").equals(this.scope).delete();
             });
         })();
@@ -66,6 +127,7 @@ export class IndexedDbResponseCache {
             return;
         const task = (async () => {
             try {
+                await this.synchronizeAccess();
                 const accepted = await this.db.transaction("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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.20",
+  "version": "0.12.0-next.21",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",