Cross-Device Message-Hide Synchronization Automation: Deleted on the Phone, Still There on the Desktop

Someone who hides a message on one device and still sees it on another has exactly one observation available to them: it didn't work everywhere. Whether the underlying cause is a genuine synchronization bug (two devices tried to agree and failed) or the complete absence of any attempt to synchronize at all (two devices were never designed to know about each other) is invisible from that single observation — both produce the identical symptom, and only looking at the actual architecture reveals which one it actually is.

The starting state is stated plainly in the change's own documentation: hiding a message "for me" lived entirely inside `localStorage`, keyed by that specific browser or app instance, and the mobile app runs as its own separate shell with its OWN independent storage, completely disconnected from the desktop browser's. Before this fix, "I hid it on my phone and it's still showing on my computer" was never a bug in a synchronization mechanism — there had never been one to begin with.

The fix introduces a dedicated database table with one row per person and message, protected so each person can only ever see and create their own hidden-message records — never anyone else's, and there is deliberately no way to un-hide a message once hidden, matching how the feature already worked in the product. The device's own local storage is deliberately kept in the design, but its role changes: it becomes a fast, synchronous CACHE that lets the chat screen filter out a hidden message instantly, without waiting on a network round trip, while the database row is the one shared, cross-device source of truth. The moment a message is hidden, that same device also writes the corresponding row to the database in the background; every OTHER device signed in as that same person receives that write live, through a real-time subscription, and immediately applies the same filter to its own screen — turning what used to be device-local behavior into something that genuinely follows the person, not the device.

The design explicitly plans for the network or database being briefly unavailable: hiding a message always updates the local cache first, so the screen responds instantly and correctly regardless of connectivity, and the corresponding database write is attempted as a best-effort background operation that quietly retries on the next natural sync point rather than failing loudly or blocking the interaction. A companion reconciliation routine merges both directions on each app open — hidden-message records that exist in the database but not yet in this device's local cache (meaning they were hidden somewhere else) get pulled in, and any that exist locally but not yet in the database (hidden while offline, or from before this feature existed) get pushed up — so a device that was closed when a hide happened elsewhere still catches up correctly the next time it's opened.

A same-day regression in the very same file is worth including honestly rather than treated as a separate footnote: the first version of the new live-subscription function referenced the shared database client directly at the top of the file, when every OTHER function in that same file deliberately defers that reference behind a small, documented lazy-loading wrapper — specifically so the file's own pure, easily-testable functions don't have to load the mobile-app framework and real-time connection machinery just to run a unit test. That direct reference would have thrown immediately the first time the function actually ran, crashing the chat screen with an unhandled error rather than degrading gracefully. It was caught and fixed the same day, restoring the same lazy-loading pattern already used consistently everywhere else in the file.

Someone hides a message on their phone while on a subway with no signal. The message disappears from their screen instantly, from the local cache alone. Once the phone reconnects, the hide is written to the database in the background — and the next time that same person opens the chat on their desktop, the message is already gone there too, without them having to do anything on that second device.

Hiding a message inside Centriu Axis now genuinely follows the person across every device they use, rather than the specific browser or app instance they happened to be using at the time — closing a gap that was never a synchronization bug to begin with, but the deliberate absence of any synchronization mechanism until this change.

This feature is specifically "hide for me" — a private, per-person preference. It does not change "delete for everyone," which was already synchronized across the conversation for every participant before this fix, through a different, already-working mechanism.

Storing a personal preference only in a single device's own local storage is simple and fast, right up until someone reasonably expects it to follow them to their next device — an expectation the product's own multi-device support already sets. Centriu Axis's fix keeps the local speed (an instant, synchronous cache) while adding the one thing that was missing: a shared, per-person database record that every device the same person uses can read from and write to.