Add files using upload-large-folder tool

lib/python3.11/site-packages/cuda/bindings/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+
+from cuda.bindings import utils
+from cuda.bindings._version import __version__

lib/python3.11/site-packages/cuda/bindings/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '13.2.0'
+__version_tuple__ = version_tuple = (13, 2, 0)
+
+__commit_id__ = commit_id = 'g06e60656c'

lib/python3.11/site-packages/cuda/bindings/cufile.pxd

@@ -0,0 +1,85 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+#
+# This code was automatically generated across versions from 12.9.1 to 13.2.0, generator version 0.3.1.dev1364+ged01d643e. Do not modify it directly.
+
+from libc.stdint cimport intptr_t
+
+from .cycufile cimport *
+
+
+###############################################################################
+# Types
+###############################################################################
+
+ctypedef CUfileHandle_t Handle
+ctypedef CUfileBatchHandle_t BatchHandle
+ctypedef CUfileError_t Error
+ctypedef cufileRDMAInfo_t RDMAInfo
+ctypedef CUfileFSOps_t FSOps
+ctypedef CUfileDrvProps_t DrvProps
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+ctypedef CUfileOpError _OpError
+ctypedef CUfileDriverStatusFlags_t _DriverStatusFlags
+ctypedef CUfileDriverControlFlags_t _DriverControlFlags
+ctypedef CUfileFeatureFlags_t _FeatureFlags
+ctypedef CUfileFileHandleType _FileHandleType
+ctypedef CUfileOpcode_t _Opcode
+ctypedef CUfileStatus_t _Status
+ctypedef CUfileBatchMode_t _BatchMode
+ctypedef CUFileSizeTConfigParameter_t _SizeTConfigParameter
+ctypedef CUFileBoolConfigParameter_t _BoolConfigParameter
+ctypedef CUFileStringConfigParameter_t _StringConfigParameter
+ctypedef CUFileArrayConfigParameter_t _ArrayConfigParameter
+ctypedef CUfileP2PFlags_t _P2PFlags
+
+
+###############################################################################
+# Functions
+###############################################################################
+
+cpdef intptr_t handle_register(intptr_t descr) except? 0
+cpdef void handle_deregister(intptr_t fh) except*
+cpdef buf_register(intptr_t buf_ptr_base, size_t length, int flags)
+cpdef buf_deregister(intptr_t buf_ptr_base)
+cpdef driver_open()
+cpdef use_count()
+cpdef driver_get_properties(intptr_t props)
+cpdef driver_set_poll_mode(bint poll, size_t poll_threshold_size)
+cpdef driver_set_max_direct_io_size(size_t max_direct_io_size)
+cpdef driver_set_max_cache_size(size_t max_cache_size)
+cpdef driver_set_max_pinned_mem_size(size_t max_pinned_size)
+cpdef intptr_t batch_io_set_up(unsigned nr) except? 0
+cpdef batch_io_submit(intptr_t batch_idp, unsigned nr, intptr_t iocbp, unsigned int flags)
+cpdef batch_io_get_status(intptr_t batch_idp, unsigned min_nr, intptr_t nr, intptr_t iocbp, intptr_t timeout)
+cpdef batch_io_cancel(intptr_t batch_idp)
+cpdef void batch_io_destroy(intptr_t batch_idp) except*
+cpdef read_async(intptr_t fh, intptr_t buf_ptr_base, intptr_t size_p, intptr_t file_offset_p, intptr_t buf_ptr_offset_p, intptr_t bytes_read_p, intptr_t stream)
+cpdef write_async(intptr_t fh, intptr_t buf_ptr_base, intptr_t size_p, intptr_t file_offset_p, intptr_t buf_ptr_offset_p, intptr_t bytes_written_p, intptr_t stream)
+cpdef stream_register(intptr_t stream, unsigned flags)
+cpdef stream_deregister(intptr_t stream)
+cpdef int get_version() except? 0
+cpdef size_t get_parameter_size_t(int param) except? 0
+cpdef bint get_parameter_bool(int param) except? 0
+cpdef str get_parameter_string(int param, int len)
+cpdef set_parameter_size_t(int param, size_t value)
+cpdef set_parameter_bool(int param, bint value)
+cpdef set_parameter_string(int param, intptr_t desc_str)
+cpdef tuple get_parameter_min_max_value(int param)
+cpdef set_stats_level(int level)
+cpdef int get_stats_level() except? 0
+cpdef stats_start()
+cpdef stats_stop()
+cpdef stats_reset()
+cpdef get_stats_l1(intptr_t stats)
+cpdef get_stats_l2(intptr_t stats)
+cpdef get_stats_l3(intptr_t stats)
+cpdef size_t get_bar_size_in_kb(int gpu_ind_ex) except? 0
+cpdef set_parameter_posix_pool_slab_array(intptr_t size_values, intptr_t count_values, int len)
+cpdef get_parameter_posix_pool_slab_array(intptr_t size_values, intptr_t count_values, int len)

lib/python3.11/site-packages/cuda/bindings/cycufile.pxd

@@ -0,0 +1,431 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: LicenseRef-NVIDIA-SOFTWARE-LICENSE
+#
+# This code was automatically generated across versions from 12.9.1 to 13.2.0, generator version 0.3.1.dev1364+ged01d643e. Do not modify it directly.
+
+from libc.stdint cimport uint32_t, uint64_t
+from libc.time cimport time_t
+from libcpp cimport bool as cpp_bool
+from posix.types cimport off_t
+
+cimport cuda.bindings.cydriver
+from cuda.bindings.cydriver cimport CUresult
+
+
+###############################################################################
+# Types (structs, enums, ...)
+###############################################################################
+
+# TODO: switch to "from libc.time cimport timespec" once we can use recent
+# Cython to build
+cdef extern from "<time.h>":
+    cdef struct timespec:
+        time_t tv_sec
+        long   tv_nsec
+cdef extern from "<sys/socket.h>":
+    cdef struct sockaddr:
+        unsigned short sa_family
+        char sa_data[14]
+    ctypedef sockaddr sockaddr_t
+
+
+
+
+    # enums
+cdef extern from '<cufile.h>':
+    ctypedef enum CUfileOpError:
+        CU_FILE_SUCCESS
+        CU_FILE_DRIVER_NOT_INITIALIZED
+        CU_FILE_DRIVER_INVALID_PROPS
+        CU_FILE_DRIVER_UNSUPPORTED_LIMIT
+        CU_FILE_DRIVER_VERSION_MISMATCH
+        CU_FILE_DRIVER_VERSION_READ_ERROR
+        CU_FILE_DRIVER_CLOSING
+        CU_FILE_PLATFORM_NOT_SUPPORTED
+        CU_FILE_IO_NOT_SUPPORTED
+        CU_FILE_DEVICE_NOT_SUPPORTED
+        CU_FILE_NVFS_DRIVER_ERROR
+        CU_FILE_CUDA_DRIVER_ERROR
+        CU_FILE_CUDA_POINTER_INVALID
+        CU_FILE_CUDA_MEMORY_TYPE_INVALID
+        CU_FILE_CUDA_POINTER_RANGE_ERROR
+        CU_FILE_CUDA_CONTEXT_MISMATCH
+        CU_FILE_INVALID_MAPPING_SIZE
+        CU_FILE_INVALID_MAPPING_RANGE
+        CU_FILE_INVALID_FILE_TYPE
+        CU_FILE_INVALID_FILE_OPEN_FLAG
+        CU_FILE_DIO_NOT_SET
+        CU_FILE_INVALID_VALUE
+        CU_FILE_MEMORY_ALREADY_REGISTERED
+        CU_FILE_MEMORY_NOT_REGISTERED
+        CU_FILE_PERMISSION_DENIED
+        CU_FILE_DRIVER_ALREADY_OPEN
+        CU_FILE_HANDLE_NOT_REGISTERED
+        CU_FILE_HANDLE_ALREADY_REGISTERED
+        CU_FILE_DEVICE_NOT_FOUND
+        CU_FILE_INTERNAL_ERROR
+        CU_FILE_GETNEWFD_FAILED
+        CU_FILE_NVFS_SETUP_ERROR
+        CU_FILE_IO_DISABLED
+        CU_FILE_BATCH_SUBMIT_FAILED
+        CU_FILE_GPU_MEMORY_PINNING_FAILED
+        CU_FILE_BATCH_FULL
+        CU_FILE_ASYNC_NOT_SUPPORTED
+        CU_FILE_INTERNAL_BATCH_SETUP_ERROR
+        CU_FILE_INTERNAL_BATCH_SUBMIT_ERROR
+        CU_FILE_INTERNAL_BATCH_GETSTATUS_ERROR
+        CU_FILE_INTERNAL_BATCH_CANCEL_ERROR
+        CU_FILE_NOMEM_ERROR
+        CU_FILE_IO_ERROR
+        CU_FILE_INTERNAL_BUF_REGISTER_ERROR
+        CU_FILE_HASH_OPR_ERROR
+        CU_FILE_INVALID_CONTEXT_ERROR
+        CU_FILE_NVFS_INTERNAL_DRIVER_ERROR
+        CU_FILE_BATCH_NOCOMPAT_ERROR
+        CU_FILE_IO_MAX_ERROR
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUfileDriverStatusFlags_t:
+        CU_FILE_LUSTRE_SUPPORTED
+        CU_FILE_WEKAFS_SUPPORTED
+        CU_FILE_NFS_SUPPORTED
+        CU_FILE_GPFS_SUPPORTED
+        CU_FILE_NVME_SUPPORTED
+        CU_FILE_NVMEOF_SUPPORTED
+        CU_FILE_SCSI_SUPPORTED
+        CU_FILE_SCALEFLUX_CSD_SUPPORTED
+        CU_FILE_NVMESH_SUPPORTED
+        CU_FILE_BEEGFS_SUPPORTED
+        CU_FILE_NVME_P2P_SUPPORTED
+        CU_FILE_SCATEFS_SUPPORTED
+        CU_FILE_VIRTIOFS_SUPPORTED
+        CU_FILE_MAX_TARGET_TYPES
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUfileDriverControlFlags_t:
+        CU_FILE_USE_POLL_MODE
+        CU_FILE_ALLOW_COMPAT_MODE
+        CU_FILE_POSIX_IO_MODE
+        CU_FILE_FALLBACK_IO_MODE
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUfileFeatureFlags_t:
+        CU_FILE_DYN_ROUTING_SUPPORTED
+        CU_FILE_BATCH_IO_SUPPORTED
+        CU_FILE_STREAMS_SUPPORTED
+        CU_FILE_PARALLEL_IO_SUPPORTED
+        CU_FILE_P2P_SUPPORTED
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUfileFileHandleType:
+        CU_FILE_HANDLE_TYPE_OPAQUE_FD
+        CU_FILE_HANDLE_TYPE_OPAQUE_WIN32
+        CU_FILE_HANDLE_TYPE_USERSPACE_FS
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUfileOpcode_t:
+        CUFILE_READ
+        CUFILE_WRITE
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUfileStatus_t:
+        CUFILE_WAITING
+        CUFILE_PENDING
+        CUFILE_INVALID
+        CUFILE_CANCELED
+        CUFILE_COMPLETE
+        CUFILE_TIMEOUT
+        CUFILE_FAILED
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUfileBatchMode_t:
+        CUFILE_BATCH
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUFileSizeTConfigParameter_t:
+        CUFILE_PARAM_PROFILE_STATS
+        CUFILE_PARAM_EXECUTION_MAX_IO_QUEUE_DEPTH
+        CUFILE_PARAM_EXECUTION_MAX_IO_THREADS
+        CUFILE_PARAM_EXECUTION_MIN_IO_THRESHOLD_SIZE_KB
+        CUFILE_PARAM_EXECUTION_MAX_REQUEST_PARALLELISM
+        CUFILE_PARAM_PROPERTIES_MAX_DIRECT_IO_SIZE_KB
+        CUFILE_PARAM_PROPERTIES_MAX_DEVICE_CACHE_SIZE_KB
+        CUFILE_PARAM_PROPERTIES_PER_BUFFER_CACHE_SIZE_KB
+        CUFILE_PARAM_PROPERTIES_MAX_DEVICE_PINNED_MEM_SIZE_KB
+        CUFILE_PARAM_PROPERTIES_IO_BATCHSIZE
+        CUFILE_PARAM_POLLTHRESHOLD_SIZE_KB
+        CUFILE_PARAM_PROPERTIES_BATCH_IO_TIMEOUT_MS
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUFileBoolConfigParameter_t:
+        CUFILE_PARAM_PROPERTIES_USE_POLL_MODE
+        CUFILE_PARAM_PROPERTIES_ALLOW_COMPAT_MODE
+        CUFILE_PARAM_FORCE_COMPAT_MODE
+        CUFILE_PARAM_FS_MISC_API_CHECK_AGGRESSIVE
+        CUFILE_PARAM_EXECUTION_PARALLEL_IO
+        CUFILE_PARAM_PROFILE_NVTX
+        CUFILE_PARAM_PROPERTIES_ALLOW_SYSTEM_MEMORY
+        CUFILE_PARAM_USE_PCIP2PDMA
+        CUFILE_PARAM_PREFER_IO_URING
+        CUFILE_PARAM_FORCE_ODIRECT_MODE
+        CUFILE_PARAM_SKIP_TOPOLOGY_DETECTION
+        CUFILE_PARAM_STREAM_MEMOPS_BYPASS
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUFileStringConfigParameter_t:
+        CUFILE_PARAM_LOGGING_LEVEL
+        CUFILE_PARAM_ENV_LOGFILE_PATH
+        CUFILE_PARAM_LOG_DIR
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUFileArrayConfigParameter_t:
+        CUFILE_PARAM_POSIX_POOL_SLAB_SIZE_KB
+        CUFILE_PARAM_POSIX_POOL_SLAB_COUNT
+        CUFILE_PARAM_GPU_BOUNCE_BUFFER_SLAB_SIZE_KB
+        CUFILE_PARAM_GPU_BOUNCE_BUFFER_SLAB_COUNT
+
+cdef extern from '<cufile.h>':
+    ctypedef enum CUfileP2PFlags_t:
+        CUFILE_P2PDMA
+        CUFILE_NVFS
+        CUFILE_DMABUF
+        CUFILE_C2C
+        CUFILE_NVIDIA_PEERMEM
+
+    # types
+cdef extern from '<cufile.h>':
+    ctypedef void* CUfileHandle_t 'CUfileHandle_t'
+
+cdef extern from '<cufile.h>':
+    ctypedef void* CUfileBatchHandle_t 'CUfileBatchHandle_t'
+
+cdef extern from '<cufile.h>':
+    ctypedef struct CUfileError_t 'CUfileError_t':
+        CUfileOpError err
+        CUresult cu_err
+
+cdef struct _anon_pod0 '_anon_pod0':
+    unsigned int major_version
+    unsigned int minor_version
+    size_t poll_thresh_size
+    size_t max_direct_io_size
+    unsigned int dstatusflags
+    unsigned int dcontrolflags
+
+cdef extern from '<cufile.h>':
+    ctypedef struct cufileRDMAInfo_t 'cufileRDMAInfo_t':
+        int version
+        int desc_len
+        char* desc_str
+
+cdef extern from '<cufile.h>':
+    ctypedef struct CUfileFSOps_t 'CUfileFSOps_t':
+        char* (*fs_type)(const void*)
+        int (*getRDMADeviceList)(const void*, sockaddr_t**)
+        int (*getRDMADevicePriority)(const void*, char*, size_t, loff_t, const sockaddr_t*)
+        ssize_t (*read)(const void*, char*, size_t, loff_t, const cufileRDMAInfo_t*)
+        ssize_t (*write)(const void*, const char*, size_t, loff_t, const cufileRDMAInfo_t*)
+
+cdef union _anon_pod1 '_anon_pod1':
+    int fd
+    void* handle
+
+cdef struct _anon_pod3 '_anon_pod3':
+    void* devPtr_base
+    off_t file_offset
+    off_t devPtr_offset
+    size_t size
+
+cdef extern from '<cufile.h>':
+    ctypedef struct CUfileIOEvents_t 'CUfileIOEvents_t':
+        void* cookie
+        CUfileStatus_t status
+        size_t ret
+
+cdef extern from '<cufile.h>':
+    ctypedef struct CUfileOpCounter_t 'CUfileOpCounter_t':
+        uint64_t ok
+        uint64_t err
+
+cdef extern from '<cufile.h>':
+    ctypedef struct CUfilePerGpuStats_t 'CUfilePerGpuStats_t':
+        char uuid[16]
+        uint64_t read_bytes
+        uint64_t read_bw_bytes_per_sec
+        uint64_t read_utilization
+        uint64_t read_duration_us
+        uint64_t n_total_reads
+        uint64_t n_p2p_reads
+        uint64_t n_nvfs_reads
+        uint64_t n_posix_reads
+        uint64_t n_unaligned_reads
+        uint64_t n_dr_reads
+        uint64_t n_sparse_regions
+        uint64_t n_inline_regions
+        uint64_t n_reads_err
+        uint64_t writes_bytes
+        uint64_t write_bw_bytes_per_sec
+        uint64_t write_utilization
+        uint64_t write_duration_us
+        uint64_t n_total_writes
+        uint64_t n_p2p_writes
+        uint64_t n_nvfs_writes
+        uint64_t n_posix_writes
+        uint64_t n_unaligned_writes
+        uint64_t n_dr_writes
+        uint64_t n_writes_err
+        uint64_t n_mmap
+        uint64_t n_mmap_ok
+        uint64_t n_mmap_err
+        uint64_t n_mmap_free
+        uint64_t reg_bytes
+
+cdef extern from '<cufile.h>':
+    ctypedef struct CUfileDrvProps_t 'CUfileDrvProps_t':
+        _anon_pod0 nvfs
+        unsigned int fflags
+        unsigned int max_device_cache_size
+        unsigned int per_buffer_cache_size
+        unsigned int max_device_pinned_mem_size
+        unsigned int max_batch_io_size
+        unsigned int max_batch_io_timeout_msecs
+
+cdef extern from '<cufile.h>':
+    ctypedef struct CUfileDescr_t 'CUfileDescr_t':
+        CUfileFileHandleType type
+        _anon_pod1 handle
+        CUfileFSOps_t* fs_ops
+
+cdef union _anon_pod2 '_anon_pod2':
+    _anon_pod3 batch
+
+cdef extern from '<cufile.h>':
+    ctypedef struct CUfileStatsLevel1_t 'CUfileStatsLevel1_t':
+        CUfileOpCounter_t read_ops
+        CUfileOpCounter_t write_ops
+        CUfileOpCounter_t hdl_register_ops
+        CUfileOpCounter_t hdl_deregister_ops
+        CUfileOpCounter_t buf_register_ops
+        CUfileOpCounter_t buf_deregister_ops
+        uint64_t read_bytes
+        uint64_t write_bytes
+        uint64_t read_bw_bytes_per_sec
+        uint64_t write_bw_bytes_per_sec
+        uint64_t read_lat_avg_us
+        uint64_t write_lat_avg_us
+        uint64_t read_ops_per_sec
+        uint64_t write_ops_per_sec
+        uint64_t read_lat_sum_us
+        uint64_t write_lat_sum_us
+        CUfileOpCounter_t batch_submit_ops
+        CUfileOpCounter_t batch_complete_ops
+        CUfileOpCounter_t batch_setup_ops
+        CUfileOpCounter_t batch_cancel_ops
+        CUfileOpCounter_t batch_destroy_ops
+        CUfileOpCounter_t batch_enqueued_ops
+        CUfileOpCounter_t batch_posix_enqueued_ops
+        CUfileOpCounter_t batch_processed_ops
+        CUfileOpCounter_t batch_posix_processed_ops
+        CUfileOpCounter_t batch_nvfs_submit_ops
+        CUfileOpCounter_t batch_p2p_submit_ops
+        CUfileOpCounter_t batch_aio_submit_ops
+        CUfileOpCounter_t batch_iouring_submit_ops
+        CUfileOpCounter_t batch_mixed_io_submit_ops
+        CUfileOpCounter_t batch_total_submit_ops
+        uint64_t batch_read_bytes
+        uint64_t batch_write_bytes
+        uint64_t batch_read_bw_bytes
+        uint64_t batch_write_bw_bytes
+        uint64_t batch_submit_lat_avg_us
+        uint64_t batch_completion_lat_avg_us
+        uint64_t batch_submit_ops_per_sec
+        uint64_t batch_complete_ops_per_sec
+        uint64_t batch_submit_lat_sum_us
+        uint64_t batch_completion_lat_sum_us
+        uint64_t last_batch_read_bytes
+        uint64_t last_batch_write_bytes
+
+cdef extern from '<cufile.h>':
+    ctypedef struct CUfileIOParams_t 'CUfileIOParams_t':
+        CUfileBatchMode_t mode
+        _anon_pod2 u
+        CUfileHandle_t fh
+        CUfileOpcode_t opcode
+        void* cookie
+
+cdef extern from '<cufile.h>':
+    ctypedef struct CUfileStatsLevel2_t 'CUfileStatsLevel2_t':
+        CUfileStatsLevel1_t basic
+        uint64_t read_size_kb_hist[32]
+        uint64_t write_size_kb_hist[32]
+
+cdef extern from '<cufile.h>':
+    ctypedef struct CUfileStatsLevel3_t 'CUfileStatsLevel3_t':
+        CUfileStatsLevel2_t detailed
+        uint32_t num_gpus
+        CUfilePerGpuStats_t per_gpu_stats[16]
+
+
+
+cdef extern from *:
+    """
+    // This is the missing piece we need to supply to help Cython & C++ compilers.
+    inline bool operator==(const CUfileError_t& lhs, const CUfileError_t& rhs) {
+        return (lhs.err == rhs.err) && (lhs.cu_err == rhs.cu_err);
+    }
+    static CUfileError_t CUFILE_LOADING_ERROR{(CUfileOpError)-1, (CUresult)-1};
+    """
+    const CUfileError_t CUFILE_LOADING_ERROR
+    ctypedef void* CUstream "CUstream"
+
+    const char* cufileop_status_error(CUfileOpError)
+
+
+###############################################################################
+# Functions
+###############################################################################
+
+cdef CUfileError_t cuFileHandleRegister(CUfileHandle_t* fh, CUfileDescr_t* descr) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef void cuFileHandleDeregister(CUfileHandle_t fh) except* nogil
+cdef CUfileError_t cuFileBufRegister(const void* bufPtr_base, size_t length, int flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileBufDeregister(const void* bufPtr_base) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef ssize_t cuFileRead(CUfileHandle_t fh, void* bufPtr_base, size_t size, off_t file_offset, off_t bufPtr_offset) except* nogil
+cdef ssize_t cuFileWrite(CUfileHandle_t fh, const void* bufPtr_base, size_t size, off_t file_offset, off_t bufPtr_offset) except* nogil
+cdef CUfileError_t cuFileDriverOpen() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverClose() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverClose_v2() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef long cuFileUseCount() except* nogil
+cdef CUfileError_t cuFileDriverGetProperties(CUfileDrvProps_t* props) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverSetPollMode(cpp_bool poll, size_t poll_threshold_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverSetMaxDirectIOSize(size_t max_direct_io_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverSetMaxCacheSize(size_t max_cache_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileDriverSetMaxPinnedMemSize(size_t max_pinned_size) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileBatchIOSetUp(CUfileBatchHandle_t* batch_idp, unsigned nr) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileBatchIOSubmit(CUfileBatchHandle_t batch_idp, unsigned nr, CUfileIOParams_t* iocbp, unsigned int flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileBatchIOGetStatus(CUfileBatchHandle_t batch_idp, unsigned min_nr, unsigned* nr, CUfileIOEvents_t* iocbp, timespec* timeout) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileBatchIOCancel(CUfileBatchHandle_t batch_idp) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef void cuFileBatchIODestroy(CUfileBatchHandle_t batch_idp) except* nogil
+cdef CUfileError_t cuFileReadAsync(CUfileHandle_t fh, void* bufPtr_base, size_t* size_p, off_t* file_offset_p, off_t* bufPtr_offset_p, ssize_t* bytes_read_p, CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileWriteAsync(CUfileHandle_t fh, void* bufPtr_base, size_t* size_p, off_t* file_offset_p, off_t* bufPtr_offset_p, ssize_t* bytes_written_p, CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileStreamRegister(CUstream stream, unsigned flags) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileStreamDeregister(CUstream stream) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetVersion(int* version) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool* value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetParameterString(CUFileStringConfigParameter_t param, char* desc_str, int len) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileSetParameterSizeT(CUFileSizeTConfigParameter_t param, size_t value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileSetParameterBool(CUFileBoolConfigParameter_t param, cpp_bool value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileSetParameterString(CUFileStringConfigParameter_t param, const char* desc_str) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetParameterMinMaxValue(CUFileSizeTConfigParameter_t param, size_t* min_value, size_t* max_value) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileSetStatsLevel(int level) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetStatsLevel(int* level) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileStatsStart() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileStatsStop() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileStatsReset() except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetStatsL1(CUfileStatsLevel1_t* stats) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetStatsL2(CUfileStatsLevel2_t* stats) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetStatsL3(CUfileStatsLevel3_t* stats) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetBARSizeInKB(int gpuIndex, size_t* barSize) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileSetParameterPosixPoolSlabArray(const size_t* size_values, const size_t* count_values, int len) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil
+cdef CUfileError_t cuFileGetParameterPosixPoolSlabArray(size_t* size_values, size_t* count_values, int len) except?<CUfileError_t>CUFILE_LOADING_ERROR nogil

lib/python3.11/site-packages/cuda/pathfinder/README.md

@@ -0,0 +1,3 @@
+### The `cuda.pathfinder` documentation was moved
+
+Please see https://nvidia.github.io/cuda-python/cuda-pathfinder/latest/

lib/python3.11/site-packages/cuda/pathfinder/__init__.py

@@ -0,0 +1,91 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""cuda.pathfinder public APIs"""
+
+# NOTE: When adding or removing public APIs from this file, remember to update
+#     cuda_pathfinder/docs/source/api.rst
+# to keep the documentation in sync.
+
+from cuda.pathfinder._binaries.find_nvidia_binary_utility import (
+    find_nvidia_binary_utility as find_nvidia_binary_utility,
+)
+from cuda.pathfinder._binaries.supported_nvidia_binaries import SUPPORTED_BINARIES as _SUPPORTED_BINARIES
+from cuda.pathfinder._dynamic_libs.load_dl_common import (
+    DynamicLibNotAvailableError as DynamicLibNotAvailableError,
+)
+from cuda.pathfinder._dynamic_libs.load_dl_common import DynamicLibNotFoundError as DynamicLibNotFoundError
+from cuda.pathfinder._dynamic_libs.load_dl_common import (
+    DynamicLibUnknownError as DynamicLibUnknownError,
+)
+from cuda.pathfinder._dynamic_libs.load_dl_common import LoadedDL as LoadedDL
+from cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib import load_nvidia_dynamic_lib as load_nvidia_dynamic_lib
+from cuda.pathfinder._dynamic_libs.supported_nvidia_libs import (
+    SUPPORTED_LIBNAMES as SUPPORTED_NVIDIA_LIBNAMES,
+)
+from cuda.pathfinder._headers.find_nvidia_headers import LocatedHeaderDir as LocatedHeaderDir
+from cuda.pathfinder._headers.find_nvidia_headers import find_nvidia_header_directory as find_nvidia_header_directory
+from cuda.pathfinder._headers.find_nvidia_headers import (
+    locate_nvidia_header_directory as locate_nvidia_header_directory,
+)
+from cuda.pathfinder._headers.supported_nvidia_headers import SUPPORTED_HEADERS_CTK as _SUPPORTED_HEADERS_CTK
+from cuda.pathfinder._static_libs.find_bitcode_lib import (
+    SUPPORTED_BITCODE_LIBS as _SUPPORTED_BITCODE_LIBS,
+)
+from cuda.pathfinder._static_libs.find_bitcode_lib import (
+    BitcodeLibNotFoundError as BitcodeLibNotFoundError,
+)
+from cuda.pathfinder._static_libs.find_bitcode_lib import (
+    LocatedBitcodeLib as LocatedBitcodeLib,
+)
+from cuda.pathfinder._static_libs.find_bitcode_lib import (
+    find_bitcode_lib as find_bitcode_lib,
+)
+from cuda.pathfinder._static_libs.find_bitcode_lib import (
+    locate_bitcode_lib as locate_bitcode_lib,
+)
+from cuda.pathfinder._static_libs.find_static_lib import (
+    SUPPORTED_STATIC_LIBS as _SUPPORTED_STATIC_LIBS,
+)
+from cuda.pathfinder._static_libs.find_static_lib import (
+    LocatedStaticLib as LocatedStaticLib,
+)
+from cuda.pathfinder._static_libs.find_static_lib import (
+    StaticLibNotFoundError as StaticLibNotFoundError,
+)
+from cuda.pathfinder._static_libs.find_static_lib import (
+    find_static_lib as find_static_lib,
+)
+from cuda.pathfinder._static_libs.find_static_lib import (
+    locate_static_lib as locate_static_lib,
+)
+from cuda.pathfinder._utils.env_vars import get_cuda_path_or_home as get_cuda_path_or_home
+
+from cuda.pathfinder._version import __version__  # isort: skip
+
+# Indirections to help Sphinx find the docstrings.
+#: Mapping from short CUDA Toolkit (CTK) library names to their canonical
+#: header basenames (used to validate a discovered include directory).
+#: Example: ``"cublas" → "cublas.h"``. The key set is platform-aware
+#: (e.g., ``"cufile"`` may be Linux-only).
+SUPPORTED_HEADERS_CTK = _SUPPORTED_HEADERS_CTK
+
+#: Tuple of supported CUDA binary utility names that can be located
+#: via ``find_nvidia_binary_utility()``. Platform-aware (e.g., some
+#: utilities may be available only on Linux or Windows).
+#: Example utilities: ``"nvdisasm"``, ``"cuobjdump"``, ``"nvcc"``.
+SUPPORTED_BINARY_UTILITIES = _SUPPORTED_BINARIES
+
+#: Tuple of supported bitcode library names that can be resolved
+#: via ``locate_bitcode_lib()`` and ``find_bitcode_lib()``.
+#: Example value: ``"device"``.
+SUPPORTED_BITCODE_LIBS = _SUPPORTED_BITCODE_LIBS
+
+#: Tuple of supported static library names that can be resolved
+#: via ``locate_static_lib()`` and ``find_static_lib()``.
+#: Example value: ``"cudadevrt"``.
+SUPPORTED_STATIC_LIBS = _SUPPORTED_STATIC_LIBS
+
+# Backward compatibility: _find_nvidia_header_directory was added in release 1.2.2.
+# It will be removed in release 1.2.4.
+_find_nvidia_header_directory = find_nvidia_header_directory

lib/python3.11/site-packages/cuda/pathfinder/_binaries/find_nvidia_binary_utility.py

@@ -0,0 +1,107 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import functools
+import os
+import shutil
+
+from cuda.pathfinder._binaries import supported_nvidia_binaries
+from cuda.pathfinder._utils.env_vars import get_cuda_path_or_home
+from cuda.pathfinder._utils.find_sub_dirs import find_sub_dirs_all_sitepackages
+from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+
+
+class UnsupportedBinaryError(Exception):
+    def __init__(self, utility: str) -> None:
+        super().__init__(utility)
+        self.utility = utility
+
+    def __str__(self) -> str:
+        supported_utilities = ", ".join(supported_nvidia_binaries.SUPPORTED_BINARIES)
+        return f"Binary '{self.utility}' is not supported. Supported utilities are: {supported_utilities}"
+
+
+def _normalize_utility_name(utility_name: str) -> str:
+    """Normalize utility name by adding .exe on Windows if needed."""
+    if IS_WINDOWS and not utility_name.lower().endswith((".exe", ".bat", ".cmd")):
+        return f"{utility_name}.exe"
+    return utility_name
+
+
+@functools.cache
+def find_nvidia_binary_utility(utility_name: str) -> str | None:
+    """Locate a CUDA binary utility executable.
+
+    Args:
+        utility_name (str): The name of the binary utility to find
+            (e.g., ``"nvdisasm"``, ``"cuobjdump"``). On Windows, the ``.exe``
+            extension will be automatically appended if not present. The function
+            also recognizes ``.bat`` and ``.cmd`` files on Windows.
+
+    Returns:
+        str or None: Absolute path to the discovered executable, or ``None``
+        if the utility cannot be found. The returned path is normalized
+        (absolute and with resolved separators).
+
+    Raises:
+        UnsupportedBinaryError: If ``utility_name`` is not in the supported set
+            (see ``SUPPORTED_BINARY_UTILITIES``).
+
+    Search order:
+        1. **NVIDIA Python wheels**
+
+           - Scan installed distributions (``site-packages``) for binary layouts
+             shipped in NVIDIA wheels (e.g., ``cuda-nvcc``).
+
+        2. **Conda environments**
+
+           - Check Conda-style installation prefixes via ``CONDA_PREFIX``
+             environment variable, which use platform-specific bin directory
+             layouts (``Library/bin`` on Windows, ``bin`` on Linux).
+
+        3. **CUDA Toolkit environment variables**
+
+           - Use ``CUDA_HOME`` or ``CUDA_PATH`` (in that order), searching
+             ``bin/x64``, ``bin/x86_64``, and ``bin`` subdirectories on Windows,
+             or just ``bin`` on Linux.
+
+    Note:
+        Results are cached using ``@functools.cache`` for performance. The cache
+        persists for the lifetime of the process.
+
+        On Windows, executables are identified by their file extensions
+        (``.exe``, ``.bat``, ``.cmd``). On Unix-like systems, executables
+        are identified by the ``X_OK`` (execute) permission bit.
+
+    Example:
+        >>> from cuda.pathfinder import find_nvidia_binary_utility
+        >>> nvdisasm = find_nvidia_binary_utility("nvdisasm")
+        >>> if nvdisasm:
+        ...     print(f"Found nvdisasm at: {nvdisasm}")
+    """
+    if utility_name not in supported_nvidia_binaries.SUPPORTED_BINARIES:
+        raise UnsupportedBinaryError(utility_name)
+
+    # 1. Search in site-packages (NVIDIA wheels)
+    candidate_dirs = supported_nvidia_binaries.SITE_PACKAGES_BINDIRS.get(utility_name, ())
+    dirs = []
+
+    for sub_dir in candidate_dirs:
+        dirs.extend(find_sub_dirs_all_sitepackages(sub_dir.split(os.sep)))
+
+    # 2. Search in Conda environment
+    if (conda_prefix := os.environ.get("CONDA_PREFIX")) is not None:
+        if IS_WINDOWS:
+            dirs.append(os.path.join(conda_prefix, "Library", "bin"))
+        else:
+            dirs.append(os.path.join(conda_prefix, "bin"))
+
+    # 3. Search in CUDA Toolkit (CUDA_HOME/CUDA_PATH)
+    if (cuda_home := get_cuda_path_or_home()) is not None:
+        if IS_WINDOWS:
+            dirs.append(os.path.join(cuda_home, "bin", "x64"))
+            dirs.append(os.path.join(cuda_home, "bin", "x86_64"))
+        dirs.append(os.path.join(cuda_home, "bin"))
+
+    normalized_name = _normalize_utility_name(utility_name)
+    return shutil.which(normalized_name, path=os.pathsep.join(dirs))

lib/python3.11/site-packages/cuda/pathfinder/_binaries/supported_nvidia_binaries.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+import os
+
+# Site-packages bin directories where binaries might be found
+# Based on NVIDIA wheel layouts (same for Linux and Windows)
+_CUDA_NVCC_BIN = os.path.join("nvidia", "cuda_nvcc", "bin")
+_CUDA13_BIN = os.path.join("nvidia", "cu13", "bin")
+_NSIGHT_SYSTEMS_BIN = os.path.join("nvidia", "nsight_systems", "bin")
+_NSIGHT_COMPUTE_BIN = os.path.join("nvidia", "nsight_compute", "bin")
+
+# Common CUDA binary utilities available on both Linux and Windows
+SITE_PACKAGES_BINDIRS = {
+    # Core compilation tools
+    "nvcc": (_CUDA13_BIN, _CUDA_NVCC_BIN),
+    "nvdisasm": (_CUDA13_BIN, _CUDA_NVCC_BIN),
+    "cuobjdump": (_CUDA_NVCC_BIN,),
+    "nvprune": (_CUDA_NVCC_BIN,),
+    "fatbinary": (_CUDA13_BIN, _CUDA_NVCC_BIN),
+    "bin2c": (_CUDA13_BIN, _CUDA_NVCC_BIN),
+    "nvlink": (_CUDA13_BIN, _CUDA_NVCC_BIN),
+    # Runtime/debugging tools
+    "cuda-gdb": (_CUDA_NVCC_BIN,),
+    "cuda-gdbserver": (_CUDA_NVCC_BIN,),
+    "compute-sanitizer": (_CUDA13_BIN, _CUDA_NVCC_BIN),
+    # Profiling tools
+    "nvprof": (_CUDA_NVCC_BIN,),
+    "nsys": (_NSIGHT_SYSTEMS_BIN,),
+    "nsight-sys": (_NSIGHT_SYSTEMS_BIN,),
+    "ncu": (_NSIGHT_COMPUTE_BIN,),
+    "nsight-compute": (_NSIGHT_COMPUTE_BIN,),
+}
+
+SUPPORTED_BINARIES_ALL = SUPPORTED_BINARIES = tuple(SITE_PACKAGES_BINDIRS.keys())

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/descriptor_catalog.py

@@ -0,0 +1,407 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Canonical authored descriptor catalog for dynamic libraries."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+PackagedWith = Literal["ctk", "other", "driver"]
+
+
+@dataclass(frozen=True, slots=True)
+class DescriptorSpec:
+    name: str
+    packaged_with: PackagedWith
+    linux_sonames: tuple[str, ...] = ()
+    windows_dlls: tuple[str, ...] = ()
+    site_packages_linux: tuple[str, ...] = ()
+    site_packages_windows: tuple[str, ...] = ()
+    dependencies: tuple[str, ...] = ()
+    anchor_rel_dirs_linux: tuple[str, ...] = ("lib64", "lib")
+    anchor_rel_dirs_windows: tuple[str, ...] = ("bin/x64", "bin")
+    ctk_root_canary_anchor_libnames: tuple[str, ...] = ()
+    requires_add_dll_directory: bool = False
+    requires_rtld_deepbind: bool = False
+
+
+DESCRIPTOR_CATALOG: tuple[DescriptorSpec, ...] = (
+    # -----------------------------------------------------------------------
+    # CTK (CUDA Toolkit) libraries
+    # -----------------------------------------------------------------------
+    DescriptorSpec(
+        name="cudart",
+        packaged_with="ctk",
+        linux_sonames=("libcudart.so.12", "libcudart.so.13"),
+        windows_dlls=("cudart64_12.dll", "cudart64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cuda_runtime/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cuda_runtime/bin"),
+    ),
+    DescriptorSpec(
+        name="nvfatbin",
+        packaged_with="ctk",
+        linux_sonames=("libnvfatbin.so.12", "libnvfatbin.so.13"),
+        windows_dlls=("nvfatbin_120_0.dll", "nvfatbin_130_0.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/nvfatbin/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/nvfatbin/bin"),
+    ),
+    DescriptorSpec(
+        name="nvJitLink",
+        packaged_with="ctk",
+        linux_sonames=("libnvJitLink.so.12", "libnvJitLink.so.13"),
+        windows_dlls=("nvJitLink_120_0.dll", "nvJitLink_130_0.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/nvjitlink/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/nvjitlink/bin"),
+    ),
+    DescriptorSpec(
+        name="nvrtc",
+        packaged_with="ctk",
+        linux_sonames=("libnvrtc.so.12", "libnvrtc.so.13"),
+        windows_dlls=("nvrtc64_120_0.dll", "nvrtc64_130_0.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cuda_nvrtc/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cuda_nvrtc/bin"),
+        requires_add_dll_directory=True,
+    ),
+    DescriptorSpec(
+        name="nvvm",
+        packaged_with="ctk",
+        linux_sonames=("libnvvm.so.4",),
+        windows_dlls=("nvvm64.dll", "nvvm64_40_0.dll", "nvvm70.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cuda_nvcc/nvvm/lib64"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cuda_nvcc/nvvm/bin"),
+        anchor_rel_dirs_linux=("nvvm/lib64",),
+        anchor_rel_dirs_windows=("nvvm/bin/*", "nvvm/bin"),
+        ctk_root_canary_anchor_libnames=("cudart",),
+    ),
+    DescriptorSpec(
+        name="cublas",
+        packaged_with="ctk",
+        linux_sonames=("libcublas.so.12", "libcublas.so.13"),
+        windows_dlls=("cublas64_12.dll", "cublas64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cublas/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cublas/bin"),
+        dependencies=("cublasLt",),
+    ),
+    DescriptorSpec(
+        name="cublasLt",
+        packaged_with="ctk",
+        linux_sonames=("libcublasLt.so.12", "libcublasLt.so.13"),
+        windows_dlls=("cublasLt64_12.dll", "cublasLt64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cublas/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cublas/bin"),
+    ),
+    DescriptorSpec(
+        name="cufft",
+        packaged_with="ctk",
+        linux_sonames=("libcufft.so.11", "libcufft.so.12"),
+        windows_dlls=("cufft64_11.dll", "cufft64_12.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cufft/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cufft/bin"),
+        requires_add_dll_directory=True,
+    ),
+    DescriptorSpec(
+        name="cufftw",
+        packaged_with="ctk",
+        linux_sonames=("libcufftw.so.11", "libcufftw.so.12"),
+        windows_dlls=("cufftw64_11.dll", "cufftw64_12.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cufft/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cufft/bin"),
+        dependencies=("cufft",),
+    ),
+    DescriptorSpec(
+        name="curand",
+        packaged_with="ctk",
+        linux_sonames=("libcurand.so.10",),
+        windows_dlls=("curand64_10.dll",),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/curand/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/curand/bin"),
+    ),
+    DescriptorSpec(
+        name="cusolver",
+        packaged_with="ctk",
+        linux_sonames=("libcusolver.so.11", "libcusolver.so.12"),
+        windows_dlls=("cusolver64_11.dll", "cusolver64_12.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cusolver/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cusolver/bin"),
+        dependencies=("nvJitLink", "cusparse", "cublasLt", "cublas"),
+    ),
+    DescriptorSpec(
+        name="cusolverMg",
+        packaged_with="ctk",
+        linux_sonames=("libcusolverMg.so.11", "libcusolverMg.so.12"),
+        windows_dlls=("cusolverMg64_11.dll", "cusolverMg64_12.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cusolver/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cusolver/bin"),
+        dependencies=("nvJitLink", "cublasLt", "cublas"),
+    ),
+    DescriptorSpec(
+        name="cusparse",
+        packaged_with="ctk",
+        linux_sonames=("libcusparse.so.12",),
+        windows_dlls=("cusparse64_12.dll",),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cusparse/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cusparse/bin"),
+        dependencies=("nvJitLink",),
+    ),
+    DescriptorSpec(
+        name="nppc",
+        packaged_with="ctk",
+        linux_sonames=("libnppc.so.12", "libnppc.so.13"),
+        windows_dlls=("nppc64_12.dll", "nppc64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"),
+    ),
+    DescriptorSpec(
+        name="nppial",
+        packaged_with="ctk",
+        linux_sonames=("libnppial.so.12", "libnppial.so.13"),
+        windows_dlls=("nppial64_12.dll", "nppial64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"),
+        dependencies=("nppc",),
+    ),
+    DescriptorSpec(
+        name="nppicc",
+        packaged_with="ctk",
+        linux_sonames=("libnppicc.so.12", "libnppicc.so.13"),
+        windows_dlls=("nppicc64_12.dll", "nppicc64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"),
+        dependencies=("nppc",),
+    ),
+    DescriptorSpec(
+        name="nppidei",
+        packaged_with="ctk",
+        linux_sonames=("libnppidei.so.12", "libnppidei.so.13"),
+        windows_dlls=("nppidei64_12.dll", "nppidei64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"),
+        dependencies=("nppc",),
+    ),
+    DescriptorSpec(
+        name="nppif",
+        packaged_with="ctk",
+        linux_sonames=("libnppif.so.12", "libnppif.so.13"),
+        windows_dlls=("nppif64_12.dll", "nppif64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"),
+        dependencies=("nppc",),
+    ),
+    DescriptorSpec(
+        name="nppig",
+        packaged_with="ctk",
+        linux_sonames=("libnppig.so.12", "libnppig.so.13"),
+        windows_dlls=("nppig64_12.dll", "nppig64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"),
+        dependencies=("nppc",),
+    ),
+    DescriptorSpec(
+        name="nppim",
+        packaged_with="ctk",
+        linux_sonames=("libnppim.so.12", "libnppim.so.13"),
+        windows_dlls=("nppim64_12.dll", "nppim64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"),
+        dependencies=("nppc",),
+    ),
+    DescriptorSpec(
+        name="nppist",
+        packaged_with="ctk",
+        linux_sonames=("libnppist.so.12", "libnppist.so.13"),
+        windows_dlls=("nppist64_12.dll", "nppist64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"),
+        dependencies=("nppc",),
+    ),
+    DescriptorSpec(
+        name="nppisu",
+        packaged_with="ctk",
+        linux_sonames=("libnppisu.so.12", "libnppisu.so.13"),
+        windows_dlls=("nppisu64_12.dll", "nppisu64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"),
+        dependencies=("nppc",),
+    ),
+    DescriptorSpec(
+        name="nppitc",
+        packaged_with="ctk",
+        linux_sonames=("libnppitc.so.12", "libnppitc.so.13"),
+        windows_dlls=("nppitc64_12.dll", "nppitc64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"),
+        dependencies=("nppc",),
+    ),
+    DescriptorSpec(
+        name="npps",
+        packaged_with="ctk",
+        linux_sonames=("libnpps.so.12", "libnpps.so.13"),
+        windows_dlls=("npps64_12.dll", "npps64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/npp/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/npp/bin"),
+        dependencies=("nppc",),
+    ),
+    DescriptorSpec(
+        name="nvblas",
+        packaged_with="ctk",
+        linux_sonames=("libnvblas.so.12", "libnvblas.so.13"),
+        windows_dlls=("nvblas64_12.dll", "nvblas64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cublas/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cublas/bin"),
+        dependencies=("cublas", "cublasLt"),
+    ),
+    DescriptorSpec(
+        name="nvjpeg",
+        packaged_with="ctk",
+        linux_sonames=("libnvjpeg.so.12", "libnvjpeg.so.13"),
+        windows_dlls=("nvjpeg64_12.dll", "nvjpeg64_13.dll"),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/nvjpeg/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/nvjpeg/bin"),
+    ),
+    DescriptorSpec(
+        name="cufile",
+        packaged_with="ctk",
+        linux_sonames=("libcufile.so.0",),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cufile/lib"),
+    ),
+    DescriptorSpec(
+        name="cupti",
+        packaged_with="ctk",
+        linux_sonames=("libcupti.so.12", "libcupti.so.13"),
+        windows_dlls=(
+            "cupti64_2026.1.1.dll",
+            "cupti64_2026.1.0.dll",
+            "cupti64_2025.4.1.dll",
+            "cupti64_2025.3.1.dll",
+            "cupti64_2025.2.1.dll",
+            "cupti64_2025.1.1.dll",
+            "cupti64_2024.3.2.dll",
+            "cupti64_2024.2.1.dll",
+            "cupti64_2024.1.1.dll",
+            "cupti64_2023.3.1.dll",
+            "cupti64_2023.2.2.dll",
+            "cupti64_2023.1.1.dll",
+            "cupti64_2022.4.1.dll",
+        ),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cuda_cupti/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x86_64", "nvidia/cuda_cupti/bin"),
+        anchor_rel_dirs_linux=("extras/CUPTI/lib64", "lib"),
+        anchor_rel_dirs_windows=("extras/CUPTI/lib64", "bin"),
+        ctk_root_canary_anchor_libnames=("cudart",),
+    ),
+    DescriptorSpec(
+        name="cudla",
+        packaged_with="ctk",
+        linux_sonames=("libcudla.so.1",),
+        site_packages_linux=("nvidia/cu13/lib",),
+    ),
+    # -----------------------------------------------------------------------
+    # Third-party / separately packaged libraries
+    # -----------------------------------------------------------------------
+    DescriptorSpec(
+        name="cublasmp",
+        packaged_with="other",
+        linux_sonames=("libcublasmp.so.0",),
+        site_packages_linux=("nvidia/cublasmp/cu13/lib", "nvidia/cublasmp/cu12/lib"),
+        dependencies=("cublas", "cublasLt", "nvshmem_host"),
+    ),
+    DescriptorSpec(
+        name="cufftMp",
+        packaged_with="other",
+        linux_sonames=("libcufftMp.so.12", "libcufftMp.so.11"),
+        site_packages_linux=("nvidia/cufftmp/cu13/lib", "nvidia/cufftmp/cu12/lib"),
+        dependencies=("nvshmem_host",),
+        requires_rtld_deepbind=True,
+    ),
+    DescriptorSpec(
+        name="cusolverMp",
+        packaged_with="other",
+        linux_sonames=("libcusolverMp.so.0",),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cu12/lib"),
+        dependencies=("cublas", "cudart", "cusolver", "nccl"),
+    ),
+    DescriptorSpec(
+        name="mathdx",
+        packaged_with="other",
+        linux_sonames=("libmathdx.so.0",),
+        windows_dlls=("mathdx64_0.dll",),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cu12/lib"),
+        site_packages_windows=("nvidia/cu13/bin", "nvidia/cu12/bin"),
+        dependencies=("nvrtc",),
+    ),
+    DescriptorSpec(
+        name="cudss",
+        packaged_with="other",
+        linux_sonames=("libcudss.so.0",),
+        windows_dlls=("cudss64_0.dll",),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cu12/lib"),
+        site_packages_windows=("nvidia/cu13/bin", "nvidia/cu12/bin"),
+        dependencies=("cublas", "cublasLt"),
+    ),
+    DescriptorSpec(
+        name="cusparseLt",
+        packaged_with="other",
+        linux_sonames=("libcusparseLt.so.0",),
+        windows_dlls=("cusparseLt.dll",),
+        site_packages_linux=("nvidia/cu13/lib", "nvidia/cusparselt/lib"),
+        site_packages_windows=("nvidia/cu13/bin/x64", "nvidia/cusparselt/bin"),
+    ),
+    DescriptorSpec(
+        name="cutensor",
+        packaged_with="other",
+        linux_sonames=("libcutensor.so.2",),
+        windows_dlls=("cutensor.dll",),
+        site_packages_linux=("cutensor/lib",),
+        site_packages_windows=("cutensor/bin",),
+        dependencies=("cublasLt",),
+    ),
+    DescriptorSpec(
+        name="cutensorMg",
+        packaged_with="other",
+        linux_sonames=("libcutensorMg.so.2",),
+        windows_dlls=("cutensorMg.dll",),
+        site_packages_linux=("cutensor/lib",),
+        site_packages_windows=("cutensor/bin",),
+        dependencies=("cutensor", "cublasLt"),
+    ),
+    DescriptorSpec(
+        name="nccl",
+        packaged_with="other",
+        linux_sonames=("libnccl.so.2",),
+        site_packages_linux=("nvidia/nccl/lib",),
+    ),
+    DescriptorSpec(
+        name="nvpl_fftw",
+        packaged_with="other",
+        linux_sonames=("libnvpl_fftw.so.0",),
+        site_packages_linux=("nvpl/lib",),
+    ),
+    DescriptorSpec(
+        name="nvshmem_host",
+        packaged_with="other",
+        linux_sonames=("libnvshmem_host.so.3",),
+        site_packages_linux=("nvidia/nvshmem/lib",),
+    ),
+    # -----------------------------------------------------------------------
+    # Driver libraries (system-search only, no CTK cascade)
+    # -----------------------------------------------------------------------
+    DescriptorSpec(
+        name="cuda",
+        packaged_with="driver",
+        linux_sonames=("libcuda.so.1",),
+        windows_dlls=("nvcuda.dll",),
+    ),
+    DescriptorSpec(
+        name="nvcudla",
+        packaged_with="driver",
+        linux_sonames=("libnvcudla.so",),
+    ),
+    DescriptorSpec(
+        name="nvml",
+        packaged_with="driver",
+        linux_sonames=("libnvidia-ml.so.1",),
+        windows_dlls=("nvml.dll",),
+    ),
+)

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/dynamic_lib_subprocess.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import os
+import sys
+from collections.abc import Sequence
+
+from cuda.pathfinder._dynamic_libs.lib_descriptor import LIB_DESCRIPTORS
+from cuda.pathfinder._dynamic_libs.load_dl_common import DynamicLibNotFoundError, LoadedDL
+from cuda.pathfinder._dynamic_libs.platform_loader import LOADER
+from cuda.pathfinder._dynamic_libs.subprocess_protocol import (
+    MODE_CANARY,
+    MODE_LOAD,
+    STATUS_NOT_FOUND,
+    STATUS_OK,
+    VALID_MODES,
+    format_dynamic_lib_subprocess_payload,
+)
+
+# NOTE: The main entrypoint (below) serves both production (canary probe)
+# and tests (full loader). Keeping them together ensures a single subprocess
+# protocol and CLI surface, so the test subprocess stays aligned with the
+# production flow while avoiding a separate test-only module.
+# Any production-code impact is negligible since the extra logic only runs
+# in the subprocess entrypoint and only in test mode.
+
+
+def _probe_canary_abs_path(libname: str) -> str | None:
+    desc = LIB_DESCRIPTORS.get(libname)
+    if desc is None:
+        raise ValueError(f"Unsupported canary library name: {libname!r}")
+    try:
+        loaded: LoadedDL | None = LOADER.load_with_system_search(desc)
+    except DynamicLibNotFoundError:
+        return None
+    if loaded is None:
+        return None
+    abs_path: str | None = loaded.abs_path
+    return abs_path
+
+
+def _validate_abs_path(abs_path: str) -> None:
+    assert abs_path, f"empty path: {abs_path=!r}"
+    assert os.path.isabs(abs_path), f"not absolute: {abs_path=!r}"
+    assert os.path.isfile(abs_path), f"not a file: {abs_path=!r}"
+
+
+def _load_nvidia_dynamic_lib_for_test(libname: str) -> str:
+    """Test-only loader used by the subprocess entrypoint."""
+    # Keep imports inside the subprocess body so startup stays focused on the
+    # code under test rather than the parent test module.
+    from cuda.pathfinder import load_nvidia_dynamic_lib
+    from cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib import _load_lib_no_cache
+    from cuda.pathfinder._dynamic_libs.supported_nvidia_libs import (
+        SUPPORTED_LINUX_SONAMES,
+        SUPPORTED_WINDOWS_DLLS,
+    )
+    from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+
+    loaded_dl_fresh = load_nvidia_dynamic_lib(libname)
+    if loaded_dl_fresh.was_already_loaded_from_elsewhere:
+        raise RuntimeError("loaded_dl_fresh.was_already_loaded_from_elsewhere")
+
+    abs_path = loaded_dl_fresh.abs_path
+    if not isinstance(abs_path, str):
+        raise RuntimeError(f"loaded_dl_fresh.abs_path is not a string: {abs_path!r}")
+    _validate_abs_path(abs_path)
+    assert loaded_dl_fresh.found_via is not None
+
+    loaded_dl_from_cache = load_nvidia_dynamic_lib(libname)
+    if loaded_dl_from_cache is not loaded_dl_fresh:
+        raise RuntimeError("loaded_dl_from_cache is not loaded_dl_fresh")
+
+    loaded_dl_no_cache = _load_lib_no_cache(libname)
+    supported_libs = SUPPORTED_WINDOWS_DLLS if IS_WINDOWS else SUPPORTED_LINUX_SONAMES
+    if not loaded_dl_no_cache.was_already_loaded_from_elsewhere and libname in supported_libs:
+        raise RuntimeError("not loaded_dl_no_cache.was_already_loaded_from_elsewhere")
+    abs_path_no_cache = loaded_dl_no_cache.abs_path
+    if not isinstance(abs_path_no_cache, str):
+        raise RuntimeError(f"loaded_dl_no_cache.abs_path is not a string: {abs_path_no_cache!r}")
+    if not os.path.samefile(abs_path_no_cache, abs_path):
+        raise RuntimeError(f"not os.path.samefile({abs_path_no_cache=!r}, {abs_path=!r})")
+    _validate_abs_path(abs_path_no_cache)
+    return abs_path
+
+
+def probe_dynamic_lib_and_print_json(libname: str, mode: str) -> None:
+    if mode == MODE_CANARY:
+        abs_path = _probe_canary_abs_path(libname)
+        status = STATUS_OK if abs_path is not None else STATUS_NOT_FOUND
+        print(format_dynamic_lib_subprocess_payload(status, abs_path))
+        return
+
+    if mode == MODE_LOAD:
+        # Test-only path: exercises full loader behavior in isolation.
+        try:
+            abs_path = _load_nvidia_dynamic_lib_for_test(libname)
+        except DynamicLibNotFoundError as exc:
+            error = {
+                "type": exc.__class__.__name__,
+                "message": str(exc),
+            }
+            print(format_dynamic_lib_subprocess_payload(STATUS_NOT_FOUND, None, error=error))
+            return
+        print(format_dynamic_lib_subprocess_payload(STATUS_OK, abs_path))
+        return
+
+    raise ValueError(f"Unsupported subprocess probe mode: {mode!r}")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if len(args) != 2 or args[0] not in VALID_MODES:
+        modes = ", ".join(VALID_MODES)
+        raise SystemExit(
+            f"Usage: python -m cuda.pathfinder._dynamic_libs.dynamic_lib_subprocess <mode> <libname>\nModes: {modes}"
+        )
+    mode, libname = args
+    probe_dynamic_lib_and_print_json(libname, mode)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/lib_descriptor.py

@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Per-library descriptor and registry.
+
+The canonical authored data lives in :mod:`descriptor_catalog`. This module
+provides a name-keyed registry consumed by the runtime search/load path.
+"""
+
+from __future__ import annotations
+
+from typing import TypeAlias
+
+from cuda.pathfinder._dynamic_libs.descriptor_catalog import (
+    DESCRIPTOR_CATALOG,
+    DescriptorSpec,
+)
+
+# Keep the historical type name for downstream imports.
+LibDescriptor: TypeAlias = DescriptorSpec
+
+
+#: Canonical registry of all known libraries.
+LIB_DESCRIPTORS: dict[str, LibDescriptor] = {desc.name: desc for desc in DESCRIPTOR_CATALOG}

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/load_dl_common.py

@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from cuda.pathfinder._dynamic_libs.lib_descriptor import LibDescriptor
+
+
+class DynamicLibNotFoundError(RuntimeError):
+    pass
+
+
+class DynamicLibNotAvailableError(DynamicLibNotFoundError):
+    pass
+
+
+class DynamicLibUnknownError(DynamicLibNotFoundError):
+    pass
+
+
+@dataclass
+class LoadedDL:
+    abs_path: str | None
+    was_already_loaded_from_elsewhere: bool
+    _handle_uint: int  # Platform-agnostic unsigned pointer value
+    found_via: str  # "CUDA_PATH" covers both CUDA_PATH and CUDA_HOME env vars
+
+
+def load_dependencies(desc: LibDescriptor, load_func: Callable[[str], LoadedDL]) -> None:
+    for dep in desc.dependencies:
+        load_func(dep)

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/load_dl_linux.py

@@ -0,0 +1,221 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import contextlib
+import ctypes
+import ctypes.util
+import os
+from typing import TYPE_CHECKING, cast
+
+from cuda.pathfinder._dynamic_libs.load_dl_common import LoadedDL
+
+if TYPE_CHECKING:
+    from cuda.pathfinder._dynamic_libs.lib_descriptor import LibDescriptor
+
+CDLL_MODE = os.RTLD_NOW | os.RTLD_GLOBAL
+
+
+def _load_libdl() -> ctypes.CDLL:
+    # In normal glibc-based Linux environments, find_library("dl") should return
+    # something like "libdl.so.2". In minimal or stripped-down environments
+    # (no ldconfig/gcc, incomplete linker cache), this can return None even
+    # though libdl is present. In that case, we fall back to the stable SONAME.
+    name = ctypes.util.find_library("dl") or "libdl.so.2"
+    try:
+        return ctypes.CDLL(name)
+    except OSError as e:
+        raise RuntimeError(f"Could not load {name!r} (required for dlinfo/dlerror on Linux)") from e
+
+
+LIBDL = _load_libdl()
+
+# dlinfo
+LIBDL.dlinfo.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p]
+LIBDL.dlinfo.restype = ctypes.c_int
+
+# dlerror (thread-local error string; cleared after read)
+LIBDL.dlerror.argtypes = []
+LIBDL.dlerror.restype = ctypes.c_char_p
+
+# First appeared in 2004-era glibc. Universally correct on Linux for all practical purposes.
+RTLD_DI_LINKMAP = 2
+RTLD_DI_ORIGIN = 6
+
+
+class _LinkMapLNameView(ctypes.Structure):
+    """
+    Prefix-only view of glibc's `struct link_map` used **solely** to read `l_name`.
+
+    Background:
+      - `dlinfo(handle, RTLD_DI_LINKMAP, ...)` returns a `struct link_map*`.
+      - The first few members of `struct link_map` (including `l_name`) have been
+        stable on glibc for decades and are documented as debugger-visible.
+      - We only need the offset/layout of `l_name`, not the full struct.
+
+    Safety constraints:
+      - This is a **partial** definition (prefix). It must only be used via a pointer
+        returned by `dlinfo(...)`.
+      - Do **not** instantiate it or pass it **by value** to any C function.
+      - Do **not** access any members beyond those declared here.
+      - Do **not** rely on `ctypes.sizeof(LinkMapPrefix)` for allocation.
+
+    Rationale:
+      - Defining only the leading fields avoids depending on internal/unstable
+        tail members while keeping code more readable than raw pointer arithmetic.
+    """
+
+    _fields_ = (
+        ("l_addr", ctypes.c_void_p),  # ElfW(Addr)
+        ("l_name", ctypes.c_char_p),  # char*
+    )
+
+
+# Defensive assertions, mainly  to document the invariants we depend on
+assert _LinkMapLNameView.l_addr.offset == 0
+assert _LinkMapLNameView.l_name.offset == ctypes.sizeof(ctypes.c_void_p)
+
+
+def _dl_last_error() -> str | None:
+    msg_bytes = cast(bytes | None, LIBDL.dlerror())
+    if not msg_bytes:
+        return None  # no pending error
+    # Never raises; undecodable bytes are mapped to U+DC80..U+DCFF
+    return msg_bytes.decode("utf-8", "surrogateescape")
+
+
+def l_name_for_dynamic_library(libname: str, handle: ctypes.CDLL) -> str:
+    lm_view = ctypes.POINTER(_LinkMapLNameView)()
+    rc = LIBDL.dlinfo(ctypes.c_void_p(handle._handle), RTLD_DI_LINKMAP, ctypes.byref(lm_view))
+    if rc != 0:
+        err = _dl_last_error()
+        raise OSError(f"dlinfo failed for {libname=!r} (rc={rc})" + (f": {err}" if err else ""))
+    if not lm_view:  # NULL link_map**
+        raise OSError(f"dlinfo returned NULL link_map pointer for {libname=!r}")
+
+    l_name_bytes = lm_view.contents.l_name
+    if not l_name_bytes:
+        raise OSError(f"dlinfo returned empty link_map->l_name for {libname=!r}")
+
+    path = os.fsdecode(l_name_bytes)
+    if not path:
+        raise OSError(f"dlinfo returned empty l_name string for {libname=!r}")
+
+    return path
+
+
+def l_origin_for_dynamic_library(libname: str, handle: ctypes.CDLL) -> str:
+    l_origin_buf = ctypes.create_string_buffer(4096)
+    rc = LIBDL.dlinfo(ctypes.c_void_p(handle._handle), RTLD_DI_ORIGIN, l_origin_buf)
+    if rc != 0:
+        err = _dl_last_error()
+        raise OSError(f"dlinfo failed for {libname=!r} (rc={rc})" + (f": {err}" if err else ""))
+
+    path = os.fsdecode(l_origin_buf.value)
+    if not path:
+        raise OSError(f"dlinfo returned empty l_origin string for {libname=!r}")
+
+    return path
+
+
+def abs_path_for_dynamic_library(libname: str, handle: ctypes.CDLL) -> str:
+    l_name = l_name_for_dynamic_library(libname, handle)
+    l_origin = l_origin_for_dynamic_library(libname, handle)
+    return os.path.join(l_origin, os.path.basename(l_name))
+
+
+def _candidate_sonames(desc: LibDescriptor) -> list[str]:
+    # Reverse tabulated names to achieve new -> old search order.
+    candidates = list(reversed(desc.linux_sonames))
+    candidates.append(f"lib{desc.name}.so")
+    return candidates
+
+
+def check_if_already_loaded_from_elsewhere(desc: LibDescriptor, _have_abs_path: bool) -> LoadedDL | None:
+    for soname in _candidate_sonames(desc):
+        try:
+            handle = ctypes.CDLL(soname, mode=os.RTLD_NOLOAD)
+        except OSError:
+            continue
+        else:
+            return LoadedDL(
+                abs_path_for_dynamic_library(desc.name, handle),
+                True,
+                handle._handle,
+                "was-already-loaded-from-elsewhere",
+            )
+    return None
+
+
+def _load_lib(desc: LibDescriptor, filename: str) -> ctypes.CDLL:
+    cdll_mode = CDLL_MODE
+    if desc.requires_rtld_deepbind:
+        cdll_mode |= os.RTLD_DEEPBIND
+    return ctypes.CDLL(filename, cdll_mode)
+
+
+def load_with_system_search(desc: LibDescriptor) -> LoadedDL | None:
+    """Try to load a library using the native Linux dynamic-loader search path.
+
+    Args:
+        desc: Descriptor for the library to load
+
+    Returns:
+        A LoadedDL object if successful, None if the library cannot be loaded
+
+    Raises:
+        RuntimeError: If the library is loaded but no expected symbol is found
+    """
+    for soname in _candidate_sonames(desc):
+        try:
+            handle = _load_lib(desc, soname)
+        except OSError:
+            pass
+        else:
+            abs_path = abs_path_for_dynamic_library(desc.name, handle)
+            if abs_path is None:
+                raise RuntimeError(f"No expected symbol for libname={desc.name!r}")
+            return LoadedDL(abs_path, False, handle._handle, "system-search")
+    return None
+
+
+def _work_around_known_bugs(libname: str, found_path: str) -> None:
+    if libname == "nvrtc":
+        # Work around bug/oversight in
+        #   nvidia_cuda_nvrtc-13.0.48-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl
+        # Issue: libnvrtc.so.13 RUNPATH is not set.
+        # This workaround is highly specific
+        #   - for simplicity.
+        #   - to not mask bugs in future nvidia-cuda-nvrtc releases.
+        #   - because a more general workaround is complicated.
+        dirname, basename = os.path.split(found_path)
+        if basename == "libnvrtc.so.13":
+            dep_basename = "libnvrtc-builtins.so.13.0"
+            dep_path = os.path.join(dirname, dep_basename)
+            if os.path.isfile(dep_path):
+                # In case of failure, defer to primary load, which is almost certain to fail, too.
+                with contextlib.suppress(OSError):
+                    ctypes.CDLL(dep_path, CDLL_MODE)
+
+
+def load_with_abs_path(desc: LibDescriptor, found_path: str, found_via: str | None = None) -> LoadedDL:
+    """Load a dynamic library from the given path.
+
+    Args:
+        desc: Descriptor for the library to load.
+        found_path: The absolute path to the library file.
+        found_via: Label indicating how the path was discovered.
+
+    Returns:
+        A LoadedDL object representing the loaded library.
+
+    Raises:
+        RuntimeError: If the library cannot be loaded.
+    """
+    _work_around_known_bugs(desc.name, found_path)
+    try:
+        handle = _load_lib(desc, found_path)
+    except OSError as e:
+        raise RuntimeError(f"Failed to dlopen {found_path}: {e}") from e
+    return LoadedDL(found_path, False, handle._handle, found_via)

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/load_dl_windows.py

@@ -0,0 +1,167 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import ctypes
+import ctypes.wintypes
+import os
+import struct
+from typing import TYPE_CHECKING
+
+from cuda.pathfinder._dynamic_libs.load_dl_common import LoadedDL
+
+if TYPE_CHECKING:
+    from cuda.pathfinder._dynamic_libs.lib_descriptor import LibDescriptor
+
+# Mirrors WinBase.h (unfortunately not defined already elsewhere)
+WINBASE_LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100
+WINBASE_LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000
+
+POINTER_ADDRESS_SPACE = 2 ** (struct.calcsize("P") * 8)
+
+# Set up kernel32 functions with proper types
+kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]
+
+# GetModuleHandleW
+kernel32.GetModuleHandleW.argtypes = [ctypes.wintypes.LPCWSTR]
+kernel32.GetModuleHandleW.restype = ctypes.wintypes.HMODULE
+
+# LoadLibraryExW
+kernel32.LoadLibraryExW.argtypes = [
+    ctypes.wintypes.LPCWSTR,  # lpLibFileName
+    ctypes.wintypes.HANDLE,  # hFile (reserved, must be NULL)
+    ctypes.wintypes.DWORD,  # dwFlags
+]
+kernel32.LoadLibraryExW.restype = ctypes.wintypes.HMODULE
+
+# GetModuleFileNameW
+kernel32.GetModuleFileNameW.argtypes = [
+    ctypes.wintypes.HMODULE,  # hModule
+    ctypes.wintypes.LPWSTR,  # lpFilename
+    ctypes.wintypes.DWORD,  # nSize
+]
+kernel32.GetModuleFileNameW.restype = ctypes.wintypes.DWORD
+
+# AddDllDirectory (Windows 7+)
+kernel32.AddDllDirectory.argtypes = [ctypes.wintypes.LPCWSTR]
+kernel32.AddDllDirectory.restype = ctypes.c_void_p  # DLL_DIRECTORY_COOKIE
+
+
+def ctypes_handle_to_unsigned_int(handle: ctypes.wintypes.HMODULE) -> int:
+    """Convert ctypes HMODULE to unsigned int."""
+    handle_uint = int(handle)
+    if handle_uint < 0:
+        # Convert from signed to unsigned representation
+        handle_uint += POINTER_ADDRESS_SPACE
+    return handle_uint
+
+
+def add_dll_directory(dll_abs_path: str) -> None:
+    """Add a DLL directory to the search path and update PATH environment variable.
+
+    Args:
+        dll_abs_path: Absolute path to the DLL file
+
+    Raises:
+        AssertionError: If the directory containing the DLL does not exist
+    """
+    dirpath = os.path.dirname(dll_abs_path)
+    assert os.path.isdir(dirpath), dll_abs_path
+
+    # Add the DLL directory to the search path
+    result = kernel32.AddDllDirectory(dirpath)
+    if not result:
+        # Fallback: just update PATH if AddDllDirectory fails
+        pass
+
+    # Update PATH as a fallback for dependent DLL resolution
+    curr_path = os.environ.get("PATH")
+    os.environ["PATH"] = dirpath if curr_path is None else os.pathsep.join((curr_path, dirpath))
+
+
+def abs_path_for_dynamic_library(libname: str, handle: ctypes.wintypes.HMODULE) -> str:
+    """Get the absolute path of a loaded dynamic library on Windows."""
+    # Create buffer for the path
+    buffer = ctypes.create_unicode_buffer(260)  # MAX_PATH
+    length = kernel32.GetModuleFileNameW(handle, buffer, len(buffer))
+
+    if length == 0:
+        error_code = ctypes.GetLastError()  # type: ignore[attr-defined]
+        raise RuntimeError(f"GetModuleFileNameW failed for {libname!r} (error code: {error_code})")
+
+    # If buffer was too small, try with larger buffer
+    if length == len(buffer):
+        buffer = ctypes.create_unicode_buffer(32768)  # Extended path length
+        length = kernel32.GetModuleFileNameW(handle, buffer, len(buffer))
+        if length == 0:
+            error_code = ctypes.GetLastError()  # type: ignore[attr-defined]
+            raise RuntimeError(f"GetModuleFileNameW failed for {libname!r} (error code: {error_code})")
+
+    return buffer.value
+
+
+def check_if_already_loaded_from_elsewhere(desc: LibDescriptor, have_abs_path: bool) -> LoadedDL | None:
+    for dll_name in desc.windows_dlls:
+        handle = kernel32.GetModuleHandleW(dll_name)
+        if handle:
+            abs_path = abs_path_for_dynamic_library(desc.name, handle)
+            if have_abs_path and desc.requires_add_dll_directory:
+                # This is a side-effect if the pathfinder loads the library via
+                # load_with_abs_path(). To make the side-effect more deterministic,
+                # activate it even if the library was already loaded from elsewhere.
+                add_dll_directory(abs_path)
+            return LoadedDL(abs_path, True, ctypes_handle_to_unsigned_int(handle), "was-already-loaded-from-elsewhere")
+    return None
+
+
+def load_with_system_search(desc: LibDescriptor) -> LoadedDL | None:
+    """Try to load a DLL using the native Windows process DLL search path.
+
+    This calls ``LoadLibraryExW(dll_name, NULL, 0)`` directly. Under Python
+    3.8+, CPython configures the process with
+    ``SetDefaultDllDirectories(LOAD_LIBRARY_SEARCH_DEFAULT_DIRS)``, so this
+    search does **not** include the system ``PATH``. Directories added via
+    ``AddDllDirectory()`` still participate.
+
+    Args:
+        desc: Descriptor for the library to load
+
+    Returns:
+        A LoadedDL object if successful, None if the library cannot be loaded
+    """
+    # Reverse tabulated names to achieve new -> old search order.
+    for dll_name in reversed(desc.windows_dlls):
+        handle = kernel32.LoadLibraryExW(dll_name, None, 0)
+        if handle:
+            abs_path = abs_path_for_dynamic_library(desc.name, handle)
+            return LoadedDL(abs_path, False, ctypes_handle_to_unsigned_int(handle), "system-search")
+
+    return None
+
+
+def load_with_abs_path(desc: LibDescriptor, found_path: str, found_via: str | None = None) -> LoadedDL:
+    """Load a dynamic library from the given path.
+
+    Args:
+        desc: Descriptor for the library to load.
+        found_path: The absolute path to the DLL file.
+        found_via: Label indicating how the path was discovered.
+
+    Returns:
+        A LoadedDL object representing the loaded library.
+
+    Raises:
+        RuntimeError: If the DLL cannot be loaded.
+    """
+    if desc.requires_add_dll_directory:
+        add_dll_directory(found_path)
+
+    flags = WINBASE_LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | WINBASE_LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR
+    handle = kernel32.LoadLibraryExW(found_path, None, flags)
+
+    if not handle:
+        error_code = ctypes.GetLastError()  # type: ignore[attr-defined]
+        raise RuntimeError(f"Failed to load DLL at {found_path}: Windows error {error_code}")
+
+    return LoadedDL(found_path, False, ctypes_handle_to_unsigned_int(handle), found_via)

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/load_nvidia_dynamic_lib.py

@@ -0,0 +1,303 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import functools
+import struct
+import subprocess
+import sys
+from typing import TYPE_CHECKING
+
+from cuda.pathfinder._dynamic_libs.lib_descriptor import LIB_DESCRIPTORS
+from cuda.pathfinder._dynamic_libs.load_dl_common import (
+    DynamicLibNotAvailableError,
+    DynamicLibNotFoundError,
+    DynamicLibUnknownError,
+    LoadedDL,
+    load_dependencies,
+)
+from cuda.pathfinder._dynamic_libs.platform_loader import LOADER
+from cuda.pathfinder._dynamic_libs.search_steps import (
+    EARLY_FIND_STEPS,
+    LATE_FIND_STEPS,
+    SearchContext,
+    derive_ctk_root,
+    find_via_ctk_root,
+    run_find_steps,
+)
+from cuda.pathfinder._dynamic_libs.subprocess_protocol import (
+    DYNAMIC_LIB_SUBPROCESS_CWD,
+    MODE_CANARY,
+    STATUS_OK,
+    DynamicLibSubprocessPayload,
+    build_dynamic_lib_subprocess_command,
+    parse_dynamic_lib_subprocess_payload,
+)
+from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+
+if TYPE_CHECKING:
+    from cuda.pathfinder._dynamic_libs.lib_descriptor import LibDescriptor
+
+# All libnames recognized by load_nvidia_dynamic_lib, across all categories
+# (CTK, third-party, driver).
+_ALL_KNOWN_LIBNAMES: frozenset[str] = frozenset(LIB_DESCRIPTORS)
+_ALL_SUPPORTED_LIBNAMES: frozenset[str] = frozenset(
+    name for name, desc in LIB_DESCRIPTORS.items() if (desc.windows_dlls if IS_WINDOWS else desc.linux_sonames)
+)
+_PLATFORM_NAME = "Windows" if IS_WINDOWS else "Linux"
+_CANARY_PROBE_TIMEOUT_SECONDS = 10.0
+
+# Driver libraries: shipped with the NVIDIA display driver, always on the
+# system linker path.  These skip all CTK search steps (site-packages,
+# conda, CUDA_PATH, canary) and go straight to system search.
+_DRIVER_ONLY_LIBNAMES = frozenset(name for name, desc in LIB_DESCRIPTORS.items() if desc.packaged_with == "driver")
+
+
+def _load_driver_lib_no_cache(desc: LibDescriptor) -> LoadedDL:
+    """Load an NVIDIA driver library (system-search only).
+
+    Driver libs (libcuda, libnvidia-ml) are part of the display driver, not
+    the CUDA Toolkit. They are expected to be discoverable via the platform's
+    native loader mechanisms, so the full CTK search cascade (site-packages,
+    conda, CUDA_PATH, canary) is unnecessary.
+    """
+    loaded = LOADER.check_if_already_loaded_from_elsewhere(desc, False)
+    if loaded is not None:
+        return loaded
+    loaded = LOADER.load_with_system_search(desc)
+    if loaded is not None:
+        return loaded
+    raise DynamicLibNotFoundError(
+        f'"{desc.name}" is an NVIDIA driver library and can only be found via'
+        f" system search. Ensure the NVIDIA display driver is installed."
+    )
+
+
+def _coerce_subprocess_output(output: str | bytes | None) -> str:
+    if isinstance(output, bytes):
+        return output.decode(errors="replace")
+    return "" if output is None else output
+
+
+def _raise_canary_probe_child_process_error(
+    *,
+    returncode: int | None = None,
+    timeout: float | None = None,
+    stderr: str | bytes | None = None,
+) -> None:
+    if timeout is None:
+        error_line = f"Canary probe child process exited with code {returncode}."
+    else:
+        error_line = f"Canary probe child process timed out after {timeout} seconds."
+    raise ChildProcessError(
+        f"{error_line}\n"
+        "--- stderr-from-child-process ---\n"
+        f"{_coerce_subprocess_output(stderr)}"
+        "<end-of-stderr-from-child-process>\n"
+    )
+
+
+@functools.cache
+def _resolve_system_loaded_abs_path_in_subprocess(
+    libname: str,
+    *,
+    timeout: float = _CANARY_PROBE_TIMEOUT_SECONDS,
+) -> str | None:
+    """Resolve a canary library's absolute path in a fresh Python subprocess."""
+    try:
+        result = subprocess.run(  # noqa: S603 - trusted argv: current interpreter + internal probe module
+            build_dynamic_lib_subprocess_command(MODE_CANARY, libname),
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+            cwd=DYNAMIC_LIB_SUBPROCESS_CWD,
+        )
+    except subprocess.TimeoutExpired as exc:
+        _raise_canary_probe_child_process_error(timeout=exc.timeout, stderr=exc.stderr)
+
+    if result.returncode != 0:
+        _raise_canary_probe_child_process_error(returncode=result.returncode, stderr=result.stderr)
+
+    payload: DynamicLibSubprocessPayload = parse_dynamic_lib_subprocess_payload(
+        result.stdout,
+        libname=libname,
+        error_label="Canary probe child process",
+    )
+    abs_path: str | None = payload.abs_path
+    if payload.status == STATUS_OK:
+        return abs_path
+    return None
+
+
+def _loadable_via_canary_subprocess(libname: str, *, timeout: float = _CANARY_PROBE_TIMEOUT_SECONDS) -> bool:
+    """Return True if the canary subprocess can resolve ``libname`` via system search."""
+    return _resolve_system_loaded_abs_path_in_subprocess(libname, timeout=timeout) is not None
+
+
+def _try_ctk_root_canary(ctx: SearchContext) -> str | None:
+    """Try CTK-root canary fallback for descriptor-configured libraries."""
+    for canary_libname in ctx.desc.ctk_root_canary_anchor_libnames:
+        canary_abs_path = _resolve_system_loaded_abs_path_in_subprocess(canary_libname)
+        if canary_abs_path is None:
+            continue
+        ctk_root = derive_ctk_root(canary_abs_path)
+        if ctk_root is None:
+            continue
+        find = find_via_ctk_root(ctx, ctk_root)
+        if find is not None:
+            return str(find.abs_path)
+    return None
+
+
+def _load_lib_no_cache(libname: str) -> LoadedDL:
+    desc = LIB_DESCRIPTORS[libname]
+
+    if libname in _DRIVER_ONLY_LIBNAMES:
+        return _load_driver_lib_no_cache(desc)
+
+    ctx = SearchContext(desc)
+
+    # Phase 1: Try to find the library file on disk (pip wheels, conda).
+    find = run_find_steps(ctx, EARLY_FIND_STEPS)
+
+    # Phase 2: Cross-cutting — already-loaded check and dependency loading.
+    # The already-loaded check on Windows uses the "have we found a path?"
+    # flag to decide whether to apply AddDllDirectory side-effects.
+    loaded = LOADER.check_if_already_loaded_from_elsewhere(desc, find is not None)
+    load_dependencies(desc, load_nvidia_dynamic_lib)
+    if loaded is not None:
+        return loaded
+
+    # Phase 3: Load from found path, or fall back to system search + late find.
+    if find is not None:
+        return LOADER.load_with_abs_path(desc, find.abs_path, find.found_via)
+
+    loaded = LOADER.load_with_system_search(desc)
+    if loaded is not None:
+        return loaded
+
+    find = run_find_steps(ctx, LATE_FIND_STEPS)
+    if find is not None:
+        return LOADER.load_with_abs_path(desc, find.abs_path, find.found_via)
+
+    if desc.ctk_root_canary_anchor_libnames:
+        canary_abs_path = _try_ctk_root_canary(ctx)
+        if canary_abs_path is not None:
+            return LOADER.load_with_abs_path(desc, canary_abs_path, "system-ctk-root")
+
+    ctx.raise_not_found()
+
+
+@functools.cache
+def load_nvidia_dynamic_lib(libname: str) -> LoadedDL:
+    """Load an NVIDIA dynamic library by name.
+
+    Args:
+        libname (str): The short name of the library to load (e.g., ``"cudart"``,
+            ``"nvvm"``, etc.).
+
+    Returns:
+        LoadedDL: Object containing the OS library handle and absolute path.
+
+        **Important:**
+
+        **Never close the returned handle.** Do **not** call ``dlclose`` (Linux) or
+        ``FreeLibrary`` (Windows) on the ``LoadedDL._handle_uint``.
+
+        **Why:** the return value is cached (``functools.cache``) and shared across the
+        process. Closing the handle can unload the module while other code still uses
+        it, leading to crashes or subtle failures.
+
+        This applies to Linux and Windows. For context, see issue #1011:
+        https://github.com/NVIDIA/cuda-python/issues/1011
+
+    Raises:
+        DynamicLibUnknownError: If ``libname`` is not a recognized library name.
+        DynamicLibNotAvailableError: If ``libname`` is recognized but not
+            supported on this platform.
+        DynamicLibNotFoundError: If the library cannot be found or loaded.
+        RuntimeError: If Python is not 64-bit.
+
+    Search order:
+        0. **Already loaded in the current process**
+
+           - If a matching library is already loaded by some other component,
+             return its absolute path and handle and skip the rest of the search.
+
+        1. **NVIDIA Python wheels**
+
+           - Scan installed distributions (``site-packages``) to find libraries
+             shipped in NVIDIA wheels.
+
+        2. **Conda environment**
+
+           - Conda installations are discovered via ``CONDA_PREFIX``, which is
+             defined automatically in activated conda environments (see
+             https://docs.conda.io/projects/conda-build/en/stable/user-guide/environment-variables.html).
+
+        3. **OS default mechanisms**
+
+           - Fall back to the native loader:
+
+             - Linux: ``dlopen()``
+
+             - Windows: ``LoadLibraryExW()``
+
+             On Linux, CUDA Toolkit (CTK) system installs with system config updates are
+             usually discovered via ``/etc/ld.so.conf.d/*cuda*.conf``.
+
+             On Windows, under Python 3.8+, CPython configures the process with
+             ``SetDefaultDllDirectories(LOAD_LIBRARY_SEARCH_DEFAULT_DIRS)``.
+             As a result, the native DLL search used here does **not** include
+             the system ``PATH``.
+
+        4. **Environment variables**
+
+           - If set, use ``CUDA_PATH`` or ``CUDA_HOME`` (in that order).
+             On Windows, this is the typical way system-installed CTK DLLs are
+             located. Note that the NVIDIA CTK installer automatically
+             adds ``CUDA_PATH`` to the system-wide environment.
+
+        5. **CTK root canary probe (discoverable libs only)**
+
+           - For selected libraries whose shared object doesn't reside on the
+             standard linker path (currently ``nvvm``), attempt to derive CTK
+             root by system-loading a well-known CTK canary library in a
+             subprocess and then searching relative to that root. On Windows,
+             the canary uses the same native ``LoadLibraryExW`` semantics as
+             step 3, so there is also no ``PATH``-based discovery.
+
+    **Driver libraries** (``"cuda"``, ``"nvml"``):
+
+        These are part of the NVIDIA display driver (not the CUDA Toolkit) and
+        are expected to be reachable via the native OS loader path. For these
+        libraries the search is simplified to:
+
+        0. Already loaded in the current process
+        1. OS default mechanisms (``dlopen`` / ``LoadLibraryExW``)
+
+        The CTK-specific steps (site-packages, conda, ``CUDA_PATH``, canary
+        probe) are skipped entirely.
+
+    Notes:
+        The search is performed **per library**. There is currently no mechanism to
+        guarantee that multiple libraries are all resolved from the same location.
+
+    """
+    pointer_size_bits = struct.calcsize("P") * 8
+    if pointer_size_bits != 64:
+        raise RuntimeError(
+            f"cuda.pathfinder.load_nvidia_dynamic_lib() requires 64-bit Python."
+            f" Currently running: {pointer_size_bits}-bit Python"
+            f" {sys.version_info.major}.{sys.version_info.minor}"
+        )
+    if libname not in _ALL_KNOWN_LIBNAMES:
+        raise DynamicLibUnknownError(f"Unknown library name: {libname!r}. Known names: {sorted(_ALL_KNOWN_LIBNAMES)}")
+    if libname not in _ALL_SUPPORTED_LIBNAMES:
+        raise DynamicLibNotAvailableError(
+            f"Library name {libname!r} is known but not available on {_PLATFORM_NAME}. "
+            f"Supported names on {_PLATFORM_NAME}: {sorted(_ALL_SUPPORTED_LIBNAMES)}"
+        )
+    return _load_lib_no_cache(libname)

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/platform_loader.py

@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Platform loader seam for OS-specific dynamic linking.
+
+This module provides a small interface that hides the Linux vs Windows
+implementation details of:
+
+- already-loaded checks
+- system-search loading
+- absolute-path loading
+
+The orchestration logic in :mod:`load_nvidia_dynamic_lib` should not need to
+branch on platform; it calls through the loader instance exported here.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+from cuda.pathfinder._dynamic_libs.lib_descriptor import LibDescriptor
+from cuda.pathfinder._dynamic_libs.load_dl_common import LoadedDL
+from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+
+
+class PlatformLoader(Protocol):
+    def check_if_already_loaded_from_elsewhere(self, desc: LibDescriptor, have_abs_path: bool) -> LoadedDL | None: ...
+
+    def load_with_system_search(self, desc: LibDescriptor) -> LoadedDL | None: ...
+
+    def load_with_abs_path(self, desc: LibDescriptor, found_path: str, found_via: str | None = None) -> LoadedDL: ...
+
+
+if IS_WINDOWS:
+    from cuda.pathfinder._dynamic_libs import load_dl_windows as _impl
+else:
+    from cuda.pathfinder._dynamic_libs import load_dl_linux as _impl
+
+# The platform modules already expose functions matching the PlatformLoader
+# protocol. Wrap in a simple namespace so callers use LOADER.method() syntax.
+LOADER: PlatformLoader = _impl

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/search_platform.py

@@ -0,0 +1,219 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Platform abstraction for filesystem search steps.
+
+The goal is to keep :mod:`search_steps` platform-agnostic: it should not branch
+on OS flags like ``IS_WINDOWS``. Instead, it calls through the single
+``PLATFORM`` instance exported here.
+"""
+
+from __future__ import annotations
+
+import glob
+import os
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Protocol, cast
+
+from cuda.pathfinder._dynamic_libs.lib_descriptor import LibDescriptor
+from cuda.pathfinder._dynamic_libs.supported_nvidia_libs import is_suppressed_dll_file
+from cuda.pathfinder._utils.find_sub_dirs import find_sub_dirs_all_sitepackages
+from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+
+
+def _no_such_file_in_sub_dirs(
+    sub_dirs: Sequence[str], file_wild: str, error_messages: list[str], attachments: list[str]
+) -> None:
+    error_messages.append(f"No such file: {file_wild}")
+    for sub_dir in find_sub_dirs_all_sitepackages(sub_dirs):
+        attachments.append(f'  listdir("{sub_dir}"):')
+        for node in sorted(os.listdir(sub_dir)):
+            attachments.append(f"    {node}")
+
+
+def _find_so_in_rel_dirs(
+    rel_dirs: tuple[str, ...],
+    so_basename: str,
+    error_messages: list[str],
+    attachments: list[str],
+) -> str | None:
+    sub_dirs_searched: list[tuple[str, ...]] = []
+    file_wild = so_basename + "*"
+    for rel_dir in rel_dirs:
+        sub_dir = tuple(rel_dir.split(os.path.sep))
+        for abs_dir in find_sub_dirs_all_sitepackages(sub_dir):
+            # Exact unversioned match first; fall back to versioned names because some
+            # distros only ship lib<name>.so.<major> (e.g. conda libcupti). Only one match
+            # is expected in practice. Sort in reverse so the newest-sorting name wins if
+            # multiple coexist, matching the newest-first bias elsewhere in pathfinder
+            # (see LinuxSearchPlatform.find_in_lib_dir and load_dl_linux._candidate_sonames).
+            # Issue #1732 tracks the deferred question of raising on true ambiguity.
+            so_name = os.path.join(abs_dir, so_basename)
+            if os.path.isfile(so_name):
+                return so_name
+            for so_name in sorted(glob.glob(os.path.join(abs_dir, file_wild)), reverse=True):
+                if os.path.isfile(so_name):
+                    return so_name
+        sub_dirs_searched.append(sub_dir)
+    for sub_dir in sub_dirs_searched:
+        _no_such_file_in_sub_dirs(sub_dir, file_wild, error_messages, attachments)
+    return None
+
+
+def _find_dll_under_dir(dirpath: str, file_wild: str) -> str | None:
+    for path in sorted(glob.glob(os.path.join(dirpath, file_wild))):
+        if not os.path.isfile(path):
+            continue
+        if not is_suppressed_dll_file(os.path.basename(path)):
+            return path
+    return None
+
+
+def _find_dll_in_rel_dirs(
+    rel_dirs: tuple[str, ...],
+    lib_searched_for: str,
+    error_messages: list[str],
+    attachments: list[str],
+) -> str | None:
+    sub_dirs_searched: list[tuple[str, ...]] = []
+    for rel_dir in rel_dirs:
+        sub_dir = tuple(rel_dir.split(os.path.sep))
+        for abs_dir in find_sub_dirs_all_sitepackages(sub_dir):
+            dll_name = _find_dll_under_dir(abs_dir, lib_searched_for)
+            if dll_name is not None:
+                return dll_name
+        sub_dirs_searched.append(sub_dir)
+    for sub_dir in sub_dirs_searched:
+        _no_such_file_in_sub_dirs(sub_dir, lib_searched_for, error_messages, attachments)
+    return None
+
+
+class SearchPlatform(Protocol):
+    def lib_searched_for(self, libname: str) -> str: ...
+
+    def site_packages_rel_dirs(self, desc: LibDescriptor) -> tuple[str, ...]: ...
+
+    def conda_anchor_point(self, conda_prefix: str) -> str: ...
+
+    def anchor_rel_dirs(self, desc: LibDescriptor) -> tuple[str, ...]: ...
+
+    def find_in_site_packages(
+        self,
+        rel_dirs: tuple[str, ...],
+        lib_searched_for: str,
+        error_messages: list[str],
+        attachments: list[str],
+    ) -> str | None: ...
+
+    def find_in_lib_dir(
+        self,
+        lib_dir: str,
+        libname: str,
+        lib_searched_for: str,
+        error_messages: list[str],
+        attachments: list[str],
+    ) -> str | None: ...
+
+
+@dataclass(frozen=True, slots=True)
+class LinuxSearchPlatform:
+    def lib_searched_for(self, libname: str) -> str:
+        return f"lib{libname}.so"
+
+    def site_packages_rel_dirs(self, desc: LibDescriptor) -> tuple[str, ...]:
+        return cast(tuple[str, ...], desc.site_packages_linux)
+
+    def conda_anchor_point(self, conda_prefix: str) -> str:
+        return conda_prefix
+
+    def anchor_rel_dirs(self, desc: LibDescriptor) -> tuple[str, ...]:
+        return cast(tuple[str, ...], desc.anchor_rel_dirs_linux)
+
+    def find_in_site_packages(
+        self,
+        rel_dirs: tuple[str, ...],
+        lib_searched_for: str,
+        error_messages: list[str],
+        attachments: list[str],
+    ) -> str | None:
+        return _find_so_in_rel_dirs(rel_dirs, lib_searched_for, error_messages, attachments)
+
+    def find_in_lib_dir(
+        self,
+        lib_dir: str,
+        _libname: str,
+        lib_searched_for: str,
+        error_messages: list[str],
+        attachments: list[str],
+    ) -> str | None:
+        # Most libraries have both unversioned and versioned files/symlinks (exact match first)
+        so_name = os.path.join(lib_dir, lib_searched_for)
+        if os.path.isfile(so_name):
+            return so_name
+        # Some libraries only exist as versioned files (e.g., libcupti.so.13 in conda),
+        # so the glob fallback is needed
+        file_wild = lib_searched_for + "*"
+        # Only one match is expected, but to ensure deterministic behavior in unexpected
+        # situations, and to be internally consistent, we sort in reverse order with the
+        # intent to return the newest version first. Issue #1732 tracks the deferred
+        # question of raising on true ambiguity.
+        for so_name in sorted(glob.glob(os.path.join(lib_dir, file_wild)), reverse=True):
+            if os.path.isfile(so_name):
+                return so_name
+        error_messages.append(f"No such file: {file_wild}")
+        attachments.append(f'  listdir("{lib_dir}"):')
+        if not os.path.isdir(lib_dir):
+            attachments.append("    DIRECTORY DOES NOT EXIST")
+        else:
+            for node in sorted(os.listdir(lib_dir)):
+                attachments.append(f"    {node}")
+        return None
+
+
+@dataclass(frozen=True, slots=True)
+class WindowsSearchPlatform:
+    def lib_searched_for(self, libname: str) -> str:
+        return f"{libname}*.dll"
+
+    def site_packages_rel_dirs(self, desc: LibDescriptor) -> tuple[str, ...]:
+        return cast(tuple[str, ...], desc.site_packages_windows)
+
+    def conda_anchor_point(self, conda_prefix: str) -> str:
+        return os.path.join(conda_prefix, "Library")
+
+    def anchor_rel_dirs(self, desc: LibDescriptor) -> tuple[str, ...]:
+        return cast(tuple[str, ...], desc.anchor_rel_dirs_windows)
+
+    def find_in_site_packages(
+        self,
+        rel_dirs: tuple[str, ...],
+        lib_searched_for: str,
+        error_messages: list[str],
+        attachments: list[str],
+    ) -> str | None:
+        return _find_dll_in_rel_dirs(rel_dirs, lib_searched_for, error_messages, attachments)
+
+    def find_in_lib_dir(
+        self,
+        lib_dir: str,
+        libname: str,
+        _lib_searched_for: str,
+        error_messages: list[str],
+        attachments: list[str],
+    ) -> str | None:
+        file_wild = libname + "*.dll"
+        dll_name = _find_dll_under_dir(lib_dir, file_wild)
+        if dll_name is not None:
+            return dll_name
+        error_messages.append(f"No such file: {file_wild}")
+        attachments.append(f'  listdir("{lib_dir}"):')
+        if not os.path.isdir(lib_dir):
+            attachments.append("    DIRECTORY DOES NOT EXIST")
+        else:
+            for node in sorted(os.listdir(lib_dir)):
+                attachments.append(f"    {node}")
+        return None
+
+
+PLATFORM: SearchPlatform = WindowsSearchPlatform() if IS_WINDOWS else LinuxSearchPlatform()

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/search_steps.py

@@ -0,0 +1,228 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Composable search steps for locating NVIDIA libraries.
+
+Each find step is a callable with signature::
+
+    (SearchContext) -> FindResult | None
+
+Find steps locate a library file on disk without loading it.  The
+orchestrator in :mod:`load_nvidia_dynamic_lib` handles loading, the
+already-loaded check, and dependency resolution.
+
+Step sequences are defined per search strategy so that adding a new
+step or strategy only requires adding a function and a tuple entry.
+
+This module is intentionally platform-agnostic: it does not branch on the
+current operating system. Platform differences are routed through the
+:data:`~cuda.pathfinder._dynamic_libs.search_platform.PLATFORM` instance.
+"""
+
+import glob
+import os
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import NoReturn, cast
+
+from cuda.pathfinder._dynamic_libs.lib_descriptor import LibDescriptor
+from cuda.pathfinder._dynamic_libs.load_dl_common import DynamicLibNotFoundError
+from cuda.pathfinder._dynamic_libs.search_platform import PLATFORM, SearchPlatform
+from cuda.pathfinder._utils.env_vars import get_cuda_path_or_home
+
+# ---------------------------------------------------------------------------
+# Data types
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class FindResult:
+    """A library file located on disk (not yet loaded)."""
+
+    abs_path: str
+    found_via: str
+
+
+@dataclass
+class SearchContext:
+    """Mutable state accumulated during the search cascade."""
+
+    desc: LibDescriptor
+    platform: SearchPlatform = PLATFORM
+    error_messages: list[str] = field(default_factory=list)
+    attachments: list[str] = field(default_factory=list)
+
+    @property
+    def libname(self) -> str:
+        return self.desc.name  # type: ignore[no-any-return]  # mypy can't resolve new sibling module
+
+    @property
+    def lib_searched_for(self) -> str:
+        return cast(str, self.platform.lib_searched_for(self.libname))
+
+    def raise_not_found(self) -> NoReturn:
+        err = ", ".join(self.error_messages)
+        att = "\n".join(self.attachments)
+        raise DynamicLibNotFoundError(f'Failure finding "{self.lib_searched_for}": {err}\n{att}')
+
+
+#: Type alias for a find step callable.
+FindStep = Callable[[SearchContext], FindResult | None]
+
+
+def _find_lib_dir_using_anchor(desc: LibDescriptor, platform: SearchPlatform, anchor_point: str) -> str | None:
+    """Find the library directory under *anchor_point* using the descriptor's relative paths."""
+    rel_dirs = platform.anchor_rel_dirs(desc)
+    for rel_path in rel_dirs:
+        for dirname in sorted(glob.glob(os.path.join(anchor_point, rel_path))):
+            if os.path.isdir(dirname):
+                return os.path.normpath(dirname)
+    return None
+
+
+def _find_using_lib_dir(ctx: SearchContext, lib_dir: str | None) -> str | None:
+    """Find a library file in a resolved lib directory."""
+    if lib_dir is None:
+        return None
+    return cast(
+        str | None,
+        ctx.platform.find_in_lib_dir(
+            lib_dir,
+            ctx.libname,
+            ctx.lib_searched_for,
+            ctx.error_messages,
+            ctx.attachments,
+        ),
+    )
+
+
+def _derive_ctk_root_linux(resolved_lib_path: str) -> str | None:
+    """Derive CTK root from Linux canary path.
+
+    Supports:
+    - ``$CTK_ROOT/lib64/libfoo.so.*``
+    - ``$CTK_ROOT/lib/libfoo.so.*``
+    - ``$CTK_ROOT/targets/<triple>/lib64/libfoo.so.*``
+    - ``$CTK_ROOT/targets/<triple>/lib/libfoo.so.*``
+    """
+    lib_dir = os.path.dirname(resolved_lib_path)
+    basename = os.path.basename(lib_dir)
+    if basename in ("lib64", "lib"):
+        parent = os.path.dirname(lib_dir)
+        grandparent = os.path.dirname(parent)
+        if os.path.basename(grandparent) == "targets":
+            return os.path.dirname(grandparent)
+        return parent
+    return None
+
+
+def _derive_ctk_root_windows(resolved_lib_path: str) -> str | None:
+    """Derive CTK root from Windows canary path.
+
+    Supports:
+    - ``$CTK_ROOT/bin/x64/foo.dll`` (CTK 13 style)
+    - ``$CTK_ROOT/bin/foo.dll`` (CTK 12 style)
+    """
+    import ntpath
+
+    lib_dir = ntpath.dirname(resolved_lib_path)
+    basename = ntpath.basename(lib_dir).lower()
+    if basename == "x64":
+        parent = ntpath.dirname(lib_dir)
+        if ntpath.basename(parent).lower() == "bin":
+            return ntpath.dirname(parent)
+    elif basename == "bin":
+        return ntpath.dirname(lib_dir)
+    return None
+
+
+def derive_ctk_root(resolved_lib_path: str) -> str | None:
+    """Derive CTK root from a resolved canary library path."""
+    ctk_root = _derive_ctk_root_linux(resolved_lib_path)
+    if ctk_root is not None:
+        return ctk_root
+    return _derive_ctk_root_windows(resolved_lib_path)
+
+
+def find_via_ctk_root(ctx: SearchContext, ctk_root: str) -> FindResult | None:
+    """Find a library under a previously derived CTK root."""
+    lib_dir = _find_lib_dir_using_anchor(ctx.desc, ctx.platform, ctk_root)
+    abs_path = _find_using_lib_dir(ctx, lib_dir)
+    if abs_path is None:
+        return None
+    return FindResult(abs_path, "system-ctk-root")
+
+
+# ---------------------------------------------------------------------------
+# Find steps
+# ---------------------------------------------------------------------------
+
+
+def find_in_site_packages(ctx: SearchContext) -> FindResult | None:
+    """Search pip wheel install locations."""
+    rel_dirs = ctx.platform.site_packages_rel_dirs(ctx.desc)
+    if not rel_dirs:
+        return None
+    abs_path = ctx.platform.find_in_site_packages(rel_dirs, ctx.lib_searched_for, ctx.error_messages, ctx.attachments)
+    if abs_path is not None:
+        return FindResult(abs_path, "site-packages")
+    return None
+
+
+def find_in_conda(ctx: SearchContext) -> FindResult | None:
+    """Search ``$CONDA_PREFIX``."""
+    conda_prefix = os.environ.get("CONDA_PREFIX")
+    if not conda_prefix:
+        return None
+    anchor = ctx.platform.conda_anchor_point(conda_prefix)
+    lib_dir = _find_lib_dir_using_anchor(ctx.desc, ctx.platform, anchor)
+    abs_path = _find_using_lib_dir(ctx, lib_dir)
+    if abs_path is not None:
+        return FindResult(abs_path, "conda")
+    return None
+
+
+def find_in_cuda_path(ctx: SearchContext) -> FindResult | None:
+    """Search ``$CUDA_PATH`` / ``$CUDA_HOME``.
+
+    On Windows, this is the normal fallback for system-installed CTK DLLs when
+    they are not already discoverable via the native ``LoadLibraryExW(..., 0)``
+    path used by :func:`cuda.pathfinder._dynamic_libs.load_dl_windows.load_with_system_search`.
+    Python 3.8+ does not include ``PATH`` in that native DLL search.
+
+    The returned ``found_via`` is always ``"CUDA_PATH"`` regardless of which
+    environment variable actually provided the value.
+    """
+    cuda_home = get_cuda_path_or_home()
+    if cuda_home is None:
+        return None
+    lib_dir = _find_lib_dir_using_anchor(ctx.desc, ctx.platform, cuda_home)
+    abs_path = _find_using_lib_dir(ctx, lib_dir)
+    if abs_path is not None:
+        return FindResult(abs_path, "CUDA_PATH")
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Step sequences per strategy
+# ---------------------------------------------------------------------------
+
+#: Find steps that run before the already-loaded check and system search.
+EARLY_FIND_STEPS: tuple[FindStep, ...] = (find_in_site_packages, find_in_conda)
+
+#: Find steps that run after system search fails.
+LATE_FIND_STEPS: tuple[FindStep, ...] = (find_in_cuda_path,)
+
+
+# ---------------------------------------------------------------------------
+# Cascade runner
+# ---------------------------------------------------------------------------
+
+
+def run_find_steps(ctx: SearchContext, steps: tuple[FindStep, ...]) -> FindResult | None:
+    """Run find steps in order, returning the first hit."""
+    for step in steps:
+        result = step(ctx)
+        if result is not None:
+            return result
+    return None

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/subprocess_protocol.py

@@ -0,0 +1,71 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+MODE_CANARY: Literal["canary"] = "canary"
+MODE_LOAD: Literal["load"] = "load"
+VALID_MODES: tuple[Literal["canary"], Literal["load"]] = (MODE_CANARY, MODE_LOAD)
+
+STATUS_OK: Literal["ok"] = "ok"
+STATUS_NOT_FOUND: Literal["not-found"] = "not-found"
+
+DYNAMIC_LIB_SUBPROCESS_MODULE = "cuda.pathfinder._dynamic_libs.dynamic_lib_subprocess"
+DYNAMIC_LIB_SUBPROCESS_CWD = Path(__file__).resolve().parents[3]
+
+
+@dataclass(frozen=True)
+class DynamicLibSubprocessPayload:
+    status: Literal["ok", "not-found"]
+    abs_path: str | None
+
+
+def format_dynamic_lib_subprocess_payload(
+    status: Literal["ok", "not-found"],
+    abs_path: str | None,
+    *,
+    error: dict[str, str] | None = None,
+) -> str:
+    payload: dict[str, object] = {"status": status, "abs_path": abs_path}
+    if error is not None:
+        payload["error"] = error
+    return json.dumps(payload)
+
+
+def build_dynamic_lib_subprocess_command(mode: str, libname: str) -> list[str]:
+    return [sys.executable, "-m", DYNAMIC_LIB_SUBPROCESS_MODULE, mode, libname]
+
+
+def parse_dynamic_lib_subprocess_payload(
+    stdout: str,
+    *,
+    libname: str,
+    error_label: str,
+) -> DynamicLibSubprocessPayload:
+    # Use the final non-empty line in case earlier output lines are emitted.
+    lines = [line for line in stdout.splitlines() if line.strip()]
+    if not lines:
+        raise RuntimeError(f"{error_label} produced no stdout payload for {libname!r}")
+    try:
+        payload = json.loads(lines[-1])
+    except json.JSONDecodeError:
+        raise RuntimeError(f"{error_label} emitted invalid JSON payload for {libname!r}: {lines[-1]!r}") from None
+    if not isinstance(payload, dict):
+        raise RuntimeError(f"{error_label} emitted unexpected payload for {libname!r}: {payload!r}")
+    status = payload.get("status")
+    abs_path = payload.get("abs_path")
+    if status == STATUS_OK:
+        if not isinstance(abs_path, str):
+            raise RuntimeError(f"{error_label} emitted unexpected payload for {libname!r}: {payload!r}")
+        return DynamicLibSubprocessPayload(status=STATUS_OK, abs_path=abs_path)
+    if status == STATUS_NOT_FOUND:
+        if abs_path is not None:
+            raise RuntimeError(f"{error_label} emitted unexpected payload for {libname!r}: {payload!r}")
+        return DynamicLibSubprocessPayload(status=STATUS_NOT_FOUND, abs_path=None)
+    raise RuntimeError(f"{error_label} emitted unexpected payload for {libname!r}: {payload!r}")

lib/python3.11/site-packages/cuda/pathfinder/_dynamic_libs/supported_nvidia_libs.py

@@ -0,0 +1,80 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Legacy table exports derived from the authored descriptor catalog.
+
+The canonical data entry point is :mod:`descriptor_catalog`. This module keeps
+historical constant names for backward compatibility by deriving them from the
+catalog.
+"""
+
+from __future__ import annotations
+
+from cuda.pathfinder._dynamic_libs.descriptor_catalog import DESCRIPTOR_CATALOG
+from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+
+_CTK_DESCRIPTORS = tuple(desc for desc in DESCRIPTOR_CATALOG if desc.packaged_with == "ctk")
+_OTHER_DESCRIPTORS = tuple(desc for desc in DESCRIPTOR_CATALOG if desc.packaged_with == "other")
+_DRIVER_DESCRIPTORS = tuple(desc for desc in DESCRIPTOR_CATALOG if desc.packaged_with == "driver")
+_NON_CTK_DESCRIPTORS = _OTHER_DESCRIPTORS + _DRIVER_DESCRIPTORS
+
+SUPPORTED_LIBNAMES_COMMON = tuple(desc.name for desc in _CTK_DESCRIPTORS if desc.linux_sonames and desc.windows_dlls)
+SUPPORTED_LIBNAMES_LINUX_ONLY = tuple(
+    desc.name for desc in _CTK_DESCRIPTORS if desc.linux_sonames and not desc.windows_dlls
+)
+SUPPORTED_LIBNAMES_WINDOWS_ONLY = tuple(
+    desc.name for desc in _CTK_DESCRIPTORS if desc.windows_dlls and not desc.linux_sonames
+)
+
+SUPPORTED_LIBNAMES_LINUX = SUPPORTED_LIBNAMES_COMMON + SUPPORTED_LIBNAMES_LINUX_ONLY
+SUPPORTED_LIBNAMES_WINDOWS = SUPPORTED_LIBNAMES_COMMON + SUPPORTED_LIBNAMES_WINDOWS_ONLY
+SUPPORTED_LIBNAMES_ALL = SUPPORTED_LIBNAMES_COMMON + SUPPORTED_LIBNAMES_LINUX_ONLY + SUPPORTED_LIBNAMES_WINDOWS_ONLY
+SUPPORTED_LIBNAMES = SUPPORTED_LIBNAMES_WINDOWS if IS_WINDOWS else SUPPORTED_LIBNAMES_LINUX
+
+DIRECT_DEPENDENCIES_CTK = {desc.name: desc.dependencies for desc in _CTK_DESCRIPTORS if desc.dependencies}
+DIRECT_DEPENDENCIES = {desc.name: desc.dependencies for desc in DESCRIPTOR_CATALOG if desc.dependencies}
+
+SUPPORTED_LINUX_SONAMES_CTK = {desc.name: desc.linux_sonames for desc in _CTK_DESCRIPTORS if desc.linux_sonames}
+SUPPORTED_LINUX_SONAMES_OTHER = {desc.name: desc.linux_sonames for desc in _OTHER_DESCRIPTORS if desc.linux_sonames}
+SUPPORTED_LINUX_SONAMES_DRIVER = {desc.name: desc.linux_sonames for desc in _DRIVER_DESCRIPTORS if desc.linux_sonames}
+SUPPORTED_LINUX_SONAMES = SUPPORTED_LINUX_SONAMES_CTK | SUPPORTED_LINUX_SONAMES_OTHER | SUPPORTED_LINUX_SONAMES_DRIVER
+
+SUPPORTED_WINDOWS_DLLS_CTK = {desc.name: desc.windows_dlls for desc in _CTK_DESCRIPTORS if desc.windows_dlls}
+SUPPORTED_WINDOWS_DLLS_OTHER = {desc.name: desc.windows_dlls for desc in _OTHER_DESCRIPTORS if desc.windows_dlls}
+SUPPORTED_WINDOWS_DLLS_DRIVER = {desc.name: desc.windows_dlls for desc in _DRIVER_DESCRIPTORS if desc.windows_dlls}
+SUPPORTED_WINDOWS_DLLS = SUPPORTED_WINDOWS_DLLS_CTK | SUPPORTED_WINDOWS_DLLS_OTHER | SUPPORTED_WINDOWS_DLLS_DRIVER
+
+LIBNAMES_REQUIRING_OS_ADD_DLL_DIRECTORY = tuple(
+    desc.name for desc in DESCRIPTOR_CATALOG if desc.requires_add_dll_directory and desc.windows_dlls
+)
+LIBNAMES_REQUIRING_RTLD_DEEPBIND = tuple(
+    desc.name for desc in DESCRIPTOR_CATALOG if desc.requires_rtld_deepbind and desc.linux_sonames
+)
+
+# Based on output of toolshed/make_site_packages_libdirs_linux.py
+SITE_PACKAGES_LIBDIRS_LINUX_CTK = {
+    desc.name: desc.site_packages_linux for desc in _CTK_DESCRIPTORS if desc.site_packages_linux
+}
+SITE_PACKAGES_LIBDIRS_LINUX_OTHER = {
+    desc.name: desc.site_packages_linux for desc in _NON_CTK_DESCRIPTORS if desc.site_packages_linux
+}
+SITE_PACKAGES_LIBDIRS_LINUX = SITE_PACKAGES_LIBDIRS_LINUX_CTK | SITE_PACKAGES_LIBDIRS_LINUX_OTHER
+
+SITE_PACKAGES_LIBDIRS_WINDOWS_CTK = {
+    desc.name: desc.site_packages_windows for desc in _CTK_DESCRIPTORS if desc.site_packages_windows
+}
+SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER = {
+    desc.name: desc.site_packages_windows for desc in _NON_CTK_DESCRIPTORS if desc.site_packages_windows
+}
+SITE_PACKAGES_LIBDIRS_WINDOWS = SITE_PACKAGES_LIBDIRS_WINDOWS_CTK | SITE_PACKAGES_LIBDIRS_WINDOWS_OTHER
+
+
+def is_suppressed_dll_file(path_basename: str) -> bool:
+    if path_basename.startswith("nvrtc"):
+        # nvidia_cuda_nvrtc_cu12-12.8.93-py3-none-win_amd64.whl:
+        #     nvidia\cuda_nvrtc\bin\
+        #         nvrtc-builtins64_128.dll
+        #         nvrtc64_120_0.alt.dll
+        #         nvrtc64_120_0.dll
+        return path_basename.endswith(".alt.dll") or "-builtins" in path_basename
+    return path_basename.startswith(("cudart32_", "nvvm32"))

lib/python3.11/site-packages/cuda/pathfinder/_headers/find_nvidia_headers.py

@@ -0,0 +1,226 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import functools
+import glob
+import os
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from cuda.pathfinder._dynamic_libs.load_nvidia_dynamic_lib import (
+    _resolve_system_loaded_abs_path_in_subprocess,
+)
+from cuda.pathfinder._dynamic_libs.search_steps import derive_ctk_root
+from cuda.pathfinder._headers.header_descriptor import (
+    HEADER_DESCRIPTORS,
+    platform_include_subdirs,
+    resolve_conda_anchor,
+)
+from cuda.pathfinder._utils.env_vars import get_cuda_path_or_home
+from cuda.pathfinder._utils.find_sub_dirs import find_sub_dirs_all_sitepackages
+
+if TYPE_CHECKING:
+    from cuda.pathfinder._headers.header_descriptor import HeaderDescriptor
+
+# ---------------------------------------------------------------------------
+# Data types
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class LocatedHeaderDir:
+    abs_path: str | None
+    found_via: str
+
+    def __post_init__(self) -> None:
+        self.abs_path = _abs_norm(self.abs_path)
+
+
+#: Type alias for a header find step callable.
+HeaderFindStep = Callable[["HeaderDescriptor"], LocatedHeaderDir | None]
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _abs_norm(path: str | None) -> str | None:
+    if path:
+        return os.path.normpath(os.path.abspath(path))
+    return None
+
+
+def _joined_isfile(dirpath: str, basename: str) -> bool:
+    return os.path.isfile(os.path.join(dirpath, basename))
+
+
+def _locate_in_anchor_layout(desc: HeaderDescriptor, anchor_point: str) -> str | None:
+    """Search for a header under *anchor_point* using the descriptor's layout fields."""
+    h_basename = desc.header_basename
+    for rel_dir in desc.anchor_include_rel_dirs:
+        idir = os.path.join(anchor_point, rel_dir)
+        for subdir in platform_include_subdirs(desc):
+            cdir = os.path.join(idir, subdir)
+            if _joined_isfile(cdir, h_basename):
+                return cdir
+        if _joined_isfile(idir, h_basename):
+            return idir
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Find steps
+# ---------------------------------------------------------------------------
+
+
+def find_in_site_packages(desc: HeaderDescriptor) -> LocatedHeaderDir | None:
+    """Search pip wheel install locations."""
+    for sub_dir in desc.site_packages_dirs:
+        hdr_dir: str  # help mypy
+        for hdr_dir in find_sub_dirs_all_sitepackages(tuple(sub_dir.split("/"))):
+            if _joined_isfile(hdr_dir, desc.header_basename):
+                return LocatedHeaderDir(abs_path=hdr_dir, found_via="site-packages")
+    return None
+
+
+def find_in_conda(desc: HeaderDescriptor) -> LocatedHeaderDir | None:
+    """Search ``$CONDA_PREFIX``."""
+    conda_prefix = os.environ.get("CONDA_PREFIX")
+    if not conda_prefix:
+        return None
+    anchor_point = resolve_conda_anchor(desc, conda_prefix)
+    if anchor_point is None:
+        return None
+    found_header_path = _locate_in_anchor_layout(desc, anchor_point)
+    if found_header_path:
+        return LocatedHeaderDir(abs_path=found_header_path, found_via="conda")
+    return None
+
+
+def find_in_cuda_path(desc: HeaderDescriptor) -> LocatedHeaderDir | None:
+    """Search ``$CUDA_PATH`` / ``$CUDA_HOME``."""
+    cuda_home = get_cuda_path_or_home()
+    if cuda_home is None:
+        return None
+    result = _locate_in_anchor_layout(desc, cuda_home)
+    if result is not None:
+        return LocatedHeaderDir(abs_path=result, found_via="CUDA_PATH")
+    return None
+
+
+def find_via_ctk_root_canary(desc: HeaderDescriptor) -> LocatedHeaderDir | None:
+    """Try CTK header lookup via CTK-root canary probing.
+
+    Skips immediately if the descriptor does not opt in (``use_ctk_root_canary``).
+    Otherwise, system-loads ``cudart`` in a fully isolated Python subprocess, derives
+    CTK root from the resolved library path, and searches the expected include
+    layout under that root.
+    """
+    if not desc.use_ctk_root_canary:
+        return None
+    canary_abs_path = _resolve_system_loaded_abs_path_in_subprocess("cudart")
+    if canary_abs_path is None:
+        return None
+    ctk_root = derive_ctk_root(canary_abs_path)
+    if ctk_root is None:
+        return None
+    result = _locate_in_anchor_layout(desc, ctk_root)
+    if result is not None:
+        return LocatedHeaderDir(abs_path=result, found_via="system-ctk-root")
+    return None
+
+
+def find_in_system_install_dirs(desc: HeaderDescriptor) -> LocatedHeaderDir | None:
+    """Search system install directories (glob patterns)."""
+    for pattern in desc.system_install_dirs:
+        for hdr_dir in sorted(glob.glob(pattern), reverse=True):
+            if _joined_isfile(hdr_dir, desc.header_basename):
+                return LocatedHeaderDir(abs_path=hdr_dir, found_via="supported_install_dir")
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Step sequence and cascade runner
+# ---------------------------------------------------------------------------
+
+#: Unified find steps — each step self-gates based on descriptor fields.
+FIND_STEPS: tuple[HeaderFindStep, ...] = (
+    find_in_site_packages,
+    find_in_conda,
+    find_in_cuda_path,
+    find_via_ctk_root_canary,
+    find_in_system_install_dirs,
+)
+
+
+def run_find_steps(desc: HeaderDescriptor, steps: tuple[HeaderFindStep, ...]) -> LocatedHeaderDir | None:
+    """Run find steps in order, returning the first hit."""
+    for step in steps:
+        result = step(desc)
+        if result is not None:
+            return result
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+@functools.cache
+def locate_nvidia_header_directory(libname: str) -> LocatedHeaderDir | None:
+    """Locate the header directory for a supported NVIDIA library.
+
+    Args:
+        libname (str): The short name of the library whose headers are needed
+            (e.g., ``"nvrtc"``, ``"cusolver"``, ``"nvshmem"``).
+
+    Returns:
+        LocatedHeaderDir or None: A LocatedHeaderDir object containing the absolute path
+        to the discovered header directory and information about where it was found,
+        or ``None`` if the headers cannot be found.
+
+    Raises:
+        RuntimeError: If ``libname`` is not in the supported set.
+
+    Search order:
+        1. **NVIDIA Python wheels** — site-packages directories from the descriptor.
+        2. **Conda environments** — platform-specific conda include layouts.
+        3. **CUDA Toolkit environment variables** — ``CUDA_PATH`` / ``CUDA_HOME``.
+        4. **CTK root canary probe** — subprocess canary (descriptors with
+           ``use_ctk_root_canary=True`` only).
+        5. **System install directories** — glob patterns from the descriptor.
+    """
+    desc = HEADER_DESCRIPTORS.get(libname)
+    if desc is None:
+        raise RuntimeError(f"UNKNOWN {libname=}")
+    return run_find_steps(desc, FIND_STEPS)
+
+
+def find_nvidia_header_directory(libname: str) -> str | None:
+    """Locate the header directory for a supported NVIDIA library.
+
+    Args:
+        libname (str): The short name of the library whose headers are needed
+            (e.g., ``"nvrtc"``, ``"cusolver"``, ``"nvshmem"``).
+
+    Returns:
+        str or None: Absolute path to the discovered header directory, or ``None``
+        if the headers cannot be found.
+
+    Raises:
+        RuntimeError: If ``libname`` is not in the supported set.
+
+    Search order:
+        1. **NVIDIA Python wheels** — site-packages directories from the descriptor.
+        2. **Conda environments** — platform-specific conda include layouts.
+        3. **CUDA Toolkit environment variables** — ``CUDA_PATH`` / ``CUDA_HOME``.
+        4. **CTK root canary probe** — subprocess canary (descriptors with
+           ``use_ctk_root_canary=True`` only).
+        5. **System install directories** — glob patterns from the descriptor.
+    """
+    found = locate_nvidia_header_directory(libname)
+    return found.abs_path if found else None

lib/python3.11/site-packages/cuda/pathfinder/_headers/header_descriptor.py

@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Per-header descriptor, registry, and platform-aware accessors.
+
+The canonical authored data lives in :mod:`header_descriptor_catalog`. This
+module provides a name-keyed registry and platform-dispatch helpers consumed
+by the runtime search path — keeping the search code itself platform-agnostic.
+"""
+
+from __future__ import annotations
+
+import glob
+import os
+from typing import TypeAlias, cast
+
+from cuda.pathfinder._headers.header_descriptor_catalog import (
+    HEADER_DESCRIPTOR_CATALOG,
+    HeaderDescriptorSpec,
+)
+from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+
+HeaderDescriptor: TypeAlias = HeaderDescriptorSpec
+
+#: Canonical registry of all known header libraries.
+HEADER_DESCRIPTORS: dict[str, HeaderDescriptor] = {desc.name: desc for desc in HEADER_DESCRIPTOR_CATALOG}
+
+
+def platform_include_subdirs(desc: HeaderDescriptor) -> tuple[str, ...]:
+    """Return the effective include subdirectory search list for the current platform.
+
+    On Windows, Windows-specific subdirs are checked first, followed by the
+    common subdirs.  On Linux, only the common subdirs are returned.
+    """
+    if IS_WINDOWS:
+        return cast(tuple[str, ...], desc.include_subdirs_windows + desc.include_subdirs)
+    return cast(tuple[str, ...], desc.include_subdirs)
+
+
+def resolve_conda_anchor(desc: HeaderDescriptor, conda_prefix: str) -> str | None:
+    """Resolve the conda anchor point for header search on the current platform.
+
+    Returns the directory that ``_locate_in_anchor_layout`` should use as
+    *anchor_point*, or ``None`` if the conda layout is not usable.
+    """
+    if IS_WINDOWS:
+        anchor = os.path.join(conda_prefix, "Library")
+        return anchor if os.path.isdir(anchor) else None
+    if desc.conda_targets_layout:
+        targets_include_path = glob.glob(os.path.join(conda_prefix, "targets", "*", "include"))
+        if not targets_include_path or len(targets_include_path) != 1:
+            return None
+        return os.path.dirname(targets_include_path[0])
+    return conda_prefix

lib/python3.11/site-packages/cuda/pathfinder/_headers/header_descriptor_catalog.py

@@ -0,0 +1,212 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Canonical authored descriptor catalog for header directories."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+HeaderPackagedWith = Literal["ctk", "other"]
+
+
+@dataclass(frozen=True, slots=True)
+class HeaderDescriptorSpec:
+    name: str
+    packaged_with: HeaderPackagedWith
+    header_basename: str
+    site_packages_dirs: tuple[str, ...] = ()
+    available_on_linux: bool = True
+    available_on_windows: bool = True
+    # Relative path(s) from anchor point to the include directory.
+    anchor_include_rel_dirs: tuple[str, ...] = ("include",)
+    # Subdirectories within the include dir to check before the include dir itself.
+    include_subdirs: tuple[str, ...] = ()
+    # Windows-only additional subdirectories within the include dir.
+    include_subdirs_windows: tuple[str, ...] = ()
+    # System install directories (glob patterns).
+    system_install_dirs: tuple[str, ...] = ()
+    # Whether to use targets/<arch>/include layout for conda on Linux.
+    conda_targets_layout: bool = True
+    # Whether to attempt CTK-root canary probing (spawns a subprocess).
+    use_ctk_root_canary: bool = True
+
+
+HEADER_DESCRIPTOR_CATALOG: tuple[HeaderDescriptorSpec, ...] = (
+    # -----------------------------------------------------------------------
+    # CTK (CUDA Toolkit) headers
+    # -----------------------------------------------------------------------
+    HeaderDescriptorSpec(
+        name="cccl",
+        packaged_with="ctk",
+        header_basename="cuda/std/version",
+        site_packages_dirs=(
+            "nvidia/cu13/include/cccl",  # cuda-toolkit[cccl]==13.*
+            "nvidia/cuda_cccl/include",  # cuda-toolkit[cccl]==12.*
+        ),
+        include_subdirs=("cccl",),
+        include_subdirs_windows=("targets/x64/cccl", "targets/x64"),
+    ),
+    HeaderDescriptorSpec(
+        name="cublas",
+        packaged_with="ctk",
+        header_basename="cublas.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cublas/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="cudart",
+        packaged_with="ctk",
+        header_basename="cuda_runtime.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cuda_runtime/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="cufft",
+        packaged_with="ctk",
+        header_basename="cufft.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cufft/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="cufile",
+        packaged_with="ctk",
+        header_basename="cufile.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cufile/include"),
+        available_on_windows=False,
+    ),
+    HeaderDescriptorSpec(
+        name="curand",
+        packaged_with="ctk",
+        header_basename="curand.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/curand/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="cusolver",
+        packaged_with="ctk",
+        header_basename="cusolverDn.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cusolver/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="cusparse",
+        packaged_with="ctk",
+        header_basename="cusparse.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cusparse/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="npp",
+        packaged_with="ctk",
+        header_basename="npp.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/npp/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="profiler",
+        packaged_with="ctk",
+        header_basename="cuda_profiler_api.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cuda_profiler_api/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="nvcc",
+        packaged_with="ctk",
+        header_basename="fatbinary_section.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cuda_nvcc/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="nvfatbin",
+        packaged_with="ctk",
+        header_basename="nvFatbin.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/nvfatbin/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="nvjitlink",
+        packaged_with="ctk",
+        header_basename="nvJitLink.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/nvjitlink/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="nvjpeg",
+        packaged_with="ctk",
+        header_basename="nvjpeg.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/nvjpeg/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="nvrtc",
+        packaged_with="ctk",
+        header_basename="nvrtc.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cuda_nvrtc/include"),
+    ),
+    HeaderDescriptorSpec(
+        name="nvvm",
+        packaged_with="ctk",
+        header_basename="nvvm.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cuda_nvcc/nvvm/include"),
+        anchor_include_rel_dirs=("nvvm/include",),
+    ),
+    HeaderDescriptorSpec(
+        name="cudla",
+        packaged_with="ctk",
+        header_basename="cudla.h",
+        site_packages_dirs=("nvidia/cu13/include",),
+        available_on_windows=False,
+    ),
+    # -----------------------------------------------------------------------
+    # Third-party / separately packaged headers
+    # -----------------------------------------------------------------------
+    HeaderDescriptorSpec(
+        name="cusolverMp",
+        packaged_with="other",
+        header_basename="cusolverMp.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cu12/include"),
+        available_on_windows=False,
+        conda_targets_layout=False,
+        use_ctk_root_canary=False,
+    ),
+    HeaderDescriptorSpec(
+        name="cusparseLt",
+        packaged_with="other",
+        header_basename="cusparseLt.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cusparselt/include"),
+        conda_targets_layout=False,
+        use_ctk_root_canary=False,
+    ),
+    HeaderDescriptorSpec(
+        name="cute",
+        packaged_with="other",
+        header_basename="cute/tensor.hpp",
+        site_packages_dirs=("cutlass_library/source/include",),
+        conda_targets_layout=False,
+        use_ctk_root_canary=False,
+    ),
+    HeaderDescriptorSpec(
+        name="cutensor",
+        packaged_with="other",
+        header_basename="cutensor.h",
+        site_packages_dirs=("cutensor/include",),
+        conda_targets_layout=False,
+        use_ctk_root_canary=False,
+    ),
+    HeaderDescriptorSpec(
+        name="cutlass",
+        packaged_with="other",
+        header_basename="cutlass/cutlass.h",
+        site_packages_dirs=("cutlass_library/source/include",),
+        conda_targets_layout=False,
+        use_ctk_root_canary=False,
+    ),
+    HeaderDescriptorSpec(
+        name="mathdx",
+        packaged_with="other",
+        header_basename="libmathdx.h",
+        site_packages_dirs=("nvidia/cu13/include", "nvidia/cu12/include"),
+        conda_targets_layout=False,
+        use_ctk_root_canary=False,
+    ),
+    HeaderDescriptorSpec(
+        name="nvshmem",
+        packaged_with="other",
+        header_basename="nvshmem.h",
+        site_packages_dirs=("nvidia/nvshmem/include",),
+        available_on_windows=False,
+        system_install_dirs=("/usr/include/nvshmem_*",),
+        conda_targets_layout=False,
+        use_ctk_root_canary=False,
+    ),
+)

lib/python3.11/site-packages/cuda/pathfinder/_headers/supported_nvidia_headers.py

@@ -0,0 +1,81 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Legacy table exports derived from the authored header descriptor catalog.
+
+The canonical data entry point is :mod:`header_descriptor_catalog`. This module
+keeps historical constant names for backward compatibility by deriving them
+from the catalog.
+"""
+
+from __future__ import annotations
+
+from typing import Final
+
+from cuda.pathfinder._headers.header_descriptor_catalog import HEADER_DESCRIPTOR_CATALOG
+from cuda.pathfinder._utils.platform_aware import IS_WINDOWS
+
+_CTK_DESCRIPTORS = tuple(desc for desc in HEADER_DESCRIPTOR_CATALOG if desc.packaged_with == "ctk")
+_NON_CTK_DESCRIPTORS = tuple(desc for desc in HEADER_DESCRIPTOR_CATALOG if desc.packaged_with == "other")
+
+SUPPORTED_HEADERS_CTK_COMMON: Final[dict[str, str]] = {
+    desc.name: desc.header_basename
+    for desc in _CTK_DESCRIPTORS
+    if desc.available_on_linux and desc.available_on_windows
+}
+SUPPORTED_HEADERS_CTK_LINUX_ONLY: Final[dict[str, str]] = {
+    desc.name: desc.header_basename
+    for desc in _CTK_DESCRIPTORS
+    if desc.available_on_linux and not desc.available_on_windows
+}
+SUPPORTED_HEADERS_CTK_WINDOWS_ONLY: Final[dict[str, str]] = {
+    desc.name: desc.header_basename
+    for desc in _CTK_DESCRIPTORS
+    if desc.available_on_windows and not desc.available_on_linux
+}
+
+SUPPORTED_HEADERS_CTK_LINUX = SUPPORTED_HEADERS_CTK_COMMON | SUPPORTED_HEADERS_CTK_LINUX_ONLY
+SUPPORTED_HEADERS_CTK_WINDOWS = SUPPORTED_HEADERS_CTK_COMMON | SUPPORTED_HEADERS_CTK_WINDOWS_ONLY
+SUPPORTED_HEADERS_CTK_ALL = (
+    SUPPORTED_HEADERS_CTK_COMMON | SUPPORTED_HEADERS_CTK_LINUX_ONLY | SUPPORTED_HEADERS_CTK_WINDOWS_ONLY
+)
+SUPPORTED_HEADERS_CTK: Final[dict[str, str]] = (
+    SUPPORTED_HEADERS_CTK_WINDOWS if IS_WINDOWS else SUPPORTED_HEADERS_CTK_LINUX
+)
+
+SUPPORTED_SITE_PACKAGE_HEADER_DIRS_CTK: Final[dict[str, tuple[str, ...]]] = {
+    desc.name: desc.site_packages_dirs for desc in _CTK_DESCRIPTORS if desc.site_packages_dirs
+}
+
+SUPPORTED_HEADERS_NON_CTK_COMMON: Final[dict[str, str]] = {
+    desc.name: desc.header_basename
+    for desc in _NON_CTK_DESCRIPTORS
+    if desc.available_on_linux and desc.available_on_windows
+}
+SUPPORTED_HEADERS_NON_CTK_LINUX_ONLY: Final[dict[str, str]] = {
+    desc.name: desc.header_basename
+    for desc in _NON_CTK_DESCRIPTORS
+    if desc.available_on_linux and not desc.available_on_windows
+}
+SUPPORTED_HEADERS_NON_CTK_WINDOWS_ONLY: Final[dict[str, str]] = {
+    desc.name: desc.header_basename
+    for desc in _NON_CTK_DESCRIPTORS
+    if desc.available_on_windows and not desc.available_on_linux
+}
+
+SUPPORTED_HEADERS_NON_CTK_LINUX = SUPPORTED_HEADERS_NON_CTK_COMMON | SUPPORTED_HEADERS_NON_CTK_LINUX_ONLY
+SUPPORTED_HEADERS_NON_CTK_WINDOWS = SUPPORTED_HEADERS_NON_CTK_COMMON | SUPPORTED_HEADERS_NON_CTK_WINDOWS_ONLY
+SUPPORTED_HEADERS_NON_CTK_ALL = (
+    SUPPORTED_HEADERS_NON_CTK_COMMON | SUPPORTED_HEADERS_NON_CTK_LINUX_ONLY | SUPPORTED_HEADERS_NON_CTK_WINDOWS_ONLY
+)
+SUPPORTED_HEADERS_NON_CTK: Final[dict[str, str]] = (
+    SUPPORTED_HEADERS_NON_CTK_WINDOWS if IS_WINDOWS else SUPPORTED_HEADERS_NON_CTK_LINUX
+)
+
+SUPPORTED_SITE_PACKAGE_HEADER_DIRS_NON_CTK: Final[dict[str, tuple[str, ...]]] = {
+    desc.name: desc.site_packages_dirs for desc in _NON_CTK_DESCRIPTORS if desc.site_packages_dirs
+}
+
+SUPPORTED_INSTALL_DIRS_NON_CTK: Final[dict[str, tuple[str, ...]]] = {
+    desc.name: desc.system_install_dirs for desc in _NON_CTK_DESCRIPTORS if desc.system_install_dirs
+}

lib/python3.11/site-packages/cuda/pathfinder/_optional_cuda_import.py

@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import importlib
+from collections.abc import Callable
+from types import ModuleType
+
+from cuda.pathfinder._dynamic_libs.load_dl_common import DynamicLibNotFoundError
+
+
+def _optional_cuda_import(
+    fully_qualified_modname: str,
+    *,
+    probe_function: Callable[[ModuleType], object] | None = None,
+) -> ModuleType | None:
+    """Import an optional CUDA module without masking unrelated import bugs.
+
+    Returns:
+        The imported module if available and the optional probe succeeds,
+        otherwise ``None`` when the requested module is unavailable.
+
+    Raises:
+        ModuleNotFoundError: If the import fails because a dependency of the
+            target module is missing (instead of the target module itself).
+        Exception: Any exception raised by ``probe_function`` except
+            :class:`DynamicLibNotFoundError`, which is treated as "unavailable".
+    """
+    try:
+        module = importlib.import_module(fully_qualified_modname)
+    except ModuleNotFoundError as err:
+        if err.name != fully_qualified_modname:
+            raise
+        return None
+
+    if probe_function is not None:
+        try:
+            probe_function(module)
+        except DynamicLibNotFoundError:
+            return None
+
+    return module