From cff2603201e8a430ee2f8ec05c74ff0be9db3684 Mon Sep 17 00:00:00 2001
From: sayakpaul <spsayakpaul@gmail.com>
Date: Sun, 19 Apr 2026 13:17:41 +0530
Subject: [PATCH 1/8] feat: add test and docs for get_loaded_kernels.

---
 docs/source/api/kernels.md           |  4 ++
 docs/source/basic-usage.md           | 20 ++++++
 kernels/src/kernels/utils.py         | 32 +++++++++-
 kernels/tests/test_loaded_kernels.py | 92 ++++++++++++++++++++++++++++
 4 files changed, 147 insertions(+), 1 deletion(-)
 create mode 100644 kernels/tests/test_loaded_kernels.py

diff --git a/docs/source/api/kernels.md b/docs/source/api/kernels.md
index 7d4ebc0f..afff8f6e 100644
--- a/docs/source/api/kernels.md
+++ b/docs/source/api/kernels.md
@@ -14,6 +14,10 @@
 
 [[autodoc]] kernels.has_kernel
 
+### get_loaded_kernels
+
+[[autodoc]] kernels.get_loaded_kernels
+
 ## Loading locked kernels
 
 ### load_kernel
diff --git a/docs/source/basic-usage.md b/docs/source/basic-usage.md
index a93a47d6..1e622d8c 100644
--- a/docs/source/basic-usage.md
+++ b/docs/source/basic-usage.md
@@ -43,3 +43,23 @@ from kernels import has_kernel
 is_available = has_kernel("kernels-community/activation", version=1)
 print(f"Kernel available: {is_available}")
 ```
+
+## Inspecting Loaded Kernels
+
+`get_loaded_kernels()` returns a snapshot of every kernel that has been loaded
+into the current process. Each entry is a `LoadedKernel` namedtuple with the
+imported `module`, the `package_name`, and `repo_infos` (repo id, resolved
+revision, and the backend argument that was passed).
+
+```python
+from kernels import get_kernel, get_loaded_kernels
+
+get_kernel("kernels-community/activation", version=1)
+
+for loaded in get_loaded_kernels():
+    print(loaded.package_name, loaded.repo_infos)
+```
+
+`repo_infos` is populated only for kernels loaded with `get_kernel`. Kernels
+loaded from a local path (`get_local_kernel`) or via a lockfile
+(`get_locked_kernel`, `load_kernel`) have `repo_infos=None`.
diff --git a/kernels/src/kernels/utils.py b/kernels/src/kernels/utils.py
index ab7cd017..297e5f67 100644
--- a/kernels/src/kernels/utils.py
+++ b/kernels/src/kernels/utils.py
@@ -49,7 +49,37 @@ class LoadedKernel(NamedTuple):
 
 
 def get_loaded_kernels() -> list[LoadedKernel]:
-    """Returns a copy of the loaded kernels registry (see `kernels.utils.LoadedKernel` NamedTuple)."""
+    """
+    Return a snapshot of every kernel that has been loaded into the current process.
+
+    Each entry is a `kernels.utils.LoadedKernel` namedtuple with fields:
+
+    - `module` (`ModuleType`): the imported kernel module.
+    - `package_name` (`str`): the kernel's package name.
+    - `repo_infos` (`kernels.utils.RepoInfos | None`): populated only for
+      kernels loaded via `get_kernel`. Loaders that work from a local path
+      (`get_local_kernel`) or a lockfile (`get_locked_kernel`, `load_kernel`)
+      leave this as `None`.
+
+    `RepoInfos` has `repo_id`, `revision`, and `backend` fields. `backend`
+    reflects the value passed by the caller — it is `None` when the caller
+    relied on backend auto-detection.
+
+    The returned list is a new list; mutating it does not affect the registry.
+
+    Returns:
+        `list[LoadedKernel]`: one entry per distinct kernel variant path
+        loaded in this process.
+
+    Example:
+        ```python
+        from kernels import get_kernel, get_loaded_kernels
+
+        get_kernel("kernels-community/activation", version=1)
+        for loaded in get_loaded_kernels():
+            print(loaded.package_name, loaded.repo_infos)
+        ```
+    """
     return list(_loaded_kernels.values())
 
 
diff --git a/kernels/tests/test_loaded_kernels.py b/kernels/tests/test_loaded_kernels.py
new file mode 100644
index 00000000..ab039bb4
--- /dev/null
+++ b/kernels/tests/test_loaded_kernels.py
@@ -0,0 +1,92 @@
+import pytest
+
+from kernels import get_kernel, get_loaded_kernels, get_local_kernel, install_kernel
+from kernels.utils import LoadedKernel, RepoInfos, _loaded_kernels
+
+
+_REPO_ID = "kernels-test/versions"
+_PACKAGE_NAME = "versions"
+_VERSION = 2
+
+
+@pytest.fixture
+def fresh_registry():
+    """Snapshot the process-wide registry, run the test with a clean one, restore on teardown."""
+    saved = _loaded_kernels.copy()
+    _loaded_kernels.clear()
+    yield
+    _loaded_kernels.clear()
+    _loaded_kernels.update(saved)
+
+
+def test_namedtuple_shape():
+    assert LoadedKernel._fields == ("module", "package_name", "repo_infos")
+    assert RepoInfos._fields == ("repo_id", "revision", "backend")
+
+
+def test_get_loaded_kernels_returns_copy(fresh_registry):
+    kernel = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+
+    snapshot = get_loaded_kernels()
+    assert len(snapshot) == 1
+
+    snapshot.clear()
+    snapshot.append("garbage")  # type: ignore[arg-type]
+
+    again = get_loaded_kernels()
+    assert len(again) == 1
+    assert again[0].module is kernel
+
+
+def test_get_kernel_registers_loaded_kernel(fresh_registry):
+    kernel = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+
+    loaded = get_loaded_kernels()
+    assert len(loaded) == 1
+
+    entry = loaded[0]
+    assert entry.module is kernel
+    assert entry.package_name == _PACKAGE_NAME
+    assert entry.repo_infos is not None
+    assert entry.repo_infos.repo_id == _REPO_ID
+    assert isinstance(entry.repo_infos.revision, str) and entry.repo_infos.revision
+    assert entry.repo_infos.backend == "cpu"
+
+
+def test_repeated_get_kernel_is_cached(fresh_registry):
+    first = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+    second = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+
+    assert first is second
+    assert len(get_loaded_kernels()) == 1
+
+
+def test_get_local_kernel_registers_with_null_repo_infos(fresh_registry):
+    # Populate the HF cache via get_kernel, grab the variant path it registered,
+    # then clear the registry and exercise get_local_kernel against that path.
+    get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+    (variant_path,) = list(_loaded_kernels.keys())
+
+    _loaded_kernels.clear()
+
+    kernel = get_local_kernel(variant_path, _PACKAGE_NAME, backend="cpu")
+
+    loaded = get_loaded_kernels()
+    assert len(loaded) == 1
+
+    entry = loaded[0]
+    assert entry.module is kernel
+    assert entry.package_name == _PACKAGE_NAME
+    assert entry.repo_infos is None
+
+
+def test_install_kernel_plus_import_does_not_set_repo_infos(fresh_registry):
+    # install_kernel alone does not import; it returns a path. Any loader
+    # that does not go through get_kernel must leave repo_infos as None.
+    package_name, variant_path = install_kernel(_REPO_ID, revision="main", backend="cpu")
+    assert package_name == _PACKAGE_NAME
+    assert get_loaded_kernels() == []
+
+    get_local_kernel(variant_path, package_name, backend="cpu")
+    (entry,) = get_loaded_kernels()
+    assert entry.repo_infos is None

From c6746d89422cdded0f6296ba03e7a3811091abbe Mon Sep 17 00:00:00 2001
From: sayakpaul <spsayakpaul@gmail.com>
Date: Sun, 19 Apr 2026 13:19:13 +0530
Subject: [PATCH 2/8] ruff

---
 kernels/tests/test_loaded_kernels.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/kernels/tests/test_loaded_kernels.py b/kernels/tests/test_loaded_kernels.py
index ab039bb4..4274ceaa 100644
--- a/kernels/tests/test_loaded_kernels.py
+++ b/kernels/tests/test_loaded_kernels.py
@@ -3,7 +3,6 @@
 from kernels import get_kernel, get_loaded_kernels, get_local_kernel, install_kernel
 from kernels.utils import LoadedKernel, RepoInfos, _loaded_kernels
 
-
 _REPO_ID = "kernels-test/versions"
 _PACKAGE_NAME = "versions"
 _VERSION = 2

From aea089d178bcbb443e40e949fc42fd6477fb3ba2 Mon Sep 17 00:00:00 2001
From: sayakpaul <spsayakpaul@gmail.com>
Date: Sun, 19 Apr 2026 16:28:01 +0530
Subject: [PATCH 3/8] up

---
 kernels/tests/test_loaded_kernels.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/kernels/tests/test_loaded_kernels.py b/kernels/tests/test_loaded_kernels.py
index 4274ceaa..f6ca032e 100644
--- a/kernels/tests/test_loaded_kernels.py
+++ b/kernels/tests/test_loaded_kernels.py
@@ -3,9 +3,9 @@
 from kernels import get_kernel, get_loaded_kernels, get_local_kernel, install_kernel
 from kernels.utils import LoadedKernel, RepoInfos, _loaded_kernels
 
-_REPO_ID = "kernels-test/versions"
+_REPO_ID = "kernels-community/relu"
 _PACKAGE_NAME = "versions"
-_VERSION = 2
+_VERSION = 1
 
 
 @pytest.fixture
@@ -24,7 +24,7 @@ def test_namedtuple_shape():
 
 
 def test_get_loaded_kernels_returns_copy(fresh_registry):
-    kernel = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+    kernel = get_kernel(_REPO_ID, version=_VERSION)
 
     snapshot = get_loaded_kernels()
     assert len(snapshot) == 1
@@ -38,7 +38,7 @@ def test_get_loaded_kernels_returns_copy(fresh_registry):
 
 
 def test_get_kernel_registers_loaded_kernel(fresh_registry):
-    kernel = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+    kernel = get_kernel(_REPO_ID, version=_VERSION)
 
     loaded = get_loaded_kernels()
     assert len(loaded) == 1
@@ -53,22 +53,22 @@ def test_get_kernel_registers_loaded_kernel(fresh_registry):
 
 
 def test_repeated_get_kernel_is_cached(fresh_registry):
-    first = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
-    second = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+    first = get_kernel(_REPO_ID, version=_VERSION)
+    second = get_kernel(_REPO_ID, version=_VERSION)
 
     assert first is second
     assert len(get_loaded_kernels()) == 1
 
 
 def test_get_local_kernel_registers_with_null_repo_infos(fresh_registry):
-    # Populate the HF cache via get_kernel, grab the variant path it registered,
+    # Populate the HF cache via get_kernel, grab the variant path,
     # then clear the registry and exercise get_local_kernel against that path.
-    get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+    get_kernel(_REPO_ID, version=_VERSION)
     (variant_path,) = list(_loaded_kernels.keys())
 
     _loaded_kernels.clear()
 
-    kernel = get_local_kernel(variant_path, _PACKAGE_NAME, backend="cpu")
+    kernel = get_local_kernel(variant_path, _PACKAGE_NAME)
 
     loaded = get_loaded_kernels()
     assert len(loaded) == 1
@@ -82,10 +82,10 @@ def test_get_local_kernel_registers_with_null_repo_infos(fresh_registry):
 def test_install_kernel_plus_import_does_not_set_repo_infos(fresh_registry):
     # install_kernel alone does not import; it returns a path. Any loader
     # that does not go through get_kernel must leave repo_infos as None.
-    package_name, variant_path = install_kernel(_REPO_ID, revision="main", backend="cpu")
+    package_name, variant_path = install_kernel(_REPO_ID, revision="main")
     assert package_name == _PACKAGE_NAME
     assert get_loaded_kernels() == []
 
-    get_local_kernel(variant_path, package_name, backend="cpu")
+    get_local_kernel(variant_path, package_name)
     (entry,) = get_loaded_kernels()
     assert entry.repo_infos is None

From 2c472b898d5787d13a0e57070374743f52604f6c Mon Sep 17 00:00:00 2001
From: sayakpaul <spsayakpaul@gmail.com>
Date: Sun, 19 Apr 2026 16:48:48 +0530
Subject: [PATCH 4/8] fix

---
 kernels/tests/test_loaded_kernels.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/kernels/tests/test_loaded_kernels.py b/kernels/tests/test_loaded_kernels.py
index f6ca032e..a24698fc 100644
--- a/kernels/tests/test_loaded_kernels.py
+++ b/kernels/tests/test_loaded_kernels.py
@@ -4,7 +4,7 @@
 from kernels.utils import LoadedKernel, RepoInfos, _loaded_kernels
 
 _REPO_ID = "kernels-community/relu"
-_PACKAGE_NAME = "versions"
+_PACKAGE_NAME = "relu"
 _VERSION = 1
 
 

From 12b20384c0013d3a90092045238c1d171934da5d Mon Sep 17 00:00:00 2001
From: sayakpaul <spsayakpaul@gmail.com>
Date: Sun, 19 Apr 2026 13:17:41 +0530
Subject: [PATCH 5/8] feat: add test and docs for get_loaded_kernels.

---
 docs/source/api/kernels.md           |  4 ++
 docs/source/basic-usage.md           | 20 ++++++
 kernels/src/kernels/utils.py         | 32 +++++++++-
 kernels/tests/test_loaded_kernels.py | 92 ++++++++++++++++++++++++++++
 4 files changed, 147 insertions(+), 1 deletion(-)
 create mode 100644 kernels/tests/test_loaded_kernels.py

diff --git a/docs/source/api/kernels.md b/docs/source/api/kernels.md
index 7d4ebc0f..afff8f6e 100644
--- a/docs/source/api/kernels.md
+++ b/docs/source/api/kernels.md
@@ -14,6 +14,10 @@
 
 [[autodoc]] kernels.has_kernel
 
+### get_loaded_kernels
+
+[[autodoc]] kernels.get_loaded_kernels
+
 ## Loading locked kernels
 
 ### load_kernel
diff --git a/docs/source/basic-usage.md b/docs/source/basic-usage.md
index a93a47d6..1e622d8c 100644
--- a/docs/source/basic-usage.md
+++ b/docs/source/basic-usage.md
@@ -43,3 +43,23 @@ from kernels import has_kernel
 is_available = has_kernel("kernels-community/activation", version=1)
 print(f"Kernel available: {is_available}")
 ```
+
+## Inspecting Loaded Kernels
+
+`get_loaded_kernels()` returns a snapshot of every kernel that has been loaded
+into the current process. Each entry is a `LoadedKernel` namedtuple with the
+imported `module`, the `package_name`, and `repo_infos` (repo id, resolved
+revision, and the backend argument that was passed).
+
+```python
+from kernels import get_kernel, get_loaded_kernels
+
+get_kernel("kernels-community/activation", version=1)
+
+for loaded in get_loaded_kernels():
+    print(loaded.package_name, loaded.repo_infos)
+```
+
+`repo_infos` is populated only for kernels loaded with `get_kernel`. Kernels
+loaded from a local path (`get_local_kernel`) or via a lockfile
+(`get_locked_kernel`, `load_kernel`) have `repo_infos=None`.
diff --git a/kernels/src/kernels/utils.py b/kernels/src/kernels/utils.py
index 831d86e2..c0c8e446 100644
--- a/kernels/src/kernels/utils.py
+++ b/kernels/src/kernels/utils.py
@@ -52,7 +52,37 @@ class LoadedKernel:
 
 
 def get_loaded_kernels() -> list[LoadedKernel]:
-    """Returns a copy of the loaded kernels registry (see `kernels.utils.LoadedKernel` NamedTuple)."""
+    """
+    Return a snapshot of every kernel that has been loaded into the current process.
+
+    Each entry is a `kernels.utils.LoadedKernel` namedtuple with fields:
+
+    - `module` (`ModuleType`): the imported kernel module.
+    - `package_name` (`str`): the kernel's package name.
+    - `repo_infos` (`kernels.utils.RepoInfos | None`): populated only for
+      kernels loaded via `get_kernel`. Loaders that work from a local path
+      (`get_local_kernel`) or a lockfile (`get_locked_kernel`, `load_kernel`)
+      leave this as `None`.
+
+    `RepoInfos` has `repo_id`, `revision`, and `backend` fields. `backend`
+    reflects the value passed by the caller — it is `None` when the caller
+    relied on backend auto-detection.
+
+    The returned list is a new list; mutating it does not affect the registry.
+
+    Returns:
+        `list[LoadedKernel]`: one entry per distinct kernel variant path
+        loaded in this process.
+
+    Example:
+        ```python
+        from kernels import get_kernel, get_loaded_kernels
+
+        get_kernel("kernels-community/activation", version=1)
+        for loaded in get_loaded_kernels():
+            print(loaded.package_name, loaded.repo_infos)
+        ```
+    """
     return list(_loaded_kernels.values())
 
 
diff --git a/kernels/tests/test_loaded_kernels.py b/kernels/tests/test_loaded_kernels.py
new file mode 100644
index 00000000..ab039bb4
--- /dev/null
+++ b/kernels/tests/test_loaded_kernels.py
@@ -0,0 +1,92 @@
+import pytest
+
+from kernels import get_kernel, get_loaded_kernels, get_local_kernel, install_kernel
+from kernels.utils import LoadedKernel, RepoInfos, _loaded_kernels
+
+
+_REPO_ID = "kernels-test/versions"
+_PACKAGE_NAME = "versions"
+_VERSION = 2
+
+
+@pytest.fixture
+def fresh_registry():
+    """Snapshot the process-wide registry, run the test with a clean one, restore on teardown."""
+    saved = _loaded_kernels.copy()
+    _loaded_kernels.clear()
+    yield
+    _loaded_kernels.clear()
+    _loaded_kernels.update(saved)
+
+
+def test_namedtuple_shape():
+    assert LoadedKernel._fields == ("module", "package_name", "repo_infos")
+    assert RepoInfos._fields == ("repo_id", "revision", "backend")
+
+
+def test_get_loaded_kernels_returns_copy(fresh_registry):
+    kernel = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+
+    snapshot = get_loaded_kernels()
+    assert len(snapshot) == 1
+
+    snapshot.clear()
+    snapshot.append("garbage")  # type: ignore[arg-type]
+
+    again = get_loaded_kernels()
+    assert len(again) == 1
+    assert again[0].module is kernel
+
+
+def test_get_kernel_registers_loaded_kernel(fresh_registry):
+    kernel = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+
+    loaded = get_loaded_kernels()
+    assert len(loaded) == 1
+
+    entry = loaded[0]
+    assert entry.module is kernel
+    assert entry.package_name == _PACKAGE_NAME
+    assert entry.repo_infos is not None
+    assert entry.repo_infos.repo_id == _REPO_ID
+    assert isinstance(entry.repo_infos.revision, str) and entry.repo_infos.revision
+    assert entry.repo_infos.backend == "cpu"
+
+
+def test_repeated_get_kernel_is_cached(fresh_registry):
+    first = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+    second = get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+
+    assert first is second
+    assert len(get_loaded_kernels()) == 1
+
+
+def test_get_local_kernel_registers_with_null_repo_infos(fresh_registry):
+    # Populate the HF cache via get_kernel, grab the variant path it registered,
+    # then clear the registry and exercise get_local_kernel against that path.
+    get_kernel(_REPO_ID, version=_VERSION, backend="cpu")
+    (variant_path,) = list(_loaded_kernels.keys())
+
+    _loaded_kernels.clear()
+
+    kernel = get_local_kernel(variant_path, _PACKAGE_NAME, backend="cpu")
+
+    loaded = get_loaded_kernels()
+    assert len(loaded) == 1
+
+    entry = loaded[0]
+    assert entry.module is kernel
+    assert entry.package_name == _PACKAGE_NAME
+    assert entry.repo_infos is None
+
+
+def test_install_kernel_plus_import_does_not_set_repo_infos(fresh_registry):
+    # install_kernel alone does not import; it returns a path. Any loader
+    # that does not go through get_kernel must leave repo_infos as None.
+    package_name, variant_path = install_kernel(_REPO_ID, revision="main", backend="cpu")
+    assert package_name == _PACKAGE_NAME
+    assert get_loaded_kernels() == []
+
+    get_local_kernel(variant_path, package_name, backend="cpu")
+    (entry,) = get_loaded_kernels()
+    assert entry.repo_infos is None

From 58d717a78b0439763b653fbe1fb530c35918e6ae Mon Sep 17 00:00:00 2001
From: sayakpaul <spsayakpaul@gmail.com>
Date: Tue, 21 Apr 2026 12:19:53 -0300
Subject: [PATCH 6/8] namedtuple -> dataclasses.

---
 kernels/src/kernels/utils.py         |  8 +++++---
 kernels/tests/test_loaded_kernels.py | 17 ++++++++++++-----
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/kernels/src/kernels/utils.py b/kernels/src/kernels/utils.py
index c0c8e446..60d22972 100644
--- a/kernels/src/kernels/utils.py
+++ b/kernels/src/kernels/utils.py
@@ -55,10 +55,12 @@ def get_loaded_kernels() -> list[LoadedKernel]:
     """
     Return a snapshot of every kernel that has been loaded into the current process.
 
-    Each entry is a `kernels.utils.LoadedKernel` namedtuple with fields:
+    Each entry is a `kernels.utils.LoadedKernel` dataclass with fields:
 
+    - `kernel_id` (`str`): unique identifier used as the `sys.modules` key
+      for this variant (either `metadata.id` or a hash-suffixed module name).
     - `module` (`ModuleType`): the imported kernel module.
-    - `package_name` (`str`): the kernel's package name.
+    - `module_name` (`str`): the kernel's module name.
     - `repo_infos` (`kernels.utils.RepoInfos | None`): populated only for
       kernels loaded via `get_kernel`. Loaders that work from a local path
       (`get_local_kernel`) or a lockfile (`get_locked_kernel`, `load_kernel`)
@@ -80,7 +82,7 @@ def get_loaded_kernels() -> list[LoadedKernel]:
 
         get_kernel("kernels-community/activation", version=1)
         for loaded in get_loaded_kernels():
-            print(loaded.package_name, loaded.repo_infos)
+            print(loaded.module_name, loaded.repo_infos)
         ```
     """
     return list(_loaded_kernels.values())
diff --git a/kernels/tests/test_loaded_kernels.py b/kernels/tests/test_loaded_kernels.py
index 4274ceaa..328f4c89 100644
--- a/kernels/tests/test_loaded_kernels.py
+++ b/kernels/tests/test_loaded_kernels.py
@@ -1,3 +1,5 @@
+from dataclasses import fields
+
 import pytest
 
 from kernels import get_kernel, get_loaded_kernels, get_local_kernel, install_kernel
@@ -18,9 +20,14 @@ def fresh_registry():
     _loaded_kernels.update(saved)
 
 
-def test_namedtuple_shape():
-    assert LoadedKernel._fields == ("module", "package_name", "repo_infos")
-    assert RepoInfos._fields == ("repo_id", "revision", "backend")
+def test_dataclass_shape():
+    assert tuple(f.name for f in fields(LoadedKernel)) == (
+        "kernel_id",
+        "module",
+        "module_name",
+        "repo_infos",
+    )
+    assert tuple(f.name for f in fields(RepoInfos)) == ("repo_id", "revision", "backend")
 
 
 def test_get_loaded_kernels_returns_copy(fresh_registry):
@@ -45,7 +52,7 @@ def test_get_kernel_registers_loaded_kernel(fresh_registry):
 
     entry = loaded[0]
     assert entry.module is kernel
-    assert entry.package_name == _PACKAGE_NAME
+    assert entry.module_name == _PACKAGE_NAME
     assert entry.repo_infos is not None
     assert entry.repo_infos.repo_id == _REPO_ID
     assert isinstance(entry.repo_infos.revision, str) and entry.repo_infos.revision
@@ -75,7 +82,7 @@ def test_get_local_kernel_registers_with_null_repo_infos(fresh_registry):
 
     entry = loaded[0]
     assert entry.module is kernel
-    assert entry.package_name == _PACKAGE_NAME
+    assert entry.module_name == _PACKAGE_NAME
     assert entry.repo_infos is None
 
 

From 013ea40167fb970c7221c933e39a43cf386be355 Mon Sep 17 00:00:00 2001
From: sayakpaul <spsayakpaul@gmail.com>
Date: Tue, 21 Apr 2026 12:21:31 -0300
Subject: [PATCH 7/8] reminder.

---
 kernels/src/kernels/utils.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/kernels/src/kernels/utils.py b/kernels/src/kernels/utils.py
index 60d22972..eea224e9 100644
--- a/kernels/src/kernels/utils.py
+++ b/kernels/src/kernels/utils.py
@@ -72,6 +72,9 @@ def get_loaded_kernels() -> list[LoadedKernel]:
 
     The returned list is a new list; mutating it does not affect the registry.
 
+    > [!NOTE]
+    > These arguments might be renamed / changed a bit.
+
     Returns:
         `list[LoadedKernel]`: one entry per distinct kernel variant path
         loaded in this process.

From c186c27fcec7800ffd905ec5df8d15063f50b7dd Mon Sep 17 00:00:00 2001
From: sayakpaul <spsayakpaul@gmail.com>
Date: Tue, 21 Apr 2026 13:24:07 -0300
Subject: [PATCH 8/8] upgrade to kernels-community/relu.

---
 kernels/tests/test_loaded_kernels.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/kernels/tests/test_loaded_kernels.py b/kernels/tests/test_loaded_kernels.py
index 328f4c89..87e13a84 100644
--- a/kernels/tests/test_loaded_kernels.py
+++ b/kernels/tests/test_loaded_kernels.py
@@ -5,9 +5,9 @@
 from kernels import get_kernel, get_loaded_kernels, get_local_kernel, install_kernel
 from kernels.utils import LoadedKernel, RepoInfos, _loaded_kernels
 
-_REPO_ID = "kernels-test/versions"
-_PACKAGE_NAME = "versions"
-_VERSION = 2
+_REPO_ID = "kernels-community/relu"
+_PACKAGE_NAME = "relu"
+_VERSION = 1
 
 
 @pytest.fixture