@pmate/chat-sdk 0.12.0-next.38 → 0.12.0-next.39

package/lib/runtime/chatSession.js

@@ -67,7 +67,7 @@ export class ChatSession {
                     return options.connection.onReach(event);
                 throw new Error("REACH_HANDLER_UNAVAILABLE");
             } });
-        this.reading = new ReadingClient({ ...options.reading, teamId: scope.teamId, storageScope: JSON.stringify([scope.accountId]), migrateLegacy: true });
+        this.reading = new ReadingClient({ ...options.reading, teamId: scope.teamId, storageScope: JSON.stringify([scope.accountId]), migrateLegacy: true, metadataOnly: true });
         this.readers = new MessageReadersClient({ appId: scope.appId, profileId: scope.profileId, token: options.reading.sessionToken, scope, access: () => this.messages.scopeAccess(), onError: options.onError, hubHttpUrl: options.reading.hubHttpUrl, fetch: options.reading.fetch });
         this.sender = new DurableChatSender(this.connection, scope, options.onError, { access: () => this.messages.scopeAccess() });
         this.catchUp = new WindowedTasks(1000, error => { if (!this.closed)

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;
@@ -98,6 +105,7 @@ export interface ReadIndexPersistence {
 export declare class IndexedDbReadIndex implements ReadIndexPersistence {
     private storageScope?;
     private migrateLegacy;
+    private metadataOnly;
     private database;
     private profiles;
     private threadRows;
@@ -106,11 +114,12 @@ export declare class IndexedDbReadIndex implements ReadIndexPersistence {
     private normalizedStates;
     private versions;
     private closed;
-    constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined, migrateLegacy?: boolean);
+    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;

package/lib/runtime/readIndex.js

@@ -1,6 +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) {
@@ -159,7 +177,7 @@ export function unreadInThread(state, threadId, hidden) {
     if (!thread)
         throw new Error("UNKNOWN_READ_THREAD");
     const explicit = new Set(thread.explicitReadMessageIds);
-    const messages = thread.messages.filter(message => !message.recalled && !hidden?.get(message.id)?.has(message.from) && !isReadingControl(message.payload, state.appId) && 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;
@@ -189,6 +207,7 @@ export function removeReadTeam(state, teamId, knownThreadIds = []) {
 export class IndexedDbReadIndex {
     storageScope;
     migrateLegacy;
+    metadataOnly;
     database;
     profiles;
     threadRows;
@@ -197,9 +216,10 @@ export class IndexedDbReadIndex {
     normalizedStates = new WeakSet();
     versions;
     closed = false;
-    constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index", storageScope, migrateLegacy = false) {
+    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 });
@@ -274,13 +294,23 @@ export class IndexedDbReadIndex {
         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) {
-            if (this.migrateLegacy)
-                await this.persist(appId, profileId, undefined, current, true);
-            return 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;
@@ -291,7 +321,8 @@ export class IndexedDbReadIndex {
         const legacyRow = await this.profiles.get([appId, profileId]);
         if (!legacyRow)
             return undefined;
-        const legacy = await this.hydrate(legacyRow, [appId, profileId]);
+        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 };
@@ -380,10 +411,10 @@ export class IndexedDbReadIndex {
         this.normalizedStates.add(next);
     }
     async load(appId, profileId) {
-        return this.transaction(this.migrateLegacy ? "rw" : "r", () => this.loadCurrent(appId, profileId));
+        return this.transaction(this.migrateLegacy || this.metadataOnly ? "rw" : "r", () => this.loadCurrent(appId, profileId));
     }
     async loadVersioned(appId, profileId) {
-        return this.transaction(this.migrateLegacy ? "rw" : "r", async () => ({
+        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 ?? {},
         }));
     }
@@ -407,7 +438,8 @@ export class IndexedDbReadIndex {
     async update(appId, profileId, transform) {
         return this.transaction("rw", async () => {
             const previous = await this.loadCurrent(appId, profileId);
-            const next = transform(previous ?? createReadIndex(appId, profileId), (await this.versions.get(this.key(appId, profileId)))?.teams ?? {});
+            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");
             await this.persist(appId, profileId, previous, next);

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;

package/lib/runtime/readSync.js

@@ -1,4 +1,4 @@
-import { assertReadIndexVersions, applyReadChange, ReadSyncGap, createReadIndex, installReadSnapshot } from "./readIndex.js";
+import { readingMetadata, assertReadIndexVersions, applyReadChange, ReadSyncGap, createReadIndex, installReadSnapshot } from "./readIndex.js";
 /** Keeps local operations until an authoritative projection covers them. */
 export class ReadSyncClient {
     options;
@@ -9,8 +9,11 @@ export class ReadSyncClient {
         this.options = options;
     }
     async loadLocal() {
-        return await this.options.persistence.load(this.options.appId, this.options.profileId)
-            ?? createReadIndex(this.options.appId, this.options.profileId);
+        const { appId, profileId, persistence, metadataOnly } = this.options;
+        const state = await persistence.load(appId, profileId) ?? createReadIndex(appId, profileId);
+        if (!metadataOnly || readingMetadata(state) === state)
+            return state;
+        return persistence.update(appId, profileId, readingMetadata);
     }
     stop() { this.controller.abort(); }
     synchronize() {
@@ -84,7 +87,7 @@ export class ReadSyncClient {
                         throw new Error("READ_SYNC_STOPPED");
                     const next = await persistence.update(appId, profileId, (state, currentVersions) => {
                         assertReadIndexVersions(versions, currentVersions);
-                        const applied = delta.changes.reduce(applyReadChange, state);
+                        const applied = delta.changes.reduce((current, change) => applyReadChange(current, this.options.metadataOnly ? { ...change, thread: readingMetadata({ appId, threads: [change.thread] }).threads[0] } : change), state);
                         if (applied.syncCursor !== delta.syncCursor)
                             throw new ReadSyncGap(applied.syncCursor);
                         return applied;
@@ -107,7 +110,7 @@ export class ReadSyncClient {
         // Merge into the latest transaction, including reads made while HTTP was pending.
         const next = await persistence.update(appId, profileId, (state, currentVersions) => {
             assertReadIndexVersions(versions, currentVersions);
-            return installReadSnapshot(state, snapshot);
+            return installReadSnapshot(state, this.options.metadataOnly ? readingMetadata(snapshot) : snapshot);
         });
         if (!next.pending.length)
             this.readAfter = 0;

package/lib/runtime/readingClient.d.ts

@@ -6,6 +6,7 @@ export type ReadingClientOptions = {
     sessionToken: string;
     hubHttpUrl: string;
     teamId?: string;
+    metadataOnly?: boolean;
     persistence?: ReadIndexPersistence;
     storageScope?: string;
     migrateLegacy?: boolean;

package/lib/runtime/readingClient.js

@@ -3,7 +3,7 @@ import { isOffline, isOfflineNetworkFailure } from "./connectivity.js";
 import { recordConversationRead } from "./conversationRead.js";
 import { BatchedReadIndex } from "./batchedReadIndex.js";
 import { WindowedTasks } from "./coalescer.js";
-import { IndexedDbReadIndex, recordReadIntent, assertReadIndexVersions } from "./readIndex.js";
+import { IndexedDbReadIndex, readingMetadata, recordReadIntent, assertReadIndexVersions } from "./readIndex.js";
 import { ReadSyncClient } from "./readSync.js";
 /** Owns durable local reads, network coalescing, retries and state notifications.
  * Hosts report actual visibility; loading or subscribing never marks messages read. */
@@ -30,7 +30,7 @@ export class ReadingClient {
         this.options = options;
         if (options.teamId !== undefined && !isValidChatTeamId(options.teamId))
             throw new Error("INVALID_READ_TEAM");
-        const storage = options.persistence ?? (this.storage = new IndexedDbReadIndex(globalThis.indexedDB, "pmate-social-read-index", options.storageScope, options.migrateLegacy));
+        const storage = options.persistence ?? (this.storage = new IndexedDbReadIndex(globalThis.indexedDB, "pmate-social-read-index", options.storageScope, options.migrateLegacy, options.metadataOnly));
         this.backing = storage;
         this.persistence = new BatchedReadIndex(storage);
         this.tasks = new WindowedTasks(1000, error => this.failed(error));
@@ -112,7 +112,8 @@ export class ReadingClient {
             const expected = await versions;
             const next = await this.persistence.update(this.options.appId, this.options.profileId, (state, currentVersions) => {
                 assertReadIndexVersions(expected, currentVersions, teamId);
-                return transform(state);
+                const next = transform(state);
+                return this.options.metadataOnly ? readingMetadata(next) : next;
             });
             if (!this.closed) {
                 this.publish(next);

package/package.json

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