@@ -42,7 +42,7 @@ jobs:
 
       - name: Verify release tag and main ancestry
         run: |
-          declared_version=$(python -c 'import tomllib; print(tomllib.load(open("pyproject.toml", "rb"))["project"]["version"])')
+          declared_version=$(python -c 'import arraybridge; print(arraybridge.__version__)')
           test "$GITHUB_REF_NAME" = "v$declared_version"
           git fetch origin main
           git merge-base --is-ancestor "$GITHUB_SHA" origin/main
 
@@ -16,13 +16,15 @@
 sys.path.insert(0, str(EXTERNAL_ROOT / "metaclass-registry" / "src"))
 sys.path.insert(0, str(PACKAGE_ROOT / "src"))
 
+from arraybridge import __version__
+
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
 project = 'arraybridge'
 copyright = '2025, Tristan Simas'
 author = 'Tristan Simas'
-release = '0.3.1'
+release = __version__
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
 
@@ -15,6 +15,11 @@ overwritten. Hosts that import optional frameworks themselves should call
 ``MemoryType.prepare_import()`` first. ArrayBridge warns when it encounters an
 already-loaded framework whose import-time defaults were absent.
 
+``MemoryType.subprocess_environment()`` projects the same member-owned import
+defaults into a child-process environment. The CuPy member also derives native
+library search paths from installed NVIDIA wheels, so a fresh child interpreter
+does not depend on another framework having loaded CUDA libraries first.
+
 JAX float64 output requires x64 mode to be enabled before import. ArrayBridge
 raises instead of silently returning float32 when a caller requests float64
 while that capability is disabled.
 
@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arraybridge"
-version = "0.3.2"
+dynamic = ["version"]
 description = "Unified API for NumPy, CuPy, PyTorch, TensorFlow, JAX, and pyclesperanto with automatic memory type conversion"
 authors = [{name = "Tristan Simas", email = "tristan.simas@mail.mcgill.ca"}]
 license = {text = "MIT"}
@@ -98,6 +98,9 @@ Issues = "https://github.com/OpenHCSDev/arraybridge/issues"
 [tool.hatch.build.targets.wheel]
 packages = ["src/arraybridge"]
 
+[tool.hatch.version]
+path = "src/arraybridge/__init__.py"
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]
 
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Update ArrayBridge's three version projections without Git side effects."""
+"""Update ArrayBridge's canonical package version without Git side effects."""
 
 import argparse
 import re
@@ -8,39 +8,21 @@
 from packaging.version import InvalidVersion, Version
 
 PROJECT_ROOT = Path(__file__).resolve().parents[1]
-VERSION_FILES = {
-    PROJECT_ROOT
-    / "src/arraybridge/__init__.py": (
-        r"(__version__\s*=\s*['\"])([^'\"]+)(['\"])",
-        "package",
-    ),
-    PROJECT_ROOT
-    / "pyproject.toml": (
-        r"(^version\s*=\s*['\"])([^'\"]+)(['\"])",
-        "project",
-    ),
-    PROJECT_ROOT
-    / "docs/source/conf.py": (
-        r"(^release\s*=\s*['\"])([^'\"]+)(['\"])",
-        "documentation",
-    ),
-}
+VERSION_FILE = PROJECT_ROOT / "src/arraybridge/__init__.py"
+VERSION_PATTERN = r"(__version__\s*=\s*['\"])([^'\"]+)(['\"])"
 
 
 def current_version() -> Version:
-    """Return the agreed version, failing when a projection has drifted."""
-    declared_versions: dict[str, Version] = {}
-    for path, (pattern, projection_name) in VERSION_FILES.items():
-        match = re.search(pattern, path.read_text(encoding="utf-8"), flags=re.MULTILINE)
-        if match is None:
-            raise RuntimeError(f"Version declaration is missing from {path}")
-        declared_versions[projection_name] = Version(match.group(2))
+    """Return the package-owned canonical version."""
 
-    unique_versions = set(declared_versions.values())
-    if len(unique_versions) != 1:
-        declarations = ", ".join(f"{name}={version}" for name, version in declared_versions.items())
-        raise RuntimeError(f"Version projections have drifted: {declarations}")
-    return unique_versions.pop()
+    match = re.search(
+        VERSION_PATTERN,
+        VERSION_FILE.read_text(encoding="utf-8"),
+        flags=re.MULTILINE,
+    )
+    if match is None:
+        raise RuntimeError(f"Version declaration is missing from {VERSION_FILE}")
+    return Version(match.group(2))
 
 
 def update_version(version_text: str) -> None:
@@ -52,19 +34,18 @@ def update_version(version_text: str) -> None:
     if requested <= current:
         raise ValueError(f"New version {requested} must be greater than {current}")
 
-    for path, (pattern, _projection_name) in VERSION_FILES.items():
-        content = path.read_text(encoding="utf-8")
-        updated, count = re.subn(
-            pattern,
-            rf"\g<1>{requested}\g<3>",
-            content,
-            flags=re.MULTILINE,
-        )
-        if count != 1:
-            raise RuntimeError(f"Expected one version declaration in {path}, found {count}")
-        path.write_text(updated, encoding="utf-8")
-
-    print(f"Updated ArrayBridge version projections to {requested}")
+    content = VERSION_FILE.read_text(encoding="utf-8")
+    updated, count = re.subn(
+        VERSION_PATTERN,
+        rf"\g<1>{requested}\g<3>",
+        content,
+        flags=re.MULTILINE,
+    )
+    if count != 1:
+        raise RuntimeError(f"Expected one version declaration in {VERSION_FILE}, found {count}")
+    VERSION_FILE.write_text(updated, encoding="utf-8")
+
+    print(f"Updated ArrayBridge version to {requested}")
     print("Run scripts/verify_release_ready.py --allow-dirty, then review and commit.")
 
 
 
@@ -16,8 +16,6 @@
 import tempfile
 from pathlib import Path
 
-import tomllib
-
 PROJECT_ROOT = Path(__file__).resolve().parents[1]
 
 
@@ -41,20 +39,6 @@ def check_version():
         print(f"  ❌ Version '{version}' doesn't follow semantic versioning (MAJOR.MINOR.PATCH)")
         return False
 
-    pyproject_version = tomllib.loads(
-        (PROJECT_ROOT / "pyproject.toml").read_text(encoding="utf-8")
-    )["project"]["version"]
-    docs_match = re.search(
-        r"release\s*=\s*['\"]([^'\"]+)",
-        (PROJECT_ROOT / "docs/source/conf.py").read_text(encoding="utf-8"),
-    )
-    docs_version = docs_match.group(1) if docs_match else None
-    if len({version, pyproject_version, docs_version}) != 1:
-        print(
-            "  ❌ Version authorities disagree: "
-            f"package={version}, pyproject={pyproject_version}, docs={docs_version}"
-        )
-        return False
     print(f"  ✅ Version: {version}")
     return True
 
@@ -70,7 +54,8 @@ def check_pyproject_toml():
     content = pyproject_file.read_text(encoding="utf-8")
     required_fields = {
         "name": r'name\s*=\s*["\']arraybridge["\']',
-        "version": r"version\s*=",
+        "dynamic version": r'dynamic\s*=\s*\[["\']version["\']\]',
+        "version authority": r'path\s*=\s*["\']src/arraybridge/__init__\.py["\']',
         "description": r"description\s*=",
         "authors": r"authors\s*=",
         "build-backend": r'build-backend\s*=\s*["\']hatchling\.build["\']',
 
@@ -5,7 +5,7 @@
 and unified utilities for working with multiple array/tensor frameworks.
 """
 
-__version__ = "0.3.2"
+__version__ = "0.3.3"
 
 from . import decorators as _decorators
 from .array_geometry import ArrayGeometry
 
@@ -14,6 +14,7 @@
 from contextlib import AbstractContextManager, contextmanager, nullcontext
 from dataclasses import dataclass
 from enum import Enum
+from pathlib import Path
 from typing import Any, TypeVar, cast
 
 from arraybridge.array_operations import (
@@ -41,6 +42,55 @@
 DLPackExporter = Callable[[Any, Any], Any | None]
 DLPackValidator = Callable[[Any, Any], bool]
 OOMMatcher = Callable[[BaseException, Any | None], bool]
+SubprocessEnvironmentResolver = Callable[[Mapping[str, str]], dict[str, str]]
+
+
+def _identity_subprocess_environment(
+    environment: Mapping[str, str],
+) -> dict[str, str]:
+    return dict(environment)
+
+
+def _nvidia_wheel_library_paths() -> tuple[str, ...]:
+    """Return native-library directories declared by installed NVIDIA wheels."""
+
+    try:
+        spec = importlib.util.find_spec("nvidia")
+    except (ImportError, ModuleNotFoundError, ValueError):
+        return ()
+    if spec is None or spec.submodule_search_locations is None:
+        return ()
+
+    paths: set[str] = set()
+    for package_root in map(Path, spec.submodule_search_locations):
+        try:
+            components = tuple(package_root.iterdir())
+        except OSError:
+            continue
+        for component in components:
+            for library_directory_name in ("lib", "bin"):
+                candidate = component / library_directory_name
+                if candidate.is_dir():
+                    paths.add(str(candidate))
+    return tuple(sorted(paths))
+
+
+def _nvidia_wheel_subprocess_environment(
+    environment: Mapping[str, str],
+) -> dict[str, str]:
+    """Prepend installed NVIDIA wheel libraries to a child environment."""
+
+    prepared = dict(environment)
+    library_paths = _nvidia_wheel_library_paths()
+    if not library_paths:
+        return prepared
+
+    search_variable = "PATH" if os.name == "nt" else "LD_LIBRARY_PATH"
+    existing_paths = tuple(
+        path for path in prepared.get(search_variable, "").split(os.pathsep) if path
+    )
+    prepared[search_variable] = os.pathsep.join(dict.fromkeys((*library_paths, *existing_paths)))
+    return prepared
 
 
 class MemoryContractAttribute(str, Enum):
@@ -501,6 +551,7 @@ class FrameworkRuntime:
     dlpack_exporter: DLPackExporter | None = None
     dlpack_validator: DLPackValidator = _protocol_dlpack
     oom_matcher: OOMMatcher = _never_oom
+    subprocess_environment: SubprocessEnvironmentResolver = _identity_subprocess_environment
 
 
 class _MemoryTypeFields:
@@ -571,6 +622,7 @@ def __new__(
             dlpack_importer=_cupy_from_dlpack,
             dlpack_exporter=_protocol_dlpack_export,
             oom_matcher=_cupy_oom,
+            subprocess_environment=_nvidia_wheel_subprocess_environment,
         ),
         CUPY_OPERATIONS,
     )
@@ -682,6 +734,20 @@ def prepare_import(self) -> None:
         for name, value in self.import_environment:
             os.environ.setdefault(name, value)
 
+    @classmethod
+    def subprocess_environment(
+        cls,
+        environment: Mapping[str, str] | None = None,
+    ) -> dict[str, str]:
+        """Project framework import requirements into a child environment."""
+
+        prepared = dict(os.environ if environment is None else environment)
+        for memory_type in cls:
+            for name, value in memory_type.import_environment:
+                prepared.setdefault(name, value)
+            prepared = memory_type._runtime.subprocess_environment(prepared)
+        return prepared
+
     def loaded_module(self) -> Any | None:
         """Return an already-loaded framework without causing an import."""
 
 
@@ -145,6 +145,58 @@ def test_import_preparation_sets_only_declaration_owned_defaults(self, monkeypat
         assert os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] == "true"
         assert os.environ["XLA_PYTHON_CLIENT_PREALLOCATE"] == "custom"
 
+    def test_subprocess_environment_derives_nvidia_wheel_paths_from_cupy_owner(
+        self,
+        monkeypatch,
+        tmp_path,
+    ):
+        from arraybridge import types
+
+        nvidia_root = tmp_path / "nvidia"
+        cublas_lib = nvidia_root / "cublas" / "lib"
+        runtime_bin = nvidia_root / "cuda_runtime" / "bin"
+        cublas_lib.mkdir(parents=True)
+        runtime_bin.mkdir(parents=True)
+        monkeypatch.setattr(
+            types.importlib.util,
+            "find_spec",
+            lambda name: (
+                SimpleNamespace(submodule_search_locations=(str(nvidia_root),))
+                if name == "nvidia"
+                else None
+            ),
+        )
+        search_variable = "PATH" if os.name == "nt" else "LD_LIBRARY_PATH"
+        original = {search_variable: "/existing", "CUSTOM": "value"}
+
+        prepared = MemoryType.subprocess_environment(original)
+
+        assert original == {search_variable: "/existing", "CUSTOM": "value"}
+        assert prepared[search_variable].split(os.pathsep) == [
+            *sorted((str(cublas_lib), str(runtime_bin))),
+            "/existing",
+        ]
+        assert prepared["CUSTOM"] == "value"
+        assert prepared["TF_FORCE_GPU_ALLOW_GROWTH"] == "true"
+        assert prepared["XLA_PYTHON_CLIENT_PREALLOCATE"] == "false"
+
+    def test_subprocess_environment_preserves_host_values_without_nvidia_wheels(
+        self,
+        monkeypatch,
+    ):
+        from arraybridge import types
+
+        monkeypatch.setattr(types.importlib.util, "find_spec", lambda name: None)
+        original = {
+            "TF_FORCE_GPU_ALLOW_GROWTH": "host",
+            "XLA_PYTHON_CLIENT_PREALLOCATE": "host",
+        }
+
+        prepared = MemoryType.subprocess_environment(original)
+
+        assert prepared == original
+        assert prepared is not original
+
     def test_preloaded_framework_reports_late_import_preparation(
         self,
         monkeypatch,