██████╗  ██████╗ 
██╔════╝ ██╔═══██╗
██║      ██║   ██║
██║      ██║   ██║
╚██████╗ ╚██████╔╝
 ╚═════╝  ╚═════╝ 

◈ THE COORDINATION ADVANTAGE

◈ FEATURES

┌─────────────────────────────────────────────────────────────────────────┐
│  ◆ PIPELINING   │  Native support for double and triple buffering.      │
│                │  Smooth frame delivery without CPU/GPU contention.      │
├─────────────────────────────────────────────────────────────────────────┤
│  ◆ TELEPORT     │  Allocations on the CPU frame arena can be "staged"    │
│                │  for automatic mirroring to GPU device memory.          │
├─────────────────────────────────────────────────────────────────────────┤
│  ◆ SCHEDULING   │  Automated transfer coalescing. Minimizes driver       │
│                │  overhead by batching many small uploads.               │
└─────────────────────────────────────────────────────────────────────────┘

◈ QUICK START

use memkit_co::{MkCoordinator, CoordinatorConfig, BufferingMode};
use memkit_gpu::DummyBackend;

// Initialize Triple Buffering Coordinator
let config = CoordinatorConfig {
    buffering: BufferingMode::Triple,
    ..Default::default()
};
let mut coordinator = MkCoordinator::new(DummyBackend::new(), config);

// Single-call "Upload & Forget"
let vertices: &[f32] = &[0.0, 0.5, 1.0, -0.5, -0.5, 1.0];
let gpu_buffer = coordinator.upload_slice(vertices).unwrap();

// Structured Frame Workflow
coordinator.begin_frame();
{
    let transform = coordinator.frame_alloc::<[f32; 16]>();
    *transform = [1.0; 16];
    
    // Automatically stage for GPU at end of frame
    coordinator.stage_for_upload(transform);
}
coordinator.end_frame().unwrap(); // Batch transfers & rotate buffers

◈ ARCHITECTURE

graph LR
    CPU([memkit Core]) --> Manager[memkit-co Manager]
    Manager --> GPU([memkit-gpu Backend])
    GPU -- Completion --> Manager
    Manager -- Stats --> CPU

◈ LICENSE

Licensed under the Mozilla Public License 2.0.