@pmate/chat-sdk 0.12.0-next.0 → 0.12.0-next.10

package/lib/runtime/messageReaders.js

@@ -0,0 +1,124 @@
+import { IndexedDbResponseCache } from "./responseCache.js";
+import { messageScopeKey } from "./messageStore.js";
+export class MessageReadersError extends Error {
+    status;
+    forbidden;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.forbidden = status === 401 || status === 403;
+    }
+}
+/** Authenticated detail reads; concurrent identical requests share one transport call. */
+export class MessageReadersClient {
+    options;
+    pending = new Map();
+    lifetime = new AbortController();
+    cache;
+    revoked = false;
+    generation = 0;
+    constructor(options) {
+        this.options = { ...options };
+        if (options.scope) {
+            if (options.scope.appId !== options.appId || options.scope.profileId !== options.profileId)
+                throw new Error("MESSAGE_READERS_SCOPE_MISMATCH");
+            this.cache = new IndexedDbResponseCache(messageScopeKey(options.scope));
+        }
+    }
+    getReaders(query, signal) {
+        if (this.lifetime.signal.aborted)
+            return Promise.reject(new Error("MESSAGE_READERS_CLOSED"));
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+        const input = { ...query, limit: query.limit ?? 50 };
+        if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 100 || (input.revision !== undefined && (!Number.isSafeInteger(input.revision) || input.revision < 0)))
+            return Promise.reject(new Error("INVALID_MESSAGE_READERS_QUERY"));
+        const key = JSON.stringify([input.threadId, input.messageId, input.afterProfileId, input.revision, input.limit]);
+        let task = this.pending.get(key);
+        if (!task) {
+            task = this.cachedRequest(input, key).finally(() => { if (this.pending.get(key) === task)
+                this.pending.delete(key); });
+            this.pending.set(key, task);
+        }
+        if (!signal)
+            return task;
+        // Cancelling one view must not cancel another view's shared request.
+        return new Promise((resolve, reject) => {
+            const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason); };
+            signal.addEventListener("abort", abort, { once: true });
+            task.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+        });
+    }
+    async cachedRequest(input, key) {
+        // Keep only the standard SDK window. Arbitrary page sizes must not multiply
+        // durable cache entries. Revision is part of the key, so changed counts do
+        // not reuse a page from a previous membership/read projection.
+        const cache = input.limit === 50 ? this.cache : undefined;
+        if (!cache)
+            return this.request(input);
+        const stored = await cache.read(key).catch(error => { this.options.onError?.(error); return undefined; });
+        if (this.lifetime.signal.aborted)
+            throw new Error("MESSAGE_READERS_CLOSED");
+        const generation = this.generation;
+        const cached = this.revoked ? undefined : stored?.cached;
+        if (cached && (Date.now() - cached.time < 5000 || (typeof navigator !== "undefined" && navigator.onLine === false)))
+            return structuredClone(cached.value);
+        let value;
+        try {
+            value = await this.request(input);
+        }
+        catch (error) {
+            if (error instanceof MessageReadersError && error.forbidden) {
+                this.revoked = true;
+                this.generation++;
+                await this.cache?.invalidate().catch(failure => this.options.onError?.(failure));
+                throw error;
+            }
+            if (cached && !this.revoked && generation === this.generation && !this.lifetime.signal.aborted && (error instanceof TypeError || (error instanceof MessageReadersError && error.status >= 500)))
+                return structuredClone(cached.value);
+            throw error;
+        }
+        if (generation !== this.generation)
+            throw new Error("MESSAGE_READERS_INVALIDATED");
+        this.revoked = false;
+        if (value.resetRequired)
+            await cache?.invalidate().catch(error => this.options.onError?.(error));
+        else if (stored)
+            await cache?.write(key, value, stored.epoch).catch(error => { if (String(error).includes("RESPONSE_CACHE_INVALIDATED"))
+                throw error; this.options.onError?.(error); });
+        if (this.lifetime.signal.aborted)
+            throw new Error("MESSAGE_READERS_CLOSED");
+        return value;
+    }
+    async request(input) {
+        const { token, fetch: fetcher, hubHttpUrl, appId, profileId } = this.options;
+        const controller = new AbortController();
+        const cancel = () => controller.abort(this.lifetime.signal.reason);
+        this.lifetime.signal.addEventListener("abort", cancel, { once: true });
+        const timeout = setTimeout(() => controller.abort(), 8000);
+        try {
+            const response = await (fetcher ?? fetch)(`${hubHttpUrl.replace(/^ws/, "http").replace(/\/+$/, "")}/api/social/reading/readers`, {
+                method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/json" }, body: JSON.stringify({ ...input, appId, profileId }),
+                signal: controller.signal, redirect: "error", cache: "no-store",
+            });
+            if (!response.ok)
+                throw new MessageReadersError(response.status, `MESSAGE_READERS_HTTP_${response.status}`);
+            const envelope = await response.json(), data = envelope.data;
+            if (envelope.success !== true || data?.appId !== appId || data.threadId !== input.threadId || data.messageId !== input.messageId
+                || !Number.isSafeInteger(data.revision) || data.revision < 0 || !Number.isSafeInteger(data.total) || data.total < 0
+                || !Array.isArray(data.profileIds) || data.profileIds.length > input.limit || data.profileIds.length > data.total
+                || data.profileIds.some((id, i, ids) => typeof id !== "string" || !id || id.length > 512 || id === profileId || (i > 0 && id <= ids[i - 1]) || (input.afterProfileId && !data.resetRequired && id <= input.afterProfileId))
+                || typeof data.resetRequired !== "boolean" || (data.nextAfter !== null && (typeof data.nextAfter !== "string" || data.nextAfter !== data.profileIds.at(-1)))
+                || (!data.resetRequired && input.revision !== undefined && data.revision !== input.revision))
+                throw new Error("INVALID_MESSAGE_READERS_RESPONSE");
+            if (this.lifetime.signal.aborted)
+                throw new Error("MESSAGE_READERS_CLOSED");
+            return data;
+        }
+        finally {
+            clearTimeout(timeout);
+            this.lifetime.signal.removeEventListener("abort", cancel);
+        }
+    }
+    close() { this.lifetime.abort(); this.pending.clear(); return this.cache?.close().catch(error => this.options.onError?.(error)) ?? Promise.resolve(); }
+}

package/lib/runtime/messageStore.d.ts

@@ -15,6 +15,9 @@ export type MessageCoverage = {
     checkpoint?: string;
     complete: boolean;
     nextBefore?: string | null;
+    syncedAt?: number;
+    resetVersion?: number;
+    revoked?: boolean;
 };
 type CoverageRow = MessageCoverage & {
     scope: string;
@@ -33,6 +36,7 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
         indexedDB?: IDBFactory;
         name?: string;
     });
+    get namespace(): string;
     read(thread: string, limit?: number, before?: {
         timestamp: number;
         id: string;
@@ -41,7 +45,13 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
         hasEarlier: boolean;
         coverage: CoverageRow | undefined;
     }>;
-    commit(thread: string, messages: T[], coverage?: MessageCoverage): Promise<number>;
+    commit(thread: string, messages: T[], coverage?: MessageCoverage, guard?: {
+        version: number;
+        authoritative?: boolean;
+    }): Promise<number>;
+    windows(): Promise<CoverageRow[]>;
+    /** A durable epoch prevents another tab's pre-reset request from restoring rows. */
+    resetThread(thread: string, revoked?: boolean): Promise<number>;
     removeThread(thread: string): Promise<void>;
     clear(): Promise<void>;
     close(): void;

package/lib/runtime/messageStore.js

@@ -17,6 +17,7 @@ export class IndexedDbMessageStore {
         this.coverage = this.db.table("coverage");
         this.db.on("versionchange", () => { this.db.close({ disableAutoOpen: false }); return false; });
     }
+    get namespace() { return this.db.name; }
     async read(thread, limit = 100, before) {
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
             throw new Error("INVALID_MESSAGE_LIMIT");
@@ -26,13 +27,18 @@ export class IndexedDbMessageStore {
             return { messages: records.slice(0, limit).reverse().map(row => row.value), hasEarlier: records.length > limit, coverage: await this.coverage.get([this.key, thread]) };
         });
     }
-    async commit(thread, messages, coverage) {
+    async commit(thread, messages, coverage, guard) {
         for (const message of messages)
             if (message.threadId !== thread || !message.id || !Number.isFinite(message.timestamp))
                 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.coverage, async () => {
+            const current = await this.coverage.get([this.key, thread]);
+            if (guard && (current?.resetVersion ?? 0) !== guard.version)
+                throw new Error("MESSAGE_PROJECTION_CHANGED");
+            if (guard && current?.revoked && !guard.authoritative)
+                throw new Error("MESSAGE_ACCESS_REVOKED");
             const ids = [...new Set(messages.map(message => message.id))];
             const previous = await this.rows.bulkGet(ids.map(id => [this.key, thread, id]));
             const latest = new Map(previous.flatMap(row => row ? [[row.id, row.value]] : []));
@@ -48,13 +54,26 @@ export class IndexedDbMessageStore {
             if (changed.size)
                 await this.rows.bulkPut([...changed.values()]);
             if (coverage) {
-                const old = await this.coverage.get([this.key, thread]), next = { ...coverage, scope: this.key, thread };
+                const old = await this.coverage.get([this.key, thread]), next = { ...old, ...coverage, scope: this.key, thread };
                 if (JSON.stringify(old) !== JSON.stringify(next))
                     await this.coverage.put(next);
             }
             return changed.size;
         });
     }
+    async windows() {
+        return this.coverage.where("scope").equals(this.key).toArray();
+    }
+    /** A durable epoch prevents another tab's pre-reset request from restoring rows. */
+    async resetThread(thread, revoked = false) {
+        return this.db.transaction("rw", this.rows, this.coverage, async () => {
+            const old = await this.coverage.get([this.key, thread]);
+            const resetVersion = (old?.resetVersion ?? 0) + 1;
+            await this.rows.where("[scope+thread]").equals([this.key, thread]).delete();
+            await this.coverage.put({ scope: this.key, thread, complete: false, resetVersion, revoked });
+            return resetVersion;
+        });
+    }
     async removeThread(thread) {
         await this.db.transaction("rw", this.rows, this.coverage, async () => {
             await this.rows.where("[scope+thread]").equals([this.key, thread]).delete();

package/lib/runtime/readCounts.d.ts

@@ -1,3 +1,4 @@
+import { type MessageScope } from "./messageStore.js";
 export type ReadCountsResult = {
     appId: string;
     threadId: string;
@@ -11,6 +12,7 @@ export type ReadCountsOptions = {
     clientInstanceId: string;
     hubHttpUrl: string;
     fetch?: typeof fetch;
+    scope?: MessageScope;
     onChange: (value: ReadCountsResult) => void;
     onError?: (error: unknown) => void;
 };
@@ -25,13 +27,22 @@ export declare class ReadCountsClient {
     private generation;
     private retries;
     private closed;
+    private closing?;
     private revision;
     private running;
     private dirty;
     private subscribed;
     private subscriptionDenied;
     private subscriptionPending?;
+    private cache?;
+    private lastResult?;
+    private publish;
+    private revoked;
+    private accessVersion;
+    private requestedRevision;
+    private force;
     constructor(options: ReadCountsOptions);
+    private denyCache;
     private post;
     private subscription;
     private renew;
@@ -40,5 +51,5 @@ export declare class ReadCountsClient {
     reconnect(): void;
     private schedule;
     private refresh;
-    close(): void;
+    close(): Promise<void>;
 }

package/lib/runtime/readCounts.js

@@ -1,3 +1,5 @@
+import { IndexedDbResponseCache } from "./responseCache.js";
+import { messageScopeKey } from "./messageStore.js";
 let subscriptionSequence = 0;
 function nextSubscriptionSequence() { subscriptionSequence = Math.max(Date.now() * 1000, subscriptionSequence + 1); return subscriptionSequence; }
 /** One active conversation; fixed event window, bounded batches, no count polling. */
@@ -11,14 +13,38 @@ export class ReadCountsClient {
     generation = 0;
     retries = 0;
     closed = false;
+    closing;
     revision = -1;
     running = false;
     dirty = false;
     subscribed = false;
     subscriptionDenied = false;
     subscriptionPending;
+    cache;
+    lastResult;
+    publish(value) {
+        if (JSON.stringify(value) === JSON.stringify(this.lastResult))
+            return;
+        this.lastResult = value;
+        this.options.onChange(value);
+    }
+    revoked = false;
+    accessVersion = 0;
+    requestedRevision = -1;
+    force = false;
     constructor(options) {
         this.options = options;
+        if (options.scope) {
+            if (options.scope.appId !== options.appId || options.scope.profileId !== options.profileId)
+                throw new Error("READ_COUNTS_SCOPE_MISMATCH");
+            this.cache = new IndexedDbResponseCache(messageScopeKey(options.scope));
+        }
+    }
+    denyCache() {
+        this.revoked = true;
+        this.accessVersion++;
+        this.lastResult = undefined;
+        void this.cache?.invalidate().catch(error => this.options.onError?.(error));
     }
     async post(path, body, signal) {
         const response = await (this.options.fetch ?? fetch)(`${this.options.hubHttpUrl.replace(/\/$/, "")}${path}`, { method: "POST", headers: { authorization: `Bearer ${this.options.token}`, "content-type": "application/json" }, body: JSON.stringify(body), signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(8000)]) : AbortSignal.timeout(8000), redirect: "error" });
@@ -33,7 +59,7 @@ export class ReadCountsClient {
         return this.post("/api/social/reading/subscription", { appId: this.options.appId, profileId: this.options.profileId, threadId, clientInstanceId: this.options.clientInstanceId, sequence: nextSubscriptionSequence(), release });
     }
     renew() {
-        if (!this.thread || this.closed || this.subscriptionDenied)
+        if (!this.thread || this.closed || this.subscriptionDenied || (typeof navigator !== "undefined" && navigator.onLine === false))
             return;
         const threadId = this.thread, generation = this.generation;
         if (this.subscriptionPending?.generation === generation)
@@ -56,6 +82,7 @@ export class ReadCountsClient {
             this.subscribed = false;
             if (/READ_COUNTS_HTTP_(401|403)/.test(String(error))) {
                 this.subscriptionDenied = true;
+                this.denyCache();
                 clearInterval(this.heartbeat);
                 this.heartbeat = undefined;
             }
@@ -83,9 +110,12 @@ export class ReadCountsClient {
         clearTimeout(this.timer);
         clearInterval(this.heartbeat);
         this.timer = undefined;
+        this.lastResult = undefined;
         this.thread = threadId;
         this.ids = ids;
         this.revision = -1;
+        this.requestedRevision = -1;
+        this.force = false;
         this.dirty = false;
         this.retries = 0;
         this.subscribed = false;
@@ -104,11 +134,13 @@ export class ReadCountsClient {
             throw new Error("INVALID_READ_COUNTS_EVENT");
         if (threadId !== this.thread || revision <= this.revision || this.closed)
             return;
+        this.requestedRevision = Math.max(this.requestedRevision, revision);
         this.schedule(3000);
     }
     reconnect() {
         if (!this.thread || this.closed)
             return;
+        this.force = true;
         this.subscribed = false;
         this.subscriptionDenied = false;
         this.renew();
@@ -137,20 +169,44 @@ export class ReadCountsClient {
         let retryDelay;
         const controller = new AbortController();
         this.controller = controller;
+        const accessVersion = this.accessVersion, force = this.force;
+        this.force = false;
+        const key = JSON.stringify(["counts", threadId, [...ids].sort()]);
         try {
+            const stored = this.cache ? await this.cache.read(key).catch(error => { this.options.onError?.(error); return undefined; }) : undefined;
+            if (generation !== this.generation || this.closed || accessVersion !== this.accessVersion)
+                return;
+            const cached = this.revoked || (stored?.cached && stored.cached.value.revision < this.revision) ? undefined : stored?.cached;
+            if (cached) {
+                this.revision = cached.value.revision;
+                this.publish(cached.value);
+                const offline = typeof navigator !== "undefined" && navigator.onLine === false;
+                if (offline || (!force && this.requestedRevision <= this.revision && Date.now() - cached.time < 5000))
+                    return;
+            }
             const value = await this.post("/api/social/reading/counts", { appId: this.options.appId, profileId: this.options.profileId, threadId, messageIds: ids }, controller.signal);
-            if (generation !== this.generation || this.closed)
+            if (generation !== this.generation || this.closed || accessVersion !== this.accessVersion)
                 return;
             if (value?.appId !== this.options.appId || value.threadId !== threadId || !Number.isSafeInteger(value.revision) || value.revision < 0 || !value.counts || typeof value.counts !== "object" || ids.some(id => !Number.isSafeInteger(value.counts[id]) || value.counts[id] < 0) || Object.keys(value.counts).some(id => !ids.includes(id)))
                 throw new Error("INVALID_READ_COUNTS_RESULT");
+            if (value.revision < this.revision)
+                return;
             this.retries = 0;
+            this.revoked = false;
+            if (stored)
+                await this.cache?.write(key, value, stored.epoch).catch(error => { if (String(error).includes("RESPONSE_CACHE_INVALIDATED"))
+                    throw error; this.options.onError?.(error); });
+            if (generation !== this.generation || this.closed || accessVersion !== this.accessVersion)
+                return;
             this.revision = value.revision;
-            this.options.onChange(value);
+            this.publish(value);
             if (!this.subscribed)
                 this.renew();
         }
         catch (error) {
             if (!controller.signal.aborted && generation === this.generation && !this.closed) {
+                if (/READ_COUNTS_HTTP_(401|403)/.test(String(error)))
+                    this.denyCache();
                 this.options.onError?.(error);
                 if (!/READ_COUNTS_HTTP_4\d\d|INVALID_READ_COUNTS/.test(String(error)) && this.retries < 3) {
                     retryDelay = 1000 * 2 ** this.retries++;
@@ -167,8 +223,8 @@ export class ReadCountsClient {
         }
     }
     close() {
-        if (this.closed)
-            return;
+        if (this.closing)
+            return this.closing;
         const old = this.thread;
         this.closed = true;
         this.generation++;
@@ -178,5 +234,6 @@ export class ReadCountsClient {
         if (old)
             void this.subscription(old, true).catch(() => { });
         this.thread = undefined;
+        return this.closing = this.cache?.close().catch(error => this.options.onError?.(error)) ?? Promise.resolve();
     }
 }

package/lib/runtime/readIndex.d.ts

@@ -84,11 +84,13 @@ export interface ReadIndexPersistence {
 }
 /** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
 export declare class IndexedDbReadIndex implements ReadIndexPersistence {
+    private storageScope?;
     private database;
     private profiles;
     private closed;
-    constructor(factory?: IDBFactory, name?: string);
+    constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined);
     private transaction;
+    private key;
     load(appId: string, profileId: string): Promise<ReadIndexState | undefined>;
     update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
     close(): Promise<void>;

package/lib/runtime/readIndex.js

@@ -102,8 +102,9 @@ function resolveObservedReads(current) {
         }
         if (message.recalled || message.from === next.profileId || !message.recipients.includes(next.profileId))
             continue;
+        // Visibility may include voice rows; incompatible observations never acknowledge them.
         if (message.readPolicy !== intent.readPolicy)
-            throw new Error("READ_POLICY_MISMATCH");
+            continue;
         next = intent.readPolicy === "explicit" ? recordExplicitRead(next, intent.threadId, intent.messageId, intent.operationId)
             : recordVisibleRead(next, intent.threadId, intent.messageId, intent.operationId);
     }
@@ -165,10 +166,12 @@ export function unreadInThread(state, threadId) {
 }
 /** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
 export class IndexedDbReadIndex {
+    storageScope;
     database;
     profiles;
     closed = false;
-    constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index") {
+    constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index", storageScope) {
+        this.storageScope = storageScope;
         if (!factory)
             throw new Error("READ_STORAGE_UNAVAILABLE");
         this.database = new Dexie(name, { indexedDB: factory, IDBKeyRange: globalThis.IDBKeyRange });
@@ -201,17 +204,18 @@ export class IndexedDbReadIndex {
         }
         throw new Error("READ_STORAGE_UNAVAILABLE");
     }
+    key(appId, profileId) { return this.storageScope === undefined ? [appId, profileId] : [appId, profileId, this.storageScope]; }
     async load(appId, profileId) {
-        return this.transaction("r", () => this.profiles.get([appId, profileId]));
+        return this.transaction("r", () => this.profiles.get(this.key(appId, profileId)));
     }
     async update(appId, profileId, transform) {
         return this.transaction("rw", async () => {
-            const previous = await this.profiles.get([appId, profileId]);
+            const previous = await this.profiles.get(this.key(appId, profileId));
             const next = transform(previous ?? createReadIndex(appId, profileId));
             if (next.appId !== appId || next.profileId !== profileId || next.schemaVersion !== 1)
                 throw new Error("READ_IDENTITY_MISMATCH");
             if (JSON.stringify(next) !== JSON.stringify(previous))
-                await this.profiles.put(next, [appId, profileId]);
+                await this.profiles.put(next, this.key(appId, profileId));
             return next;
         });
     }

package/lib/runtime/readingClient.d.ts

@@ -5,6 +5,7 @@ export type ReadingClientOptions = {
     sessionToken: string;
     hubHttpUrl: string;
     persistence?: ReadIndexPersistence;
+    storageScope?: string;
     fetch?: typeof fetch;
     onError?: (error: unknown) => void;
     onRecovered?: () => void;

package/lib/runtime/readingClient.js

@@ -19,7 +19,7 @@ export class ReadingClient {
     generation = 0;
     constructor(options) {
         this.options = options;
-        const storage = options.persistence ?? (this.storage = new IndexedDbReadIndex());
+        const storage = options.persistence ?? (this.storage = new IndexedDbReadIndex(globalThis.indexedDB, "pmate-social-read-index", options.storageScope));
         this.persistence = new BatchedReadIndex(storage);
         this.tasks = new WindowedTasks(1000, error => this.failed(error));
         this.sync = new ReadSyncClient({ ...options, persistence: this.persistence, onChange: state => this.publish(state) });

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());
         }
     }
@@ -47,6 +56,7 @@ export class IndexedDbRecordCache {
             }
             await this.reload();
             this.initialized = true;
+            this.listeners.forEach(listener => listener());
         })().catch(error => { this.ready = undefined; throw error; });
         return this.ready;
     }
@@ -70,7 +80,8 @@ export class IndexedDbRecordCache {
         }
         if (changed) {
             this.snapshotValue = [...this.values.values()];
-            this.listeners.forEach(listener => listener());
+            if (this.initialized)
+                this.listeners.forEach(listener => listener());
         }
     }
     async upsert(incoming) {
@@ -81,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);
         });
@@ -124,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));
@@ -140,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;