@pmate/chat-sdk 0.12.0-next.4 → 0.12.0-next.41

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();
     }
 }

package/lib/runtime/readIndex.d.ts

@@ -7,9 +7,16 @@ export type IndexedReadMessage = {
     mentions: string[];
     readPolicy: "visible" | "explicit";
     recalled: boolean;
-    /** Cached payload is retained so an offline reload can render the message. */
+    /** Legacy standalone readers may retain payloads; unified sessions use the message store. */
     payload: unknown;
+    /** Body-free control classification retained by metadata-only reading indexes. */
+    readingControl?: boolean;
 };
+/** Retain read semantics without a second durable copy of message bodies. */
+export declare function readingMetadata<T extends {
+    appId: string;
+    threads: IndexedReadThread[];
+}>(state: T): T;
 export type ReadingOperation = {
     operationId: string;
     threadId: string;
@@ -72,32 +79,63 @@ export declare function coalesceReadOperations(current: ReadIndexState): (Readin
     operationIds: string[];
 })[];
 /** Counts are over the indexed message coverage, not an estimate of missing history. */
-export declare function unreadInThread(state: ReadIndexState, threadId: string): {
+export declare function unreadInThread(state: ReadIndexState, threadId: string, hidden?: ReadonlyMap<string, ReadonlySet<string>>): {
     unreadMessageCount: number;
     unreadMentionCount: number;
     badgeCount: number;
 };
+export type ReadIndexVersions = Readonly<Record<string, number>>;
+export type ReadIndexTransform = (current: ReadIndexState, versions?: ReadIndexVersions) => ReadIndexState;
+export declare function assertReadIndexVersions(expected: ReadIndexVersions, current?: ReadIndexVersions, teamId?: string): void;
+/** Remove only the withdrawn team's original sources, logical conversations and
+ * queued observations. Other teams' pending operations must survive. */
+export declare function removeReadTeam(state: ReadIndexState, teamId: string, knownThreadIds?: readonly string[]): ReadIndexState;
 export interface ReadIndexPersistence {
     load(appId: string, profileId: string): Promise<ReadIndexState | undefined>;
+    loadVersioned?(appId: string, profileId: string): Promise<{
+        state: ReadIndexState | undefined;
+        versions: ReadIndexVersions;
+    }>;
+    loadVersions?(appId: string, profileId: string): Promise<ReadIndexVersions>;
+    invalidateTeam?(appId: string, profileId: string, teamId: string, version: number, knownThreadIds?: readonly string[]): Promise<ReadIndexState>;
     /** Transform and persist atomically; UI publishes only the committed result. */
-    update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
+    update(appId: string, profileId: string, transform: ReadIndexTransform): Promise<ReadIndexState>;
 }
 /** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
 export declare class IndexedDbReadIndex implements ReadIndexPersistence {
     private storageScope?;
+    private migrateLegacy;
+    private metadataOnly;
     private database;
     private profiles;
+    private threadRows;
+    private messageRows;
+    private positionRows;
+    private normalizedStates;
+    private versions;
     private closed;
-    constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined);
+    constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined, migrateLegacy?: boolean, metadataOnly?: boolean);
     private transaction;
     private key;
+    private hydrate;
+    private loadCurrent;
+    private loadStored;
+    /** Message bodies are immutable for local read observations: keep them out of
+     * profile/cursor writes, and update only changed normalized rows on sync. */
+    private persist;
     load(appId: string, profileId: string): Promise<ReadIndexState | undefined>;
-    update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
+    loadVersioned(appId: string, profileId: string): Promise<{
+        state: ReadIndexState | undefined;
+        versions: Record<string, number>;
+    }>;
+    loadVersions(appId: string, profileId: string): Promise<ReadIndexVersions>;
+    invalidateTeam(appId: string, profileId: string, teamId: string, version: number, knownThreadIds?: readonly string[]): Promise<ReadIndexState>;
+    update(appId: string, profileId: string, transform: ReadIndexTransform): Promise<ReadIndexState>;
     close(): Promise<void>;
 }
 export declare function sourcesInConversation(state: ReadIndexState, conversationId: string): IndexedReadThread[];
 /** Aggregate logical history while each original source retains its own read cursor. */
-export declare function unreadInConversation(state: ReadIndexState, conversationId: string): {
+export declare function unreadInConversation(state: ReadIndexState, conversationId: string, hidden?: ReadonlyMap<string, ReadonlySet<string>>): {
     unreadMessageCount: number;
     unreadMentionCount: number;
     badgeCount: number;

package/lib/runtime/readIndex.js

@@ -1,5 +1,24 @@
 import { Dexie } from "dexie";
+import { isReadingControl } from "./readingContent.js";
 import { isValidChatTeamId } from "./thread.js";
+/** Retain read semantics without a second durable copy of message bodies. */
+export function readingMetadata(state) {
+    let changed = false;
+    const threads = state.threads.map(thread => {
+        let different = false;
+        const messages = thread.messages.map(message => {
+            if (message.payload === null && typeof message.readingControl === "boolean")
+                return message;
+            different = true;
+            return { ...message, payload: null, readingControl: Boolean(message.readingControl) || isReadingControl(message.payload, state.appId) };
+        });
+        if (!different)
+            return thread;
+        changed = true;
+        return { ...thread, messages };
+    });
+    return changed ? { ...state, threads } : state;
+}
 export class ReadSyncGap extends Error {
     cursor;
     constructor(cursor) {
@@ -153,31 +172,66 @@ export function coalesceReadOperations(current) {
     return [...batches.values()];
 }
 /** Counts are over the indexed message coverage, not an estimate of missing history. */
-export function unreadInThread(state, threadId) {
+export function unreadInThread(state, threadId, hidden) {
     const thread = state.threads.find(t => t.id === threadId);
     if (!thread)
         throw new Error("UNKNOWN_READ_THREAD");
     const explicit = new Set(thread.explicitReadMessageIds);
-    const messages = thread.messages.filter(message => !message.recalled && message.from !== state.profileId && message.recipients.includes(state.profileId)
+    const messages = thread.messages.filter(message => !message.recalled && !hidden?.get(message.id)?.has(message.from) && !(message.readingControl || isReadingControl(message.payload, state.appId)) && message.from !== state.profileId && message.recipients.includes(state.profileId)
         && (message.readPolicy === "explicit" ? !explicit.has(message.id) : message.seq > thread.readThroughSeq));
     const unreadMessageCount = messages.length;
     const unreadMentionCount = messages.filter(message => message.mentions.includes(state.profileId)).length;
     return { unreadMessageCount, unreadMentionCount, badgeCount: thread.kind === "group" ? unreadMentionCount : unreadMessageCount };
 }
+function readTeamVersion(versions, team) { return Object.hasOwn(versions, team) ? versions[team] : 0; }
+export function assertReadIndexVersions(expected, current = {}, teamId) {
+    const teams = new Set(teamId === undefined ? [...Object.keys(expected), ...Object.keys(current)] : [teamId]);
+    if ([...teams].some(team => readTeamVersion(expected, team) !== readTeamVersion(current, team)))
+        throw new Error("READ_SCOPE_CHANGED");
+}
+/** Remove only the withdrawn team's original sources, logical conversations and
+ * queued observations. Other teams' pending operations must survive. */
+export function removeReadTeam(state, teamId, knownThreadIds = []) {
+    const removed = new Set(knownThreadIds);
+    for (const thread of state.threads)
+        if (thread.teamId === teamId) {
+            removed.add(thread.id);
+            if (thread.conversationId)
+                removed.add(thread.conversationId);
+        }
+    return { ...state, syncCursor: "0", threads: state.threads.filter(thread => thread.teamId !== teamId && !removed.has(thread.id)),
+        pending: state.pending.filter(operation => !removed.has(operation.threadId)),
+        observedReadIntents: state.observedReadIntents?.filter(intent => !removed.has(intent.threadId)) };
+}
 /** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
 export class IndexedDbReadIndex {
     storageScope;
+    migrateLegacy;
+    metadataOnly;
     database;
     profiles;
+    threadRows;
+    messageRows;
+    positionRows;
+    normalizedStates = new WeakSet();
+    versions;
     closed = false;
-    constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index", storageScope) {
+    constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index", storageScope, migrateLegacy = false, metadataOnly = false) {
         this.storageScope = storageScope;
+        this.migrateLegacy = migrateLegacy;
+        this.metadataOnly = metadataOnly;
         if (!factory)
             throw new Error("READ_STORAGE_UNAVAILABLE");
         this.database = new Dexie(name, { indexedDB: factory, IDBKeyRange: globalThis.IDBKeyRange });
         // The empty schema retains the legacy out-of-line primary key and records.
         this.database.version(1).stores({ profiles: "" });
+        this.database.version(2).stores({ profiles: "", versions: "" });
+        this.database.version(3).stores({ readThreads: "[owner+id],owner", readMessages: "[owner+thread+id],[owner+thread],owner", readPositions: "[owner+id],owner" });
+        this.positionRows = this.database.table("readPositions");
+        this.threadRows = this.database.table("readThreads");
+        this.messageRows = this.database.table("readMessages");
         this.profiles = this.database.table("profiles");
+        this.versions = this.database.table("versions");
         this.database.on("versionchange", () => { this.database.close({ disableAutoOpen: false }); return false; });
     }
     async transaction(mode, execute) {
@@ -186,7 +240,7 @@ export class IndexedDbReadIndex {
                 throw new Error("READ_STORAGE_CLOSED");
             let started = false;
             try {
-                return await this.database.transaction(mode, this.profiles, async () => {
+                return await this.database.transaction(mode, [this.profiles, this.versions, this.threadRows, this.messageRows, this.positionRows], async () => {
                     if (this.closed)
                         throw new Error("READ_STORAGE_CLOSED");
                     started = true;
@@ -205,17 +259,190 @@ export class IndexedDbReadIndex {
         throw new Error("READ_STORAGE_UNAVAILABLE");
     }
     key(appId, profileId) { return this.storageScope === undefined ? [appId, profileId] : [appId, profileId, this.storageScope]; }
+    async hydrate(current, key) {
+        if (current.normalized) {
+            const owner = JSON.stringify(key);
+            const [threads, messages, positions] = await Promise.all([
+                this.threadRows.where("owner").equals(owner).toArray(),
+                this.messageRows.where("owner").equals(owner).toArray(),
+                this.positionRows.where("owner").equals(owner).toArray(),
+            ]);
+            const byThread = new Map();
+            for (const row of messages) {
+                if (!byThread.has(row.thread))
+                    byThread.set(row.thread, new Map());
+                byThread.get(row.thread).set(row.id, row.value);
+            }
+            const byPosition = new Map(positions.map(row => [row.id, row]));
+            const byId = new Map(threads.map(row => [row.id, row]));
+            const { normalized: _normalized, threadOrder, ...state } = current;
+            const result = { ...state, threads: (threadOrder ?? []).map(id => {
+                    const row = byId.get(id);
+                    const position = byPosition.get(id);
+                    if (!row || !position)
+                        throw new Error("READ_STORAGE_INCOMPLETE");
+                    return { ...row.value, readThroughSeq: position.readThroughSeq, explicitReadMessageIds: position.explicitReadMessageIds, messages: row.messageIds.map(messageId => {
+                            const message = byThread.get(id)?.get(messageId);
+                            if (!message)
+                                throw new Error("READ_STORAGE_INCOMPLETE");
+                            return message;
+                        }) };
+                }) };
+            this.normalizedStates.add(result);
+            return result;
+        }
+        return current;
+    }
+    async loadCurrent(appId, profileId) {
+        const current = await this.loadStored(appId, profileId);
+        if (!current || !this.metadataOnly)
+            return current;
+        const metadata = readingMetadata(current);
+        if (metadata !== current)
+            await this.persist(appId, profileId, current, metadata);
+        return metadata;
+    }
+    async loadStored(appId, profileId) {
+        const current = await this.profiles.get(this.key(appId, profileId));
+        if (current?.normalized)
+            return this.hydrate(current, this.key(appId, profileId));
+        if (current) {
+            const next = this.metadataOnly ? readingMetadata(current) : current;
+            if (this.migrateLegacy || this.metadataOnly)
+                await this.persist(appId, profileId, undefined, next, true);
+            return next;
+        }
+        if (!this.migrateLegacy || this.storageScope === undefined)
+            return undefined;
+        const markerKey = [appId, profileId, "legacy-owner-v1"];
+        const marker = await this.profiles.get(markerKey);
+        if (marker && marker.legacyOwner !== this.storageScope)
+            return undefined;
+        const legacyRow = await this.profiles.get([appId, profileId]);
+        if (!legacyRow)
+            return undefined;
+        const hydrated = await this.hydrate(legacyRow, [appId, profileId]);
+        const legacy = this.metadataOnly ? readingMetadata(hydrated) : hydrated;
+        if (legacy.appId !== appId || legacy.profileId !== profileId || legacy.schemaVersion !== 1)
+            throw new Error("READ_IDENTITY_MISMATCH");
+        const ownership = { ...createReadIndex(appId, profileId), legacyOwner: this.storageScope };
+        await this.profiles.put(ownership, markerKey);
+        await this.persist(appId, profileId, undefined, legacy);
+        await this.profiles.delete([appId, profileId]);
+        const oldOwner = JSON.stringify([appId, profileId]);
+        await this.threadRows.where("owner").equals(oldOwner).delete();
+        await this.messageRows.where("owner").equals(oldOwner).delete();
+        await this.positionRows.where("owner").equals(oldOwner).delete();
+        return legacy;
+    }
+    /** Message bodies are immutable for local read observations: keep them out of
+     * profile/cursor writes, and update only changed normalized rows on sync. */
+    async persist(appId, profileId, previous, next, replaceLegacy = false) {
+        if (previous && !this.normalizedStates.has(previous)) {
+            previous = undefined;
+            replaceLegacy = true;
+        }
+        const owner = JSON.stringify(this.key(appId, profileId));
+        const oldThreads = new Map(previous?.threads.map(thread => [thread.id, thread]) ?? []);
+        const nextIds = new Set(next.threads.map(thread => thread.id));
+        if (nextIds.size !== next.threads.length)
+            throw new Error("DUPLICATE_READ_THREAD");
+        const threadWrites = [], messageWrites = [], positionWrites = [];
+        const messageDeletes = [];
+        for (const thread of next.threads) {
+            const old = oldThreads.get(thread.id);
+            if (old === thread)
+                continue;
+            const { messages, readThroughSeq, explicitReadMessageIds, ...value } = thread;
+            const position = { owner, id: thread.id, readThroughSeq, explicitReadMessageIds };
+            if (!old || old.readThroughSeq !== readThroughSeq || JSON.stringify(old.explicitReadMessageIds) !== JSON.stringify(explicitReadMessageIds))
+                positionWrites.push(position);
+            const oldValue = old ? (({ messages: _messages, readThroughSeq: _seq, explicitReadMessageIds: _explicit, ...rest }) => rest)(old) : undefined;
+            if (!old || old.messages !== messages || JSON.stringify(oldValue) !== JSON.stringify(value)) {
+                const metadata = { owner, id: thread.id, value, messageIds: messages.map(message => message.id) };
+                const oldMetadata = old ? { owner, id: old.id, value: oldValue, messageIds: old.messages.map(message => message.id) } : undefined;
+                if (JSON.stringify(metadata) !== JSON.stringify(oldMetadata))
+                    threadWrites.push(metadata);
+            }
+            if (old?.messages === messages)
+                continue;
+            const byId = new Map(old?.messages.map(message => [message.id, message]) ?? []);
+            const ids = new Set();
+            for (const message of messages) {
+                if (ids.has(message.id))
+                    throw new Error("INVALID_READ_MESSAGE");
+                ids.add(message.id);
+                const prior = byId.get(message.id);
+                if (prior !== message && JSON.stringify(prior) !== JSON.stringify(message))
+                    messageWrites.push({ owner, thread: thread.id, id: message.id, value: message });
+            }
+            for (const id of byId.keys())
+                if (!ids.has(id))
+                    messageDeletes.push([owner, thread.id, id]);
+        }
+        for (const id of oldThreads.keys())
+            if (!nextIds.has(id)) {
+                await this.threadRows.delete([owner, id]);
+                await this.positionRows.delete([owner, id]);
+                await this.messageRows.where("[owner+thread]").equals([owner, id]).delete();
+            }
+        // A legacy document can replace the full profile after normalization. Its
+        // replacement is authoritative for the row set; discard unreachable bodies
+        // in the same transaction before installing the rebuilt normalized records.
+        if (replaceLegacy) {
+            await this.messageRows.where("owner").equals(owner).delete();
+            await this.threadRows.where("owner").equals(owner).delete();
+            await this.positionRows.where("owner").equals(owner).delete();
+        }
+        // Bound each IndexedDB bulk request. A snapshot and its cursor still commit
+        // atomically; bounding total snapshot transaction bytes is separate work.
+        for (let offset = 0; offset < positionWrites.length; offset += 128)
+            await this.positionRows.bulkPut(positionWrites.slice(offset, offset + 128));
+        for (let offset = 0; offset < threadWrites.length; offset += 128)
+            await this.threadRows.bulkPut(threadWrites.slice(offset, offset + 128));
+        for (let offset = 0; offset < messageWrites.length; offset += 128)
+            await this.messageRows.bulkPut(messageWrites.slice(offset, offset + 128));
+        for (let offset = 0; offset < messageDeletes.length; offset += 128)
+            await this.messageRows.bulkDelete(messageDeletes.slice(offset, offset + 128));
+        const header = (state) => ({ ...state, threads: [], normalized: true, threadOrder: state.threads.map(thread => thread.id) });
+        const nextHeader = header(next);
+        if (!previous || JSON.stringify(header(previous)) !== JSON.stringify(nextHeader))
+            await this.profiles.put(nextHeader, this.key(appId, profileId));
+        this.normalizedStates.add(next);
+    }
     async load(appId, profileId) {
-        return this.transaction("r", () => this.profiles.get(this.key(appId, profileId)));
+        return this.transaction(this.migrateLegacy || this.metadataOnly ? "rw" : "r", () => this.loadCurrent(appId, profileId));
+    }
+    async loadVersioned(appId, profileId) {
+        return this.transaction(this.migrateLegacy || this.metadataOnly ? "rw" : "r", async () => ({
+            state: await this.loadCurrent(appId, profileId), versions: (await this.versions.get(this.key(appId, profileId)))?.teams ?? {},
+        }));
+    }
+    async loadVersions(appId, profileId) {
+        return this.transaction("r", async () => (await this.versions.get(this.key(appId, profileId)))?.teams ?? {});
+    }
+    async invalidateTeam(appId, profileId, teamId, version, knownThreadIds = []) {
+        if (!isValidChatTeamId(teamId) || !Number.isSafeInteger(version) || version < 1)
+            throw new Error("INVALID_READ_SCOPE_VERSION");
+        return this.transaction("rw", async () => {
+            const state = await this.loadCurrent(appId, profileId) ?? createReadIndex(appId, profileId);
+            const teams = (await this.versions.get(this.key(appId, profileId)))?.teams ?? {};
+            if (readTeamVersion(teams, teamId) >= version)
+                return state;
+            const next = removeReadTeam(state, teamId, knownThreadIds);
+            await this.versions.put({ teams: { ...teams, [teamId]: version } }, this.key(appId, profileId));
+            await this.persist(appId, profileId, state, next);
+            return next;
+        });
     }
     async update(appId, profileId, transform) {
         return this.transaction("rw", async () => {
-            const previous = await this.profiles.get(this.key(appId, profileId));
-            const next = transform(previous ?? createReadIndex(appId, profileId));
+            const previous = await this.loadCurrent(appId, profileId);
+            const transformed = transform(previous ?? createReadIndex(appId, profileId), (await this.versions.get(this.key(appId, profileId)))?.teams ?? {});
+            const next = this.metadataOnly ? readingMetadata(transformed) : transformed;
             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, this.key(appId, profileId));
+            await this.persist(appId, profileId, previous, next);
             return next;
         });
     }
@@ -231,14 +458,14 @@ function readSource(state, conversationId, messageId) {
     return sources[0];
 }
 /** Aggregate logical history while each original source retains its own read cursor. */
-export function unreadInConversation(state, conversationId) {
+export function unreadInConversation(state, conversationId, hidden) {
     const sources = sourcesInConversation(state, conversationId);
     if (!sources.length)
         throw new Error("UNKNOWN_READ_CONVERSATION");
     if (new Set(sources.map(source => source.teamId)).size > 1)
         throw new Error("READ_CONVERSATION_TEAM_MISMATCH");
     return sources.reduce((total, source) => {
-        const unread = unreadInThread(state, source.id);
+        const unread = unreadInThread(state, source.id, hidden);
         return { unreadMessageCount: total.unreadMessageCount + unread.unreadMessageCount, unreadMentionCount: total.unreadMentionCount + unread.unreadMentionCount, badgeCount: total.badgeCount + unread.badgeCount };
     }, { unreadMessageCount: 0, unreadMentionCount: 0, badgeCount: 0 });
 }

package/lib/runtime/readSync.d.ts

@@ -4,6 +4,7 @@ export type ReadSyncOptions = {
     profileId: string;
     sessionToken: string;
     hubHttpUrl: string;
+    metadataOnly?: boolean;
     persistence: ReadIndexPersistence;
     fetch?: typeof globalThis.fetch;
     onChange?: (state: ReadIndexState) => void;