super-storeA reactive store, quietly backed by a CRDT

Write it like in-memory state. Get real-time collaboration, offline persistence, and undo/redo — opt-in, behind the same API.

Get started

Why super-store

GitHub

counter.ts

import { StoreValue } from "@super-store/store"

// Local — identical to an in-memory store:
const counter = new StoreValue(0)
counter.subscribe(() => render(counter.getSnapshot()))
counter.set(1)  // renders 1

// Collaborative — same handle, opt-in:
counter.onUpdate((u, { local }) => local && bus.send(u))
bus.on("message", (u) => counter.applyUpdate(u))

local→collaborativeno yjs import

One API, two modes

A StoreValue is a plain in-memory value until it isn't. Bind a doc and the same handle becomes a CRDT — reads stay synchronous, writes stay a method call.

Real CRDT merge

Backed by Yjs. Concurrent edits converge — per field, per array slot, per set member — so two people editing the same thing both win.

Collaboration without importing Yjs

encodeState / applyUpdate / onUpdate move CRDT bytes over any transport you own. The wire is a CRDT; your code never sees Y.*.

Tear-free React

useStore and useStoreSelector wrap useSyncExternalStore with a cached, reference-stable snapshot. A remote merge re-renders exactly like a local set.

Undo that respects peers

Opt-in per root. Only your own edits revert; a remote merge is never undone; an undo propagates to peers like any edit.

Diff-and-patch writes

set() never clear-and-rewrites — it diffs and patches inside one transaction, so the document stays small and concurrent edits merge.

Two stores, kept in sync

Each grid below is its own StoreValue, backed by its own document — not shared state. Toggle a cell: your edit travels as CRDT bytes and merges into the other. Edit both at once; concurrent changes to different cells each win.

peer a

peer b

live0 updates relayed·0 bytes