Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
Live updates in flat Soup lists
Live updates in flat Soup lists
The normalized cache retains at most 64 flat/grouped Soup page snapshots per viewer, with a combined 512 KiB encoded budget. Older pages can require a network refetch when revisited; normalized entities and queued offline edits are not removed. Backfills hydrate entities/indexes without retaining their pagination wrappers. Existing oversized viewer records compact once on a compatible open, without resetting storage generation or pending mutations. To verify, load many pages, revisit an evicted page online, and confirm an offline property edit still replays after reopening the app.
With browser or native Tauri GraphQL caching enabled, locally supported flat lists reconcile their loaded server pages with matching cached entities. Complete matching updates can appear without a list refetch; confirmed non-matches and explicit deletions disappear. Rows whose current predicate facts are unknown retain their previous server membership and sort evidence until hydration or a network refresh resolves them. Unrelated notification-only cache records do not block other rows' updates. While recomputation is pending, the last rendered result for the same query and cache generation stays visible; local results do not trigger the tab-loading bar. A fresh server response still replaces that result, and initial loads without usable data retain normal loading indicators. A transport failure does not hide usable current-query local results, including empty results; HTTP responses and GraphQL errors still surface. To check reconnect behavior, load a non-Mail list online, let background hydration advance its cache while offline, then reconnect without delivering a fresh network response. The newer local result must remain visible; connectivity alone must not restore the older network snapshot. A fresh network response can take authority again.
This is a best-effort display, not proof that every matching entity is cached. Outside the supported cached-Mail slice below, loading more follows the original server cursors and preserves already loaded pages. Newly loaded server rows join the retained display immediately, without duplicates or waiting for local recomputation to succeed. Removing pages from the server baseline invalidates overlays built from those pages. Changing filters or resetting the cache discards prior reconciliation evidence. Unsupported filters/sorts and non-cache transports keep their existing network behavior.
Grouped views
With maintained GraphQL cache queries, supported filters and a created/updated sort, loaded grouped rows also reconcile locally. Initial and per-group continuation pages share one owner; a group's next page loads when the end of that group scrolls into view. Property edits (including multiple assignees), project changes and UTC date rollover can move loaded rows between bins; proven filter nonmatches leave the view. Unknown evidence keeps the previous membership. If local selection is incomplete, normalized display-field updates from initial and continuation pages remain visible without changing counts or server cursors. This is not a complete offline grouping query: uncached/unloaded candidates are not added, and counts preserve unseen server rows rather than counting only the loaded page. Unsupported sorts/filters retain server membership.
To verify, scroll to the end of a property group to load its second page, then
edit a property on a row
from that page. It should appear in its destination once, disappear from its old
group, and reverse on rollback without a grouped-query network round trip. Check
multi-value membership and group counts, then scroll to load another page: the request must
use the server continuation cursor. Switch filters or reset the cache during a
pending local read; its late result must not restore old rows. A server refresh
rebuilds loaded continuation pages while retaining their rows until replacement
pages are ready. Delay or fail a continuation response and confirm the list does
not collapse to its first page; retry and verify fresh rows replace the old ones.
An in-flight continuation page must remain covered by the replacement chain. Refreshes
emit graphql_cache.soup_grouped_refresh; the local phase emits
graphql_cache.soup_grouped_local_evaluation.
For Documents (including Tasks), Projects, Chats, and participating Channels,
exact UNSEEN/SEEN notification filters also reconcile locally with
created/updated timestamp sorts.
Marking a notification done removes only that notification's contribution immediately;
other active notifications can keep the entity in the list. Seen/reopen operations
update filter membership on the authoritative reply, not from a guessed optimistic
state. Rollback restores only the failed operation's contribution. DONE predicates,
other entity partitions, and notified-at sorting still use the network path.
The Mark done action (e, row menu) hides its rows at once from GraphQL lists that
exclude done items, such as Email Important/Noise and Home Signal, without waiting
for the server. Email All keeps the row and flips its done indicator immediately.
GraphQL Undo is offered as soon as Done applies locally, even while its initial
write is pending. Undo restores the row and focus immediately; its server write
waits for the initial outcomes and uses only acknowledged notification IDs.
A late Done reply must not settle or overwrite the newer Undo display intent.
Undo also restores a previously admitted row after the cache has removed it,
without waiting for the reversal's server reply; changing filters/sort clears
those view-local restoration snapshots. Home's separate recent-activity inclusion
rules are unchanged. Test Done/Undo/Redo with delayed replies and verify both flat
and grouped rows/counts. A failure must roll back only its own local intent.
Test mixed committed/queued/rejected archives and notification writes,
including an archive that fails while its notifications succeed (and vice versa). Accepted writes retain Undo; rejected siblings must neither
reappear in its request nor be retried by Redo. Partial feedback keeps an Undo
action. A reply with no matching notification IDs must release that target's
optimistic hide and notification overrides immediately, even if Undo was never
clicked and mounted readers remain stale. Do not wait for acknowledgement or a
timer when there is no receipt. The exception is an entity-wide Done with the
normalized cache: the rows it left out were already done on the server, so they
are written as done into the cache and the hide stays until readers acknowledge
it; that target has nothing to undo. Accepted siblings keep their own display intent;
a no-op target cannot borrow their IDs to restore its row. Mixed accepted/no-op
results replace the optimistic full-count toast with the actual completed count
and retain Undo for accepted writes. An empty notification receipt alone must not
make a successfully archived email or completed reminder look partially failed.
Partial Undo/Redo failures retry only the failed writes.
If every initial write fails, retire its pending Undo/Redo entry and unwind both
Done and any early Undo overrides. Disposal or clearing history while a reversal
is pending must not resurrect that entry when its response arrives. Also delay
Redo, then perform a new action: the late Redo's success or failure must not
repopulate either history stack or show its stale completion toast. The next Undo
must still target the newer action; already-dispatched network writes are not
cancelled by this history fence.
Newer in-scope activity can re-admit a row, but loading an older notification or
activity in a separate channel thread must not. Redo targets the original exact
notification IDs, not notifications received since the original action. A newer
Done must win over an older retained overlay. Delay reconciliation past a minute:
pending/stale state must not simply expire and resurrect the row. Once committed,
mounted cache readers must acknowledge the intent before its overlay is released.
GraphQL display intents are scoped to the authenticated viewer and login session.
Login/logout retires old buckets; even same-account native reauthentication must
not let old overlay Undo/Redo handles or a late refresh republish old intent.
Verify account changes with overlapping entity IDs and a pending/failed refresh.
After a successful Done, verify that the row stays gone after a reload.
Test GraphQL list optimism independently of REST: block REST Soup, email-thread,
and user-notification data endpoints before page initialization, then confirm
GraphQL alone populates the list. Hold GraphQL mutation replies while testing
Done/Undo/Redo and rejection: row feedback must not depend on REST cache reads,
patches, cancellation, or invalidation. Auth/account metadata is outside this
row-data boundary. Test the REST path separately, not as a GraphQL fallback.
Email Reminders contains original email rows: Done archives those conversations,
with the same immediate GraphQL Undo behavior as the other email tabs.
In Tasks, Email, Home and Drive, rows keep their DOM when the list updates. A
property edit or a rename updates the edited row in place instead of rebuilding
every visible row. To verify, watch the row nodes with a MutationObserver while
editing: only moved or removed rows should be added or removed. Rename a row and
then drag it: its drag label/payload must use the new fields without another
registration/layout measurement.
Shared list-filter menus in Home, Tasks, Drive, Email, Reviews, and CRM, plus searchable filter dropdowns, use the multiselect dropdown pattern: checkbox toggles stay open, row activation adds and closes, and Shift/Only replaces the current group's selection without closing. Single-select controls, independent settings, and mobile filter drawers retain their existing behavior.
Channels use the same general Soup reconciliation path, not a separate local page chain. Channel ID, type, team, organization, importance, and participant-scoped filters operate over synchronized channel metadata. The default channel scope requires active participation. Filters that widen to unjoined team channels, message sender/mentions, and channel threads remain network-only. Missing channel metadata or notification snapshots are unknown, not empty. The existing core backfill checkpoint is refreshed to index channel rows; queued work is preserved.
Notification facts use the existing active-only GraphQL edge and primary entity
association. Missing/partial or over-budget snapshots remain incomplete, never an
empty notification set; display metadata decoding omissions remain a best-effort
limitation. The current soup-flat-v5 projection retains notification IDs and
adds complete select-option/entity-reference property snapshots. Tags, task status,
priority and assignee selections compose with owner and type filters. The shared
256-fact per-entity budget still applies: missing, malformed or over-budget property
snapshots are unknown, never evidence of absence. Property-only mutations update
these postings atomically; rollback does not restore unrelated property values.
Checkpoint v14 rehydrates older projections without wiping normalized records or
queued mutations. General Soup still uses its existing server pagination; filter-only
offline checks use an ungrouped view with a created/updated timestamp sort.
The email Focus list is not a Soup list the cache maintains: membership comes from
the worker's classifications, so it reads user.emailFocus again when told to. See
the Focus walkthrough and useEmailFocusQuery. A list like it pushes
over the connection gateway and refreshes through createVisibleRefresh, which
holds a hidden tab to one read when it next shows.
Realtime Soup batches coalesce repeated entity IDs (including entity type), keeping
that entity's last operation in the batch. Emitted SoupUpdated items are non-null.
If viewer-scoped hydration finds no item, the backend logs and omits that update;
it does not imply deletion. Only explicit GraphqlCacheDeletion events remove records.