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

package/lib/runtime/connectivity.d.ts

@@ -0,0 +1,4 @@
+/** Browser connectivity is advisory: only suppress network errors while the
+ * browser explicitly reports offline. Permission and data errors stay visible. */
+export declare function isOffline(): boolean;
+export declare function isOfflineNetworkFailure(error: unknown): boolean;

package/lib/runtime/connectivity.js

@@ -0,0 +1,8 @@
+/** Browser connectivity is advisory: only suppress network errors while the
+ * browser explicitly reports offline. Permission and data errors stay visible. */
+export function isOffline() {
+    return typeof navigator !== "undefined" && navigator.onLine === false;
+}
+export function isOfflineNetworkFailure(error) {
+    return isOffline() && (error instanceof TypeError || error?.name === "AbortError");
+}

package/lib/runtime/conversationRead.d.ts

@@ -0,0 +1,13 @@
+import { type ReadIndexState } from "./readIndex.js";
+/** Optional observations whose index metadata may still be in flight. */
+export type ConversationReadMessage = {
+    id: string;
+    threadId: string;
+    mine?: boolean;
+    from?: string;
+    recalled?: boolean;
+    readPolicy?: "visible" | "explicit";
+    kind?: string;
+};
+/** Explicitly mark ordinary text history read; unheard audio stays unread. */
+export declare function recordConversationRead(state: ReadIndexState, conversationId: string, messages?: readonly ConversationReadMessage[], operationId?: () => `${string}-${string}-${string}-${string}-${string}`): ReadIndexState;

package/lib/runtime/conversationRead.js

@@ -0,0 +1,34 @@
+import { recordReadIntent, sourcesInConversation } from "./readIndex.js";
+/** Explicitly mark ordinary text history read; unheard audio stays unread. */
+export function recordConversationRead(state, conversationId, messages = [], operationId = () => crypto.randomUUID()) {
+    if (!conversationId)
+        throw new Error("INVALID_READING_THREAD");
+    const sources = sourcesInConversation(state, conversationId);
+    if (new Set(sources.map(source => source.teamId)).size > 1)
+        throw new Error("READ_CONVERSATION_TEAM_MISMATCH");
+    let next = state;
+    const indexedIds = new Set();
+    for (const source of sources) {
+        const incoming = source.messages.filter(message => {
+            indexedIds.add(message.id);
+            return !message.recalled && message.from !== state.profileId && message.recipients.includes(state.profileId);
+        });
+        const latest = incoming.filter(message => message.readPolicy === "visible" && message.seq > source.readThroughSeq)
+            .reduce((last, message) => !last || message.seq > last.seq ? message : last, undefined);
+        if (latest)
+            next = recordReadIntent(next, { operationId: operationId(), threadId: source.id, messageId: latest.id, readPolicy: "visible" });
+    }
+    // Live/history messages can precede their read-index metadata. Persist their
+    // observations so leaving the page or reloading cannot resurrect the badge.
+    const observed = new Set(next.observedReadIntents?.filter(intent => intent.threadId === conversationId).map(intent => intent.messageId));
+    for (const message of messages) {
+        if (message.threadId !== conversationId || message.mine || message.from === state.profileId || message.recalled || indexedIds.has(message.id) || observed.has(message.id))
+            continue;
+        const readPolicy = message.readPolicy ?? (message.kind === "voice" ? "explicit" : "visible");
+        if (message.kind === "voice" || readPolicy === "explicit")
+            continue;
+        next = recordReadIntent(next, { operationId: operationId(), threadId: conversationId, messageId: message.id, readPolicy });
+        observed.add(message.id);
+    }
+    return next;
+}

package/lib/runtime/conversationReading.d.ts

@@ -0,0 +1,28 @@
+import { unreadInConversation, type ReadIndexState } from "./readIndex.js";
+export type ReadingCandidate = {
+    id: string;
+    threadId: string;
+    from?: string;
+    mine?: boolean;
+    recalled?: boolean;
+    unread?: boolean;
+    attentionEligible?: boolean;
+    readPolicy?: "visible" | "explicit";
+};
+export type MessageReadingState = {
+    seq?: number;
+    read: boolean;
+    readPolicy: "visible" | "explicit";
+};
+export type ConversationReadingView = {
+    messageReading: Readonly<Record<string, MessageReadingState>>;
+    unread: ReturnType<typeof unreadInConversation> | undefined;
+    badgeCount: number | undefined;
+};
+/** One projection for indexed authority and observations awaiting indexing. A
+ * directory badge is optional compatibility metadata, never proof of coverage. */
+export declare function projectConversationReading(state: ReadIndexState | undefined, conversation: {
+    id: string;
+    kind: "dm" | "group";
+    badgeCount?: number;
+}, candidates?: readonly ReadingCandidate[]): ConversationReadingView;

package/lib/runtime/conversationReading.js

@@ -0,0 +1,47 @@
+import { sourcesInConversation, unreadInConversation } from "./readIndex.js";
+/** One projection for indexed authority and observations awaiting indexing. A
+ * directory badge is optional compatibility metadata, never proof of coverage. */
+export function projectConversationReading(state, conversation, candidates = []) {
+    const unique = new Map(candidates.filter(message => message.threadId === conversation.id).map(message => [message.id, message]));
+    const hidden = new Map();
+    for (const message of unique.values())
+        if (message.recalled && message.from)
+            hidden.set(message.id, new Set([message.from]));
+    const sources = state ? sourcesInConversation(state, conversation.id) : [];
+    const sourceIds = new Set([conversation.id, ...sources.map(source => source.id)]);
+    const indexed = new Set(), messageReading = Object.create(null);
+    for (const source of sources)
+        for (const message of source.messages) {
+            indexed.add(message.id);
+            messageReading[message.id] = { seq: message.seq, readPolicy: message.readPolicy, read: message.recalled || hidden.get(message.id)?.has(message.from) === true || message.from === state.profileId || !message.recipients.includes(state.profileId) || (message.readPolicy === "explicit" ? source.explicitReadMessageIds.includes(message.id) : message.seq <= source.readThroughSeq) };
+        }
+    const observed = new Map();
+    for (const intent of state?.observedReadIntents ?? [])
+        if (sourceIds.has(intent.threadId)) {
+            if (!observed.has(intent.messageId))
+                observed.set(intent.messageId, new Set());
+            observed.get(intent.messageId).add(intent.readPolicy);
+        }
+    let pendingMessages = 0, pendingMentions = 0, observedBadges = 0;
+    for (const message of unique.values()) {
+        const incoming = !message.mine && message.from !== state?.profileId && !message.recalled;
+        const attention = conversation.kind === "dm" || message.attentionEligible === true;
+        const policy = message.readPolicy ?? "visible";
+        const acknowledged = observed.get(message.id)?.has(policy) === true;
+        if (!indexed.has(message.id) && acknowledged)
+            messageReading[message.id] = { read: true, readPolicy: policy };
+        if (!incoming)
+            continue;
+        if (acknowledged && attention)
+            observedBadges++;
+        if (indexed.has(message.id) || acknowledged || message.unread !== true)
+            continue;
+        pendingMessages++;
+        if (message.attentionEligible === true)
+            pendingMentions++;
+    }
+    const authoritative = sources.length && state ? unreadInConversation(state, conversation.id, hidden) : undefined;
+    const unread = authoritative ? { unreadMessageCount: authoritative.unreadMessageCount + pendingMessages, unreadMentionCount: authoritative.unreadMentionCount + pendingMentions, badgeCount: authoritative.badgeCount + (conversation.kind === "group" ? pendingMentions : pendingMessages) } : undefined;
+    const pendingBadge = conversation.kind === "group" ? pendingMentions : pendingMessages;
+    return { messageReading, unread, badgeCount: unread?.badgeCount ?? (conversation.badgeCount === undefined ? undefined : Math.max(Math.max(0, conversation.badgeCount - observedBadges), pendingBadge)) };
+}

package/lib/runtime/createChat.d.ts

@@ -1,16 +1,16 @@
 import { ChatSession } from "./chatSession.js";
-import type { ChatReaderSocialMessage } from "./readerClient.js";
 import type { ChatClient, ChatClientOptions } from "./chatClient.js";
-export type CachedChatMessage = ChatReaderSocialMessage & {
-    id: string;
-    timestamp: number;
-};
+import { type CachedChatMessage } from "./cachedMessage.js";
+export type { CachedChatMessage } from "./cachedMessage.js";
 export type CreateChatOptions = {
     appId: string;
     accountId: string;
     profileId: string;
     teamId: string;
     token: string;
+    /** Limit reconnect reconciliation for a dedicated conversation document. */
+    threadId?: string;
+    uploadEndpoint?: string;
     endpoint?: string;
     clientInstanceId?: string;
     fetch?: typeof fetch;

package/lib/runtime/createChat.js

@@ -1,7 +1,9 @@
+import { voiceUploader } from "./voiceUpload.js";
+import { isReadingControl, messageRequiresPlayback, messageMentionsProfile } from "./readingContent.js";
 import { ChatSession } from "./chatSession.js";
 import { SocialReadClient } from "./socialReadClient.js";
-import { chatTeamId } from "./teamScope.js";
-import { dmThreadId, groupThreadId, isValidChatTeamId } from "./thread.js";
+import { isValidChatTeamId } from "./thread.js";
+import { decodeCachedChatMessage } from "./cachedMessage.js";
 /** Standard browser entry: storage, paging, realtime and reading share one identity. */
 export function createChat(options) {
     const { appId, accountId, profileId, teamId, token, onError } = options;
@@ -16,24 +18,21 @@ export function createChat(options) {
     };
     return new ChatSession({
         sharedConnection: options.connection,
+        uploadVoice: voiceUploader(profileId, options.uploadEndpoint, options.fetch),
+        activeThreadId: options.threadId,
         messages: { scope: { appId, accountId, profileId, teamId }, transport: { load: (thread, signal) => page(thread, signal), changes: (thread, after, signal) => page(thread, signal, { after }), older: (thread, before, signal) => page(thread, signal, { before }) }, onError },
         reading: { appId, profileId, sessionToken: token, hubHttpUrl: http, fetch: options.fetch, onError },
         connection: { appId, profileId, teamId, hubUrl: ws, clientInstanceId: options.clientInstanceId, fetchImpl: options.fetch,
             session: { token, identity: { accountId, app: appId, profileId } }, onNotification: options.onNotification, onReach: options.onReach },
-        decode: message => decodeIncoming(message, { appId, profileId, teamId }), onError,
+        readingCandidate: message => {
+            if (isReadingControl(message.body, appId))
+                return undefined;
+            const body = message.body;
+            if (!body || !["message", "quote"].includes(String(body.kind)) && !(body.kind === "contact" && ["friendRequest", "requestFriend"].includes(String(body.action))))
+                return undefined;
+            return { id: message.id, threadId: message.threadId, from: message.from, mine: message.from === profileId, recalled: message.recalled, unread: message.from !== profileId,
+                readPolicy: message.readPolicy === "explicit" || message.legacyDisplay?.kind === "voice" || messageRequiresPlayback(body) ? "explicit" : "visible", attentionEligible: messageMentionsProfile(body, profileId) };
+        },
+        decode: message => decodeCachedChatMessage(message, { appId, profileId, teamId }), onError,
     });
 }
-function decodeIncoming(message, scope) {
-    if (message.opcode !== 1 || !message.body || typeof message.body !== "object")
-        return;
-    const body = message.body;
-    if (body.kind !== "message" || body.content?.appId !== scope.appId || chatTeamId(body) !== scope.teamId)
-        return;
-    if (body.threadKind !== "dm" && body.threadKind !== "group")
-        return;
-    if (body.threadKind === "dm" && message.from !== scope.profileId && message.to !== scope.profileId)
-        return;
-    const threadId = body.threadKind === "dm" ? dmThreadId(scope.appId, message.from, message.to, scope.teamId) : groupThreadId(scope.appId, message.to, scope.teamId);
-    return { appId: scope.appId, teamId: scope.teamId, threadId, threadKind: body.threadKind, messageId: message.hash, id: message.hash,
-        timestamp: message.t, serverCreatedAt: message.t, clientCreatedAt: message.t, from: message.from, to: message.to, body: message.body, recipients: message.recipients };
-}

package/lib/runtime/durableSender.d.ts

@@ -8,13 +8,52 @@ export type OutgoingMessage = {
     message: ChatRuntimeMessage;
     status: "sending" | "failed" | "sent";
     confirmed?: boolean;
+    pendingState?: 0 | 1;
+    accessVersion?: number;
+    voiceBlob?: Blob;
+    voiceData?: {
+        bytes: ArrayBuffer;
+        type: string;
+    };
+};
+export type SendMessageInput = {
+    to: string;
+    body: ChatBody;
+    recipients?: string[];
+    voiceBlob?: Blob;
+};
+export type SenderScopeAccess = {
+    version: number;
+    allowed: boolean;
+};
+export type DurableSenderOptions = {
+    indexedDB?: IDBFactory;
+    name?: string;
+    access?: () => Promise<SenderScopeAccess>;
+    uploadVoice?: (blob: Blob, signal: AbortSignal) => Promise<string>;
 };
 /** Persists the exact wire message before sending; retries preserve its hash. */
 export declare class DurableChatSender {
     private client;
     private onError;
+    private options;
     private db;
     private outbox;
+    private epochs;
+    private localUrls;
+    private localViews;
+    private uploads;
+    private uploadTail;
+    private uploadWaiting;
+    private confirmationQueue;
+    private confirmationTimer?;
+    private confirmationRunning?;
+    private confirmationSize;
+    private version;
+    private withdrawn;
+    private revoking?;
+    private channel?;
+    private accepted;
     private scope;
     private identity;
     private values;
@@ -22,35 +61,45 @@ export declare class DurableChatSender {
     private listeners;
     private running;
     private closed;
+    private closing;
+    private empty;
     private offConnection;
     private ready;
-    constructor(client: ChatClient, scope: MessageScope, onError: (error: unknown) => void, options?: {
-        indexedDB?: IDBFactory;
-        name?: string;
-    });
+    constructor(client: ChatClient, scope: MessageScope, onError: (error: unknown) => void, options?: DurableSenderOptions);
+    /** Read only the selected durable rows, without restoring or delivering an outbox. */
+    static readSelected(scope: MessageScope, threadId: string, ids: readonly string[], version: number, options?: Pick<DurableSenderOptions, "indexedDB" | "name">): Promise<OutgoingMessage[]>;
+    private readAccess;
+    private restore;
+    private checkAccess;
+    private withEpoch;
+    private deleteRows;
+    /** Stop disclosure immediately; durable invalidation is coordinated separately. */
+    withdraw(): void;
+    revoke(targetVersion?: number): Promise<void>;
     initialize(): Promise<void>;
     subscribe(listener: () => void): () => void;
     snapshot(threadId?: string): readonly OutgoingMessage[];
     private emit;
     /** Resolves after the exact wire message is durable, independently of network delivery. */
-    enqueue(threadId: string, input: {
-        to: string;
-        body: ChatBody;
-        recipients?: string[];
-    }): Promise<ChatRuntimeMessage>;
+    enqueue(threadId: string, input: SendMessageInput): Promise<ChatRuntimeMessage>;
     /** Compatibility API: resolves only after transport delivery. */
-    send(threadId: string, input: {
-        to: string;
-        body: ChatBody;
-        recipients?: string[];
-    }): Promise<ChatRuntimeMessage>;
+    send(threadId: string, input: SendMessageInput): Promise<ChatRuntimeMessage>;
     private persistOutgoing;
     retry(hash: string): Promise<ChatRuntimeMessage>;
     private transmit;
+    private releaseUrl;
+    private releaseUrls;
+    private localView;
+    private prepareVoice;
     private save;
     /** Confirm only after the authoritative message has been durably merged.
      * A tombstone prevents another tab's late failure from recreating the outbox. */
     confirm(hashes: string[]): Promise<void>;
+    private scheduleConfirmations;
+    private drainConfirmations;
+    private failConfirmations;
+    private flushConfirmations;
+    private confirmNow;
     private resume;
     close(): Promise<void>;
 }