@pmate/chat-sdk 0.12.0-next.8 → 0.12.0-next.80

package/lib/internal/chatEngine.js

@@ -0,0 +1,284 @@
+import { createMessagePresenter } from "../messageView.js";
+import { createChat as createSession } from "../runtime/createChat.js";
+import { asChatError } from "../runtime/chatError.js";
+import { ChatError } from "../chatError.js";
+export { ChatError } from "../chatError.js";
+const emptyMessages = Object.freeze([]);
+/** App-facing API. Cache coverage, raw protocol and synchronization stay in advanced. */
+export class ChatEngine {
+    advanced;
+    options;
+    groups = new WeakMap();
+    group(value) {
+        if (!value)
+            return undefined;
+        let projected = this.groups.get(value);
+        if (!projected) {
+            const { versionNumber: _, ...visible } = value;
+            projected = visible;
+            this.groups.set(value, projected);
+        }
+        return projected;
+    }
+    present = createMessagePresenter();
+    redactedQuotes = new WeakMap();
+    messageLists = new WeakMap();
+    messages(items) {
+        let values = this.messageLists.get(items);
+        if (!values) {
+            const recalled = new Set(items.filter(item => item.recalled).map(item => item.id));
+            values = items.map(item => {
+                const value = this.present(item);
+                if (!value.quote?.messageId || !recalled.has(value.quote.messageId))
+                    return value;
+                let hidden = this.redactedQuotes.get(value);
+                if (!hidden) {
+                    hidden = { ...value, quote: { ...value.quote, content: "", recalled: true } };
+                    this.redactedQuotes.set(value, hidden);
+                }
+                return hidden;
+            });
+            this.messageLists.set(items, values);
+        }
+        return values;
+    }
+    views = new Map();
+    summary;
+    targets = new Map();
+    errors = new Map();
+    listeners = new Map();
+    closed = false;
+    constructor(advanced, options) {
+        this.advanced = advanced;
+        this.options = options;
+    }
+    async operation(run) { try {
+        return await run();
+    }
+    catch (error) {
+        throw asChatError(error);
+    } }
+    async deny(threadId, failure) {
+        this.errors.set(threadId, failure);
+        this.targets.delete(threadId);
+        const retiring = this.advanced.revokeThread(threadId);
+        this.notify(threadId);
+        try {
+            await retiring;
+        }
+        catch (error) {
+            failure.cause = new AggregateError([failure.cause, error], "Access withdrawn; cache cleanup incomplete");
+        }
+    }
+    threadOperation(threadId, run) {
+        return this.operation(async () => {
+            const denied = threadId ? this.errors.get(threadId) : undefined;
+            if (denied?.code === "access-denied")
+                throw denied;
+            try {
+                return await run();
+            }
+            catch (error) {
+                const failure = threadId ? await this.advanced.conversationFailure(error, threadId) : asChatError(error);
+                if (threadId && failure.code === "access-denied" && failure.threadId)
+                    await this.deny(threadId, failure);
+                throw failure;
+            }
+        });
+    }
+    start() { return this.operation(() => this.options.connection ? this.advanced.initialize() : this.advanced.start()); }
+    /** Resolve a scoped ID locally, registering its target when needed. No remote group is created. */
+    resolveThreadId(target) { return this.getConversation(target); }
+    /** A trusted recent window. Source selection and synchronization belong to the SDK. */
+    getThread(threadId, options = {}) { return this.readForCaller(() => this.getMessages(threadId), options); }
+    loadEarlier(threadId, options = {}) { return this.readForCaller(() => this.getMessages(threadId, { earlier: true }), options); }
+    refreshThread(threadId, options = {}) { return this.readForCaller(() => this.getMessages(threadId, { refresh: true }), options); }
+    readForCaller(run, { signal }) {
+        if (signal?.aborted)
+            return Promise.reject(signal.reason ?? new DOMException("The operation was aborted", "AbortError"));
+        if (!signal)
+            return run();
+        // A caller's cancellation never aborts another subscriber's shared read.
+        return new Promise((resolve, reject) => {
+            const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason ?? new DOMException("The operation was aborted", "AbortError")); };
+            signal.addEventListener("abort", abort, { once: true });
+            run().then(value => { signal.removeEventListener("abort", abort); resolve(value); }, error => { signal.removeEventListener("abort", abort); reject(error); });
+        });
+    }
+    threadSubscribers = new Map();
+    openQueue = new Set();
+    opening = 0;
+    drainOpens() {
+        while (!this.closed && this.opening < 4 && this.openQueue.size) {
+            const id = this.openQueue.values().next().value;
+            this.openQueue.delete(id);
+            if (!this.threadSubscribers.has(id))
+                continue;
+            this.opening++;
+            void this.getThread(id).catch(() => { }).finally(() => { this.opening--; this.drainOpens(); });
+        }
+    }
+    /** Listen first, then open the local window; concurrent consumers share the initial read. */
+    subscribeThread(threadId, listener, options = {}) {
+        const off = this.subscribe(threadId, listener, options), count = this.threadSubscribers.get(threadId) ?? 0;
+        this.threadSubscribers.set(threadId, count + 1);
+        if (!count) {
+            this.openQueue.add(threadId);
+            this.drainOpens();
+        }
+        let disposed = false;
+        return () => {
+            if (disposed)
+                return;
+            disposed = true;
+            off();
+            const remaining = (this.threadSubscribers.get(threadId) ?? 1) - 1;
+            if (remaining)
+                this.threadSubscribers.set(threadId, remaining);
+            else {
+                this.threadSubscribers.delete(threadId);
+                this.openQueue.delete(threadId);
+            }
+        };
+    }
+    /** @deprecated Use resolveThreadId. Retained only for the migration window. */
+    getConversation(target) {
+        return this.operation(async () => {
+            const id = await this.advanced.getConversation(target);
+            const value = target.groupId !== undefined ? { kind: "group", targetId: target.groupId } : { kind: "dm", targetId: target.peerId };
+            this.targets.delete(id);
+            this.targets.set(id, value);
+            if (this.targets.size > 256)
+                this.targets.delete(this.targets.keys().next().value);
+            this.notify(id);
+            return id;
+        });
+    }
+    getSnapshot(threadId) {
+        if (threadId === undefined) {
+            const source = this.advanced.getSnapshot(), previous = this.summary;
+            const threads = source.threads.filter(thread => this.errors.get(thread.threadId)?.code !== "access-denied").map(thread => ({ threadId: thread.threadId, lastMessage: this.messages(this.advanced.getSnapshot(thread.threadId).timeline).at(-1), group: this.group(thread.group), unread: thread.unread, outgoingCount: thread.outgoingCount }));
+            const unreadMessageCount = source.unreadMessageCount === undefined ? undefined : threads.reduce((sum, thread) => sum + (thread.unread?.unreadMessageCount ?? 0), 0);
+            const badgeCount = source.badgeCount === undefined ? undefined : threads.reduce((sum, thread) => sum + (thread.unread?.badgeCount ?? 0), 0);
+            if (previous && previous.connection === source.connection && previous.badgeCount === badgeCount && previous.unreadMessageCount === unreadMessageCount && previous.threads.length === threads.length && threads.every((thread, i) => { const old = previous.threads[i]; return thread.threadId === old.threadId && thread.lastMessage === old.lastMessage && thread.group === old.group && thread.unread === old.unread && thread.outgoingCount === old.outgoingCount; }))
+                return previous;
+            return this.summary = { threads, connection: source.connection, badgeCount, unreadMessageCount };
+        }
+        const source = this.advanced.getSnapshot(threadId), previous = this.views.get(threadId);
+        const error = this.closed ? undefined : this.errors.get(threadId), denied = error?.code === "access-denied";
+        const target = this.closed || !this.advanced.active || denied ? undefined : this.advanced.getConversationTarget(threadId) ?? this.targets.get(threadId);
+        const conversation = previous?.conversation?.kind === target?.kind && previous?.conversation?.targetId === target?.targetId ? previous?.conversation : target ? { kind: target.kind, targetId: target.targetId } : undefined;
+        // Partial migrated rows never masquerade as a trusted recent window.
+        const next = { threadId, conversation, messages: !denied && source.complete ? this.messages(source.timeline) : emptyMessages, ready: !denied && source.complete, hasEarlier: !denied && source.hasEarlier, unread: denied ? undefined : source.unread, group: denied ? undefined : this.group(source.group), readCounts: denied ? undefined : source.readCounts, error, status: !denied && source.complete ? "ready" : error ? "error" : "pending" };
+        if (previous && Object.keys(next).every(key => next[key] === previous[key]))
+            return previous;
+        this.views.set(threadId, next);
+        return next;
+    }
+    async getMessages(threadId, query = {}) {
+        try {
+            const denied = this.errors.get(threadId);
+            if (denied?.code === "access-denied")
+                throw denied;
+            if (Object.keys(query).some(key => !["earlier", "all", "refresh"].includes(key)))
+                throw new ChatError("invalid-input", "Unsupported message query");
+            const page = await this.advanced.getMessages(threadId, query);
+            if (!page.complete)
+                throw new ChatError("unavailable", "Messages are not ready; retry when connected");
+            this.errors.delete(threadId);
+            this.notify(threadId);
+            return this.getSnapshot(threadId);
+        }
+        catch (error) {
+            const failure = await this.advanced.conversationFailure(error, threadId);
+            if (!this.closed) {
+                if (failure.code === "access-denied" && failure.threadId)
+                    await this.deny(threadId, failure);
+                else {
+                    this.errors.set(threadId, failure);
+                    this.notify(threadId);
+                }
+            }
+            throw failure;
+        }
+    }
+    sendMessage(threadId, content, options = {}) {
+        return this.threadOperation(threadId, async () => {
+            if (content && ("groupCreate" in content || "groupUpdate" in content || "groupDissolve" in content))
+                throw new ChatError("invalid-input", "Use group lifecycle methods for group changes");
+            const result = await this.advanced.sendMessage(threadId, content, options);
+            return { id: result.hash, timestamp: result.t };
+        });
+    }
+    retryMessage(messageId) { return this.operation(async () => { const result = await this.advanced.retryMessage(messageId); return { id: result.hash, timestamp: result.t }; }); }
+    subscribe(target, callback, options = {}) {
+        const global = typeof target === "function", key = global ? "" : target;
+        const config = global ? callback : options;
+        const read = () => global ? this.getSnapshot() : this.getSnapshot(key);
+        let previous = read();
+        const emit = () => {
+            const value = read();
+            const fields = config?.fields;
+            const changed = fields ? fields.some(field => previous[field] !== value[field]) : value !== previous;
+            previous = value;
+            if (changed) {
+                try {
+                    (global ? target : callback)(value);
+                }
+                catch (error) {
+                    try {
+                        this.options.onError(error);
+                    }
+                    catch { /* A consumer cannot break other consumers or cache publication. */ }
+                }
+            }
+        };
+        let listeners = this.listeners.get(key);
+        if (!listeners) {
+            listeners = new Set();
+            this.listeners.set(key, listeners);
+        }
+        listeners.add(emit);
+        const off = global ? this.advanced.subscribeChanges(emit) : this.advanced.subscribeChanges(key, emit, this.sessionFields(options.fields));
+        const dispose = () => { off(); listeners.delete(emit); if (!listeners.size)
+            this.listeners.delete(key); };
+        if (config?.emitCurrent !== false) {
+            try {
+                (global ? target : callback)(previous);
+            }
+            catch (error) {
+                dispose();
+                throw error;
+            }
+        }
+        return dispose;
+    }
+    sessionFields(fields) {
+        return fields ? [...new Set(fields.flatMap(field => field === "messages" ? ["timeline", "complete"] : field === "ready" || field === "status" ? ["complete"] : field === "conversation" ? ["messages", "group"] : field === "error" || field === "threadId" ? [] : [field]))] : undefined;
+    }
+    notify(threadId) { this.listeners.get(threadId)?.forEach(listener => listener()); this.listeners.get("")?.forEach(listener => listener()); }
+    observeMessages(threadId, ids, event) { return this.threadOperation(threadId, async () => { await this.advanced.observeMessages(threadId, ids, event); }); }
+    markRead(threadId) { return this.threadOperation(threadId, async () => { await this.advanced.markRead(threadId); }); }
+    getReaders(threadId, messageId, page = {}, signal) {
+        return this.threadOperation(threadId, async () => {
+            if (Object.keys(page).some(key => !["afterProfileId", "revision"].includes(key)))
+                throw new ChatError("invalid-input", "Unsupported reader query");
+            return this.advanced.getReaders(threadId, messageId, page, signal);
+        });
+    }
+    watchReaders(threadId, ids, receiver) { return this.threadOperation(threadId, () => this.advanced.observeMessages(threadId, ids, "receipts", receiver)); }
+    handleReach(event) { return this.operation(() => this.advanced.handleReach(event)); }
+    getVoiceAttachment(threadId, messageId) { return this.threadOperation(threadId, () => this.advanced.getVoiceAttachment(threadId, messageId)); }
+    getGroup(threadId, options = {}) { return this.threadOperation(threadId, async () => this.group(await this.advanced.getGroup(threadId, options))); }
+    createGroup(input) {
+        return this.operation(async () => {
+            const groupId = input.groupId ?? crypto.randomUUID(), threadId = await this.getConversation({ groupId });
+            const group = await this.advanced.createGroup({ id: threadId, kind: "group", targetId: groupId, teamId: this.options.teamId }, { title: input.title, members: input.members });
+            return { ...this.group(group), threadId };
+        });
+    }
+    updateGroup(threadId, changes) { return this.threadOperation(threadId, async () => this.group(await this.advanced.updateGroup(threadId, changes))); }
+    dissolveGroup(threadId, options = {}) { return this.threadOperation(threadId, async () => this.group(await this.advanced.dissolveGroup(threadId, options))); }
+    revokeAccess() { return this.operation(() => this.advanced.revokeAccess()); }
+    close() { this.closed = true; return this.operation(() => this.advanced.close()).finally(() => { this.errors.clear(); this.targets.clear(); this.listeners.clear(); this.threadSubscribers.clear(); this.openQueue.clear(); this.views.clear(); this.summary = undefined; this.present = createMessagePresenter(); this.messageLists = new WeakMap(); this.groups = new WeakMap(); this.redactedQuotes = new WeakMap(); }); }
+}

package/lib/internal/chatRegistry.d.ts

@@ -0,0 +1,4 @@
+import type { Chat } from "../chatContract.js";
+import type { ChatEngine } from "./chatEngine.js";
+export declare function registerChat(chat: Chat, engine: ChatEngine): void;
+export declare function chatEngine(chat: Chat): ChatEngine;

package/lib/internal/chatRegistry.js

@@ -0,0 +1,4 @@
+const engines = new WeakMap();
+export function registerChat(chat, engine) { engines.set(chat, engine); }
+export function chatEngine(chat) { const engine = engines.get(chat); if (!engine)
+    throw new TypeError("Unknown Chat client"); return engine; }

package/lib/internal/createPublicChat.d.ts

@@ -0,0 +1,4 @@
+import type { Chat } from "../chatContract.js";
+import { type CreateChatOptions } from "../runtime/createChat.js";
+/** Build only the public capabilities; no aliases or engine fields on the returned object. */
+export declare function createPublicChat(options: CreateChatOptions): Chat;

package/lib/internal/createPublicChat.js

@@ -0,0 +1,52 @@
+import { waitForCaller } from "../credentials.js";
+import { ChatEngine } from "./chatEngine.js";
+import { registerChat } from "./chatRegistry.js";
+import { createChat as createSession } from "../runtime/createChat.js";
+import { asChatError } from "../runtime/chatError.js";
+import { ChatError } from "../chatError.js";
+/** Build only the public capabilities; no aliases or engine fields on the returned object. */
+export function createPublicChat(options) {
+    const configured = { ...options, onError: (error) => options.onError?.(asChatError(error)) };
+    let session;
+    try {
+        session = createSession(configured);
+    }
+    catch (error) {
+        throw asChatError(error);
+    }
+    const engine = new ChatEngine(session, configured);
+    const keys = (value, allowed) => { if (Object.keys(value).some(key => !allowed.includes(key)))
+        throw new ChatError("invalid-input", "Unsupported operation options"); };
+    const read = (run, options = {}, cleanup) => {
+        try {
+            keys(options, ["signal"]);
+            options.signal?.throwIfAborted();
+            return waitForCaller(run(), options.signal, cleanup);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    };
+    const chat = Object.freeze({
+        start: () => engine.start(), close: () => engine.close(),
+        resolveThreadId: (target, options = {}) => read(() => engine.resolveThreadId(target), options),
+        getThread: (id, options) => read(() => engine.getThread(id), options), loadEarlier: (id, options) => read(() => engine.loadEarlier(id), options), refreshThread: (id, options) => read(() => engine.refreshThread(id), options),
+        subscribeThread: (id, listener, options = {}) => { keys(options, ["fields"]); return engine.subscribeThread(id, listener, options); }, subscribeChat: (listener, options = {}) => { keys(options, ["fields"]); return engine.subscribe(listener, options); },
+        sendMessage: (id, content, options) => engine.sendMessage(id, content, options), retryMessage: id => engine.retryMessage(id),
+        observeMessages: (id, ids, event) => engine.observeMessages(id, ids, event), markRead: id => engine.markRead(id), watchReaders: (id, ids, receiver) => engine.watchReaders(id, ids, receiver),
+        getReaders: (id, messageId, options = {}) => {
+            try {
+                keys(options, ["afterProfileId", "revision", "signal"]);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+            return read(() => engine.getReaders(id, messageId, { afterProfileId: options.afterProfileId, revision: options.revision }), { signal: options.signal });
+        },
+        getVoiceAttachment: (id, messageId, options = {}) => read(() => engine.getVoiceAttachment(id, messageId), options, lease => lease.release()),
+        getGroup: (id, options = {}) => read(() => engine.getGroup(id), options), refreshGroup: (id, options = {}) => read(() => engine.getGroup(id, { refresh: true }), options),
+        createGroup: input => engine.createGroup(input), updateGroup: (id, changes) => engine.updateGroup(id, changes), dissolveGroup: (id, options) => engine.dissolveGroup(id, options),
+    });
+    registerChat(chat, engine);
+    return chat;
+}

package/lib/messageView.d.ts

@@ -0,0 +1,6 @@
+import type { TimelineItem } from "./runtime/messageTimeline.js";
+import type { CachedChatMessage } from "./runtime/cachedMessage.js";
+import type { ChatMessage } from "./chatTypes.js";
+export type { ChatMessage } from "./chatTypes.js";
+/** Decode a body once; reading and delivery projections reuse its normalized content. */
+export declare function createMessagePresenter(): (item: TimelineItem<CachedChatMessage>) => ChatMessage;

package/lib/messageView.js

@@ -0,0 +1,103 @@
+import { parseChatFile } from "./fileMetadata.js";
+const object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+const text = (value) => typeof value === "string" ? value : "";
+function media(value) {
+    if (typeof value !== "string" || !value)
+        return undefined;
+    try {
+        const url = new URL(value, "https://chat.invalid");
+        return ["https:", "http:"].includes(url.protocol) && !url.username && !url.password ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function quote(value) {
+    const record = object(value);
+    if (typeof record.senderName !== "string" || typeof record.content !== "string" || record.content.length > 6000)
+        return;
+    return { senderName: record.senderName.slice(0, 100), content: record.content, ...(typeof record.messageId === "string" ? { messageId: record.messageId } : {}) };
+}
+function legacyDuration(value) {
+    if (typeof value !== "string" || !/^\d+:\d{2}$/.test(value))
+        return 0;
+    const [minutes, seconds] = value.split(":").map(Number);
+    return (minutes * 60 + seconds) * 1000;
+}
+function content(message) {
+    const body = object(message.body), outer = object(body.content);
+    const envelope = body.kind === "quote" && outer.content !== undefined ? outer : body;
+    const payload = object(envelope.content);
+    const legacy = object(message.legacyDisplay);
+    const validLegacy = legacy.id === message.id && legacy.threadId === message.threadId && legacy.orgId === message.teamId && legacy.from === message.from && typeof legacy.content === "string";
+    const hint = validLegacy ? legacy : {};
+    const file = parseChatFile(payload.file === undefined ? hint.file : payload.file);
+    const contentKind = envelope.contentKind, voice = object(payload.voice);
+    const voiceHint = hint.kind === "voice";
+    const voiceUrl = media(voice.url) ?? (voiceHint ? media(hint.audioUrl) : undefined) ?? "";
+    const durationMs = typeof voice.durationMs === "number" && Number.isFinite(voice.durationMs) ? voice.durationMs : voiceHint ? legacyDuration(hint.duration) : 0;
+    const hasVoice = voiceHint || Object.keys(voice).length > 0 && (voiceUrl.length > 0 || durationMs > 0) || contentKind === "voice";
+    const imageUrl = media(payload.url) ?? (hint.kind === "image" ? media(hint.imageUrl) : undefined);
+    const messageQuote = quote(payload.quote) ?? quote(hint.quote);
+    const rawText = text(payload.text) || text(object(body.payload).message);
+    const result = { kind: "text", text: validLegacy ? text(hint.content) : rawText, senderName: text(hint.senderName) || undefined, senderAvatar: media(hint.senderAvatar), timeLabel: text(hint.createdAt) || undefined,
+        recipientCount: message.threadKind === "dm" ? 1 : validLegacy ? typeof hint.recipientCount === "number" ? hint.recipientCount : undefined : Array.isArray(message.recipients) ? new Set(message.recipients.filter(id => id !== message.from)).size : undefined };
+    if (validLegacy && ["emoji", "system", "attachment", "quote"].includes(String(hint.kind)))
+        result.kind = hint.kind;
+    if (body.kind === "contact") {
+        result.kind = ["friendRequest", "requestFriend"].includes(String(body.action)) ? "invitation" : "system";
+        if (result.kind === "system")
+            result.system = { type: "contact-updated" };
+    }
+    else if (body.kind === "group") {
+        result.kind = "system";
+        result.system = { type: body.action === "groupCreate" ? "group-created" : body.action === "groupDissolve" ? "group-dissolved" : "group-updated", title: text(object(body.payload).title) || undefined };
+    }
+    else if (file) {
+        result.kind = "attachment";
+        result.file = file;
+    }
+    else if (hasVoice) {
+        result.kind = "voice";
+        result.voice = { url: voiceUrl, durationMs, ...(text(voice.transcript) || text(hint.transcript) ? { transcript: text(voice.transcript) || text(hint.transcript) } : {}) };
+    }
+    else if ((contentKind === "image" || hint.kind === "image") && imageUrl) {
+        result.kind = "image";
+        result.image = { url: imageUrl, name: text(payload.name) || text(hint.imageAlt) || undefined };
+    }
+    else if (contentKind === "emoji") {
+        result.kind = "emoji";
+        result.text = text(payload.code) || result.text;
+    }
+    if (messageQuote) {
+        result.quote = messageQuote;
+        if (result.kind === "text")
+            result.kind = "quote";
+    }
+    if (result.kind === "attachment")
+        result.attachment = { name: text(hint.attachmentName) || undefined, size: text(hint.attachmentSize) || undefined };
+    if (payload.format !== undefined)
+        result.richContent = payload;
+    else if (hint.richContent !== undefined)
+        result.richContent = hint.richContent;
+    if (Array.isArray(payload.mentions))
+        result.mentions = payload.mentions;
+    return result;
+}
+/** Decode a body once; reading and delivery projections reuse its normalized content. */
+export function createMessagePresenter() {
+    const bodies = new WeakMap(), items = new WeakMap();
+    return (item) => {
+        const previous = items.get(item);
+        if (previous)
+            return previous;
+        let value = { kind: "system", text: "" };
+        if (!item.recalled && item.message) {
+            value = bodies.get(item.message) ?? content(item.message);
+            bodies.set(item.message, value);
+        }
+        const result = { id: item.id, threadId: item.threadId, timestamp: item.timestamp, from: item.from, mine: item.mine, status: item.status, recalled: item.recalled, unread: item.unread, attentionEligible: item.attentionEligible, reading: item.reading, reactions: item.reactions, ...value };
+        items.set(item, result);
+        return result;
+    };
+}

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

@@ -16,6 +16,7 @@ export type ChatClientOptions = {
     onNotification?: OnlineNotificationHandler;
     profileId?: string;
     botKey?: PmateBotKeyFile | string | unknown;
+    getToken?: () => Promise<string>;
     session?: BotLoginSession;
     hubUrl?: string;
     authBaseUrl?: string;
@@ -62,6 +63,7 @@ export declare class ChatClient {
         profileId: string | undefined;
         accountId: string | undefined;
         teamId: string | undefined;
+        clientInstanceId: string;
     };
     watchConnection(handler: (state: ChatConnectionState) => void): () => void;
     private setConnection;
@@ -121,6 +123,11 @@ export declare class ChatClient {
         title?: string;
         avatar?: string;
     }): Promise<ChatRuntimeMessage>;
+    dissolveGroup(input: {
+        groupId: string;
+        teamId?: string;
+        expectedRevision: string;
+    }): Promise<ChatRuntimeMessage>;
     sendGroup(input: {
         groupId: string;
         teamId?: string;