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

package/lib/runtime/outgoingContent.js

@@ -0,0 +1,106 @@
+import { dmThreadId, groupThreadId } from "./thread.js";
+const contentKeys = ["text", "image", "voice", "recall", "reaction", "invitation", "groupCreate", "groupUpdate"];
+export function validMessageIdentifier(value) { return typeof value === "string" && value.length > 0 && new TextEncoder().encode(value).byteLength <= 256 && !/[\u0000-\u001f]/u.test(value); }
+function members(value) {
+    if (!Array.isArray(value) || value.length > 256 || !value.every(validMessageIdentifier))
+        throw new Error("INVALID_GROUP_MEMBERS");
+    return [...new Set(value)].sort();
+}
+export function validateConversation(scope, thread) {
+    if (!thread || !["dm", "group"].includes(thread.kind) || !validMessageIdentifier(thread.targetId) || thread.teamId !== undefined && thread.teamId !== scope.teamId)
+        throw new Error("INVALID_MESSAGE_CONVERSATION");
+    const expected = thread.kind === "group" ? groupThreadId(scope.appId, thread.targetId, scope.teamId) : dmThreadId(scope.appId, scope.profileId, thread.targetId, scope.teamId);
+    if (thread.id !== expected)
+        throw new Error("MESSAGE_CONVERSATION_MISMATCH");
+}
+export const ALL_MENTION_ID = "__pmate_mention_all__";
+/** Expand group mentions into concrete members understood by all protocol readers. */
+export function expandGroupMentions(text, mentions, memberIds, senderId) {
+    const validMembers = [...new Set(memberIds)], members = validMembers.filter(id => id !== senderId), entries = [...(mentions ?? [])];
+    const pattern = /(?:^|[\s([{，。！？、：；])(@(?:all|所有人))(?=$|[\s,.;:!?，。！？、：；)\]}])/gu;
+    for (const match of text.matchAll(pattern)) {
+        const start = match.index + match[0].length - match[1].length;
+        if (!entries.some(entry => entry.start === start && entry.end === start + match[1].length))
+            entries.push({ id: ALL_MENTION_ID, name: match[1].slice(1), start, end: start + match[1].length });
+    }
+    const seen = new Set();
+    return entries.flatMap(entry => {
+        if (text.slice(entry.start, entry.end) !== `@${entry.name}`)
+            return [];
+        if (entry.id === ALL_MENTION_ID)
+            return ["all", "所有人"].includes(entry.name) ? members.map(id => ({ ...entry, id })) : [];
+        return validMembers.includes(entry.id) ? [entry] : [];
+    }).filter(entry => { const key = `${entry.id}:${entry.start}:${entry.end}`; if (seen.has(key))
+        return false; seen.add(key); return true; });
+}
+/** Build the existing wire protocol inside the owner, before durable acceptance. */
+export function outgoingContent(scope, thread, input) {
+    validateConversation(scope, thread);
+    if (!input || typeof input !== "object" || contentKeys.filter(key => Object.hasOwn(input, key)).length !== 1)
+        throw new Error("INVALID_MESSAGE_CONTENT");
+    const identity = { appId: scope.appId, teamId: scope.teamId };
+    if (input.invitation) {
+        if (typeof input.invitation !== "object" || Array.isArray(input.invitation) || thread.kind !== "dm" || input.invitation.message !== undefined && typeof input.invitation.message !== "string")
+            throw new Error("INVALID_MESSAGE_INVITATION");
+        return { to: thread.targetId, body: { kind: "contact", threadKind: "dm", action: "friendRequest", payload: { ...identity, message: input.invitation.message ?? "" } } };
+    }
+    if (input.groupCreate) {
+        if (thread.kind !== "group" || typeof input.groupCreate.title !== "string")
+            throw new Error("INVALID_GROUP_CREATE");
+        const recipients = members(input.groupCreate.members);
+        if (new Set([scope.profileId, ...recipients]).size > 256)
+            throw new Error("INVALID_GROUP_MEMBERS");
+        return { to: thread.targetId, recipients, body: { kind: "group", threadKind: "group", action: "groupCreate", payload: { ...identity, groupId: thread.targetId, title: input.groupCreate.title, members: recipients } } };
+    }
+    if (input.groupUpdate) {
+        const update = input.groupUpdate, add = members(update.addMembers ?? []), remove = members(update.removeMembers ?? []);
+        if (thread.kind !== "group" || !validMessageIdentifier(update.expectedRevision) || Number(add.length > 0) + Number(remove.length > 0) + Number(update.title !== undefined) + Number(update.avatar !== undefined) !== 1)
+            throw new Error("INVALID_GROUP_UPDATE");
+        if (update.title !== undefined && (typeof update.title !== "string" || !update.title.trim() || [...update.title.trim()].length > 120))
+            throw new Error("INVALID_GROUP_TITLE");
+        if (update.avatar !== undefined && (typeof update.avatar !== "string" || !update.avatar.startsWith("https://") || update.avatar.length > 2048 || /\s/u.test(update.avatar)))
+            throw new Error("INVALID_GROUP_AVATAR");
+        return { to: thread.targetId, body: { kind: "group", threadKind: "group", action: "groupUpdate", payload: { ...identity, groupId: thread.targetId, expectedRevision: update.expectedRevision, addMembers: add, removeMembers: remove, ...(update.title === undefined ? {} : { title: update.title.trim() }), ...(update.avatar === undefined ? {} : { avatar: update.avatar }) } } };
+    }
+    if (thread.kind === "group" && !Array.isArray(thread.memberIds))
+        throw new Error("MESSAGE_GROUP_MEMBERS_UNAVAILABLE");
+    const recipients = thread.kind === "group" ? [...new Set(thread.memberIds)] : undefined;
+    if (recipients && (!recipients.length || recipients.length > 256 || !recipients.every(validMessageIdentifier)))
+        throw new Error("MESSAGE_GROUP_MEMBERS_UNAVAILABLE");
+    const base = { ...identity, ...(thread.kind === "group" ? { groupId: thread.targetId } : {}) };
+    if (input.recall) {
+        if (!validMessageIdentifier(input.recall.messageId))
+            throw new Error("INVALID_MESSAGE_RECALL");
+        return { to: thread.targetId, ...(recipients ? { recipients } : {}), body: { kind: "message", threadKind: thread.kind, contentKind: "text", content: { ...identity, text: "[消息已撤回]", recall: { messageId: input.recall.messageId } } } };
+    }
+    if (input.reaction) {
+        const reaction = input.reaction;
+        if (!validMessageIdentifier(reaction.messageId) || !validMessageIdentifier(reaction.emojiId) || typeof reaction.active !== "boolean")
+            throw new Error("INVALID_MESSAGE_REACTION");
+        // The durable sender assigns the revision in the acceptance transaction.
+        return { to: thread.targetId, ...(recipients ? { recipients } : {}), body: { kind: "message", threadKind: thread.kind, contentKind: "text", content: { ...identity, text: "[表情回应]", reaction: { version: 1, messageId: reaction.messageId, emojiId: reaction.emojiId, active: reaction.active, revision: 1 } } } };
+    }
+    let content, contentKind = "text", voiceBlob;
+    if ("text" in input) {
+        if (typeof input.text !== "string")
+            throw new Error("INVALID_MESSAGE_TEXT");
+        const mentions = thread.kind === "group" ? expandGroupMentions(input.text, input.mentions, recipients, scope.profileId) : input.mentions;
+        content = { ...base, text: input.text, ...(input.quote ? { quote: input.quote } : {}), ...(mentions?.length ? { mentions } : {}) };
+    }
+    else if ("image" in input && input.image) {
+        if (typeof input.image.url !== "string" || !input.image.url)
+            throw new Error("INVALID_MESSAGE_IMAGE");
+        contentKind = "image";
+        content = { ...base, url: input.image.url, ...(input.image.name === undefined ? {} : { name: input.image.name }) };
+    }
+    else if ("voice" in input && input.voice) {
+        const voice = input.voice;
+        if (!Number.isFinite(voice.durationMs) || voice.durationMs <= 0 || !("blob" in voice ? voice.blob instanceof Blob : typeof voice.url === "string" && voice.url.length > 0))
+            throw new Error("INVALID_MESSAGE_VOICE");
+        voiceBlob = voice.blob;
+        content = { ...base, text: "[语音]", voice: { url: voiceBlob ? "" : voice.url, durationMs: voice.durationMs, ...(voice.transcript ? { transcript: voice.transcript } : {}) } };
+    }
+    else
+        throw new Error("INVALID_MESSAGE_CONTENT");
+    return { to: thread.targetId, body: { kind: "message", threadKind: thread.kind, contentKind, content }, ...(recipients ? { recipients } : {}), ...(voiceBlob ? { voiceBlob } : {}) };
+}

package/lib/runtime/readBatchJournal.d.ts

@@ -0,0 +1,35 @@
+import { Dexie } from "dexie";
+export type ReadMutation = {
+    table: "readingThreads" | "readingMessages" | "readingPositions";
+    key: string[];
+    value?: unknown;
+};
+type Plan = {
+    profileKey: string[];
+    header: unknown;
+    versions?: unknown;
+};
+/** Cross-document serialization; the persisted journal is the crash boundary. */
+export declare function lockReadOwner<T>(factory: IDBFactory, name: string, owner: string, run: () => Promise<T>, fallback?: (run: () => Promise<T>) => Promise<T>): Promise<T>;
+/** Stage the full plan first, roll forward bounded batches, publish cursor last. */
+export declare class ReadBatchJournal {
+    private db;
+    private closed;
+    private rows;
+    private knownOwners;
+    private leases;
+    private acquiring;
+    constructor(db: Dexie, closed: () => boolean);
+    lease<T>(owner: string, run: () => Promise<T>): Promise<T>;
+    releaseLeases(): Promise<void>;
+    checkLeases(renew?: boolean): Promise<void>;
+    private check;
+    private tables;
+    recover(owner: string): Promise<void>;
+    private cleanup;
+    private apply;
+    private validatePlan;
+    private finish;
+    commit(owner: string, operations: Iterable<ReadMutation>, plan: Plan): Promise<void>;
+}
+export {};

package/lib/runtime/readBatchJournal.js

@@ -0,0 +1,210 @@
+import { Dexie } from "dexie";
+const LIMIT = 124, BYTES = 1024 * 1024, LEASE_MS = 5_000;
+const size = (value) => JSON.stringify(value).length * 3;
+const localLocks = new WeakMap();
+/** Cross-document serialization; the persisted journal is the crash boundary. */
+export async function lockReadOwner(factory, name, owner, run, fallback) {
+    const key = JSON.stringify(["pmate-reading", name, owner]);
+    if (typeof navigator !== "undefined" && navigator.locks)
+        return navigator.locks.request(key, run);
+    if (typeof window !== "undefined") {
+        if (!fallback)
+            throw new Error("READ_STORAGE_LOCK_UNAVAILABLE");
+        return fallback(run);
+    }
+    let locks = localLocks.get(factory);
+    if (!locks) {
+        locks = new Map();
+        localLocks.set(factory, locks);
+    }
+    const previous = locks.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise(resolve => { release = resolve; });
+    locks.set(key, current);
+    await previous;
+    try {
+        return await run();
+    }
+    finally {
+        release();
+        if (locks.get(key) === current)
+            locks.delete(key);
+    }
+}
+/** Stage the full plan first, roll forward bounded batches, publish cursor last. */
+export class ReadBatchJournal {
+    db;
+    closed;
+    rows;
+    knownOwners = new Set();
+    leases = new Map();
+    acquiring = new Set();
+    constructor(db, closed) {
+        this.db = db;
+        this.closed = closed;
+        this.rows = db.table("readBatches");
+    }
+    async lease(owner, run) {
+        const token = crypto.randomUUID();
+        for (;;) {
+            this.check();
+            const attempt = (async () => {
+                const acquired = await this.db.transaction("rw", this.rows, async () => {
+                    const old = (await this.rows.get([owner, "lease"]))?.lease;
+                    if (old && old.expires > Date.now())
+                        return false;
+                    await this.rows.put({ owner, key: "lease", lease: { token, expires: Date.now() + LEASE_MS } });
+                    return true;
+                });
+                if (acquired)
+                    this.leases.set(owner, token);
+                return acquired;
+            })();
+            this.acquiring.add(attempt);
+            const acquired = await attempt.finally(() => this.acquiring.delete(attempt));
+            if (acquired)
+                break;
+            await new Promise(resolve => setTimeout(resolve, 25));
+        }
+        try {
+            const result = await run();
+            this.check();
+            await this.db.transaction("r", this.rows, () => this.checkLeases());
+            return result;
+        }
+        finally {
+            this.leases.delete(owner);
+            if (!this.closed())
+                await this.db.transaction("rw", this.rows, async () => { if ((await this.rows.get([owner, "lease"]))?.lease?.token === token)
+                    await this.rows.delete([owner, "lease"]); });
+        }
+    }
+    async releaseLeases() {
+        await Promise.allSettled([...this.acquiring]);
+        for (const [owner, token] of this.leases)
+            await this.db.transaction("rw", this.rows, async () => { if ((await this.rows.get([owner, "lease"]))?.lease?.token === token)
+                await this.rows.delete([owner, "lease"]); });
+    }
+    async checkLeases(renew = false) {
+        for (const [owner, token] of this.leases) {
+            if ((await this.rows.get([owner, "lease"]))?.lease?.token !== token)
+                throw new Error("READ_STORAGE_LOCK_LOST");
+            if (renew)
+                await this.rows.put({ owner, key: "lease", lease: { token, expires: Date.now() + LEASE_MS } });
+        }
+    }
+    check() { if (this.closed())
+        throw new Error("READ_STORAGE_CLOSED"); }
+    tables() { return [this.rows, ...["readingProfiles", "readingVersions", "readingThreads", "readingMessages", "readingPositions"].map(name => this.db.table(name))]; }
+    async recover(owner) {
+        this.check();
+        const active = (await this.rows.get([owner, "active"]))?.active;
+        if (!active) {
+            if (!this.knownOwners.has(owner)) {
+                await this.cleanup(owner);
+                this.knownOwners.add(owner);
+            }
+            return;
+        }
+        const plan = (await this.rows.get([owner, `${active.id}:plan`]))?.plan;
+        if (!plan || typeof active.id !== "string" || !Number.isSafeInteger(active.next) || !Number.isSafeInteger(active.total) || active.next < 0 || active.total < 1 || active.next > active.total)
+            throw new Error("READ_STORAGE_INCOMPLETE");
+        this.validatePlan(owner, plan);
+        while (active.next < active.total) {
+            this.check();
+            await this.db.transaction("rw", this.tables(), async () => {
+                await this.checkLeases();
+                const chunk = await this.rows.get([owner, `${active.id}:${active.next}`]);
+                if (!chunk?.operations || chunk.operations.length > LIMIT || chunk.operations.some(operation => !["readingThreads", "readingMessages", "readingPositions"].includes(operation.table) || operation.key[0] !== owner || operation.value !== undefined && operation.value.owner !== owner))
+                    throw new Error("READ_STORAGE_INCOMPLETE");
+                await this.apply(chunk.operations);
+                await this.rows.put({ owner, key: "active", active: { ...active, next: active.next + 1 } });
+                await this.checkLeases(true);
+            });
+            active.next++;
+            await new Promise(resolve => setTimeout(resolve, 0));
+        }
+        this.check();
+        await this.db.transaction("rw", this.tables(), async () => { await this.checkLeases(); await this.finish(plan); await this.rows.delete([owner, "active"]); await this.checkLeases(true); });
+        await this.cleanup(owner);
+        this.knownOwners.add(owner);
+    }
+    async cleanup(owner) {
+        for (;;) {
+            this.check();
+            const keys = await this.rows.where("owner").equals(owner).limit(LIMIT).primaryKeys();
+            const removable = keys.filter(key => key[1] !== "lease");
+            if (removable.length)
+                await this.db.transaction("rw", this.rows, async () => { await this.checkLeases(); await this.rows.bulkDelete(removable); await this.checkLeases(true); });
+            const count = keys.length;
+            if (count < LIMIT)
+                return;
+            await new Promise(resolve => setTimeout(resolve, 0));
+        }
+    }
+    async apply(operations) {
+        for (const name of ["readingThreads", "readingMessages", "readingPositions"]) {
+            const selected = operations.filter(operation => operation.table === name);
+            const writes = selected.filter(operation => operation.value !== undefined).map(operation => operation.value);
+            const deletes = selected.filter(operation => operation.value === undefined).map(operation => operation.key);
+            if (writes.length)
+                await this.db.table(name).bulkPut(writes);
+            if (deletes.length)
+                await this.db.table(name).bulkDelete(deletes);
+        }
+    }
+    validatePlan(owner, plan) {
+        const header = plan.header;
+        if (!Array.isArray(plan.profileKey) || JSON.stringify(plan.profileKey) !== owner || !header || header.schemaVersion !== 1 || header.appId !== plan.profileKey[0] || header.profileId !== plan.profileKey[1])
+            throw new Error("READ_IDENTITY_MISMATCH");
+    }
+    async finish(plan) {
+        if (plan.versions !== undefined)
+            await this.db.table("readingVersions").put(plan.versions, plan.profileKey);
+        await this.db.table("readingProfiles").put(plan.header, plan.profileKey);
+    }
+    async commit(owner, operations, plan) {
+        this.check();
+        this.validatePlan(owner, plan);
+        this.knownOwners.delete(owner);
+        await this.cleanup(owner);
+        if (size(plan) > BYTES)
+            throw new Error("READ_STORAGE_RECORD_TOO_LARGE");
+        const id = crypto.randomUUID(), iterator = operations[Symbol.iterator]();
+        let next = iterator.next(), total = 0;
+        while (!next.done) {
+            const batch = [];
+            let bytes = 512;
+            while (!next.done && batch.length < LIMIT) {
+                const weight = size(next.value);
+                if (weight > BYTES - 512)
+                    throw new Error("READ_STORAGE_RECORD_TOO_LARGE");
+                if (batch.length && bytes + weight > BYTES)
+                    break;
+                bytes += weight;
+                batch.push(next.value);
+                next = iterator.next();
+            }
+            if (total === 0 && next.done) {
+                await this.db.transaction("rw", this.tables(), async () => { await this.checkLeases(); await this.apply(batch); await this.finish(plan); await this.checkLeases(true); });
+                this.knownOwners.add(owner);
+                return;
+            }
+            this.check();
+            await this.db.transaction("rw", this.rows, async () => { await this.checkLeases(); await this.rows.put({ owner, key: `${id}:${total++}`, operations: batch }); await this.checkLeases(true); });
+            await new Promise(resolve => setTimeout(resolve, 0));
+        }
+        if (!total) {
+            await this.db.transaction("rw", this.tables(), async () => { await this.checkLeases(); await this.finish(plan); await this.checkLeases(true); });
+            this.knownOwners.add(owner);
+            return;
+        }
+        await this.db.transaction("rw", this.rows, async () => {
+            await this.checkLeases();
+            await this.rows.put({ owner, key: `${id}:plan`, plan });
+            await this.rows.put({ owner, key: "active", active: { id, next: 0, total } });
+            await this.checkLeases(true);
+        });
+        await this.recover(owner);
+    }
+}

package/lib/runtime/readCounts.d.ts

@@ -1,3 +1,5 @@
+import { type ResponseCacheAccess } from "./responseCache.js";
+import { type MessageScope } from "./messageStore.js";
 export type ReadCountsResult = {
     appId: string;
     threadId: string;
@@ -11,6 +13,8 @@ export type ReadCountsOptions = {
     clientInstanceId: string;
     hubHttpUrl: string;
     fetch?: typeof fetch;
+    scope?: MessageScope;
+    access?: ResponseCacheAccess;
     onChange: (value: ReadCountsResult) => void;
     onError?: (error: unknown) => void;
 };
@@ -25,13 +29,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 +53,6 @@ export declare class ReadCountsClient {
     reconnect(): void;
     private schedule;
     private refresh;
-    close(): void;
+    retireScope(version: number): Promise<void>;
+    close(): Promise<void>;
 }

package/lib/runtime/readCounts.js

@@ -1,3 +1,6 @@
+import { isOffline, isOfflineNetworkFailure } from "./connectivity.js";
+import { IndexedDbResponseCache, isResponseCacheAuthorityError, assertResponseCacheAccess } 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,29 +14,58 @@ 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), { access: options.access });
+        }
+    }
+    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 scopeVersion = this.options.access ? await assertResponseCacheAccess(this.options.access) : undefined;
         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" });
         if (!response.ok)
             throw new Error(`READ_COUNTS_HTTP_${response.status}`);
         const envelope = await response.json();
         if (envelope.success !== true)
             throw new Error("INVALID_READ_COUNTS_RESPONSE");
+        if (this.options.access)
+            await assertResponseCacheAccess(this.options.access, scopeVersion);
         return envelope.data;
     }
     subscription(threadId, release) {
+        if (release && isOffline())
+            return Promise.resolve();
         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)
@@ -48,18 +80,29 @@ export class ReadCountsClient {
                 this.heartbeat = setInterval(() => { if (!this.closed && this.thread === threadId)
                     this.renew(); }, 20_000);
             // Recover changes that occurred before a receiver/subscription became ready.
-            if (recovered && this.revision >= 0)
+            if (recovered) {
+                // A fresh cache predates the new lease and cannot cover its delivery gap.
+                this.force = true;
                 this.schedule(0);
+            }
         }).catch(error => {
             if (this.closed || generation !== this.generation)
                 return;
             this.subscribed = false;
             if (/READ_COUNTS_HTTP_(401|403)/.test(String(error))) {
                 this.subscriptionDenied = true;
+                this.denyCache();
                 clearInterval(this.heartbeat);
                 this.heartbeat = undefined;
             }
-            this.options.onError?.(error);
+            if (isResponseCacheAuthorityError(error)) {
+                this.lastResult = undefined;
+                this.subscriptionDenied = true;
+                clearInterval(this.heartbeat);
+                this.heartbeat = undefined;
+            }
+            if (!isOfflineNetworkFailure(error))
+                this.options.onError?.(error);
         }).finally(() => { if (this.subscriptionPending === pending)
             this.subscriptionPending = undefined; });
         this.subscriptionPending = pending;
@@ -83,9 +126,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 +150,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,22 +185,60 @@ 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 => { if (isResponseCacheAuthorityError(error))
+                throw 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;
+            }
+            if (isOffline())
+                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 (isResponseCacheAuthorityError(error))
+                    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 (isOfflineNetworkFailure(error)) {
+                this.dirty = false;
+                return;
+            }
             if (!controller.signal.aborted && generation === this.generation && !this.closed) {
+                if (/READ_COUNTS_HTTP_(401|403)/.test(String(error)))
+                    this.denyCache();
+                if (isResponseCacheAuthorityError(error)) {
+                    this.lastResult = undefined;
+                    this.subscriptionDenied = true;
+                    this.dirty = false;
+                    clearInterval(this.heartbeat);
+                    this.heartbeat = undefined;
+                }
                 this.options.onError?.(error);
-                if (!/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)) && this.retries < 3) {
                     retryDelay = 1000 * 2 ** this.retries++;
                     this.dirty = true;
                 }
@@ -166,9 +252,10 @@ export class ReadCountsClient {
             }
         }
     }
+    retireScope(version) { return this.cache?.retire(version) ?? Promise.resolve(); }
     close() {
-        if (this.closed)
-            return;
+        if (this.closing)
+            return this.closing;
         const old = this.thread;
         this.closed = true;
         this.generation++;
@@ -178,5 +265,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();
     }
 }