youknowone · Oct 27, 2026 · Oct 26, 2026 · Oct 26, 2026 · Oct 26, 2026 · Oct 26, 2026
diff --git a/crates/vm/src/builtins/memory.rs b/crates/vm/src/builtins/memory.rs
@@ -1553,20 +1553,22 @@ static BUFFER_WINDOW_METHODS: BufferMethods = BufferMethods {
 /// or from_address view can alias another object without sharing its owner.
 /// Return None for that storage so either operand forces a source snapshot.
 fn root_exporter(buffer: &PyBuffer) -> Option<PyObjectRef> {
-    let mut obj = buffer.obj.clone();
+    let obj = buffer_owner(&buffer.obj);
+    (!crate::stdlib::is_borrowed_ctypes_buffer(obj)).then(|| obj.to_owned())
+}
+
+// Follow forwarding payloads without reacquiring a buffer or invoking Python.
+pub(crate) fn buffer_owner(mut obj: &PyObject) -> &PyObject {
     loop {
-        let next = if let Some(view) = obj.downcast_ref::<PyMemoryView>() {
-            view.buffer.obj.clone()
+        obj = if let Some(view) = obj.downcast_ref::<PyMemoryView>() {
+            &view.buffer.obj
         } else if let Some(wrapper) = obj.downcast_ref::<PyBufferWrapper>() {
-            wrapper.view.obj.clone()
+            &wrapper.view.obj
         } else if let Some(window) = obj.downcast_ref::<PyBufferWindow>() {
-            window.source.obj.clone()
-        } else if crate::stdlib::is_borrowed_ctypes_buffer(&obj) {
-            return None;
+            &window.source.obj
         } else {
-            return Some(obj);
+            return obj;
         };
-        obj = next;
     }
 }
 

diff --git a/crates/vm/src/stdlib/_ctypes.rs b/crates/vm/src/stdlib/_ctypes.rs
@@ -16,6 +16,7 @@ use crate::{
 };
 
 pub(super) use array::PyCArray;
+pub(crate) use base::BufferViewRegistry;
 pub(super) use base::{CArgValue, PyCData, PyCField, StgInfo, StgInfoFlags};
 pub(super) use pointer::PyCPointer;
 pub(super) use simple::{PyCSimple, PyCSimpleType};

diff --git a/crates/vm/src/stdlib/_ctypes/array.rs b/crates/vm/src/stdlib/_ctypes/array.rs
@@ -1,5 +1,5 @@
-use super::StgInfo;
 use super::base::{CDATA_BUFFER_METHODS, PyCData};
+use super::{StgInfo, StgInfoFlags};
 use crate::common::lock::LazyLock;
 use crate::sliceable::SaturatedSliceIter;
 use crate::{
@@ -560,8 +560,9 @@ impl PyCArray {
             let address = rustpython_host_env::ctypes::read_pointer_from_buffer(
                 &buffer[offset..offset + element_size],
             );
+            let slot = buffer.as_ptr().wrapping_add(offset) as usize;
             drop(buffer);
-            return zelf.0.object_at(address, Some(index), vm);
+            return zelf.0.object_at(address, slot, Some(index), vm);
         }
         if let Some(element_type) = stg.as_ref().and_then(|info| info.element_type.as_ref())
             && super::simple::is_swapped(element_type)
@@ -620,15 +621,26 @@ impl PyCArray {
             return Err(vm.new_index_error("invalid index"));
         }
         let index = index as usize;
+        // A view's buffer already points to its element. Its base can be a
+        // pointer object, whose own buffer stores an address rather than data.
+        let write = if element_type
+            .stg_info(vm)?
+            .flags
+            .intersects(StgInfoFlags::TYPEFLAG_ISPOINTER | StgInfoFlags::TYPEFLAG_HASPOINTER)
+        {
+            zelf.0
+                .register_pyobject_view(index, index * element_size, element_size, vm)?
+        } else {
+            super::base::CDataWrite::default()
+        };
         let prepared = super::base::CDataValue::new(
             &element_type,
             value,
             element_size,
             super::simple::is_swapped(&element_type),
             vm,
         )?;
-        // A view's buffer already points to its element. Its base can be a
-        // pointer object, whose own buffer stores an address rather than data.
+        write.publish(vm)?;
         zelf.0
             .write_bytes_at_offset(index * element_size, &prepared.bytes);
         prepared.keep(&zelf.0, index, vm)