@pmate/chat-sdk 0.12.0-next.33 → 0.12.0-next.35

package/lib/runtime/chatSession.js

@@ -261,7 +261,8 @@ export class ChatSession {
                 return { ...recent, messages: [], hasEarlier: false };
             if (!edge.before)
                 throw new Error("MESSAGE_SYNC_NO_PROGRESS");
-            const page = await this.getMessages(threadId, { before: edge.before });
+            const page = await this.messages.earlier(threadId, edge.before, 100, true);
+            await this.sender.confirm(page.messages.map(message => message.id));
             this.assertOpen();
             this.rememberHistoryEdge(threadId, page);
             return page;

package/lib/runtime/messageClient.d.ts

@@ -36,6 +36,7 @@ export declare class MessageClient<T extends StoredMessage> {
     private options;
     private storage;
     private watches;
+    private windowEdges;
     private accessListeners;
     private allListeners;
     private reads;
@@ -93,7 +94,7 @@ export declare class MessageClient<T extends StoredMessage> {
     earlier(thread: string, before: {
         timestamp: number;
         id: string;
-    }, limit?: number): Promise<MessageSnapshot<T>>;
+    }, limit?: number, expand?: boolean): Promise<MessageSnapshot<T>>;
     private fillWindow;
     private denyView;
     private denyScope;

package/lib/runtime/messageClient.js

@@ -6,6 +6,7 @@ export class MessageClient {
     options;
     storage;
     watches = new Map();
+    windowEdges = new Map();
     accessListeners = new Set();
     allListeners = new Set();
     reads = new Map();
@@ -252,7 +253,27 @@ export class MessageClient {
     async reload(thread, fallback = false) {
         await this.ensureScope();
         const limit = 100;
-        const page = await (fallback ? this.storage.readFallback(thread, limit) : this.storage.read(thread, limit));
+        let page = await (fallback ? this.storage.readFallback(thread, limit) : this.storage.read(thread, limit));
+        const edge = this.windowEdges.get(thread);
+        if (edge && edge.version !== (page.coverage?.resetVersion ?? 0))
+            this.windowEdges.delete(thread);
+        if (edge && edge.version === (page.coverage?.resetVersion ?? 0)) {
+            const pages = [page.messages];
+            const beforeEdge = (message) => message.timestamp < edge.timestamp || message.timestamp === edge.timestamp && message.id < edge.id;
+            let oldest = page.messages[0];
+            while (oldest && !beforeEdge(oldest) && (oldest.timestamp !== edge.timestamp || oldest.id !== edge.id) && page.hasEarlier) {
+                const next = await (fallback ? this.storage.readFallback(thread, limit, { timestamp: oldest.timestamp, id: oldest.id }) : this.storage.read(thread, limit, { timestamp: oldest.timestamp, id: oldest.id }));
+                if ((next.coverage?.resetVersion ?? 0) !== edge.version || (next.coverage?.scopeVersion ?? 0) !== (page.coverage?.scopeVersion ?? 0)) {
+                    this.windowEdges.delete(thread);
+                    return this.reload(thread, fallback);
+                }
+                pages.push(next.messages);
+                page = next;
+                oldest = next.messages[0];
+            }
+            const messages = pages.reverse().flat();
+            page = { ...page, messages: messages.filter(message => !beforeEdge(message)), hasEarlier: page.hasEarlier || messages.some(beforeEdge) };
+        }
         if (this.closed)
             throw new Error("MESSAGE_CLIENT_CLOSED");
         if ((page.coverage?.scopeVersion ?? 0) !== this.scopeVersion) {
@@ -464,7 +485,7 @@ export class MessageClient {
         this.syncing.set(thread, task);
         return task;
     }
-    async earlier(thread, before, limit = 100) {
+    async earlier(thread, before, limit = 100, expand = false) {
         await this.ensureScope();
         if (this.scopeDenied)
             throw new Error("MESSAGE_ACCESS_REVOKED");
@@ -478,7 +499,14 @@ export class MessageClient {
                     throw new Error("MESSAGE_OFFLINE_UNAVAILABLE");
                 await this.synchronize(thread);
             }
-            return await this.fillWindow(thread, limit, before);
+            const page = await this.fillWindow(thread, limit, before);
+            if (expand && page.complete && page.messages.length) {
+                const first = page.messages[0], old = this.windowEdges.get(thread);
+                if (!old || old.version !== page.resetVersion || first.timestamp < old.timestamp || first.timestamp === old.timestamp && first.id < old.id)
+                    this.windowEdges.set(thread, { timestamp: first.timestamp, id: first.id, version: page.resetVersion });
+                await this.reload(thread);
+            }
+            return page;
         }
         catch (error) {
             if (String(error).includes("MESSAGE_SCOPE_CHANGED")) {
@@ -538,6 +566,7 @@ export class MessageClient {
         return { messages: page.messages, hasEarlier: page.hasEarlier || Boolean(page.coverage?.nextBefore), resetVersion: page.coverage?.resetVersion ?? 0, complete: page.coverage?.complete ?? false };
     }
     denyView(thread, version) {
+        this.windowEdges.delete(thread);
         this.revoked.add(thread);
         const watch = this.watches.get(thread);
         const snapshot = { messages: [], hasEarlier: false, complete: false, resetVersion: Math.max(watch?.snapshot.resetVersion ?? 0, version ?? (watch?.snapshot.resetVersion ?? 0) + 1) };
@@ -619,6 +648,7 @@ export class MessageClient {
             this.abort.abort();
             this.channel?.close();
             this.watches.clear();
+            this.windowEdges.clear();
             this.allListeners.clear();
             this.accessListeners.clear();
             this.storage.close();

package/lib/runtime/messageControls.d.ts

@@ -0,0 +1,19 @@
+import type { StoredMessage, MessageScope } from "./messageStore.js";
+export type MessageControl = {
+    scope: string;
+    thread: string;
+    target: string;
+    kind: "recall" | "reaction";
+    actor: string;
+    emoji: string;
+    id: string;
+    timestamp: number;
+    revision: number;
+    active: boolean;
+};
+export type ControlKey = [string, string, string, string, string, string];
+export declare const controlKey: (event: MessageControl) => ControlKey;
+export declare function newerControl(old: MessageControl | undefined, next: MessageControl): MessageControl;
+/** Body-free proofs retained independently of the visible history window. */
+export declare function messageControls(message: StoredMessage, scope: MessageScope, key: string): MessageControl[];
+export declare function applyMessageControls<T extends StoredMessage>(messages: T[], controls: readonly MessageControl[]): T[];

package/lib/runtime/messageControls.js

@@ -0,0 +1,44 @@
+export const controlKey = (event) => [event.scope, event.thread, event.target, event.kind, event.actor, event.emoji];
+export function newerControl(old, next) {
+    return !old || next.revision > old.revision || next.revision === old.revision && (next.timestamp > old.timestamp || next.timestamp === old.timestamp && next.id > old.id) ? next : old;
+}
+const identifier = (value) => typeof value === "string" && value.length > 0 && value.length <= 256;
+/** Body-free proofs retained independently of the visible history window. */
+export function messageControls(message, scope, key) {
+    const row = message;
+    if (row.appId !== undefined && row.appId !== scope.appId || row.teamId !== undefined && row.teamId !== scope.teamId || !identifier(row.from))
+        return [];
+    const apps = row.body;
+    const app = apps?.content?.appId ?? apps?.payload?.appId;
+    if (app !== undefined && app !== scope.appId)
+        return [];
+    if (row.recalled || row.legacyDisplay?.recalled)
+        return [{ scope: key, thread: message.threadId, target: message.id, kind: "recall", actor: row.from, emoji: "", id: message.id, timestamp: message.timestamp, revision: 0, active: true }];
+    const body = row.body;
+    const content = body?.kind === "message" && body.content?.appId === scope.appId ? body.content : undefined;
+    const target = body?.kind === "recall" && row.appId === scope.appId ? body.targetMessageId : content?.recall?.messageId;
+    const base = { scope: key, thread: message.threadId, actor: row.from, id: message.id, timestamp: message.timestamp };
+    if (identifier(target))
+        return [{ ...base, target, kind: "recall", emoji: "", revision: 0, active: true }];
+    const reaction = content?.reaction;
+    if (body?.contentKind === "text" && reaction?.version === 1 && identifier(reaction.messageId) && identifier(reaction.emojiId) && Number.isSafeInteger(reaction.revision) && (reaction.revision ?? 0) >= 1 && typeof reaction.active === "boolean")
+        return [{ ...base, target: reaction.messageId, kind: "reaction", emoji: reaction.emojiId, revision: reaction.revision, active: reaction.active }];
+    return [];
+}
+export function applyMessageControls(messages, controls) {
+    const grouped = new Map();
+    for (const event of controls) {
+        const list = grouped.get(event.target) ?? [];
+        list.push(event);
+        grouped.set(event.target, list);
+    }
+    return messages.map(message => {
+        const facts = grouped.get(message.id);
+        if (!facts?.length)
+            return message;
+        const row = message;
+        const recalled = message.recalled || facts.some(event => event.kind === "recall" && event.actor === row.from);
+        const reactionEvents = facts.filter(event => event.kind === "reaction").map(event => ({ id: event.id, messageId: event.target, threadId: event.thread, from: event.actor, emojiId: event.emoji, active: event.active, revision: event.revision, timestamp: event.timestamp }));
+        return { ...message, ...(recalled ? { recalled: true } : {}), ...(reactionEvents.length ? { reactionEvents: [...(row.reactionEvents ?? []), ...reactionEvents] } : {}) };
+    });
+}

package/lib/runtime/messageStore.d.ts

@@ -33,12 +33,14 @@ export declare const messageScopeKey: (scope: MessageScope) => string;
 /** Normalized browser cache. Data and coverage advance together in each commit.
  * Merge runs inside the write transaction against the latest cross-tab state. */
 export declare class IndexedDbMessageStore<T extends StoredMessage> {
+    private scope;
     private merge;
     private db;
     private rows;
     private legacy;
     private coverage;
     private accessRows;
+    private controls;
     private key;
     constructor(scope: MessageScope, merge: (previous: T | undefined, incoming: T) => T, options?: {
         indexedDB?: IDBFactory;
@@ -69,6 +71,9 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
         authoritative?: boolean;
         scopeVersion?: number;
     }): Promise<number>;
+    private rememberControls;
+    private controlPage;
+    private finishPage;
     windows(): Promise<CoverageRow[]>;
     scopeAccess(): Promise<MessageScopeAccess>;
     private scopedCoverage;

package/lib/runtime/messageStore.js

@@ -1,22 +1,28 @@
 import { Dexie } from "dexie";
+import { messageControls, controlKey, newerControl, applyMessageControls } from "./messageControls.js";
 export const messageScopeKey = (scope) => JSON.stringify([scope.appId, scope.accountId, scope.profileId, scope.teamId]);
 /** Normalized browser cache. Data and coverage advance together in each commit.
  * Merge runs inside the write transaction against the latest cross-tab state. */
 export class IndexedDbMessageStore {
+    scope;
     merge;
     db;
     rows;
     legacy;
     coverage;
     accessRows;
+    controls;
     key;
     constructor(scope, merge, options = {}) {
+        this.scope = scope;
         this.merge = merge;
         this.key = messageScopeKey(scope);
         this.db = new Dexie(options.name ?? "pmate-chat-messages", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
         this.db.version(1).stores({ messages: "[scope+thread+id],[scope+thread+time+id],[scope+thread],scope", coverage: "[scope+thread],scope" });
         this.db.version(2).stores({ legacyMessages: "[scope+thread+id],[scope+thread+time+id],[scope+thread],scope" });
         this.db.version(3).stores({ scopeAccess: "scope" });
+        this.db.version(4).stores({ messageControls: "[scope+thread+target+kind+actor+emoji],[scope+thread+target],[scope+thread],scope" });
+        this.controls = this.db.table("messageControls");
         this.accessRows = this.db.table("scopeAccess");
         this.legacy = this.db.table("legacyMessages");
         this.rows = this.db.table("messages");
@@ -27,14 +33,15 @@ export class IndexedDbMessageStore {
     async read(thread, limit = 100, before) {
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
             throw new Error("INVALID_MESSAGE_LIMIT");
-        return this.db.transaction("r", this.rows, this.coverage, this.accessRows, async () => {
+        const page = await this.db.transaction("r", this.rows, this.coverage, this.accessRows, this.controls, async () => {
             const access = await this.scopeAccess();
             if (access.revoked)
                 return { messages: [], hasEarlier: false, coverage: { complete: false, revoked: true, resetVersion: 0, scopeVersion: access.version } };
             const range = this.rows.where("[scope+thread+time+id]").between([this.key, thread, Dexie.minKey, Dexie.minKey], [this.key, thread, before?.timestamp ?? Dexie.maxKey, before?.id ?? Dexie.maxKey], true, !before);
             const records = await range.reverse().limit(limit + 1).toArray();
-            return { messages: records.slice(0, limit).reverse().map(row => row.value), hasEarlier: records.length > limit, coverage: this.scopedCoverage(await this.coverage.get([this.key, thread]), access) };
+            return this.controlPage({ messages: records.slice(0, limit).reverse().map(row => row.value), hasEarlier: records.length > limit, coverage: this.scopedCoverage(await this.coverage.get([this.key, thread]), access) });
         });
+        return this.finishPage(thread, page);
     }
     /** Migration records never claim coverage or overwrite authoritative rows. */
     async importLegacy(thread, messages) {
@@ -48,13 +55,19 @@ export class IndexedDbMessageStore {
             if (bytes > 1_048_576)
                 throw new Error("MESSAGE_BATCH_TOO_LARGE");
         }
-        return this.db.transaction("rw", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        return this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             const coverage = await this.coverage.get([this.key, thread]);
             if (access.revoked || coverage?.revoked)
                 throw new Error("MESSAGE_ACCESS_REVOKED");
             if (access.version > 0)
                 throw new Error("MESSAGE_PROJECTION_CHANGED");
+            const proofs = messages.map(message => messageControls(message, this.scope, this.key));
+            const controlsOnly = messages.length > 0 && proofs.every((events, index) => events.length > 0 && !messages[index].recalled && !messages[index].legacyDisplay?.recalled);
+            if (controlsOnly) {
+                await this.rememberControls(proofs.flat());
+                return 0;
+            }
             if ((coverage?.resetVersion ?? 0) > 0)
                 throw new Error("MESSAGE_PROJECTION_CHANGED");
             const ids = [...new Set(messages.map(message => message.id))], keys = ids.map(id => [this.key, thread, id]);
@@ -71,6 +84,7 @@ export class IndexedDbMessageStore {
                 if (JSON.stringify(old) !== JSON.stringify(value))
                     changed.set(message.id, { scope: this.key, thread, id: value.id, time: value.timestamp, value });
             }
+            await this.rememberControls([...changed.values()].flatMap(row => messageControls(row.value, this.scope, this.key)));
             if (changed.size)
                 await this.legacy.bulkPut([...changed.values()]);
             return changed.size;
@@ -80,7 +94,7 @@ export class IndexedDbMessageStore {
     async readFallback(thread, limit = 100, before) {
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
             throw new Error("INVALID_MESSAGE_LIMIT");
-        return this.db.transaction("r", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        const page = await this.db.transaction("r", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             const coverage = access.revoked ? { complete: false, revoked: true, resetVersion: 0, scopeVersion: access.version } : this.scopedCoverage(await this.coverage.get([this.key, thread]), access);
             if (coverage?.revoked)
@@ -88,8 +102,9 @@ export class IndexedDbMessageStore {
             const read = (table) => table.where("[scope+thread+time+id]").between([this.key, thread, Dexie.minKey, Dexie.minKey], [this.key, thread, before?.timestamp ?? Dexie.maxKey, before?.id ?? Dexie.maxKey], true, !before).reverse().limit(limit + 1).toArray();
             const [canonical, legacy] = await Promise.all([read(this.rows), read(this.legacy)]);
             const rows = [...new Map([...legacy, ...canonical].map(row => [row.id, row])).values()].sort((a, b) => a.time - b.time || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-            return { messages: rows.slice(-limit).map(row => row.value), hasEarlier: rows.length > limit, coverage };
+            return this.controlPage({ messages: rows.slice(-limit).map(row => row.value), hasEarlier: rows.length > limit, coverage });
         });
+        return this.finishPage(thread, page);
     }
     async commit(thread, messages, coverage, guard) {
         for (const message of messages)
@@ -97,7 +112,7 @@ export class IndexedDbMessageStore {
                 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.legacy, this.coverage, this.accessRows, async () => {
+        return this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             if ((guard?.scopeVersion ?? 0) !== access.version)
                 throw new Error("MESSAGE_SCOPE_CHANGED");
@@ -126,6 +141,7 @@ export class IndexedDbMessageStore {
                 if (!canonicalIds.has(message.id) || JSON.stringify(old) !== JSON.stringify(value))
                     changed.set(message.id, { scope: this.key, thread, id: value.id, time: value.timestamp, value });
             }
+            await this.rememberControls(messages.flatMap(message => messageControls(message, this.scope, this.key)));
             if (changed.size)
                 await this.rows.bulkPut([...changed.values()]);
             const replaced = legacy.flatMap(row => row ? [[this.key, thread, row.id]] : []);
@@ -139,6 +155,47 @@ export class IndexedDbMessageStore {
             return changed.size;
         });
     }
+    async rememberControls(events) {
+        const latest = new Map();
+        for (const event of events) {
+            const key = JSON.stringify(controlKey(event));
+            latest.set(key, newerControl(latest.get(key), event));
+        }
+        const values = [...latest.values()];
+        for (let offset = 0; offset < values.length; offset += 128) {
+            const batch = values.slice(offset, offset + 128), previous = await this.controls.bulkGet(batch.map(controlKey));
+            const changed = batch.filter((event, index) => newerControl(previous[index], event) !== previous[index]);
+            if (changed.length)
+                await this.controls.bulkPut(changed);
+        }
+    }
+    async controlPage(page) {
+        const events = page.messages.flatMap(message => messageControls(message, this.scope, this.key));
+        const old = events.length ? await this.controls.bulkGet(events.map(controlKey)) : [];
+        const pendingControls = events.filter((event, index) => newerControl(old[index], event) !== old[index]);
+        const facts = await this.controls.where("[scope+thread+target]").anyOf(page.messages.map(message => [this.key, message.threadId, message.id])).toArray();
+        const latest = new Map();
+        for (const event of [...facts, ...events]) {
+            const key = JSON.stringify(controlKey(event));
+            latest.set(key, newerControl(latest.get(key), event));
+        }
+        return { ...page, messages: applyMessageControls(page.messages, [...latest.values()]), pendingControls };
+    }
+    async finishPage(thread, page) {
+        const { pendingControls, ...result } = page;
+        // v3 caches migrate only source proofs from already-read pages, with no body
+        // rewrite. Steady reads remain a single read-only IndexedDB transaction.
+        if (pendingControls?.length)
+            await this.db.transaction("rw", this.controls, this.coverage, this.accessRows, async () => {
+                const access = await this.scopeAccess(), current = await this.coverage.get([this.key, thread]);
+                if (access.revoked || access.version !== (page.coverage?.scopeVersion ?? 0))
+                    throw new Error("MESSAGE_SCOPE_CHANGED");
+                if ((current?.resetVersion ?? 0) !== (page.coverage?.resetVersion ?? 0))
+                    throw new Error("MESSAGE_PROJECTION_CHANGED");
+                await this.rememberControls(pendingControls);
+            });
+        return result;
+    }
     async windows() {
         return this.db.transaction("r", this.coverage, this.accessRows, async () => {
             if ((await this.scopeAccess()).revoked)
@@ -156,6 +213,7 @@ export class IndexedDbMessageStore {
         return access.version ? { ...coverage, complete: coverage?.complete ?? false, scopeVersion: access.version } : coverage;
     }
     async clearScopeRows() {
+        await this.controls.where("scope").equals(this.key).delete();
         await this.rows.where("[scope+thread+id]").between([this.key, Dexie.minKey, Dexie.minKey], [this.key, Dexie.maxKey, Dexie.maxKey], true, true).delete();
         await this.legacy.where("[scope+thread+id]").between([this.key, Dexie.minKey, Dexie.minKey], [this.key, Dexie.maxKey, Dexie.maxKey], true, true).delete();
         await this.coverage.where("[scope+thread]").between([this.key, Dexie.minKey], [this.key, Dexie.maxKey], true, true).delete();
@@ -170,7 +228,7 @@ export class IndexedDbMessageStore {
             await this.accessRows.put(next);
             return next;
         });
-        await this.db.transaction("rw", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        await this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const current = await this.scopeAccess();
             if (current.version === access.version && current.revoked)
                 await this.clearScopeRows();
@@ -179,7 +237,7 @@ export class IndexedDbMessageStore {
     }
     /** A durable epoch prevents another tab's pre-reset request from restoring rows. */
     async resetThread(thread, revoked = false, scopeVersion = 0) {
-        return this.db.transaction("rw", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        return this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
             const access = await this.scopeAccess();
             if (access.version !== scopeVersion)
                 throw new Error("MESSAGE_SCOPE_CHANGED");
@@ -187,6 +245,8 @@ export class IndexedDbMessageStore {
                 throw new Error("MESSAGE_ACCESS_REVOKED");
             const old = await this.coverage.get([this.key, thread]);
             const resetVersion = (old?.resetVersion ?? 0) + 1;
+            if (revoked)
+                await this.controls.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.rows.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.legacy.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.coverage.put({ scope: this.key, thread, complete: false, resetVersion, revoked });
@@ -194,14 +254,16 @@ export class IndexedDbMessageStore {
         });
     }
     async removeThread(thread) {
-        await this.db.transaction("rw", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        await this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+            await this.controls.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.rows.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.legacy.where("[scope+thread]").equals([this.key, thread]).delete();
             await this.coverage.delete([this.key, thread]);
         });
     }
     async clear() {
-        await this.db.transaction("rw", this.rows, this.legacy, this.coverage, this.accessRows, async () => {
+        await this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+            await this.controls.where("scope").equals(this.key).delete();
             await this.legacy.where("scope").equals(this.key).delete();
             await this.rows.where("scope").equals(this.key).delete();
             await this.coverage.where("scope").equals(this.key).delete();

package/package.json

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