@pmate/chat-sdk 0.11.4 → 0.11.6

package/lib/mentions/model.d.ts

@@ -4,6 +4,7 @@ export type MentionCandidate = {
     name: string;
     avatar?: string;
     description?: string;
+    aliases?: string[];
 };
 /** UTF-16 offsets [start, end) in the sent text, including @. */
 export type ChatMention = {

package/lib/mentions/model.js

@@ -12,7 +12,7 @@ export function filterMentionCandidates(candidates, query) {
         if (seen.has(candidate.id))
             return false;
         seen.add(candidate.id);
-        return candidate.name.toLocaleLowerCase().includes(query.toLocaleLowerCase());
+        return [candidate.name, ...(candidate.aliases ?? [])].some(name => name.toLocaleLowerCase().includes(query.toLocaleLowerCase()));
     });
 }
 /** Rebase untouched mentions; editing any part of a mention removes its identity. */

package/lib/runtime/readIndex.d.ts

@@ -82,14 +82,12 @@ export interface ReadIndexPersistence {
     /** Transform and persist atomically; UI publishes only the committed result. */
     update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;
 }
-/** IndexedDB transactions serialize tabs, and retain offline outbox across process restarts. */
+/** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
 export declare class IndexedDbReadIndex implements ReadIndexPersistence {
-    private factory;
-    private name;
-    private database?;
+    private database;
+    private profiles;
     private closed;
     constructor(factory?: IDBFactory, name?: string);
-    private getDatabase;
     private transaction;
     load(appId: string, profileId: string): Promise<ReadIndexState | undefined>;
     update(appId: string, profileId: string, transform: (current: ReadIndexState) => ReadIndexState): Promise<ReadIndexState>;

package/lib/runtime/readIndex.js

@@ -1,3 +1,4 @@
+import { Dexie } from "dexie";
 import { isValidChatTeamId } from "./thread.js";
 export class ReadSyncGap extends Error {
     cursor;
@@ -162,107 +163,57 @@ export function unreadInThread(state, threadId) {
     const unreadMentionCount = messages.filter(message => message.mentions.includes(state.profileId)).length;
     return { unreadMessageCount, unreadMentionCount, badgeCount: thread.kind === "group" ? unreadMentionCount : unreadMessageCount };
 }
-/** IndexedDB transactions serialize tabs, and retain offline outbox across process restarts. */
+/** Dexie preserves the legacy database/store and outbound [appId, profileId] keys. */
 export class IndexedDbReadIndex {
-    factory;
-    name;
     database;
+    profiles;
     closed = false;
     constructor(factory = globalThis.indexedDB, name = "pmate-social-read-index") {
-        this.factory = factory;
-        this.name = name;
         if (!factory)
             throw new Error("READ_STORAGE_UNAVAILABLE");
-    }
-    getDatabase() {
-        if (this.closed)
-            return Promise.reject(new Error("READ_STORAGE_CLOSED"));
-        if (this.database)
-            return this.database;
-        let abandoned = false;
-        const pending = new Promise((resolve, reject) => {
-            const request = this.factory.open(this.name);
-            request.onupgradeneeded = () => { if (!request.result.objectStoreNames.contains("profiles"))
-                request.result.createObjectStore("profiles"); };
-            request.onsuccess = () => {
-                const db = request.result;
-                if (abandoned || this.closed) {
-                    db.close();
-                    reject(new Error("READ_STORAGE_CLOSED"));
-                    return;
-                }
-                const invalidate = () => { if (this.database === pending)
-                    this.database = undefined; };
-                db.onversionchange = () => { db.close(); invalidate(); };
-                db.onclose = invalidate;
-                resolve(db);
-            };
-            request.onerror = () => { abandoned = true; reject(request.error); };
-            request.onblocked = () => { abandoned = true; reject(new Error("READ_STORAGE_BLOCKED")); };
-        });
-        this.database = pending;
-        void pending.catch(() => { if (this.database === pending)
-            this.database = undefined; });
-        return pending;
+        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.profiles = this.database.table("profiles");
+        this.database.on("versionchange", () => { this.database.close({ disableAutoOpen: false }); return false; });
     }
     async transaction(mode, execute) {
         for (let attempt = 0; attempt < 2; attempt++) {
-            const pending = this.getDatabase(), db = await pending;
             if (this.closed)
                 throw new Error("READ_STORAGE_CLOSED");
-            let transaction;
+            let started = false;
             try {
-                transaction = db.transaction("profiles", mode);
+                return await this.database.transaction(mode, this.profiles, async () => {
+                    if (this.closed)
+                        throw new Error("READ_STORAGE_CLOSED");
+                    started = true;
+                    return execute();
+                });
             }
             catch (error) {
-                if (attempt || error?.name !== "InvalidStateError")
+                if (this.closed)
+                    throw new Error("READ_STORAGE_CLOSED");
+                // Retry only failed transaction creation, never a transform or write.
+                if (attempt || started || this.closed || error?.name !== "InvalidStateError")
                     throw error;
-                // Retry only transaction creation: no transform or write has run yet.
-                db.close();
-                if (this.database === pending)
-                    this.database = undefined;
-                continue;
+                this.database.close({ disableAutoOpen: false });
             }
-            // Start requests synchronously after creation, including on WebKit.
-            return execute(transaction);
         }
         throw new Error("READ_STORAGE_UNAVAILABLE");
     }
     async load(appId, profileId) {
-        return this.transaction("readonly", transaction => new Promise((resolve, reject) => {
-            const request = transaction.objectStore("profiles").get([appId, profileId]);
-            transaction.oncomplete = () => resolve(request.result);
-            transaction.onerror = () => reject(transaction.error);
-            transaction.onabort = () => reject(transaction.error ?? new Error("READ_STORAGE_ABORTED"));
-        }));
+        return this.transaction("r", () => this.profiles.get([appId, profileId]));
     }
     async update(appId, profileId, transform) {
-        return this.transaction("readwrite", transaction => new Promise((resolve, reject) => {
-            const store = transaction.objectStore("profiles");
-            const request = store.get([appId, profileId]);
-            let next, failure;
-            request.onsuccess = () => {
-                try {
-                    next = transform(request.result ?? createReadIndex(appId, profileId));
-                    if (next.appId !== appId || next.profileId !== profileId || next.schemaVersion !== 1)
-                        throw new Error("READ_IDENTITY_MISMATCH");
-                    store.put(next, [appId, profileId]);
-                }
-                catch (error) {
-                    failure = error;
-                    transaction.abort();
-                }
-            };
-            transaction.oncomplete = () => resolve(next);
-            transaction.onerror = () => reject(failure ?? transaction.error);
-            transaction.onabort = () => reject(failure ?? transaction.error ?? new Error("READ_STORAGE_ABORTED"));
-        }));
+        return this.transaction("rw", async () => {
+            const next = transform(await this.profiles.get([appId, profileId]) ?? createReadIndex(appId, profileId));
+            if (next.appId !== appId || next.profileId !== profileId || next.schemaVersion !== 1)
+                throw new Error("READ_IDENTITY_MISMATCH");
+            await this.profiles.put(next, [appId, profileId]);
+            return next;
+        });
     }
-    async close() { this.closed = true; const pending = this.database; this.database = undefined; if (pending) {
-        const db = await pending.catch(error => { if (error?.message !== "READ_STORAGE_CLOSED")
-            throw error; return undefined; });
-        db?.close();
-    } }
+    async close() { this.closed = true; this.database.close(); }
 }
 export function sourcesInConversation(state, conversationId) {
     return state.threads.filter(thread => (thread.conversationId ?? thread.id) === conversationId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.11.4",
+  "version": "0.11.6",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",
@@ -33,6 +33,7 @@
     "@emoji-mart/react": "^1.1.1",
     "@msgpack/msgpack": "^3.1.2",
     "@noble/hashes": "^2.4.0",
+    "dexie": "^4.0.4",
     "jotai": "^2.16.1"
   },
   "peerDependencies": {