@robono/messaging-react-native 0.0.0-stage → 0.2.0

package/dist/expo-media.js

@@ -0,0 +1,411 @@
+import { AudioModule, RecordingPresets, createAudioPlayer, setAudioModeAsync } from 'expo-audio';
+import * as Picker from 'expo-image-picker';
+import * as Documents from 'expo-document-picker';
+import * as FS from 'expo-file-system/legacy';
+import * as Crypto from 'expo-crypto';
+import { defaultAttachmentLimits } from '@robono/messaging';
+let audioOwner = false;
+/** Pass your app's call-state guard and restore mode, or supply your existing audio-session coordinator. */
+export function createExpoMessagingAudioSession(options = {}) {
+    return { isAvailable: (purpose = 'playback') => purpose === 'playback' || !options.isCallActive?.(), async acquire(purpose) {
+            if (audioOwner)
+                throw Error('Finish the current recording first.');
+            if (purpose === 'recording' && options.isCallActive?.())
+                throw Error('Finish the current call before recording.');
+            audioOwner = true;
+            // The call owns its microphone, mode and output route. A playback lease
+            // borrows that session without changing any of them. Outside our call,
+            // mix rather than requesting exclusive focus from another calling app.
+            const borrowed = purpose === 'playback' && !!options.isCallActive?.();
+            try {
+                if (!borrowed)
+                    await setAudioModeAsync({ allowsRecording: purpose === 'recording', playsInSilentMode: true, shouldPlayInBackground: false, shouldRouteThroughEarpiece: false, interruptionMode: purpose === 'recording' ? 'doNotMix' : 'mixWithOthers' });
+            }
+            catch (e) {
+                audioOwner = false;
+                throw e;
+            }
+            let released = false;
+            return async () => {
+                if (released)
+                    return;
+                released = true;
+                try {
+                    if (!borrowed && !options.isCallActive?.())
+                        await setAudioModeAsync(options.restoreMode ?? { allowsRecording: false, playsInSilentMode: true, shouldPlayInBackground: false, shouldRouteThroughEarpiece: false, interruptionMode: 'mixWithOthers' });
+                }
+                finally {
+                    audioOwner = false;
+                }
+            };
+        } };
+}
+function check(signal) { if (signal.aborted)
+    throw Error('Cancelled.'); }
+const cacheRoot = () => { if (!FS.cacheDirectory)
+    throw Error('Private device storage is unavailable.'); return FS.cacheDirectory + 'robono-messaging/'; };
+const ownedDirectories = new Set();
+async function cacheDirectory() { const dir = cacheRoot() + Crypto.randomUUID() + '/'; await FS.makeDirectoryAsync(dir, { intermediates: true }); ownedDirectories.add(dir); return dir; }
+const cacheName = (name) => name.replace(/[^a-zA-Z0-9._-]/g, '_').slice(-90) || 'Attachment';
+async function cachePath(name) { return (await cacheDirectory()) + cacheName(name); }
+async function removeUri(uri) {
+    if (!uri.startsWith(cacheRoot()))
+        return;
+    const dir = uri.slice(0, uri.lastIndexOf('/') + 1);
+    // Each owned directory contains exactly one private copy. Remove it in one
+    // native operation rather than making the next open wait for two deletions.
+    if (ownedDirectories.has(dir)) {
+        await FS.deleteAsync(dir, { idempotent: true });
+        ownedDirectories.delete(dir);
+    }
+    else
+        await FS.deleteAsync(uri, { idempotent: true });
+}
+async function remove(file) { await removeUri(file.uri); }
+async function pickedCopy(uri, fileName, mimeType, durationMs) {
+    try {
+        return await copied(uri, fileName, mimeType, durationMs);
+    }
+    finally {
+        if (FS.cacheDirectory && uri.startsWith(FS.cacheDirectory))
+            await FS.deleteAsync(uri, { idempotent: true }).catch(() => { });
+    }
+}
+export async function copyMessagingCache(file) { return copied(file.uri, file.fileName, file.mimeType, file.durationMs); }
+async function copied(uri, fileName, mimeType, durationMs) {
+    const target = await cachePath(fileName);
+    try {
+        await FS.copyAsync({ from: uri, to: target });
+        const info = await FS.getInfoAsync(target);
+        if (!info.exists || info.isDirectory)
+            throw Error('The file could not be read.');
+        return { uri: target, fileName, mimeType, byteSize: info.size, ...(durationMs === undefined ? {} : { durationMs: Math.ceil(durationMs) }) };
+    }
+    catch (e) {
+        await removeUri(target).catch(() => { });
+        throw e;
+    }
+}
+async function recordingDuration(uri) {
+    // Android resets recorder status to zero after automatic stop. Read the finished file.
+    const player = createAudioPlayer(uri);
+    try {
+        const deadline = Date.now() + 5000;
+        while (!player.isLoaded && Date.now() < deadline)
+            await new Promise(r => setTimeout(r, 40));
+        const ms = Math.ceil(player.duration * 1000);
+        if (!player.isLoaded || !Number.isFinite(ms) || ms < 1)
+            throw Error('The recording length could not be read. Record again.');
+        return ms;
+    }
+    finally {
+        player.remove();
+    }
+}
+const extensionMimes = { jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', gif: 'image/gif', webp: 'image/webp', heic: 'image/heic', heif: 'image/heif', avif: 'image/avif', mp4: 'video/mp4', mov: 'video/quicktime', webm: 'video/webm', '3gp': 'video/3gpp', pdf: 'application/pdf', txt: 'text/plain', csv: 'text/csv', zip: 'application/zip', doc: 'application/msword', docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', xls: 'application/vnd.ms-excel', xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', ppt: 'application/vnd.ms-powerpoint', pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation' };
+function mime(value, name) { return value?.toLowerCase() || extensionMimes[name.split('.').at(-1)?.toLowerCase() ?? ''] || 'application/octet-stream'; }
+export function createExpoMessagingDevice(audio) {
+    let recorder = null, release = null;
+    let recordingDeadline = 0;
+    let starting = null;
+    let stopping = null;
+    return {
+        async pick(kind, settings, signal, source) {
+            if (source === 'camera' && (!['image', 'video'].includes(kind) || !settings.appearance.showCamera))
+                throw Error('Camera capture is unavailable.');
+            if (source === 'call-video' && (kind !== 'video' || !settings.enabled || !settings.features.video || settings.unansweredCalls?.video !== 'video'))
+                throw Error('Video messages after a call are unavailable.');
+            const limits = (settings.attachments ?? defaultAttachmentLimits())[kind];
+            if (kind === 'document') {
+                const result = await Documents.getDocumentAsync({ type: limits.allowedMimeTypes, multiple: false, copyToCacheDirectory: true });
+                if (signal.aborted) {
+                    for (const a of result.assets ?? [])
+                        if (FS.cacheDirectory && a.uri.startsWith(FS.cacheDirectory))
+                            await FS.deleteAsync(a.uri, { idempotent: true }).catch(() => { });
+                    check(signal);
+                }
+                if (result.canceled)
+                    return null;
+                const asset = result.assets[0];
+                if (!asset)
+                    return null;
+                return pickedCopy(asset.uri, asset.name, mime(asset.mimeType, asset.name));
+            }
+            if ((source === 'camera' || source === 'call-video')) {
+                const permission = await Picker.requestCameraPermissionsAsync();
+                check(signal);
+                if (!permission.granted)
+                    throw Error('Camera permission is needed to take photos or record videos.');
+            }
+            const result = await ((source === 'camera' || source === 'call-video') ? Picker.launchCameraAsync : Picker.launchImageLibraryAsync)({ mediaTypes: source === 'call-video' ? ['videos'] : (source === 'camera' || source === 'call-video') ? ([...((settings.features?.image ?? kind === 'image') ? ['images'] : []), ...(settings.features?.video ? ['videos'] : [])]) : kind === 'image' ? ['images'] : ['videos'], ...((source === 'camera' || source === 'call-video') ? { videoMaxDuration: settings.attachments?.video?.maxDurationSeconds ?? 60 } : {}), allowsMultipleSelection: false, allowsEditing: false, quality: 1, preferredAssetRepresentationMode: Picker.UIImagePickerPreferredAssetRepresentationMode.Current });
+            if (signal.aborted) {
+                for (const a of result.assets ?? [])
+                    if (FS.cacheDirectory && a.uri.startsWith(FS.cacheDirectory))
+                        await FS.deleteAsync(a.uri, { idempotent: true }).catch(() => { });
+                check(signal);
+            }
+            if (result.canceled)
+                return null;
+            const asset = result.assets[0];
+            if (!asset)
+                return null;
+            const video = (source === 'camera' || source === 'call-video') ? (asset.type === 'video' || asset.mimeType?.startsWith('video/')) : kind === 'video';
+            const name = asset.fileName ?? asset.uri.split('/').at(-1) ?? (kind === 'image' ? 'Photo' : 'Video');
+            if (video && (!asset.duration || !Number.isFinite(asset.duration))) {
+                if (FS.cacheDirectory && asset.uri.startsWith(FS.cacheDirectory))
+                    await FS.deleteAsync(asset.uri, { idempotent: true }).catch(() => { });
+                throw Error('The video length could not be read. Choose another video.');
+            }
+            return pickedCopy(asset.uri, name, mime(asset.mimeType, name), video ? asset.duration : undefined);
+        },
+        async startRecording(maximum, signal) {
+            if (starting || recorder)
+                throw Error('A recording is already in progress.');
+            const work = (async () => {
+                const permission = await AudioModule.requestRecordingPermissionsAsync();
+                check(signal);
+                if (!permission.granted)
+                    throw Error('Microphone permission is needed to record a voice message.');
+                release = await audio.acquire('recording');
+                try {
+                    check(signal);
+                    recorder = new AudioModule.AudioRecorder({ ...RecordingPresets.HIGH_QUALITY, isMeteringEnabled: true });
+                    await recorder.prepareToRecordAsync({ ...RecordingPresets.HIGH_QUALITY, isMeteringEnabled: true });
+                    check(signal); // Leave room for AAC encoder/container padding; the backend checks final file duration.
+                    const captureMs = Math.max(100, maximum - 100);
+                    recorder.record({ forDuration: captureMs / 1000 });
+                    recordingDeadline = Date.now() + captureMs;
+                }
+                catch (e) {
+                    if (recorder) {
+                        await recorder.stop().catch(() => { });
+                        const uri = recorder.uri;
+                        recorder.release();
+                        recorder = null;
+                        if (uri?.startsWith(FS.cacheDirectory ?? 'file://unavailable/'))
+                            await FS.deleteAsync(uri, { idempotent: true }).catch(() => { });
+                    }
+                    await release?.();
+                    release = null;
+                    throw e;
+                }
+            })();
+            starting = work;
+            try {
+                await work;
+            }
+            finally {
+                if (starting === work)
+                    starting = null;
+            }
+        },
+        recordingStatus() { const state = recorder?.getStatus(); return { durationMs: state?.durationMillis ?? 0, level: typeof state?.metering === 'number' ? Math.pow(10, state.metering / 40) : undefined, recording: !!state?.isRecording && audio.isAvailable?.('recording') !== false, limitReached: !state?.isRecording && Date.now() >= recordingDeadline }; },
+        async stopRecording() {
+            if (stopping)
+                return stopping;
+            const work = (async () => {
+                if (starting)
+                    await starting.catch(() => { });
+                const current = recorder;
+                recorder = null;
+                if (!current)
+                    return null;
+                let original = null;
+                try {
+                    const before = current.getStatus();
+                    if (before.isRecording)
+                        await current.stop();
+                    original = current.uri;
+                    if (!original)
+                        return null;
+                    const duration = await recordingDuration(original);
+                    return await copied(original, 'Voice message.m4a', 'audio/mp4', duration);
+                }
+                finally {
+                    current.release();
+                    if (original?.startsWith(FS.cacheDirectory ?? 'file://unavailable/'))
+                        await FS.deleteAsync(original, { idempotent: true }).catch(() => { });
+                    await release?.();
+                    release = null;
+                }
+            })();
+            stopping = work;
+            try {
+                return await work;
+            }
+            finally {
+                if (stopping === work)
+                    stopping = null;
+            }
+        }, remove,
+    };
+}
+function https(value) { const url = new URL(value); if (url.protocol !== 'https:' || url.username || url.password)
+    throw Error('A secure media URL is required.'); return url.href; }
+/** Private-storage transport. The endpoint is YOUR authenticated backend, never a Robono API key on the phone. */
+export function createExpoMessagingStorage(options) {
+    const endpoint = https(options.url);
+    async function request(operation, input, signal) {
+        const token = await options.getAccessToken();
+        if (!token)
+            throw Error('Sign in to continue.');
+        const bounded = new AbortController();
+        const cancel = () => bounded.abort();
+        signal?.addEventListener('abort', cancel, { once: true });
+        if (signal?.aborted)
+            bounded.abort();
+        const timeout = setTimeout(cancel, operation === 'complete' ? 120000 : 15000);
+        try {
+            const response = await fetch(endpoint, { method: 'POST', redirect: 'error', signal: bounded.signal, headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` }, body: JSON.stringify({ ...input, operation }) });
+            const result = await response.json();
+            if (!response.ok) {
+                const error = Object.assign(Error(result?.error?.message ?? 'The file could not be transferred. Try again.'), { status: response.status });
+                throw error;
+            }
+            return result;
+        }
+        finally {
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', cancel);
+        }
+    }
+    async function playbackPlan(message, signal) {
+        check(signal);
+        if (message.deleted)
+            throw Error('This attachment is no longer available.');
+        const grant = message.attachmentDownload;
+        const granted = grant && grant.messageId === message.id && grant.conversationId === message.conversationId && grant.assetId === message.media?.assetId && Number.isFinite(grant.expiresAt) && grant.expiresAt > Date.now() + 5000 && grant.expiresAt <= Date.now() + 60000;
+        const plan = granted ? { url: grant.url, media: message.media, headers: undefined } : await request('download', { conversationId: message.conversationId, messageId: message.id }, signal);
+        check(signal);
+        const media = plan.media;
+        if (!media || media.assetId !== message.media?.assetId || !Number.isSafeInteger(media.byteSize) || media.byteSize < 1 || media.byteSize > 104857600)
+            throw Error('Invalid attachment size or identity.');
+        return { ...plan, url: https(plan.url), media };
+    }
+    async function cancellable(task, context, run) {
+        check(context.signal);
+        const cancel = () => { void task.cancelAsync().catch(() => { }); };
+        context.signal.addEventListener('abort', cancel, { once: true });
+        try {
+            const result = await run();
+            check(context.signal);
+            return result;
+        }
+        finally {
+            context.signal.removeEventListener('abort', cancel);
+        }
+    }
+    return {
+        async stream(message, context) {
+            check(context.signal);
+            if (message.deleted)
+                throw Error('This attachment is no longer available.');
+            if (options.streaming === false || !['voice', 'video'].includes(message.kind) || !message.media?.assetId.startsWith('robono-r2:'))
+                return null;
+            const plan = await playbackPlan(message, context.signal);
+            // The native player requests byte ranges directly from the same private,
+            // metered gateway. No file copy or thumbnail precedes playback.
+            const { assetId, ...media } = plan.media;
+            return { ...media, uri: plan.url, stream: { headers: plan.headers } };
+        },
+        async upload(file, context) {
+            const { uri, ...metadata } = file;
+            const plan = await request('prepare', { uploadId: context.uploadId, conversationId: context.conversationId, kind: context.kind, file: metadata }, context.signal);
+            check(context.signal);
+            if (plan.media)
+                return plan.media;
+            const task = FS.createUploadTask(https(plan.url), uri, { httpMethod: 'PUT', uploadType: FS.FileSystemUploadType.BINARY_CONTENT, headers: plan.headers ?? {}, sessionType: FS.FileSystemSessionType.FOREGROUND }, p => context.onProgress(p.totalBytesExpectedToSend > 0 ? p.totalBytesSent / p.totalBytesExpectedToSend : 0));
+            const result = await cancellable(task, context, () => task.uploadAsync());
+            // An immutable PUT may already have succeeded before its response was lost.
+            // A 412 is not success by itself: complete still verifies ownership and bytes.
+            if (!result || result.status !== 412 && (result.status < 200 || result.status >= 300))
+                throw Error('Upload failed. Try again.');
+            // Verification is repeatable for the same upload. A transient inspector
+            // failure must not upload the bytes again or create a second attachment.
+            for (let attempt = 0;; attempt++) {
+                check(context.signal);
+                try {
+                    const complete = await request('complete', { uploadId: context.uploadId, conversationId: context.conversationId }, context.signal);
+                    return complete.media;
+                }
+                catch (error) {
+                    if (attempt >= 2 || ![502, 503, 504].includes(error.status ?? 0))
+                        throw error;
+                    check(context.signal);
+                    await new Promise((resolve, reject) => {
+                        const cancel = () => { clearTimeout(timer); context.signal.removeEventListener('abort', cancel); reject(Error('Cancelled')); };
+                        const timer = setTimeout(() => { context.signal.removeEventListener('abort', cancel); resolve(); }, 1000 * (attempt + 1));
+                        context.signal.addEventListener('abort', cancel, { once: true });
+                        if (context.signal.aborted)
+                            cancel();
+                    });
+                }
+            }
+        },
+        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)
+                throw Error('This attachment is no longer available.');
+            // Local directory preparation needs no media access. Run it alongside
+            // authorization, but never start the transfer until both have succeeded.
+            const [authorized, prepared] = await Promise.allSettled([
+                playbackPlan(message, context.signal),
+                cacheDirectory(),
+            ]);
+            const dir = prepared.status === 'fulfilled' ? prepared.value : null;
+            let path = null;
+            try {
+                if (authorized.status === 'rejected')
+                    throw authorized.reason;
+                if (prepared.status === 'rejected')
+                    throw prepared.reason;
+                check(context.signal);
+                const plan = authorized.value, media = plan.media;
+                if (!media || !Number.isSafeInteger(media.byteSize) || media.byteSize < 1 || media.byteSize > 104857600)
+                    throw Error('Invalid attachment size.');
+                path = prepared.value + cacheName(media.fileName);
+                const task = FS.createDownloadResumable(https(plan.url), path, { headers: plan.headers ?? {}, sessionType: FS.FileSystemSessionType.FOREGROUND }, p => {
+                    if (p.totalBytesWritten > media.byteSize)
+                        void task.cancelAsync().catch(() => { });
+                    context.onProgress(p.totalBytesWritten / media.byteSize);
+                });
+                const result = await cancellable(task, context, () => task.downloadAsync());
+                if (!result || result.status !== 200)
+                    throw Error('Download failed. Try again.');
+                const info = await FS.getInfoAsync(path);
+                if (!info.exists || info.isDirectory || info.size !== media.byteSize)
+                    throw Error('The attachment could not be verified.');
+                return { uri: path, mimeType: media.mimeType, fileName: media.fileName, byteSize: media.byteSize, ...(media.durationMs ? { durationMs: media.durationMs } : {}) };
+            }
+            catch (e) {
+                if (dir)
+                    await removeUri(path ?? dir + 'Attachment').catch(() => { });
+                throw e;
+            }
+        },
+        async discard(uploadId) { await request('discard', { uploadId }); },
+    };
+}

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