@awiki/dsh-plugin 0.2.4 → 0.3.0-rc.1

package/lib/types/sdk-adapter.js

@@ -14,6 +14,8 @@ const RUST_FAILURE_CODES = {
     handle_unavailable: 'handle-unavailable',
     not_found: 'not-found',
     permission_denied: 'forbidden',
+    group_not_member: 'group-membership-required',
+    group_identity_stale: 'group-identity-stale',
     auth_revoked: 'forbidden',
     conflict: 'conflict',
     join_required: 'handle-unavailable',
@@ -37,7 +39,7 @@ export class AwikiSdkError extends Error {
 function fail(code = 'remote') {
     throw new AwikiSdkError(code);
 }
-function mapError(error) {
+function mapError(error, ambiguousSend = false) {
     if (error instanceof AwikiSdkError)
         throw error;
     let code = 'remote';
@@ -45,7 +47,9 @@ function mapError(error) {
         if (typeof error === 'object' && error !== null) {
             const value = error;
             if (value.name === 'ImCoreNodeError' && typeof value.code === 'string') {
-                code = RUST_FAILURE_CODES[value.code] ?? 'remote';
+                code = ambiguousSend && (value.code === 'timeout' || value.code === 'transport_unavailable')
+                    ? 'delivery-unknown'
+                    : RUST_FAILURE_CODES[value.code] ?? 'remote';
             }
         }
     }
@@ -71,6 +75,143 @@ function required(value) {
         fail();
     return value;
 }
+/** Recover the browser's exact optimistic message identity without widening the Remote schema. */
+function browserMessageId(idempotencyKey) {
+    return /^msg-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u.test(idempotencyKey)
+        ? idempotencyKey
+        : undefined;
+}
+function remoteString(value, maxBytes) {
+    if (typeof value !== 'string' || value.includes('\0') || Buffer.byteLength(value, 'utf8') > maxBytes)
+        fail();
+    return value;
+}
+function remoteOptionalString(value, maxBytes) {
+    return value === undefined ? undefined : remoteString(value, maxBytes);
+}
+function mailToken(value, maxCharacters) {
+    if (typeof value !== 'string'
+        || value.length === 0
+        || value.trim() !== value
+        || Array.from(value).length > maxCharacters
+        || /[\u0000-\u001f\u007f-\u009f]/u.test(value))
+        fail();
+    return value;
+}
+function mailAddress(value) {
+    if (typeof value !== 'string')
+        fail();
+    const length = Array.from(value).length;
+    if (length < 3
+        || length > 320
+        || !value.includes('@')
+        || /[\s\u0000-\u001f\u007f-\u009f]/u.test(value))
+        fail();
+    return value;
+}
+function mailAddresses(value) {
+    if (!Array.isArray(value) || value.length > 100)
+        fail();
+    return value.map(mailAddress);
+}
+function mailTimestamp(value) {
+    if (value === undefined)
+        return undefined;
+    const copied = remoteString(value, 64);
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/u.test(copied)
+        || !Number.isFinite(Date.parse(copied)))
+        fail();
+    return copied;
+}
+function uint32(value) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 0xffff_ffff)
+        fail();
+    return value;
+}
+function recoveryE2eeGroupCount(impact) {
+    if (typeof impact !== 'object' || impact === null)
+        fail();
+    const value = impact;
+    return uint32(value.unsupportedE2eeGroupCount !== undefined
+        ? value.unsupportedE2eeGroupCount
+        : value.unsupportedE2EeGroupCount);
+}
+function boolean(value) {
+    if (typeof value !== 'boolean')
+        fail();
+    return value;
+}
+function mailSummary(value) {
+    const receivedAt = mailTimestamp(value.receivedAt);
+    const sentAt = mailTimestamp(value.sentAt);
+    const folder = value.folder === undefined ? undefined : mailToken(value.folder, 64);
+    const preview = remoteOptionalString(value.preview, 4_096);
+    const attachmentCount = value.attachmentCount === undefined ? undefined : uint32(value.attachmentCount);
+    return {
+        id: mailToken(value.id, 2_048),
+        ...folder === undefined ? {} : { folder },
+        from: mailAddresses(value.from),
+        to: mailAddresses(value.to),
+        cc: mailAddresses(value.cc),
+        subject: remoteString(value.subject, 1_024),
+        subjectTruncated: boolean(value.subjectTruncated),
+        ...preview === undefined ? {} : { preview },
+        previewTruncated: boolean(value.previewTruncated),
+        ...receivedAt === undefined ? {} : { receivedAt },
+        ...sentAt === undefined ? {} : { sentAt },
+        unread: boolean(value.unread),
+        hasAttachments: boolean(value.hasAttachments),
+        ...attachmentCount === undefined ? {} : { attachmentCount },
+    };
+}
+function mailAttachment(value) {
+    const fileName = remoteOptionalString(value.fileName, 512);
+    const contentType = remoteOptionalString(value.contentType, 255);
+    const sizeBytes = value.sizeBytes === undefined ? undefined : remoteString(value.sizeBytes, 20);
+    if (sizeBytes !== undefined && !/^(?:0|[1-9]\d*)$/u.test(sizeBytes))
+        fail();
+    return {
+        index: uint32(value.index),
+        ...fileName === undefined ? {} : { fileName },
+        ...contentType === undefined ? {} : { contentType },
+        ...sizeBytes === undefined ? {} : { sizeBytes },
+    };
+}
+function mailAccount(value) {
+    const mailboxAddress = value.mailboxAddress === undefined ? undefined : mailAddress(value.mailboxAddress);
+    const displayName = remoteOptionalString(value.displayName, 512);
+    const status = remoteOptionalString(value.status, 128);
+    return {
+        ...mailboxAddress === undefined ? {} : { mailboxAddress },
+        ...displayName === undefined ? {} : { displayName },
+        ...status === undefined ? {} : { status },
+    };
+}
+function mailInbox(value) {
+    if (!Array.isArray(value.items) || value.items.length > 100)
+        fail();
+    const hasMore = boolean(value.hasMore);
+    const nextOffset = value.nextOffset === undefined ? undefined : uint32(value.nextOffset);
+    if ((hasMore && nextOffset === undefined) || (!hasMore && nextOffset !== undefined))
+        fail();
+    return {
+        items: value.items.map(mailSummary),
+        ...nextOffset === undefined ? {} : { nextOffset },
+        hasMore,
+    };
+}
+function mailMessage(value) {
+    if (!Array.isArray(value.attachments) || value.attachments.length > 100)
+        fail();
+    const bodyText = remoteOptionalString(value.bodyText, 65_536);
+    return {
+        summary: mailSummary(value.summary),
+        ...bodyText === undefined ? {} : { bodyText },
+        bodyTruncated: boolean(value.bodyTruncated),
+        hasHtmlBody: boolean(value.hasHtmlBody),
+        attachments: value.attachments.map(mailAttachment),
+    };
+}
 function sha256(value) {
     const provided = value.sha256Hex?.toLowerCase();
     if (provided !== undefined && /^[a-f0-9]{64}$/u.test(provided))
@@ -93,6 +234,67 @@ function identity(value) {
         registeredAt: safeInteger(value.registeredAtMs),
     };
 }
+function profile(value) {
+    return {
+        did: required(value.did),
+        ...value.handle === undefined ? {} : { handle: value.handle },
+        displayName: value.displayName?.trim() ?? '',
+        bio: value.bio ?? '',
+        tags: [...value.tags],
+        ...value.updatedAt === undefined ? {} : { updatedAt: value.updatedAt },
+    };
+}
+function mentionPayload(value) {
+    if (value.content.kind !== 'payload' || value.content.payloadJson === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(value.content.payloadJson);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== 'object' || parsed === null || !('text' in parsed) || typeof parsed.text !== 'string')
+        return undefined;
+    const text = parsed.text;
+    if (!('mentions' in parsed) || !Array.isArray(parsed.mentions))
+        return { text };
+    const length = Array.from(text).length;
+    const mentions = [];
+    for (const raw of parsed.mentions) {
+        if (typeof raw !== 'object' || raw === null
+            || !('id' in raw) || typeof raw.id !== 'string' || raw.id.trim() === ''
+            || !('range' in raw) || typeof raw.range !== 'object' || raw.range === null
+            || !('start' in raw.range) || !Number.isSafeInteger(raw.range.start)
+            || !('end' in raw.range) || !Number.isSafeInteger(raw.range.end)
+            || !('unit' in raw.range) || raw.range.unit !== 'unicode_code_point'
+            || raw.range.start < 0
+            || raw.range.end <= raw.range.start
+            || raw.range.end > length
+            || !('target' in raw) || typeof raw.target !== 'object' || raw.target === null
+            || !('kind' in raw.target) || raw.target.kind !== 'human'
+            || !('did' in raw.target) || typeof raw.target.did !== 'string' || !raw.target.did.startsWith('did:')) {
+            return { text };
+        }
+        const displayName = 'display_name' in raw.target && typeof raw.target.display_name === 'string'
+            ? raw.target.display_name
+            : undefined;
+        mentions.push({
+            id: raw.id,
+            start: raw.range.start,
+            end: raw.range.end,
+            did: raw.target.did,
+            ...displayName === undefined ? {} : { displayName },
+        });
+    }
+    const ordered = [...mentions].sort((left, right) => left.start - right.start || left.end - right.end);
+    if (ordered.some((item, index) => index > 0 && item.start < ordered[index - 1].end))
+        return { text };
+    const characters = Array.from(text);
+    if (ordered.some(item => !characters.slice(item.start, item.end).join('').startsWith('@')))
+        return { text };
+    return ordered.length === 0 ? { text } : { text, mentions: ordered };
+}
 /** Copy one native attachment and normalize its decimal/digest encodings. */
 function attachment(value) {
     return {
@@ -112,9 +314,16 @@ function preview(value) {
             const fileName = value.content.attachment?.fileName;
             return fileName === undefined ? undefined : `[附件] ${fileName}`;
         }
+        case 'payload': return mentionPayload(value)?.text;
         default: return undefined;
     }
 }
+/** Provider-only protocol events are not part of the browser's text/attachment history contract. */
+function displayableMessage(value) {
+    return value.content.kind === 'text'
+        || value.content.kind === 'attachment'
+        || mentionPayload(value) !== undefined;
+}
 /** Copy one native page and brand its opaque cursor for the Host API. */
 function page(value, copy) {
     return {
@@ -151,17 +360,77 @@ export class RustSdkAdapter {
     client;
     attachmentConversations = new Map();
     disposal;
+    listener;
     constructor(client) {
         this.client = Promise.resolve(client);
+        this.listener = {
+            syncNow: reason => this.listenerSyncNow(reason),
+            startRealtime: () => this.listenerStartRealtime(),
+            listConversations: request => this.listenerConversations(request),
+            getHistory: request => this.listenerHistory(request),
+            markConversationRead: conversationId => this.markConversationRead(conversationId),
+            sendText: request => this.sendText(request),
+        };
     }
-    async run(operation) {
+    async run(operation, ambiguousSend = false) {
         try {
             return await operation(await this.client);
         }
         catch (error) {
-            mapError(error);
+            mapError(error, ambiguousSend);
         }
     }
+    async displayableMessages(client, values) {
+        const messages = values.filter(displayableMessage);
+        const peers = [...new Set(messages
+                .filter(message => (message.conversationKind === 'group'
+                && !message.outgoing
+                && message.senderHandle === undefined
+                && message.senderDisplayName === undefined))
+                .map(message => message.senderDid))];
+        if (peers.length === 0)
+            return [...messages];
+        const profiles = await client.hydrateDisplayProfiles({ peers });
+        const byDid = new Map();
+        for (const profile of profiles) {
+            if (profile.did !== undefined)
+                byDid.set(profile.did, profile);
+        }
+        return messages.map((message) => {
+            const profile = byDid.get(message.senderDid);
+            if (profile === undefined)
+                return message;
+            return {
+                ...message,
+                ...profile.handle === undefined ? {} : { senderHandle: profile.handle },
+                ...profile.displayName === undefined ? {} : { senderDisplayName: profile.displayName },
+            };
+        });
+    }
+    /**
+     * Join the persisted Core peer-profile projection onto direct roster rows.
+     * The conversation registry intentionally keeps routing identifiers separate
+     * from display metadata, so a bare roster row may otherwise regress to a Handle.
+     */
+    async displayableConversations(client, values) {
+        const peers = [...new Set(values
+                .filter((conversation) => (conversation.kind === 'direct' && conversation.peerDid !== undefined))
+                .map(conversation => conversation.peerDid))];
+        const profiles = peers.length === 0 ? [] : await client.hydrateDisplayProfiles({ peers });
+        const byPeer = new Map();
+        for (const [index, profile] of profiles.entries()) {
+            const requested = peers[index];
+            if (requested !== undefined)
+                byPeer.set(requested, profile);
+            if (profile.did !== undefined)
+                byPeer.set(profile.did, profile);
+            if (profile.handle !== undefined)
+                byPeer.set(profile.handle, profile);
+        }
+        return values.map(value => this.conversation(value, value.kind === 'direct'
+            ? byPeer.get(value.peerDid ?? '') ?? byPeer.get(value.peerHandle ?? '')
+            : undefined));
+    }
     message(value) {
         const sentAt = value.sentAt === undefined ? fail() : timestamp(value.sentAt);
         const common = {
@@ -193,12 +462,29 @@ export class RustSdkAdapter {
                     },
                 };
             }
+            case 'payload': {
+                const parsed = mentionPayload(value);
+                if (parsed === undefined)
+                    fail();
+                return {
+                    ...common,
+                    content: {
+                        kind: 'text',
+                        text: parsed.text,
+                        ...parsed.mentions === undefined ? {} : { mentions: parsed.mentions },
+                    },
+                };
+            }
             default: fail();
         }
     }
-    conversation(value) {
+    conversation(value, profile) {
         const id = required(value.id);
-        const title = value.title?.trim();
+        const displayName = profile?.displayName?.trim();
+        const profileHandle = profile?.handle?.trim();
+        const title = displayName === undefined || displayName.length === 0
+            ? value.title?.trim()
+            : displayName;
         const lastMessagePreview = preview(value.lastMessage);
         const common = {
             id,
@@ -209,14 +495,17 @@ export class RustSdkAdapter {
             ...value.lastMessageAt === undefined ? {} : { lastMessageAt: timestamp(value.lastMessageAt) },
             ...lastMessagePreview === undefined ? {} : { lastMessagePreview },
         };
-        if (value.lastMessage !== undefined)
+        if (value.lastMessage !== undefined && displayableMessage(value.lastMessage))
             this.message(value.lastMessage);
         switch (value.kind) {
             case 'direct': return {
                 kind: 'direct',
                 ...common,
-                peerDid: required(value.peerDid),
-                ...value.peerHandle === undefined ? {} : { peerHandle: value.peerHandle },
+                peerDid: required(profile?.did ?? value.peerDid),
+                ...profileHandle === undefined && value.peerHandle === undefined
+                    ? {}
+                    : { peerHandle: required(profileHandle ?? value.peerHandle) },
+                ...displayName === undefined || displayName.length === 0 ? {} : { displayName },
             };
             case 'group': return {
                 kind: 'group',
@@ -226,6 +515,108 @@ export class RustSdkAdapter {
             default: fail();
         }
     }
+    createdGroup(value) {
+        return {
+            kind: 'group',
+            id: required(value.conversationId),
+            groupDid: required(value.did),
+            title: required(value.title),
+            unreadCount: 0,
+        };
+    }
+    groupSnapshot(value) {
+        return {
+            groupDid: required(value.did),
+            conversationId: required(value.conversationId),
+            title: required(value.title),
+            ...value.description === undefined ? {} : { description: value.description },
+            ...value.myRole === undefined ? {} : { myRole: value.myRole },
+            ...value.membershipStatus === undefined ? {} : { membershipStatus: value.membershipStatus },
+            ...value.memberCount === undefined ? {} : { memberCount: value.memberCount },
+        };
+    }
+    groupMember(value) {
+        return {
+            did: required(value.did),
+            ...value.handle === undefined ? {} : { handle: value.handle },
+        };
+    }
+    groupMemberRecord(value, profile) {
+        return {
+            ...value.membershipId === undefined ? {} : { membershipId: value.membershipId },
+            ...value.peerPersonaId === undefined ? {} : { peerPersonaId: value.peerPersonaId },
+            ...value.did === undefined ? {} : { did: value.did },
+            ...value.credentialDid === undefined ? {} : { credentialDid: value.credentialDid },
+            ...value.handle === undefined ? {} : { handle: value.handle },
+            ...profile?.displayName === undefined ? {} : { displayName: profile.displayName },
+            ...value.role === undefined ? {} : { role: value.role },
+            ...value.status === undefined ? {} : { status: value.status },
+            ...value.joinedAt === undefined ? {} : { joinedAt: value.joinedAt },
+            ...value.subjectType === undefined ? {} : { subjectType: value.subjectType },
+        };
+    }
+    listenerConversation(value) {
+        const common = {
+            id: required(value.id),
+            unreadCount: value.unreadCount,
+            ...value.lastMessageAt === undefined ? {} : { lastMessageAt: timestamp(value.lastMessageAt) },
+        };
+        if (value.kind === 'direct') {
+            return {
+                kind: 'direct',
+                ...common,
+                peerDid: required(value.peerDid),
+                ...value.peerHandle === undefined ? {} : { peerHandle: value.peerHandle },
+            };
+        }
+        return { kind: 'group', ...common };
+    }
+    listenerMessage(value) {
+        const sentAt = value.sentAt === undefined ? fail() : timestamp(value.sentAt);
+        const common = {
+            id: required(value.id),
+            conversationId: required(value.conversationId),
+            conversationKind: value.conversationKind,
+            senderDid: required(value.senderDid),
+            sentAt,
+            outgoing: value.outgoing,
+        };
+        return value.content.kind === 'text' && value.content.text !== undefined
+            ? { ...common, content: { kind: 'text', text: required(value.content.text) } }
+            : { ...common, content: { kind: 'ignored' } };
+    }
+    listenerSyncNow(reason) {
+        return this.run(async (client) => {
+            const result = await client.syncNow({ reason });
+            if (result.status === 'idle' || result.status === 'changed')
+                return;
+            if (result.status === 'auth_revoked')
+                fail('forbidden');
+            fail('network');
+        });
+    }
+    listenerStartRealtime() {
+        return this.run(async (client) => {
+            const session = await client.startRealtime();
+            return {
+                nextEvent: () => this.run(() => session.nextEvent()),
+                stop: () => this.run(() => session.stop()),
+            };
+        });
+    }
+    listenerConversations(request) {
+        return this.run(async (client) => page(await client.listConversations(request), value => this.listenerConversation(value)));
+    }
+    listenerHistory(request) {
+        return this.run(async (client) => {
+            const history = await client.getHistory({
+                conversationId: String(request.conversationId),
+                ...request.cursor === undefined ? {} : { cursor: String(request.cursor) },
+                ...request.limit === undefined ? {} : { limit: request.limit },
+            });
+            return page({ ...history, items: [...history.items].reverse() }, value => this.listenerMessage(value));
+        });
+    }
     async conversationId(client, target) {
         if (target.kind === 'direct')
             return required((await client.resolvePeer(target.peer)).conversationId);
@@ -270,6 +661,59 @@ export class RustSdkAdapter {
     updateDisplayName(request) {
         return this.run(async (client) => identity(await client.updateDisplayName(request.displayName)));
     }
+    getProfile() {
+        return this.run(async (client) => profile(await client.getProfile()));
+    }
+    updateProfile(request) {
+        return this.run(async (client) => profile(await client.updateProfile({
+            displayName: request.displayName,
+            bio: request.bio,
+            tags: [...request.tags],
+        })));
+    }
+    recoveryProgress(value) {
+        return {
+            operationId: required(value.operationId),
+            fullHandle: required(value.fullHandle),
+            ...value.previousDid === undefined ? {} : { previousDid: value.previousDid },
+            currentDid: required(value.currentDid),
+            phase: value.phase,
+            ...value.failureCode === undefined ? {} : { failureCode: value.failureCode },
+            retryable: boolean(value.retryable),
+            localOrdinaryDataWillMigrate: boolean(value.impact.localOrdinaryDataWillMigrate),
+            otherDevicesMustRejoin: boolean(value.impact.otherDevicesMustRejoin),
+            unsupportedE2eeGroupCount: recoveryE2eeGroupCount(value.impact),
+            unsupportedDidOnlyGroupCount: uint32(value.impact.unsupportedDidOnlyGroupCount),
+        };
+    }
+    sendRecoveryOtp(request) {
+        return this.run(async (client) => {
+            const value = await client.requestHandleRecoveryOtp(request);
+            return {
+                operationId: required(value.operationId),
+                fullHandle: required(value.fullHandle),
+                retryAfterSeconds: value.retryAfterSeconds,
+                retryAt: value.retryAt,
+            };
+        });
+    }
+    prepareRecovery(request) {
+        return this.run(async (client) => this.recoveryProgress(await client.prepareHandleRecovery(request)));
+    }
+    activateRecovery(request) {
+        return this.run(async (client) => this.recoveryProgress(await client.activateHandleRecovery(request)));
+    }
+    getRecoveryStatus(request) {
+        return this.run(async (client) => this.recoveryProgress(await client.getHandleRecoveryStatus(request)));
+    }
+    resumeRecovery(request) {
+        return this.run(async (client) => this.recoveryProgress(await client.resumeHandleRecovery(request)));
+    }
+    discardRecovery(request) {
+        return this.run(async (client) => {
+            await client.discardHandleRecovery(request);
+        });
+    }
     resolvePeer(peer) {
         return this.run(async (client) => {
             const value = await client.resolvePeer(peer);
@@ -281,8 +725,79 @@ export class RustSdkAdapter {
             };
         });
     }
+    createGroup(name) {
+        return this.run(async (client) => this.createdGroup(await client.createGroup({ name })));
+    }
+    addGroupMember(groupDid, member) {
+        return this.run(async (client) => this.groupMember(await client.addGroupMember({
+            groupDid: String(groupDid),
+            member,
+        })));
+    }
+    getGroup(groupDid) {
+        return this.run(async (client) => this.groupSnapshot(await client.getGroup({ groupDid: String(groupDid) })));
+    }
+    joinGroup(groupDid) {
+        return this.run(async (client) => this.groupSnapshot(await client.joinGroup({ groupDid: String(groupDid) })));
+    }
+    leaveGroup(groupDid) {
+        return this.run(client => client.leaveGroup({ groupDid: String(groupDid) }));
+    }
+    listGroupMembers(request) {
+        return this.run(async (client) => {
+            const value = await client.listGroupMembers({
+                groupDid: String(request.groupDid),
+                ...request.cursor === undefined ? {} : { cursor: String(request.cursor) },
+                ...request.limit === undefined ? {} : { limit: request.limit },
+            });
+            const peers = [...new Set(value.items.flatMap(member => member.did ?? member.handle ?? []))];
+            const profiles = peers.length === 0 ? [] : await client.hydrateDisplayProfiles({ peers });
+            const byPeer = new Map();
+            for (const [index, profile] of profiles.entries()) {
+                const requested = peers[index];
+                if (requested !== undefined)
+                    byPeer.set(requested, profile);
+                if (profile.did !== undefined)
+                    byPeer.set(profile.did, profile);
+                if (profile.handle !== undefined)
+                    byPeer.set(profile.handle, profile);
+            }
+            return {
+                items: value.items.map(item => this.groupMemberRecord(item, byPeer.get(item.did ?? '') ?? byPeer.get(item.handle ?? ''))),
+                ...value.total === undefined ? {} : { total: value.total },
+                ...value.nextCursor === undefined ? {} : { nextCursor: value.nextCursor },
+                hasMore: value.hasMore,
+                ...value.pageGroup === undefined ? {} : { pageGroup: value.pageGroup },
+                ...value.groupStateVersion === undefined ? {} : { groupStateVersion: value.groupStateVersion },
+                warnings: [...value.warnings],
+            };
+        });
+    }
+    removeGroupMember(groupDid, member) {
+        return this.run(async (client) => this.groupMember(await client.removeGroupMember({
+            groupDid: String(groupDid),
+            member,
+        })));
+    }
+    resumeGroupRebindRecovery() {
+        return this.run(async (client) => {
+            const value = await client.resumeGroupRebindRecovery(100);
+            return {
+                processed: uint32(value.processed),
+                completed: uint32(value.completed),
+                pending: uint32(value.pending),
+                blocked: uint32(value.blocked),
+            };
+        });
+    }
     listConversations(request) {
-        return this.run(async (client) => page(await client.listConversations(request), value => this.conversation(value)));
+        return this.run(async (client) => {
+            const conversations = await client.listConversations(request);
+            return {
+                ...page(conversations, value => value),
+                items: await this.displayableConversations(client, conversations.items),
+            };
+        });
     }
     getHistory(request) {
         return this.run(async (client) => {
@@ -293,28 +808,69 @@ export class RustSdkAdapter {
             });
             return page(
             // Rust Core pages newest-first; the Host/UI contract is chronological.
-            { ...history, items: [...history.items].reverse() }, value => this.message(value));
+            { ...history, items: await this.displayableMessages(client, [...history.items].reverse()) }, value => this.message(value));
+        });
+    }
+    getLocalHistory(request) {
+        return this.run(async (client) => {
+            const history = await client.getLocalConversationTimeline({
+                conversationId: String(request.conversationId),
+                ...request.cursor === undefined ? {} : { cursor: String(request.cursor) },
+                ...request.limit === undefined ? {} : { limit: request.limit },
+            });
+            return page(
+            // Rust Core local pages are newest-first; the Host/UI contract is chronological.
+            { ...history, items: await this.displayableMessages(client, [...history.items].reverse()) }, value => this.message(value));
         });
     }
     markConversationRead(conversationId) {
         return this.run(async (client) => (await client.markConversationRead(String(conversationId))).updatedCount);
     }
     sendText(request) {
-        return this.run(async (client) => this.message(await client.sendText({
-            conversationId: await this.conversationId(client, request.target),
-            text: request.text,
-            idempotencyKey: request.idempotencyKey,
-        })));
+        return this.run(async (client) => {
+            const clientMessageId = browserMessageId(request.idempotencyKey);
+            const conversationId = await this.conversationId(client, request.target);
+            if (request.mentions !== undefined && request.mentions.length > 0) {
+                return this.message(await client.sendPayload({
+                    conversationId,
+                    payloadJson: JSON.stringify({
+                        text: request.text,
+                        mentions: request.mentions.map(mention => ({
+                            id: mention.id,
+                            range: { start: mention.start, end: mention.end, unit: 'unicode_code_point' },
+                            target: {
+                                kind: 'human',
+                                did: mention.did,
+                                ...mention.displayName === undefined ? {} : { display_name: mention.displayName },
+                            },
+                            mention_role: 'addressee',
+                        })),
+                    }),
+                    ...clientMessageId === undefined ? {} : { clientMessageId },
+                    idempotencyKey: request.idempotencyKey,
+                }));
+            }
+            return this.message(await client.sendText({
+                conversationId,
+                text: request.text,
+                ...clientMessageId === undefined ? {} : { clientMessageId },
+                idempotencyKey: request.idempotencyKey,
+            }));
+        });
     }
     sendAttachment(request) {
-        return this.run(async (client) => this.message(await client.sendAttachment({
-            conversationId: await this.conversationId(client, request.target),
-            fileName: request.attachment.fileName,
-            mimeType: request.attachment.mimeType,
-            bytes: request.attachment.bytes,
-            ...request.caption === undefined ? {} : { caption: request.caption },
-            idempotencyKey: request.idempotencyKey,
-        })));
+        return this.run(async (client) => {
+            const clientMessageId = browserMessageId(request.idempotencyKey);
+            return this.message(await client.sendAttachment({
+                conversationId: await this.conversationId(client, request.target),
+                fileName: request.attachment.fileName,
+                mimeType: request.attachment.mimeType,
+                bytes: request.attachment.bytes,
+                ...request.caption === undefined ? {} : { caption: request.caption },
+                ...clientMessageId === undefined ? {} : { clientMessageId },
+                idempotencyKey: request.idempotencyKey,
+            }));
+        });
     }
     downloadAttachment(request) {
         return this.run(async (client) => {
@@ -329,6 +885,48 @@ export class RustSdkAdapter {
             return { attachment: attachment(value.attachment), bytes: Uint8Array.from(value.bytes) };
         });
     }
+    getMailAccount() {
+        return this.run(async (client) => mailAccount(await client.getMailAccount()));
+    }
+    listMailInbox(request = {}) {
+        return this.run(async (client) => mailInbox(await client.listMailInbox({
+            ...request.folder === undefined ? {} : { folder: request.folder },
+            ...request.unreadOnly === undefined ? {} : { unreadOnly: request.unreadOnly },
+            ...request.limit === undefined ? {} : { limit: request.limit },
+            ...request.offset === undefined ? {} : { offset: request.offset },
+        })));
+    }
+    readMail(request) {
+        return this.run(async (client) => mailMessage(await client.readMail(request.messageId)));
+    }
+    markMailRead(request) {
+        return this.run(async (client) => {
+            const value = await client.markMailRead({
+                messageIds: [...request.messageIds],
+            });
+            return { updated: uint32(value.updated) };
+        });
+    }
+    sendMail(request) {
+        return this.run(async (client) => {
+            const value = await client.sendMail({
+                to: [...request.to],
+                ...request.cc === undefined ? {} : { cc: [...request.cc] },
+                subject: request.subject,
+                bodyText: request.bodyText,
+            });
+            if (!Array.isArray(value.warnings) || value.warnings.length > 100)
+                fail();
+            const messageId = value.messageId === undefined
+                ? undefined
+                : mailToken(value.messageId, 2_048);
+            return {
+                accepted: boolean(value.accepted),
+                ...messageId === undefined ? {} : { messageId },
+                warnings: value.warnings.map(warning => remoteString(warning, 1_024)),
+            };
+        }, true);
+    }
     clearLocalData() {
         return this.run(client => client.clearLocalData());
     }