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

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;
 }