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

src/kv-storage/kv-storage-indexeddb.ts

@@ -1,5 +1,5 @@
 import type { AnySpec, Spec } from '../utils/schema.js'
-import { BaseKVStorage, type ScanOptions } from './base-kv-storage.js'
+import { BaseKVStorage, type KVChange, type ScanOptions } from './base-kv-storage.js'
 
 export interface KVStorageIndexedDBOptions {
   /** Database name. */
@@ -56,32 +56,15 @@ export class KVStorageIndexedDB<S extends Spec = AnySpec> extends BaseKVStorage<
     ;(await this.db).close()
   }
 
-  protected async applyWrite(entries: [string, unknown][]): Promise<void> {
+  protected async write(changes: KVChange[]): Promise<void> {
     const store = await this.store('readwrite')
-    for (const [key, value] of entries) store.put(value, key)
+    for (const { key, value } of changes) {
+      if (value === undefined) store.delete(key)
+      else store.put(value, key)
+    }
     await KVStorageIndexedDB.committed(store.transaction)
   }
 
-  protected async applyRemove(keys: string[]): Promise<void> {
-    const store = await this.store('readwrite')
-    for (const key of keys) store.delete(key)
-    await KVStorageIndexedDB.committed(store.transaction)
-  }
-
-  protected async applyWriteIfAbsent(entries: [string, unknown][]): Promise<boolean[]> {
-    // One readwrite transaction: checks and writes can't interleave with other writers.
-    const store = await this.store('readwrite')
-    const written = await Promise.all(
-      entries.map(async ([key, value]) => {
-        if ((await KVStorageIndexedDB.done(store.getKey(key))) !== undefined) return false
-        store.add(value, key)
-        return true
-      }),
-    )
-    await KVStorageIndexedDB.committed(store.transaction)
-    return written
-  }
-
   /** Up to `count` entries after `last` (exclusive), in scan order, within one transaction. */
   private async readBatch(options: ScanOptions, last: string | undefined, count: number): Promise<[string, unknown][]> {
     const reverse = options.reverse ?? false