(def src (atom-source))
(def items (collection src))

(get items {:id 3})           ; fetch by query
(seq items)                   ; list all
(mutate! items nil data)      ; create
(mutate! items {:id 3} data)  ; update
(mutate! items {:id 3} nil)   ; delete

(def src (atom-source))

;; Apply mutations atomically
(transact! src
  [{:op :create :data {:title "Post 1"}}
   {:op :create :data {:title "Post 2"}}])

;; Query the new state
(count (snapshot src))  ;=> 2

(def sources {:posts (atom-source) :users (atom-source)})

(transact! (:users sources) [{:op :create :data {:name "Alice"}}])
(transact! (:posts sources) [{:op :create :data {:title "Hello"}}])

{:users (vals (snapshot (:users sources)))
 :posts (vals (snapshot (:posts sources)))}

CRUD collection abstraction with transactional support.

Provides a generic Collection type that wraps a DataSource backend
and implements ILookup, Seqable, Counted for pattern-based access.

## Basic Usage

```clojure
(def src (atom-source))
(def items (collection src))

(get items {:id 3})           ; fetch by query
(seq items)                   ; list all
(mutate! items nil data)      ; create
(mutate! items {:id 3} data)  ; update
(mutate! items {:id 3} nil)   ; delete
```

## Transactional Mutations

For queries containing mutations, apply all mutations atomically
via `transact!`, then query the new state via `snapshot`:

```clojure
(def src (atom-source))

;; Apply mutations atomically
(transact! src
  [{:op :create :data {:title "Post 1"}}
   {:op :create :data {:title "Post 2"}}])

;; Query the new state
(count (snapshot src))  ;=> 2
```

For multiple collections, call `transact!` on each, then `snapshot`:

```clojure
(def sources {:posts (atom-source) :users (atom-source)})

(transact! (:users sources) [{:op :create :data {:name "Alice"}}])
(transact! (:posts sources) [{:op :create :data {:title "Hello"}}])

{:users (vals (snapshot (:users sources)))
 :posts (vals (snapshot (:posts sources)))}
```