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

package/dist/message-links.js

@@ -0,0 +1,30 @@
+/** Only explicit web links become actions. Never interpret arbitrary URI schemes. */
+export function messageLinks(text) {
+    const parts = [];
+    let offset = 0;
+    for (const match of text.matchAll(/(?:https?:\/\/|www\.)[^\s<>]+/gi)) {
+        const start = match.index, raw = match[0];
+        let label = raw.replace(/[.,!?;:]+$/, '');
+        while (/[)\]}]$/.test(label)) {
+            const close = label.at(-1), open = { ')': '(', ']': '[', '}': '{' }[close];
+            if (label.split(close).length <= label.split(open).length)
+                break;
+            label = label.slice(0, -1);
+        }
+        if (!label)
+            continue;
+        try {
+            const url = new URL(/^www\./i.test(label) ? 'https://' + label : label);
+            if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password)
+                continue;
+            if (start > offset)
+                parts.push({ text: text.slice(offset, start) });
+            parts.push({ text: label, url: url.href });
+            offset = start + label.length;
+        }
+        catch { }
+    }
+    if (offset < text.length)
+        parts.push({ text: text.slice(offset) });
+    return parts.length ? parts : [{ text }];
+}

package/dist/message-order.d.ts

@@ -0,0 +1,4 @@
+import type { MessagingMessage } from '@robono/messaging';
+/** Upload completion order must not reorder the attachments selected together.
+ * Transport state remains in server sequence order for reconnect cursors. */
+export declare function orderChatMessages<T extends MessagingMessage>(messages: readonly T[]): T[];

package/dist/message-order.js

@@ -0,0 +1,17 @@
+/** Upload completion order must not reorder the attachments selected together.
+ * Transport state remains in server sequence order for reconnect cursors. */
+export function orderChatMessages(messages) {
+    const first = new Map();
+    const key = (m) => m.attachmentBatch ? JSON.stringify([m.senderId, m.attachmentBatch.id]) : null;
+    for (let i = 0; i < messages.length; i++) {
+        const k = key(messages[i]);
+        if (k && !first.has(k))
+            first.set(k, i);
+    }
+    return messages.map((message, index) => ({ message, index })).sort((a, b) => {
+        const ak = key(a.message), bk = key(b.message);
+        if (ak && ak === bk)
+            return a.message.attachmentBatch.index - b.message.attachmentBatch.index || a.index - b.index;
+        return (ak ? first.get(ak) : a.index) - (bk ? first.get(bk) : b.index);
+    }).map(item => item.message);
+}

package/dist/native-outbox.d.ts

@@ -0,0 +1,49 @@
+import type { MessageContent, MessageMedia, MessagingOutbox, SavedOutgoingMessage } from '@robono/messaging';
+import type { LocalMessagingMedia } from './media-controller.js';
+export interface NativeDraftFiles {
+    read(scope: string, conversation: string): Promise<NativeDraftState>;
+    write(scope: string, conversation: string, state: NativeDraftState): Promise<void>;
+    copy(scope: string, conversation: string, id: string, source: LocalMessagingMedia): Promise<string>;
+    file(scope: string, conversation: string, id: string): Promise<string | null>;
+    remove(scope: string, conversation: string, id: string): Promise<void>;
+    clear(scope: string, conversation?: string): Promise<void>;
+}
+export interface NativeDraftState {
+    draft: string;
+    messages: Array<SavedOutgoingMessage & {
+        fileId?: string;
+    }>;
+    files: Record<string, {
+        kind: MessageContent['kind'];
+        media: MessageMedia;
+    }>;
+}
+export declare const emptyNativeDraft: () => NativeDraftState;
+/** Durable outgoing content only, isolated by endpoint, namespace and signed-in user. */
+export declare class NativeMessagingOutbox implements MessagingOutbox {
+    private files;
+    private generation;
+    private scope;
+    constructor(endpoint: string, userId: string, files: NativeDraftFiles, namespace?: string);
+    private serial;
+    load(cid: string): Promise<{
+        draft: string;
+        messages: {
+            clientMessageId: string;
+            createdAt: string;
+            content: MessageContent;
+            needsPreparation?: boolean;
+        }[];
+        attachments: {
+            kind: "text" | "voice" | "image" | "video" | "document" | "poll";
+            media: MessageMedia;
+        }[];
+    }>;
+    put(cid: string, message: SavedOutgoingMessage): Promise<void>;
+    remove(cid: string, id: string): Promise<void>;
+    draft(cid: string, text: string): Promise<void>;
+    clear(cid?: string): Promise<void>;
+    saveFile(cid: string, media: MessageMedia, file: LocalMessagingMedia, kind: MessageContent['kind']): Promise<void>;
+    file(cid: string, id: string): Promise<LocalMessagingMedia | undefined>;
+    releaseFile(cid: string, id: string): Promise<void>;
+}

package/dist/native-outbox.js

@@ -0,0 +1,51 @@
+export const emptyNativeDraft = () => ({ draft: '', messages: [], files: {} });
+const queues = new Map();
+const epochs = new Map();
+/** Durable outgoing content only, isolated by endpoint, namespace and signed-in user. */
+export class NativeMessagingOutbox {
+    files;
+    generation = 0;
+    scope;
+    constructor(endpoint, userId, files, namespace = 'default') {
+        this.files = files;
+        this.scope = JSON.stringify([endpoint, namespace, userId]);
+    }
+    serial(work) { const task = (queues.get(this.scope) ?? Promise.resolve()).catch(() => { }).then(work); queues.set(this.scope, task); void task.finally(() => { if (queues.get(this.scope) === task)
+        queues.delete(this.scope); }).catch(() => { }); return task; }
+    load(cid) { return this.serial(async () => { const saved = await this.files.read(this.scope, cid), used = new Set(saved.messages.map(m => m.fileId)); return { draft: saved.draft, messages: saved.messages.map(({ fileId, ...message }) => message), attachments: Object.entries(saved.files).filter(([id]) => !used.has(id)).map(([, f]) => ({ kind: f.kind, media: f.media })) }; }); }
+    put(cid, message) { return this.serial(async () => { const state = await this.files.read(this.scope, cid), previous = state.messages.find(m => m.clientMessageId === message.clientMessageId); state.messages = state.messages.filter(m => m.clientMessageId !== message.clientMessageId); state.messages.push({ ...message, fileId: message.needsPreparation ? message.content.media?.assetId : previous?.fileId }); await this.files.write(this.scope, cid, state); }); }
+    remove(cid, id) { return this.serial(async () => { const state = await this.files.read(this.scope, cid), fileId = state.messages.find(m => m.clientMessageId === id)?.fileId; state.messages = state.messages.filter(m => m.clientMessageId !== id); if (fileId && !state.messages.some(m => m.fileId === fileId)) {
+        delete state.files[fileId];
+        await this.files.write(this.scope, cid, state);
+        await this.files.remove(this.scope, cid, fileId);
+    }
+    else
+        await this.files.write(this.scope, cid, state); }); }
+    draft(cid, text) { return this.serial(async () => { const state = await this.files.read(this.scope, cid); state.draft = text.slice(0, 10000); await this.files.write(this.scope, cid, state); }); }
+    clear(cid) { this.generation++; epochs.set(this.scope, (epochs.get(this.scope) ?? 0) + 1); return this.serial(() => this.files.clear(this.scope, cid)); }
+    saveFile(cid, media, file, kind) {
+        const generation = this.generation, epoch = epochs.get(this.scope) ?? 0;
+        const current = () => generation === this.generation && epoch === (epochs.get(this.scope) ?? 0);
+        return this.serial(async () => {
+            if (!current())
+                throw Error('The chat closed before the attachment was saved.');
+            await this.files.copy(this.scope, cid, media.assetId, file);
+            try {
+                if (!current())
+                    throw Error('The chat closed before the attachment was saved.');
+                const state = await this.files.read(this.scope, cid);
+                state.files[media.assetId] = { kind, media };
+                await this.files.write(this.scope, cid, state);
+            }
+            catch (error) {
+                await this.files.remove(this.scope, cid, media.assetId).catch(() => { });
+                throw error;
+            }
+        });
+    }
+    file(cid, id) { return this.serial(async () => { const saved = (await this.files.read(this.scope, cid)).files[id]; if (!saved)
+        return undefined; const uri = await this.files.file(this.scope, cid, id); if (!uri)
+        throw Error('This saved attachment is missing. Remove it and choose it again.'); return { ...saved.media, uri }; }); }
+    releaseFile(cid, id) { return this.serial(async () => { const state = await this.files.read(this.scope, cid); if (state.messages.some(m => m.fileId === id))
+        return; delete state.files[id]; await this.files.write(this.scope, cid, state); await this.files.remove(this.scope, cid, id); }); }
+}

package/dist/pollVoteQueue.d.ts

@@ -0,0 +1,3 @@
+/** Show the latest selection immediately, but serialize complete selections so
+ * an older, slower request can never overwrite a newer vote on the server. */
+export declare function createPollVoteQueue(save: (choices: number[]) => Promise<void>, pending: (choices: number[] | null) => void, failed: () => void): (choices: number[]) => Promise<void>;

package/dist/pollVoteQueue.js

@@ -0,0 +1,29 @@
+/** Show the latest selection immediately, but serialize complete selections so
+ * an older, slower request can never overwrite a newer vote on the server. */
+export function createPollVoteQueue(save, pending, failed) {
+    let running = false, next;
+    return async (choices) => {
+        next = [...choices];
+        pending(next);
+        if (running)
+            return;
+        running = true;
+        try {
+            while (next) {
+                const current = next;
+                next = undefined;
+                try {
+                    await save(current);
+                }
+                catch {
+                    if (!next)
+                        failed();
+                }
+            }
+        }
+        finally {
+            running = false;
+            pending(null);
+        }
+    };
+}

package/dist/polls.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { type MessagingAppearance, type MessagingMessage, type MessagePoll } from '@robono/messaging';
+/** Optional reusable poll content. Votes are submitted as a complete selection, not a toggle request. */
+export declare function PollMessage({ message, userId, ink, accent, enabled, onVote, onClose, resolveVoterName, background, foreground, renderDetails, detailsOpen, onDetailsOpenChange }: {
+    detailsOpen?: boolean;
+    onDetailsOpenChange?: (open: boolean) => void;
+    renderDetails?: (content: React.ReactNode, onClose: () => void) => React.ReactNode;
+    message: MessagingMessage;
+    userId: string;
+    ink: string;
+    accent: string;
+    enabled: boolean;
+    onVote: (options: number[]) => Promise<void>;
+    onClose: () => Promise<void>;
+    resolveVoterName?: (userId: string) => string;
+    background?: string;
+    foreground?: string;
+}): React.JSX.Element | null;
+export declare function PollComposer({ appearance, onSend, onCancel, retrySafe, yesNo }: {
+    yesNo?: boolean;
+    retrySafe?: boolean;
+    appearance: MessagingAppearance;
+    onSend: (poll: MessagePoll) => Promise<void>;
+    onCancel: () => void;
+}): React.JSX.Element;

package/dist/polls.js

@@ -0,0 +1,121 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useRef, useState } from 'react';
+import { createPollVoteQueue } from './pollVoteQueue';
+import { ActivityIndicator, KeyboardAvoidingView, Platform, Pressable, ScrollView, Switch, Text, TextInput, View } from 'react-native';
+import { validatePoll } from '@robono/messaging';
+const PollArea = View;
+import { MessagingPopup as PollModal } from './popup.js';
+/** Optional reusable poll content. Votes are submitted as a complete selection, not a toggle request. */
+export function PollMessage({ message, userId, ink, accent, enabled, onVote, onClose, resolveVoterName, background = '#101010', foreground = '#fff', renderDetails, detailsOpen, onDetailsOpenChange }) {
+    const [busy, setBusy] = useState(false), [error, setError] = useState(''), [localShowVotes, setLocalShowVotes] = useState(false);
+    const showVotes = detailsOpen ?? localShowVotes;
+    const setShowVotes = (open) => { setLocalShowVotes(open); onDetailsOpenChange?.(open); };
+    const [pending, setPending] = useState(null);
+    const current = useRef({ onVote });
+    current.current = { onVote };
+    const selection = useRef([]);
+    const queue = useRef(null);
+    if (!queue.current)
+        queue.current = createPollVoteQueue(choices => current.current.onVote(choices), choices => { if (choices)
+            selection.current = choices; setPending(choices); }, () => setError('The poll could not be updated. Try again.'));
+    const actionBusy = useRef(false);
+    const poll = message.poll;
+    if (!poll)
+        return null;
+    if (poll.kind === 'yes_no')
+        return _jsx(YesNoQuestion, { message, userId, ink, accent, enabled, onVote, onClose, resolveVoterName, renderDetails, detailsOpen, onDetailsOpenChange, background, foreground });
+    const savedVotes = message.pollState?.votes ?? [], selected = pending ?? savedVotes.find(v => v.userId === userId)?.options ?? [], closed = !!message.pollState?.closed;
+    selection.current = selected;
+    const votes = pending === null ? savedVotes : [...savedVotes.filter(v => v.userId !== userId), ...(pending.length ? [{ userId, options: pending }] : [])];
+    async function act(work) { if (actionBusy.current)
+        return; actionBusy.current = true; setBusy(true); setError(''); try {
+        await work();
+    }
+    catch {
+        setError('The poll could not be updated. Try again.');
+    }
+    finally {
+        actionBusy.current = false;
+        setBusy(false);
+    } }
+    const details = _jsxs(View, { style: { gap: 14 }, children: [_jsxs(View, { style: { gap: 4 }, children: [_jsx(Text, { style: { fontSize: 17, lineHeight: 23, fontWeight: '600', color: foreground }, children: poll.question }), _jsxs(Text, { style: { fontSize: 12, lineHeight: 17, color: foreground, opacity: .65 }, children: [votes.length, " ", votes.length === 1 ? 'person voted' : 'people voted', " \u00B7 ", closed ? 'Closed' : poll.multiple ? 'Multiple answers' : 'One answer per person'] })] }), _jsx(View, { style: { gap: 14 }, children: poll.options.map((option, index) => {
+                    const people = votes.filter(v => v.options.includes(index));
+                    const names = people.map(v => v.userId === userId ? 'You' : resolveVoterName?.(v.userId) || 'Chat member').join(', ');
+                    return _jsxs(View, { style: { gap: 5 }, children: [_jsxs(View, { style: { flexDirection: 'row', alignItems: 'baseline', gap: 12 }, children: [_jsx(Text, { style: { flex: 1, color: foreground, fontSize: 15, lineHeight: 21, fontWeight: '600' }, children: option }), _jsx(Text, { style: { color: foreground, opacity: .65, fontSize: 13 }, children: people.length })] }), _jsxs(View, { style: { height: 4, borderRadius: 2, overflow: 'hidden' }, children: [_jsx(View, { style: { position: 'absolute', top: 0, bottom: 0, left: 0, right: 0, backgroundColor: foreground, opacity: .12 } }), _jsx(View, { style: { height: 4, width: `${votes.length ? people.length / votes.length * 100 : 0}%`, backgroundColor: accent } })] }), !!names && _jsx(Text, { style: { color: foreground, opacity: .7, fontSize: 13, lineHeight: 18 }, children: names })] }, index);
+                }) }), message.senderId === userId && !closed && enabled && _jsx(Pressable, { accessibilityRole: "button", disabled: busy || pending !== null, onPress: () => void act(onClose), style: { minHeight: 36, alignSelf: 'flex-end', justifyContent: 'center' }, children: _jsx(Text, { style: { color: accent, fontSize: 14 }, children: "End poll" }) }), !!error && _jsx(Text, { accessibilityRole: "alert", style: { color: foreground, fontSize: 13, lineHeight: 18 }, children: error })] });
+    return _jsxs(_Fragment, { children: [_jsxs(Pressable, { accessible: false, onPress: event => { event.stopPropagation(); setShowVotes(true); }, accessibilityLabel: `Poll: ${poll.question}. Open votes`, style: { width: 270, maxWidth: '100%', gap: 0, padding: 0 }, children: [_jsxs(Text, { accessibilityRole: "button", onPress: () => setShowVotes(true), style: { fontSize: 17, lineHeight: 23, fontWeight: '600', color: ink }, accessibilityHint: closed ? 'Poll closed' : poll.multiple ? 'Choose one or more answers' : 'Choose one answer', children: [poll.question, closed ? ' · Closed' : ''] }), poll.options.map((label, index) => {
+                        const count = votes.filter(v => v.options.includes(index)).length, checked = selected.includes(index);
+                        return _jsxs(View, { style: { minHeight: 36, paddingVertical: 3, gap: 2 }, children: [_jsxs(View, { style: { flexDirection: 'row', gap: 10, alignItems: 'center' }, children: [_jsx(Pressable, { accessibilityRole: poll.multiple ? 'checkbox' : 'radio', accessibilityLabel: `${label}, ${count} ${count === 1 ? 'vote' : 'votes'}`, "aria-checked": checked, accessibilityState: { checked, disabled: !enabled || closed || busy, busy: pending !== null }, hitSlop: 4, disabled: !enabled || closed || busy, onPress: event => { event.stopPropagation(); if (!enabled || closed || busy || actionBusy.current)
+                                                return; const previous = selection.current; setError(''); void queue.current(previous.includes(index) ? previous.filter(x => x !== index) : poll.multiple ? [...previous, index] : [index]); }, style: { width: 20, height: 20, borderRadius: poll.multiple ? 4 : 10, borderWidth: 2, borderColor: checked ? accent : ink, alignItems: 'center', justifyContent: 'center' }, children: checked && _jsx(View, { style: { width: 10, height: 10, borderRadius: poll.multiple ? 2 : 5, backgroundColor: accent } }) }), _jsx(Text, { style: { flex: 1, color: ink, fontSize: 16 }, children: label }), _jsx(Text, { style: { color: ink, fontSize: 13 }, children: count })] }), _jsx(View, { pointerEvents: "none", style: { height: 3, marginLeft: 30, backgroundColor: ink + '20', borderRadius: 2, overflow: 'hidden' }, children: _jsx(View, { style: { height: 3, width: `${votes.length ? count / votes.length * 100 : 0}%`, backgroundColor: accent } }) })] }, index);
+                    }), !!error && _jsx(Text, { accessibilityRole: "alert", style: { color: ink }, children: error })] }), showVotes && (renderDetails ? renderDetails(details, () => setShowVotes(false)) : _jsx(PollModal, { background: background, onClose: () => setShowVotes(false), children: _jsxs(PollArea, { style: { flexShrink: 1, backgroundColor: background }, children: [_jsxs(View, { style: { height: 56, paddingHorizontal: 20, flexDirection: 'row', alignItems: 'center', gap: 16 }, children: [_jsx(Text, { accessibilityRole: "header", style: { color: foreground, fontSize: 22, fontWeight: '600', flex: 1 }, children: "Votes" }), _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: "Close votes", onPress: () => setShowVotes(false), style: { minHeight: 44, justifyContent: 'center' }, children: _jsx(Text, { style: { color: accent, fontSize: 17 }, children: "Done" }) })] }), _jsx(ScrollView, { contentContainerStyle: { padding: 16 }, children: details })] }) }))] });
+}
+/** Recipient-only decision. Keep the attempted answer on an uncertain failure so
+ * retry cannot silently switch an answer the server may already have accepted. */
+function YesNoQuestion({ message, userId, ink, accent, enabled, onVote, onClose, resolveVoterName, renderDetails, detailsOpen, onDetailsOpenChange, background = '#111111', foreground = '#fff' }) {
+    const [attempt, setAttempt] = useState(null), [busy, setBusy] = useState(false), [error, setError] = useState(''), [localOpen, setLocalOpen] = useState(false);
+    const inFlight = useRef(false), firstChoice = useRef(null);
+    const poll = message.poll, answer = message.pollState?.votes.find(v => v.userId !== message.senderId)?.options[0];
+    const closed = !!message.pollState?.closed, chosen = answer ?? attempt, mine = message.senderId === userId;
+    const open = detailsOpen ?? localOpen;
+    const setOpen = (value) => { setLocalOpen(value); onDetailsOpenChange?.(value); };
+    async function choose(index) {
+        if (inFlight.current || !enabled || mine || closed)
+            return;
+        if (firstChoice.current !== null && firstChoice.current !== index)
+            return;
+        firstChoice.current = index;
+        inFlight.current = true;
+        setAttempt(index);
+        setBusy(true);
+        setError('');
+        setOpen(false);
+        try {
+            await onVote([index]);
+        }
+        catch {
+            setError('Answer not confirmed. Tap to retry.');
+        }
+        finally {
+            inFlight.current = false;
+            setBusy(false);
+        }
+    }
+    const respondent = message.pollState?.votes.find(v => v.userId !== message.senderId)?.userId;
+    const details = _jsxs(View, { style: { gap: 12 }, children: [_jsx(Text, { style: { color: foreground, fontSize: 17, lineHeight: 23, fontWeight: '600' }, children: poll.question }), _jsx(Text, { style: { color: foreground, fontSize: 15, lineHeight: 21 }, children: answer !== undefined ? `${respondent === userId ? 'You' : resolveVoterName?.(respondent) || 'Recipient'} answered ${poll.options[answer]}.` : closed ? 'Closed without an answer.' : attempt !== null ? 'Confirming your answer…' : 'Waiting for an answer.' }), mine && !closed && enabled && _jsx(Pressable, { accessibilityRole: "button", onPress: () => { if (inFlight.current)
+                    return; inFlight.current = true; void onClose().catch(() => setError('Could not close the question. Try again.')).finally(() => { inFlight.current = false; }); }, style: { minHeight: 36, alignSelf: 'flex-end', justifyContent: 'center' }, children: _jsx(Text, { style: { color: accent }, children: "End question" }) })] });
+    return _jsxs(_Fragment, { children: [_jsxs(Pressable, { accessible: false, onPress: e => { e.stopPropagation(); setOpen(true); }, style: { maxWidth: '100%', width: 270 }, children: [_jsx(Text, { accessibilityRole: "button", onPress: () => setOpen(true), style: { fontSize: 17, lineHeight: 23, fontWeight: '600', color: ink }, children: poll.question }), _jsx(View, { style: { flexDirection: 'row', gap: 20, paddingVertical: 6 }, children: poll.options.map((label, index) => _jsxs(Pressable, { accessibilityRole: "radio", accessibilityLabel: label, accessibilityState: { checked: chosen === index, disabled: !enabled || mine || closed || attempt !== null, busy }, disabled: !enabled || mine || closed || attempt !== null, onPress: e => { e.stopPropagation(); void choose(index); }, style: { flexDirection: 'row', alignItems: 'center', gap: 8, minHeight: 24 }, children: [_jsx(View, { style: { width: 20, height: 20, borderRadius: 10, borderWidth: 2, borderColor: chosen === index ? accent : ink, alignItems: 'center', justifyContent: 'center', opacity: chosen === undefined && mine ? .5 : 1 }, children: chosen === index && _jsx(View, { style: { width: 10, height: 10, borderRadius: 5, backgroundColor: accent } }) }), _jsx(Text, { style: { color: ink, fontSize: 16, fontWeight: chosen === index ? '600' : '400' }, children: label })] }, index)) }), !!error && !closed && _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: "Retry answer", disabled: busy || closed || attempt === null, onPress: e => { e.stopPropagation(); if (attempt !== null)
+                            void choose(attempt); }, children: _jsx(Text, { accessibilityRole: "alert", style: { color: ink, fontSize: 13 }, children: error }) })] }), open && (renderDetails ? renderDetails(details, () => setOpen(false)) : _jsxs(PollModal, { background: background, onClose: () => setOpen(false), children: [_jsxs(View, { style: { flexDirection: 'row', alignItems: 'center', marginBottom: 12 }, children: [_jsx(Text, { accessibilityRole: "header", style: { flex: 1, color: foreground, fontSize: 16, fontWeight: '600' }, children: "Answer" }), _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: "Close answer", onPress: () => setOpen(false), style: { minWidth: 44, minHeight: 44, justifyContent: 'center', alignItems: 'center' }, children: _jsx(Text, { style: { color: foreground, fontSize: 24 }, children: "\u00D7" }) })] }), _jsx(ScrollView, { children: details })] }))] });
+}
+export function PollComposer({ appearance, onSend, onCancel, retrySafe = false, yesNo = false }) {
+    const [question, setQuestion] = useState(''), [options, setOptions] = useState(['', '']), [multiple, setMultiple] = useState(false), [busy, setBusy] = useState(false), [error, setError] = useState(''), [submitted, setSubmitted] = useState(false);
+    const c = appearance.colors;
+    async function send() { if (busy || submitted)
+        return; let poll; try {
+        poll = validatePoll(yesNo ? { question, options: ['Yes', 'No'], multiple: false, kind: 'yes_no' } : { question, options, multiple });
+    }
+    catch (e) {
+        setError(e.message);
+        return;
+    } setBusy(true); setSubmitted(true); try {
+        await onSend(poll);
+        onCancel();
+    }
+    catch {
+        if (retrySafe)
+            setSubmitted(false);
+        setError(retrySafe ? 'The poll was not sent. Try again.' : 'The poll was not sent. Check the conversation for a retry.');
+    }
+    finally {
+        setBusy(false);
+    } }
+    const inputStyle = { fontSize: 17, color: c.foreground, minHeight: 48, borderBottomWidth: 1, borderBottomColor: c.secondary + '40', paddingVertical: 12 };
+    const web = true;
+    let ready = false;
+    try {
+        validatePoll(yesNo ? { question, options: ['Yes', 'No'], multiple: false, kind: 'yes_no' } : { question, options, multiple });
+        ready = true;
+    }
+    catch { }
+    return _jsx(PollModal, { form: true, background: c.background, onClose: () => { if (!busy)
+            onCancel(); }, children: _jsxs(PollArea, { style: { ...(web ? { flexShrink: 1 } : { flex: 1 }), backgroundColor: c.background }, children: [_jsxs(View, { style: { height: web ? 36 : 56, paddingHorizontal: web ? 0 : 16, flexDirection: 'row', alignItems: 'center', gap: 16 }, children: [!web && _jsx(Pressable, { accessibilityRole: "button", disabled: busy, onPress: onCancel, style: { minHeight: 44, justifyContent: 'center' }, children: _jsx(Text, { style: { color: c.foreground, fontSize: 16 }, children: "Cancel" }) }), _jsx(Text, { accessibilityRole: "header", style: { flex: 1, fontSize: 20, fontWeight: '600', color: c.foreground }, children: yesNo ? 'Yes/No question' : 'New poll' }), !web && _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: yesNo ? "Send question" : "Send poll", disabled: busy || submitted || !ready, onPress: () => void send(), style: { minHeight: 44, justifyContent: 'center', opacity: ready ? 1 : .4 }, children: busy ? _jsx(ActivityIndicator, { color: c.accent }) : _jsx(Text, { style: { color: c.accent, fontSize: 17, fontWeight: '600' }, children: "Send" }) })] }), _jsx(KeyboardAvoidingView, { style: web ? { flexShrink: 1 } : { flex: 1 }, behavior: Platform.OS === 'ios' ? 'padding' : 'height', children: _jsxs(ScrollView, { keyboardShouldPersistTaps: "handled", keyboardDismissMode: "on-drag", contentContainerStyle: { padding: web ? 0 : 16, paddingBottom: web ? 12 : 20, gap: 4 }, children: [_jsx(Text, { style: { color: c.secondary, fontSize: 14, marginTop: 12 }, children: "Question" }), _jsx(TextInput, { accessibilityLabel: "Poll question", placeholder: "Ask a question", placeholderTextColor: c.secondary, maxLength: 300, multiline: true, value: question, onChangeText: setQuestion, editable: !busy, style: inputStyle }), !yesNo && _jsxs(_Fragment, { children: [_jsx(Text, { style: { color: c.secondary, fontSize: 14, marginTop: 16 }, children: "Answers" }), options.map((option, i) => _jsxs(View, { style: { flexDirection: 'row', alignItems: 'center', gap: 8 }, children: [_jsx(TextInput, { accessibilityLabel: `Option ${i + 1}`, placeholder: "Add an option", placeholderTextColor: c.secondary, maxLength: 100, value: option, onChangeText: v => setOptions(items => items.map((x, n) => n === i ? v : x)), editable: !busy, style: { ...inputStyle, flex: 1 } }), options.length > 2 && _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: `Remove option ${i + 1}`, disabled: busy, onPress: () => setOptions(items => items.filter((_, n) => n !== i)), style: { width: 44, height: 44, alignItems: 'center', justifyContent: 'center' }, children: _jsx(Text, { style: { color: c.secondary, fontSize: 26 }, children: "\u00D7" }) })] }, i)), options.length < 12 && _jsx(Pressable, { accessibilityRole: "button", disabled: busy, onPress: () => setOptions(items => [...items, '']), style: { minHeight: 44, justifyContent: 'center' }, children: _jsx(Text, { style: { color: c.accent, fontSize: 16 }, children: "Add option" }) }), _jsxs(View, { style: { minHeight: 48, flexDirection: 'row', gap: 12, alignItems: 'center', marginTop: 8 }, children: [_jsx(Text, { style: { color: c.foreground, fontSize: 16, flex: 1 }, children: "Allow multiple answers" }), _jsx(Switch, { accessibilityLabel: "Allow multiple answers", disabled: busy, value: multiple, onValueChange: setMultiple, trackColor: { true: c.accent } })] }), _jsx(Text, { style: { color: c.secondary, fontSize: 13, lineHeight: 19 }, children: "Everyone in the chat can see the votes." })] }), yesNo && _jsx(Text, { style: { color: c.secondary, fontSize: 13, lineHeight: 19, marginTop: 8 }, children: "Their first Yes or No answer is final." }), !!error && _jsx(Text, { accessibilityRole: "alert", style: { color: c.foreground, marginTop: 8 }, children: error })] }) }), web && _jsxs(View, { style: { flexDirection: 'row', gap: 8, marginTop: 8 }, children: [_jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: "Cancel", disabled: busy, onPress: onCancel, style: { flex: 1, minHeight: 44, borderRadius: 12, backgroundColor: c.secondary + '20', alignItems: 'center', justifyContent: 'center' }, children: _jsx(Text, { style: { color: c.foreground, fontSize: 16, fontWeight: '600' }, children: "Cancel" }) }), _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: yesNo ? "Send question" : "Send poll", disabled: busy || submitted || !ready, onPress: () => void send(), style: { flex: 1, minHeight: 44, borderRadius: 12, backgroundColor: c.accent, opacity: (busy || submitted || !ready) ? 0.45 : 1, alignItems: 'center', justifyContent: 'center' }, children: busy ? _jsx(ActivityIndicator, { color: "#fff" }) : _jsx(Text, { style: { color: '#fff', fontSize: 16, fontWeight: '600' }, children: "Send" }) })] })] }) });
+}

package/dist/popup.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export declare function MessagingPopup({ children, onClose, background, form, visible, onDismiss }: {
+    children: React.ReactNode;
+    onClose: () => void;
+    background: string;
+    form?: boolean;
+    visible?: boolean;
+    onDismiss?: () => void;
+}): React.JSX.Element;

package/dist/popup.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { KeyboardAvoidingView, Modal, Platform, View } from 'react-native';
+// Messenger's centered popup on every platform. Keyboard movement is contained
+// by the scrim; the form itself must never become a separate full-screen route.
+export function MessagingPopup({ children, onClose, background, form = false, visible = true, onDismiss }) {
+    return _jsx(Modal, { visible: visible, onDismiss: onDismiss, transparent: true, animationType: "fade", onRequestClose: onClose, children: _jsx(KeyboardAvoidingView, { behavior: Platform.OS === 'ios' ? 'padding' : undefined, style: { flex: 1, backgroundColor: '#0009', justifyContent: 'center', alignItems: 'center', padding: 24 }, children: _jsx(View, { accessibilityViewIsModal: true, onAccessibilityEscape: onClose, style: { width: '100%', maxWidth: 360, maxHeight: '85%', backgroundColor: background, borderRadius: form ? 20 : 18, padding: form ? 20 : 16, overflow: 'hidden' }, children: children }) }) });
+}

package/dist/recent-media.d.ts

@@ -0,0 +1,21 @@
+import type { MessagingMessage } from '@robono/messaging';
+import type { LocalMessagingMedia, MessagingMediaStorage } from './media-controller.js';
+/** Small, short-lived conversation cache. Every original is obtained through the
+ * authenticated storage adapter. Viewers receive their own disposable copy. */
+export declare class RecentMessagingMedia {
+    private source;
+    private files;
+    private now;
+    private entries;
+    private running;
+    constructor(source: MessagingMediaStorage, files: {
+        copy: (file: LocalMessagingMedia) => Promise<LocalMessagingMedia>;
+        remove: (file: LocalMessagingMedia) => Promise<void>;
+    }, now?: () => number);
+    readonly storage: MessagingMediaStorage;
+    sync(messages: MessagingMessage[]): void;
+    clear(): void;
+    private drop;
+    private pump;
+    private start;
+}

package/dist/recent-media.js

@@ -0,0 +1,123 @@
+const key = (m) => JSON.stringify([m.conversationId, m.id, m.media]);
+/** Small, short-lived conversation cache. Every original is obtained through the
+ * authenticated storage adapter. Viewers receive their own disposable copy. */
+export class RecentMessagingMedia {
+    source;
+    files;
+    now;
+    entries = new Map();
+    running = 0;
+    constructor(source, files, now = Date.now) {
+        this.source = source;
+        this.files = files;
+        this.now = now;
+    }
+    storage = {
+        thumbnail: (message, context) => this.source.thumbnail?.(message, context) ?? Promise.resolve(null),
+        stream: (message, context) => this.source.stream?.(message, context) ?? Promise.resolve(null),
+        upload: (file, context) => this.source.upload(file, context), discard: id => this.source.discard(id),
+        download: async (message, context) => {
+            const id = key(message), entry = this.entries.get(id);
+            if (!entry)
+                return this.source.download(message, context);
+            if (context.signal.aborted)
+                throw Error('Cancelled.');
+            if (entry.file && entry.expires <= this.now()) {
+                this.drop(id, entry);
+                return this.source.download(message, context);
+            }
+            let file;
+            try {
+                file = await this.start(id, entry);
+            }
+            catch {
+                if (context.signal.aborted || this.entries.get(id) !== entry)
+                    throw Error('Cancelled.');
+                // A failed speculative transfer must not make the user's explicit retry fail.
+                this.drop(id, entry);
+                return this.source.download(message, context);
+            }
+            if (context.signal.aborted || this.entries.get(id) !== entry)
+                throw Error('Cancelled.');
+            const copy = await this.files.copy(file);
+            if (context.signal.aborted || this.entries.get(id) !== entry) {
+                await this.files.remove(copy);
+                throw Error('Cancelled.');
+            }
+            context.onProgress(1);
+            return copy;
+        }
+    };
+    sync(messages) {
+        // At most six recent photos/voice clips/small videos, 2 MiB each / 6 MiB total.
+        // Large videos and documents remain tap-to-download. Never preload all history.
+        const wanted = new Map();
+        let bytes = 0;
+        for (const m of [...messages].reverse()) {
+            if (wanted.size >= 6)
+                break;
+            const size = m.media?.byteSize;
+            if (this.source.stream && ['voice', 'video'].includes(m.kind))
+                continue;
+            if (m.deleted || !['image', 'voice', 'video'].includes(m.kind) || !size || size > 2 * 1048576 || bytes + size > 6 * 1048576)
+                continue;
+            wanted.set(key(m), m);
+            bytes += size;
+        }
+        for (const [id, entry] of this.entries)
+            if (!wanted.has(id))
+                this.drop(id, entry);
+        for (const [id, message] of wanted) {
+            const entry = this.entries.get(id);
+            if (!entry)
+                this.entries.set(id, { message, abort: new AbortController(), expires: 0, attempted: false });
+            // The client replaces message objects when it receives refreshed server history.
+            // A re-render with the same objects must not extend this access window.
+            else if (entry.message !== message) {
+                entry.message = message;
+                if (entry.file)
+                    entry.expires = this.now() + 60000;
+            }
+        }
+        this.pump();
+    }
+    clear() { for (const [id, entry] of this.entries)
+        this.drop(id, entry); }
+    drop(id, entry) {
+        if (this.entries.get(id) === entry)
+            this.entries.delete(id);
+        entry.abort.abort();
+        if (entry.file) {
+            void this.files.remove(entry.file).catch(() => { });
+            entry.file = undefined;
+        }
+    }
+    pump() {
+        for (const [id, entry] of this.entries) {
+            if (this.running >= 2)
+                break;
+            if (!entry.attempted) {
+                this.running++;
+                void this.start(id, entry).catch(() => { }).finally(() => { this.running--; this.pump(); });
+            }
+        }
+    }
+    start(id, entry) {
+        if (entry.file)
+            return Promise.resolve(entry.file);
+        if (entry.work)
+            return entry.work;
+        entry.attempted = true;
+        entry.work = (async () => {
+            const file = await this.source.download(entry.message, { signal: entry.abort.signal, onProgress: () => { } });
+            if (entry.abort.signal.aborted || this.entries.get(id) !== entry) {
+                await this.files.remove(file);
+                throw Error('Cancelled.');
+            }
+            entry.file = file;
+            entry.expires = this.now() + 60000;
+            return file;
+        })();
+        return entry.work;
+    }
+}

package/dist/safety.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { MessagingClient, MessagingAppearance, MessagingState } from '@robono/messaging';
+/** Uses the authenticated messaging client's durable safety operations, or the host can keep its own UI. */
+export declare function MessagingSafety({ client, state, appearance, name, messageId, onClose, onSearch }: {
+    client: MessagingClient;
+    state: MessagingState;
+    appearance: MessagingAppearance;
+    name: string;
+    messageId?: string;
+    onClose: () => void;
+    onSearch?: () => void;
+}): React.JSX.Element;

package/dist/safety.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { KeyboardAvoidingView, Modal, Platform, Pressable, ScrollView, Text, TextInput, View } from 'react-native';
+/** Uses the authenticated messaging client's durable safety operations, or the host can keep its own UI. */
+export function MessagingSafety({ client, state, appearance, name, messageId, onClose, onSearch }) {
+    const [mode, setMode] = useState(messageId ? 'report' : 'menu');
+    const [category, setCategory] = useState(''), [details, setDetails] = useState(''), [busy, setBusy] = useState(false), [error, setError] = useState('');
+    const reportRequest = useRef(null), reportContent = useRef('');
+    const [visible, setVisible] = useState(true), afterClose = useRef(null);
+    const dismissed = () => { const next = afterClose.current; afterClose.current = null; next?.(); };
+    useEffect(() => { if (!visible && Platform.OS !== 'ios')
+        dismissed(); }, [visible]);
+    useEffect(() => () => { afterClose.current = null; }, [client]);
+    const search = () => { afterClose.current = onSearch ?? null; setVisible(false); };
+    const c = appearance.colors, safety = state.conversation?.safety, blocked = safety?.blockedByMe;
+    const primaryInk = (() => { const hex = c.accent.replace('#', ''); const expanded = hex.length === 3 ? hex.split('').map(x => x + x).join('') : hex; const value = parseInt(expanded, 16); return Number.isFinite(value) && ((value >> 16) * .299 + ((value >> 8) & 255) * .587 + (value & 255) * .114) > 155 ? '#111111' : '#ffffff'; })();
+    const button = (label, press, disabled = false, kind = 'plain') => _jsx(Pressable, { accessibilityRole: "button", accessibilityLabel: label, accessibilityState: { disabled: busy || disabled }, disabled: busy || disabled, onPress: press, style: ({ pressed }) => ({ minHeight: 44, paddingHorizontal: 12, paddingVertical: 10, justifyContent: 'center', alignItems: kind === 'plain' ? 'flex-start' : 'center', borderRadius: 12, flex: kind === 'plain' ? undefined : 1, backgroundColor: kind === 'primary' ? c.accent : kind === 'danger' ? '#b72d34' : kind === 'cancel' ? c.incoming : 'transparent', opacity: (busy || disabled) ? 0.5 : pressed ? 0.7 : 1 }), children: _jsx(Text, { style: { color: kind === 'primary' ? primaryInk : kind === 'danger' ? '#fff' : c.foreground, fontSize: 16, fontWeight: kind === 'plain' ? '400' : '600' }, children: label }) });
+    async function block() { setBusy(true); setError(''); try {
+        await client.setBlocked(!blocked);
+        onClose();
+    }
+    catch {
+        setError('The change was not saved. Try again.');
+    }
+    finally {
+        setBusy(false);
+    } }
+    async function report() {
+        const reason = [category, details.trim()].filter(Boolean).join(': ');
+        if (!reason)
+            return;
+        setBusy(true);
+        setError('');
+        if (reportContent.current !== reason) {
+            reportContent.current = reason;
+            reportRequest.current = null;
+        }
+        // Stable across retries, including a response lost after the report was saved.
+        reportRequest.current ??= globalThis.crypto?.randomUUID?.() ?? `report-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+        try {
+            await client.report({ reason, messageId, requestId: reportRequest.current });
+            setMode('sent');
+        }
+        catch {
+            setError('The report could not be confirmed. Try again.');
+        }
+        finally {
+            setBusy(false);
+        }
+    }
+    return _jsx(Modal, { visible: visible, onDismiss: dismissed, transparent: true, animationType: "fade", onRequestClose: () => { if (!busy)
+            onClose(); }, children: _jsx(KeyboardAvoidingView, { behavior: Platform.OS === 'ios' ? 'padding' : undefined, style: { flex: 1, backgroundColor: '#0009', justifyContent: 'center', alignItems: 'center', padding: 24 }, children: _jsxs(ScrollView, { keyboardShouldPersistTaps: "handled", accessibilityViewIsModal: true, style: { width: '100%', maxWidth: 360, flexGrow: 0, flexShrink: 1, maxHeight: '90%', backgroundColor: c.background, borderRadius: 20, borderWidth: 1, borderColor: c.secondary + '40' }, contentContainerStyle: { padding: 20, gap: 8 }, children: [_jsx(Text, { accessibilityRole: "header", style: { fontSize: 20, fontWeight: '600', color: c.foreground }, children: mode === 'menu' ? name : mode === 'block' ? `${blocked ? 'Unblock' : 'Block'} ${name}?` : mode === 'sent' ? 'Report sent' : messageId ? 'Report message' : 'Report conversation' }), mode === 'menu' && _jsxs(_Fragment, { children: [onSearch && button('Search messages', search), safety?.canBlock && button(blocked ? 'Unblock contact' : 'Block contact', () => setMode('block')), safety?.canReport && button('Report', () => setMode('report'))] }), mode === 'block' && _jsx(_Fragment, { children: _jsx(Text, { style: { fontSize: 14, lineHeight: 21, color: c.secondary }, children: blocked ? 'You will be able to message and call each other again. Messages attempted while blocked will not be delivered.' : 'This stops direct messages and calls between you. Your existing chat stays. They will not receive a notification that you blocked them. Shared group messages are not hidden.' }) }), mode === 'report' && _jsxs(_Fragment, { children: [_jsxs(Text, { style: { fontSize: 14, lineHeight: 21, color: c.secondary }, children: [messageId ? 'This message and your reason will be shared with this app’s moderation team.' : 'Up to five recent messages from other people in this conversation and your reason will be shared with this app’s moderation team.', " Report details are kept for up to 30 days. Reporting does not block this contact."] }), ['Spam', 'Harassment', 'Inappropriate content', 'Other'].map(value => _jsxs(Pressable, { accessibilityRole: "radio", accessibilityLabel: value, accessibilityState: { checked: category === value }, disabled: busy, onPress: () => setCategory(value), style: { minHeight: 40, flexDirection: 'row', alignItems: 'center', gap: 10 }, children: [_jsx(View, { style: { width: 18, height: 18, borderRadius: 9, borderWidth: 2, borderColor: c.accent, backgroundColor: category === value ? c.accent : 'transparent' } }), _jsx(Text, { style: { color: c.foreground, fontSize: 15 }, children: value })] }, value)), _jsx(TextInput, { accessibilityLabel: "Report details", placeholder: "Tell us what happened (optional)", placeholderTextColor: c.secondary, value: details, onChangeText: setDetails, multiline: true, maxLength: 1800, editable: !busy, style: { color: c.foreground, minHeight: 80, borderWidth: 1, borderColor: c.secondary + '60', borderRadius: 10, padding: 12, fontSize: 15 } })] }), mode === 'sent' && _jsx(Text, { style: { color: c.secondary, fontSize: 15, lineHeight: 21 }, children: "Your report was saved for review. The other person is not notified." }), !!error && _jsx(Text, { accessibilityRole: "alert", style: { color: c.foreground }, children: error }), _jsxs(View, { style: { flexDirection: 'row', gap: 8, marginTop: 8 }, children: [mode !== 'sent' && button('Cancel', onClose, false, 'cancel'), mode === 'block' && button(blocked ? 'Unblock' : 'Block', () => void block(), false, blocked ? 'primary' : 'danger'), mode === 'report' && button(busy ? 'Sending…' : 'Send report', () => void report(), !category && !details.trim(), 'primary'), mode === 'sent' && button('Done', onClose, false, 'primary')] })] }) }) });
+}

package/dist/saved.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { MessagingAppearance, SavedMessage } from '@robono/messaging';
+/** Same compact popup and media viewer as the conversation; no server-history copy. */
+export declare function SavedMessagesPopup({ records, appearance, onClose, onOpen, onRemove }: {
+    records: SavedMessage[];
+    appearance: MessagingAppearance;
+    onClose: () => void;
+    onOpen: (record: SavedMessage) => Promise<void>;
+    onRemove: (key: string) => Promise<void>;
+}): React.JSX.Element;