refactor!: async-only consolidation (one async bus + drop the sync repository API)

[patrickleet]

Makes the crate async-only and consistent: one async bus facade and one async repository surface, with HashMap/SQLite/Postgres all behaving the same. Removes the sync/async mix that was the source of subtle combination bugs. Stacked on the matrix branch (#48).

Net 135 files, +3,935 / −7,092 (−3,157 lines). All green: cargo test 490 passed / 0 failed; --features http,grpc / postgres / sqlite build; clippy --all-targets clean.

Phase 1 — remove the legacy sync bus

• Migrated every consumer first, then deleted src/bus/ (~1.4k lines), OutboxWorkerThread, the bus-gated service.rs surface (dispatch_event/listen/subscribe/TransportHandle + the Event↔Message bridges), and the bus Cargo feature. http/grpc no longer depend on it (they use the unconditional microsvc::Message).
• Migrated transport_subscribe/transport_listen/microsvc_saga/the board onto the async InMemoryBus; removed the superseded raw-bus::Bus saga test (coverage preserved by the async tests); decoupled both projection handlers (incl. the gold-standard matrix) from bus::Event.

Phase 2 — async ergonomic builders

• ReadModelWorkspace: added load_async/commit_async + AsyncReadModelWorkspaceExt::workspace_async() (the load→mutate→sync→commit ergonomic, previously sync-only) with no duplicated diff logic.
• QueuedRepository: a runtime-agnostic, waker-based async lock (AsyncLock/AsyncLockManager, no tokio dep) + the full async repo surface, so .queued_async().async_aggregate::<T>() serializes per-aggregate get/commit over the async path (which previously bypassed locking entirely). An adversarial review caught + fixed two latent unlock defects (poison-on-panic and reentrant-wake deadlock from waking under the guard); regression tests added.

Phase 3 — async handler model + drop the sync repo API

• Async handlers: HandlerFn is now a boxed Send future with an AsyncHandler HRTB helper trait, so async fn handle(ctx: &Context<'_, D>) registers directly; dispatch/invoke and dependencies.rs are async; guards stay sync. (Required because dropping the sync repo traits meant handlers could no longer call sync ctx.repo().get/commit.)
• All 21 integration test crates migrated to the async handler + async repo API (handlers, services via .queued_async().async_aggregate(), and test bodies).
• Deleted the entire sync repository surface: Get/Commit/Repository/GetOne/GetMany/TransactionalCommit, sync SnapshotStore/ReadModelWritePlanStore/RelationalReadModelQueryStore, sync AggregateRepository/QueuedRepository/CommitBuilder/OutboxCommit, and the now-unused sync lock module — across HashMap/SQLite/Postgres/in-memory backends.

Breaking changes

• Handlers are now async fn; Service::dispatch/dispatch_message are async.
• The synchronous repository/read-model/snapshot/lock APIs are removed; use the Async* equivalents and .queued_async()/.async_aggregate().

Tracked by tasks/async-only-consolidation.

🤖 Generated with Claude Code

Summary by CodeRabbit

Release Notes

• Breaking Changes

  • All repository operations now require async/await syntax; synchronous APIs removed.
  • Lock management is now async-only; blocking APIs eliminated.
  • Service handlers and microservice dispatch must now be async functions.
  • Read-model queries and commits now require async/await.
  • Aggregate commits and snapshots now require async/await.

• Removals

  • bus module no longer enabled by default in Cargo features.
  • All synchronous repository, lock, and commit builder APIs removed.

[coderabbitai]

Important

Review skipped

Auto reviews are disabled on base/target branches other than the default branch.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro Plus

Run ID: b82e14c2-30e8-4fd1-ad53-0031c60d6d5c

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

📝 Walkthrough

Walkthrough

Converts the crate to async-first: adds async locks/managers, async repository traits/implementations, async read-model and snapshot APIs, async outbox commit; removes synchronous layers and the entire bus module. Microsvc handlers become async, transports await dispatch. Tests are migrated to async patterns.

Changes

Async Platform Migration

Layer / File(s)	Summary
Async locks and queueing src/lock/*, src/queued_repo/*	Introduces AsyncLock/AsyncLockManager and async-queued repository with per-stream serialization and opt-in no-lock reads.
Repository and commit builder src/hashmap_repo/repository.rs, src/commit_builder/mod.rs, src/repository/*, src/aggregate/*, src/lib.rs	Replaces sync traits with async get/commit, narrows aggregate re-exports to async, updates crate root to async surfaces.
Read-model async API src/read_model/*	Moves store/session to async commit/load graph; updates examples and exports to async builders and workspace.
Snapshots async API src/snapshot/*	Replaces sync snapshot repository/store with async variants and re-exports.
Outbox async commit src/outbox/*, src/outbox_worker/*	Removes sync outbox helpers and threaded worker; adds async outbox commit borrowing repo.
Microsvc and transports src/microsvc/*	Handlers become async; dispatch awaits; removes bus-specific APIs.
Bus removal and features src/bus/*, Cargo.toml	Deletes entire bus module and related features from defaults.
Tests migration tests/**/*	Converts tests to Tokio async, updates repos to queued_async/async_aggregate, and adapts transports to new async bus helpers.

Sequence Diagram(s)

sequenceDiagram
  participant Client
  participant Service
  participant AsyncRepo
  participant ReadModelStore
  Client->>Service: Command
  Service->>AsyncRepo: commit(...)
  AsyncRepo->>AsyncRepo: lock streams
  AsyncRepo->>ReadModelStore: commit_write_plan_async
  AsyncRepo-->>Service: Result
  Service-->>Client: Response

Loading

Estimated code review effort

🎯 5 (Critical) | ⏱️ ~120 minutes

Possibly related PRs

• patrickleet/sourced_rust#44 — Prior shift to relational read-model write plans aligns with this PR’s async read-model commit/load changes.
• patrickleet/sourced_rust#40 — Touches outbox worker internals that this PR removes in favor of async flow.
• patrickleet/sourced_rust#41 — Overlaps snapshot subsystem updated here to async snapshot repository/store.

Poem

A rabbit taps the future’s drum,
Async streams begin to hum.
Locks awake, the bus is gone—
Snapshots shimmer, tests run on.
Commits await, projections sing—
With gentle paws, we modernize spring. 🐇✨

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch feat/async-only-consolidation

[patrickleet]

@coderabbitai review

[coderabbitai]

✅ Actions performed

Review triggered.

Note: CodeRabbit is an incremental review system and does not re-review already reviewed commits. This command is applicable only when automatic reviews are paused.

[coderabbitai]

Actionable comments posted: 3

🧹 Nitpick comments (6)

src/lock/mod.rs (1)

27-34: ⚡ Quick win

Update module docs to match the async-only API surface.

The exported surface is async-only now, but the module-level architecture docs still describe sync Lock/LockManager/InMemoryLock, which is confusing for users.

📘 Proposed doc update

-//! │              LockManager (per repository)                    │
-//! │  - get_lock(id) → Arc<Lock>                                 │
+//! │           AsyncLockManager (per repository)                  │
+//! │  - get_lock(id) → Arc<AsyncLock>                             │
 ...
-//! │                     Lock Trait                               │
+//! │                   AsyncLock Trait                            │
 //! │  lock() / try_lock() / unlock()                              │
 ...
-//! │InMemoryLock │    │ RedisLock   │    │ PostgresAdvisory    │
+//! │InMemoryAsync│    │ RedisLock   │    │ PostgresAdvisory    │
+//! │Lock (included)│  │ (external)  │    │    (external)       │
-//! │ (included)  │    │ (external)  │    │    (external)       │

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/lock/mod.rs` around lines 27 - 34, Update the module-level documentation
in src/lock/mod.rs to reflect the async-only API: remove or replace any
references to sync types "Lock", "LockManager", and "InMemoryLock" with the
async equivalents "AsyncLock", "AsyncLockManager", and "InMemoryAsyncLock" and
adjust prose to describe async behavior (futures, non-blocking semantics, and
the InMemoryAsyncLock/ InMemoryAsyncLockManager testing use-case); also ensure
exported symbols listed (AsyncLock, AsyncLockManager, InMemoryAsyncLock,
InMemoryAsyncLockFuture, InMemoryAsyncLockManager) are accurately described in
the docs so consumers aren’t misled by legacy sync terminology.

src/commit_builder/mod.rs (1)

325-342: 💤 Low value

Busy-poll block_on works only for immediately-ready futures.

This no-op waker implementation spins until Poll::Ready. It's safe here because HashMapRepository and InMemoryReadModelStore complete synchronously, but would deadlock on any future that genuinely yields.

Consider adding a brief doc comment noting the limitation, or use futures::executor::block_on which handles real yields.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/commit_builder/mod.rs` around lines 325 - 342, The custom busy-polling
function block_on spins with a no-op waker and only works for futures that are
immediately Ready; replace its use or document its limitation: either switch to
a proper executor (e.g., use futures::executor::block_on) wherever block_on is
used, or add a clear doc comment on the block_on function explaining that it
only supports synchronously-completing futures and will deadlock on yielding
futures (mention HashMapRepository and InMemoryReadModelStore as currently safe
examples). Ensure calls to block_on are updated to use the executor if you
choose replacement.

src/queued_repo/repository.rs (1)

177-187: ⚡ Quick win

Deduplicate committed stream locks before releasing.

commit_batch_async currently resolves/unlocks per batch.streams entry; duplicate stream identities can cause repeated unlock attempts for the same lock.

♻️ Proposed hardening

-            let mut locks = Vec::with_capacity(batch.streams.len());
-            for stream in &batch.streams {
-                locks.push(self.ensure_async_lock(&stream.identity.storage_key())?);
-            }
+            let mut lock_ids: Vec<String> = batch
+                .streams
+                .iter()
+                .map(|s| s.identity.storage_key())
+                .collect();
+            lock_ids.sort_unstable();
+            lock_ids.dedup();
+
+            let mut locks = Vec::with_capacity(lock_ids.len());
+            for id in &lock_ids {
+                locks.push(self.ensure_async_lock(id)?);
+            }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/queued_repo/repository.rs` around lines 177 - 187, The unlock loop in
commit_batch_async can call unlock multiple times for the same stream when
batch.streams contains duplicates; change the collection of locks from a plain
Vec to a keyed collection (e.g., HashMap or deduplicated Vec) keyed by
stream.identity.storage_key() when calling ensure_async_lock so you only store
one lock per unique storage_key, then iterate that deduplicated set to call
unlock() once per key; update references in this block (ensure_async_lock,
locks, batch.streams, and the unlock loop) accordingly to prevent duplicate
unlock attempts.

src/read_model/in_memory.rs (1)

573-590: 💤 Low value

Test block_on helper will spin indefinitely if the future yields Pending.

This no-op waker block_on spins in a busy loop. It works for the current in-memory store futures (which never actually suspend), but if future refactoring introduces a real .await that returns Pending, this loop will spin forever. Consider adding a panic or a bounded iteration count as a safety net.

💡 Suggested defensive guard

     let mut future = std::pin::pin!(future);
+    let mut iterations = 0;
     loop {
         if let Poll::Ready(output) = future.as_mut().poll(&mut cx) {
             return output;
         }
+        iterations += 1;
+        if iterations > 1000 {
+            panic!("block_on: future did not resolve after 1000 polls");
+        }
     }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/read_model/in_memory.rs` around lines 573 - 590, The block_on helper
(function block_on) uses a no-op waker and busy-loops, which will spin forever
if the polled future ever returns Pending; change it to include a defensive
safety net such as tracking loop iterations or elapsed time and panic (or return
an error) after a reasonable bound, or yield to the OS with a short sleep per
iteration to avoid busy spinning; update the block_on implementation to detect
when a future hasn’t completed after the bound and abort with a clear message
including "block_on: future did not complete" so callers of block_on/block_on in
this module can surface the failure safely.

tests/read_model_relationship_includes/main.rs (1)

11-28: 💤 Low value

Third occurrence of the same block_on helper.

This is duplicated across three test files (src/read_model/in_memory.rs, src/snapshot/in_memory.rs, and here). Consider extracting to a shared test utility module to reduce duplication.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/read_model_relationship_includes/main.rs` around lines 11 - 28, The
helper fn block_on is duplicated across tests; extract it to a shared test
utility module (e.g., tests/common.rs or tests/util/mod.rs) as a pub fn
block_on<F: Future>(...) and remove the local duplicates in
read_model_relationship_includes, snapshot/in_memory.rs and
read_model/in_memory.rs; update those test files to import the shared function
(use crate::common::block_on or appropriate path) and ensure the signature and
visibility match so callers compile without changing behavior.

src/snapshot/in_memory.rs (1)

85-102: 💤 Low value

Same block_on spinning concern as in in_memory.rs.

This is the same no-op waker spinning pattern. Consider extracting a shared test utility or adding the same defensive guard.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/snapshot/in_memory.rs` around lines 85 - 102, The block_on function in
snapshot::in_memory.rs uses a no-op RawWaker that spins indefinitely; replace it
with the shared test utility or the same defensive pattern used elsewhere:
extract this into a common test helper (e.g., a shared block_on_noop_waker) or
modify block_on to track poll iterations and call thread::yield_now periodically
and panic after a reasonable max-iterations with a clear error message; update
references to use the shared helper and keep the RawWaker creation logic
centralized so both in_memory implementations share the same safe, non-spinning
behavior.

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/outbox/commit.rs`:
- Around line 49-66: The custom block_on function creates a no-op RawWaker and
busy-polls, which can hang on Pending futures; remove this function and replace
uses of block_on with a proper executor (e.g., call
tokio::runtime::Runtime::new().unwrap().block_on(...) in tests or use
futures::executor::block_on(...)) so futures can be scheduled and woken
correctly; delete the unsafe RawWaker implementation in block_on and update any
calls that referenced block_on to use the chosen executor API (or convert tests
to #[tokio::test]/async tests) so waking and Pending are handled properly.

In `@tests/distributed_read_model_board/projections_service/handlers/board.rs`:
- Around line 32-33: The handler currently panics on malformed transport IDs
because event_version(message_id) and later code use expect(...) instead of
returning errors; update the code so message_id parsing returns a Result and
propagate parsing failures as a HandlerError instead of panicking. Concretely,
change usage of event_version(message_id) to handle its Result (or update
event_version to return Result<u64, ParseError>), replace any expect(...) calls
around Transport/MessageId parsing with map_err or match that converts the parse
error into a HandlerError (e.g., HandlerError::MalformedMessageId or a
descriptive variant), and ensure updated_board_view(&snapshot, version) is only
called after successful parsing so the handler returns Err(HandlerError) on
malformed IDs rather than panicking.

In `@tests/todos/main.rs`:
- Around line 146-154: The test is ignoring commit results and allowing an empty
path to pass; change the calls to repo.commit_all(&mut [&mut todo2, &mut
todo3]).await so failures are not ignored (unwrap or assert the Result is Ok)
and update the subsequent check of all_todos from repo.peek_all(&[&id1, &id2,
&id3]).await.unwrap() to fail fast (remove the if/else) by asserting the result
is not empty and that all_todos.len() == 3 (e.g. assert!(!all_todos.is_empty());
assert_eq!(all_todos.len(), 3)); apply the same pattern for the other
occurrences mentioned (the commit_all calls at the other locations and any
conditional empty-path checks).

---

Nitpick comments:
In `@src/commit_builder/mod.rs`:
- Around line 325-342: The custom busy-polling function block_on spins with a
no-op waker and only works for futures that are immediately Ready; replace its
use or document its limitation: either switch to a proper executor (e.g., use
futures::executor::block_on) wherever block_on is used, or add a clear doc
comment on the block_on function explaining that it only supports
synchronously-completing futures and will deadlock on yielding futures (mention
HashMapRepository and InMemoryReadModelStore as currently safe examples). Ensure
calls to block_on are updated to use the executor if you choose replacement.

In `@src/lock/mod.rs`:
- Around line 27-34: Update the module-level documentation in src/lock/mod.rs to
reflect the async-only API: remove or replace any references to sync types
"Lock", "LockManager", and "InMemoryLock" with the async equivalents
"AsyncLock", "AsyncLockManager", and "InMemoryAsyncLock" and adjust prose to
describe async behavior (futures, non-blocking semantics, and the
InMemoryAsyncLock/ InMemoryAsyncLockManager testing use-case); also ensure
exported symbols listed (AsyncLock, AsyncLockManager, InMemoryAsyncLock,
InMemoryAsyncLockFuture, InMemoryAsyncLockManager) are accurately described in
the docs so consumers aren’t misled by legacy sync terminology.

In `@src/queued_repo/repository.rs`:
- Around line 177-187: The unlock loop in commit_batch_async can call unlock
multiple times for the same stream when batch.streams contains duplicates;
change the collection of locks from a plain Vec to a keyed collection (e.g.,
HashMap or deduplicated Vec) keyed by stream.identity.storage_key() when calling
ensure_async_lock so you only store one lock per unique storage_key, then
iterate that deduplicated set to call unlock() once per key; update references
in this block (ensure_async_lock, locks, batch.streams, and the unlock loop)
accordingly to prevent duplicate unlock attempts.

In `@src/read_model/in_memory.rs`:
- Around line 573-590: The block_on helper (function block_on) uses a no-op
waker and busy-loops, which will spin forever if the polled future ever returns
Pending; change it to include a defensive safety net such as tracking loop
iterations or elapsed time and panic (or return an error) after a reasonable
bound, or yield to the OS with a short sleep per iteration to avoid busy
spinning; update the block_on implementation to detect when a future hasn’t
completed after the bound and abort with a clear message including "block_on:
future did not complete" so callers of block_on/block_on in this module can
surface the failure safely.

In `@src/snapshot/in_memory.rs`:
- Around line 85-102: The block_on function in snapshot::in_memory.rs uses a
no-op RawWaker that spins indefinitely; replace it with the shared test utility
or the same defensive pattern used elsewhere: extract this into a common test
helper (e.g., a shared block_on_noop_waker) or modify block_on to track poll
iterations and call thread::yield_now periodically and panic after a reasonable
max-iterations with a clear error message; update references to use the shared
helper and keep the RawWaker creation logic centralized so both in_memory
implementations share the same safe, non-spinning behavior.

In `@tests/read_model_relationship_includes/main.rs`:
- Around line 11-28: The helper fn block_on is duplicated across tests; extract
it to a shared test utility module (e.g., tests/common.rs or tests/util/mod.rs)
as a pub fn block_on<F: Future>(...) and remove the local duplicates in
read_model_relationship_includes, snapshot/in_memory.rs and
read_model/in_memory.rs; update those test files to import the shared function
(use crate::common::block_on or appropriate path) and ensure the signature and
visibility match so callers compile without changing behavior.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro Plus

Run ID: 61233f48-07b5-4c61-8d96-82a012393114

📥 Commits

Reviewing files that changed from the base of the PR and between 2010205 and 8a7d690.

📒 Files selected for processing (135)

• Cargo.toml
• src/aggregate/aggregate.rs
• src/aggregate/async_aggregate.rs
• src/aggregate/mod.rs
• src/bus/bus.rs
• src/bus/event_bus.rs
• src/bus/in_memory_queue.rs
• src/bus/listener.rs
• src/bus/mod.rs
• src/bus/publisher.rs
• src/bus/sender.rs
• src/bus/subscriber.rs
• src/commit_builder/mod.rs
• src/hashmap_repo/repository.rs
• src/lib.rs
• src/lock/async_in_memory.rs
• src/lock/async_lock.rs
• src/lock/async_lock_manager.rs
• src/lock/in_memory.rs
• src/lock/lock.rs
• src/lock/lock_manager.rs
• src/lock/mod.rs
• src/microsvc/dependencies.rs
• src/microsvc/grpc.rs
• src/microsvc/http.rs
• src/microsvc/mod.rs
• src/microsvc/service.rs
• src/microsvc/transport/in_memory_bus.rs
• src/microsvc/transport/knative.rs
• src/microsvc/transport/outbox_dispatch.rs
• src/microsvc/transport/outbox_source.rs
• src/microsvc/transport/runner.rs
• src/outbox/commit.rs
• src/outbox/mod.rs
• src/outbox_worker/mod.rs
• src/outbox_worker/store.rs
• src/outbox_worker/thread.rs
• src/queued_repo/mod.rs
• src/queued_repo/repository.rs
• src/read_model/in_memory.rs
• src/read_model/mod.rs
• src/read_model/session.rs
• src/repository/batch.rs
• src/repository/gettable.rs
• src/repository/mod.rs
• src/repository/repository.rs
• src/snapshot/in_memory.rs
• src/snapshot/mod.rs
• src/snapshot/repository.rs
• src/snapshot/store.rs
• tests/blob_game/main.rs
• tests/bomberman/handlers/create_game.rs
• tests/bomberman/handlers/get_player.rs
• tests/bomberman/handlers/join_game.rs
• tests/bomberman/handlers/mod.rs
• tests/bomberman/handlers/move_player.rs
• tests/bomberman/handlers/place_bomb.rs
• tests/bomberman/handlers/shared.rs
• tests/bomberman/handlers/tick.rs
• tests/bomberman/main.rs
• tests/bomberman/sim.rs
• tests/distributed_read_model/checkout_saga_service/handlers/record_seat_reserved.rs
• tests/distributed_read_model/checkout_saga_service/handlers/start.rs
• tests/distributed_read_model/checkout_saga_service/mod.rs
• tests/distributed_read_model/main.rs
• tests/distributed_read_model/projection_service/handlers/checkout.rs
• tests/distributed_read_model/projection_service/handlers/mod.rs
• tests/distributed_read_model/projection_service/handlers/seat.rs
• tests/distributed_read_model/query_service/mod.rs
• tests/distributed_read_model/read_models/mod.rs
• tests/distributed_read_model/seat_inventory_service/handlers/add.rs
• tests/distributed_read_model/seat_inventory_service/handlers/reserve_started_checkout_seat.rs
• tests/distributed_read_model/seat_inventory_service/mod.rs
• tests/distributed_read_model_board/board_service/handlers/board_add_card.rs
• tests/distributed_read_model_board/board_service/handlers/board_move_card.rs
• tests/distributed_read_model_board/board_service/handlers/board_open.rs
• tests/distributed_read_model_board/board_service/handlers/board_remove_card.rs
• tests/distributed_read_model_board/board_service/mod.rs
• tests/distributed_read_model_board/main.rs
• tests/distributed_read_model_board/projections_service/handlers/board.rs
• tests/distributed_read_model_board/projections_service/handlers/mod.rs
• tests/distributed_read_model_board/projections_service/mod.rs
• tests/distributed_read_model_board/query_service/mod.rs
• tests/enqueue/main.rs
• tests/event_store/main.rs
• tests/kafka_transport/main.rs
• tests/knative_cloudevents/main.rs
• tests/microsvc/basic.rs
• tests/microsvc/convention.rs
• tests/microsvc/handlers/counter_create.rs
• tests/microsvc/handlers/counter_increment.rs
• tests/microsvc/handlers/mod.rs
• tests/microsvc/handlers/whoami.rs
• tests/microsvc/session.rs
• tests/microsvc/transport_grpc.rs
• tests/microsvc/transport_http.rs
• tests/microsvc/transport_listen.rs
• tests/microsvc/transport_subscribe.rs
• tests/nats_transport/main.rs
• tests/postgres_transport/main.rs
• tests/queued_repo_async/main.rs
• tests/rabbitmq_transport/main.rs
• tests/read_model_commit_bridge/main.rs
• tests/read_model_relationship_includes/main.rs
• tests/read_model_session/main.rs
• tests/sagas/distributed.rs
• tests/sagas/handlers/inventory/init.rs
• tests/sagas/handlers/inventory/mod.rs
• tests/sagas/handlers/inventory/reserve.rs
• tests/sagas/handlers/messages.rs
• tests/sagas/handlers/orders/complete.rs
• tests/sagas/handlers/orders/create.rs
• tests/sagas/handlers/orders/mod.rs
• tests/sagas/handlers/payments/mod.rs
• tests/sagas/handlers/payments/process.rs
• tests/sagas/handlers/saga/mod.rs
• tests/sagas/handlers/saga/on_inventory_reserved.rs
• tests/sagas/handlers/saga/on_order_completed.rs
• tests/sagas/handlers/saga/on_order_created.rs
• tests/sagas/handlers/saga/on_payment_succeeded.rs
• tests/sagas/handlers/saga/start.rs
• tests/sagas/main.rs
• tests/sagas/microsvc_saga.rs
• tests/sagas/orchestration.rs
• tests/sagas/order/events.rs
• tests/sagas/order/mod.rs
• tests/snapshots/main.rs
• tests/sourced/main.rs
• tests/sourced_enqueue/main.rs
• tests/sourced_snapshot/main.rs
• tests/sourced_upcasting/main.rs
• tests/todos/main.rs
• tests/transport_conformance/mod.rs
• tests/upcasting/aggregate.rs
• tests/upcasting/main.rs

💤 Files with no reviewable changes (23)

• src/bus/subscriber.rs
• src/bus/event_bus.rs
• src/lock/lock_manager.rs
• src/bus/sender.rs
• tests/sagas/main.rs
• src/bus/listener.rs
• src/bus/publisher.rs
• src/bus/mod.rs
• tests/sagas/order/events.rs
• src/lock/lock.rs
• src/bus/bus.rs
• src/outbox_worker/mod.rs
• src/lock/in_memory.rs
• src/outbox_worker/thread.rs
• tests/sagas/order/mod.rs
• tests/sagas/distributed.rs
• src/repository/batch.rs
• src/repository/gettable.rs
• src/repository/repository.rs
• src/snapshot/store.rs
• tests/distributed_read_model_board/projections_service/handlers/mod.rs
• src/bus/in_memory_queue.rs
• src/microsvc/mod.rs