@pmate/chat-sdk 0.12.0-next.5 → 0.12.0-next.50

package/README.md

@@ -142,7 +142,12 @@ 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, { limit: 50 })
+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)))
@@ -153,9 +158,17 @@ await chat.observeMessages(threadId, [voiceId], "played")
 await chat.sendMessage(threadId, { to, body, recipients })
 const readers = await chat.getReaders(threadId, messageId)
 off(); offSummary()
+// Ordinary navigation/shutdown preserves offline data.
 await chat.close()
 ```
 
+```ts
+// When team access is withdrawn, use this instead of ordinary close(). It hides
+// snapshots immediately, retires durable caches/outbox and closes this session.
+// Other teams' reading operations remain intact. Create a new session to recover.
+await chat.revokeAccess()
+```
+
 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.
@@ -198,6 +211,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
@@ -210,3 +228,18 @@ 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.
+
+When the browser reports offline, scheduled message restoration and reading
+refreshes wait for the normal reconnect/wake path. Cached reads remain available;
+unknown receipt counts stay unknown and an uncached reader detail page rejects
+without attempting transport. A network failure arriving after the browser went
+offline does not turn background synchronization into an operation error.
+Authorization failures still revoke the corresponding cached data.
+
+Reading entry points check the message scope even before `initialize()` finishes.
+Concurrent observations share the permission lookup and batch their local writes.
+Visibility/playback operations reject another known team's conversation; a
+permission change in another team does not discard this team's observations.
+Ordinary shutdown waits for accepted local reading writes, while access withdrawal
+rejects late results. Retired asynchronous reading entries reject through promises;
+refresh/subscription teardown remains safe.

package/lib/runtime/batchedReadIndex.d.ts

@@ -1,6 +1,8 @@
-import { type ReadIndexPersistence, type ReadIndexState } from "./readIndex.js";
+import { type ReadIndexPersistence, type ReadIndexState, type ReadIndexTransform, type ReadObservationScope } from "./readIndex.js";
 type Change = {
-    transform: (state: ReadIndexState) => ReadIndexState;
+    weight: number;
+    observation?: ReadObservationScope;
+    transform: ReadIndexTransform;
     resolve: (state: ReadIndexState) => void;
     reject: (error: unknown) => void;
 };
@@ -13,9 +15,20 @@ export declare class BatchedReadIndex implements ReadIndexPersistence {
     private queueLimit;
     private queues;
     private closed;
+    private sourceCounts;
     constructor(storage: ReadIndexPersistence, windowMs?: number, batchSize?: number, queueLimit?: number);
     load(appId: string, profileId: string): Promise<ReadIndexState | undefined>;
-    update(appId: string, profileId: string, transform: Change["transform"]): Promise<ReadIndexState>;
+    loadVersioned(appId: string, profileId: string): Promise<{
+        state: ReadIndexState | undefined;
+        versions: import("./readIndex.js").ReadIndexVersions;
+    } | {
+        state: ReadIndexState | undefined;
+        versions: {};
+    }>;
+    loadVersions(appId: string, profileId: string): Promise<{}>;
+    invalidateTeam(appId: string, profileId: string, teamId: string, version: number, knownThreadIds?: readonly string[]): Promise<ReadIndexState>;
+    private weight;
+    update(appId: string, profileId: string, transform: Change["transform"], observation?: ReadObservationScope): Promise<ReadIndexState>;
     private drain;
     flush(appId: string, profileId: string): Promise<void>;
     close(): Promise<void>;

package/lib/runtime/batchedReadIndex.js

@@ -8,6 +8,7 @@ export class BatchedReadIndex {
     queueLimit;
     queues = new Map();
     closed = false;
+    sourceCounts = new WeakMap();
     constructor(storage, windowMs = 16, batchSize = 128, queueLimit = 4096) {
         this.storage = storage;
         this.windowMs = windowMs;
@@ -22,7 +23,42 @@ export class BatchedReadIndex {
             throw new Error("READ_STORAGE_CLOSED");
         return this.storage.load(appId, profileId);
     }
-    update(appId, profileId, transform) {
+    async loadVersioned(appId, profileId) {
+        await this.flush(appId, profileId);
+        if (this.closed)
+            throw new Error("READ_STORAGE_CLOSED");
+        return this.storage.loadVersioned ? this.storage.loadVersioned(appId, profileId) : { state: await this.storage.load(appId, profileId), versions: {} };
+    }
+    async loadVersions(appId, profileId) {
+        if (this.closed)
+            throw new Error("READ_STORAGE_CLOSED");
+        return this.storage.loadVersions ? this.storage.loadVersions(appId, profileId) : {};
+    }
+    async invalidateTeam(appId, profileId, teamId, version, knownThreadIds) {
+        if (this.closed)
+            throw new Error("READ_STORAGE_CLOSED");
+        if (!this.storage.invalidateTeam)
+            throw new Error("READ_SCOPE_INVALIDATION_UNAVAILABLE");
+        // Do not flush a blocked old HTTP transform first. The durable epoch is the
+        // barrier; any queued transform sees it inside its eventual transaction.
+        return this.storage.invalidateTeam(appId, profileId, teamId, version, knownThreadIds);
+    }
+    weight(observation) {
+        if (!observation)
+            return 1;
+        let counts = this.sourceCounts.get(observation.base);
+        if (!counts) {
+            counts = new Map();
+            for (const thread of observation.base.threads) {
+                counts.set(thread.id, (counts.get(thread.id) ?? 0) + 1);
+                if (thread.conversationId && thread.conversationId !== thread.id)
+                    counts.set(thread.conversationId, (counts.get(thread.conversationId) ?? 0) + 1);
+            }
+            this.sourceCounts.set(observation.base, counts);
+        }
+        return observation.targets.reduce((sum, target) => sum + (counts.get(target.threadId) ?? 1), 0);
+    }
+    update(appId, profileId, transform, observation) {
         if (this.closed)
             return Promise.reject(new Error("READ_STORAGE_CLOSED"));
         const key = JSON.stringify([appId, profileId]);
@@ -33,7 +69,7 @@ export class BatchedReadIndex {
         }
         if (queue.pending.length >= this.queueLimit)
             return Promise.reject(new Error("READ_STORAGE_BACKPRESSURE"));
-        const promise = new Promise((resolve, reject) => queue.pending.push({ transform, resolve, reject }));
+        const promise = new Promise((resolve, reject) => queue.pending.push({ transform, observation, weight: this.weight(observation), resolve, reject }));
         if (!queue.running && queue.timer === undefined)
             queue.timer = setTimeout(() => { queue.timer = undefined; void this.drain(key, queue); }, this.windowMs);
         return promise;
@@ -43,12 +79,22 @@ export class BatchedReadIndex {
             return queue.running;
         clearTimeout(queue.timer);
         queue.timer = undefined;
-        const batch = queue.pending.splice(0, this.batchSize);
+        const batch = [];
+        let weight = 0;
+        while (queue.pending.length && batch.length < this.batchSize) {
+            const nextWeight = queue.pending[0].weight;
+            if (batch.length && weight + nextWeight > 128)
+                break;
+            weight += nextWeight;
+            batch.push(queue.pending.shift());
+        }
         if (!batch.length)
             return;
         const run = (async () => {
             try {
-                const next = await this.storage.update(queue.appId, queue.profileId, state => batch.reduce((current, change) => change.transform(current), state));
+                const first = batch[0].observation;
+                const observation = first && batch.every(change => change.observation?.base === first.base) ? { base: first.base, targets: batch.flatMap(change => change.observation.targets) } : undefined;
+                const next = await this.storage.update(queue.appId, queue.profileId, (state, versions) => batch.reduce((current, change) => change.transform(current, versions), state), observation);
                 batch.forEach(change => change.resolve(next));
             }
             catch (error) {

package/lib/runtime/cachedMessage.d.ts

@@ -0,0 +1,12 @@
+import type { ChatReaderSocialMessage } from "./readerClient.js";
+import type { ChatRuntimeMessage } from "./protocol.js";
+export type CachedChatMessage = ChatReaderSocialMessage & {
+    id: string;
+    timestamp: number;
+    readPolicy?: "visible" | "explicit";
+};
+export declare function decodeCachedChatMessage(message: ChatRuntimeMessage, scope: {
+    appId: string;
+    profileId: string;
+    teamId: string;
+}): CachedChatMessage | undefined;

package/lib/runtime/cachedMessage.js

@@ -0,0 +1,18 @@
+import { chatTeamId } from "./teamScope.js";
+import { dmThreadId, groupThreadId } from "./thread.js";
+export function decodeCachedChatMessage(message, scope) {
+    if (message.opcode !== 1 || !message.body || typeof message.body !== "object")
+        return;
+    const body = message.body;
+    const invitation = body.kind === "contact" && ["friendRequest", "requestFriend"].includes(String(body.action));
+    if ((!invitation && body.kind !== "message") || (invitation ? body.payload?.appId : body.content?.appId) !== scope.appId || chatTeamId(body) !== scope.teamId)
+        return;
+    const threadKind = invitation ? "dm" : body.threadKind;
+    if (threadKind !== "dm" && threadKind !== "group")
+        return;
+    if (threadKind === "dm" && message.from !== scope.profileId && message.to !== scope.profileId)
+        return;
+    const threadId = 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, 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/chatClient.d.ts

@@ -62,6 +62,7 @@ export declare class ChatClient {
         profileId: string | undefined;
         accountId: string | undefined;
         teamId: string | undefined;
+        clientInstanceId: string;
     };
     watchConnection(handler: (state: ChatConnectionState) => void): () => void;
     private setConnection;

package/lib/runtime/chatClient.js

@@ -123,7 +123,7 @@ export class ChatClient {
     /** 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 };
+        return { appId: this.options.appId, profileId: this.profileIdValue ?? this.options.profileId, accountId: identity?.accountId, teamId: this.options.teamId, clientInstanceId: this.instanceId };
     }
     watchConnection(handler) {
         this.connectionHandlers.add(handler);

package/lib/runtime/chatSession.d.ts

@@ -1,36 +1,48 @@
+import { type TimelineItem } from "./messageTimeline.js";
+import { type ReadingCandidate, type MessageReadingState } from "./conversationReading.js";
+import type { ConversationReadMessage } from "./conversationRead.js";
+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 { type ReadingClientOptions } from "./readingClient.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;
     onError: (error: unknown) => void;
 };
 export type ChatThreadSnapshot<T> = {
     messages: readonly T[];
+    timeline: readonly TimelineItem<T>[];
     outgoing: ReturnType<DurableChatSender["snapshot"]>;
     hasEarlier: boolean;
     resetVersion: number;
     complete: boolean;
-    unread: ReturnType<typeof unreadInConversation>;
+    readCounts?: ReadCountsResult;
+    unread: ReturnType<typeof unreadInConversation> | undefined;
+    messageReading: Readonly<Record<string, MessageReadingState>>;
 };
 export type ChatSummarySnapshot<T> = {
     threads: readonly {
         threadId: string;
         lastMessage?: T;
+        lastItem?: TimelineItem<T>;
         unread: ChatThreadSnapshot<T>["unread"];
         outgoingCount: number;
     }[];
-    unreadMessageCount: number;
-    badgeCount: number;
+    unreadMessageCount: number | undefined;
+    badgeCount: number | undefined;
     connection: ChatConnectionState;
 };
 /** Owns all browser message clients. Hosts subscribe to stable thread snapshots. */
@@ -40,18 +52,58 @@ export declare class ChatSession<T extends StoredMessage> {
     private connection;
     private reading;
     private readers;
+    private counts?;
+    private countsReceiver?;
+    private countsThread?;
+    private countSnapshots;
+    private countClosings;
+    private countTasks;
     private sender;
     private listeners;
     private snapshots;
+    private timelineDecoded;
+    private decodeTimeline;
+    private historyEdges;
+    private earlierReads;
     private off;
     private globalListeners;
     private globalSnapshot?;
+    private closedThread;
+    private closedSummary;
     private connectionState;
+    private catchUp;
+    private readingAllowed;
+    private readingListeners;
+    private acceptedReading;
+    private readingAccess?;
+    private readingStarted;
+    private readingStarting?;
+    private withdrawn;
+    private revoking?;
     private closed;
     private starting?;
+    private initializing?;
     private closing?;
     constructor(options: ChatSessionOptions<T>);
+    private scheduleCatchUp;
     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>;
+    private startReading;
+    /** One-time migration only: never establishes trusted history coverage. */
+    importLegacyMessages(threadId: string, messages: T[]): Promise<void>;
+    getReadingSnapshot(): import("./readIndex.js").ReadIndexState | undefined;
+    subscribeReading(listener: () => void): () => void;
+    private setReadingAllowed;
+    private readingAuthority;
+    private authorizeReading;
+    private readingOperation;
+    refreshReading(): void;
+    synchronizeReading(cursor?: string, profileId?: string): Promise<import("./readIndex.js").ReadIndexState>;
+    /** Explicit text-history acknowledgement; unheard audio stays unread. */
+    markRead(threadId: string, messages?: readonly ConversationReadMessage[]): Promise<import("./readIndex.js").ReadIndexState>;
+    updateReading(transform: Parameters<ReadingClient["update"]>[0]): Promise<import("./readIndex.js").ReadIndexState>;
     private assertOpen;
     getMessages(threadId: string, options?: {
         limit?: number;
@@ -59,24 +111,36 @@ export declare class ChatSession<T extends StoredMessage> {
             timestamp: number;
             id: string;
         };
+        earlier?: boolean;
         all?: boolean;
+        refresh?: boolean;
     }): Promise<MessageSnapshot<T>>;
+    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"): Promise<import("./readIndex.js").ReadIndexState>;
+    observeMessages(threadId: string, ids: string[], event: "visible" | "played"): ReturnType<ReadingClient["recordVisible"]>;
+    observeMessages(threadId: string | undefined, ids: string[], event: "receipts", clientInstanceId?: string): Promise<void>;
+    /** Bridge transports can delegate social events without maintaining clients. */
+    handleReach(event: OnlineReachEvent): Promise<"handled" | undefined>;
+    private wakeCounts;
+    private publishCountSnapshot;
+    private publishCounts;
+    private watchCounts;
     getSnapshot(): ChatSummarySnapshot<T>;
     getSnapshot(threadId: string): ChatThreadSnapshot<T>;
+    private buildThreadSnapshot;
     subscribe(listener: () => void): () => void;
-    subscribe(threadId: string, listener: () => void): () => void;
+    subscribe(threadId: string, listener: () => void, fields?: readonly (keyof ChatThreadSnapshot<T>)[]): () => void;
     private publishAll;
     private buildGlobal;
     private publishGlobal;
     private publish;
+    /** Permanently retire this identity/team session. UI withdrawal is immediate;
+     * completion means all durable stores have crossed the same authority epoch. */
+    revokeAccess(): Promise<void>;
     close(): Promise<void>;
+    private dispose;
 }