grafos_std/

host.rs

//! Raw host function bindings for FBMU and FBBU.
//!
//! This module provides the low-level interface between grafos-std and the
//! grafOS runtime. On `wasm32` targets, these functions link to real host
//! imports (`fabricbios_fbmu_v0` and `fabricbios_fbbu_v0` WASM import
//! modules). On native targets, they delegate to mock implementations backed
//! by thread-local storage so unit tests work without a WASM runtime.
//!
//! All `unsafe` in the crate is confined to this module. Higher-level code
//! in [`crate::mem`] and [`crate::block`] wraps these functions with safe
//! Rust APIs.
//!
//! # Mock configuration (native targets only)
//!
//! When running on non-WASM targets, the mock state can be configured for
//! testing:
//!
//! ```rust
//! use grafos_std::host;
//!
//! host::reset_mock();
//! host::mock_set_fbmu_arena_size(8192);
//! host::mock_set_fbbu_num_blocks(256);
//! host::mock_set_unix_time_secs(1_700_000_000);
//!
//! // Now FabricMem::hello() and FabricBlock::hello() will use these values.
//! ```

extern crate alloc;

use crate::error::{FabricError, Result};
use alloc::vec::Vec;

/// Lease status code: lease is active.
pub const LEASE_STATUS_ACTIVE: u8 = 0;
/// Lease status code: lease has expired.
pub const LEASE_STATUS_EXPIRED: u8 = 1;
/// Lease status code: lease was explicitly revoked/freed.
pub const LEASE_STATUS_REVOKED: u8 = 2;

/// Host-side FBMU lease metadata returned by v0 lease lifecycle calls.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FbmuLeaseInfo {
    pub lease_id: u128,
    pub expires_at_unix_secs: u64,
    pub arena_size: u64,
    pub status: u8,
}

/// Host-side FBBU lease metadata returned by v0 lease lifecycle calls.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FbbuLeaseInfo {
    pub lease_id: u128,
    pub expires_at_unix_secs: u64,
    pub num_blocks: u64,
    pub block_size: u32,
    pub status: u8,
}

#[cfg(target_arch = "wasm32")]
fn split_u128_words(value: u128) -> (i64, i64) {
    let hi = (value >> 64) as u64;
    let lo = value as u64;
    (hi as i64, lo as i64)
}

#[cfg(target_arch = "wasm32")]
fn join_u128_words(hi: i64, lo: i64) -> u128 {
    ((hi as u64 as u128) << 64) | (lo as u64 as u128)
}

// ---------------------------------------------------------------------------
// WASM target: real host imports
// ---------------------------------------------------------------------------

#[cfg(target_arch = "wasm32")]
mod wasm {
    #[link(wasm_import_module = "fabricbios_fbmu_v0")]
    extern "C" {
        pub fn fbmu_hello() -> i32;
        pub fn fbmu_write(offset: i64, ptr: i32, len: i32) -> i32;
        pub fn fbmu_read(offset: i64, len: i32, out_ptr: i32) -> i32;
        pub fn fbmu_get_arena_size() -> i64;
        pub fn fbmu_alloc(
            min_bytes: i64,
            lease_secs: i64,
            lease_hi_ptr: i32,
            lease_lo_ptr: i32,
            expires_at_ptr: i32,
            arena_size_ptr: i32,
        ) -> i32;
        pub fn fbmu_query(
            lease_hi: i64,
            lease_lo: i64,
            status_ptr: i32,
            expires_at_ptr: i32,
            arena_size_ptr: i32,
        ) -> i32;
        pub fn fbmu_renew(
            lease_hi: i64,
            lease_lo: i64,
            duration_secs: i64,
            expires_at_ptr: i32,
        ) -> i32;
        pub fn fbmu_free(lease_hi: i64, lease_lo: i64) -> i32;
        pub fn fbmu_write_lease(
            lease_hi: i64,
            lease_lo: i64,
            offset: i64,
            ptr: i32,
            len: i32,
        ) -> i32;
        pub fn fbmu_read_lease(
            lease_hi: i64,
            lease_lo: i64,
            offset: i64,
            len: i32,
            out_ptr: i32,
        ) -> i32;
    }

    #[link(wasm_import_module = "fabricbios_fbbu_v0")]
    extern "C" {
        pub fn fbbu_hello() -> i32;
        pub fn fbbu_write_block(lba: i64, ptr: i32) -> i32;
        pub fn fbbu_read_block(lba: i64, out_ptr: i32) -> i32;
        pub fn fbbu_get_num_blocks() -> i64;
        pub fn fbbu_alloc(
            min_blocks: i64,
            lease_secs: i64,
            lease_hi_ptr: i32,
            lease_lo_ptr: i32,
            expires_at_ptr: i32,
            num_blocks_ptr: i32,
            block_size_ptr: i32,
        ) -> i32;
        pub fn fbbu_query(
            lease_hi: i64,
            lease_lo: i64,
            status_ptr: i32,
            expires_at_ptr: i32,
            num_blocks_ptr: i32,
            block_size_ptr: i32,
        ) -> i32;
        pub fn fbbu_renew(
            lease_hi: i64,
            lease_lo: i64,
            duration_secs: i64,
            expires_at_ptr: i32,
        ) -> i32;
        pub fn fbbu_free(lease_hi: i64, lease_lo: i64) -> i32;
        pub fn fbbu_write_block_lease(lease_hi: i64, lease_lo: i64, lba: i64, ptr: i32) -> i32;
        pub fn fbbu_read_block_lease(lease_hi: i64, lease_lo: i64, lba: i64, out_ptr: i32) -> i32;
    }
}

/// Perform the FBMU HELLO handshake with the host.
///
/// Establishes the memory data-plane session. Must be called before any
/// FBMU read/write operations.
///
/// # Errors
///
/// Returns [`FabricError::Disconnected`] if the host connection is not
/// available, or another [`FabricError`] variant based on the host status
/// code.
#[cfg(target_arch = "wasm32")]
pub fn fbmu_hello() -> Result<()> {
    let status = unsafe { wasm::fbmu_hello() };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Write `data` to the FBMU arena at the given byte `offset`.
///
/// # Errors
///
/// Returns a [`FabricError`] if the host reports a write failure.
#[cfg(target_arch = "wasm32")]
pub fn fbmu_write(offset: u64, data: &[u8]) -> Result<()> {
    let status =
        unsafe { wasm::fbmu_write(offset as i64, data.as_ptr() as i32, data.len() as i32) };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Read from the FBMU arena at `offset` into `buf`.
///
/// Returns the number of bytes actually read, which may be less than
/// `buf.len()` if the arena region is shorter.
///
/// # Errors
///
/// Returns a [`FabricError`] if the host reports a read failure.
#[cfg(target_arch = "wasm32")]
pub fn fbmu_read(offset: u64, buf: &mut [u8]) -> Result<usize> {
    let n = unsafe { wasm::fbmu_read(offset as i64, buf.len() as i32, buf.as_mut_ptr() as i32) };
    if n < 0 {
        Err(FabricError::from_status(n).unwrap_or(FabricError::IoError(n)))
    } else {
        Ok(n as usize)
    }
}

/// Query the total FBMU arena size in bytes.
///
/// # Errors
///
/// Returns [`FabricError::IoError`] if the host returns a negative value.
#[cfg(target_arch = "wasm32")]
pub fn fbmu_get_arena_size() -> Result<u64> {
    let size = unsafe { wasm::fbmu_get_arena_size() };
    if size < 0 {
        Err(FabricError::IoError(size as i32))
    } else {
        Ok(size as u64)
    }
}

/// Perform the FBBU HELLO handshake with the host.
///
/// Establishes the block data-plane session. Must be called before any
/// FBBU read/write operations.
///
/// # Errors
///
/// Returns [`FabricError::Disconnected`] if the host connection is not
/// available.
#[cfg(target_arch = "wasm32")]
pub fn fbbu_hello() -> Result<()> {
    let status = unsafe { wasm::fbbu_hello() };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Write a single 512-byte block at the given logical block address.
///
/// # Errors
///
/// Returns [`FabricError::CapacityExceeded`] if `lba` is beyond the
/// device's block count.
#[cfg(target_arch = "wasm32")]
pub fn fbbu_write_block(lba: u64, data: &[u8; 512]) -> Result<()> {
    let status = unsafe { wasm::fbbu_write_block(lba as i64, data.as_ptr() as i32) };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Read a single 512-byte block at the given logical block address.
///
/// # Errors
///
/// Returns [`FabricError::CapacityExceeded`] if `lba` is beyond the
/// device's block count.
#[cfg(target_arch = "wasm32")]
pub fn fbbu_read_block(lba: u64, buf: &mut [u8; 512]) -> Result<()> {
    let status = unsafe { wasm::fbbu_read_block(lba as i64, buf.as_mut_ptr() as i32) };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Query the total number of blocks available on the FBBU device.
///
/// # Errors
///
/// Returns [`FabricError::IoError`] if the host returns a negative value.
#[cfg(target_arch = "wasm32")]
pub fn fbbu_get_num_blocks() -> Result<u64> {
    let n = unsafe { wasm::fbbu_get_num_blocks() };
    if n < 0 {
        Err(FabricError::IoError(n as i32))
    } else {
        Ok(n as u64)
    }
}

/// Allocate a memory lease from FBMU with the requested minimum capacity and TTL.
#[cfg(target_arch = "wasm32")]
pub fn fbmu_alloc(min_bytes: u64, lease_secs: u64) -> Result<FbmuLeaseInfo> {
    let mut lease_hi: i64 = 0;
    let mut lease_lo: i64 = 0;
    let mut expires_at: i64 = 0;
    let mut arena_size: i64 = 0;
    let status = unsafe {
        wasm::fbmu_alloc(
            min_bytes as i64,
            lease_secs as i64,
            &mut lease_hi as *mut i64 as i32,
            &mut lease_lo as *mut i64 as i32,
            &mut expires_at as *mut i64 as i32,
            &mut arena_size as *mut i64 as i32,
        )
    };
    match FabricError::from_status(status) {
        None => Ok(FbmuLeaseInfo {
            lease_id: join_u128_words(lease_hi, lease_lo),
            expires_at_unix_secs: expires_at as u64,
            arena_size: arena_size as u64,
            status: LEASE_STATUS_ACTIVE,
        }),
        Some(e) => Err(e),
    }
}

/// Query FBMU lease status and capacity metadata.
#[cfg(target_arch = "wasm32")]
pub fn fbmu_query(lease_id: u128) -> Result<FbmuLeaseInfo> {
    let (lease_hi, lease_lo) = split_u128_words(lease_id);
    let mut lease_status: i32 = LEASE_STATUS_REVOKED as i32;
    let mut expires_at: i64 = 0;
    let mut arena_size: i64 = 0;
    let status = unsafe {
        wasm::fbmu_query(
            lease_hi,
            lease_lo,
            &mut lease_status as *mut i32 as i32,
            &mut expires_at as *mut i64 as i32,
            &mut arena_size as *mut i64 as i32,
        )
    };
    match FabricError::from_status(status) {
        None => Ok(FbmuLeaseInfo {
            lease_id,
            expires_at_unix_secs: expires_at as u64,
            arena_size: arena_size as u64,
            status: lease_status as u8,
        }),
        Some(e) => Err(e),
    }
}

/// Renew an FBMU lease and return the updated expiry timestamp.
#[cfg(target_arch = "wasm32")]
pub fn fbmu_renew(lease_id: u128, duration_secs: u64) -> Result<u64> {
    let (lease_hi, lease_lo) = split_u128_words(lease_id);
    let mut expires_at: i64 = 0;
    let status = unsafe {
        wasm::fbmu_renew(
            lease_hi,
            lease_lo,
            duration_secs as i64,
            &mut expires_at as *mut i64 as i32,
        )
    };
    match FabricError::from_status(status) {
        None => Ok(expires_at as u64),
        Some(e) => Err(e),
    }
}

/// Free/revoke an FBMU lease.
#[cfg(target_arch = "wasm32")]
pub fn fbmu_free(lease_id: u128) -> Result<()> {
    let (lease_hi, lease_lo) = split_u128_words(lease_id);
    let status = unsafe { wasm::fbmu_free(lease_hi, lease_lo) };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Write to FBMU using an explicit lease id.
#[cfg(target_arch = "wasm32")]
pub fn fbmu_write_lease(lease_id: u128, offset: u64, data: &[u8]) -> Result<()> {
    let (lease_hi, lease_lo) = split_u128_words(lease_id);
    let status = unsafe {
        wasm::fbmu_write_lease(
            lease_hi,
            lease_lo,
            offset as i64,
            data.as_ptr() as i32,
            data.len() as i32,
        )
    };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Read from FBMU using an explicit lease id.
#[cfg(target_arch = "wasm32")]
pub fn fbmu_read_lease(lease_id: u128, offset: u64, buf: &mut [u8]) -> Result<usize> {
    let (lease_hi, lease_lo) = split_u128_words(lease_id);
    let n = unsafe {
        wasm::fbmu_read_lease(
            lease_hi,
            lease_lo,
            offset as i64,
            buf.len() as i32,
            buf.as_mut_ptr() as i32,
        )
    };
    if n < 0 {
        Err(FabricError::from_status(n).unwrap_or(FabricError::IoError(n)))
    } else {
        Ok(n as usize)
    }
}

/// Allocate a block lease from FBBU with the requested minimum capacity and TTL.
#[cfg(target_arch = "wasm32")]
pub fn fbbu_alloc(min_blocks: u64, lease_secs: u64) -> Result<FbbuLeaseInfo> {
    let mut lease_hi: i64 = 0;
    let mut lease_lo: i64 = 0;
    let mut expires_at: i64 = 0;
    let mut num_blocks: i64 = 0;
    let mut block_size: i32 = 0;
    let status = unsafe {
        wasm::fbbu_alloc(
            min_blocks as i64,
            lease_secs as i64,
            &mut lease_hi as *mut i64 as i32,
            &mut lease_lo as *mut i64 as i32,
            &mut expires_at as *mut i64 as i32,
            &mut num_blocks as *mut i64 as i32,
            &mut block_size as *mut i32 as i32,
        )
    };
    match FabricError::from_status(status) {
        None => Ok(FbbuLeaseInfo {
            lease_id: join_u128_words(lease_hi, lease_lo),
            expires_at_unix_secs: expires_at as u64,
            num_blocks: num_blocks as u64,
            block_size: block_size as u32,
            status: LEASE_STATUS_ACTIVE,
        }),
        Some(e) => Err(e),
    }
}

/// Query FBBU lease status and geometry metadata.
#[cfg(target_arch = "wasm32")]
pub fn fbbu_query(lease_id: u128) -> Result<FbbuLeaseInfo> {
    let (lease_hi, lease_lo) = split_u128_words(lease_id);
    let mut lease_status: i32 = LEASE_STATUS_REVOKED as i32;
    let mut expires_at: i64 = 0;
    let mut num_blocks: i64 = 0;
    let mut block_size: i32 = 0;
    let status = unsafe {
        wasm::fbbu_query(
            lease_hi,
            lease_lo,
            &mut lease_status as *mut i32 as i32,
            &mut expires_at as *mut i64 as i32,
            &mut num_blocks as *mut i64 as i32,
            &mut block_size as *mut i32 as i32,
        )
    };
    match FabricError::from_status(status) {
        None => Ok(FbbuLeaseInfo {
            lease_id,
            expires_at_unix_secs: expires_at as u64,
            num_blocks: num_blocks as u64,
            block_size: block_size as u32,
            status: lease_status as u8,
        }),
        Some(e) => Err(e),
    }
}

/// Renew an FBBU lease and return the updated expiry timestamp.
#[cfg(target_arch = "wasm32")]
pub fn fbbu_renew(lease_id: u128, duration_secs: u64) -> Result<u64> {
    let (lease_hi, lease_lo) = split_u128_words(lease_id);
    let mut expires_at: i64 = 0;
    let status = unsafe {
        wasm::fbbu_renew(
            lease_hi,
            lease_lo,
            duration_secs as i64,
            &mut expires_at as *mut i64 as i32,
        )
    };
    match FabricError::from_status(status) {
        None => Ok(expires_at as u64),
        Some(e) => Err(e),
    }
}

/// Free/revoke an FBBU lease.
#[cfg(target_arch = "wasm32")]
pub fn fbbu_free(lease_id: u128) -> Result<()> {
    let (lease_hi, lease_lo) = split_u128_words(lease_id);
    let status = unsafe { wasm::fbbu_free(lease_hi, lease_lo) };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Write a 512-byte block via FBBU using an explicit lease id.
#[cfg(target_arch = "wasm32")]
pub fn fbbu_write_block_lease(lease_id: u128, lba: u64, data: &[u8; 512]) -> Result<()> {
    let (lease_hi, lease_lo) = split_u128_words(lease_id);
    let status = unsafe {
        wasm::fbbu_write_block_lease(lease_hi, lease_lo, lba as i64, data.as_ptr() as i32)
    };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Read a 512-byte block via FBBU using an explicit lease id.
#[cfg(target_arch = "wasm32")]
pub fn fbbu_read_block_lease(lease_id: u128, lba: u64, buf: &mut [u8; 512]) -> Result<()> {
    let (lease_hi, lease_lo) = split_u128_words(lease_id);
    let status = unsafe {
        wasm::fbbu_read_block_lease(lease_hi, lease_lo, lba as i64, buf.as_mut_ptr() as i32)
    };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

// ---------------------------------------------------------------------------
// WASM target: tasklet host imports
// ---------------------------------------------------------------------------

#[cfg(target_arch = "wasm32")]
mod wasm_tasklet {
    #[link(wasm_import_module = "fabricbios_tasklet_v0")]
    extern "C" {
        /// Submit WASM bytes for execution. Returns status (0=ok, negative=error).
        /// On success, exit_code written at exit_code_ptr, output at output_ptr,
        /// actual output length at output_len_ptr.
        pub fn tasklet_submit(
            wasm_ptr: i32,
            wasm_len: i32,
            input_ptr: i32,
            input_len: i32,
            fuel: i64,
            exit_code_ptr: i32,
            output_ptr: i32,
            output_max_len: i32,
            output_len_ptr: i32,
        ) -> i32;
    }
}

#[cfg(target_arch = "wasm32")]
mod wasm_net {
    #[link(wasm_import_module = "fabricbios_net_v0")]
    extern "C" {
        /// Acquire a network interface with minimum bandwidth.
        /// On success: status=0, interface name written at name_ptr (up to name_max_len),
        /// actual name length at name_len_ptr, actual bandwidth at bw_ptr.
        pub fn net_hello(
            min_bw: i64,
            name_ptr: i32,
            name_max_len: i32,
            name_len_ptr: i32,
            bw_ptr: i32,
        ) -> i32;
    }
}

#[cfg(target_arch = "wasm32")]
mod wasm_gpu {
    #[link(wasm_import_module = "fabricbios_gpu_v0")]
    extern "C" {
        /// Allocate a GPU lease. Returns status (0=ok, negative=error).
        /// On success, lease_id written as two u64 halves at the given pointers.
        pub fn gpu_lease_alloc(
            resource_id_lo: i64,
            resource_id_hi: i64,
            lease_secs: u32,
            lease_id_lo_ptr: i32,
            lease_id_hi_ptr: i32,
        ) -> i32;

        /// Renew a GPU lease. Returns status (0=ok, negative=error).
        pub fn gpu_lease_renew(lease_id_lo: i64, lease_id_hi: i64, duration_secs: u32) -> i32;

        /// Free a GPU lease. Returns status (0=ok, negative=error).
        pub fn gpu_lease_free(lease_id_lo: i64, lease_id_hi: i64) -> i32;

        /// Query GPU lease status. Returns status (0=ok, negative=error).
        /// On success, lease_status written at status_ptr.
        pub fn gpu_lease_query(lease_id_lo: i64, lease_id_hi: i64, status_ptr: i32) -> i32;
    }

    // Phase 48.15 W1 — persistent GPU session ops (0x0601–0x0607).
    //
    // These mirror `fabricbios_core::gpu_session` request/response types on
    // the wire. Lease IDs are split into `(lo, hi)` u64 halves per the v0
    // calling convention; byte buffers are passed as `(ptr, len)` pairs; and
    // handle-returning ops take an out-pointer for the handle.
    //
    // Return value is a 32-bit status: `0` = success; negative values map to
    // the transport-level [`FabricError`] variants via
    // [`FabricError::from_status`]; non-negative non-zero values carry the
    // raw `SESSION_STATUS_*` code and surface as
    // [`FabricError::GpuSessionFailed(u8)`].
    #[link(wasm_import_module = "fabricbios_gpu_v1")]
    extern "C" {
        pub fn gpu_session_mem_alloc(
            lease_lo: i64,
            lease_hi: i64,
            size: i64,
            handle_out_ptr: i32,
        ) -> i32;

        pub fn gpu_session_mem_write(
            lease_lo: i64,
            lease_hi: i64,
            handle: i64,
            offset: i64,
            data_ptr: i32,
            data_len: i32,
        ) -> i32;

        pub fn gpu_session_mem_read(
            lease_lo: i64,
            lease_hi: i64,
            handle: i64,
            offset: i64,
            dst_ptr: i32,
            dst_max: i32,
            out_len_ptr: i32,
        ) -> i32;

        pub fn gpu_session_mem_free(lease_lo: i64, lease_hi: i64, handle: i64) -> i32;

        pub fn gpu_session_module_load(
            lease_lo: i64,
            lease_hi: i64,
            bin_ptr: i32,
            bin_len: i32,
            module_out_ptr: i32,
        ) -> i32;

        pub fn gpu_session_launch(
            lease_lo: i64,
            lease_hi: i64,
            module_id: i64,
            kname_ptr: i32,
            kname_len: i32,
            gx: u32,
            gy: u32,
            gz: u32,
            bx: u32,
            by: u32,
            bz: u32,
            args_ptr: i32,
            args_len: i32,
            arg_sizes_ptr: i32,
            arg_sizes_len: i32,
        ) -> i32;

        pub fn gpu_session_sync(lease_lo: i64, lease_hi: i64) -> i32;

        /// Phase 48.16 SDK polish — explicit module unload, the 8th
        /// `fabricbios_gpu_v1` op. Additive: existing 7 ops unchanged.
        /// Powers `GpuModule::drop` RAII in `crates/grafos-std/src/gpu.rs`.
        pub fn gpu_session_module_unload(lease_lo: i64, lease_hi: i64, module_id: i64) -> i32;
    }
}

/// Submit a WASM tasklet for execution on a fabric CPU resource.
///
/// # Parameters
///
/// - `wasm`: The WASM module bytes to execute.
/// - `input`: Input data passed to the tasklet.
/// - `fuel`: WASM fuel limit (instruction budget).
/// - `output_buf`: Buffer for tasklet output.
///
/// # Returns
///
/// On success, returns `(exit_code, output_len)`.
///
/// # Errors
///
/// Returns a [`FabricError`] if the submission fails.
#[cfg(target_arch = "wasm32")]
pub fn tasklet_submit(
    wasm: &[u8],
    input: &[u8],
    fuel: u64,
    output_buf: &mut [u8],
) -> Result<(u64, usize)> {
    let mut exit_code: u64 = 0;
    let mut output_len: u32 = 0;
    let status = unsafe {
        wasm_tasklet::tasklet_submit(
            wasm.as_ptr() as i32,
            wasm.len() as i32,
            input.as_ptr() as i32,
            input.len() as i32,
            fuel as i64,
            &mut exit_code as *mut u64 as i32,
            output_buf.as_mut_ptr() as i32,
            output_buf.len() as i32,
            &mut output_len as *mut u32 as i32,
        )
    };
    match FabricError::from_status(status) {
        None => Ok((exit_code, output_len as usize)),
        Some(e) => Err(e),
    }
}

/// Allocate a GPU lease via host import.
#[cfg(target_arch = "wasm32")]
pub fn gpu_lease_alloc(resource_id: u128, lease_secs: u32) -> Result<u128> {
    let res_lo = resource_id as i64;
    let res_hi = (resource_id >> 64) as i64;
    let mut lease_id_lo: u64 = 0;
    let mut lease_id_hi: u64 = 0;
    let status = unsafe {
        wasm_gpu::gpu_lease_alloc(
            res_lo,
            res_hi,
            lease_secs,
            &mut lease_id_lo as *mut u64 as i32,
            &mut lease_id_hi as *mut u64 as i32,
        )
    };
    match FabricError::from_status(status) {
        None => Ok((lease_id_hi as u128) << 64 | (lease_id_lo as u128)),
        Some(e) => Err(e),
    }
}

/// Renew a GPU lease via host import.
#[cfg(target_arch = "wasm32")]
pub fn gpu_lease_renew(lease_id: u128, duration_secs: u32) -> Result<()> {
    let lo = lease_id as i64;
    let hi = (lease_id >> 64) as i64;
    let status = unsafe { wasm_gpu::gpu_lease_renew(lo, hi, duration_secs) };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Free a GPU lease via host import.
#[cfg(target_arch = "wasm32")]
pub fn gpu_lease_free(lease_id: u128) -> Result<()> {
    let lo = lease_id as i64;
    let hi = (lease_id >> 64) as i64;
    let status = unsafe { wasm_gpu::gpu_lease_free(lo, hi) };
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Query GPU lease status via host import.
/// Returns a status code (0=active, 1=expired, 2=revoked, 3=fenced).
#[cfg(target_arch = "wasm32")]
pub fn gpu_lease_query(lease_id: u128) -> Result<u32> {
    let lo = lease_id as i64;
    let hi = (lease_id >> 64) as i64;
    let mut lease_status: u32 = 0;
    let status = unsafe { wasm_gpu::gpu_lease_query(lo, hi, &mut lease_status as *mut u32 as i32) };
    match FabricError::from_status(status) {
        None => Ok(lease_status),
        Some(e) => Err(e),
    }
}

// ---------------------------------------------------------------------------
// Phase 48.15 W1 — wasm32 bridge for persistent GPU session ops.
//
// These lower Rust-typed parameters to the `fabricbios_gpu_v1` wire ABI
// (lease_id split into lo/hi, byte slices split into (ptr, len), handle
// out-parameters via pointer) and translate the i32 return:
//
//   0                                    → Ok(..)
//   negative                             → Err(FabricError::from_status(..))
//   positive (SESSION_STATUS_* from
//   `fabricbios_core::gpu_session`)      → Err(FabricError::GpuSessionFailed(code))
//
// Native equivalents (mock-backed) live further below under
// `#[cfg(not(target_arch = "wasm32"))]`; both families share the same Rust
// signatures so `impl GpuSession` compiles on both targets.
// ---------------------------------------------------------------------------

#[cfg(target_arch = "wasm32")]
#[inline]
fn lease_id_split(lease_id: u128) -> (i64, i64) {
    (lease_id as i64, (lease_id >> 64) as i64)
}

// Phase 48.15 W2a — `session_status_to_result` is now used by BOTH the
// wasm32 import-bridge wrappers AND the native mock wrappers. Previously it
// was wasm32-only and the native wrappers used `FabricError::from_status`
// directly, which collapses any positive non-zero status into
// `FabricError::IoError(n)` instead of `FabricError::GpuSessionFailed(n)`.
// That meant `mock::TestState::gpu.session_error = Some(SESSION_STATUS_*)`
// produced different error variants under wasm32 vs native, breaking the
// host-mock parity story for `impl GpuSession`. Sharing the helper across
// both targets is the fix.
#[inline]
fn session_status_to_result(status: i32) -> Result<()> {
    if status == 0 {
        Ok(())
    } else if status < 0 {
        // Transport/lease-level failure surfaced by the daemon bridge.
        Err(FabricError::from_status(status).unwrap_or(FabricError::IoError(status)))
    } else {
        // Positive, non-zero: a raw SESSION_STATUS_* code from
        // `fabricbios_core::gpu_session`.
        Err(FabricError::GpuSessionFailed(status as u8))
    }
}

/// Allocate device memory within a GPU session.
#[cfg(target_arch = "wasm32")]
pub fn gpu_session_mem_alloc(lease_id: u128, size: u64) -> Result<u64> {
    let (lo, hi) = lease_id_split(lease_id);
    let mut handle: u64 = 0;
    let status = unsafe {
        wasm_gpu::gpu_session_mem_alloc(lo, hi, size as i64, &mut handle as *mut u64 as i32)
    };
    session_status_to_result(status).map(|()| handle)
}

/// Write data to device memory within a GPU session.
#[cfg(target_arch = "wasm32")]
pub fn gpu_session_mem_write(lease_id: u128, handle: u64, offset: u64, data: &[u8]) -> Result<()> {
    let (lo, hi) = lease_id_split(lease_id);
    let status = unsafe {
        wasm_gpu::gpu_session_mem_write(
            lo,
            hi,
            handle as i64,
            offset as i64,
            data.as_ptr() as i32,
            data.len() as i32,
        )
    };
    session_status_to_result(status)
}

/// Read data from device memory within a GPU session.
///
/// The wasm32 ABI uses a caller-supplied output buffer (sized to `size`)
/// with an out-length pointer, mirroring the `gpu_submit` output pattern.
/// On success the returned `Vec<u8>` is truncated to the actual bytes read.
#[cfg(target_arch = "wasm32")]
pub fn gpu_session_mem_read(
    lease_id: u128,
    handle: u64,
    offset: u64,
    size: u32,
) -> Result<alloc::vec::Vec<u8>> {
    let (lo, hi) = lease_id_split(lease_id);
    let mut buf: alloc::vec::Vec<u8> = alloc::vec![0u8; size as usize];
    let mut out_len: u32 = 0;
    let status = unsafe {
        wasm_gpu::gpu_session_mem_read(
            lo,
            hi,
            handle as i64,
            offset as i64,
            buf.as_mut_ptr() as i32,
            size as i32,
            &mut out_len as *mut u32 as i32,
        )
    };
    session_status_to_result(status).map(|()| {
        buf.truncate(out_len as usize);
        buf
    })
}

/// Free device memory within a GPU session.
#[cfg(target_arch = "wasm32")]
pub fn gpu_session_mem_free(lease_id: u128, handle: u64) -> Result<()> {
    let (lo, hi) = lease_id_split(lease_id);
    let status = unsafe { wasm_gpu::gpu_session_mem_free(lo, hi, handle as i64) };
    session_status_to_result(status)
}

/// Load a GPU module (PTX/cubin) within a GPU session.
#[cfg(target_arch = "wasm32")]
pub fn gpu_session_module_load(lease_id: u128, binary: &[u8]) -> Result<u64> {
    let (lo, hi) = lease_id_split(lease_id);
    let mut module_id: u64 = 0;
    let status = unsafe {
        wasm_gpu::gpu_session_module_load(
            lo,
            hi,
            binary.as_ptr() as i32,
            binary.len() as i32,
            &mut module_id as *mut u64 as i32,
        )
    };
    session_status_to_result(status).map(|()| module_id)
}

/// Launch a kernel from a loaded module within a GPU session.
#[cfg(target_arch = "wasm32")]
pub fn gpu_session_launch(
    lease_id: u128,
    module_id: u64,
    kernel_name: &str,
    grid_dim: [u32; 3],
    block_dim: [u32; 3],
    args: &[u8],
    arg_sizes: &[u32],
) -> Result<()> {
    let (lo, hi) = lease_id_split(lease_id);
    let name_bytes = kernel_name.as_bytes();
    let status = unsafe {
        wasm_gpu::gpu_session_launch(
            lo,
            hi,
            module_id as i64,
            name_bytes.as_ptr() as i32,
            name_bytes.len() as i32,
            grid_dim[0],
            grid_dim[1],
            grid_dim[2],
            block_dim[0],
            block_dim[1],
            block_dim[2],
            args.as_ptr() as i32,
            args.len() as i32,
            arg_sizes.as_ptr() as i32,
            arg_sizes.len() as i32,
        )
    };
    session_status_to_result(status)
}

/// Synchronize a GPU session (wait for all outstanding launches).
#[cfg(target_arch = "wasm32")]
pub fn gpu_session_sync(lease_id: u128) -> Result<()> {
    let (lo, hi) = lease_id_split(lease_id);
    let status = unsafe { wasm_gpu::gpu_session_sync(lo, hi) };
    session_status_to_result(status)
}

/// Unload a GPU module within a GPU session (Phase 48.16 SDK polish).
#[cfg(target_arch = "wasm32")]
pub fn gpu_session_module_unload(lease_id: u128, module_id: u64) -> Result<()> {
    let (lo, hi) = lease_id_split(lease_id);
    let status = unsafe { wasm_gpu::gpu_session_module_unload(lo, hi, module_id as i64) };
    session_status_to_result(status)
}

/// Acquire a network interface with the given minimum bandwidth.
///
/// # Parameters
///
/// - `min_bw`: Minimum bandwidth in bits per second.
///
/// # Returns
///
/// On success, returns `(interface_name, actual_bandwidth)`.
///
/// # Errors
///
/// Returns a [`FabricError`] if the acquisition fails.
#[cfg(target_arch = "wasm32")]
pub fn net_hello(min_bw: u64) -> Result<(alloc::string::String, u64)> {
    let mut name_buf = [0u8; 64];
    let mut name_len: u32 = 0;
    let mut actual_bw: u64 = 0;
    let status = unsafe {
        wasm_net::net_hello(
            min_bw as i64,
            name_buf.as_mut_ptr() as i32,
            name_buf.len() as i32,
            &mut name_len as *mut u32 as i32,
            &mut actual_bw as *mut u64 as i32,
        )
    };
    match FabricError::from_status(status) {
        None => {
            let name = core::str::from_utf8(&name_buf[..name_len as usize]).unwrap_or("unknown");
            Ok((alloc::string::String::from(name), actual_bw))
        }
        Some(e) => Err(e),
    }
}

// ---------------------------------------------------------------------------
// Native target: mock implementations for testing
// ---------------------------------------------------------------------------

#[cfg(not(target_arch = "wasm32"))]
mod mock {
    extern crate alloc;
    use super::{LEASE_STATUS_ACTIVE, LEASE_STATUS_EXPIRED, LEASE_STATUS_REVOKED};
    use alloc::collections::BTreeMap;
    use alloc::vec::Vec;

    pub struct MockFbmu {
        pub arena: BTreeMap<u64, Vec<u8>>,
        pub arena_size: u64,
        pub hello_called: bool,
    }

    impl Default for MockFbmu {
        fn default() -> Self {
            MockFbmu {
                arena: BTreeMap::new(),
                arena_size: 65536,
                hello_called: false,
            }
        }
    }

    pub struct MockFbbu {
        pub blocks: BTreeMap<u64, [u8; 512]>,
        pub num_blocks: u64,
        pub hello_called: bool,
    }

    impl Default for MockFbbu {
        fn default() -> Self {
            MockFbbu {
                blocks: BTreeMap::new(),
                num_blocks: 1024,
                hello_called: false,
            }
        }
    }

    pub struct MockFbmuLease {
        pub status: u8,
        pub expires_at_unix_secs: u64,
        pub arena_size: u64,
        pub arena: BTreeMap<u64, Vec<u8>>,
    }

    pub struct MockFbbuLease {
        pub status: u8,
        pub expires_at_unix_secs: u64,
        pub block_size: u32,
        pub num_blocks: u64,
        pub blocks: BTreeMap<u64, [u8; 512]>,
    }

    #[derive(Default)]
    pub struct MockTasklet {
        /// Pre-configured exit code for tasklet submissions.
        pub exit_code: u64,
        /// Pre-configured output for tasklet submissions.
        pub output: Vec<u8>,
        /// Number of submit calls made.
        pub submit_count: u64,
    }

    #[derive(Default)]
    pub struct MockGpu {
        /// Session: next allocation handle.
        pub session_next_handle: u64,
        /// Session: next module_id.
        pub session_next_module: u64,
        /// Session: number of session ops performed.
        pub session_op_count: u64,
        /// Session: number of `mem_free` ops performed (Phase 48.16 SDK
        /// polish — used by the RAII Drop tests in
        /// `crates/grafos-std/src/gpu.rs`).
        pub session_mem_free_count: u64,
        /// Session: number of `module_unload` ops performed (Phase 48.16
        /// SDK polish — used by the GpuModule RAII Drop tests in
        /// `crates/grafos-std/src/gpu.rs`).
        pub session_module_unload_count: u64,
        /// When set, session ops return this error code.
        pub session_error: Option<i32>,
        /// Lease: next lease_id counter.
        pub lease_next_id: u128,
        /// Lease: set of active lease IDs.
        pub lease_active: BTreeMap<u128, ()>,
        /// When set, lease ops return this error code.
        pub lease_error: Option<i32>,
    }

    pub struct MockNet {
        /// Pre-configured interface name.
        pub interface_name: alloc::string::String,
        /// Pre-configured bandwidth in bits per second.
        pub bandwidth: u64,
    }

    impl Default for MockNet {
        fn default() -> Self {
            MockNet {
                interface_name: alloc::string::String::from("eth-mock0"),
                bandwidth: 1_000_000_000,
            }
        }
    }

    pub struct MockState {
        pub fbmu: MockFbmu,
        pub fbbu: MockFbbu,
        pub fbmu_leases: BTreeMap<u128, MockFbmuLease>,
        pub fbbu_leases: BTreeMap<u128, MockFbbuLease>,
        pub next_lease_seq: u64,
        pub tasklet: MockTasklet,
        pub gpu: MockGpu,
        pub net: MockNet,
        /// Mock unix time used by lease lifecycle logic.
        pub now_unix_secs: u64,
        /// When set, fbmu_hello returns this error code.
        pub fbmu_hello_error: Option<i32>,
        /// When set, fbbu_hello returns this error code.
        pub fbbu_hello_error: Option<i32>,
        /// When set, tasklet_submit returns this error code.
        pub tasklet_submit_error: Option<i32>,
        /// When set, net_hello returns this error code.
        pub net_hello_error: Option<i32>,
    }

    impl Default for MockState {
        fn default() -> Self {
            MockState {
                fbmu: MockFbmu::default(),
                fbbu: MockFbbu::default(),
                fbmu_leases: BTreeMap::new(),
                fbbu_leases: BTreeMap::new(),
                next_lease_seq: 1,
                tasklet: MockTasklet::default(),
                gpu: MockGpu::default(),
                net: MockNet::default(),
                now_unix_secs: 1_700_000_000,
                fbmu_hello_error: None,
                fbbu_hello_error: None,
                tasklet_submit_error: None,
                net_hello_error: None,
            }
        }
    }

    #[cfg(feature = "std")]
    thread_local! {
        pub static MOCK: std::cell::RefCell<MockState> = std::cell::RefCell::new(MockState::default());
    }

    // Without std, we use a static mutex via a simple spin lock.
    // This is only for native testing — not production.
    #[cfg(not(feature = "std"))]
    mod nostd_mock {
        use super::MockState;
        use core::sync::atomic::{AtomicBool, Ordering};

        static LOCK: AtomicBool = AtomicBool::new(false);
        static mut STATE: Option<MockState> = None;

        pub fn with_mock<F, R>(f: F) -> R
        where
            F: FnOnce(&mut MockState) -> R,
        {
            while LOCK
                .compare_exchange_weak(false, true, Ordering::Acquire, Ordering::Relaxed)
                .is_err()
            {
                core::hint::spin_loop();
            }
            let state = unsafe {
                if STATE.is_none() {
                    STATE = Some(MockState::default());
                }
                STATE.as_mut().unwrap()
            };
            let result = f(state);
            LOCK.store(false, Ordering::Release);
            result
        }
    }

    pub fn with_mock<F, R>(f: F) -> R
    where
        F: FnOnce(&mut MockState) -> R,
    {
        #[cfg(feature = "std")]
        {
            MOCK.with(|cell| f(&mut cell.borrow_mut()))
        }
        #[cfg(not(feature = "std"))]
        {
            nostd_mock::with_mock(f)
        }
    }

    fn next_lease_id(state: &mut MockState, tag: u8) -> u128 {
        let seq = state.next_lease_seq as u128;
        state.next_lease_seq = state.next_lease_seq.saturating_add(1);
        ((state.now_unix_secs as u128) << 64) | ((tag as u128) << 56) | seq
    }

    fn refresh_fbmu_leases(state: &mut MockState) {
        let now = state.now_unix_secs;
        for lease in state.fbmu_leases.values_mut() {
            if lease.status == LEASE_STATUS_ACTIVE && now >= lease.expires_at_unix_secs {
                lease.status = LEASE_STATUS_EXPIRED;
            }
        }
    }

    fn refresh_fbbu_leases(state: &mut MockState) {
        let now = state.now_unix_secs;
        for lease in state.fbbu_leases.values_mut() {
            if lease.status == LEASE_STATUS_ACTIVE && now >= lease.expires_at_unix_secs {
                lease.status = LEASE_STATUS_EXPIRED;
            }
        }
    }

    pub fn fbmu_hello_impl() -> i32 {
        with_mock(|s| {
            if let Some(err) = s.fbmu_hello_error {
                return err;
            }
            s.fbmu.hello_called = true;
            0
        })
    }

    pub fn fbmu_write_impl(offset: u64, data: &[u8]) -> i32 {
        with_mock(|s| {
            s.fbmu.arena.insert(offset, data.to_vec());
            0
        })
    }

    pub fn fbmu_read_impl(offset: u64, buf: &mut [u8]) -> i32 {
        with_mock(|s| {
            if let Some(data) = s.fbmu.arena.get(&offset) {
                let len = buf.len().min(data.len());
                buf[..len].copy_from_slice(&data[..len]);
                len as i32
            } else {
                // Return zeroed data of requested length
                for b in buf.iter_mut() {
                    *b = 0;
                }
                buf.len() as i32
            }
        })
    }

    pub fn fbmu_get_arena_size_impl() -> i64 {
        with_mock(|s| s.fbmu.arena_size as i64)
    }

    pub fn fbmu_alloc_impl(min_bytes: u64, lease_secs: u64) -> (i32, u128, u64, u64) {
        with_mock(|s| {
            if s.fbmu.arena_size < min_bytes {
                return (-4, 0, 0, 0);
            }
            let lease_id = next_lease_id(s, 0x01);
            let expires = s.now_unix_secs.saturating_add(lease_secs.max(1));
            let lease = MockFbmuLease {
                status: LEASE_STATUS_ACTIVE,
                expires_at_unix_secs: expires,
                arena_size: s.fbmu.arena_size,
                arena: BTreeMap::new(),
            };
            s.fbmu_leases.insert(lease_id, lease);
            (0, lease_id, expires, s.fbmu.arena_size)
        })
    }

    pub fn fbmu_query_impl(lease_id: u128) -> (i32, u8, u64, u64) {
        with_mock(|s| {
            refresh_fbmu_leases(s);
            let Some(lease) = s.fbmu_leases.get(&lease_id) else {
                return (-2, LEASE_STATUS_REVOKED, 0, 0);
            };
            (
                0,
                lease.status,
                lease.expires_at_unix_secs,
                lease.arena_size,
            )
        })
    }

    pub fn fbmu_renew_impl(lease_id: u128, duration_secs: u64) -> (i32, u64) {
        with_mock(|s| {
            if duration_secs == 0 {
                return (-1, 0);
            }
            refresh_fbmu_leases(s);
            let Some(lease) = s.fbmu_leases.get_mut(&lease_id) else {
                return (-2, 0);
            };
            if lease.status != LEASE_STATUS_ACTIVE {
                return (-2, lease.expires_at_unix_secs);
            }
            let requested_exp = s.now_unix_secs.saturating_add(duration_secs);
            if requested_exp > lease.expires_at_unix_secs {
                lease.expires_at_unix_secs = requested_exp;
            }
            (0, lease.expires_at_unix_secs)
        })
    }

    pub fn fbmu_free_impl(lease_id: u128) -> i32 {
        with_mock(|s| {
            refresh_fbmu_leases(s);
            let Some(lease) = s.fbmu_leases.get_mut(&lease_id) else {
                return -2;
            };
            lease.status = LEASE_STATUS_REVOKED;
            0
        })
    }

    pub fn fbmu_write_lease_impl(lease_id: u128, offset: u64, data: &[u8]) -> i32 {
        with_mock(|s| {
            refresh_fbmu_leases(s);
            let Some(lease) = s.fbmu_leases.get_mut(&lease_id) else {
                return -2;
            };
            if lease.status != LEASE_STATUS_ACTIVE {
                return -2;
            }
            let end = match offset.checked_add(data.len() as u64) {
                Some(v) => v,
                None => return -4,
            };
            if end > lease.arena_size {
                return -4;
            }
            lease.arena.insert(offset, data.to_vec());
            0
        })
    }

    pub fn fbmu_read_lease_impl(lease_id: u128, offset: u64, buf: &mut [u8]) -> i32 {
        with_mock(|s| {
            refresh_fbmu_leases(s);
            let Some(lease) = s.fbmu_leases.get_mut(&lease_id) else {
                return -2;
            };
            if lease.status != LEASE_STATUS_ACTIVE {
                return -2;
            }
            if offset >= lease.arena_size {
                return -4;
            }
            let max_len = (lease.arena_size - offset) as usize;
            let read_len = buf.len().min(max_len);
            for b in buf.iter_mut().take(read_len) {
                *b = 0;
            }
            if let Some(data) = lease.arena.get(&offset) {
                let copy_len = read_len.min(data.len());
                buf[..copy_len].copy_from_slice(&data[..copy_len]);
            }
            read_len as i32
        })
    }

    pub fn fbbu_hello_impl() -> i32 {
        with_mock(|s| {
            if let Some(err) = s.fbbu_hello_error {
                return err;
            }
            s.fbbu.hello_called = true;
            0
        })
    }

    pub fn fbbu_write_block_impl(lba: u64, data: &[u8; 512]) -> i32 {
        with_mock(|s| {
            if lba >= s.fbbu.num_blocks {
                return -4; // CapacityExceeded
            }
            s.fbbu.blocks.insert(lba, *data);
            0
        })
    }

    pub fn fbbu_read_block_impl(lba: u64, buf: &mut [u8; 512]) -> i32 {
        with_mock(|s| {
            if lba >= s.fbbu.num_blocks {
                return -4; // CapacityExceeded
            }
            if let Some(block) = s.fbbu.blocks.get(&lba) {
                *buf = *block;
            } else {
                *buf = [0u8; 512];
            }
            0
        })
    }

    pub fn fbbu_get_num_blocks_impl() -> i64 {
        with_mock(|s| s.fbbu.num_blocks as i64)
    }

    pub fn fbbu_alloc_impl(min_blocks: u64, lease_secs: u64) -> (i32, u128, u64, u64, u32) {
        with_mock(|s| {
            if s.fbbu.num_blocks < min_blocks {
                return (-4, 0, 0, 0, 0);
            }
            let lease_id = next_lease_id(s, 0x02);
            let expires = s.now_unix_secs.saturating_add(lease_secs.max(1));
            let lease = MockFbbuLease {
                status: LEASE_STATUS_ACTIVE,
                expires_at_unix_secs: expires,
                block_size: 512,
                num_blocks: s.fbbu.num_blocks,
                blocks: BTreeMap::new(),
            };
            s.fbbu_leases.insert(lease_id, lease);
            (0, lease_id, expires, s.fbbu.num_blocks, 512)
        })
    }

    pub fn fbbu_query_impl(lease_id: u128) -> (i32, u8, u64, u64, u32) {
        with_mock(|s| {
            refresh_fbbu_leases(s);
            let Some(lease) = s.fbbu_leases.get(&lease_id) else {
                return (-2, LEASE_STATUS_REVOKED, 0, 0, 0);
            };
            (
                0,
                lease.status,
                lease.expires_at_unix_secs,
                lease.num_blocks,
                lease.block_size,
            )
        })
    }

    pub fn fbbu_renew_impl(lease_id: u128, duration_secs: u64) -> (i32, u64) {
        with_mock(|s| {
            if duration_secs == 0 {
                return (-1, 0);
            }
            refresh_fbbu_leases(s);
            let Some(lease) = s.fbbu_leases.get_mut(&lease_id) else {
                return (-2, 0);
            };
            if lease.status != LEASE_STATUS_ACTIVE {
                return (-2, lease.expires_at_unix_secs);
            }
            let requested_exp = s.now_unix_secs.saturating_add(duration_secs);
            if requested_exp > lease.expires_at_unix_secs {
                lease.expires_at_unix_secs = requested_exp;
            }
            (0, lease.expires_at_unix_secs)
        })
    }

    pub fn fbbu_free_impl(lease_id: u128) -> i32 {
        with_mock(|s| {
            refresh_fbbu_leases(s);
            let Some(lease) = s.fbbu_leases.get_mut(&lease_id) else {
                return -2;
            };
            lease.status = LEASE_STATUS_REVOKED;
            0
        })
    }

    pub fn fbbu_write_block_lease_impl(lease_id: u128, lba: u64, data: &[u8; 512]) -> i32 {
        with_mock(|s| {
            refresh_fbbu_leases(s);
            let Some(lease) = s.fbbu_leases.get_mut(&lease_id) else {
                return -2;
            };
            if lease.status != LEASE_STATUS_ACTIVE {
                return -2;
            }
            if lba >= lease.num_blocks {
                return -4;
            }
            lease.blocks.insert(lba, *data);
            0
        })
    }

    pub fn fbbu_read_block_lease_impl(lease_id: u128, lba: u64, buf: &mut [u8; 512]) -> i32 {
        with_mock(|s| {
            refresh_fbbu_leases(s);
            let Some(lease) = s.fbbu_leases.get_mut(&lease_id) else {
                return -2;
            };
            if lease.status != LEASE_STATUS_ACTIVE {
                return -2;
            }
            if lba >= lease.num_blocks {
                return -4;
            }
            if let Some(block) = lease.blocks.get(&lba) {
                *buf = *block;
            } else {
                *buf = [0u8; 512];
            }
            0
        })
    }

    pub fn tasklet_submit_impl(
        _wasm: &[u8],
        _input: &[u8],
        _fuel: u64,
        output_buf: &mut [u8],
    ) -> (i32, u64, usize) {
        with_mock(|s| {
            if let Some(err) = s.tasklet_submit_error {
                return (err, 0, 0);
            }
            s.tasklet.submit_count += 1;
            let out_len = output_buf.len().min(s.tasklet.output.len());
            output_buf[..out_len].copy_from_slice(&s.tasklet.output[..out_len]);
            (0, s.tasklet.exit_code, out_len)
        })
    }

    // ── GPU session mock impls ──────────────────────────────────────────

    pub fn gpu_session_mem_alloc_impl(_lease_id: u128, _size: u64) -> (i32, u64) {
        with_mock(|s| {
            if let Some(err) = s.gpu.session_error {
                return (err, 0);
            }
            s.gpu.session_next_handle += 1;
            s.gpu.session_op_count += 1;
            (0, s.gpu.session_next_handle)
        })
    }

    pub fn gpu_session_mem_write_impl(
        _lease_id: u128,
        _handle: u64,
        _offset: u64,
        _data: &[u8],
    ) -> i32 {
        with_mock(|s| {
            if let Some(err) = s.gpu.session_error {
                return err;
            }
            s.gpu.session_op_count += 1;
            0
        })
    }

    pub fn gpu_session_mem_read_impl(
        _lease_id: u128,
        _handle: u64,
        _offset: u64,
        size: u32,
    ) -> (i32, Vec<u8>) {
        with_mock(|s| {
            if let Some(err) = s.gpu.session_error {
                return (err, Vec::new());
            }
            s.gpu.session_op_count += 1;
            (0, alloc::vec![0u8; size as usize])
        })
    }

    pub fn gpu_session_mem_free_impl(_lease_id: u128, _handle: u64) -> i32 {
        with_mock(|s| {
            if let Some(err) = s.gpu.session_error {
                return err;
            }
            s.gpu.session_op_count += 1;
            s.gpu.session_mem_free_count += 1;
            0
        })
    }

    pub fn gpu_session_module_load_impl(_lease_id: u128, _binary: &[u8]) -> (i32, u64) {
        with_mock(|s| {
            if let Some(err) = s.gpu.session_error {
                return (err, 0);
            }
            s.gpu.session_next_module += 1;
            s.gpu.session_op_count += 1;
            (0, s.gpu.session_next_module)
        })
    }

    pub fn gpu_session_launch_impl(
        _lease_id: u128,
        _module_id: u64,
        _kernel_name: &str,
        _grid_dim: [u32; 3],
        _block_dim: [u32; 3],
        _args: &[u8],
        _arg_sizes: &[u32],
    ) -> i32 {
        with_mock(|s| {
            if let Some(err) = s.gpu.session_error {
                return err;
            }
            s.gpu.session_op_count += 1;
            0
        })
    }

    pub fn gpu_session_sync_impl(_lease_id: u128) -> i32 {
        with_mock(|s| {
            if let Some(err) = s.gpu.session_error {
                return err;
            }
            s.gpu.session_op_count += 1;
            0
        })
    }

    pub fn gpu_session_module_unload_impl(_lease_id: u128, _module_id: u64) -> i32 {
        with_mock(|s| {
            if let Some(err) = s.gpu.session_error {
                return err;
            }
            s.gpu.session_op_count += 1;
            s.gpu.session_module_unload_count += 1;
            0
        })
    }

    // ── GPU lease mock impls ────────────────────────────────────────────

    pub fn gpu_lease_alloc_impl(_resource_id: u128, _lease_secs: u32) -> (i32, u128) {
        with_mock(|s| {
            if let Some(err) = s.gpu.lease_error {
                return (err, 0);
            }
            s.gpu.lease_next_id += 1;
            let id = s.gpu.lease_next_id;
            s.gpu.lease_active.insert(id, ());
            (0, id)
        })
    }

    pub fn gpu_lease_renew_impl(lease_id: u128, _duration_secs: u32) -> i32 {
        with_mock(|s| {
            if let Some(err) = s.gpu.lease_error {
                return err;
            }
            if s.gpu.lease_active.contains_key(&lease_id) {
                0
            } else {
                -1
            }
        })
    }

    pub fn gpu_lease_free_impl(lease_id: u128) -> i32 {
        with_mock(|s| {
            if let Some(err) = s.gpu.lease_error {
                return err;
            }
            s.gpu.lease_active.remove(&lease_id);
            0
        })
    }

    pub fn gpu_lease_query_impl(lease_id: u128) -> (i32, u32) {
        with_mock(|s| {
            if let Some(err) = s.gpu.lease_error {
                return (err, 0);
            }
            if s.gpu.lease_active.contains_key(&lease_id) {
                (0, 0) // active
            } else {
                (0, 1) // expired
            }
        })
    }

    pub fn net_hello_impl(_min_bw: u64) -> (i32, alloc::string::String, u64) {
        with_mock(|s| {
            if let Some(err) = s.net_hello_error {
                return (err, alloc::string::String::new(), 0);
            }
            (0, s.net.interface_name.clone(), s.net.bandwidth)
        })
    }

    /// Phase 48.15 W2a — test helper. Inject a status code that the next
    /// `gpu_session_*` mock op will return. Pass `None` to clear. Used by
    /// the host-mock parity roundtrip test in
    /// `crates/grafos-std/tests/gpu_session_status_translation.rs`.
    pub fn _set_gpu_session_error(err: Option<i32>) {
        with_mock(|s| s.gpu.session_error = err);
    }

    /// Phase 48.15 W2a — test helper. Snapshot the current `session_op_count`
    /// (incremented on every successful mock session op). Lets the parity
    /// test confirm that the happy path actually executed the mock body.
    pub fn _gpu_session_op_count() -> u64 {
        with_mock(|s| s.gpu.session_op_count)
    }

    /// Phase 48.16 SDK polish — snapshot the number of `mem_free` ops
    /// the mock has observed. Used by the RAII Drop tests in
    /// `crates/grafos-std/src/gpu.rs` to verify that handle Drop
    /// actually issues a free hostcall.
    pub fn _gpu_session_mem_free_count() -> u64 {
        with_mock(|s| s.gpu.session_mem_free_count)
    }

    /// Phase 48.16 SDK polish — snapshot the number of `module_unload`
    /// ops the mock has observed. Used by the GpuModule RAII Drop
    /// tests in `crates/grafos-std/src/gpu.rs`.
    pub fn _gpu_session_module_unload_count() -> u64 {
        with_mock(|s| s.gpu.session_module_unload_count)
    }
}

/// Test-only re-exports for the host mock. Hidden from rustdoc; the
/// `_`-prefixed names emphasize the test-only contract.
#[cfg(not(target_arch = "wasm32"))]
#[doc(hidden)]
pub mod test_mock {
    pub use super::mock::{
        _gpu_session_mem_free_count, _gpu_session_module_unload_count, _gpu_session_op_count,
        _set_gpu_session_error,
    };
}

/// Perform the FBMU HELLO handshake with the host.
///
/// Establishes the memory data-plane session. Must be called before any
/// FBMU read/write operations.
///
/// # Errors
///
/// Returns [`FabricError::Disconnected`] if the host connection is not
/// available, or another [`FabricError`] variant based on the host status
/// code.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbmu_hello() -> Result<()> {
    let status = mock::fbmu_hello_impl();
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Write `data` to the FBMU arena at the given byte `offset`.
///
/// # Errors
///
/// Returns a [`FabricError`] if the host reports a write failure.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbmu_write(offset: u64, data: &[u8]) -> Result<()> {
    let status = mock::fbmu_write_impl(offset, data);
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Read from the FBMU arena at `offset` into `buf`.
///
/// Returns the number of bytes actually read, which may be less than
/// `buf.len()` if the arena region is shorter.
///
/// # Errors
///
/// Returns a [`FabricError`] if the host reports a read failure.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbmu_read(offset: u64, buf: &mut [u8]) -> Result<usize> {
    let n = mock::fbmu_read_impl(offset, buf);
    if n < 0 {
        Err(FabricError::from_status(n).unwrap_or(FabricError::IoError(n)))
    } else {
        Ok(n as usize)
    }
}

/// Query the total FBMU arena size in bytes.
///
/// # Errors
///
/// Returns [`FabricError::IoError`] if the host returns a negative value.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbmu_get_arena_size() -> Result<u64> {
    let size = mock::fbmu_get_arena_size_impl();
    if size < 0 {
        Err(FabricError::IoError(size as i32))
    } else {
        Ok(size as u64)
    }
}

/// Allocate a memory lease from FBMU with the requested minimum capacity and TTL.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbmu_alloc(min_bytes: u64, lease_secs: u64) -> Result<FbmuLeaseInfo> {
    let (status, lease_id, expires_at_unix_secs, arena_size) =
        mock::fbmu_alloc_impl(min_bytes, lease_secs);
    match FabricError::from_status(status) {
        None => Ok(FbmuLeaseInfo {
            lease_id,
            expires_at_unix_secs,
            arena_size,
            status: LEASE_STATUS_ACTIVE,
        }),
        Some(e) => Err(e),
    }
}

/// Query FBMU lease status and capacity metadata.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbmu_query(lease_id: u128) -> Result<FbmuLeaseInfo> {
    let (status, lease_status, expires_at_unix_secs, arena_size) = mock::fbmu_query_impl(lease_id);
    match FabricError::from_status(status) {
        None => Ok(FbmuLeaseInfo {
            lease_id,
            expires_at_unix_secs,
            arena_size,
            status: lease_status,
        }),
        Some(e) => Err(e),
    }
}

/// Renew an FBMU lease and return the updated expiry timestamp.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbmu_renew(lease_id: u128, duration_secs: u64) -> Result<u64> {
    let (status, expires_at_unix_secs) = mock::fbmu_renew_impl(lease_id, duration_secs);
    match FabricError::from_status(status) {
        None => Ok(expires_at_unix_secs),
        Some(e) => Err(e),
    }
}

/// Free/revoke an FBMU lease.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbmu_free(lease_id: u128) -> Result<()> {
    let status = mock::fbmu_free_impl(lease_id);
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Write to FBMU using an explicit lease id.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbmu_write_lease(lease_id: u128, offset: u64, data: &[u8]) -> Result<()> {
    let status = mock::fbmu_write_lease_impl(lease_id, offset, data);
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Read from FBMU using an explicit lease id.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbmu_read_lease(lease_id: u128, offset: u64, buf: &mut [u8]) -> Result<usize> {
    let n = mock::fbmu_read_lease_impl(lease_id, offset, buf);
    if n < 0 {
        Err(FabricError::from_status(n).unwrap_or(FabricError::IoError(n)))
    } else {
        Ok(n as usize)
    }
}

/// Perform the FBBU HELLO handshake with the host.
///
/// Establishes the block data-plane session. Must be called before any
/// FBBU read/write operations.
///
/// # Errors
///
/// Returns [`FabricError::Disconnected`] if the host connection is not
/// available.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbbu_hello() -> Result<()> {
    let status = mock::fbbu_hello_impl();
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Write a single 512-byte block at the given logical block address.
///
/// # Errors
///
/// Returns [`FabricError::CapacityExceeded`] if `lba` is beyond the
/// device's block count.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbbu_write_block(lba: u64, data: &[u8; 512]) -> Result<()> {
    let status = mock::fbbu_write_block_impl(lba, data);
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Read a single 512-byte block at the given logical block address.
///
/// # Errors
///
/// Returns [`FabricError::CapacityExceeded`] if `lba` is beyond the
/// device's block count.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbbu_read_block(lba: u64, buf: &mut [u8; 512]) -> Result<()> {
    let status = mock::fbbu_read_block_impl(lba, buf);
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Query the total number of blocks available on the FBBU device.
///
/// # Errors
///
/// Returns [`FabricError::IoError`] if the host returns a negative value.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbbu_get_num_blocks() -> Result<u64> {
    let n = mock::fbbu_get_num_blocks_impl();
    if n < 0 {
        Err(FabricError::IoError(n as i32))
    } else {
        Ok(n as u64)
    }
}

/// Allocate a block lease from FBBU with the requested minimum capacity and TTL.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbbu_alloc(min_blocks: u64, lease_secs: u64) -> Result<FbbuLeaseInfo> {
    let (status, lease_id, expires_at_unix_secs, num_blocks, block_size) =
        mock::fbbu_alloc_impl(min_blocks, lease_secs);
    match FabricError::from_status(status) {
        None => Ok(FbbuLeaseInfo {
            lease_id,
            expires_at_unix_secs,
            num_blocks,
            block_size,
            status: LEASE_STATUS_ACTIVE,
        }),
        Some(e) => Err(e),
    }
}

/// Query FBBU lease status and geometry metadata.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbbu_query(lease_id: u128) -> Result<FbbuLeaseInfo> {
    let (status, lease_status, expires_at_unix_secs, num_blocks, block_size) =
        mock::fbbu_query_impl(lease_id);
    match FabricError::from_status(status) {
        None => Ok(FbbuLeaseInfo {
            lease_id,
            expires_at_unix_secs,
            num_blocks,
            block_size,
            status: lease_status,
        }),
        Some(e) => Err(e),
    }
}

/// Renew an FBBU lease and return the updated expiry timestamp.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbbu_renew(lease_id: u128, duration_secs: u64) -> Result<u64> {
    let (status, expires_at_unix_secs) = mock::fbbu_renew_impl(lease_id, duration_secs);
    match FabricError::from_status(status) {
        None => Ok(expires_at_unix_secs),
        Some(e) => Err(e),
    }
}

/// Free/revoke an FBBU lease.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbbu_free(lease_id: u128) -> Result<()> {
    let status = mock::fbbu_free_impl(lease_id);
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Write a 512-byte block via FBBU using an explicit lease id.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbbu_write_block_lease(lease_id: u128, lba: u64, data: &[u8; 512]) -> Result<()> {
    let status = mock::fbbu_write_block_lease_impl(lease_id, lba, data);
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Read a 512-byte block via FBBU using an explicit lease id.
#[cfg(not(target_arch = "wasm32"))]
pub fn fbbu_read_block_lease(lease_id: u128, lba: u64, buf: &mut [u8; 512]) -> Result<()> {
    let status = mock::fbbu_read_block_lease_impl(lease_id, lba, buf);
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Submit a WASM tasklet for execution on a fabric CPU resource.
///
/// # Parameters
///
/// - `wasm`: The WASM module bytes to execute.
/// - `input`: Input data passed to the tasklet.
/// - `fuel`: WASM fuel limit (instruction budget).
/// - `output_buf`: Buffer for tasklet output.
///
/// # Returns
///
/// On success, returns `(exit_code, output_len)`.
///
/// # Errors
///
/// Returns a [`FabricError`] if the submission fails.
#[cfg(not(target_arch = "wasm32"))]
pub fn tasklet_submit(
    wasm: &[u8],
    input: &[u8],
    fuel: u64,
    output_buf: &mut [u8],
) -> Result<(u64, usize)> {
    let (status, exit_code, output_len) = mock::tasklet_submit_impl(wasm, input, fuel, output_buf);
    match FabricError::from_status(status) {
        None => Ok((exit_code, output_len)),
        Some(e) => Err(e),
    }
}

// ---------------------------------------------------------------------------
// GPU session host functions (non-WASM mock implementations)
// ---------------------------------------------------------------------------

/// Allocate device memory within a GPU session.
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_session_mem_alloc(lease_id: u128, size: u64) -> Result<u64> {
    let (status, handle) = mock::gpu_session_mem_alloc_impl(lease_id, size);
    // Phase 48.15 W2a — go through `session_status_to_result` so positive
    // SESSION_STATUS_* codes injected via the mock surface as
    // `FabricError::GpuSessionFailed(u8)`, matching the wasm32 path.
    session_status_to_result(status).map(|()| handle)
}

/// Write data to device memory within a GPU session.
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_session_mem_write(lease_id: u128, handle: u64, offset: u64, data: &[u8]) -> Result<()> {
    let status = mock::gpu_session_mem_write_impl(lease_id, handle, offset, data);
    session_status_to_result(status)
}

/// Read data from device memory within a GPU session.
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_session_mem_read(
    lease_id: u128,
    handle: u64,
    offset: u64,
    size: u32,
) -> Result<Vec<u8>> {
    let (status, data) = mock::gpu_session_mem_read_impl(lease_id, handle, offset, size);
    session_status_to_result(status).map(|()| data)
}

/// Free device memory within a GPU session.
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_session_mem_free(lease_id: u128, handle: u64) -> Result<()> {
    let status = mock::gpu_session_mem_free_impl(lease_id, handle);
    session_status_to_result(status)
}

/// Load a GPU module within a GPU session.
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_session_module_load(lease_id: u128, binary: &[u8]) -> Result<u64> {
    let (status, module_id) = mock::gpu_session_module_load_impl(lease_id, binary);
    session_status_to_result(status).map(|()| module_id)
}

/// Launch a kernel within a GPU session.
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_session_launch(
    lease_id: u128,
    module_id: u64,
    kernel_name: &str,
    grid_dim: [u32; 3],
    block_dim: [u32; 3],
    args: &[u8],
    arg_sizes: &[u32],
) -> Result<()> {
    let status = mock::gpu_session_launch_impl(
        lease_id,
        module_id,
        kernel_name,
        grid_dim,
        block_dim,
        args,
        arg_sizes,
    );
    session_status_to_result(status)
}

/// Synchronize a GPU session.
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_session_sync(lease_id: u128) -> Result<()> {
    let status = mock::gpu_session_sync_impl(lease_id);
    session_status_to_result(status)
}

/// Unload a GPU module within a GPU session (Phase 48.16 SDK polish).
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_session_module_unload(lease_id: u128, module_id: u64) -> Result<()> {
    let status = mock::gpu_session_module_unload_impl(lease_id, module_id);
    session_status_to_result(status)
}

// ---------------------------------------------------------------------------
// GPU lease lifecycle (native mock)
// ---------------------------------------------------------------------------

/// Allocate a GPU lease for the given resource.
/// Returns an opaque lease_id on success.
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_lease_alloc(resource_id: u128, lease_secs: u32) -> Result<u128> {
    let (status, lease_id) = mock::gpu_lease_alloc_impl(resource_id, lease_secs);
    match FabricError::from_status(status) {
        None => Ok(lease_id),
        Some(e) => Err(e),
    }
}

/// Renew an existing GPU lease.
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_lease_renew(lease_id: u128, duration_secs: u32) -> Result<()> {
    let status = mock::gpu_lease_renew_impl(lease_id, duration_secs);
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Free/revoke a GPU lease.
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_lease_free(lease_id: u128) -> Result<()> {
    let status = mock::gpu_lease_free_impl(lease_id);
    match FabricError::from_status(status) {
        None => Ok(()),
        Some(e) => Err(e),
    }
}

/// Query the status of a GPU lease.
/// Returns a status code (0=active, 1=expired, 2=revoked, 3=fenced).
#[cfg(not(target_arch = "wasm32"))]
pub fn gpu_lease_query(lease_id: u128) -> Result<u32> {
    let (status, lease_status) = mock::gpu_lease_query_impl(lease_id);
    match FabricError::from_status(status) {
        None => Ok(lease_status),
        Some(e) => Err(e),
    }
}

/// Reset all mock state to defaults.
///
/// Restores the FBMU arena to 65536 bytes, the FBBU block count to 1024,
/// and clears all stored data and error injections. Call this at the start
/// of each test to ensure a clean slate.
///
/// Only available on native (non-WASM) targets.
#[cfg(not(target_arch = "wasm32"))]
pub fn reset_mock() {
    mock::with_mock(|s| {
        *s = mock::MockState::default();
    });
}

/// Return the current unix time in seconds used by lease lifecycle logic.
///
/// On native targets this returns the mock clock value so tests can control
/// lease expiry deterministically. On WASM targets this currently returns 0.
#[cfg(not(target_arch = "wasm32"))]
pub fn unix_time_secs() -> u64 {
    mock::with_mock(|s| s.now_unix_secs)
}

/// Return the current unix time in seconds used by lease lifecycle logic.
#[cfg(target_arch = "wasm32")]
pub fn unix_time_secs() -> u64 {
    0
}

/// Set the mock FBMU arena size in bytes.
///
/// Controls the value returned by [`fbmu_get_arena_size`]. Used to test
/// capacity checks in [`MemBuilder::acquire`](crate::mem::MemBuilder::acquire).
///
/// Only available on native (non-WASM) targets.
#[cfg(not(target_arch = "wasm32"))]
pub fn mock_set_fbmu_arena_size(size: u64) {
    mock::with_mock(|s| {
        s.fbmu.arena_size = size;
    });
}

/// Set the mock unix time used by lease lifecycle logic.
///
/// Only available on native (non-WASM) targets.
#[cfg(not(target_arch = "wasm32"))]
pub fn mock_set_unix_time_secs(secs: u64) {
    mock::with_mock(|s| {
        s.now_unix_secs = secs;
    });
}

/// Advance the mock unix time by `delta_secs`.
///
/// Only available on native (non-WASM) targets.
#[cfg(not(target_arch = "wasm32"))]
pub fn mock_advance_time_secs(delta_secs: u64) {
    mock::with_mock(|s| {
        s.now_unix_secs = s.now_unix_secs.saturating_add(delta_secs);
    });
}

/// Set the mock FBBU block count.
///
/// Controls the value returned by [`fbbu_get_num_blocks`] and the upper
/// bound for LBA validation. Used to test capacity checks in
/// [`BlockBuilder::acquire`](crate::block::BlockBuilder::acquire).
///
/// Only available on native (non-WASM) targets.
#[cfg(not(target_arch = "wasm32"))]
pub fn mock_set_fbbu_num_blocks(n: u64) {
    mock::with_mock(|s| {
        s.fbbu.num_blocks = n;
    });
}

/// Inject an error into the mock FBMU HELLO handshake.
///
/// When `code` is `Some(status)`, [`fbmu_hello`] will return the
/// corresponding [`FabricError`] instead of
/// succeeding. Pass `None` to restore normal behavior.
///
/// Only available on native (non-WASM) targets.
#[cfg(not(target_arch = "wasm32"))]
pub fn mock_set_fbmu_hello_error(code: Option<i32>) {
    mock::with_mock(|s| {
        s.fbmu_hello_error = code;
    });
}

/// Inject an error into the mock FBBU HELLO handshake.
///
/// When `code` is `Some(status)`, [`fbbu_hello`] will return the
/// corresponding [`FabricError`] instead of
/// succeeding. Pass `None` to restore normal behavior.
///
/// Only available on native (non-WASM) targets.
#[cfg(not(target_arch = "wasm32"))]
pub fn mock_set_fbbu_hello_error(code: Option<i32>) {
    mock::with_mock(|s| {
        s.fbbu_hello_error = code;
    });
}

/// Configure the mock tasklet exit code and output. Only available on native targets.
#[cfg(not(target_arch = "wasm32"))]
pub fn mock_set_tasklet_result(exit_code: u64, output: &[u8]) {
    mock::with_mock(|s| {
        s.tasklet.exit_code = exit_code;
        s.tasklet.output = output.to_vec();
    });
}

/// Make mock tasklet_submit return an error. Only available on native targets.
#[cfg(not(target_arch = "wasm32"))]
pub fn mock_set_tasklet_submit_error(code: Option<i32>) {
    mock::with_mock(|s| {
        s.tasklet_submit_error = code;
    });
}

/// Acquire a network interface with the given minimum bandwidth.
///
/// # Parameters
///
/// - `min_bw`: Minimum bandwidth in bits per second.
///
/// # Returns
///
/// On success, returns `(interface_name, actual_bandwidth)`.
///
/// # Errors
///
/// Returns a [`FabricError`] if the acquisition fails.
#[cfg(not(target_arch = "wasm32"))]
pub fn net_hello(min_bw: u64) -> Result<(alloc::string::String, u64)> {
    let (status, name, bw) = mock::net_hello_impl(min_bw);
    match FabricError::from_status(status) {
        None => Ok((name, bw)),
        Some(e) => Err(e),
    }
}

/// Configure the mock network interface name and bandwidth. Only available on native targets.
#[cfg(not(target_arch = "wasm32"))]
pub fn mock_set_net_interface(name: &str, bandwidth: u64) {
    mock::with_mock(|s| {
        s.net.interface_name = alloc::string::String::from(name);
        s.net.bandwidth = bandwidth;
    });
}

/// Make mock net_hello return an error. Only available on native targets.
#[cfg(not(target_arch = "wasm32"))]
pub fn mock_set_net_hello_error(code: Option<i32>) {
    mock::with_mock(|s| {
        s.net_hello_error = code;
    });
}