@pmate/chat-sdk 0.12.0-next.42 → 0.12.0-next.43

package/lib/runtime/chatSession.d.ts

@@ -5,17 +5,18 @@ import { type ReadCountsResult } from "./readCounts.js";
 import type { OnlineReachEvent } from "./reach.js";
 import { type MessageReadersQuery } from "./messageReaders.js";
 import { type MessageClientOptions, type MessageSnapshot } from "./messageClient.js";
-import { DurableChatSender } from "./durableSender.js";
+import { DurableChatSender, type SendMessageInput, type DurableSenderOptions } from "./durableSender.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";
-import type { ChatBody, ChatRuntimeMessage } from "./protocol.js";
+import type { ChatRuntimeMessage } from "./protocol.js";
 export type ChatSessionOptions<T extends StoredMessage> = {
     messages: MessageClientOptions<T>;
     connection: ChatClientOptions;
     sharedConnection?: ChatClient;
     activeThreadId?: string;
+    uploadVoice?: DurableSenderOptions["uploadVoice"];
     reading: ReadingClientOptions;
     decode: (message: ChatRuntimeMessage) => T | undefined;
     readingCandidate?: (message: T) => ReadingCandidate | undefined;
@@ -116,11 +117,7 @@ export declare class ChatSession<T extends StoredMessage> {
     private rememberHistoryEdge;
     private readEarlier;
     private readAll;
-    sendMessage(threadId: string, input: {
-        to: string;
-        body: ChatBody;
-        recipients?: string[];
-    }): Promise<ChatRuntimeMessage>;
+    sendMessage(threadId: string, input: SendMessageInput): Promise<ChatRuntimeMessage>;
     getReaders(threadId: string, messageId: string, page?: Omit<MessageReadersQuery, "threadId" | "messageId">, signal?: AbortSignal): Promise<import("./messageReaders.js").MessageReadersPage>;
     retryMessage(messageId: string): Promise<ChatRuntimeMessage>;
     observeMessages(threadId: string, ids: string[], event: "visible" | "played"): ReturnType<ReadingClient["recordVisible"]>;

package/lib/runtime/chatSession.js

@@ -69,7 +69,7 @@ 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() });
+        this.sender = new DurableChatSender(this.connection, scope, options.onError, { access: () => this.messages.scopeAccess(), uploadVoice: options.uploadVoice });
         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.d.ts

@@ -10,6 +10,7 @@ export type CreateChatOptions = {
     token: string;
     /** Limit reconnect reconciliation for a dedicated conversation document. */
     threadId?: string;
+    uploadEndpoint?: string;
     endpoint?: string;
     clientInstanceId?: string;
     fetch?: typeof fetch;

package/lib/runtime/createChat.js

@@ -1,3 +1,4 @@
+import { voiceUploader } from "./voiceUpload.js";
 import { isReadingControl, messageRequiresPlayback, messageMentionsProfile } from "./readingContent.js";
 import { ChatSession } from "./chatSession.js";
 import { SocialReadClient } from "./socialReadClient.js";
@@ -17,6 +18,7 @@ export function createChat(options) {
     };
     return new ChatSession({
         sharedConnection: options.connection,
+        uploadVoice: voiceUploader(profileId, options.uploadEndpoint, options.fetch),
         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

@@ -9,6 +9,13 @@ export type OutgoingMessage = {
     status: "sending" | "failed" | "sent";
     confirmed?: boolean;
     accessVersion?: number;
+    voiceBlob?: Blob;
+};
+export type SendMessageInput = {
+    to: string;
+    body: ChatBody;
+    recipients?: string[];
+    voiceBlob?: Blob;
 };
 export type SenderScopeAccess = {
     version: number;
@@ -18,6 +25,7 @@ export type DurableSenderOptions = {
     indexedDB?: IDBFactory;
     name?: string;
     access?: () => Promise<SenderScopeAccess>;
+    uploadVoice?: (blob: Blob, signal: AbortSignal) => Promise<string>;
 };
 /** Persists the exact wire message before sending; retries preserve its hash. */
 export declare class DurableChatSender {
@@ -27,6 +35,11 @@ export declare class DurableChatSender {
     private db;
     private outbox;
     private epochs;
+    private localUrls;
+    private localViews;
+    private uploads;
+    private uploadTail;
+    private uploadWaiting;
     private version;
     private withdrawn;
     private revoking?;
@@ -59,20 +72,16 @@ export declare class DurableChatSender {
     snapshot(threadId?: string): readonly OutgoingMessage[];
     private emit;
     /** Resolves after the exact wire message is durable, independently of network delivery. */
-    enqueue(threadId: string, input: {
-        to: string;
-        body: ChatBody;
-        recipients?: string[];
-    }): Promise<ChatRuntimeMessage>;
+    enqueue(threadId: string, input: SendMessageInput): Promise<ChatRuntimeMessage>;
     /** Compatibility API: resolves only after transport delivery. */
-    send(threadId: string, input: {
-        to: string;
-        body: ChatBody;
-        recipients?: string[];
-    }): Promise<ChatRuntimeMessage>;
+    send(threadId: string, input: SendMessageInput): Promise<ChatRuntimeMessage>;
     private persistOutgoing;
     retry(hash: string): Promise<ChatRuntimeMessage>;
     private transmit;
+    private releaseUrl;
+    private releaseUrls;
+    private localView;
+    private prepareVoice;
     private save;
     /** Confirm only after the authoritative message has been durably merged.
      * A tombstone prevents another tab's late failure from recreating the outbox. */

package/lib/runtime/durableSender.js

@@ -9,6 +9,11 @@ export class DurableChatSender {
     db;
     outbox;
     epochs;
+    localUrls = new Map();
+    localViews = new WeakMap();
+    uploads = new Set();
+    uploadTail = Promise.resolve();
+    uploadWaiting = 0;
     version = 0;
     withdrawn = false;
     revoking;
@@ -132,6 +137,8 @@ export class DurableChatSender {
     /** Stop disclosure immediately; durable invalidation is coordinated separately. */
     withdraw() {
         this.withdrawn = true;
+        this.uploads.forEach(controller => controller.abort());
+        this.releaseUrls();
         this.values.clear();
         this.emit();
     }
@@ -165,7 +172,7 @@ export class DurableChatSender {
             return this.empty;
         let snapshot = this.snapshots.get(threadId);
         if (!snapshot) {
-            snapshot = [...this.values.values()].filter(record => threadId === undefined || record.threadId === threadId);
+            snapshot = [...this.values.values()].filter(record => threadId === undefined || record.threadId === threadId).map(record => this.localView(record));
             this.snapshots.set(threadId, snapshot);
         }
         return snapshot;
@@ -193,7 +200,12 @@ export class DurableChatSender {
             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 record = { scope: this.scope, threadId, hash: message.hash, message, status: "sending", accessVersion: this.version };
+            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))
+                    throw new Error("INVALID_VOICE_ATTACHMENT");
+            }
+            const record = { ...(input.voiceBlob ? { voiceBlob: input.voiceBlob } : {}), 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);
@@ -215,7 +227,7 @@ export class DurableChatSender {
     }
     async transmit(hash) {
         await this.ready;
-        const record = await this.withEpoch("r", async () => this.outbox.get([this.scope, hash]));
+        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)
@@ -232,6 +244,14 @@ export class DurableChatSender {
             this.emit();
         }
         try {
+            if (record.voiceBlob) {
+                record = await this.prepareVoice(record);
+                if (record.confirmed || record.status === "sent")
+                    return record.message;
+            }
+            await this.checkAccess();
+            if (this.closing)
+                throw new Error("CHAT_SENDER_CLOSED");
             const message = await this.client.sendPrepared(record.message);
             const sent = { ...record, message, status: "sent" };
             const committed = await this.save(sent);
@@ -262,11 +282,92 @@ export class DurableChatSender {
             throw error;
         }
     }
+    releaseUrl(hash) { const value = this.localUrls.get(hash); if (value) {
+        URL.revokeObjectURL(value.url);
+        this.localUrls.delete(hash);
+    } }
+    releaseUrls() { for (const hash of this.localUrls.keys())
+        this.releaseUrl(hash); }
+    localView(record) {
+        if (!record.voiceBlob || typeof URL.createObjectURL !== "function")
+            return record;
+        let cached = this.localViews.get(record);
+        if (cached)
+            return cached;
+        let local = this.localUrls.get(record.hash);
+        if (!local || local.blob !== record.voiceBlob) {
+            this.releaseUrl(record.hash);
+            local = { blob: record.voiceBlob, url: URL.createObjectURL(record.voiceBlob) };
+            this.localUrls.set(record.hash, local);
+        }
+        cached = { ...record, message: withVoiceUrl(record.message, local.url) };
+        this.localViews.set(record, cached);
+        return cached;
+    }
+    async prepareVoice(record) {
+        if (this.uploadWaiting >= 32)
+            throw new Error("VOICE_UPLOAD_BACKPRESSURE");
+        this.uploadWaiting++;
+        const previous = this.uploadTail;
+        let release;
+        this.uploadTail = new Promise(resolve => { release = resolve; });
+        try {
+            await previous;
+            await this.checkAccess();
+            if (this.closing)
+                throw new Error("CHAT_SENDER_CLOSED");
+            const latest = await this.withEpoch("r", () => this.outbox.get([this.scope, record.hash]));
+            if (!latest)
+                throw new Error("OUTGOING_MESSAGE_UNAVAILABLE");
+            if (!latest.voiceBlob || latest.confirmed || latest.status === "sent")
+                return latest;
+            if (!this.options.uploadVoice)
+                throw new Error("VOICE_UPLOAD_UNAVAILABLE");
+            const controller = new AbortController();
+            this.uploads.add(controller);
+            const timeout = setTimeout(() => controller.abort(), 30_000);
+            let url;
+            try {
+                url = await this.options.uploadVoice(latest.voiceBlob, controller.signal);
+            }
+            finally {
+                clearTimeout(timeout);
+                this.uploads.delete(controller);
+            }
+            const parsed = new URL(url);
+            if (!["https:", "http:"].includes(parsed.protocol) || parsed.username || parsed.password)
+                throw new Error("INVALID_VOICE_UPLOAD_URL");
+            await this.checkAccess();
+            if (this.closing)
+                throw new Error("CHAT_SENDER_CLOSED");
+            const { voiceBlob: _blob, ...uploaded } = latest;
+            const committed = await this.withEpoch("rw", async () => {
+                const current = await this.outbox.get([this.scope, record.hash]);
+                if (!current || current.confirmed || current.status === "sent" || !current.voiceBlob)
+                    return current;
+                const next = { ...uploaded, message: withVoiceUrl(latest.message, url) };
+                await this.outbox.put(next);
+                return next;
+            });
+            if (!committed)
+                throw new Error("OUTGOING_MESSAGE_UNAVAILABLE");
+            this.values.set(record.hash, committed);
+            this.emit();
+            return committed;
+        }
+        finally {
+            this.uploadWaiting--;
+            release();
+        }
+    }
     async save(record) {
         return this.withEpoch("rw", async () => {
             const previous = await this.outbox.get([this.scope, record.hash]);
             if (!previous || previous.confirmed || previous.status === "sent")
                 return previous;
+            // A second document may already have durably replaced the Blob with its URL.
+            if (record.voiceBlob && !previous.voiceBlob)
+                return previous;
             await this.outbox.put(record);
             return record;
         });
@@ -280,13 +381,15 @@ export class DurableChatSender {
         await this.ready;
         await this.withEpoch("rw", async () => {
             const previous = await this.outbox.bulkGet(hashes.map(hash => [this.scope, hash]));
-            const confirmed = previous.filter((record) => Boolean(record && !record.confirmed)).map(record => ({ ...record, status: "sent", confirmed: true }));
+            const confirmed = previous.filter((record) => Boolean(record && !record.confirmed)).map(record => ({ ...record, voiceBlob: undefined, status: "sent", confirmed: true }));
             if (confirmed.length)
                 await this.outbox.bulkPut(confirmed);
         });
         let changed = false;
-        for (const hash of hashes)
+        for (const hash of hashes) {
             changed = this.values.delete(hash) || changed;
+            this.releaseUrl(hash);
+        }
         if (changed)
             this.emit();
     }
@@ -309,6 +412,7 @@ export class DurableChatSender {
     }
     async close() {
         this.closing = true;
+        this.uploads.forEach(controller => controller.abort());
         this.offConnection();
         this.listeners.clear();
         this.channel?.close();
@@ -319,9 +423,15 @@ export class DurableChatSender {
         }
         finally {
             this.closed = true;
+            this.releaseUrls();
             this.values.clear();
             this.snapshots.clear();
             this.db.close();
         }
     }
 }
+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;
+    return { ...message, body: { ...body, content: { ...body.content, voice: { ...body.content.voice, url } } } };
+}

package/lib/runtime/voiceUpload.d.ts

@@ -0,0 +1,2 @@
+/** The SDK owns upload I/O; hosts configure only their service endpoint. */
+export declare function voiceUploader(profileId: string, endpoint?: string, fetcher?: typeof fetch): (blob: Blob, signal: AbortSignal) => Promise<string>;

package/lib/runtime/voiceUpload.js

@@ -0,0 +1,20 @@
+/** The SDK owns upload I/O; hosts configure only their service endpoint. */
+export function voiceUploader(profileId, endpoint = "https://upload-fc.pmate.chat", fetcher = globalThis.fetch) {
+    return async (blob, signal) => {
+        const bytes = new Uint8Array(await blob.arrayBuffer());
+        if (signal.aborted)
+            throw new DOMException("Upload aborted", "AbortError");
+        let binary = "";
+        for (let offset = 0; offset < bytes.length; offset += 32768)
+            binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+        const extension = blob.type.includes("mp4") ? "m4a" : blob.type.includes("mpeg") ? "mp3" : "webm";
+        const type = extension === "m4a" ? "audio/mp4" : extension === "mp3" ? "audio/mpeg" : "audio/webm";
+        const response = await fetcher(`${endpoint.replace(/\/+$/, "")}/file`, { method: "POST", signal, headers: { "Content-Type": "application/json", "x-file-content-type": type }, body: JSON.stringify({ user: profileId, base64: btoa(binary), filename: `voice-${Date.now()}.${extension}` }) });
+        if (!response.ok)
+            throw new Error("VOICE_UPLOAD_FAILED");
+        const result = await response.json();
+        if (typeof result.data !== "string" || !result.data)
+            throw new Error("VOICE_UPLOAD_FAILED");
+        return result.data;
+    };
+}

package/package.json

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