@@ -2,7 +2,9 @@
 
 This example runs Python source on `wasm32-unknown-unknown` in a native Wasmer
 host. The guest has no JavaScript or WASI dependency and no operating-system
-services. It imports only `env.print`. The host rejects any other import.
+services. It imports `env.print`, `env.kv_get`, and `env.kv_put`. The host
+rejects any other import. The `kv` module (`kv.get` / `kv.put`) reads and
+writes byte storage owned by the host; the map is empty for each run.
 
 ## Build and run
 
@@ -37,5 +39,5 @@ python3 test_runtime.py -v \
 
 The existing WASM CI job runs these checks.
 
-This is a no-OS build: `Interpreter::without_stdlib`, only `env.print`, a fixed
-hash seed, and unsupported entropy.
+This is a no-OS build: `Interpreter::builder` with a native `kv` module, host-lent
+storage, a fixed hash seed, and unsupported entropy.
@@ -1,8 +1,10 @@
-use rustpython_vm::{Interpreter, Settings};
+use rustpython_vm::{Interpreter, Settings, pymodule};
 
 #[link(wasm_import_module = "env")]
 unsafe extern "C" {
     fn print(p: i32, l: i32) -> i32;
+    fn kv_put(key_ptr: i32, key_len: i32, value_ptr: i32, value_len: i32) -> i32;
+    fn kv_get(key_ptr: i32, key_len: i32, buf_ptr: i32, buf_len: i32) -> i32;
 }
 
 // The host writes source into guest-owned memory before calling eval.
@@ -15,6 +17,45 @@ fn report(message: &str) {
     unsafe { print(message.as_ptr() as i32, message.len() as i32) };
 }
 
+#[pymodule]
+mod kv {
+    use rustpython_vm::builtins::PyBytesRef;
+
+    #[pyfunction]
+    fn put(key: PyBytesRef, value: PyBytesRef) {
+        let key = key.as_bytes();
+        let value = value.as_bytes();
+        unsafe {
+            super::kv_put(
+                key.as_ptr() as i32,
+                key.len() as i32,
+                value.as_ptr() as i32,
+                value.len() as i32,
+            );
+        }
+    }
+
+    #[pyfunction]
+    fn get(key: PyBytesRef) -> Option<Vec<u8>> {
+        let key = key.as_bytes();
+        let key_ptr = key.as_ptr() as i32;
+        let key_len = key.len() as i32;
+        let mut buf = vec![0u8; 64];
+        loop {
+            let len = unsafe {
+                super::kv_get(key_ptr, key_len, buf.as_mut_ptr() as i32, buf.len() as i32)
+            };
+            // A negative length means the key is missing.
+            let len = usize::try_from(len).ok()?;
+            if len <= buf.len() {
+                buf.truncate(len);
+                return Some(buf);
+            }
+            buf.resize(len, 0);
+        }
+    }
+}
+
 /// Execute UTF-8 Python source. Return 0 on success, 1 for a Python exception,
 /// or 2 for invalid UTF-8. The result or exception is sent to env.print.
 ///
@@ -33,7 +74,9 @@ pub unsafe extern "C" fn eval(source: *mut u8, len: usize) -> i32 {
     // rather than pretending that the custom getrandom backend produced bytes.
     let mut settings = Settings::default();
     settings.hash_seed = Some(0);
-    let interpreter = Interpreter::without_stdlib(settings);
+    let builder = Interpreter::builder(settings);
+    let def = kv::module_def(&builder.ctx);
+    let interpreter = builder.add_native_module(def).build();
     interpreter.enter(|vm| {
         let scope = vm.new_scope_with_builtins();
         match vm
 
@@ -46,6 +46,20 @@ def __init__(self, value):
 """
         self.assertEqual(self.run_guest("-c", source), "'guest:55:한글'\n")
 
+    def test_host_storage(self):
+        source = """
+import kv
+assert kv.get(b'missing') is None
+kv.put(b'k', b'v')
+assert kv.get(b'k') == b'v'
+kv.put(b'k', b'replaced')
+big = bytes(range(256)) * 64
+kv.put(b'big', big)
+assert kv.get(b'big') == big
+(kv.get(b'k'), len(kv.get(b'big')))
+"""
+        self.assertEqual(self.run_guest("-c", source), "(b'replaced', 16384)\n")
+
     def test_file_source(self):
         with tempfile.TemporaryDirectory() as directory:
             source = Path(directory) / "source with spaces.py"
 
@@ -2,8 +2,16 @@
 
 See the [example README](../README.md) for build, CLI, and test commands.
 
-The guest imports `env.print(ptr: i32, len: i32) -> i32`. The host writes that
-UTF-8 message to stdout followed by a newline.
+The guest imports:
+
+- `env.print(ptr: i32, len: i32) -> i32`: write a UTF-8 message to stdout
+  followed by a newline
+- `env.kv_put(key_ptr: i32, key_len: i32, value_ptr: i32, value_len: i32) -> i32`:
+  copy the value under the key and return 0
+- `env.kv_get(key_ptr: i32, key_len: i32, buf_ptr: i32, buf_len: i32) -> i32`:
+  return -1 if the key is missing, otherwise the full value length. The value
+  is copied into the buffer only when it fits; otherwise the caller retries
+  with a buffer of that length.
 
 The guest exports:
 
 
@@ -1,31 +1,85 @@
-use std::{path::PathBuf, process::ExitCode};
+use std::{collections::HashMap, path::PathBuf, process::ExitCode};
 
 use wasmer::{
-    Function, FunctionEnv, FunctionEnvMut, Instance, Memory, Module, RuntimeError, Store, imports,
+    AsStoreRef, Function, FunctionEnv, FunctionEnvMut, Instance, Memory, Module, RuntimeError,
+    Store, imports,
 };
 
 const USAGE: &str = "usage: wasm-runtime MODULE.wasm (-c CODE | FILE.py)";
 
 struct Context {
     memory: Option<Memory>,
+    kv: HashMap<Vec<u8>, Vec<u8>>,
 }
 
-fn print(mut ctx: FunctionEnvMut<Context>, ptr: u32, len: u32) -> Result<i32, RuntimeError> {
-    let (context, store) = ctx.data_and_store_mut();
-    let memory = context
-        .memory
-        .as_ref()
-        .ok_or_else(|| RuntimeError::new("guest memory is not initialized"))?
-        .view(&store);
+impl Context {
+    fn memory(&self) -> Result<&Memory, RuntimeError> {
+        self.memory
+            .as_ref()
+            .ok_or_else(|| RuntimeError::new("guest memory is not initialized"))
+    }
+}
+
+fn read_memory(
+    context: &Context,
+    store: &impl AsStoreRef,
+    ptr: u32,
+    len: u32,
+) -> Result<Vec<u8>, RuntimeError> {
     let mut bytes = vec![0; len as usize];
-    memory
+    context
+        .memory()?
+        .view(store)
         .read(u64::from(ptr), &mut bytes)
         .map_err(|err| RuntimeError::new(err.to_string()))?;
+    Ok(bytes)
+}
+
+fn print(mut ctx: FunctionEnvMut<Context>, ptr: u32, len: u32) -> Result<i32, RuntimeError> {
+    let (context, store) = ctx.data_and_store_mut();
+    let bytes = read_memory(context, &store, ptr, len)?;
     let message = std::str::from_utf8(&bytes).map_err(|err| RuntimeError::new(err.to_string()))?;
     println!("{message}");
     Ok(0)
 }
 
+fn kv_put(
+    mut ctx: FunctionEnvMut<Context>,
+    key_ptr: u32,
+    key_len: u32,
+    value_ptr: u32,
+    value_len: u32,
+) -> Result<i32, RuntimeError> {
+    let (context, store) = ctx.data_and_store_mut();
+    let key = read_memory(context, &store, key_ptr, key_len)?;
+    let value = read_memory(context, &store, value_ptr, value_len)?;
+    context.kv.insert(key, value);
+    Ok(0)
+}
+
+fn kv_get(
+    mut ctx: FunctionEnvMut<Context>,
+    key_ptr: u32,
+    key_len: u32,
+    buf_ptr: u32,
+    buf_len: u32,
+) -> Result<i32, RuntimeError> {
+    let (context, store) = ctx.data_and_store_mut();
+    let key = read_memory(context, &store, key_ptr, key_len)?;
+    let Some(value) = context.kv.get(&key) else {
+        return Ok(-1);
+    };
+    let len = i32::try_from(value.len()).map_err(|err| RuntimeError::new(err.to_string()))?;
+    if value.len() <= buf_len as usize {
+        context
+            .memory()?
+            .view(&store)
+            .write(u64::from(buf_ptr), value)
+            .map_err(|err| RuntimeError::new(err.to_string()))?;
+    }
+    Ok(len)
+}
+
 fn run() -> Result<i32, Box<dyn std::error::Error>> {
     let mut args = std::env::args_os().skip(1);
     let module_path = PathBuf::from(args.next().ok_or(USAGE)?);
@@ -48,14 +102,22 @@ fn run() -> Result<i32, Box<dyn std::error::Error>> {
     let module = Module::new(&store, std::fs::read(&module_path)?)?;
     // Fail closed if a future build accidentally acquires OS or JS imports.
     for import in module.imports() {
-        if import.module() != "env" || import.name() != "print" {
+        if import.module() != "env" || !matches!(import.name(), "print" | "kv_get" | "kv_put") {
             return Err(format!("unexpected import: {}.{}", import.module(), import.name()).into());
         }
     }
-    let env = FunctionEnv::new(&mut store, Context { memory: None });
+    let env = FunctionEnv::new(
+        &mut store,
+        Context {
+            memory: None,
+            kv: HashMap::new(),
+        },
+    );
     let imports = imports! {
         "env" => {
             "print" => Function::new_typed_with_env(&mut store, &env, print),
+            "kv_get" => Function::new_typed_with_env(&mut store, &env, kv_get),
+            "kv_put" => Function::new_typed_with_env(&mut store, &env, kv_put),
         }
     };
     let instance = Instance::new(&mut store, &module, &imports)?;