@pmate/chat-sdk 0.12.0-next.7 → 0.12.0-next.70

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),
+    });
+    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" : "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;

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);
@@ -161,7 +161,7 @@ export class ChatClient {
         catch (error) {
             if (generation !== this.generation)
                 return;
-            if (error instanceof ChatAckError) {
+            if (error instanceof ChatAckError || ["authentication-required", "access-denied"].includes(error?.code ?? "")) {
                 this.close();
                 this.setConnection("authentication_required");
             }
@@ -295,7 +295,12 @@ export class ChatClient {
         });
     }
     async sendAuth() {
-        const token = this.session?.token;
+        const generation = this.generation;
+        const token = this.options.getToken ? await this.options.getToken() : this.session?.token;
+        if (generation !== this.generation)
+            throw new Error("ChatClient closed");
+        if (this.session && token)
+            this.session = { ...this.session, token };
         if (!token) {
             throw new Error("Missing PMate session token");
         }

package/lib/runtime/chatError.d.ts

@@ -0,0 +1,3 @@
+import { ChatError } from "../chatError.js";
+export { ChatError, type ChatErrorCode } from "../chatError.js";
+export declare function asChatError(error: unknown): ChatError;

package/lib/runtime/chatError.js

@@ -0,0 +1,15 @@
+import { ChatError } from "../chatError.js";
+export { ChatError } from "../chatError.js";
+export function asChatError(error) {
+    if (error instanceof ChatError)
+        return error;
+    const value = error;
+    const status = value?.status, message = value?.message ?? String(error);
+    const code = status === 401 ? "authentication-required" : status === 403 || /ACCESS_REVOKED|ACCESS_DENIED|SCOPE_CHANGED/.test(message) ? "access-denied"
+        : /CLOSED/.test(message) ? "closed"
+            : status === 409 || /REVISION_CONFLICT|PROJECTION_CHANGED/.test(message) ? "conflict"
+                : /BACKPRESSURE|TOO_LARGE/.test(message) ? "busy"
+                    : status === 400 || /INVALID_|CONVERSATION_MISMATCH|CONVERSATION_UNKNOWN|NOT_OWNED/.test(message) ? "invalid-input"
+                        : /QuotaExceeded|DatabaseClosed|UnknownError|AbortError/.test(value?.name ?? "") || /STORAGE_|DATABASE_|CACHE_WRITE/.test(message) ? "storage-unavailable" : "unavailable";
+    return new ChatError(code, message, { cause: error, status });
+}

package/lib/runtime/chatSession.d.ts

@@ -1,59 +1,124 @@
+import { type ConversationTarget } from "./conversationDirectory.js";
+import { type ChatGroup } from "./groupClient.js";
+import type { SocialGroup } from "./socialReadClient.js";
+import { type ChatConversation, type OutgoingContent } from "./outgoingContent.js";
+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, type VoiceAttachmentLease } 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> = {
+    onDispose?: () => void;
     messages: MessageClientOptions<T>;
     connection: ChatClientOptions;
     sharedConnection?: ChatClient;
+    activeThreadId?: string;
+    uploadVoice?: DurableSenderOptions["uploadVoice"];
+    reconcileOutgoing?: DurableSenderOptions["reconcile"];
+    loadGroup?: (groupId: string, signal: AbortSignal) => Promise<SocialGroup>;
     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>;
+    group?: ChatGroup;
+    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>;
+        group?: ChatGroup;
         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. */
 export declare class ChatSession<T extends StoredMessage> {
     private options;
+    private conversations;
     private messages;
     private connection;
     private reading;
     private readers;
+    private groups?;
+    private counts?;
+    private countsReceiver?;
+    private countsThread?;
+    private countSnapshots;
+    private countClosings;
+    private countTasks;
+    private controlTails;
+    private acceptedControls;
+    private controlCount;
+    private controlBytes;
     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;
@@ -61,25 +126,74 @@ export declare class ChatSession<T extends StoredMessage> {
             timestamp: number;
             id: string;
         };
+        earlier?: boolean;
         all?: boolean;
         refresh?: boolean;
     }): Promise<MessageSnapshot<T>>;
+    private confirmMessages;
+    private rememberHistoryEdge;
+    private readEarlier;
     private readAll;
-    sendMessage(threadId: string, input: {
-        to: string;
-        body: ChatBody;
-        recipients?: string[];
+    /** Reads trusted local group metadata immediately; SDK refreshes it in the background. */
+    getGroup(thread: ChatConversation | string, options?: {
+        refresh?: boolean;
+    }): Promise<ChatGroup>;
+    createGroup(thread: ChatConversation, content: {
+        title: string;
+        members: readonly string[];
+    }): Promise<ChatGroup>;
+    updateGroup(target: ChatConversation | string, changes: {
+        expectedRevision?: string;
+        addMembers?: readonly string[];
+        removeMembers?: readonly string[];
+        title?: string;
+        avatar?: string;
+    }): Promise<ChatGroup>;
+    sendMessage(threadId: string, input: OutgoingContent, options?: {
+        waitFor?: "accepted" | "delivered";
+    }): Promise<ChatRuntimeMessage>;
+    sendMessage(thread: ChatConversation, input: OutgoingContent, options?: {
+        waitFor?: "accepted" | "delivered";
+    }): Promise<ChatRuntimeMessage>;
+    sendMessage(threadId: string, input: SendMessageInput, options?: {
+        waitFor?: "accepted" | "delivered";
     }): Promise<ChatRuntimeMessage>;
+    private sendWire;
+    getConversation(target: ConversationTarget): Promise<string>;
+    private sendContent;
+    private resolveConversation;
+    /** Validated target identity survives content redaction; no roster is exposed. */
+    getConversationTarget(threadId: string): ChatConversation | undefined;
+    private sendControl;
     getReaders(threadId: string, messageId: string, page?: Omit<MessageReadersQuery, "threadId" | "messageId">, signal?: AbortSignal): Promise<import("./messageReaders.js").MessageReadersPage>;
+    /** Resolve voice media uniformly; pending local bytes are loaded only on demand. */
+    getVoiceAttachment(threadId: string, messageId: string): Promise<VoiceAttachmentLease>;
     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>;
-    subscribe(listener: () => void): () => void;
-    subscribe(threadId: string, listener: () => void): () => void;
+    private buildThreadSnapshot;
+    /** Delivers the current stable snapshot immediately, then only meaningful changes. */
+    subscribe(listener: (snapshot: ChatSummarySnapshot<T>) => void): () => void;
+    subscribe(threadId: string, listener: (snapshot: ChatThreadSnapshot<T>) => void, fields?: readonly (keyof ChatThreadSnapshot<T>)[]): () => void;
+    /** Change-only bridge for useSyncExternalStore and other framework adapters. */
+    subscribeChanges(listener: () => void): () => void;
+    subscribeChanges(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>;
+    get active(): boolean;
     close(): Promise<void>;
+    private dispose;
 }