@pmate/chat-sdk 0.12.0-next.1 → 0.12.0-next.11

package/README.md

@@ -137,6 +137,52 @@ sends and reading synchronization independently. The runtime now provides local
 IndexedDB storage and fixed-window scheduling primitives so those operations can
 share bounded I/O, durable confirmation and scoped subscriptions.
 
+The browser entry point is `createChat` from `@pmate/chat-sdk/runtime`:
+
+```ts
+const chat = createChat({ appId, accountId, profileId, teamId, token, onError })
+await chat.start()
+const page = await chat.getMessages(threadId)
+// SDK owns the page size and history boundary; hosts need not construct a cursor.
+const earlier = await chat.getMessages(threadId, { earlier: true })
+// After an authoritative mutation (e.g. history assignment), await reconciliation.
+// Concurrent refreshes share transport; errors do not masquerade as fresh cache.
+const reconciled = await chat.getMessages(threadId, { refresh: true })
+// Explicit full-history queries reuse cached pages and internally rebase expired cursors.
+const history = await chat.getMessages(threadId, { all: true })
+const off = chat.subscribe(threadId, () => render(chat.getSnapshot(threadId)))
+const offSummary = chat.subscribe(() => renderSummary(chat.getSnapshot()))
+await chat.observeMessages(threadId, visibleIds, "visible")
+// Report only the actual audio `playing` event.
+await chat.observeMessages(threadId, [voiceId], "played")
+await chat.sendMessage(threadId, { to, body, recipients })
+const readers = await chat.getReaders(threadId, messageId)
+off(); offSummary()
+await chat.close()
+```
+
+The facade owns all clients below. Message reads transparently restore IndexedDB
+windows and fetch missing ranges through the authenticated Hub. Its normalized
+messages retain the protocol body; product rendering remains with the host.
+`sendMessage` resolves after local persistence, while `outgoing` in the thread
+snapshot reports transport progress and failure. Retry uses the original message
+hash. The subscribed recent window remains 100 records regardless of individual
+query limits; history requests return their own pages and do not replace it.
+Global snapshots contain thread summaries and totals, not complete message arrays.
+Message pages report `complete`; unavailable older pages return cached records with
+`complete: false`. Authorization failures throw and never fall back to denied
+records. Thread snapshots expose `resetVersion`; hosts discard retained rows when
+it changes. Reset epochs are durable, so late cross-tab writes cannot restore a
+pre-reset payload.
+Voice visibility never acknowledges playback, including observations that arrive
+before metadata. Create a new instance and close the previous owner when the
+account or active Team changes.
+
+This facade is still under integration. Reader details currently require network
+access, global summaries do not yet replace the host's contact/thread metadata,
+and Merry's message-list/send migration and production validation are unfinished.
+The lower-level primitives remain available for custom transports:
+
 `MessageClient` reads a trusted recent window locally, coalesces concurrent misses,
 subscribes per conversation, and accepts incremental event batches. Its transport
 supplies authoritative `load`, `changes` and `older` pages. `nextBefore` tracks
@@ -157,6 +203,11 @@ legacy cleanup happens after durable migration. Normal reads use memory and writ
 are merged into bounded IndexedDB transactions. Cache errors must be surfaced by
 the host, and pending operations are not reported as saved before their promise
 resolves.
+Control-event batches are bounded by both 128 records and 1 MiB per transaction;
+the queue includes in-flight writes and is limited to 4096 records / 8 MiB.
+`transactionBytes` and `queueBytes` can lower these limits. Oversized operations
+fail before changing the memory snapshot. Repeating an in-flight write waits for
+that physical write, including its failure, rather than acknowledging it early.
 
 `DurableChatSender` saves the exact message created by `ChatClient.prepareChat`
 before transmitting it. `retry(hash)` uses `sendPrepared` with the original hash
@@ -165,7 +216,7 @@ when the connection returns. Call `confirm(hashes)` only after authoritative
 messages have been durably merged. Confirmation tombstones prevent another tab's
 late transport failure from recreating an outgoing message.
 
-These APIs are runtime primitives; applications must initialize them with the
-same authenticated scope, dispose them on identity changes, and wire their
-transport to an authorized server. The Merry migration and production validation
+Custom primitive integrations must initialize them with the same authenticated
+scope, dispose them on identity changes, and wire their transport to an authorized
+server. Standard browser integrations should use the facade instead. The Merry migration and production validation
 are tracked in the unified message layer proposal.

package/lib/runtime/chatClient.d.ts

@@ -56,6 +56,13 @@ export declare class ChatClient {
     private initialize;
     close(): void;
     connectionState(): ChatConnectionState;
+    /** Non-secret identity used to validate a shared browser transport. */
+    identityScope(): {
+        appId: string;
+        profileId: string | undefined;
+        accountId: string | undefined;
+        teamId: string | undefined;
+    };
     watchConnection(handler: (state: ChatConnectionState) => void): () => void;
     private setConnection;
     private rejectPending;

package/lib/runtime/chatClient.js

@@ -120,6 +120,11 @@ export class ChatClient {
         this.rejectPending(new Error("ChatClient closed"));
     }
     connectionState() { return this.connection; }
+    /** Non-secret identity used to validate a shared browser transport. */
+    identityScope() {
+        const identity = this.session?.identity ?? this.session?.session?.identity;
+        return { appId: this.options.appId, profileId: this.profileIdValue ?? this.options.profileId, accountId: identity?.accountId, teamId: this.options.teamId };
+    }
     watchConnection(handler) {
         this.connectionHandlers.add(handler);
         handler(this.connection);
@@ -423,10 +428,11 @@ export class ChatClient {
         return profileId;
     }
     profileId() {
-        if (!this.profileIdValue) {
+        const profileId = this.profileIdValue ?? this.options.profileId;
+        if (!profileId) {
             throw new Error("ChatClient is missing profile id; call connect() first");
         }
-        return this.profileIdValue;
+        return profileId;
     }
     async fetchProfiles(appId, accountId, token) {
         const fetcher = this.options.fetchImpl ?? fetch;

package/lib/runtime/chatSession.d.ts

@@ -1,14 +1,15 @@
 import { type MessageReadersQuery } from "./messageReaders.js";
-import { type MessageClientOptions } from "./messageClient.js";
+import { type MessageClientOptions, type MessageSnapshot } from "./messageClient.js";
 import { DurableChatSender } from "./durableSender.js";
-import { type ReadingClientOptions } from "./readingClient.js";
-import { type ChatClientOptions } from "./chatClient.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";
 export type ChatSessionOptions<T extends StoredMessage> = {
     messages: MessageClientOptions<T>;
     connection: ChatClientOptions;
+    sharedConnection?: ChatClient;
     reading: ReadingClientOptions;
     decode: (message: ChatRuntimeMessage) => T | undefined;
     onError: (error: unknown) => void;
@@ -17,8 +18,21 @@ export type ChatThreadSnapshot<T> = {
     messages: readonly T[];
     outgoing: ReturnType<DurableChatSender["snapshot"]>;
     hasEarlier: boolean;
+    resetVersion: number;
+    complete: boolean;
     unread: ReturnType<typeof unreadInConversation>;
 };
+export type ChatSummarySnapshot<T> = {
+    threads: readonly {
+        threadId: string;
+        lastMessage?: T;
+        unread: ChatThreadSnapshot<T>["unread"];
+        outgoingCount: number;
+    }[];
+    unreadMessageCount: number;
+    badgeCount: number;
+    connection: ChatConnectionState;
+};
 /** Owns all browser message clients. Hosts subscribe to stable thread snapshots. */
 export declare class ChatSession<T extends StoredMessage> {
     private options;
@@ -29,12 +43,28 @@ export declare class ChatSession<T extends StoredMessage> {
     private sender;
     private listeners;
     private snapshots;
+    private historyEdges;
+    private earlierReads;
     private off;
+    private globalListeners;
+    private globalSnapshot?;
+    private connectionState;
+    private catchUp;
+    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;
@@ -42,7 +72,13 @@ export declare class ChatSession<T extends StoredMessage> {
             timestamp: number;
             id: string;
         };
-    }): Promise<import("./messageClient.js").MessageSnapshot<T>>;
+        earlier?: boolean;
+        all?: boolean;
+        refresh?: boolean;
+    }): Promise<MessageSnapshot<T>>;
+    private rememberHistoryEdge;
+    private readEarlier;
+    private readAll;
     sendMessage(threadId: string, input: {
         to: string;
         body: ChatBody;
@@ -51,9 +87,13 @@ export declare class ChatSession<T extends StoredMessage> {
     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"): Promise<import("./readIndex.js").ReadIndexState>;
+    getSnapshot(): ChatSummarySnapshot<T>;
     getSnapshot(threadId: string): ChatThreadSnapshot<T>;
+    subscribe(listener: () => void): () => void;
     subscribe(threadId: string, listener: () => void): () => void;
     private publishAll;
+    private buildGlobal;
+    private publishGlobal;
     private publish;
     close(): Promise<void>;
 }

package/lib/runtime/chatSession.js

@@ -1,3 +1,4 @@
+import { WindowedTasks } from "./coalescer.js";
 import { MessageReadersClient } from "./messageReaders.js";
 import { MessageClient } from "./messageClient.js";
 import { DurableChatSender } from "./durableSender.js";
@@ -14,57 +15,175 @@ export class ChatSession {
     sender;
     listeners = new Map();
     snapshots = new Map();
+    historyEdges = new Map();
+    earlierReads = new Map();
     off = [];
+    globalListeners = new Set();
+    globalSnapshot;
+    connectionState = "closed";
+    catchUp;
+    readingStarted = false;
     closed = false;
     starting;
+    initializing;
     closing;
     constructor(options) {
         this.options = options;
         const scope = options.messages.scope;
         if (options.connection.appId !== scope.appId || options.reading.appId !== scope.appId || options.reading.profileId !== scope.profileId || options.connection.profileId !== scope.profileId || options.connection.teamId !== scope.teamId)
             throw new Error("CHAT_SESSION_SCOPE_MISMATCH");
+        if (options.sharedConnection) {
+            const shared = options.sharedConnection.identityScope();
+            if (shared.appId !== scope.appId || shared.profileId !== scope.profileId || (shared.accountId !== undefined && shared.accountId !== scope.accountId) || (shared.teamId !== undefined && shared.teamId !== scope.teamId))
+                throw new Error("CHAT_SESSION_SCOPE_MISMATCH");
+        }
         this.messages = new MessageClient(options.messages);
-        this.connection = new ChatClient(options.connection);
-        this.reading = new ReadingClient(options.reading);
-        this.readers = new MessageReadersClient({ appId: scope.appId, profileId: scope.profileId, token: options.reading.sessionToken, hubHttpUrl: options.reading.hubHttpUrl, fetch: options.reading.fetch });
+        this.connection = options.sharedConnection ?? new ChatClient(options.connection);
+        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)
+            options.onError(error); });
+        this.off.push(this.messages.subscribeAll(thread => this.publish(thread)));
         this.off.push(this.sender.subscribe(() => this.publishAll()), this.reading.subscribe(() => this.publishAll()));
         this.off.push(this.connection.watchMessages(message => {
             try {
                 const decoded = options.decode(message);
                 if (decoded)
-                    void this.messages.receive(decoded.threadId, [decoded]).then(() => { this.publish(decoded.threadId); return this.sender.confirm([message.hash]); }).catch(options.onError);
+                    void this.messages.receive(decoded.threadId, [decoded]).then(() => this.sender.confirm([message.hash])).catch(error => { if (String(error).includes("MESSAGE_PROJECTION_CHANGED"))
+                        this.messages.invalidate(decoded.threadId);
+                    else if (!this.closed)
+                        options.onError(error); });
             }
             catch (error) {
                 options.onError(error);
             }
         }));
         this.off.push(this.connection.watchConnection(state => {
+            this.connectionState = state;
+            this.publishGlobal();
             if (state === "connected") {
-                for (const thread of this.listeners.keys())
-                    this.messages.invalidate(thread);
-                this.reading.refresh();
+                const since = Date.now();
+                this.catchUp.schedule("scope", () => this.messages.restore(since));
+                if (this.readingStarted)
+                    this.reading.refresh();
             }
         }));
     }
     start() {
         this.assertOpen();
         return this.starting ??= (async () => {
-            await this.sender.initialize();
-            await this.reading.start();
+            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();
+        })().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 = {}) {
         this.assertOpen();
+        if (options.earlier) {
+            if (options.before || options.all || options.limit !== undefined || options.refresh)
+                throw new Error("INVALID_MESSAGE_QUERY");
+            return this.readEarlier(threadId);
+        }
+        if (options.all && (options.before || options.limit !== undefined))
+            throw new Error("INVALID_MESSAGE_QUERY");
+        // Explicit authoritative changes (for example history assignment) can invalidate
+        // even a recently cached empty window. Keep this on the existing read surface.
+        if (options.refresh)
+            await this.messages.read(threadId, options.limit ?? 100, true);
+        if (options.all) {
+            return this.readAll(threadId);
+        }
         const page = await (options.before ? this.messages.earlier(threadId, options.before, options.limit) : this.messages.read(threadId, options.limit));
-        if (!options.before)
-            this.publish(threadId);
+        await this.sender.confirm(page.messages.map(message => message.id));
+        const edge = this.historyEdges.get(threadId);
+        if (!options.before && page.complete && (!edge || edge.version !== page.resetVersion))
+            this.rememberHistoryEdge(threadId, page);
         return page;
     }
+    rememberHistoryEdge(threadId, page) {
+        const first = page.messages[0];
+        this.historyEdges.set(threadId, { before: first ? { timestamp: first.timestamp, id: first.id } : undefined, version: page.resetVersion, hasEarlier: page.hasEarlier });
+    }
+    readEarlier(threadId) {
+        const running = this.earlierReads.get(threadId);
+        if (running)
+            return running;
+        const task = (async () => {
+            const recent = await this.getMessages(threadId);
+            if (!recent.complete)
+                throw new Error("MESSAGE_WINDOW_INCOMPLETE");
+            const edge = this.historyEdges.get(threadId);
+            if (!edge.hasEarlier)
+                return { ...recent, messages: [], hasEarlier: false };
+            if (!edge.before)
+                throw new Error("MESSAGE_SYNC_NO_PROGRESS");
+            const page = await this.getMessages(threadId, { before: edge.before });
+            this.assertOpen();
+            this.rememberHistoryEdge(threadId, page);
+            return page;
+        })().finally(() => { if (this.earlierReads.get(threadId) === task)
+            this.earlierReads.delete(threadId); });
+        this.earlierReads.set(threadId, task);
+        return task;
+    }
+    async readAll(threadId) {
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const pages = [];
+            let version = 0;
+            try {
+                let page = await this.getMessages(threadId);
+                version = page.resetVersion;
+                pages.push(page.messages);
+                if (!page.complete)
+                    return { ...page, hasEarlier: true };
+                let restart = false;
+                while (page.hasEarlier) {
+                    const first = page.messages[0];
+                    if (!first)
+                        throw new Error("MESSAGE_SYNC_NO_PROGRESS");
+                    page = await this.getMessages(threadId, { before: { timestamp: first.timestamp, id: first.id } });
+                    if (page.resetVersion !== version) {
+                        restart = true;
+                        break;
+                    }
+                    pages.push(page.messages);
+                }
+                if (restart)
+                    continue;
+                return { messages: pages.reverse().flat(), hasEarlier: false, complete: true, resetVersion: version };
+            }
+            catch (error) {
+                if ([401, 403].includes(error?.status ?? 0))
+                    throw error;
+                if (String(error).includes("MESSAGE_PROJECTION_CHANGED"))
+                    continue;
+                if (pages.length)
+                    return { messages: pages.reverse().flat(), hasEarlier: true, complete: false, resetVersion: version };
+                throw error;
+            }
+        }
+        throw new Error("MESSAGE_SYNC_RESET_REQUIRED");
+    }
     sendMessage(threadId, input) {
         this.assertOpen();
         return this.sender.enqueue(threadId, input);
@@ -79,34 +198,68 @@ export class ChatSession {
         return event === "played" ? this.reading.recordExplicit(threadId, ids) : this.reading.recordVisible(threadId, ids);
     }
     getSnapshot(threadId) {
+        if (threadId === undefined) {
+            if (!this.globalSnapshot)
+                this.globalSnapshot = this.buildGlobal();
+            return this.globalSnapshot;
+        }
         let snapshot = this.snapshots.get(threadId);
         if (!snapshot) {
             const messages = this.messages.getSnapshot(threadId);
             const state = this.reading.getSnapshot();
-            snapshot = { messages: messages?.messages ?? [], hasEarlier: messages?.hasEarlier ?? 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) : { unreadMessageCount: 0, unreadMentionCount: 0, badgeCount: 0 } };
             this.snapshots.set(threadId, snapshot);
         }
         return snapshot;
     }
-    subscribe(threadId, listener) {
+    subscribe(target, listener) {
         this.assertOpen();
+        if (typeof target === "function") {
+            this.globalListeners.add(target);
+            return () => { this.globalListeners.delete(target); };
+        }
+        const threadId = target;
+        const notify = listener;
         let listeners = this.listeners.get(threadId);
         if (!listeners) {
             listeners = new Set();
             this.listeners.set(threadId, listeners);
         }
-        listeners.add(listener);
-        const off = this.messages.subscribe(threadId, () => this.publish(threadId));
+        listeners.add(notify);
+        const off = this.messages.subscribe(threadId, () => { });
         return () => {
             off();
-            listeners.delete(listener);
+            listeners.delete(notify);
             if (!listeners.size)
                 this.listeners.delete(threadId);
         };
     }
-    publishAll() { for (const threadId of [...this.snapshots.keys()])
-        this.publish(threadId); }
-    publish(threadId) {
+    publishAll() {
+        for (const threadId of [...this.snapshots.keys()])
+            this.publish(threadId, false);
+        this.publishGlobal();
+    }
+    buildGlobal() {
+        const ids = new Set(this.snapshots.keys());
+        for (const thread of this.reading.getSnapshot()?.threads ?? [])
+            if (thread.teamId === this.options.messages.scope.teamId)
+                ids.add(thread.conversationId ?? thread.id);
+        for (const outgoing of this.sender.snapshot())
+            ids.add(outgoing.threadId);
+        const threads = [...ids].sort().map(threadId => {
+            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 };
+    }
+    publishGlobal() {
+        const next = this.buildGlobal();
+        if (JSON.stringify(next) === JSON.stringify(this.globalSnapshot))
+            return;
+        this.globalSnapshot = next;
+        this.globalListeners.forEach(listener => listener());
+    }
+    publish(threadId, notifyGlobal = true) {
         const previous = this.snapshots.get(threadId);
         this.snapshots.delete(threadId);
         const next = this.getSnapshot(threadId);
@@ -115,16 +268,23 @@ export class ChatSession {
             return;
         }
         this.listeners.get(threadId)?.forEach(listener => listener());
+        if (notifyGlobal)
+            this.publishGlobal();
     }
     close() {
         return this.closing ??= (async () => {
             this.closed = true;
+            this.catchUp.close();
             this.off.splice(0).forEach(off => off());
-            this.connection.close();
-            this.readers.close();
-            await Promise.all([this.sender.close(), this.reading.close(), this.messages.close()]);
+            if (!this.options.sharedConnection)
+                this.connection.close();
+            await Promise.all([this.readers.close(), this.sender.close(), this.reading.close(), this.messages.close()]);
             this.listeners.clear();
+            this.globalListeners.clear();
             this.snapshots.clear();
+            this.historyEdges.clear();
+            this.earlierReads.clear();
+            this.globalSnapshot = undefined;
         })();
     }
 }

package/lib/runtime/createChat.d.ts

@@ -0,0 +1,24 @@
+import { ChatSession } from "./chatSession.js";
+import type { ChatReaderSocialMessage } from "./readerClient.js";
+import type { ChatClient, ChatClientOptions } from "./chatClient.js";
+export type CachedChatMessage = ChatReaderSocialMessage & {
+    id: string;
+    timestamp: number;
+};
+export type CreateChatOptions = {
+    appId: string;
+    accountId: string;
+    profileId: string;
+    teamId: string;
+    token: string;
+    endpoint?: string;
+    clientInstanceId?: string;
+    fetch?: typeof fetch;
+    /** Reuse an existing transport for call/presence integrations; its owner closes it. */
+    connection?: ChatClient;
+    onError: (error: unknown) => void;
+    onNotification?: ChatClientOptions["onNotification"];
+    onReach?: ChatClientOptions["onReach"];
+};
+/** Standard browser entry: storage, paging, realtime and reading share one identity. */
+export declare function createChat(options: CreateChatOptions): ChatSession<CachedChatMessage>;

package/lib/runtime/createChat.js

@@ -0,0 +1,39 @@
+import { ChatSession } from "./chatSession.js";
+import { SocialReadClient } from "./socialReadClient.js";
+import { chatTeamId } from "./teamScope.js";
+import { dmThreadId, groupThreadId, isValidChatTeamId } from "./thread.js";
+/** Standard browser entry: storage, paging, realtime and reading share one identity. */
+export function createChat(options) {
+    const { appId, accountId, profileId, teamId, token, onError } = options;
+    if (!isValidChatTeamId(teamId))
+        throw new Error("INVALID_CHAT_TEAM");
+    const endpoint = (options.endpoint ?? "https://hub.pmate.chat").replace(/\/+$/, "");
+    const http = endpoint.replace(/^ws/, "http"), ws = endpoint.replace(/^http/, "ws");
+    const reader = new SocialReadClient({ appId, profileId, token, hubHttpUrl: http, fetch: options.fetch });
+    const page = async (threadId, signal, cursor = {}) => {
+        const result = await reader.messagePage({ threadId, teamId, limit: 100, ...cursor }, signal);
+        return { ...result, messages: result.messages.map(message => ({ ...message, id: message.messageId, timestamp: message.serverCreatedAt })) };
+    };
+    return new ChatSession({
+        sharedConnection: options.connection,
+        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 },
+        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 },
+        decode: message => decodeIncoming(message, { appId, profileId, teamId }), onError,
+    });
+}
+function decodeIncoming(message, scope) {
+    if (message.opcode !== 1 || !message.body || typeof message.body !== "object")
+        return;
+    const body = message.body;
+    if (body.kind !== "message" || body.content?.appId !== scope.appId || chatTeamId(body) !== scope.teamId)
+        return;
+    if (body.threadKind !== "dm" && body.threadKind !== "group")
+        return;
+    if (body.threadKind === "dm" && message.from !== scope.profileId && message.to !== scope.profileId)
+        return;
+    const threadId = body.threadKind === "dm" ? dmThreadId(scope.appId, message.from, message.to, scope.teamId) : groupThreadId(scope.appId, message.to, scope.teamId);
+    return { appId: scope.appId, teamId: scope.teamId, threadId, threadKind: body.threadKind, messageId: message.hash, id: message.hash,
+        timestamp: message.t, serverCreatedAt: message.t, clientCreatedAt: message.t, from: message.from, to: message.to, body: message.body, recipients: message.recipients };
+}

package/lib/runtime/durableSender.js

@@ -143,10 +143,13 @@ export class DurableChatSender {
     /** Confirm only after the authoritative message has been durably merged.
      * A tombstone prevents another tab's late failure from recreating the outbox. */
     async confirm(hashes) {
+        hashes = [...new Set(hashes)];
+        if (!hashes.length)
+            return;
         await this.ready;
         await this.db.transaction("rw", this.outbox, async () => {
             const previous = await this.outbox.bulkGet(hashes.map(hash => [this.scope, hash]));
-            const confirmed = previous.filter((record) => Boolean(record)).map(record => ({ ...record, status: "sent", confirmed: true }));
+            const confirmed = previous.filter((record) => Boolean(record && !record.confirmed)).map(record => ({ ...record, status: "sent", confirmed: true }));
             if (confirmed.length)
                 await this.outbox.bulkPut(confirmed);
         });

package/lib/runtime/index.d.ts

@@ -28,3 +28,4 @@ export * from "./recordCache.js";
 export * from "./durableSender.js";
 export * from "./chatSession.js";
 export * from "./messageReaders.js";
+export * from "./createChat.js";

package/lib/runtime/index.js

@@ -28,3 +28,4 @@ export * from "./recordCache.js";
 export * from "./durableSender.js";
 export * from "./chatSession.js";
 export * from "./messageReaders.js";
+export * from "./createChat.js";