rsscript: Tensor.f32_to_le_bytes / f32_from_le_bytes (device-buffer serialization)

The fused-backend realize path needs to populate device exec-context buffers from
host float data and read results back. The native bitcast can't be used (its f64
widening loses bits above 2^24), and the suite hand-encodes bytes literally. Adds
exact f32<->little-endian-bytes conversion (f32::to_le_bytes / from_le_bytes),
registered in runtime_abi, the reg-VM dispatch, and tensor.rssi. 2 round-trip
tests (incl. a value above 2^24).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: olwang

crates/rsscript/src/reg_vm/mod.rs

@@ -2121,6 +2121,8 @@ enum RegIntrinsic {
     TensorToF32Slice,
     TensorShape,
     TensorRank,
+    TensorF32ToLeBytes,
+    TensorF32FromLeBytes,
     TensorMatmul,
     TensorMatmulMetal,
     TensorMetalAvailable,
@@ -5440,6 +5442,8 @@ fn qualified_intrinsic(namespace: &str, name: &str) -> Option<RegIntrinsic> {
         ("Tensor", "to_f32_slice") => Some(RegIntrinsic::TensorToF32Slice),
         ("Tensor", "shape") => Some(RegIntrinsic::TensorShape),
         ("Tensor", "rank") => Some(RegIntrinsic::TensorRank),
+        ("Tensor", "f32_to_le_bytes") => Some(RegIntrinsic::TensorF32ToLeBytes),
+        ("Tensor", "f32_from_le_bytes") => Some(RegIntrinsic::TensorF32FromLeBytes),
         ("Tensor", "matmul") => Some(RegIntrinsic::TensorMatmul),
         ("Tensor", "matmul_metal") => Some(RegIntrinsic::TensorMatmulMetal),
         ("Tensor", "metal_available") => Some(RegIntrinsic::TensorMetalAvailable),
@@ -9646,6 +9650,26 @@ impl RegVm {
                 let tensor = self.expect_tensor_ref(intrinsic_arg(&self.stack, base, args, 0)?)?;
                 Ok(VmValue::Int(rsscript_runtime::tensor_rank(&tensor)))
             }
+            RegIntrinsic::TensorF32ToLeBytes => {
+                let data = expect_float_list_ref(intrinsic_arg(&self.stack, base, args, 0)?)?;
+                let bytes = rsscript_runtime::tensor_f32_to_le_bytes(&data);
+                Ok(VmValue::List(Rc::new(RefCell::new(
+                    bytes.into_iter().map(VmValue::Int).collect(),
+                ))))
+            }
+            RegIntrinsic::TensorF32FromLeBytes => {
+                let bytes = expect_int_list_ref(intrinsic_arg(&self.stack, base, args, 0)?)?;
+                Ok(json_result(
+                    match rsscript_runtime::tensor_f32_from_le_bytes(&bytes) {
+                        Ok(values) => Ok(VmValue::List(Rc::new(RefCell::new(
+                            values.into_iter().map(VmValue::Float).collect(),
+                        )))),
+                        Err(error) => Err(tensor_error_value(
+                            rsscript_runtime::tensor_error_message(&error),
+                        )),
+                    },
+                ))
+            }
             RegIntrinsic::TensorMatmul => {
                 let a = self.expect_tensor_ref(intrinsic_arg(&self.stack, base, args, 0)?)?;
                 let b = self.expect_tensor_ref(intrinsic_arg(&self.stack, base, args, 1)?)?;

crates/rsscript/src/runtime_abi.rs

@@ -403,6 +403,17 @@ const RUNTIME_INTRINSICS: &[RuntimeIntrinsic] = &[
     ),
     runtime_intrinsic("Tensor", "shape", "rsscript_runtime::tensor_shape"),
     runtime_intrinsic("Tensor", "rank", "rsscript_runtime::tensor_rank"),
+    // f32 <-> little-endian device-buffer bytes (fused-backend buffer plumbing)
+    runtime_intrinsic(
+        "Tensor",
+        "f32_to_le_bytes",
+        "rsscript_runtime::tensor_f32_to_le_bytes",
+    ),
+    runtime_intrinsic(
+        "Tensor",
+        "f32_from_le_bytes",
+        "rsscript_runtime::tensor_f32_from_le_bytes",
+    ),
     runtime_intrinsic("Tensor", "matmul", "rsscript_runtime::tensor_matmul"),
     // Metal GPU compute path
     runtime_intrinsic(

crates/runtime/src/tensor.rs

@@ -203,6 +203,40 @@ pub fn tensor_matmul(a: &RssTensor, b: &RssTensor) -> Result<RssTensor, TensorEr
     })
 }
 
+/// Serialize f32 values (narrowed from the f64 host inputs) to little-endian bytes,
+/// 4 per value, returned as `i64` in `0..=255`. This is the exact byte layout a
+/// CPU/GPU device buffer expects — used by the fused-backend realize path to
+/// populate exec-context buffers from host float data (the native bitcast can't be
+/// used: its f64 widening loses bits above 2^24). Infallible.
+pub fn tensor_f32_to_le_bytes(data: &[f64]) -> Vec<i64> {
+    let mut out = Vec::with_capacity(data.len() * 4);
+    for &value in data {
+        for byte in (value as f32).to_le_bytes() {
+            out.push(byte as i64);
+        }
+    }
+    out
+}
+
+/// Inverse of [`tensor_f32_to_le_bytes`]: decode little-endian f32 bytes (length a
+/// multiple of 4; each `i64` is taken modulo 256) back to f64 values. Used to read
+/// a realized output device buffer back into host floats. Errors if the byte count
+/// is not a multiple of 4.
+pub fn tensor_f32_from_le_bytes(bytes: &[i64]) -> Result<Vec<f64>, TensorError> {
+    if bytes.len() % 4 != 0 {
+        return Err(TensorError::new(format!(
+            "f32_from_le_bytes: byte length {} is not a multiple of 4",
+            bytes.len()
+        )));
+    }
+    let mut out = Vec::with_capacity(bytes.len() / 4);
+    for chunk in bytes.chunks_exact(4) {
+        let raw = [chunk[0] as u8, chunk[1] as u8, chunk[2] as u8, chunk[3] as u8];
+        out.push(f32::from_le_bytes(raw) as f64);
+    }
+    Ok(out)
+}
+
 /// Whether a Metal GPU is available for the native compute path (false off macOS
 /// or when no device is present). Lets the port choose the GPU vs CPU matmul.
 pub fn tensor_metal_available() -> bool {
@@ -2365,6 +2399,26 @@ mod tests {
         );
     }
 
+    #[test]
+    fn f32_le_bytes_round_trip() {
+        // 1.0 -> [0,0,128,63]; round-trips exactly, including a value above 2^24
+        // where the native i32 bitcast would lose precision.
+        let data = [1.0, 2.0, 3.0, 16_777_217.0, -0.5];
+        let bytes = tensor_f32_to_le_bytes(&data);
+        assert_eq!(bytes.len(), data.len() * 4);
+        assert_eq!(&bytes[0..4], &[0, 0, 128, 63]); // 1.0f little-endian
+        let back = tensor_f32_from_le_bytes(&bytes).unwrap();
+        for (g, e) in back.iter().zip(data.iter()) {
+            assert_eq!(*g as f32, *e as f32);
+        }
+    }
+
+    #[test]
+    fn f32_from_le_bytes_rejects_bad_length() {
+        let err = tensor_f32_from_le_bytes(&[0, 0, 128]).unwrap_err();
+        assert!(tensor_error_message(&err).contains("multiple of 4"));
+    }
+
     #[test]
     // Literal π/2 and π test inputs for the sin kernel; the lint wants the
     // `consts::PI` constant, but these are deliberate fixed sample points.

packages/ml/interface/tensor.rssi

@@ -29,6 +29,15 @@ pub native fn Tensor.shape(tensor: read Tensor) -> Result<fresh List<Int>, Tenso
 pub native fn Tensor.rank(tensor: read Tensor) -> Int
     effects(native)
 
+// Serialize f32 values to little-endian device-buffer bytes (4 per value, each in
+// 0..=255). Used by the fused-backend realize path to fill exec-context buffers.
+pub native fn Tensor.f32_to_le_bytes(data: read List<Float>) -> fresh List<Int>
+    effects(native)
+
+// Inverse: decode little-endian f32 bytes (length a multiple of 4) to floats.
+pub native fn Tensor.f32_from_le_bytes(bytes: read List<Int>) -> Result<fresh List<Float>, TensorError>
+    effects(native)
+
 // 2-D × 2-D matrix multiply, contracting the inner dims: (m, k) × (k, n) -> (m,
 // n). Errors on non-rank-2 operands or an inner-dimension mismatch.
 pub native fn Tensor.matmul(