One API Call.
The Right Backend. Every Time.

// Encrypt integers — the session knows which backend to use
let values = vec![42, 100, 7, 255];
let ct_a = fabric.encrypt(&session.session_id, &values)?;

// Encrypt a second vector
let ct_b = fabric.encrypt(&session.session_id, &[10, 20, 30, 40])?;

// Homomorphic addition (on encrypted data)
let ct_sum = fabric.add(&session.session_id, &ct_a, &ct_b)?;

// Homomorphic multiplication
let ct_prod = fabric.multiply(&session.session_id, &ct_a, &ct_b)?;

// Decrypt — results computed entirely on ciphertext
let sum: Vec<i64> = fabric.decrypt_integers(&session.session_id, &ct_sum)?;
let prod: Vec<i64> = fabric.decrypt_integers(&session.session_id, &ct_prod)?;

assert_eq!(sum[0], 52);   // 42 + 10
assert_eq!(prod[0], 420); // 42 * 10

// Check noise budget (how many more operations before decryption fails)
let budget = fabric.noise_budget(&session.session_id, &ct_prod)?;
println!("Noise budget remaining: {} bits", budget);

// Request float computation — router auto-selects CKKS
let request = RoutingRequest {
    data_type: DataType::Float,           // This triggers CKKS selection
    product_tier: ProductTier::H33,
    security_tier: SecurityTier::Q128,
    needs_bootstrapping: true,          // Unlimited depth
    ..Default::default()
};

let session = fabric.create_session(request, "ml-pipeline")?;
assert_eq!(session.backend_id, BackendId::Ckks);

// Encrypt floating-point data (ML embeddings, scores, etc.)
let embeddings = vec![0.85, 0.92, -0.31, 0.67];
let ct = fabric.encrypt_floats(&session.session_id, &embeddings)?;

// Homomorphic dot product, scoring, aggregation...
let ct_doubled = fabric.add(&session.session_id, &ct, &ct)?;

// Decrypt
let result: Vec<f64> = fabric.decrypt_floats(&session.session_id, &ct_doubled)?;
// result[0] ≈ 1.70  (0.85 + 0.85, CKKS gives approximate results)

// Stateless recommendation — see what FHE-IQ would pick
// without creating a session (zero cost, useful for planning)

let decision = fabric.recommend(&RoutingRequest {
    data_type: DataType::Integer,
    product_tier: ProductTier::H256,     // Maximum security
    security_tier: SecurityTier::Q256,   // NIST Level 5
    needs_rotation: true,
    ..Default::default()
})?;

println!("Recommended: {:?}", decision.backend_id);  // Bfv64
println!("Score: {:.2}", decision.score);              // 0.87
println!("Disqualified:");
for (id, reason) in &decision.disqualified {
    println!("  {:?}: {}", id, reason);
    // Ckks: "Integer data type requires integer backend"
    // Bfv32: "H-256 tier not supported (max: H1)"
}

// Check all backend capabilities
let backends = fabric.list_backends();
for b in &backends {
    println!("{:?}: max_tier={:?}, floats={}, rotation={}",
        b.id, b.max_product_tier, b.supports_float, b.supports_rotation);
}