@pmate/chat-sdk 0.12.0-next.6 → 0.12.0-next.7

package/README.md

@@ -201,6 +201,11 @@ legacy cleanup happens after durable migration. Normal reads use memory and writ
 are merged into bounded IndexedDB transactions. Cache errors must be surfaced by
 the host, and pending operations are not reported as saved before their promise
 resolves.
+Control-event batches are bounded by both 128 records and 1 MiB per transaction;
+the queue includes in-flight writes and is limited to 4096 records / 8 MiB.
+`transactionBytes` and `queueBytes` can lower these limits. Oversized operations
+fail before changing the memory snapshot. Repeating an in-flight write waits for
+that physical write, including its failure, rather than acknowledging it early.
 
 `DurableChatSender` saves the exact message created by `ChatClient.prepareChat`
 before transmitting it. `retry(hash)` uses `sendPrepared` with the original hash

package/lib/runtime/recordCache.d.ts

@@ -5,6 +5,8 @@ export type RecordCacheOptions<T> = {
     indexedDB?: IDBFactory;
     name?: string;
     onError?: (error: unknown) => void;
+    transactionBytes?: number;
+    queueBytes?: number;
 };
 /** In-memory control-event index backed by bounded asynchronous IndexedDB batches.
  * Legacy storage is read only during open; the hot path never uses localStorage. */
@@ -23,6 +25,11 @@ export declare class IndexedDbRecordCache<T> {
     private closing;
     private initialized;
     private running?;
+    private activeBytes;
+    private pendingBytes;
+    private activeRecords;
+    private transactionBytes;
+    private queueBytes;
     private channel?;
     private listeners;
     constructor(options: RecordCacheOptions<T>);
@@ -34,7 +41,9 @@ export declare class IndexedDbRecordCache<T> {
     subscribe(listener: () => void): () => void;
     private reload;
     upsert(incoming: T[]): Promise<void>;
+    private bytes;
     private write;
+    private writeBatch;
     flush(): Promise<void>;
     private runFlush;
     close(): Promise<void>;

package/lib/runtime/recordCache.js

@@ -17,17 +17,26 @@ export class IndexedDbRecordCache {
     closing = false;
     initialized = false;
     running;
+    activeBytes = 0;
+    pendingBytes = 0;
+    activeRecords = 0;
+    transactionBytes;
+    queueBytes;
     channel;
     listeners = new Set();
     constructor(options) {
         this.options = options;
+        this.transactionBytes = options.transactionBytes ?? 1_048_576;
+        this.queueBytes = options.queueBytes ?? 8_388_608;
+        if (!Number.isSafeInteger(this.transactionBytes) || this.transactionBytes < 1 || !Number.isSafeInteger(this.queueBytes) || this.queueBytes < this.transactionBytes)
+            throw new Error("INVALID_RECORD_CACHE_BYTE_LIMIT");
         this.db = new Dexie(options.name ?? "pmate-chat-records", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
         this.db.version(1).stores({ records: "[scope+id],scope", metadata: "scope" });
         this.records = this.db.table("records");
         this.metadata = this.db.table("metadata");
         this.tasks = new WindowedTasks(16, error => options.onError?.(error));
         if (typeof BroadcastChannel !== "undefined") {
-            this.channel = new BroadcastChannel(`pmate-chat-records:${options.scope}`);
+            this.channel = new BroadcastChannel(`pmate-chat-records:${options.scope}${this.db.name === "pmate-chat-records" ? "" : `:${this.db.name}`}`);
             this.channel.onmessage = () => this.tasks.schedule("reload", () => this.reload());
         }
     }
@@ -83,30 +92,70 @@ export class IndexedDbRecordCache {
         await this.ready;
         if (this.closed || this.closing)
             throw new Error("RECORD_CACHE_CLOSED");
-        if (incoming.length + this.pending.size > 4096)
+        if (incoming.length > 4096)
             throw new Error("RECORD_CACHE_BACKPRESSURE");
-        let changed = false;
+        // Plan and validate the whole operation before publishing any in-memory state.
+        const staged = new Map();
         for (const value of incoming) {
-            const key = this.options.key(value), old = this.values.get(key), next = this.options.merge(old, value);
+            const key = this.options.key(value), old = staged.get(key) ?? this.values.get(key);
+            const next = this.options.merge(old, value);
             if (JSON.stringify(old) === JSON.stringify(next))
                 continue;
+            if (this.bytes(next) > this.transactionBytes)
+                throw new Error("RECORD_CACHE_RECORD_TOO_LARGE");
+            staged.set(key, structuredClone(next));
+        }
+        let nextBytes = this.pendingBytes, nextRecords = this.pending.size;
+        for (const [key, value] of staged) {
+            const previous = this.pending.get(key);
+            nextBytes += this.bytes(value) - (previous === undefined ? 0 : this.bytes(previous));
+            if (!this.pending.has(key))
+                nextRecords++;
+        }
+        if (nextRecords + this.activeRecords > 4096 || nextBytes + this.activeBytes > this.queueBytes)
+            throw new Error("RECORD_CACHE_BACKPRESSURE");
+        let changed = false;
+        for (const [key, next] of staged) {
             this.values.set(key, next);
             this.pending.set(key, next);
             changed = true;
         }
+        this.pendingBytes = nextBytes;
         if (changed)
             this.snapshotValue = [...this.values.values()];
-        if (!changed && !this.pending.size)
+        if (!changed && !this.pending.size) {
+            await this.running;
             return;
+        }
         const committed = new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
         this.tasks.schedule("write", () => this.flush());
         return committed;
     }
+    bytes(value) { return new TextEncoder().encode(JSON.stringify({ scope: this.options.scope, id: this.options.key(value), value })).byteLength; }
     async write(values) {
+        let batch = [], bytes = 0;
+        for (const value of values) {
+            const size = this.bytes(value);
+            if (size > this.transactionBytes)
+                throw new Error("RECORD_CACHE_RECORD_TOO_LARGE");
+            if (batch.length && (batch.length === 128 || bytes + size > this.transactionBytes)) {
+                await this.writeBatch(batch);
+                batch = [];
+                bytes = 0;
+            }
+            batch.push(value);
+            bytes += size;
+        }
+        if (batch.length)
+            await this.writeBatch(batch);
+    }
+    async writeBatch(values) {
         await this.db.transaction("rw", this.records, async () => {
             const previous = await this.records.bulkGet(values.map(value => [this.options.scope, this.options.key(value)]));
             const records = values.map((value, index) => ({ scope: this.options.scope, id: this.options.key(value), value: this.options.merge(previous[index]?.value, value) }));
             const changed = records.filter((row, index) => JSON.stringify(previous[index]?.value) !== JSON.stringify(row.value));
+            if (changed.reduce((sum, row) => sum + this.bytes(row.value), 0) > this.transactionBytes)
+                throw new Error("RECORD_CACHE_MERGE_TOO_LARGE");
             if (changed.length)
                 await this.records.bulkPut(changed);
         });
@@ -126,8 +175,11 @@ export class IndexedDbRecordCache {
     async runFlush() {
         const values = [...this.pending.values()], waiters = this.waiters.splice(0);
         this.pending.clear();
+        this.pendingBytes = 0;
         if (!values.length)
             return;
+        this.activeBytes = values.reduce((sum, value) => sum + this.bytes(value), 0);
+        this.activeRecords = values.length;
         try {
             for (let offset = 0; offset < values.length; offset += 128)
                 await this.write(values.slice(offset, offset + 128));
@@ -142,9 +194,14 @@ export class IndexedDbRecordCache {
                 const key = this.options.key(value);
                 this.pending.set(key, this.options.merge(value, this.pending.get(key) ?? value));
             }
+            this.pendingBytes = [...this.pending.values()].reduce((sum, value) => sum + this.bytes(value), 0);
             waiters.forEach(waiter => waiter.reject(error));
             throw error;
         }
+        finally {
+            this.activeBytes = 0;
+            this.activeRecords = 0;
+        }
     }
     async close() {
         this.closing = true;

package/package.json

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