🔵 Quite sure

🟠 With doubts

⚫ TBD

• Concurrency remains an open problem. Multiple peers may modify the same data concurrently, leading to conflicts that must be resolved deterministically.

• Event linearization vs. decentralization. Today, servers may linearize events to simplify consistency, but this introduces centralization. Can we preserve correctness without relying on a single authority?

• Optimistic concurrency control. Assume operations succeed locally and resolve conflicts later. This requires robust conflict-resolution semantics.

• Time conflicts. Wall-clock time is unreliable across devices. Logical clocks (e.g. vector clocks or Lamport clocks) may be necessary.

• Blob vs. operations. Should we store raw state snapshots, operation logs, or a hybrid?

• CRDTs as a foundation. CRDTs can help resolve conflicts without coordination.

  • Operation-based CRDTs vs. state-based CRDTs remains an open choice.

  • State-based CRDTs require enough metadata/history to converge correctly.

• Deletion semantics. Deletion implies tombstones.

  • How long do we keep them?

  • Can we garbage-collect safely without breaking convergence?

• Per-device vector clocks. Tracking causality per device could enable better merges and conflict resolution.

• Signed operations. Operations can be cryptographically signed and distributed peer-to-peer, removing the need for a central server to establish authorship or validity.

• Subscription model. Should subscriptions be merged or deduplicated across devices and peers?

• Vault-based notifications. One option is storing notification state (or a notification server reference) inside the user’s vault.

• Centralization tradeoff. Email and push notifications likely require some form of central service—this may be unavoidable.

• Invocation-based authentication. Should all actions be authorized via explicit invocations?

• Session keys. Alternatively, short-lived session keys could reduce overhead for frequent operations.

• Hybrid approach? Invocations for delegation, session keys for performance.

• Private documents between peers. How far can we go without servers?

• Zero-knowledge techniques. ZK proofs or encrypted capabilities may allow sharing metadata or permissions without revealing content.

• Selective disclosure. Can peers prove authorization without exposing document contents or full histories?