@robono/messaging-react-native 0.1.0 → 0.2.0

package/dist/calling.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import { createContext, useContext, useSyncExternalStore } from 'react';
 import { Pressable, View, Text } from 'react-native';
 import { RobonoIcon } from './visual/RobonoIcon.js';
-import { MessagingScreen, MessagingProvider, MessagingHeader, MessagingComposer, useMessagingUI } from './index.js';
+import { messagingHeaderColors, MessagingScreen, MessagingProvider, MessagingHeader, MessagingComposer, useMessagingUI } from './index.js';
 import { UnansweredCallMessage } from './call-message.js';
 export { UnansweredCallMessage } from './call-message.js';
 const Action = createContext(null);
@@ -12,7 +12,7 @@ function CallingMessageComposer() { const follow = useContext(FollowUp); return
 export function MessagingCallHeader() {
     const action = useContext(Action), { design, state } = useMessagingUI();
     const allowed = state.conversation?.canSend !== false;
-    return _jsxs(MessagingHeader, { children: [allowed && action?.onCall && _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: action.label, onPress: action.onCall, style: { minWidth: 44, minHeight: 44, alignItems: 'center', justifyContent: 'center' }, children: _jsx(RobonoIcon, { name: "phone", size: 24, color: design.colors.foreground }) }), allowed && action?.onVideoCall && _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: action.videoLabel, onPress: action.onVideoCall, style: { minWidth: 44, minHeight: 44, alignItems: 'center', justifyContent: 'center' }, children: _jsx(RobonoIcon, { name: "video", size: 24, color: design.colors.foreground }) })] });
+    return _jsxs(MessagingHeader, { children: [allowed && action?.onCall && _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: action.label, onPress: action.onCall, style: { minWidth: 44, minHeight: 44, alignItems: 'center', justifyContent: 'center' }, children: _jsx(RobonoIcon, { name: "phone", size: 24, color: messagingHeaderColors(design, state.conversation?.kind === 'group').foreground }) }), allowed && action?.onVideoCall && _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: action.videoLabel, onPress: action.onVideoCall, style: { minWidth: 44, minHeight: 44, alignItems: 'center', justifyContent: 'center' }, children: _jsx(RobonoIcon, { name: "video", size: 24, color: messagingHeaderColors(design, state.conversation?.kind === 'group').foreground }) })] });
 }
 export function MessagingCallingScreen({ onCall, onVideoCall, videoCallLabel = 'Video call', callLabel = 'Voice call', components, unansweredCallId, onDismissCallMessage, ...props }) {
     const state = useSyncExternalStore(props.client.subscribe, props.client.getSnapshot, props.client.getSnapshot);

package/dist/expo-download.d.ts

@@ -0,0 +1,3 @@
+import type { LocalMessagingMedia, MediaKind } from './media-controller.js';
+/** Export an already-authorized viewer copy; never expose its private source URL. */
+export declare function saveMessagingAttachment(file: LocalMessagingMedia, kind: MediaKind): Promise<void>;

package/dist/expo-download.js

@@ -0,0 +1,43 @@
+import { Platform } from 'react-native';
+import * as FS from 'expo-file-system/legacy';
+import * as Sharing from 'expo-sharing';
+import * as MediaLibrary from 'expo-media-library';
+/** Export an already-authorized viewer copy; never expose its private source URL. */
+export async function saveMessagingAttachment(file, kind) {
+    if (kind === 'image' || kind === 'video') {
+        const permission = await MediaLibrary.requestPermissionsAsync(true, [kind === 'image' ? 'photo' : 'video']);
+        if (!permission.granted)
+            throw Error('Allow photo access to save this attachment.');
+        await MediaLibrary.saveToLibraryAsync(file.uri);
+        return;
+    }
+    if (kind !== 'document')
+        throw Error('This attachment cannot be downloaded.');
+    if (Platform.OS !== 'android') {
+        if (!await Sharing.isAvailableAsync())
+            throw Error('File saving is unavailable.');
+        await Sharing.shareAsync(file.uri, { mimeType: file.mimeType, dialogTitle: 'Save ' + file.fileName });
+        return;
+    }
+    const permission = await FS.StorageAccessFramework.requestDirectoryPermissionsAsync();
+    if (!permission.granted)
+        return;
+    const name = file.fileName.split(/[\\/]/).at(-1)?.replace(/[\u0000-\u001f\u007f]/g, '').trim() || 'Attachment';
+    const destination = await FS.StorageAccessFramework.createFileAsync(permission.directoryUri, name, file.mimeType);
+    try {
+        // Bounded chunks avoid keeping an entire large document and its base64 copy in memory.
+        const chunk = 3 * 256 * 1024;
+        for (let position = 0; position < file.byteSize; position += chunk) {
+            const length = Math.min(chunk, file.byteSize - position);
+            const data = await FS.readAsStringAsync(file.uri, { encoding: FS.EncodingType.Base64, position, length });
+            const bytes = data.length * 3 / 4 - (data.endsWith('==') ? 2 : data.endsWith('=') ? 1 : 0);
+            if (bytes !== length)
+                throw Error('The attachment could not be read completely.');
+            await FS.writeAsStringAsync(destination, data, { encoding: FS.EncodingType.Base64, append: position > 0 });
+        }
+    }
+    catch (error) {
+        await FS.deleteAsync(destination, { idempotent: true }).catch(() => { });
+        throw error;
+    }
+}

package/dist/expo-media.js

@@ -342,6 +342,29 @@ export function createExpoMessagingStorage(options) {
                 }
             }
         },
+        async thumbnail(message, context) {
+            check(context.signal);
+            const plan = await request('thumbnail', { conversationId: message.conversationId, messageId: message.id }, context.signal);
+            if (!plan)
+                return null;
+            const media = plan.media;
+            if (media?.assetId !== message.media?.assetId || media?.mimeType !== 'image/jpeg' || !Number.isInteger(media.byteSize) || media.byteSize < 1 || media.byteSize > 131072)
+                throw Error('Invalid attachment preview.');
+            const path = await cachePath('preview.jpg');
+            try {
+                const task = FS.createDownloadResumable(https(plan.url), path, { headers: plan.headers ?? {}, sessionType: FS.FileSystemSessionType.FOREGROUND }, progress => { if (progress.totalBytesWritten > media.byteSize)
+                    void task.cancelAsync().catch(() => { }); });
+                const result = await cancellable(task, context, () => task.downloadAsync());
+                const info = await FS.getInfoAsync(path);
+                if (!result || result.status !== 200 || !info.exists || info.isDirectory || info.size !== media.byteSize)
+                    throw Error('Attachment preview is incomplete.');
+                return { uri: path, mimeType: 'image/jpeg', fileName: 'preview.jpg', byteSize: media.byteSize };
+            }
+            catch (error) {
+                await removeUri(path).catch(() => { });
+                throw error;
+            }
+        },
         async download(message, context) {
             check(context.signal);
             if (message.deleted)

package/dist/expo-outbox.d.ts

@@ -0,0 +1,13 @@
+import { MessagingClient, type MessagingRequest } from '@robono/messaging';
+import { NativeMessagingOutbox } from './native-outbox.js';
+export declare const expoOutbox: (client: MessagingClient) => NativeMessagingOutbox | undefined;
+/** Ready-made authenticated mobile client with private, per-account outgoing drafts. */
+export declare function createExpoMessagingClient(options: {
+    url: string;
+    userId: string;
+    getAccessToken: () => Promise<string>;
+    fetch?: typeof fetch;
+    persistence?: false;
+    namespace?: string;
+    transformRequest?: MessagingRequest;
+}): MessagingClient;

package/dist/expo-outbox.js

@@ -0,0 +1,81 @@
+import * as FS from 'expo-file-system/legacy';
+import * as Crypto from 'expo-crypto';
+import { MessagingClient, createMessagingTransport } from '@robono/messaging';
+import { NativeMessagingOutbox, emptyNativeDraft } from './native-outbox.js';
+import { ExpoSavedMessages, bindExpoSaved } from './expo-saved.js';
+const stores = new WeakMap();
+export const expoOutbox = (client) => stores.get(client);
+const digest = (value) => Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, value);
+const root = async (scope) => { if (!FS.documentDirectory)
+    throw Error('Private app storage is unavailable.'); return FS.documentDirectory + 'robono-outgoing/' + await digest(scope) + '/'; };
+const folder = async (scope, cid) => (await root(scope)) + await digest(cid) + '/';
+const asset = async (scope, cid, id) => (await folder(scope, cid)) + 'file-' + await digest(id);
+const files = {
+    async read(scope, cid) {
+        const dir = await folder(scope, cid);
+        if (!(await FS.getInfoAsync(dir)).exists)
+            return emptyNativeDraft();
+        const names = (await FS.readDirectoryAsync(dir)).filter(name => /^state-\d+\.json$/.test(name)).sort((a, b) => Number(b.slice(6, -5)) - Number(a.slice(6, -5)));
+        for (const name of names) {
+            try {
+                const state = JSON.parse(await FS.readAsStringAsync(dir + name));
+                if (typeof state.draft === 'string' && Array.isArray(state.messages) && state.files && typeof state.files === 'object')
+                    return state;
+            }
+            catch { }
+        }
+        if (names.length)
+            throw Error('Saved messages could not be read. Your files have been kept.');
+        return emptyNativeDraft();
+    },
+    async write(scope, cid, state) {
+        const dir = await folder(scope, cid);
+        await FS.makeDirectoryAsync(dir, { intermediates: true });
+        const names = (await FS.readDirectoryAsync(dir)).filter(name => /^state-\d+\.json$/.test(name)).sort((a, b) => Number(b.slice(6, -5)) - Number(a.slice(6, -5)));
+        const sequence = names.length ? Number(names[0].slice(6, -5)) + 1 : 1, temp = dir + 'pending-' + Crypto.randomUUID() + '.tmp';
+        try {
+            await FS.writeAsStringAsync(temp, JSON.stringify(state));
+            await FS.moveAsync({ from: temp, to: dir + 'state-' + sequence + '.json' });
+        }
+        finally {
+            await FS.deleteAsync(temp, { idempotent: true }).catch(() => { });
+        }
+        // Keep the preceding complete snapshot for interrupted writes; no full app copies.
+        await Promise.all(names.slice(1).map(name => FS.deleteAsync(dir + name, { idempotent: true }).catch(() => { })));
+    },
+    async copy(scope, cid, id, source) {
+        if (!source.uri.startsWith('file://') || source.stream)
+            throw Error('Choose a local attachment.');
+        const dir = await folder(scope, cid), target = await asset(scope, cid, id);
+        await FS.makeDirectoryAsync(dir, { intermediates: true });
+        const existing = await FS.getInfoAsync(target);
+        if (existing.exists && !existing.isDirectory && existing.size === source.byteSize)
+            return target;
+        const temporary = target + '-' + Crypto.randomUUID() + '.tmp';
+        try {
+            await FS.copyAsync({ from: source.uri, to: temporary });
+            const info = await FS.getInfoAsync(temporary);
+            if (!info.exists || info.isDirectory || info.size !== source.byteSize)
+                throw Error('The attachment was not saved completely.');
+            await FS.moveAsync({ from: temporary, to: target });
+            return target;
+        }
+        finally {
+            await FS.deleteAsync(temporary, { idempotent: true }).catch(() => { });
+        }
+    },
+    async file(scope, cid, id) { const target = await asset(scope, cid, id); return (await FS.getInfoAsync(target)).exists ? target : null; },
+    async remove(scope, cid, id) { await FS.deleteAsync(await asset(scope, cid, id), { idempotent: true }); },
+    async clear(scope, cid) { await FS.deleteAsync(cid === undefined ? await root(scope) : await folder(scope, cid), { idempotent: true }); },
+};
+/** Ready-made authenticated mobile client with private, per-account outgoing drafts. */
+export function createExpoMessagingClient(options) {
+    const request = createMessagingTransport(options), store = options.persistence === false ? undefined : new NativeMessagingOutbox(options.url, options.userId, files, options.namespace);
+    const saved = store ? new ExpoSavedMessages(options.url, options.userId, options.namespace) : undefined;
+    const client = new MessagingClient({ request, userId: options.userId, createMessageId: Crypto.randomUUID, outbox: store, saved, transformRequest: options.transformRequest });
+    if (store)
+        stores.set(client, store);
+    if (saved)
+        bindExpoSaved(client, saved);
+    return client;
+}

package/dist/expo-saved.d.ts

@@ -0,0 +1,24 @@
+import { type MessagingClient, type MessagingMessage, type MessagingSavedStore, type SavedMessage } from '@robono/messaging';
+import type { LocalMessagingMedia } from './media-controller.js';
+export declare const expoSaved: (client: MessagingClient) => ExpoSavedMessages | undefined;
+export declare const bindExpoSaved: (client: MessagingClient, store: ExpoSavedMessages) => WeakMap<MessagingClient, ExpoSavedMessages>;
+/** Explicit saved copies in the OS-private app directory, never cache/signed URLs. */
+export declare class ExpoSavedMessages implements MessagingSavedStore {
+    private generation;
+    private scope;
+    private download;
+    constructor(endpoint: string, userId: string, namespace?: string);
+    bindDownload(download: NonNullable<ExpoSavedMessages['download']>): () => void;
+    private serial;
+    private directory;
+    private read;
+    private write;
+    list(): Promise<SavedMessage[]>;
+    prepare(message: MessagingMessage): Promise<{
+        commit: (record: SavedMessage) => Promise<void>;
+        discard: () => Promise<void>;
+    }>;
+    remove(key: string): Promise<void>;
+    clear(): Promise<void>;
+    file(record: SavedMessage): Promise<LocalMessagingMedia>;
+}

package/dist/expo-saved.js

@@ -0,0 +1,76 @@
+import * as FS from 'expo-file-system/legacy';
+import * as Crypto from 'expo-crypto';
+import { savedMessageKey } from '@robono/messaging';
+const stores = new WeakMap();
+export const expoSaved = (client) => stores.get(client);
+export const bindExpoSaved = (client, store) => stores.set(client, store);
+const queues = new Map(), epochs = new Map();
+/** Explicit saved copies in the OS-private app directory, never cache/signed URLs. */
+export class ExpoSavedMessages {
+    generation = 0;
+    scope;
+    download;
+    constructor(endpoint, userId, namespace = 'default') { this.scope = JSON.stringify([endpoint, namespace, userId]); }
+    bindDownload(download) { this.download = download; return () => { if (this.download === download)
+        this.download = undefined; }; }
+    serial(work) { const promise = (queues.get(this.scope) ?? Promise.resolve()).catch(() => { }).then(work); queues.set(this.scope, promise); void promise.finally(() => { if (queues.get(this.scope) === promise)
+        queues.delete(this.scope); }).catch(() => { }); return promise; }
+    async directory() { if (!FS.documentDirectory)
+        throw Error('Private app storage is unavailable.'); return FS.documentDirectory + 'robono-saved/' + await Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, this.scope) + '/'; }
+    async read() { const dir = await this.directory(); if (!(await FS.getInfoAsync(dir)).exists)
+        return []; const names = (await FS.readDirectoryAsync(dir)).filter(n => /^state-\d+\.json$/.test(n)).sort((a, b) => Number(b.slice(6, -5)) - Number(a.slice(6, -5))); for (const name of names) {
+        try {
+            const rows = JSON.parse(await FS.readAsStringAsync(dir + name));
+            if (Array.isArray(rows) && rows.every(r => r.record?.key && (!r.file || /^file-[\da-f-]+$/i.test(r.file))))
+                return rows;
+        }
+        catch { }
+    } if (names.length)
+        throw Error('Saved messages could not be read. Your files have been kept.'); return []; }
+    async write(rows) { const dir = await this.directory(); await FS.makeDirectoryAsync(dir, { intermediates: true }); const names = (await FS.readDirectoryAsync(dir)).filter(n => /^state-\d+\.json$/.test(n)).sort((a, b) => Number(b.slice(6, -5)) - Number(a.slice(6, -5))); const sequence = names.length ? Number(names[0].slice(6, -5)) + 1 : 1, temp = dir + 'pending-' + Crypto.randomUUID(); try {
+        await FS.writeAsStringAsync(temp, JSON.stringify(rows));
+        await FS.moveAsync({ from: temp, to: dir + 'state-' + sequence + '.json' });
+    }
+    finally {
+        await FS.deleteAsync(temp, { idempotent: true }).catch(() => { });
+    } await Promise.all(names.map(n => FS.deleteAsync(dir + n, { idempotent: true }).catch(() => { }))); }
+    list() { return this.serial(async () => (await this.read()).map(r => r.record).sort((a, b) => b.savedAt.localeCompare(a.savedAt))); }
+    async prepare(message) {
+        const generation = this.generation, epoch = epochs.get(this.scope) ?? 0;
+        let file, committed = false;
+        const active = () => { if (generation !== this.generation || epoch !== (epochs.get(this.scope) ?? 0))
+            throw Error('The account was signed out.'); };
+        if (message.media) {
+            if (!this.download)
+                throw Error('Open media tools before saving attachments.');
+            const source = await this.download(message);
+            try {
+                active();
+                if (source.file.stream || !source.file.uri.startsWith('file://'))
+                    throw Error('A local attachment is required.');
+                file = 'file-' + Crypto.randomUUID();
+                const dir = await this.directory();
+                await this.serial(async () => { active(); await FS.makeDirectoryAsync(dir, { intermediates: true }); await FS.copyAsync({ from: source.file.uri, to: dir + file }); const info = await FS.getInfoAsync(dir + file); if (!info.exists || info.isDirectory || info.size !== message.media.byteSize)
+                    throw Error('The saved file is incomplete.'); });
+            }
+            catch (error) {
+                if (file)
+                    await FS.deleteAsync((await this.directory()) + file, { idempotent: true }).catch(() => { });
+                throw error;
+            }
+            finally {
+                await source.release();
+            }
+        }
+        return { commit: (record) => this.serial(async () => { active(); if (record.key !== savedMessageKey(message))
+                throw Error('The saved message changed.'); const rows = await this.read(), old = rows.find(r => r.record.key === record.key); active(); await this.write([{ record, file }, ...rows.filter(r => r.record.key !== record.key)]); committed = true; if (old?.file && old.file !== file)
+                await FS.deleteAsync((await this.directory()) + old.file, { idempotent: true }).catch(() => { }); }), discard: async () => { if (file && !committed)
+                await FS.deleteAsync((await this.directory()) + file, { idempotent: true }).catch(() => { }); } };
+    }
+    remove(key) { return this.serial(async () => { const rows = await this.read(), old = rows.find(r => r.record.key === key); await this.write(rows.filter(r => r.record.key !== key)); if (old?.file)
+        await FS.deleteAsync((await this.directory()) + old.file, { idempotent: true }).catch(() => { }); }); }
+    clear() { this.generation++; epochs.set(this.scope, (epochs.get(this.scope) ?? 0) + 1); return this.serial(async () => { await FS.deleteAsync(await this.directory(), { idempotent: true }); }); }
+    file(record) { return this.serial(async () => { const row = (await this.read()).find(r => r.record.key === record.key); if (!row?.file || !row.record.message.media)
+        throw Error('This saved attachment is unavailable.'); const uri = (await this.directory()) + row.file, info = await FS.getInfoAsync(uri); if (!info.exists || info.isDirectory || info.size !== row.record.message.media.byteSize)
+        throw Error('This saved attachment is missing.'); return { ...row.record.message.media, uri }; }); }
+}

package/dist/expo-social.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { SocialPlayerProps } from './social.js';
+export declare function ExpoSocialPlayer({ html, origin, onError }: SocialPlayerProps): React.JSX.Element;

package/dist/expo-social.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Linking, Text, UIManager } from 'react-native';
+// Expo builds include this native module when the documented peer is installed.
+const available = !!UIManager.getViewManagerConfig('RNCWebView');
+const WebView = available ? require('react-native-webview').WebView : null;
+export function ExpoSocialPlayer({ html, origin, onError }) {
+    if (!WebView)
+        return _jsx(Text, { children: "Update the app to play this preview." });
+    const open = (url) => { try {
+        const u = new URL(url);
+        if (u.protocol === 'https:' && !u.username && !u.password)
+            void Linking.openURL(url).catch(onError);
+    }
+    catch { } };
+    return _jsx(WebView, { source: { html, baseUrl: origin + '/' }, originWhitelist: ['https://*'], javaScriptEnabled: true, domStorageEnabled: true, allowsInlineMediaPlayback: true, mediaPlaybackRequiresUserAction: true, allowsFullscreenVideo: true, sharedCookiesEnabled: false, thirdPartyCookiesEnabled: true, mixedContentMode: "never", allowFileAccess: false, allowFileAccessFromFileURLs: false, allowUniversalAccessFromFileURLs: false, setSupportMultipleWindows: true, onOpenWindow: event => open(event.nativeEvent.targetUrl), onShouldStartLoadWithRequest: request => { if (request.url === 'about:blank' || request.url === origin + '/')
+            return true; if (!request.url.startsWith('https://'))
+            return false; if (request.isTopFrame && request.navigationType === 'click') {
+            open(request.url);
+            return false;
+        } return true; }, onError: onError, style: { flex: 1 } });
+}

package/dist/expo-thumbnails.d.ts

@@ -0,0 +1,9 @@
+import type { MessagingMessage } from '@robono/messaging';
+import type { LocalMessagingMedia, MessagingMediaStorage } from './media-controller.js';
+/** Small local previews, with bounded downloads and memory. Large originals stay
+ * tap-to-open until the storage service supplies a dedicated thumbnail. */
+export declare function createExpoThumbnails(storage: MessagingMediaStorage, local: (id: string) => LocalMessagingMedia | undefined, remove: (file: LocalMessagingMedia) => Promise<void>): {
+    preview: (message: MessagingMessage) => Promise<{}>;
+    clear: () => void;
+    alias: (from: string, to: string) => void;
+};

package/dist/expo-thumbnails.js

@@ -0,0 +1,68 @@
+import * as ImageManipulator from 'expo-image-manipulator';
+import * as VideoThumbnails from 'expo-video-thumbnails';
+import * as FS from 'expo-file-system/legacy';
+/** Small local previews, with bounded downloads and memory. Large originals stay
+ * tap-to-open until the storage service supplies a dedicated thumbnail. */
+export function createExpoThumbnails(storage, local, remove) {
+    let generation = 0;
+    const cache = new Map(), abort = new Set();
+    let queue = Promise.resolve();
+    function clear() { generation++; cache.clear(); for (const c of abort)
+        c.abort(); abort.clear(); }
+    function preview(message) {
+        const media = message.media;
+        if (!media || message.deleted)
+            return Promise.resolve({});
+        if (message.kind === 'voice')
+            return Promise.resolve({ waveform: media.waveform });
+        if (!['image', 'video'].includes(message.kind))
+            return Promise.resolve({});
+        const id = media.assetId, existing = cache.get(id);
+        if (existing)
+            return existing;
+        const g = generation;
+        const work = queue.then(async () => {
+            if (g !== generation)
+                return {};
+            let file = local(id), downloaded = false, poster, thumbnail;
+            const controller = new AbortController();
+            abort.add(controller);
+            try {
+                let dedicated = false;
+                if (!file && storage.thumbnail) {
+                    file = await storage.thumbnail(message, { signal: controller.signal, onProgress: () => { } }).catch(() => null) ?? undefined;
+                    dedicated = !!file;
+                    downloaded = !!file;
+                }
+                if (!file) {
+                    if (media.byteSize > 2 * 1024 * 1024)
+                        return {};
+                    file = await storage.download(message, { signal: controller.signal, onProgress: () => { } });
+                    downloaded = true;
+                }
+                if (g !== generation)
+                    return {};
+                if (message.kind === 'video' && !dedicated)
+                    poster = (await VideoThumbnails.getThumbnailAsync(file.uri, { time: 0, quality: .6 })).uri;
+                const result = await ImageManipulator.manipulateAsync(poster ?? file.uri, [{ resize: { width: 480 } }], { compress: .7, format: ImageManipulator.SaveFormat.JPEG, base64: true });
+                thumbnail = result.uri;
+                return g === generation && result.base64 ? { uri: 'data:image/jpeg;base64,' + result.base64 } : {};
+            }
+            finally {
+                abort.delete(controller);
+                if (downloaded && file)
+                    await remove(file).catch(() => { });
+                for (const uri of [poster, thumbnail])
+                    if (uri && FS.cacheDirectory && uri.startsWith(FS.cacheDirectory))
+                        await FS.deleteAsync(uri, { idempotent: true }).catch(() => { });
+            }
+        }).catch(() => ({}));
+        queue = work.then(() => { });
+        cache.set(id, work);
+        if (cache.size > 100)
+            cache.delete(cache.keys().next().value);
+        return work;
+    }
+    return { preview, clear, alias: (from, to) => { const value = cache.get(from); if (value)
+            cache.set(to, value); } };
+}

package/dist/expo.d.ts

@@ -1,3 +1,4 @@
+export { createExpoMessagingClient } from './expo-outbox.js';
 import React from 'react';
 import { type MessagingAppearance } from '@robono/messaging';
 import { type MessagingScreenProps } from './index.js';
@@ -8,12 +9,17 @@ export { createExpoMessagingAudioSession, createExpoMessagingDevice, createExpoM
 export type { MessagingAudioSession } from './expo-media.js';
 export type { LocalMessagingMedia, MessagingMediaStorage, MediaTransferOptions } from './media-controller.js';
 export { MessagingMediaController } from './media-controller.js';
-export declare function MessagingMediaOverlay({ controller, audio, appearance, inlineVoice, inlineRecorder }: {
+export declare function MessagingMediaOverlay({ controller, audio, appearance, inlineVoice, inlineRecorder, viewerActions, onDismiss }: {
+    onDismiss?: () => void;
+    viewerActions?: () => {
+        onForward?: () => void;
+        onDelete?: () => void;
+    };
     controller: MessagingMediaController;
     audio: MessagingAudioSession;
     appearance: MessagingAppearance;
-    inlineVoice?: boolean;
-    inlineRecorder?: boolean;
+    inlineVoice?: boolean | (() => boolean);
+    inlineRecorder?: boolean | (() => boolean);
 }): React.JSX.Element | null;
 export interface ExpoMessagingScreenProps extends Omit<MessagingScreenProps, 'pickAttachment' | 'openAttachment'> {
     storage: MessagingMediaStorage;