persist: Phase 1 — log + kv facets on injectable in-memory backend + 28 tests

event/backend/log/kv/api over one injected backend protocol (mem default).
log: append/read/read-from, sequential per-stream seq, stream isolation.
kv: get/put/delete/has?/keys/get-or/update. conformance.sh + 3 suites, 28/28.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

lib/persist/tests/event.sx

@@ -0,0 +1,30 @@
+; Phase 1 — event record accessors. Uses the persist-test harness
+; (persist-test name got expected) provided by conformance.sh.
+
+(persist-test
+  "event-stream"
+  (persist/event-stream
+    (persist/event "s" 1 "t" 0 {}))
+  "s")
+(persist-test
+  "event-seq"
+  (persist/event-seq (persist/event "s" 3 "t" 0 {}))
+  3)
+(persist-test
+  "event-type"
+  (persist/event-type
+    (persist/event "s" 1 "create" 0 {}))
+  "create")
+(persist-test
+  "event-at"
+  (persist/event-at (persist/event "s" 1 "t" 42 {}))
+  42)
+(persist-test
+  "event-data"
+  (persist/event-data
+    (persist/event "s" 1 "t" 0 {:x 9}))
+  {:x 9})
+(persist-test
+  "event is a dict with all fields"
+  (len (keys (persist/event "s" 1 "t" 0 {})))
+  5)

lib/persist/tests/kv.sx

@@ -0,0 +1,86 @@
+; Phase 1 — kv facet: get/put/delete/has?/keys, get-or, update.
+
+(persist-test "absent key reads nil" (persist/kv-get (persist/open) "x") nil)
+(persist-test
+  "has? false when absent"
+  (persist/kv-has? (persist/open) "x")
+  false)
+(persist-test
+  "put then get"
+  (let
+    ((b (persist/open)))
+    (begin (persist/kv-put b "x" 7) (persist/kv-get b "x")))
+  7)
+(persist-test
+  "put returns value"
+  (let ((b (persist/open))) (persist/kv-put b "x" 9))
+  9)
+(persist-test
+  "has? true after put"
+  (let
+    ((b (persist/open)))
+    (begin (persist/kv-put b "x" 1) (persist/kv-has? b "x")))
+  true)
+(persist-test
+  "put overwrites"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/kv-put b "x" 1)
+      (persist/kv-put b "x" 2)
+      (persist/kv-get b "x")))
+  2)
+(persist-test
+  "delete removes key"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/kv-put b "x" 1)
+      (persist/kv-delete b "x")
+      (persist/kv-has? b "x")))
+  false)
+(persist-test
+  "delete then get is nil"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/kv-put b "x" 1)
+      (persist/kv-delete b "x")
+      (persist/kv-get b "x")))
+  nil)
+(persist-test
+  "keys lists stored keys"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/kv-put b "a" 1)
+      (persist/kv-put b "b" 2)
+      (len (persist/kv-keys b))))
+  2)
+(persist-test
+  "get-or returns default when absent"
+  (persist/kv-get-or (persist/open) "x" 99)
+  99)
+(persist-test
+  "get-or returns value when present"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/kv-put b "x" 5)
+      (persist/kv-get-or b "x" 99)))
+  5)
+(persist-test
+  "kv-update applies fn over default"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/kv-update b "n" 0 (fn (v) (+ v 1)))
+      (persist/kv-update b "n" 0 (fn (v) (+ v 1)))
+      (persist/kv-get b "n")))
+  2)
+(persist-test
+  "kv facet does not touch log"
+  (let
+    ((b (persist/open)))
+    (begin (persist/kv-put b "x" 1) (persist/count b "x")))
+  0)

lib/persist/tests/log.sx

@@ -0,0 +1,81 @@
+; Phase 1 — log facet: append/read/read-from, sequential seq, stream isolation.
+; Note: map returns an array-backed list not equal? to a (list ...) literal,
+; so assertions build their compared list with list/nth, not map.
+
+(persist-test
+  "empty stream reads empty"
+  (len (persist/read (persist/open) "orders"))
+  0)
+(persist-test
+  "last-seq empty is 0"
+  (persist/last-seq (persist/open) "orders")
+  0)
+(persist-test
+  "append returns event with seq 1"
+  (persist/event-seq
+    (persist/append (persist/open) "orders" "placed" 0 {:id 1}))
+  1)
+(persist-test
+  "append assigns sequential seqs"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/append b "orders" "placed" 0 {})
+      (persist/append b "orders" "placed" 1 {})
+      (persist/event-seq
+        (persist/append b "orders" "placed" 2 {}))))
+  3)
+(persist-test
+  "read returns events oldest-first"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/append b "s" "a" 0 {:n 1})
+      (persist/append b "s" "b" 0 {:n 2})
+      (let
+        ((es (persist/read b "s")))
+        (list
+          (get (persist/event-data (nth es 0)) :n)
+          (get (persist/event-data (nth es 1)) :n)))))
+  (list 1 2))
+(persist-test
+  "count tracks appends"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/append b "s" "a" 0 {})
+      (persist/append b "s" "a" 0 {})
+      (persist/count b "s")))
+  2)
+(persist-test
+  "streams are isolated"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/append b "s1" "a" 0 {})
+      (persist/append b "s2" "a" 0 {})
+      (persist/append b "s2" "a" 0 {})
+      (list (persist/count b "s1") (persist/count b "s2"))))
+  (list 1 2))
+(persist-test
+  "read-from filters by seq"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/append b "s" "a" 0 {})
+      (persist/append b "s" "a" 0 {})
+      (persist/append b "s" "a" 0 {})
+      (let
+        ((es (persist/read-from b "s" 2)))
+        (list
+          (persist/event-seq (nth es 0))
+          (persist/event-seq (nth es 1))))))
+  (list 2 3))
+(persist-test
+  "read-from past end is empty"
+  (let
+    ((b (persist/open)))
+    (begin
+      (persist/append b "s" "a" 0 {})
+      (len (persist/read-from b "s" 5))))
+  0)