@pmate/chat-sdk 0.12.0-next.10 → 0.12.0-next.12

package/lib/runtime/chatSession.d.ts

@@ -1,7 +1,7 @@
 import { type MessageReadersQuery } from "./messageReaders.js";
 import { type MessageClientOptions, type MessageSnapshot } from "./messageClient.js";
 import { DurableChatSender } from "./durableSender.js";
-import { type ReadingClientOptions } from "./readingClient.js";
+import { ReadingClient, type ReadingClientOptions } from "./readingClient.js";
 import { ChatClient, type ChatClientOptions, type ChatConnectionState } from "./chatClient.js";
 import { unreadInConversation } from "./readIndex.js";
 import type { StoredMessage } from "./messageStore.js";
@@ -20,7 +20,7 @@ export type ChatThreadSnapshot<T> = {
     hasEarlier: boolean;
     resetVersion: number;
     complete: boolean;
-    unread: ReturnType<typeof unreadInConversation>;
+    unread: ReturnType<typeof unreadInConversation> | undefined;
 };
 export type ChatSummarySnapshot<T> = {
     threads: readonly {
@@ -29,8 +29,8 @@ export type ChatSummarySnapshot<T> = {
         unread: ChatThreadSnapshot<T>["unread"];
         outgoingCount: number;
     }[];
-    unreadMessageCount: number;
-    badgeCount: number;
+    unreadMessageCount: number | undefined;
+    badgeCount: number | undefined;
     connection: ChatConnectionState;
 };
 /** Owns all browser message clients. Hosts subscribe to stable thread snapshots. */
@@ -53,9 +53,18 @@ export declare class ChatSession<T extends StoredMessage> {
     private readingStarted;
     private closed;
     private starting?;
+    private initializing?;
     private closing?;
     constructor(options: ChatSessionOptions<T>);
     start(): Promise<void>;
+    /** Initializes local state and background reading sync without opening a
+     * second transport when the host already owns calls/presence. */
+    initialize(): Promise<void>;
+    getReadingSnapshot(): import("./readIndex.js").ReadIndexState | undefined;
+    subscribeReading(listener: () => void): () => void;
+    refreshReading(): void;
+    synchronizeReading(cursor?: string, profileId?: string): Promise<import("./readIndex.js").ReadIndexState>;
+    updateReading(transform: Parameters<ReadingClient["update"]>[0]): Promise<import("./readIndex.js").ReadIndexState>;
     private assertOpen;
     getMessages(threadId: string, options?: {
         limit?: number;

package/lib/runtime/chatSession.js

@@ -25,6 +25,7 @@ export class ChatSession {
     readingStarted = false;
     closed = false;
     starting;
+    initializing;
     closing;
     constructor(options) {
         this.options = options;
@@ -38,7 +39,7 @@ export class ChatSession {
         }
         this.messages = new MessageClient(options.messages);
         this.connection = options.sharedConnection ?? new ChatClient(options.connection);
-        this.reading = new ReadingClient({ ...options.reading, storageScope: JSON.stringify([scope.accountId, scope.teamId]) });
+        this.reading = new ReadingClient({ ...options.reading, storageScope: JSON.stringify([scope.accountId]), migrateLegacy: true });
         this.readers = new MessageReadersClient({ appId: scope.appId, profileId: scope.profileId, token: options.reading.sessionToken, scope, onError: options.onError, hubHttpUrl: options.reading.hubHttpUrl, fetch: options.reading.fetch });
         this.sender = new DurableChatSender(this.connection, scope, options.onError);
         this.catchUp = new WindowedTasks(1000, error => { if (!this.closed)
@@ -72,13 +73,28 @@ export class ChatSession {
     start() {
         this.assertOpen();
         return this.starting ??= (async () => {
+            await this.initialize();
+            this.assertOpen();
+            await this.connection.connect();
+        })().catch(error => { this.starting = undefined; throw error; });
+    }
+    /** Initializes local state and background reading sync without opening a
+     * second transport when the host already owns calls/presence. */
+    initialize() {
+        this.assertOpen();
+        return this.initializing ??= (async () => {
             await this.sender.initialize();
+            this.assertOpen();
             this.readingStarted = true;
             await this.reading.start();
             this.assertOpen();
-            await this.connection.connect();
-        })().catch(error => { this.starting = undefined; throw error; });
+        })().catch(error => { this.initializing = undefined; throw error; });
     }
+    getReadingSnapshot() { return this.reading.getSnapshot(); }
+    subscribeReading(listener) { this.assertOpen(); return this.reading.subscribe(listener); }
+    refreshReading() { this.assertOpen(); this.reading.refresh(); }
+    synchronizeReading(cursor, profileId) { this.assertOpen(); return this.reading.synchronize(cursor, profileId); }
+    updateReading(transform) { this.assertOpen(); return this.reading.update(transform); }
     assertOpen() { if (this.closed)
         throw new Error("CHAT_SESSION_CLOSED"); }
     async getMessages(threadId, options = {}) {
@@ -191,7 +207,7 @@ export class ChatSession {
         if (!snapshot) {
             const messages = this.messages.getSnapshot(threadId);
             const state = this.reading.getSnapshot();
-            snapshot = { messages: messages?.messages ?? [], hasEarlier: messages?.hasEarlier ?? false, resetVersion: messages?.resetVersion ?? 0, complete: messages?.complete ?? false, outgoing: this.sender.snapshot(threadId), unread: state?.threads.some(thread => (thread.conversationId ?? thread.id) === threadId) ? unreadInConversation(state, threadId) : { unreadMessageCount: 0, unreadMentionCount: 0, badgeCount: 0 } };
+            snapshot = { messages: messages?.messages ?? [], hasEarlier: messages?.hasEarlier ?? false, resetVersion: messages?.resetVersion ?? 0, complete: messages?.complete ?? false, outgoing: this.sender.snapshot(threadId), unread: state?.threads.some(thread => (thread.conversationId ?? thread.id) === threadId) ? unreadInConversation(state, threadId) : undefined };
             this.snapshots.set(threadId, snapshot);
         }
         return snapshot;
@@ -234,7 +250,9 @@ export class ChatSession {
             const snapshot = this.getSnapshot(threadId);
             return { threadId, lastMessage: snapshot.messages.at(-1), unread: snapshot.unread, outgoingCount: snapshot.outgoing.length };
         });
-        return { threads, unreadMessageCount: threads.reduce((sum, t) => sum + t.unread.unreadMessageCount, 0), badgeCount: threads.reduce((sum, t) => sum + t.unread.badgeCount, 0), connection: this.connectionState };
+        const state = this.reading.getSnapshot();
+        const known = Boolean(state && state.syncCursor !== "0" && threads.every(thread => thread.unread !== undefined));
+        return { threads, unreadMessageCount: known ? threads.reduce((sum, t) => sum + (t.unread?.unreadMessageCount ?? 0), 0) : undefined, badgeCount: known ? threads.reduce((sum, t) => sum + (t.unread?.badgeCount ?? 0), 0) : undefined, connection: this.connectionState };
     }
     publishGlobal() {
         const next = this.buildGlobal();

package/lib/runtime/readIndex.d.ts

@@ -85,12 +85,14 @@ export interface ReadIndexPersistence {
 /** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
 export declare class IndexedDbReadIndex implements ReadIndexPersistence {
     private storageScope?;
+    private migrateLegacy;
     private database;
     private profiles;
     private closed;
-    constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined);
+    constructor(factory?: IDBFactory, name?: string, storageScope?: string | undefined, migrateLegacy?: boolean);
     private transaction;
     private key;
+    private loadCurrent;
     load(appId: string, profileId: string): Promise<ReadIndexState | undefined>;
     update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
     close(): Promise<void>;

package/lib/runtime/readIndex.js

@@ -167,11 +167,13 @@ export function unreadInThread(state, threadId) {
 /** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
 export class IndexedDbReadIndex {
     storageScope;
+    migrateLegacy;
     database;
     profiles;
     closed = false;
-    constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index", storageScope) {
+    constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index", storageScope, migrateLegacy = false) {
         this.storageScope = storageScope;
+        this.migrateLegacy = migrateLegacy;
         if (!factory)
             throw new Error("READ_STORAGE_UNAVAILABLE");
         this.database = new Dexie(name, { indexedDB: factory, IDBKeyRange: globalThis.IDBKeyRange });
@@ -205,12 +207,31 @@ export class IndexedDbReadIndex {
         throw new Error("READ_STORAGE_UNAVAILABLE");
     }
     key(appId, profileId) { return this.storageScope === undefined ? [appId, profileId] : [appId, profileId, this.storageScope]; }
+    async loadCurrent(appId, profileId) {
+        const current = await this.profiles.get(this.key(appId, profileId));
+        if (current || !this.migrateLegacy || this.storageScope === undefined)
+            return current;
+        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)
+            return undefined;
+        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.profiles.delete([appId, profileId]);
+        return legacy;
+    }
     async load(appId, profileId) {
-        return this.transaction("r", () => this.profiles.get(this.key(appId, profileId)));
+        return this.transaction(this.migrateLegacy ? "rw" : "r", () => this.loadCurrent(appId, profileId));
     }
     async update(appId, profileId, transform) {
         return this.transaction("rw", async () => {
-            const previous = await this.profiles.get(this.key(appId, profileId));
+            const previous = await this.loadCurrent(appId, profileId);
             const next = transform(previous ?? createReadIndex(appId, profileId));
             if (next.appId !== appId || next.profileId !== profileId || next.schemaVersion !== 1)
                 throw new Error("READ_IDENTITY_MISMATCH");

package/lib/runtime/readingClient.d.ts

@@ -6,6 +6,7 @@ export type ReadingClientOptions = {
     hubHttpUrl: string;
     persistence?: ReadIndexPersistence;
     storageScope?: string;
+    migrateLegacy?: boolean;
     fetch?: typeof fetch;
     onError?: (error: unknown) => void;
     onRecovered?: () => void;

package/lib/runtime/readingClient.js

@@ -19,7 +19,7 @@ export class ReadingClient {
     generation = 0;
     constructor(options) {
         this.options = options;
-        const storage = options.persistence ?? (this.storage = new IndexedDbReadIndex(globalThis.indexedDB, "pmate-social-read-index", options.storageScope));
+        const storage = options.persistence ?? (this.storage = new IndexedDbReadIndex(globalThis.indexedDB, "pmate-social-read-index", options.storageScope, options.migrateLegacy));
         this.persistence = new BatchedReadIndex(storage);
         this.tasks = new WindowedTasks(1000, error => this.failed(error));
         this.sync = new ReadSyncClient({ ...options, persistence: this.persistence, onChange: state => this.publish(state) });

package/package.json

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