@@ -56,9 +56,9 @@ cdef class IPCAllocationHandle:
 # Descriptor of a VirtualMemoryResource buffer: one exported handle per
 # physical allocation that backs the buffer, in address order.
 cdef class _VirtualMemoryDescriptor(IPCBufferDescriptor):
-    cdef readonly int   _handle_type
     cdef readonly tuple _chunk_sizes
 
+    cdef int driver_handle_type(self) except -1
     cdef void* handle_ptr(self, Py_ssize_t i, cydriver.CUmemFabricHandle* scratch) except? NULL
 
 
 
@@ -60,7 +60,6 @@ class IPCAllocationHandle:
 
 class _VirtualMemoryDescriptor(IPCBufferDescriptor):
     """Common allocation layout and driver-handle interface for VMM descriptors."""
-    _handle_type: int
     _chunk_sizes: tuple[Any, ...]
 
     @property
@@ -106,7 +105,7 @@ class VirtualMemoryFdBufferDescriptor(_VirtualMemoryDescriptor):
     _handles: tuple[Any, ...]
 
     @staticmethod
-    def _from_exports(handle_type: int, chunk_sizes: tuple[int, ...], handles: tuple[Any, ...], size: int) -> VirtualMemoryFdBufferDescriptor: ...
+    def _from_exports(chunk_sizes: tuple[int, ...], handles: tuple[Any, ...], size: int) -> VirtualMemoryFdBufferDescriptor: ...
     @classmethod
     def from_fds(cls, fds: Iterable[int | IPCAllocationHandle], sizes: Iterable[int], *, size: int | None=None) -> VirtualMemoryFdBufferDescriptor:
         """Build a descriptor from POSIX file descriptors received outside ``multiprocessing``.
 
@@ -187,16 +187,20 @@ cdef class _VirtualMemoryDescriptor(IPCBufferDescriptor):
         """The export handle type; the importing resource must use the same type."""
         from cuda.core._memory._virtual_memory_resource import VirtualMemoryResourceOptions
 
+        handle_type = self.driver_handle_type()
         for spec, value in VirtualMemoryResourceOptions._handle_types.items():
-            if spec is not None and int(value) == self._handle_type:
+            if spec is not None and int(value) == handle_type:
                 return spec
-        raise ValueError(f"the descriptor carries an unknown handle type ({self._handle_type})")
+        raise ValueError(f"the descriptor carries an unknown handle type ({handle_type})")
 
     @property
     def sizes(self) -> tuple[int, ...]:
         """Size of each physical allocation, in address order; the sum is at least ``size``."""
         return self._chunk_sizes
 
+    cdef int driver_handle_type(self) except -1:
+        raise NotImplementedError("a concrete VMM descriptor is required")
+
     cdef void* handle_ptr(self, Py_ssize_t i, cydriver.CUmemFabricHandle* scratch) except? NULL:
         raise NotImplementedError("a concrete VMM descriptor is required")
 
@@ -237,13 +241,12 @@ cdef class VirtualMemoryFdBufferDescriptor(_VirtualMemoryDescriptor):
 
     @staticmethod
     def _from_exports(
-        handle_type: int, chunk_sizes: tuple[int, ...], handles: tuple, size: int
+        chunk_sizes: tuple[int, ...], handles: tuple, size: int
     ) -> VirtualMemoryFdBufferDescriptor:
         cdef VirtualMemoryFdBufferDescriptor self = VirtualMemoryFdBufferDescriptor.__new__(
             VirtualMemoryFdBufferDescriptor)
         self._payload = b""
         self._size = size
-        self._handle_type = handle_type
         self._chunk_sizes = tuple(chunk_sizes)
         self._handles = tuple(handles)
         return self
@@ -288,7 +291,6 @@ cdef class VirtualMemoryFdBufferDescriptor(_VirtualMemoryDescriptor):
         OSError
             If an ``int`` is not an open file descriptor.
         """
-        cdef int driver_type = <int>cydriver.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR
         cdef tuple sizes_t = tuple(operator.index(n) for n in sizes)
         cdef list given = list(fds)
         if len(given) != len(sizes_t):
@@ -315,7 +317,10 @@ cdef class VirtualMemoryFdBufferDescriptor(_VirtualMemoryDescriptor):
                 raise
             # The handle owns the duplicate now; if append fails, the handle closes it once.
             handles.append(handle)
-        return VirtualMemoryFdBufferDescriptor._from_exports(driver_type, sizes_t, tuple(handles), size)
+        return VirtualMemoryFdBufferDescriptor._from_exports(sizes_t, tuple(handles), size)
+
+    cdef int driver_handle_type(self) except -1:
+        return <int>cydriver.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR
 
     cdef void* handle_ptr(self, Py_ssize_t i, cydriver.CUmemFabricHandle* scratch) except? NULL:
         # fd zero is valid, so NULL is a valid result unless an exception is set.
@@ -344,7 +349,7 @@ cdef class VirtualMemoryFdBufferDescriptor(_VirtualMemoryDescriptor):
     def __reduce__(self) -> tuple[object, ...]:
         # multiprocessing duplicates the IPCAllocationHandle fds into the receiver; plain pickle raises.
         return VirtualMemoryFdBufferDescriptor._from_exports, (
-            self._handle_type, self._chunk_sizes, self._handles, self._size)
+            self._chunk_sizes, self._handles, self._size)
 
 
 cdef class VirtualMemoryFabricBufferDescriptor(_VirtualMemoryDescriptor):
@@ -419,7 +424,6 @@ cdef class VirtualMemoryFabricBufferDescriptor(_VirtualMemoryDescriptor):
             raise ValueError(f"size {size} is outside 0..{total}, the sum of the allocation sizes")
         cdef VirtualMemoryFabricBufferDescriptor self = VirtualMemoryFabricBufferDescriptor.__new__(cls)
         self._payload = b""
-        self._handle_type = <int>cydriver.CU_MEM_HANDLE_TYPE_FABRIC
         self._chunk_sizes = sizes_t
         self._handles = handles_t
         self._size = size
@@ -436,6 +440,9 @@ cdef class VirtualMemoryFabricBufferDescriptor(_VirtualMemoryDescriptor):
         """The exporting device's UUID, if supplied by the exporter."""
         return self._owner_uuid
 
+    cdef int driver_handle_type(self) except -1:
+        return <int>cydriver.CU_MEM_HANDLE_TYPE_FABRIC
+
     cdef void* handle_ptr(self, Py_ssize_t i, cydriver.CUmemFabricHandle* scratch) except? NULL:
         cdef bytes handle = self._handles[i]
         memcpy(scratch.data, <const char*>handle, 64)
 
@@ -263,37 +263,36 @@ cdef int _raise_last_error() except -1:
     )
 
 
-cdef inline int _attach_note(exc, str detail) except -1:
-    # PEP 678 notes (Python 3.11+) keep the detail separable from the message;
-    # older interpreters get it appended to the message instead.
-    add_note = getattr(exc, "add_note", None)
-    if add_note is not None:
-        add_note(detail)
-    else:
-        exc.args = (f"{exc.args[0]} ({detail})", *exc.args[1:])
-    return 0
-
-
 cdef int _raise_last_error_noting(str detail) except -1:
     """Raise the status a handle factory recorded, with ``detail`` attached as a note."""
     try:
         _raise_last_error()
     except Exception as exc:
-        _attach_note(exc, detail)
+        exc.add_note(detail)
         raise
     return 0
 
 
-cdef int _raise_allocation_error(const cydriver.CUmemAllocationProp* prop) except -1:
-    """Raise the status of a failed physical allocation; a fabric resource gets the IMEX note."""
-    if prop.requestedHandleTypes == cydriver.CU_MEM_HANDLE_TYPE_FABRIC:
-        _raise_last_error_noting(
+cdef int _raise_allocation_error(
+    cydriver.CUresult status, cydriver.CUmemAllocationHandleType requested_handle_types
+) except -1:
+    """Raise a physical-allocation failure, noting possible fabric configuration errors."""
+    if (requested_handle_types == cydriver.CU_MEM_HANDLE_TYPE_FABRIC
+            and status in (cydriver.CUDA_ERROR_NOT_PERMITTED,
+                           cydriver.CUDA_ERROR_NOT_SUPPORTED,
+                           cydriver.CUDA_ERROR_INVALID_VALUE)):
+        _check_noting(
+            status,
             "while creating a physical allocation with a fabric handle; fabric handles need an NVLink fabric "
             "and an accessible IMEX channel, and a device can report support while the allocation is refused "
             "(the attribute does not check for an NVLink fabric, and older drivers do not check for an IMEX "
             "channel)"
         )
-    return _raise_last_error()
+    HANDLE_RETURN(status)
+    raise RuntimeError(
+        "internal cuda.core error, please report: a physical allocation factory "
+        "returned an empty handle without recording a CUDA error"
+    )
 
 
 cdef int _check_noting(cydriver.CUresult status, str detail) except -1:
@@ -303,7 +302,7 @@ cdef int _check_noting(cydriver.CUresult status, str detail) except -1:
     try:
         HANDLE_RETURN(status)
     except Exception as exc:
-        _attach_note(exc, detail)
+        exc.add_note(detail)
         raise
     return 0
 
@@ -740,7 +739,7 @@ cdef class VirtualMemoryResource(MemoryResource):
         with nogil:
             h_alloc = create_mem_allocation_handle(aligned, prop, descs.data(), descs.size())
         if not h_alloc:
-            _raise_allocation_error(&prop)
+            _raise_allocation_error(get_last_error(), prop.requestedHandleTypes)
         with nogil:
             h_res = create_va_reservation_handle(aligned, addr_align, hint)
         if not h_res:
@@ -893,7 +892,7 @@ cdef class VirtualMemoryResource(MemoryResource):
             with nogil:
                 h_alloc = create_mem_allocation_handle(add, prop, descs.data(), descs.size())
             if not h_alloc:
-                _raise_allocation_error(&prop)
+                _raise_allocation_error(get_last_error(), prop.requestedHandleTypes)
             with nogil:
                 h_map = create_va_mapping_handle(base + total, h_alloc, h_res)
             if not h_map:
@@ -926,7 +925,7 @@ cdef class VirtualMemoryResource(MemoryResource):
         with nogil:
             h_alloc = create_mem_allocation_handle(add, prop, descs.data(), descs.size())
         if not h_alloc:
-            _raise_allocation_error(&prop)
+            _raise_allocation_error(get_last_error(), prop.requestedHandleTypes)
         with nogil:
             m2 = create_va_mapping_handle(base_new + offset, h_alloc, h_res_new)
         if not m2:
@@ -1044,7 +1043,7 @@ cdef class VirtualMemoryResource(MemoryResource):
         if not self.is_ipc_enabled:
             raise RuntimeError("Memory resource is not IPC-enabled")
         handle_type = int(VirtualMemoryResourceOptions._handle_type_to_driver(cfg.handle_type))
-        if desc._handle_type != handle_type:
+        if desc.driver_handle_type() != handle_type:
             raise ValueError(
                 "the descriptor's handle type does not match this resource's "
                 f"handle_type={str(cfg.handle_type)!r}; import it with a resource configured like the exporter's"
@@ -1282,4 +1281,4 @@ cdef _VirtualMemoryDescriptor _export_ipc_descriptor(Buffer buf):
     if handle_type == <int>cydriver.CU_MEM_HANDLE_TYPE_FABRIC:
         return VirtualMemoryFabricBufferDescriptor._from_exports(
             tuple(sizes), tuple(handles), buf._size, mr.device.uuid)
-    return VirtualMemoryFdBufferDescriptor._from_exports(handle_type, tuple(sizes), tuple(handles), buf._size)
+    return VirtualMemoryFdBufferDescriptor._from_exports(tuple(sizes), tuple(handles), buf._size)
@@ -454,9 +454,9 @@ def _require_vmm_fabric_device(device):
         except CUDAError as exc:
             # Only a refused physical allocation means "no fabric here" (NOT_PERMITTED on the CI runners,
             # INVALID_VALUE on an H200 without an IMEX channel). VirtualMemoryResource attaches its note about
-            # the fabric and IMEX requirements at that stage alone (on Python 3.10 it lands in the message);
+            # the fabric and IMEX requirements at that stage alone;
             # a failure of the reservation, the mapping, or the stream setup is a real error and propagates.
-            if "fabric handle" not in " ".join((str(exc), *getattr(exc, "__notes__", ()))):
+            if "fabric handle" not in " ".join(getattr(exc, "__notes__", ())):
                 raise
             _fabric_allocation_error[device.device_id] = str(exc).split(":", 1)[0]
         finally:
 
@@ -216,7 +216,7 @@ def PARENT_ACTION(self, queue):
         else:
             # The VMM descriptor carries the exported handles and their sizes;
             # forge only the buffer size.
-            oversized = type(desc)._from_exports(desc._handle_type, desc._chunk_sizes, desc._handles, desc.size * 100)
+            oversized = type(desc)._from_exports(desc._chunk_sizes, desc._handles, desc.size * 100)
         stream.sync()
         queue.put(oversized)
 
 
@@ -40,15 +40,11 @@ def _read(buf):
     return bytes(host)
 
 
-def _notes(exc):
-    # Python 3.10 appends the note to the message instead of using PEP 678.
-    return " ".join((str(exc), *getattr(exc, "__notes__", ())))
-
-
 def _check_import_error(exc):
     # The driver's status for a bad handle varies with the IMEX setup; the note is cuda.core's and does not.
+    notes = " ".join(exc.__notes__)
     for detail in ("stale", "exporting buffer was closed", "forged", "different IMEX channel"):
-        assert detail in _notes(exc)
+        assert detail in notes
 
 
 def _exchange(owner_uuid, payload):
@@ -137,7 +133,7 @@ def test_export_shape(vmm_fabric_device):
         prefix = VirtualMemoryFabricBufferDescriptor.from_handles(desc.handles, desc.sizes, size=1)
         with Buffer.from_ipc_descriptor(mr, prefix, stream=device.default_stream) as alias:
             assert alias.size == 1 < sum(prefix.sizes)
-        assert not any(hasattr(desc, name) for name in ("fds", "close", "is_closed"))
+        assert not hasattr(desc, "fds")
     with mr.allocate(0) as empty:
         desc = empty.ipc_descriptor
         assert (desc.handles, desc.sizes, desc.size) == ((), (), 0)
@@ -228,8 +224,10 @@ def test_second_gpu_and_wrong_owner(vmm_fabric_device_x2):
 
 
 @pytest.mark.agent_authored(model="gpt-6.1-sol")
-def test_handle_type_mismatch(vmm_fabric_device):
-    device = vmm_fabric_device
+def test_handle_type_mismatch(vmm_ipc_device):
+    device = vmm_ipc_device
+    if not device.properties.handle_type_fabric_supported:
+        pytest.skip("Device does not support fabric handles")
     fabric, fd = _resource(device), _resource(device, handle_type="posix_fd")
     # Empty descriptors would need no import call; even these must reject a mismatch.
     for exporting, importing in ((fabric, fd), (fd, fabric)):
@@ -279,13 +277,9 @@ def test_reexport_imported_derivatives(vmm_fabric_device):
 
 
 @pytest.mark.agent_authored(model="gpt-6.1-sol")
-def test_configuration_and_buffer_pickle(vmm_fabric_device):
+def test_buffer_pickle(vmm_fabric_device):
     device = vmm_fabric_device
     mr = _resource(device)
-    assert mr.is_ipc_enabled
-    for location in ("host", "host_numa", "host_numa_current"):
-        host = _resource(device, location_type=location, handle_type=None if location == "host" else "fabric")
-        assert not host.is_ipc_enabled
     with mr.allocate(1) as buf:
         _fill(buf, 0x55)
         with pickle.loads(pickle.dumps(buf)) as alias:  # noqa: S301  our own live buffer
 
@@ -30,7 +30,12 @@
 from cuda.bindings import driver
 from cuda.core import Buffer, Device, MemoryResource, VirtualMemoryResource, VirtualMemoryResourceOptions
 from cuda.core._dlpack import DLDeviceType
-from cuda.core._memory._ipc import IPCAllocationHandle, IPCBufferDescriptor, VirtualMemoryFdBufferDescriptor
+from cuda.core._memory._ipc import (
+    IPCAllocationHandle,
+    IPCBufferDescriptor,
+    VirtualMemoryFabricBufferDescriptor,
+    VirtualMemoryFdBufferDescriptor,
+)
 from cuda.core._memory._virtual_memory_resource import VirtualMemoryBuffer
 from cuda.core._utils.cuda_utils import CUDAError, handle_return
 from cuda.core.utils import StridedMemoryView
@@ -109,13 +114,10 @@ def _has_note(exc, text):
 
 def _forge(desc, **fields):
     """A copy of ``desc`` with some fields replaced, as a hostile or buggy peer could send."""
-    fields.setdefault("handle_type", desc._handle_type)
     fields.setdefault("chunk_sizes", desc._chunk_sizes)
     fields.setdefault("handles", desc._handles)
     fields.setdefault("size", desc.size)
-    return VirtualMemoryFdBufferDescriptor._from_exports(
-        fields["handle_type"], fields["chunk_sizes"], fields["handles"], fields["size"]
-    )
+    return VirtualMemoryFdBufferDescriptor._from_exports(fields["chunk_sizes"], fields["handles"], fields["size"])
 
 
 class _SharedStub(MemoryResource):
@@ -177,16 +179,26 @@ def _on_queue_feeder_error(e, _obj):
     ("options", "expected"),
     [
         pytest.param({"handle_type": "posix_fd"}, True, id="posix_fd"),
+        pytest.param({"handle_type": "fabric"}, True, id="fabric"),
         pytest.param({"handle_type": None}, False, id="none"),
         pytest.param({"handle_type": "win32_kmt"}, False, id="win32_kmt"),
         pytest.param({"location_type": "host", "handle_type": None}, False, id="host"),
         pytest.param(
             {"location_type": "host_numa", "numa_id": 0, "handle_type": "posix_fd"}, False, id="host_numa-posix_fd"
         ),
+        pytest.param(
+            {"location_type": "host_numa", "numa_id": 0, "handle_type": "fabric"}, False, id="host_numa-fabric"
+        ),
     ],
 )
 def test_is_ipc_enabled(vmm_ipc_device, options, expected):
-    """POSIX file descriptors on device memory have a transport; host-located memory is not shared yet."""
+    """POSIX fd and fabric device memory have transports; host-located memory is not shared yet."""
+    if (
+        options.get("location_type", "device") == "device"
+        and options.get("handle_type") == "fabric"
+        and not vmm_ipc_device.properties.handle_type_fabric_supported
+    ):
+        pytest.skip("Device does not support fabric handles")
     mr = VirtualMemoryResource(vmm_ipc_device, config=VirtualMemoryResourceOptions(**options))
     assert mr.is_ipc_enabled is expected
 
@@ -352,9 +364,9 @@ def test_rejected_before_import(self, vmm_ipc_device):
         with mr.allocate(1) as buf:
             gran = buf.size
             desc = buf.ipc_descriptor
-            fabric = int(driver.CUmemAllocationHandleType.CU_MEM_HANDLE_TYPE_FABRIC)
+            fabric = VirtualMemoryFabricBufferDescriptor.from_handles([bytes(64)], [gran])
             cases = [
-                (_forge(desc, handle_type=fabric), ValueError, "handle type does not match"),
+                (fabric, ValueError, "handle type does not match"),
                 (_forge(desc, chunk_sizes=(gran, gran)), ValueError, "malformed"),
                 (_forge(desc, chunk_sizes=(0,), size=0), ValueError, "positive multiple"),
                 (_forge(desc, chunk_sizes=(gran + 1,)), ValueError, "positive multiple"),