npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2026 – Pkg Stats / Ryan Hefner

@robono/messaging

v0.19.0

Published

Direct and group messaging state, permissions and transport for Robono.

Readme

Robono messaging

One-to-one and group conversations within your app, using your own accounts and contact permissions. Joining the Robono Bridge is optional. This package manages message state and transport; @robono/messaging-react-native supplies optional, replaceable screens. Existing Bridge messaging remains available through @robono/client. To open an accepted external-app ↔ Robono-user connection in the standard Messenger, use createExpoBridgeMessenger or createWebBridgeMessenger with createBridgeMessengerBackendAdapter; see the BRIDGE-MESSENGER.md guide included with those packages.

Start here

Use the hosted setup guide for websites and React Native apps. Robono hosts messages, files, calling and Maps. Your existing server verifies the user's login and tells Robono who may communicate.

  1. Choose services and appearance in Features & preview.
  2. Run npx --package @robono/server robono-messenger-install inside your app.
  3. Connect your existing login using the generated .robono/SETUP.md, then place CustomerMessenger on your screen. The installer supplies the connection and account cleanup.

For a website, start with @robono/messaging-web; for Expo, start with @robono/messaging-react-native. This core package is for customers building their own interface or extending those screens. Do not put a Robono API key in website or phone code.

Advanced: custom clients and forwarding adapters

The following reference is for customers deliberately building a custom interface or hosting the forwarding adapter. These steps are not required by the recommended hosted setup above.

Configure your app

In the Robono workspace, open Features & preview for your test or live integration. Choose Messaging and its text, voice message, photo, video and file options. Quoting and read receipts are separate options. Voice messages do not grant live-calling permission. Saved settings are enforced by the service, including requests from a custom interface.

Choose Full conversation history or Only the latest two messages. The two-message limit is per conversation, across all participants, not two per person. Use walkie-talkie settings selects voice-only messages, two-message history and no quoting; the options remain individually adjustable. Voice messages default to 60 seconds; choose 15, 30, 60 or a custom whole number from 1 to 3600 seconds.

Saving the two-message limit removes older content from existing conversations as well as new ones. Returning to full history keeps future messages but does not restore removed ones. A shorter voice limit applies to new messages; existing recordings are not cut short.

Appearance controls change the optional screen's colors, logo, display text, avatars and spacing. Customers using their own interface can ignore presentation settings.

Connect your backend

Use RobonoMessagingBackend and createMessagingBackendAdapter from @robono/server. Keep your network API key on the server. Create a key with messaging:read, messaging:write and messaging:manage permissions in Developer tools. The management permission is for your server's relationship and group synchronization and account erasure; the client adapter never exposes these operations.

import {RobonoMessagingBackend, createMessagingBackendAdapter} from '@robono/server';

const robono = new RobonoMessagingBackend({apiKey: process.env.ROBONO_API_KEY!});
export const handleMessaging = createMessagingBackendAdapter({
  robono,
  authenticate: request => sessions.userId(request),
  authorize: ({actorId, operation, input}) =>
    permissions.allowMessaging({userId: actorId, operation, input}),
});

Here sessions and permissions are your app's existing session and authorization services. Mount handleMessaging on your authenticated backend. Authorization must check conversation membership, blocks, app restrictions and ownership of any attached asset. Identity comes from your session, not a user ID sent by a phone. Each app's data is isolated by its network API key.

Synchronize an existing accepted contact relationship on your backend:

const relationship = await robono.setRelationship({
  externalUserIds: [friendship.userA, friendship.userB],
  allowed: friendship.canMessage,
  revision: friendship.revision,
});

Save relationship.conversationId against your contact record. Use a monotonically increasing revision persisted with that relationship. On a block or removal, send allowed: false with a higher revision. Replaying the same revision is safe. Never blindly raise an outdated allow request after a 409 relationship_revision_conflict.

Connect the client

import {MessagingClient, createMessagingTransport} from '@robono/messaging';

const client = new MessagingClient({
  userId: session.userId,
  createMessageId: () => crypto.randomUUID(),
  request: createMessagingTransport({
    url: appConfig.messagingEndpoint,
    getAccessToken: () => sessions.accessToken(),
  }),
});
await client.open(contact.messagingConversationId);
client.start();
await client.send({kind: 'text', text: 'See you soon.'});

Use your platform's secure UUID generator on native platforms (for example Expo Crypto). Subscribe with client.subscribe, read client.getSnapshot, and dispose on logout. Open the next conversation on the same client or create a separate client for each displayed conversation. Stop polling while your app is in the background; refresh and restart on return. Polling backs off on server errors and honors Retry-After. Failed sends remain available for explicit retry with the original message ID. The in-memory outbox does not persist across app termination.

loadOlder() pages backward. Refresh drains new pages without skipping intervening messages and updates loaded messages, including receipts, reactions, votes and erasures. markRead(messageId) records received messages through that visible message; invoke only while the user is viewing them. The optional screen does this for visible messages when the app is active.

Attachments and privacy

Media stays in your app's private store. The optional @robono/messaging-react-native/expo entry supplies recording, playback, pickers, previews and private transfer tools. You can also keep your own media interface. Pick or record the file, verify size/type/duration on your backend, upload privately, and send an opaque asset ID:

await client.send({kind: 'voice', media: {
  assetId: upload.id, mimeType: 'audio/mp4', fileName: 'Voice message.m4a',
  byteSize: upload.sizeBytes, durationMs: upload.durationMs,
}});

Resolve the asset through your authenticated backend after checking the recipient's access. Do not put a public download URL or a storage credential in assetId. Robono stores the reference and message metadata, not the file. Your backend must measure the stored recording and verify durationMs; do not trust duration or ownership claimed by a phone. Robono rejects voice durations above the configured limit with 422 voice_duration_exceeded. Limits: text 10,000 characters; each attachment up to 100 MiB; video up to one hour; voice up to the configured limit (60 seconds by default). Set smaller size limits and allowed formats independently under settings.attachments.image, .video and .document. Each has maxFileBytes and allowedMimeTypes; video also has maxDurationSeconds. The service enforces these settings. Files exclude audio, image and video MIME types, so the file selector cannot bypass those message-kind restrictions. Your backend verifies the actual stored type, size and duration and supplies it through resolveMedia on the server adapter. An attachment may include a caption in text; captions obey the text permission and 10,000-character limit. Automatic translation, transcription and spoken-text generation use the separate language-processing APIs; these message-type controls do not automatically run or bill those operations.

New-message notifications

Robono atomically queues a signed messaging.message_created event when a message is accepted. Configure your integration's webhook URL and verify signatures using verifyRobonoWebhook from @robono/server. The event contains event_id, conversation_id, message_id, sender_external_user_id and recipient_external_user_id; it contains no message text or media URL.

Persist/deduplicate by event_id, acknowledge promptly, and send the recipient's notification using your app's existing push credentials. Recheck your own blocks and account status before notifying. Opening the notification should navigate to the conversation and refresh its messages. Webhook retries recheck Robono's current relationship permission. The developer workspace's event-delivery history shows failed deliveries and retries. Push and app navigation remain under your app's control.

Limited history and media deletion

list and send responses include removedThroughId, a decimal-string sequence watermark. Delete cached content at or below it even after switching back to full history. The headless client applies this automatically and prevents delayed responses from restoring removed messages. Custom clients must do the same, including clearing disk caches when they reconnect. An offline device cannot learn about removals until it reconnects.

For each removed message, Robono queues a signed messaging.message_removed webhook containing conversation_id, message_id, reason: "history_limit" and asset_id (or null for text). This is a backend cleanup event, not an incoming-message notification. Verify the signature and deduplicate its event_id. Revoke access to the asset, remove it from your private store and clear associated cached messages. Make deletion safe to retry and acknowledge only after cleanup has been persisted or durably queued on your backend. Use a distinct asset ID for each attachment message so removing one cannot break another. Cleanup events continue when messaging or a friendship is disabled.

Robono clears expired message bodies and media references, cancels queued new-message notifications for those messages, and retains only identifiers and a content hash needed to make retries safe. A retry for an already removed message returns message: null, replayed: true, expired: true and the removal watermark; it does not recreate content or increase usage. Removal also clears reply references to expired content. Media cleanup follows webhook delivery, and provider backups follow their own retention schedules; this is not a promise that offline copies or backups disappear instantly.

Usage and deletion

Accepted messages generate one server-side usage row. Retries do not increase the count. Test/live counts and message types stay separate, and automatic charging is off. client.reportUsage({platform: 'ios', components: ['screen']}) records the package/components in use, without message content or user IDs. This client-declared inventory is not a billing meter.

Call robono.eraseUser(externalUserId) from your authorized account-deletion backend to erase that user's hosted conversations and cancel their queued notifications. Delete their media from your own storage as well. Aggregate usage records contain no user IDs or message content and remain for reporting. Blocking preserves existing stored conversations. Erasure removes direct conversations for both participants. In groups, it removes membership and replaces the deleted account’s messages with “Message removed”, while preserving everyone else’s messages. Group media produces a cleanup event with reason: "account_deleted".

API

All operations use POST /v1/messaging on Robono's API and a server-side bearer key. operation is settings, relationship, group, group-members, send, list, read, react, vote, close-poll, inventory or erase-user. User operations require actorId plus conversationId; the adapter supplies authenticated identity. list accepts limit (1–100) and either before or after message ID. To refresh already loaded content, pass messageIds (1–100 decimal-string IDs) without a cursor. Reconcile only those requested IDs against the result. IDs are decimal strings, not JavaScript numbers. send requires a stable clientMessageId; changing content under the same ID returns 409 message_id_conflict. Disabled messaging/permissions return 403; unknown or unauthorized conversations return 404. Rate limits use 429 and temporary server failures use 503.

Supergroups

The live service supports opt-in supergroups of up to 2,000 messaging members with messaging 0.3.0 and server 0.16.0 or later. Enable groups.enabled and groups.supergroupsEnabled, then choose groups.maxSupergroupParticipants (2–2,000). Standard groups retain their separate 2–250 limit (default 50). Disabling supergroups blocks access until the network re-enables them. This setting does not start billing.

Send supergroup: true with every setGroup membership snapshot. Revisions and per-member permissions work as they do for standard groups. The conversation response includes supergroup, memberCount and the first 100 memberIds; that sample is not the complete membership list. Use client.groupMembers(nextCursor?) to read successive pages of at most 100 members. Authorize group-members as a read operation in your backend adapter.

Supergroups omit individual read receipts. New-member history, moderation, removal, private media, and message metering retain their existing rules. Voice/video calling is a separate feature and stays capped at eight participants. Messenger supergroups are messaging-only.

Group conversations

Enable Group messaging in Features & preview. Under Customize Selected, set the maximum membership (2–250; default 50) and whether new members see all retained history or only messages sent after they join. Your backend owns membership. Synchronize a complete snapshot whenever membership or permissions change:

const result = await robono.setGroup({
  externalGroupId: group.id,
  name: group.name,
  revision: group.revision,
  allowed: group.messagingAllowed,
  members: group.members.map(member => ({
    userId: member.userId,
    canSend: member.canSend,
    features: member.messagePermissions,
  })),
});

Persist the returned conversationId. The external group ID is unique within your app. Replaying an identical revision is safe; a stale or different snapshot at the same revision returns 409 group_revision_conflict. Use your persisted revision, not a phone's timestamp. Removing someone from the snapshot revokes access. Read-only members can read but cannot send, react or vote. Empty groups can be prepared by your backend; the configured maximum is enforced.

features may restrict text, voice, image, video, document, poll and reactions. A shared group permits a message type only when the app enables it and no member explicitly disables it. Your authorization callback must still enforce your own account restrictions. Existing members keep their history boundary; leaving and rejoining applies the current new-member rule. Group read receipts mean all current recipients entitled to the message have read it.

Open the returned conversation with the same MessagingClient. The response includes its name, member IDs and whether the current actor can send. The optional screen shows the group header and sender names supplied through participants. A group message counts once; each recipient receives a separate signed wake event. These groups are within your app; Bridge direct connections retain their separate API and permissions.

Extra-feature refreshes

The supplied web and phone screens use MessagingExtrasClient.refreshIfDue() for their timer checks. Ordinary chats refresh extra-feature availability and Privacy Lens preferences at most once every 30 seconds. Chats with an address and tracking access keep five-second checks, including before another participant starts sharing. Active tracking and failed reads also retain the five-second interval. These are extra-feature reads, not message delivery or location capture intervals. Opening a chat, changing its message list, returning to the foreground and explicit feature actions refresh immediately. Timer checks do not cancel or duplicate an unfinished read. Every server operation still checks current access; another device's extra-feature preferences can take up to 30 seconds to appear in an idle ordinary chat. Background screens stop timer reads.

Reactions and polls

Enable Reactions and Polls separately in Features & preview. Reactions use the same 62 choices as Robono Messenger, exported as messageReactions and messageReactionOptions. Each person has one reaction per message; choosing a different reaction replaces it. Setting the same reaction again is safe, and null removes it.

await client.react(message.id, '👍');
await client.react(message.id, null);
await client.send({kind: 'poll', poll: {
  question: 'When shall we meet?', options: ['Saturday', 'Sunday'], multiple: false,
}});
await client.vote(pollMessage.id, [1]);
await client.vote(pollMessage.id, []); // Remove this person's vote.
await client.closePoll(pollMessage.id); // Poll creator only.

Polls have 2–12 distinct choices, a question up to 300 characters and choices up to 100 characters. Votes are visible to participants. Send the complete selected option-index list on each change; retries do not toggle votes. Only the creator can close a poll. A closed poll keeps its results and accepts no more votes. Reactions, changed votes and closures have separate aggregate usage counters; repeated identical operations do not increase them. Poll creation counts as one message.

An unanswered call can become a message

In Calling customization, enable Let callers leave a voice message when voice calling and voice messages are both enabled. After no answer, the optional UI offers a new recording for the existing conversation. It never records the call automatically. Cancelled, declined or previously answered calls do not trigger this offer.

Connect onUnansweredCall on the calling controller to your conversation navigation. Pass the call ID to MessagingCallingScreen as unansweredCallId, with onDismissCallMessage to clear the prompt. The authenticated messaging adapter needs resolveUnansweredCall to read the finalized call, verify its mapping to this conversation and supply current calling/message permissions. RobonoCallingBackend.unansweredCall reads the service's trusted call outcome. Do not accept a phone's claimed outcome or permissions. Configure resolveMedia to verify the separately recorded file before sending.

call-message-options and send-call-message are operations on your authenticated adapter, not public network-key API operations. A permitted recording uses the ordinary messaging send path, retry identity, storage, retention and usage count. The optional prompt uses your existing media adapter and its review flow.

Transcripts and translation

Enable Voice message transcripts or Message translation in Features & preview. Pass a transformRequest transport to MessagingClient, pointing at your authenticated endpoint built with createMessagingTransformBackendAdapter from @robono/server. The backend adapter resolves the original message and its private media, checks current access before and after processing, and uses Robono’s existing speech service. The client sends the conversation and message IDs, never an arbitrary audio URL or replacement source text.

The supplied screen stores Off / Text / Voice, the incoming language and the target language once per conversation in its contact-options menu. Translation defaults to Off. A received message in a different known language then offers Translate or Play Translation directly; there is no per-message output/language popup. The translated result replaces the displayed content with a Show original toggle. Only an explicit message action invokes the language service; changing preferences does not process history. Transcription remains a separate voice-message action.

Pass language for the viewer's initial target language and contact.language / participants[id].language for known sender languages. Otherwise the viewer chooses the incoming language once. Matching base languages (for example en-US and en-GB) do not show Translate. This uses language preferences, not automatic language detection. A custom settings screen can call await client.setTranslationPreference({mode:'text', language:'es', sourceLanguage:'en'}). The normal browser/Expo clients persist the choice per endpoint, account and conversation on this device; a custom outbox must implement its optional translationPreference writer to retain it across restarts. A client without persistence keeps the choice only during its lifetime. No cross-device preference synchronization is implied.

These tools do not record or transcribe live calls. A custom interface may still use client.transform(messageId, 'transcript') or client.transform(messageId, 'translation', language, 'text' | 'voice'). These APIs continue to require current message and feature access.

Safety operations

conversation.safety advertises canBlock, blockedByMe and canReport. Use client.setBlocked(true) or client.setBlocked(false) for the current direct contact. This preserves history; conversation.canSend is authoritative. Do not infer who blocked whom from unavailable sending. Blocks do not hide shared group messages.

client.report({reason, messageId?, requestId}) stores a report through the authenticated backend. Reuse a stable requestId after a network error. A selected message must belong to another participant and be visible to the reporter; without an ID, the service captures up to five recent incoming messages. Reporting never implicitly blocks. Reasons accept 1–2000 characters; there is no ten-character minimum.

Keep safety operations available while sending is blocked. The host must authorize conversation membership for every request. Moderator operations belong only on a trusted server; they are not supported by the end-user adapter.

Search, inbox and activity APIs

These APIs use the matching Robono messaging service and your authenticated server route.

  • client.search('blue bicycle', {limit: 20}) searches retained text in the open conversation. Pass nextCursor back as before for more results. Results are newest first and are discarded if navigation or sign-out happens during the request.
  • new MessagingInboxClient({request}) supplies refresh(), loadMore(), start(), stop(), dispose(), subscribe and getSnapshot. Use one instance per signed-in identity. Dispose it at logout; never reuse it for a different person. A refresh replaces the snapshot so revoked chats cannot linger.
  • client.markRead(messageId) records private seen state on upgraded backends, while respecting the public read-receipt setting. Call only for messages actually visible in the foreground.
  • client.setTyping(true) reports typing only when enabled by current settings. setDraft does this automatically. client.setPresenceActive(false) stops foreground activity; UI packages connect this to visibility automatically. Headless hosts must call it when their screen is covered/backgrounded.

Typing refers to the current conversation. The complete Messenger now supplies app-wide foreground activity through MessagingAvailabilityClient; optional Last seen stores only the latest timestamp. Both remain subject to current membership, blocks and device-session ordering. See the activity guide.

Message actions and finding originals

Use client.editMessage(message.id, textOrCaption, message.revision ?? 0) or client.deleteMessage(message.id, message.revision ?? 0). Capture the revision when editing begins. The server permits only the sender, with current conversation access, before another recipient reads, hears or opens the message. Turning read receipts off hides public read indicators; it does not bypass this rule. A stale revision fails rather than overwriting a newer edit. Retrying the original send cannot restore edited/deleted content. This release edits text/captions; replacing the attachment itself is not yet supported.

The ready-made UI includes these controls when messageActionsAvailable is true.

History responses may also include quotedMessages: authorized previews of the direct originals quoted by that page. These do not expand the loaded history or count as opening a media attachment. The server applies the same membership, join-history and retention checks to each original. The shared UI shows a compact sender/thumbnail preview and still navigates to the original when pressed. Upgrade the customer backend adapter first; it announces support automatically. Custom backends should send messageActionsVersion: 1 on authorized list requests only after supporting edit, delete, consume and textOnly read operations. Custom media viewers call consumeMessage(id) after successful opening/playback; markRead deliberately excludes unopened attachments on the updated service.

focusMessage(id) opens at most 30 messages on either side when the original is not loaded. loadOlder() and loadNewer() page that window; goToLatest() restores the latest messages without clearing drafts. Search and quote controls use these methods automatically. Missing/removed originals show an error without clearing the current conversation.

Scheduled messages

When the service advertises scheduledMessagesAvailable, call client.scheduleMessages([{clientMessageId, content}], sendAt) with an ISO UTC time and stable IDs from client.createScheduleId(). Save and reuse those IDs when retrying an uncertain response. A request accepts up to ten messages as one atomic queue operation. It does not put them into the recipient's chat early.

Use scheduledMessages(), rescheduleMessage(item, sendAt) and cancelScheduledMessage(item) for sender-only management. Revisions prevent a stale screen from cancelling or rescheduling an already-sent message. Cancellation and actual sending are serialized: whichever commits first determines the result.

Choose a time 30 seconds to 30 days ahead. Limits: 50 pending messages per sender and 1,000 per app. The worker starts around the selected minute; outages, screening or throttling can delay it. A message more than 15 minutes late fails instead of silently arriving at an inappropriate time. The sender can see that failure. Scheduling creates no delivered-message charge; normal send and storage/screening charges apply when those services are used. Scheduled uploads require Robono managed storage and remain private; stored bytes still count while waiting.

Text, polls and finalized private image/video/document/voice uploads use the same message rules. Custom storage is not accepted for scheduled attachments because Robono cannot guarantee that a customer's private file will remain available. Content rules, access, current key status, screening and budgets are rechecked at send time. Failed content stays privately available for seven days; content-free terminal status/retry records last 30 days. Deleting an account erases its queued messages. Deleting a chat cancels that sender’s pending messages in that chat. Cancelling releases an unused managed upload for cleanup within one day.

Business messages

createMessageCard({title, body, fields, actions}) creates a regular text message with a readable fallback and a supplied card for web and React Native. Custom data formats use MessageContent.custom and a registered renderer. See the business message guide for actions, permissions, screening, limits and lifecycle behavior.

Public communities: discovery, joining and moderator controls.

Change recovery and request volume

Use the supplied MessagingClient.start() / stop() lifecycle instead of adding another timer. The complete web and Expo screens handle visibility themselves. The authenticated wait operation holds a request for up to 20 seconds. A stored cursor recovers missed changes; server notifications only wake the held request. Messages, receipts, deletions, reactions, votes, membership and relationship changes advance it. The next service release also stores block/suspension changes in the cursor, so a missed wake notification cannot hide them.

An unchanged chat normally uses approximately three held wait requests per minute after initial loading. The authorized response includes the recent messages; the client does not fetch that same window again. A changed chat may need additional reads to recover a gap or reconcile loaded older messages, including their removals and reactions. Presence can add three writes per minute. The inbox, while visible, refreshes about every five seconds; deep loaded inboxes may require multiple pages. Sending, typing, recovery and other features add requests. These are client HTTP counts, not internal database query counts or a promise of zero idle traffic.

The client cancels a held request when stopped, switched, or disposed; the transport combines caller cancellation with a 35-second wait deadline (15 seconds for ordinary operations). Native cancellation does not require AbortSignal.throwIfAborted. Late responses from a previous chat/session are ignored. A transient live connection failure retries after 1–1.5 seconds, progressively backing off during repeated failures. Server retry limits take precedence; unsupported live operations keep the slower fallback of at least 30 seconds. Authentication/permission failures clear inaccessible data and stop retries. Reconcile current server state after reconnecting; do not treat a missed notification as proof that nothing changed.

Hosted connection routing

Hosted sessions may include transportEndpoint alongside the existing endpoint. The supplied connection automatically uses the approved direct route; existing sessions and older SDKs keep using the public address. Both routes run the same session, membership, feature and origin checks. No API key enters the client.

Websites with a restrictive Content Security Policy must allow the origin of the returned transportEndpoint in connect-src, alongside their existing Robono and media hosts. If that policy cannot be updated, pass directTransport: false to the hosted Messenger connection to keep using the public address. Do not construct a transport address from user input or change token handling.

Independent attachment text

The standard composer sends accompanying text as its own text message. Each attachment and text item has its own delivery/consumption receipt and quote or forward action. Existing media records with a text caption render as two items. Their textReadAt is separate from the attachment's readAt; absence of a caption receipt does not imply it was read. Receipt privacy still applies.

For an older combined record, replyTo with replyPart: 'text' | 'attachment' selects the quoted item. client.forwardMessage(id, destinationId, retryId, part) forwards only that item after freshly authorizing the source and destination. The UI-only MessagingMessage.part retains the real message ID; it must not be persisted as new message content. Edit, delete, Save and multi-selection of older combined records retain their original whole-message semantics and say “both items.” Deploy the caption-receipt migration and updated messaging gateway before releasing clients that rely on independent receipts for existing combined records.

Chat backup — unreleased

The shared backup screen follows Messenger account settings and supports backup status, account/storage actions, schedules, cellular policy, video inclusion, recovery keys and restore. Pass a MessagingBackupClient as account.backup. Core/native encryption and sample-data round trips are implemented; complete local-history storage, cloud-account integration and background jobs remain required before this is available to customers. See BACKUPS.md.