CameoDB Engine

                         ┌──────────────────────┐
                         │  ClusterCoordinator  │
                         │  RouteOperation msg  │
                         └─────────┬────────────┘
                                    │
                         routing_key present?
                           ┌────────┴────────┐
                          YES                NO
                           │                 │
                    Hash ring lookup    RoutingDecision::
                           │              Broadcast
                    owner == local?
                     ┌─────┴─────┐
                    YES          NO
                     │           │
              RoutingDecision  RoutingDecision::Remote
                ::Local        { node_id, peer_addr }

HTTP POST /api/{index}/search
  │
  ▼
RouterActor::route_and_handle(routing_key=None)
  │
  ▼ RoutingDecision::Broadcast
  │
  ├── LOCAL ──→ Worker Pool (or actor mailbox fallback)
  │               └── OrchestratorEngine::orch_search()
  │                     └── Fan out to all local MicroshardActors
  │                           └── spawn_blocking { store.search() }
  │
  └── REMOTE (per peer, up to fanout_limit) ──→ try_remote()
        │
        ▼
      RemotePeerPool::get_orchestrator(node_id)    ◄── cache hit: O(1)
        ├── RwLock read → HashMap lookup           ◄── cache miss: swarm lookup, then cached
        │
        ▼
      remote_ref.ask(&ClientOp::Search)
        │
        ▼
      Remote node executes same local search path
        │
        ▼
  ┌────────────────────────────────────────────┐
  │  Merge: bounded score-aware top-K merge,   │
  │  then truncate to the requested limit      │
  └────────────────────────────────────────────┘

HTTP POST /api/{index}/_bulk
  │
  ▼
RouterActor::route_and_handle(routing_hint=first_doc.id)
  │
  ▼ Routed to one node (usually local for the first doc)
  │
  ▼
NodeOrchestrator::orch_bulk_write(index, docs[])
  │
  ├── 1. Schema Resolution
  │     └── Fingerprint cache → shard fallback
  │
  ├── 2. Staged Schema Validation
  │     └── Parallel Rayon validation + sequential evolution
  │
  ├── 3. Per-Document Routing (spawn_blocking + Rayon par_iter)
  │     └── For each doc: hash(routing_key) → ConsistentRing → target shard
  │
  ├── 4. Separate Local vs Remote
  │     ├── shard in self.shards → local_docs
  │     └── shard owned by other node → remote_docs (grouped by node_id)
  │
  ├── 5. Phase 3.1: Parallel Local Shard Processing
  │     └── Per-shard MicroshardActor::write_batch()
  │           └── writer_thread → redb WAL + Tantivy index
  │
  └── 6. Phase 3.2: Parallel Remote Forwarding (futures::join_all)
        │
        for each (node_id, docs_for_remote):
          │
          ▼
        NodeOrchestrator::forward_bulk_to_remote()
          │
          ▼
        RemotePeerPool::get_orchestrator(node_id)    ◄── cached lookup
          │
          ▼
        remote_ref.ask(&ClientOp::BulkWrite)
          │
          ▼
        Remote node runs orch_bulk_write() (recursive, same path)