@pmate/chat-sdk 0.12.0-next.66 → 0.12.0-next.68

package/lib/messageView.js

@@ -4,7 +4,7 @@ function media(value) {
     if (typeof value !== "string" || !value)
         return undefined;
     try {
-        const url = new URL(value);
+        const url = new URL(value, "https://chat.invalid");
         return ["https:", "http:"].includes(url.protocol) && !url.username && !url.password ? value : undefined;
     }
     catch {

package/lib/runtime/chatError.js

@@ -20,7 +20,7 @@ export function asChatError(error) {
         : /CLOSED/.test(message) ? "closed"
             : status === 409 || /REVISION_CONFLICT|PROJECTION_CHANGED/.test(message) ? "conflict"
                 : /BACKPRESSURE|TOO_LARGE/.test(message) ? "busy"
-                    : status === 400 || /INVALID_|CONVERSATION_MISMATCH|NOT_OWNED/.test(message) ? "invalid-input"
+                    : status === 400 || /INVALID_|CONVERSATION_MISMATCH|CONVERSATION_UNKNOWN|NOT_OWNED/.test(message) ? "invalid-input"
                         : /QuotaExceeded|DatabaseClosed|UnknownError|AbortError/.test(value?.name ?? "") || /STORAGE_|DATABASE_|CACHE_WRITE/.test(message) ? "storage-unavailable" : "unavailable";
     return new ChatError(code, message, { cause: error, status });
 }

package/lib/runtime/chatSession.js

@@ -415,7 +415,19 @@ export class ChatSession {
         return (delivered ? this.sender.send(threadId, wire) : this.sender.enqueue(threadId, wire)).then(next => { if (this.withdrawn)
             throw new Error("CHAT_ACCESS_REVOKED"); return next; });
     }
-    getConversation(target) { this.assertOpen(); return this.conversations.create(target); }
+    async getConversation(target) {
+        this.assertOpen();
+        try {
+            return await this.conversations.create(target);
+        }
+        catch (error) {
+            if (error?.message !== "CHAT_ACCESS_REVOKED")
+                throw error;
+            await this.messages.authorizeScope();
+            this.assertOpen();
+            return this.conversations.create(target);
+        }
+    }
     async sendContent(target, input, delivered) {
         let thread = typeof target === "string" ? await this.resolveConversation(target) : target;
         validateConversation(this.options.messages.scope, thread);
@@ -444,21 +456,32 @@ export class ChatSession {
     /** Validated target identity survives content redaction; no roster is exposed. */
     getConversationTarget(threadId) {
         const scope = this.options.messages.scope;
-        const group = this.getSnapshot(threadId).group;
+        const snapshot = this.getSnapshot(threadId), group = snapshot.group;
         if (group)
             return { id: threadId, kind: "group", targetId: group.groupId, teamId: scope.teamId };
-        for (const value of this.getSnapshot(threadId).messages) {
-            const row = value;
+        const infer = (row) => {
             const kind = row.threadKind ?? row.body?.threadKind;
             if ((kind !== "group" && kind !== "dm") || !row.to || !row.from)
-                continue;
+                return undefined;
             const thread = { id: threadId, kind, targetId: kind === "group" || row.from === scope.profileId ? row.to : row.from, teamId: scope.teamId };
-            // A stored row is only a hint; validate the canonical scoped identifier.
             try {
                 validateConversation(scope, thread);
                 return thread;
             }
-            catch { }
+            catch {
+                return undefined;
+            }
+        };
+        for (const value of snapshot.messages) {
+            const thread = infer(value);
+            if (thread)
+                return thread;
+        }
+        // Older integrations may have a durable send but no registered target or indexed history yet.
+        for (const value of snapshot.outgoing) {
+            const thread = infer(value.message);
+            if (thread)
+                return thread;
         }
         return undefined;
     }

package/lib/runtime/conversationDirectory.d.ts

@@ -30,6 +30,7 @@ export declare class ConversationDirectory {
     put(thread: ChatConversation): Promise<ChatConversation>;
     private persist;
     get(id: string): Promise<ChatConversation | undefined>;
+    private lookup;
     private flush;
     retire(version: number): Promise<void>;
     close(): Promise<void>;

package/lib/runtime/conversationDirectory.js

@@ -19,7 +19,7 @@ export class ConversationDirectory {
     constructor(scope, access) {
         this.scope = scope;
         this.access = access;
-        this.cache = new IndexedDbResponseCache(`conversations:${messageScopeKey(scope)}`, { access: () => this.authorize(), entries: 256, recordBytes: 4096 });
+        this.cache = new IndexedDbResponseCache(`conversations:${messageScopeKey(scope)}`, { access: () => this.authorize(), entries: 256, recordBytes: 4096, retainAll: true });
     }
     authorize() { return this.authority ??= this.access().finally(() => { this.authority = undefined; }); }
     assertOpen() { if (this.retired)
@@ -56,18 +56,18 @@ export class ConversationDirectory {
         this.assertOpen();
         validateConversation(this.scope, thread);
         const value = { id: thread.id, kind: thread.kind, targetId: thread.targetId, teamId: this.scope.teamId };
-        const previous = await this.get(thread.id);
+        const row = await this.lookup(thread.id), previous = row.value;
         if (previous) {
             if (previous.kind !== value.kind || previous.targetId !== value.targetId)
                 throw new Error("MESSAGE_CONVERSATION_MISMATCH");
             return previous;
         }
-        const row = await this.cache.read(thread.id);
         await this.cache.write(thread.id, value, row.epoch);
         this.assertOpen();
         return this.remember(value);
     }
-    async get(id) {
+    async get(id) { return (await this.lookup(id)).value; }
+    async lookup(id) {
         this.assertOpen();
         const authority = await this.authorize();
         this.assertOpen();
@@ -78,7 +78,7 @@ export class ConversationDirectory {
         this.version = authority.version;
         const known = this.memory.get(id);
         if (known)
-            return this.remember(known);
+            return { value: this.remember(known), epoch: 0 };
         const existing = this.pending.get(id);
         if (existing)
             return existing;
@@ -98,13 +98,13 @@ export class ConversationDirectory {
             const rows = await this.cache.readMany(batch.map(item => item.id));
             this.assertOpen();
             for (const item of batch) {
-                const value = rows.get(item.id)?.cached?.value;
+                const row = rows.get(item.id), value = row.cached?.value;
                 if (value) {
                     if (value.id !== item.id)
                         throw new Error("MESSAGE_CONVERSATION_MISMATCH");
                     validateConversation(this.scope, value);
                 }
-                item.resolve(value ? this.remember(value) : undefined);
+                item.resolve({ value: value ? this.remember(value) : undefined, epoch: row.epoch });
             }
         }
         catch (error) {

package/lib/runtime/createChat.js

@@ -34,7 +34,7 @@ export function createChat(options) {
         },
         loadGroup: (groupId, signal) => reader.group({ groupId, teamId }, signal),
         activeThreadId: options.threadId,
-        messages: { scope: { appId, accountId, profileId, teamId }, transport: { load: (thread, signal) => page(thread, signal), changes: (thread, after, signal) => page(thread, signal, { after }), older: (thread, before, signal) => page(thread, signal, { before }) }, onError },
+        messages: { scope: { appId, accountId, profileId, teamId }, transport: { authorizeScope: async (signal) => { await reader.contacts(teamId, signal); }, load: (thread, signal) => page(thread, signal), changes: (thread, after, signal) => page(thread, signal, { after }), older: (thread, before, signal) => page(thread, signal, { before }) }, onError },
         reading: { appId, profileId, sessionToken: token, hubHttpUrl: http, fetch: options.fetch, onError },
         connection: { appId, profileId, teamId, hubUrl: ws, clientInstanceId: options.clientInstanceId, fetchImpl: options.fetch,
             session: { token, identity: { accountId, app: appId, profileId } }, onNotification: options.onNotification, onReach: options.onReach },

package/lib/runtime/messageClient.d.ts

@@ -7,6 +7,8 @@ export type MessagePage<T> = {
     resetRequired?: boolean;
 };
 export type MessageTransport<T> = {
+    /** Optional team-scoped authorization for fresh instances recovering a revoked cache. */
+    authorizeScope?: (signal: AbortSignal) => Promise<void>;
     /** Authoritative history. Must include control state needed to merge old rows. */
     load: (threadId: string, signal: AbortSignal) => Promise<MessagePage<T>>;
     changes?: (threadId: string, after: string, signal: AbortSignal) => Promise<MessagePage<T>>;
@@ -72,6 +74,9 @@ export declare class MessageClient<T extends StoredMessage> {
         version: number;
         allowed: boolean;
     }>;
+    private authorizingScope?;
+    /** Recovery belongs to the SDK; withdrawn instances never regain authority. */
+    authorizeScope(): Promise<void>;
     getSnapshot(thread: string): MessageSnapshot<T> | undefined;
     /** Exact authoritative row only; migration-only rows never prove delivery. */
     cachedMessage(thread: string, id: string): Promise<T>;

package/lib/runtime/messageClient.js

@@ -100,6 +100,38 @@ export class MessageClient {
         const current = await this.storage.scopeAccess();
         return { version: current.version, allowed: !this.scopeDenied && !current.revoked && current.version === this.scopeVersion };
     }
+    authorizingScope;
+    /** Recovery belongs to the SDK; withdrawn instances never regain authority. */
+    authorizeScope() {
+        return this.authorizingScope ??= (async () => {
+            await this.ensureScope();
+            if (this.closed || this.closing || this.scopeDenied)
+                throw accessRevoked();
+            const access = await this.scopeAccess();
+            if (access.allowed)
+                return;
+            if (access.version !== this.scopeVersion) {
+                this.denyScope();
+                throw accessRevoked();
+            }
+            if (!this.options.transport.authorizeScope)
+                throw accessRevoked();
+            try {
+                await this.options.transport.authorizeScope(this.abort.signal);
+                if (this.closed || this.closing || this.scopeDenied)
+                    throw accessRevoked();
+                await this.storage.authorizeScope(this.scopeVersion);
+                if (this.closed || this.closing || this.scopeDenied)
+                    throw accessRevoked();
+                this.scopeAllowed = true;
+            }
+            catch (error) {
+                if ([401, 403].includes(error?.status ?? 0) || String(error).includes("MESSAGE_SCOPE_CHANGED"))
+                    this.denyScope();
+                throw error;
+            }
+        })().finally(() => { this.authorizingScope = undefined; });
+    }
     getSnapshot(thread) { return this.watches.get(thread)?.snapshot; }
     /** Exact authoritative row only; migration-only rows never prove delivery. */
     async cachedMessage(thread, id) {

package/lib/runtime/messageStore.d.ts

@@ -82,6 +82,8 @@ export declare class IndexedDbMessageStore<T extends StoredMessage> {
     private finishPage;
     windows(): Promise<CoverageRow[]>;
     scopeAccess(): Promise<MessageScopeAccess>;
+    /** Only fresh, server-confirmed authorization may lift this durable tombstone. */
+    authorizeScope(expectedVersion: number): Promise<void>;
     private scopedCoverage;
     private clearScopeRows;
     /** Persist the denial first; failed cleanup must never make cached rows readable. */

package/lib/runtime/messageStore.js

@@ -230,6 +230,18 @@ export class IndexedDbMessageStore {
             throw new Error("INVALID_MESSAGE_SCOPE_ACCESS");
         return access;
     }
+    /** Only fresh, server-confirmed authorization may lift this durable tombstone. */
+    async authorizeScope(expectedVersion) {
+        await this.db.transaction("rw", [this.rows, this.legacy, this.coverage, this.accessRows, this.controls], async () => {
+            const access = await this.scopeAccess();
+            if (access.version !== expectedVersion)
+                throw new Error("MESSAGE_SCOPE_CHANGED");
+            if (!access.revoked)
+                return;
+            await this.clearScopeRows();
+            await this.accessRows.put({ ...access, revoked: false });
+        });
+    }
     scopedCoverage(coverage, access) {
         return access.version ? { ...coverage, complete: coverage?.complete ?? false, scopeVersion: access.version } : coverage;
     }

package/lib/runtime/responseCache.d.ts

@@ -8,6 +8,8 @@ export type ResponseCacheOptions<T> = {
     indexedDB?: IDBFactory;
     name?: string;
     access?: ResponseCacheAccess;
+    /** Immutable identity metadata must survive ordinary response-window eviction. */
+    retainAll?: boolean;
     recordBytes?: number;
     entries?: number;
     batchRecords?: number;

package/lib/runtime/responseCache.js

@@ -59,7 +59,7 @@ export class IndexedDbResponseCache {
                     throw new Error("RESPONSE_CACHE_SCOPE_CHANGED");
                 if (access.version > version) {
                     await this.epochs.put({ scope: this.scope, epoch: (current?.epoch ?? 0) + 1, accessVersion: access.version });
-                    await this.rows.where("scope").equals(this.scope).delete();
+                    await this.rows.where("[scope+key]").between([this.scope, Dexie.minKey], [this.scope, Dexie.maxKey], true, true).delete();
                 }
             });
         if (!access.allowed)
@@ -114,7 +114,7 @@ export class IndexedDbResponseCache {
             if ((current?.accessVersion ?? 0) >= version)
                 return;
             await this.epochs.put({ scope: this.scope, epoch: (current?.epoch ?? 0) + 1, accessVersion: version });
-            await this.rows.where("scope").equals(this.scope).delete();
+            await this.rows.where("[scope+key]").between([this.scope, Dexie.minKey], [this.scope, Dexie.maxKey], true, true).delete();
         });
         this.invalidations.add(task);
         return task.finally(() => this.invalidations.delete(task));
@@ -127,7 +127,7 @@ export class IndexedDbResponseCache {
                 const current = await this.epochs.get(this.scope);
                 const epoch = (current?.epoch ?? 0) + 1;
                 await this.epochs.put({ scope: this.scope, epoch, accessVersion: current?.accessVersion });
-                await this.rows.where("scope").equals(this.scope).delete();
+                await this.rows.where("[scope+key]").between([this.scope, Dexie.minKey], [this.scope, Dexie.maxKey], true, true).delete();
             });
         })();
         this.invalidations.add(task);
@@ -178,14 +178,16 @@ export class IndexedDbResponseCache {
                         }
                         if (unique.size) {
                             await this.rows.bulkPut([...unique.values()]);
-                            const stored = await this.rows.where("scope").equals(this.scope).toArray();
-                            stored.sort((a, b) => b.time - a.time || a.key.localeCompare(b.key));
-                            let bytes = 0;
-                            const evicted = [];
-                            stored.forEach((row, index) => { bytes += row.bytes; if (index >= (this.options.entries ?? 256) || bytes > 1048576)
-                                evicted.push([this.scope, row.key]); });
-                            if (evicted.length)
-                                await this.rows.bulkDelete(evicted);
+                            if (!this.options.retainAll) {
+                                const stored = await this.rows.where("scope").equals(this.scope).toArray();
+                                stored.sort((a, b) => b.time - a.time || a.key.localeCompare(b.key));
+                                let bytes = 0;
+                                const evicted = [];
+                                stored.forEach((row, index) => { bytes += row.bytes; if (index >= (this.options.entries ?? 256) || bytes > 1048576)
+                                    evicted.push([this.scope, row.key]); });
+                                if (evicted.length)
+                                    await this.rows.bulkDelete(evicted);
+                            }
                         }
                         return { accepted, changed };
                     });

package/lib/runtime/socialReadClient.d.ts

@@ -46,7 +46,7 @@ export declare class SocialReadClient {
     private readonly options;
     constructor(options: SocialReadClientOptions);
     /** Without teamId includes current Teams and unassigned contact metadata for migration. */
-    contacts(teamId?: string): Promise<ChatReaderContact[]>;
+    contacts(teamId?: string, signal?: AbortSignal): Promise<ChatReaderContact[]>;
     unread(teamId?: string): Promise<ChatReaderUnread[]>;
     messages(input: {
         threadId: string;

package/lib/runtime/socialReadClient.js

@@ -14,8 +14,8 @@ export class SocialReadClient {
     options;
     constructor(options) { this.options = { ...options }; }
     /** Without teamId includes current Teams and unassigned contact metadata for migration. */
-    contacts(teamId) {
-        return this.list("contacts", this.teamQuery(teamId));
+    contacts(teamId, signal) {
+        return this.list("contacts", this.teamQuery(teamId), signal);
     }
     unread(teamId) {
         return this.list("unread", this.teamQuery(teamId));
@@ -58,8 +58,8 @@ export class SocialReadClient {
         if (this.options.appId === "pmate:merry" && !teamId)
             throw new SocialReadError(400, "TEAM_ID_REQUIRED");
     }
-    async list(action, query) {
-        const value = await this.request(action, query);
+    async list(action, query, signal) {
+        const value = await this.request(action, query, signal);
         if (!Array.isArray(value))
             throw new SocialReadError(502, "INVALID_SOCIAL_READ_RESPONSE");
         return value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.66",
+  "version": "0.12.0-next.68",
   "description": "Local-first chat SDK, message subscriptions, reading state, and shared chat UI primitives",
   "type": "module",
   "main": "./lib/index.js",