@pmate/chat-sdk 0.12.0-next.53 → 0.12.0-next.55

package/lib/runtime/chatSession.d.ts

@@ -17,6 +17,7 @@ export type ChatSessionOptions<T extends StoredMessage> = {
     sharedConnection?: ChatClient;
     activeThreadId?: string;
     uploadVoice?: DurableSenderOptions["uploadVoice"];
+    reconcileOutgoing?: DurableSenderOptions["reconcile"];
     reading: ReadingClientOptions;
     decode: (message: ChatRuntimeMessage) => T | undefined;
     readingCandidate?: (message: T) => ReadingCandidate | undefined;

package/lib/runtime/chatSession.js

@@ -69,7 +69,21 @@ export class ChatSession {
             } });
         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(), uploadVoice: options.uploadVoice });
+        this.sender = new DurableChatSender(this.connection, scope, options.onError, { access: () => this.messages.scopeAccess(), uploadVoice: options.uploadVoice, reconcile: async (record, signal) => {
+                const cached = await this.messages.cachedMessage(record.threadId, record.message.hash);
+                if (cached && cached.from === scope.profileId && cached.to === record.message.to)
+                    return true;
+                if (!options.reconcileOutgoing)
+                    throw new Error("OUTBOX_RECONCILIATION_UNAVAILABLE");
+                try {
+                    return await options.reconcileOutgoing(record, signal);
+                }
+                catch (error) {
+                    if ([401, 403].includes(error?.status ?? 0))
+                        await this.messages.revoke(record.threadId);
+                    throw error;
+                }
+            } });
         this.catchUp = new WindowedTasks(1000, error => { if (!this.closed)
             options.onError(error); });
         this.countTasks = new WindowedTasks(50, error => { if (!this.closed)

package/lib/runtime/createChat.js

@@ -1,4 +1,5 @@
 import { voiceUploader } from "./voiceUpload.js";
+import { isOffline } from "./connectivity.js";
 import { isReadingControl, messageRequiresPlayback, messageMentionsProfile } from "./readingContent.js";
 import { ChatSession } from "./chatSession.js";
 import { SocialReadClient } from "./socialReadClient.js";
@@ -19,6 +20,18 @@ export function createChat(options) {
     return new ChatSession({
         sharedConnection: options.connection,
         uploadVoice: voiceUploader(profileId, options.uploadEndpoint, options.fetch),
+        reconcileOutgoing: async (record, signal) => {
+            if (isOffline())
+                throw new Error("OUTBOX_RECONCILIATION_OFFLINE");
+            const result = await reader.messagePage({ threadId: record.threadId, teamId, messageId: record.message.hash }, signal);
+            const expected = record.message.body;
+            return result.messages.some(message => {
+                const body = message.body;
+                if (message.from !== profileId || message.to !== record.message.to || body?.kind !== expected.kind || body?.action !== expected.action)
+                    throw new Error("OUTBOX_RECONCILIATION_MISMATCH");
+                return true;
+            });
+        },
         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 },
         reading: { appId, profileId, sessionToken: token, hubHttpUrl: http, fetch: options.fetch, onError },

package/lib/runtime/durableSender.d.ts

@@ -31,6 +31,7 @@ export type DurableSenderOptions = {
     name?: string;
     access?: () => Promise<SenderScopeAccess>;
     uploadVoice?: (blob: Blob, signal: AbortSignal) => Promise<string>;
+    reconcile?: (record: Pick<OutgoingMessage, "threadId" | "message">, signal: AbortSignal) => Promise<boolean>;
 };
 /** Persists the exact wire message before sending; retries preserve its hash. */
 export declare class DurableChatSender {
@@ -43,6 +44,13 @@ export declare class DurableChatSender {
     private localUrls;
     private localViews;
     private uploads;
+    private reconciliations;
+    private firstDelivery;
+    private acceptanceQueue;
+    private acceptanceTimer?;
+    private acceptanceRunning?;
+    private acceptanceCount;
+    private acceptanceBytes;
     private uploadTail;
     private uploadWaiting;
     private confirmationQueue;
@@ -85,8 +93,12 @@ export declare class DurableChatSender {
     /** Compatibility API: resolves only after transport delivery. */
     send(threadId: string, input: SendMessageInput): Promise<ChatRuntimeMessage>;
     private persistOutgoing;
+    private scheduleAcceptances;
+    private failAcceptances;
+    private drainAcceptances;
     retry(hash: string): Promise<ChatRuntimeMessage>;
     private transmit;
+    private reconcile;
     private releaseUrl;
     private releaseUrls;
     private localView;

package/lib/runtime/durableSender.js

@@ -1,4 +1,6 @@
 import { Dexie } from "dexie";
+import { blake3 } from "@noble/hashes/blake3.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
 import { withChatTeam } from "./teamScope.js";
 import { messageScopeKey } from "./messageStore.js";
 /** Persists the exact wire message before sending; retries preserve its hash. */
@@ -12,6 +14,13 @@ export class DurableChatSender {
     localUrls = new Map();
     localViews = new WeakMap();
     uploads = new Set();
+    reconciliations = new Set();
+    firstDelivery = new Set();
+    acceptanceQueue = [];
+    acceptanceTimer;
+    acceptanceRunning;
+    acceptanceCount = 0;
+    acceptanceBytes = 0;
     uploadTail = Promise.resolve();
     uploadWaiting = 0;
     confirmationQueue = [];
@@ -185,8 +194,11 @@ export class DurableChatSender {
     /** Stop disclosure immediately; durable invalidation is coordinated separately. */
     withdraw() {
         this.withdrawn = true;
+        this.failAcceptances(new Error("OUTBOX_ACCESS_REVOKED"));
         this.failConfirmations(new Error("OUTBOX_ACCESS_REVOKED"));
         this.uploads.forEach(controller => controller.abort());
+        this.reconciliations.forEach(controller => controller.abort());
+        this.firstDelivery.clear();
         this.releaseUrls();
         this.values.clear();
         this.emit();
@@ -243,27 +255,112 @@ export class DurableChatSender {
     persistOutgoing(threadId, input) {
         if (this.closed || this.closing || this.withdrawn)
             return Promise.reject(new Error("OUTBOX_ACCESS_REVOKED"));
+        if (input.voiceBlob && (!(input.voiceBlob instanceof Blob) || input.voiceBlob.size === 0 || input.voiceBlob.size > 16 * 1024 * 1024))
+            return Promise.reject(new Error("INVALID_VOICE_ATTACHMENT"));
+        const bytes = input.voiceBlob?.size ?? 0;
+        if (this.acceptanceCount >= 4096 || this.acceptanceBytes + bytes > 64 * 1024 * 1024)
+            return Promise.reject(new Error("OUTBOX_ACCEPTANCE_BACKPRESSURE"));
+        this.acceptanceCount++;
+        this.acceptanceBytes += bytes;
         const pending = (async () => {
             await this.ready;
             await this.checkAccess();
             const message = this.client.prepareChat(input.to, withChatTeam(input.body, this.identity.teamId), input.recipients);
             if (message.from !== this.identity.profileId)
                 throw new Error("OUTGOING_MESSAGE_IDENTITY_MISMATCH");
+            const command = statefulGroup(message);
+            if (command)
+                message.hash = commandId(this.scope, this.version, threadId, message);
             if (input.voiceBlob) {
                 const body = message.body;
-                if (!(input.voiceBlob instanceof Blob) || input.voiceBlob.size === 0 || input.voiceBlob.size > 16 * 1024 * 1024 || body.kind !== "message" || !validVoice(body.content.voice))
+                if (body.kind !== "message" || !validVoice(body.content.voice))
                     throw new Error("INVALID_VOICE_ATTACHMENT");
             }
             const record = { ...(input.voiceBlob ? { voiceData: { bytes: await input.voiceBlob.arrayBuffer(), type: input.voiceBlob.type } } : {}), scope: this.scope, threadId, hash: message.hash, message, status: "sending", accessVersion: this.version };
-            await this.withEpoch("rw", async () => { await this.outbox.put(record); });
-            await this.checkAccess();
-            this.values.set(record.hash, record);
-            this.emit();
-            return message;
-        })().finally(() => this.accepted.delete(pending));
+            const durable = await new Promise((resolve, reject) => {
+                this.acceptanceQueue.push({ record, resolve, reject });
+                this.scheduleAcceptances();
+            });
+            return durable.message;
+        })().finally(() => { this.accepted.delete(pending); this.acceptanceCount--; this.acceptanceBytes -= bytes; });
         this.accepted.add(pending);
         return pending;
     }
+    scheduleAcceptances() {
+        if (this.acceptanceTimer || this.acceptanceRunning || !this.acceptanceQueue.length)
+            return;
+        this.acceptanceTimer = setTimeout(() => { this.acceptanceTimer = undefined; void this.drainAcceptances(); }, 16);
+    }
+    failAcceptances(error) {
+        clearTimeout(this.acceptanceTimer);
+        this.acceptanceTimer = undefined;
+        for (const item of this.acceptanceQueue.splice(0))
+            item.reject(error);
+    }
+    drainAcceptances() {
+        const task = (async () => {
+            let bytes = 0, count = 0;
+            for (const item of this.acceptanceQueue) {
+                const size = item.record.voiceData?.bytes.byteLength ?? 0;
+                if (count >= 128 || (count > 0 && bytes + size > 16 * 1024 * 1024))
+                    break;
+                bytes += size;
+                count++;
+            }
+            const batch = this.acceptanceQueue.splice(0, count);
+            try {
+                const result = await this.withEpoch("rw", async () => {
+                    const commands = batch.filter(item => statefulGroup(item.record.message));
+                    const previous = await this.outbox.bulkGet(commands.map(item => [this.scope, item.record.hash]));
+                    const known = new Map(previous.filter((row) => Boolean(row && (row.accessVersion ?? 0) === this.version)).map(row => [row.hash, row]));
+                    const writes = [], records = [];
+                    for (const { record } of batch) {
+                        const command = statefulGroup(record.message), old = command ? known.get(record.hash) : undefined;
+                        if (old) {
+                            if (old.message.from !== this.identity.profileId || old.message.hash !== record.hash || commandId(this.scope, this.version, record.threadId, old.message) !== record.hash)
+                                throw new Error("OUTGOING_COMMAND_CONFLICT");
+                            records.push(old);
+                        }
+                        else {
+                            writes.push(record);
+                            records.push(record);
+                            if (command)
+                                known.set(record.hash, record);
+                        }
+                    }
+                    if (writes.length)
+                        await this.outbox.bulkPut(writes);
+                    return { writes, records };
+                });
+                await this.checkAccess();
+                for (const record of result.writes)
+                    if (statefulGroup(record.message))
+                        this.firstDelivery.add(record.hash);
+                let changed = false;
+                for (const record of result.records) {
+                    if (record.confirmed) {
+                        this.firstDelivery.delete(record.hash);
+                        changed = this.values.delete(record.hash) || changed;
+                    }
+                    else {
+                        const current = this.values.get(record.hash);
+                        if (!current || current.status !== record.status || current.accessVersion !== record.accessVersion) {
+                            this.values.set(record.hash, record);
+                            changed = true;
+                        }
+                    }
+                }
+                if (changed)
+                    this.emit();
+                batch.forEach((item, index) => item.resolve(result.records[index]));
+            }
+            catch (error) {
+                batch.forEach(item => item.reject(error));
+            }
+        })().finally(() => { this.acceptanceRunning = undefined; this.scheduleAcceptances(); });
+        this.acceptanceRunning = task;
+        return task;
+    }
     retry(hash) {
         if (this.closed || this.closing || this.withdrawn)
             return Promise.reject(new Error("CHAT_SENDER_CLOSED"));
@@ -279,8 +376,10 @@ export class DurableChatSender {
         let record = await this.withEpoch("r", async () => this.outbox.get([this.scope, hash]));
         if (!record || this.closed || this.withdrawn)
             throw new Error("OUTGOING_MESSAGE_UNAVAILABLE");
-        if (record.status === "sent" || record.confirmed)
+        if (record.status === "sent" || record.confirmed) {
+            this.firstDelivery.delete(hash);
             return record.message;
+        }
         const sending = { ...record, status: "sending" };
         if (record.status !== "sending") {
             const latest = await this.save(sending);
@@ -292,7 +391,15 @@ export class DurableChatSender {
             this.values.set(hash, sending);
             this.emit();
         }
+        let transmitting = false;
         try {
+            if (statefulGroup(record.message) && !this.firstDelivery.delete(hash)) {
+                const confirmed = await this.reconcile(record);
+                if (confirmed) {
+                    await this.confirm([hash]);
+                    return record.message;
+                }
+            }
             if (hasVoice(record)) {
                 record = await this.prepareVoice(record);
                 if (record.confirmed || record.status === "sent")
@@ -301,6 +408,7 @@ export class DurableChatSender {
             await this.checkAccess();
             if (this.closing)
                 throw new Error("CHAT_SENDER_CLOSED");
+            transmitting = true;
             const message = await this.client.sendPrepared(record.message);
             const sent = { ...record, message, status: "sent" };
             const committed = await this.save(sent);
@@ -314,7 +422,20 @@ export class DurableChatSender {
             return message;
         }
         catch (error) {
-            if (!this.closed && !this.withdrawn) {
+            // A failed delivery can already be durable remotely, including the first
+            // lost ACK. Proof recovery never sends a second wire in this attempt.
+            if (statefulGroup(record.message) && this.options.reconcile && transmitting && !this.closed && !this.closing && !this.withdrawn) {
+                try {
+                    if (await this.reconcile(record)) {
+                        await this.confirm([hash]);
+                        return record.message;
+                    }
+                }
+                catch (verificationError) {
+                    error = new AggregateError([error, verificationError], "OUTBOX_RECONCILIATION_FAILED");
+                }
+            }
+            if (!this.closed && !this.withdrawn && !(this.closing && statefulGroup(record.message))) {
                 const failed = { ...record, status: "failed" };
                 const committed = await this.save(failed);
                 if (committed?.confirmed || committed?.status === "sent") {
@@ -331,6 +452,30 @@ export class DurableChatSender {
             throw error;
         }
     }
+    async reconcile(record) {
+        await this.checkAccess();
+        if (this.closing || this.closed || this.withdrawn)
+            throw new Error("OUTBOX_RECONCILIATION_ABORTED");
+        if (!this.options.reconcile)
+            throw new Error("OUTBOX_RECONCILIATION_UNAVAILABLE");
+        const controller = new AbortController();
+        this.reconciliations.add(controller);
+        let abort;
+        const stopped = new Promise((_, reject) => { abort = () => reject(new Error("OUTBOX_RECONCILIATION_ABORTED")); controller.signal.addEventListener("abort", abort, { once: true }); });
+        const timer = setTimeout(() => controller.abort(), 10_000);
+        try {
+            const confirmed = await Promise.race([this.options.reconcile({ threadId: record.threadId, message: record.message }, controller.signal), stopped]);
+            await this.checkAccess();
+            if (this.closing || controller.signal.aborted)
+                throw new Error("OUTBOX_RECONCILIATION_ABORTED");
+            return confirmed;
+        }
+        finally {
+            clearTimeout(timer);
+            controller.signal.removeEventListener("abort", abort);
+            this.reconciliations.delete(controller);
+        }
+    }
     releaseUrl(hash) { const value = this.localUrls.get(hash); if (value) {
         URL.revokeObjectURL(value.url);
         this.localUrls.delete(hash);
@@ -533,6 +678,7 @@ export class DurableChatSender {
     async close() {
         this.closing = true;
         this.uploads.forEach(controller => controller.abort());
+        this.reconciliations.forEach(controller => controller.abort());
         this.offConnection();
         this.listeners.clear();
         this.channel?.close();
@@ -545,6 +691,7 @@ export class DurableChatSender {
         finally {
             this.closed = true;
             this.failConfirmations(new Error("CHAT_SENDER_CLOSED"));
+            this.firstDelivery.clear();
             this.releaseUrls();
             this.values.clear();
             this.snapshots.clear();
@@ -552,6 +699,17 @@ export class DurableChatSender {
         }
     }
 }
+function statefulGroup(message) { const body = message.body; return body?.kind === "group" && (body.action === "groupCreate" || body.action === "groupUpdate"); }
+function commandId(scope, version, threadId, message) {
+    return bytesToHex(blake3(new TextEncoder().encode(JSON.stringify(["chat-command:v1", scope, version, threadId, message.to, ordered(message.body)]))));
+}
+function ordered(value) {
+    if (Array.isArray(value))
+        return value.map(ordered);
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, ordered(item)]));
+    return value;
+}
 function validVoice(value) { const voice = value; return Boolean(voice && typeof voice.url === "string" && Number.isFinite(voice.durationMs) && voice.durationMs > 0); }
 function withVoiceUrl(message, url) {
     const body = message.body;

package/lib/runtime/messageClient.d.ts

@@ -41,6 +41,7 @@ export declare class MessageClient<T extends StoredMessage> {
     private allListeners;
     private reads;
     private syncing;
+    private completedSyncs;
     private paging;
     private writes;
     private activeWrites;
@@ -72,6 +73,8 @@ export declare class MessageClient<T extends StoredMessage> {
         allowed: boolean;
     }>;
     getSnapshot(thread: string): MessageSnapshot<T> | undefined;
+    /** Exact authoritative row only; migration-only rows never prove delivery. */
+    cachedMessage(thread: string, id: string): Promise<T>;
     subscribe(thread: string, listener: () => void): () => void;
     subscribeAll(listener: (threadId: string) => void): () => void;
     /** Close the connection gap for saved windows with four bounded background lanes. */

package/lib/runtime/messageClient.js

@@ -11,6 +11,7 @@ export class MessageClient {
     allListeners = new Set();
     reads = new Map();
     syncing = new Map();
+    completedSyncs = new Map();
     paging = new Map();
     writes = new Map();
     activeWrites = new Set();
@@ -100,6 +101,16 @@ export class MessageClient {
         return { version: current.version, allowed: !this.scopeDenied && !current.revoked && current.version === this.scopeVersion };
     }
     getSnapshot(thread) { return this.watches.get(thread)?.snapshot; }
+    /** Exact authoritative row only; migration-only rows never prove delivery. */
+    async cachedMessage(thread, id) {
+        await this.ensureScope();
+        if (this.closed || this.closing || this.scopeDenied || this.revoked.has(thread))
+            throw accessRevoked();
+        const page = await this.storage.readSelected(thread, [id]);
+        if (page.coverage?.revoked || (page.coverage?.scopeVersion ?? 0) !== this.scopeVersion)
+            throw accessRevoked();
+        return page.messages[0];
+    }
     subscribe(thread, listener) {
         let watch = this.watches.get(thread);
         if (!watch) {
@@ -137,6 +148,7 @@ export class MessageClient {
         if (running)
             return running;
         const task = (async () => {
+            const completedAtStart = this.completedSyncs.get(thread);
             await this.ensureScope();
             if (this.scopeDenied)
                 throw accessRevoked();
@@ -197,6 +209,7 @@ export class MessageClient {
             if (this.scopeDenied || this.revoked.has(thread))
                 throw accessRevoked();
             if (local.coverage?.complete && Date.now() - (local.coverage.syncedAt ?? 0) > (this.options.freshnessMs ?? 30_000)
+                && !this.syncing.has(thread) && this.completedSyncs.get(thread) === completedAtStart
                 && (typeof navigator === "undefined" || navigator.onLine !== false))
                 this.invalidate(thread);
             return limit === 100 ? snapshot : result;
@@ -483,6 +496,7 @@ export class MessageClient {
                 this.assertNetworkAvailable(thread);
                 page = await this.options.transport.changes(thread, after, this.abort.signal);
             }
+            this.completedSyncs.set(thread, (this.completedSyncs.get(thread) ?? 0) + 1);
         })().catch(async (error) => {
             if (String(error).includes("MESSAGE_SCOPE_CHANGED"))
                 this.denyScope();
@@ -676,6 +690,7 @@ export class MessageClient {
             this.channel?.close();
             this.watches.clear();
             this.windowEdges.clear();
+            this.completedSyncs.clear();
             this.allListeners.clear();
             this.accessListeners.clear();
             this.storage.close();

package/lib/runtime/socialReadClient.d.ts

@@ -57,6 +57,7 @@ export declare class SocialReadClient {
         limit?: number;
         before?: string;
         after?: string;
+        messageId?: string;
     }, signal?: AbortSignal): Promise<SocialMessagePage>;
     group(input: {
         groupId: string;

package/lib/runtime/socialReadClient.js

@@ -26,17 +26,21 @@ export class SocialReadClient {
     }
     async messagePage(input, signal) {
         this.requireTeam(input.teamId);
-        const limit = input.limit ?? 100;
+        const limit = input.limit ?? (input.messageId === undefined ? 100 : 1);
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500 || (input.before !== undefined && input.after !== undefined))
             throw new SocialReadError(400, "INVALID_MESSAGE_PAGE");
+        if (input.messageId !== undefined && (!input.messageId || input.messageId.length > 256 || /[\u0000-\u001f\u007f]/.test(input.messageId) || limit !== 1 || input.before !== undefined || input.after !== undefined))
+            throw new SocialReadError(400, "INVALID_MESSAGE_LOOKUP");
         const value = await this.request("messages", { threadId: input.threadId, ...this.teamQuery(input.teamId), limit: String(limit),
-            ...(input.before === undefined ? {} : { before: input.before }), ...(input.after === undefined ? {} : { after: input.after }) }, signal);
+            ...(input.before === undefined ? {} : { before: input.before }), ...(input.after === undefined ? {} : { after: input.after }), ...(input.messageId === undefined ? {} : { messageId: input.messageId }) }, signal);
         const cursor = (token) => typeof token === "string" && /^mp1:\d+:[0-9a-f]{64}$/.test(token);
         if (!value || !Array.isArray(value.messages) || value.messages.length > limit || !cursor(value.checkpoint)
             || (value.nextBefore !== null && !cursor(value.nextBefore)) || typeof value.hasMoreChanges !== "boolean" || typeof value.resetRequired !== "boolean"
             || value.messages.some(row => row.appId !== this.options.appId || row.threadId !== input.threadId || row.teamId !== input.teamId || !row.messageId || !Number.isFinite(row.serverCreatedAt))
             || (value.resetRequired && (value.messages.length || value.hasMoreChanges || value.nextBefore !== null)))
             throw new SocialReadError(502, "INVALID_MESSAGE_PAGE_RESPONSE");
+        if (input.messageId !== undefined && (value.messages.some(row => row.messageId !== input.messageId) || value.nextBefore !== null || value.hasMoreChanges || value.resetRequired))
+            throw new SocialReadError(502, "INVALID_MESSAGE_LOOKUP_RESPONSE");
         return value;
     }
     group(input) {

package/package.json

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