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

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/conversationDirectory.d.ts

@@ -0,0 +1,37 @@
+import type { ResponseCacheAccess } from "./responseCache.js";
+import { type MessageScope } from "./messageStore.js";
+import { type ChatConversation } from "./outgoingContent.js";
+export type ConversationTarget = {
+    peerId: string;
+    groupId?: never;
+} | {
+    groupId: string;
+    peerId?: never;
+};
+/** Canonical target identities only; rosters always belong to GroupClient. */
+export declare class ConversationDirectory {
+    private scope;
+    private access;
+    private cache;
+    private memory;
+    private pending;
+    private queue;
+    private writes;
+    private version;
+    private authority;
+    private scheduled;
+    private closed;
+    private retired;
+    constructor(scope: MessageScope, access: ResponseCacheAccess);
+    private authorize;
+    private assertOpen;
+    private remember;
+    create(target: ConversationTarget): Promise<string>;
+    put(thread: ChatConversation): Promise<ChatConversation>;
+    private persist;
+    get(id: string): Promise<ChatConversation | undefined>;
+    private lookup;
+    private flush;
+    retire(version: number): Promise<void>;
+    close(): Promise<void>;
+}

package/lib/runtime/conversationDirectory.js

@@ -0,0 +1,116 @@
+import { IndexedDbResponseCache } from "./responseCache.js";
+import { messageScopeKey } from "./messageStore.js";
+import { validateConversation } from "./outgoingContent.js";
+import { dmThreadId, groupThreadId } from "./thread.js";
+/** Canonical target identities only; rosters always belong to GroupClient. */
+export class ConversationDirectory {
+    scope;
+    access;
+    cache;
+    memory = new Map();
+    pending = new Map();
+    queue = [];
+    writes = new Map();
+    version;
+    authority;
+    scheduled = false;
+    closed = false;
+    retired = false;
+    constructor(scope, access) {
+        this.scope = scope;
+        this.access = access;
+        this.cache = new IndexedDbResponseCache(`conversations:${messageScopeKey(scope)}`, { access: () => this.authorize(), entries: 256, recordBytes: 4096, retainAll: true });
+    }
+    authorize() { return this.authority ??= this.access().finally(() => { this.authority = undefined; }); }
+    assertOpen() { if (this.retired)
+        throw new Error("CHAT_ACCESS_REVOKED"); if (this.closed)
+        throw new Error("CHAT_SESSION_CLOSED"); }
+    remember(thread) {
+        this.memory.delete(thread.id);
+        this.memory.set(thread.id, thread);
+        if (this.memory.size > 256)
+            this.memory.delete(this.memory.keys().next().value);
+        return thread;
+    }
+    async create(target) {
+        const kind = target.groupId !== undefined ? "group" : "dm", targetId = target.groupId ?? target.peerId;
+        if (target.groupId !== undefined && target.peerId !== undefined)
+            throw new Error("INVALID_MESSAGE_CONVERSATION");
+        const id = kind === "group" ? groupThreadId(this.scope.appId, targetId, this.scope.teamId) : dmThreadId(this.scope.appId, this.scope.profileId, targetId, this.scope.teamId);
+        await this.put({ id, kind, targetId, teamId: this.scope.teamId });
+        return id;
+    }
+    put(thread) {
+        this.assertOpen();
+        validateConversation(this.scope, thread);
+        const existing = this.writes.get(thread.id);
+        if (existing)
+            return existing;
+        if (this.writes.size >= 128)
+            return Promise.reject(new Error("CONVERSATION_BACKPRESSURE"));
+        const task = this.persist(thread).finally(() => this.writes.delete(thread.id));
+        this.writes.set(thread.id, task);
+        return task;
+    }
+    async persist(thread) {
+        this.assertOpen();
+        validateConversation(this.scope, thread);
+        const value = { id: thread.id, kind: thread.kind, targetId: thread.targetId, teamId: this.scope.teamId };
+        const row = await this.lookup(thread.id), previous = row.value;
+        if (previous) {
+            if (previous.kind !== value.kind || previous.targetId !== value.targetId)
+                throw new Error("MESSAGE_CONVERSATION_MISMATCH");
+            return previous;
+        }
+        await this.cache.write(thread.id, value, row.epoch);
+        this.assertOpen();
+        return this.remember(value);
+    }
+    async get(id) { return (await this.lookup(id)).value; }
+    async lookup(id) {
+        this.assertOpen();
+        const authority = await this.authorize();
+        this.assertOpen();
+        if (!authority.allowed)
+            throw new Error("CHAT_ACCESS_REVOKED");
+        if (this.version !== undefined && this.version !== authority.version)
+            this.memory.clear();
+        this.version = authority.version;
+        const known = this.memory.get(id);
+        if (known)
+            return { value: this.remember(known), epoch: 0 };
+        const existing = this.pending.get(id);
+        if (existing)
+            return existing;
+        if (this.pending.size >= 128)
+            throw new Error("CONVERSATION_BACKPRESSURE");
+        const task = new Promise((resolve, reject) => this.queue.push({ id, resolve, reject })).finally(() => this.pending.delete(id));
+        this.pending.set(id, task);
+        if (!this.scheduled) {
+            this.scheduled = true;
+            queueMicrotask(() => { this.scheduled = false; void this.flush(); });
+        }
+        return task;
+    }
+    async flush() {
+        const batch = this.queue.splice(0, 128);
+        try {
+            const rows = await this.cache.readMany(batch.map(item => item.id));
+            this.assertOpen();
+            for (const item of batch) {
+                const row = rows.get(item.id), value = row.cached?.value;
+                if (value) {
+                    if (value.id !== item.id)
+                        throw new Error("MESSAGE_CONVERSATION_MISMATCH");
+                    validateConversation(this.scope, value);
+                }
+                item.resolve({ value: value ? this.remember(value) : undefined, epoch: row.epoch });
+            }
+        }
+        catch (error) {
+            batch.forEach(item => item.reject(error));
+        }
+    }
+    retire(version) { this.retired = true; this.memory.clear(); return this.cache.retire(version); }
+    async close() { this.closed = true; this.memory.clear(); await Promise.allSettled([...this.pending.values(), ...this.writes.values()]); await this.cache.close(); }
+}

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,18 @@
+import { type TokenProvider } from "../credentials.js";
 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;
+    token?: string;
+    getToken?: TokenProvider;
+    /** Limit reconnect reconciliation for a dedicated conversation document. */
+    threadId?: string;
+    uploadEndpoint?: string;
     endpoint?: string;
     clientInstanceId?: string;
     fetch?: typeof fetch;
@@ -21,4 +23,6 @@ export type CreateChatOptions = {
     onReach?: ChatClientOptions["onReach"];
 };
 /** Standard browser entry: storage, paging, realtime and reading share one identity. */
-export declare function createChat(options: CreateChatOptions): ChatSession<CachedChatMessage>;
+export declare function createChatSession(options: CreateChatOptions): ChatSession<CachedChatMessage>;
+/** @deprecated Advanced compatibility factory. Use /chat createChat, or createChatSession for raw sessions. */
+export declare const createChat: typeof createChatSession;

package/lib/runtime/createChat.js

@@ -1,39 +1,62 @@
+import { ChatCredentials } from "../credentials.js";
+import { voiceUploader } from "./voiceUpload.js";
+import { isOffline } from "./connectivity.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;
+export function createChatSession(options) {
+    const { appId, accountId, profileId, teamId, onError } = options;
+    const token = options.token ?? "";
+    if (!token && !options.getToken)
+        throw new Error("INVALID_CHAT_CREDENTIALS");
     if (!isValidChatTeamId(teamId))
         throw new Error("INVALID_CHAT_TEAM");
     const endpoint = (options.endpoint ?? "https://hub.pmate.chat").replace(/\/+$/, "");
     const http = endpoint.replace(/^ws/, "http"), ws = endpoint.replace(/^http/, "ws");
-    const reader = new SocialReadClient({ appId, profileId, token, hubHttpUrl: http, fetch: options.fetch });
+    const credentials = options.getToken ? new ChatCredentials(options.getToken, new URL(http).origin, options.fetch) : undefined;
+    const fetcher = credentials?.fetch ?? options.fetch;
+    const reader = new SocialReadClient({ appId, profileId, token, hubHttpUrl: http, fetch: fetcher });
     const page = async (threadId, signal, cursor = {}) => {
         const result = await reader.messagePage({ threadId, teamId, limit: 100, ...cursor }, signal);
         return { ...result, messages: result.messages.map(message => ({ ...message, id: message.messageId, timestamp: message.serverCreatedAt })) };
     };
     return new ChatSession({
         sharedConnection: options.connection,
-        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,
+        onDispose: () => credentials?.close(),
+        uploadVoice: voiceUploader(profileId, options.uploadEndpoint, fetcher),
+        reconcileOutgoing: async (record, signal) => {
+            if (isOffline())
+                throw new Error("OUTBOX_RECONCILIATION_OFFLINE");
+            const result = await reader.messagePage({ threadId: record.threadId, teamId, messageId: record.message.hash }, signal);
+            const expected = record.message.body;
+            return result.messages.some(message => {
+                const body = message.body;
+                if (message.from !== profileId || message.to !== record.message.to || body?.kind !== expected.kind || body?.action !== expected.action)
+                    throw new Error("OUTBOX_RECONCILIATION_MISMATCH");
+                return true;
+            });
+        },
+        loadGroup: (groupId, signal) => reader.group({ groupId, teamId }, signal),
+        activeThreadId: options.threadId,
+        messages: { scope: { appId, accountId, profileId, teamId }, transport: { authorizeScope: async (signal) => { await reader.contacts(teamId, signal); }, 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: fetcher, onError },
+        connection: { appId, profileId, teamId, hubUrl: ws, clientInstanceId: options.clientInstanceId, fetchImpl: fetcher,
+            getToken: credentials?.getToken,
             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 };
-}
+/** @deprecated Advanced compatibility factory. Use /chat createChat, or createChatSession for raw sessions. */
+export const createChat = createChatSession;

package/lib/runtime/durableSender.d.ts

@@ -8,13 +8,77 @@ export type OutgoingMessage = {
     message: ChatRuntimeMessage;
     status: "sending" | "failed" | "sent";
     confirmed?: boolean;
+    pendingState?: 0 | 1;
+    accessVersion?: number;
+    voiceBlob?: Blob;
+    voiceData?: {
+        bytes: ArrayBuffer;
+        type: string;
+    };
+    voiceAttachment?: {
+        size: number;
+        type: string;
+    };
+};
+export type VoiceAttachmentLease = {
+    url: string;
+    release: () => void;
+};
+export type SendMessageInput = {
+    to: string;
+    body: ChatBody;
+    recipients?: string[];
+    voiceBlob?: Blob; /** SDK-owned reaction sequencing, committed with the exact wire. */
+    reactionRevisionFloor?: number;
+};
+export type SenderScopeAccess = {
+    version: number;
+    allowed: boolean;
+};
+export type DurableSenderOptions = {
+    indexedDB?: IDBFactory;
+    name?: string;
+    access?: () => Promise<SenderScopeAccess>;
+    uploadVoice?: (blob: Blob, signal: AbortSignal) => Promise<string>;
+    reconcile?: (record: Pick<OutgoingMessage, "threadId" | "message">, signal: AbortSignal) => Promise<boolean>;
 };
 /** 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 controlRevisions;
+    private attachments;
+    private schemaReady;
+    private attachmentBytes;
+    private attachmentLeases;
+    private epochs;
+    private uploads;
+    private reconciliations;
+    private firstDelivery;
+    private ioQueue;
+    private ioTimer?;
+    private ioRunning?;
+    private ioCount;
+    private ioBytes;
+    private acceptanceQueue;
+    private acceptanceTimer?;
+    private acceptanceRunning?;
+    private acceptanceCount;
+    private acceptanceBytes;
+    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 +86,54 @@ 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;
+    private scheduleAcceptances;
+    private failAcceptances;
+    private drainAcceptances;
     retry(hash: string): Promise<ChatRuntimeMessage>;
     private transmit;
+    private reconcile;
+    /** Only explicit playback/transcription acquires a local payload, never snapshots. */
+    acquireVoice(hash: string, threadId: string): Promise<VoiceAttachmentLease | undefined>;
+    private reserveAttachment;
+    private readVoice;
+    private prepareVoice;
     private save;
+    private queueIO;
+    private scheduleIO;
+    private failIO;
+    private drainIO;
     /** 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>;
 }