@cero-base/cero 1.6.0 → 1.7.0

package/README.md

@@ -234,6 +234,57 @@ self-heal — a `del` without an explicit `rotate` triggers an automatic re-key
 from any online admin device. Standalone rotations (no removal) are valid too,
 as periodic key hygiene. Full design: [`docs/key-rotation.md`](../../docs/key-rotation.md).
 
+### Watching removals
+
+There is no separate removal event — `members` is a collection, so the normal
+streams already are the membership feed. A removal arrives as an ordinary
+delete (`next: null`), carrying the row that was removed:
+
+```js
+for await (const { changes } of cero.changes(room.members)) {
+  for (const { prev, next } of changes) {
+    if (next === null) console.log('removed:', prev.name)
+  }
+}
+```
+
+To detect **your own** removal — the signal an app renders as "you were removed
+from this room" — listen for the store losing writability:
+
+```js
+room.store.on('unwritable', () => onRemoved()) // freeze the UI, close the room
+```
+
+This works even when the removal is followed by a rotation: the removal lands
+before the new key, so a removed member always receives it. After that their
+streams stay open but go silent — reads freeze at the moment of removal and
+writes reject with `NOT_WRITABLE`.
+
+### Store events
+
+Beyond the ref streams, the store reports its own lifecycle:
+
+```js
+room.store.on('writable', () => {}) // admitted — this device can write
+room.store.on('unwritable', () => {}) // access ended (removed)
+room.store.on('update', () => {}) // an apply batch committed
+room.store.on('behind', (v) => {}) // ops from a newer app version — see below
+room.store.on('rebuild', () => {}) // view replayed after catching up
+```
+
+`before`/`after` hooks only fire on the device performing the write. To observe
+**every** applied op — local _and_ replicated — use `onApply`, which returns an
+unsubscribe fn:
+
+```js
+const off = room.store.onApply(({ op, name, row, writerKey, seq }) => {
+  if (op === 'del' && name === 'member') auditLog(row)
+})
+```
+
+The callback runs synchronously inside apply, so keep it cheap — enqueue and
+return. It costs nothing when nobody is subscribed.
+
 ### `cero.before(ref, fn, opts?)` / `cero.after(ref, fn, opts?)`
 
 Hook into writes to a ref. `before` runs **in-path** before the write commits — return `false` to cancel, or mutate `ctx.row`. `after` is a non-blocking **event** that fires once the write has committed. Both return an unsubscribe fn — call it to stop early, ignore it for a subscription that lives as long as the handle, or pass `{ signal }` to unsubscribe when an `AbortSignal` fires (e.g. `{ signal: me.signal }` to stop on close).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cero-base/cero",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "The ideal p2p API — everything is a handle, handles contain refs, refs contain rows.",
   "type": "module",
   "sideEffects": false,
@@ -95,7 +95,7 @@
     "test:node": "ls test/*.test.js | xargs -P1 -n1 brittle-node"
   },
   "dependencies": {
-    "@cero-base/core": "^1.6.0",
+    "@cero-base/core": "^1.7.0",
     "b4a": "^1.8.1",
     "bare-abort-controller": "^1.1.2",
     "bare-crypto": "^1.15.3",