@pmate/chat-sdk 0.12.0-next.25 → 0.12.0-next.27

package/lib/runtime/readIndex.d.ts

@@ -100,12 +100,20 @@ export declare class IndexedDbReadIndex implements ReadIndexPersistence {
     private migrateLegacy;
     private database;
     private profiles;
+    private threadRows;
+    private messageRows;
+    private positionRows;
+    private normalizedStates;
     private versions;
     private closed;
     constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined, migrateLegacy?: boolean);
     private transaction;
     private key;
+    private hydrate;
     private loadCurrent;
+    /** 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>;
     loadVersioned(appId: string, profileId: string): Promise<{
         state: ReadIndexState | undefined;

package/lib/runtime/readIndex.js

@@ -190,6 +190,10 @@ export class IndexedDbReadIndex {
     migrateLegacy;
     database;
     profiles;
+    threadRows;
+    messageRows;
+    positionRows;
+    normalizedStates = new WeakSet();
     versions;
     closed = false;
     constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index", storageScope, migrateLegacy = false) {
@@ -201,6 +205,10 @@ export class IndexedDbReadIndex {
         // 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; });
@@ -211,7 +219,7 @@ export class IndexedDbReadIndex {
                 throw new Error("READ_STORAGE_CLOSED");
             let started = false;
             try {
-                return await this.database.transaction(mode, this.profiles, this.versions, 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;
@@ -230,25 +238,146 @@ 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.profiles.get(this.key(appId, profileId));
-        if (current || !this.migrateLegacy || this.storageScope === undefined)
+        if (current?.normalized)
+            return this.hydrate(current, this.key(appId, profileId));
+        if (current) {
+            if (this.migrateLegacy)
+                await this.persist(appId, profileId, undefined, current, true);
             return current;
+        }
+        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 legacy = await this.profiles.get([appId, profileId]);
-        if (!legacy)
+        const legacyRow = await this.profiles.get([appId, profileId]);
+        if (!legacyRow)
             return undefined;
+        const legacy = await this.hydrate(legacyRow, [appId, profileId]);
         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.profiles.put(legacy, this.key(appId, profileId));
+        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(this.migrateLegacy ? "rw" : "r", () => this.loadCurrent(appId, profileId));
     }
@@ -270,7 +399,7 @@ export class IndexedDbReadIndex {
                 return state;
             const next = removeReadTeam(state, teamId, knownThreadIds);
             await this.versions.put({ teams: { ...teams, [teamId]: version } }, this.key(appId, profileId));
-            await this.profiles.put(next, this.key(appId, profileId));
+            await this.persist(appId, profileId, state, next);
             return next;
         });
     }
@@ -280,8 +409,7 @@ export class IndexedDbReadIndex {
             const next = transform(previous ?? createReadIndex(appId, profileId), (await this.versions.get(this.key(appId, profileId)))?.teams ?? {});
             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;
         });
     }

package/package.json

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