Plain operations: last write wins, hash-keyed events, simpler composite

- KV: one write primitive, write(changes) with { key, value? }; writeIfAbsent removed.
  The server executes exactly what clients send and never reads values, so they can be
  encrypted end to end. Adds setFields/getFields on the base class.
- HTTP: no server history or event ids; SSE relays every change (own writes included) and
  the client emits resync when a dropped stream reconnects.
- Composite: writes apply locally, then go to the source (undone locally if refused);
  pushed changes are applied and announced only where they differ from local values;
  offline writes go to a queue store (any KV storage); sync() = replay, diff, replay.
  Removes KVReplicaSet, KVOutbox, KeyCounter, SerialQueue and RetryTimer.
- Events: id = <time>_<sha256(time + canonical data)>, so concurrent appends never
  collide and retries can't duplicate; no versions or ConcurrencyError.
- Event-sourced documents: read, resolve, append, apply; catchUp folds in foreign events;
  getAt takes an event id.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017Qxbkp4tA7G5SCWjzWuxmE

bench/event-storage.bench.ts

@@ -4,15 +4,19 @@ import { KVStorageInMemory } from '../src/kv-storage/kv-storage-in-memory.js'
 
 const events = new EventStorageKV(new KVStorageInMemory())
 const streams = events.child('streams')
-for (let i = 0; i < 10_000; i++) await streams.append('long', [{ i }])
+const ids = await streams.append(
+  'long',
+  Array.from({ length: 10_000 }, (_, i) => ({ i })),
+)
+const middle = ids[5000]
 let s = 0
 
 describe('events', () => {
-  bench('append 1 event (warm cache)', async () => {
+  bench('append 1 event', async () => {
     await streams.append(`s${s++ % 1000}`, [{ type: 'e' }])
   })
-  bench('read 100 events from version 5000 of 10k', async () => {
-    for await (const _ of streams.read('long', { from: 5000, limit: 100 })) {
+  bench('read 100 events from the middle of 10k', async () => {
+    for await (const _ of streams.read('long', { after: middle, limit: 100 })) {
     }
   })
   bench('read full 10k-event stream', async () => {

bench/kv-storage.bench.ts

@@ -1,9 +1,10 @@
 import { bench, describe } from 'vitest'
+import type { KVChange } from '../src/kv-storage/base-kv-storage.js'
 import { KVStorageInMemory } from '../src/kv-storage/kv-storage-in-memory.js'
 
 for (const n of [10_000, 100_000]) {
   const db = new KVStorageInMemory()
-  await db.writeMany(Array.from({ length: n }, (_, i) => [`users/u${i}`, { name: `user ${i}`, n: i }]))
+  await db.writeMany(Array.from({ length: n }, (_, i) => ({ key: `users/u${i}`, value: { name: `user ${i}`, n: i } })))
   const users = db.child('users')
   const keys = Array.from({ length: 100 }, (_, i) => `u${(i * 7919) % n}`)
   let i = 0
@@ -21,10 +22,10 @@ for (const n of [10_000, 100_000]) {
 }
 
 const tree = new KVStorageInMemory()
-const writes: [string, number][] = []
+const writes: KVChange[] = []
 for (let c = 0; c < 1000; c++) {
-  writes.push([`n/c${c}`, c])
-  for (let d = 0; d < 100; d++) writes.push([`n/c${c}/d${d}`, d])
+  writes.push({ key: `n/c${c}`, value: c })
+  for (let d = 0; d < 100; d++) writes.push({ key: `n/c${c}/d${d}`, value: d })
 }
 await tree.writeMany(writes)