Function atomic_request_reply 

pub fn atomic_request_reply() -> Chunk

Atomic request-reply with crate::Value::Message (one envelope per hop).

Requires crate::std_native_table (make_msg / msg_* / print).

Why “Atomic Hop”

Correlation (request_id) and reply routing (sender) travel in a single mailbox value. Classic actor runtimes often allow any scalar on Send; Byteflow rejects that — every hop is a typed envelope.

Protocol

1. main spawns server, builds Message { id=1, tag=REQ, payload=41 } (sender placeholder ignored)
2. server receives, logs via print, replies tag=REP, payload=42 via msg_reply_cap (echoing request_id)
3. main returns the reply payload 42

Register discipline (CallNative clobbers r[a])

CallNative ra, …, nc reads args from r[a..a+nc] and writes the result into r[a]. Keeping the original Message in r0 therefore means every unpack is Move ri, r0 then CallNative ri, msg_*, 1. make_msg needs four contiguous arg registers; the server rearranges into r4..r7 before the call.

Examples found in repository

examples/atomic_actors.rs (line 22)

fn main() {
    let chunk = samples::atomic_request_reply();
    let rt = match Runtime::with_natives_and_config(
        chunk,
        std_native_table(),
        RuntimeConfig {
            workers: 2,
            quantum: 10_000,
        },
    ) {
        Ok(rt) => rt,
        Err(e) => {
            eprintln!("runtime: {e}");
            std::process::exit(1);
        }
    };
    let Some(main) = rt.function_index("main") else {
        eprintln!("missing main");
        std::process::exit(1);
    };
    let handle = match rt.spawn(main, &[]) {
        Ok(h) => h,
        Err(e) => {
            eprintln!("spawn: {e}");
            std::process::exit(1);
        }
    };
    let outcome = handle.join();
    let metrics = rt.metrics();
    rt.shutdown();

    match outcome {
        FlowOutcome::Completed(Value::Int(42)) => {
            println!("atomic request-reply ok: payload=42");
            println!("{metrics}");
        }
        other => {
            eprintln!("unexpected {other:?}");
            std::process::exit(1);
        }
    }
}