@@ -90,16 +90,13 @@ jobs:
           key: stubs-ubuntu-latest
 
       - name: Collect the generated stubs
-        run: |
-          mkdir -p stubs
-          cp "$(python -c 'import rexlib, pathlib; print(pathlib.Path(rexlib.__file__).parent)')"/_binding/*.pyi stubs/
-          ls -l stubs
+        run: python scripts/collect_stubs.py --module rexlib._binding --output stubs
 
       - name: Upload stubs
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: type-stubs
-          path: stubs/*.pyi
+          path: stubs/
 
   build_wheels:
     needs: generate_stubs
 
@@ -14,11 +14,11 @@ the same pull request that causes it.
 
 | Path | Holds |
 |---|---|
-| `src/` | The pybind11 binding, 35 `.cpp` and 35 `.hpp`, compiled into the `rexlib._binding` extension |
-| `python/rexlib/` | The Python package, 8 `.py`: everything the binding cannot express |
+| `src/` | The pybind11 binding, 40 `.cpp` and 40 `.hpp`, compiled into the `rexlib._binding` extension |
+| `python/rexlib/` | The Python package, 10 `.py`: everything the binding cannot express |
 | `tests/` | pytest suites, mirroring the binding's module structure |
 | `tests/assets/` | Two dummy plugins, built by CMake, that the plugin tests discover |
-| `scripts/` | Development tools: the test runner, the stub generator, the wheel check |
+| `scripts/` | Development tools: the test runner, the stub generator and collector, the wheel check |
 | `cmake/modules/` | `python_stubs.cmake`, which installs the type stubs |
 | `conf/` | `coverage.ini` |
 | `external/rexlib` | The rexlib the repository is developed against, a submodule |
@@ -29,9 +29,15 @@ to ask.
 `src/` mirrors rexlib's own directory structure, and the module it produces
 mirrors the C++ API: same names, same argument order, same required arguments.
 It does not decide anything. `python/rexlib/` is where the API becomes Python:
-default arguments, implicit context, operators, process-wide state. Everything
-in it is private — a leading underscore on every module — and `__init__.py` is
-the whole public surface.
+default arguments, implicit context, operators, process-wide state. Its
+modules carry a leading underscore and `__init__.py` re-exports what they
+hold, so that the public surface is one flat namespace rather than a set of
+import paths.
+
+A public subpackage is the exception to that, and `em/` is the one: its module
+path *is* the API, `rexlib.em.image`, so the directories are named without an
+underscore and each carries an `__all__` of its own. Anything private inside
+one still takes the underscore.
 
 The rule that follows: if a change could be expressed in either place, it goes
 in `python/rexlib/`. C++ is the expensive side to change and the one that has
@@ -47,10 +53,12 @@ them: everything under those directories is flat in `namespace rexlib`,
 the only place rexlib separates these areas, so the paths are what the
 submodule names come from.
 
-Nothing under `em/` is bound yet. When it is, the same rule decides its module
-path: `em/image/` sits inside `namespace em` the way `core/hardware/` sits
-inside `namespace rexlib`, and the path is what will separate it from the
-areas that come after it. See #143.
+It reaches through nesting where rexlib's directories nest. `em/image/` sits
+inside `namespace em` the way `core/hardware/` sits inside `namespace rexlib`,
+so it binds as `em.image` rather than as `em`, even though `em::read` carries
+no `image` qualifier of its own. The path is what keeps images apart from the
+areas that come after them, which is why it is the path and not the function
+name that names them. See #143.
 
 `_binding` carries at its top level what the directories below it sit in:
 
@@ -62,9 +70,12 @@ areas that come after it. See #143.
 | `_binding.hardware` | `src/core/hardware/` | Devices, sessions, queues, events, memory resources |
 | `_binding.dispatch` | `src/core/dispatch/` | `ExecutionContext`, `Dispatcher`, `ProgramManager` |
 | `_binding.functional` | `src/functional/` | The operations, each taking an explicit context |
+| `_binding.em.image` | `src/em/image/` | `ImageLocation`, the read and write format managers |
 
-`src/main.cpp` is the only place that creates a submodule, and it names them
-in the order the declarations need.
+A submodule is created by the `main.cpp` above it, which then hands it to the
+`bind_` function of the directory it stands for: `src/main.cpp` creates `em`
+and `src/em/main.cpp` creates `image` inside it. Each names its submodules in
+the order the declarations need.
 
 ### The package's modules
 
@@ -77,6 +88,7 @@ in the order the declarations need.
 | `_device.py` | `rexlib.device(...)`, the `with` block that activates one |
 | `_functional.py` | The operations again, with `context` defaulting to the active one |
 | `_ndarray.py` | Installs the Python operators onto `Array` |
+| `em/` | The electron microscopy areas, one module each |
 
 `_paths` is imported first in `__init__.py`, and the order matters: on Windows
 nothing else imports until the bundled library is findable. `_ndarray` is
@@ -160,6 +172,14 @@ The package is typed — `py.typed` ships — so a change to the binding's
 signatures is a change to the stubs, generated for free, and a change to
 `python/rexlib/` is only as typed as it was written.
 
+A submodule that holds submodules of its own becomes a directory of stubs
+rather than one file: `em` is `_binding/em/__init__.pyi` beside
+`_binding/em/image.pyi`. Every step that moves stubs has to carry that tree,
+so `scripts/collect_stubs.py` copies it and the artifact holding it is
+uploaded as a directory. A flat `*.pyi` glob at either step takes the top
+level and drops the rest, which fails nothing and publishes wheels typed
+everywhere except the area that was just added.
+
 ## Conventions
 
 ### The binding
@@ -281,6 +301,7 @@ Tests for what `_binding` exposes at its top level stay at the root.
 | `tests/hardware/` | Devices, sessions, events, memory resources, the session pool |
 | `tests/dispatch/` | `ExecutionContext`, the active context, `rexlib.device(...)` |
 | `tests/functional/` | The operations |
+| `tests/em/image/` | `ImageLocation`, parsing, the format managers |
 
 There are no `__init__.py` files and no `conftest.py`. Test module names are
 therefore unique across the whole tree, and a fixture belongs to the file that
 
@@ -12,6 +12,10 @@
 itself, and the shape of the array libraries they are used alongside.
 Device management and dispatch stay in their own modules: they are
 reached for when setting up rather than when computing.
+
+`em` is a package rather than a flat name, one module per area of
+electron microscopy, so that each area keeps its own `read` and `write`
+instead of spelling the area into the function name.
 """
 
 from __future__ import annotations
@@ -39,6 +43,8 @@
 from ._device import device as device
 from ._paths import get_cmake_dir as get_cmake_dir, get_include as get_include
 
+from . import em as em
+
 # Imported for its effect: it installs the Python operators onto Array,
 # which has to happen before anything hands one out.
 from . import _ndarray as _ndarray
@@ -89,6 +95,7 @@
 	"device",
 	"dispatch",
 	"divide",
+	"em",
 	"empty",
 	"fill",
 	"full",
 
@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: GPL-3.0-only
+
+"""Electron microscopy file formats.
+
+One module per area of `rexlib::em`, named after the directory that area
+occupies in rexlib, the way every module here is named. Each carries the
+vocabulary of its own area, so `read` and `write` mean one thing apiece
+and the areas arriving after images rename nothing.
+"""
+
+from __future__ import annotations
+
+from . import image as image
+
+__all__ = ["image"]
@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: GPL-3.0-only
+
+"""Image files: where one is, and which formats are known.
+
+`ImageLocation` addresses an element of a file, and the two format
+managers hold the formats that can be read and written. Both managers are
+services, reached from a `rexlib.ServiceCatalog` the way the device and
+program managers are.
+
+A string is never parsed into an `ImageLocation` on its way anywhere: a
+path is a path, and `parse_image_location` is asked for by name.
+"""
+
+from __future__ import annotations
+
+from ..._binding.em.image import (
+	ImageLocation as ImageLocation,
+	ImageReadFormatManager as ImageReadFormatManager,
+	ImageWriteFormatManager as ImageWriteFormatManager,
+	get_image_read_format_manager as get_image_read_format_manager,
+	get_image_write_format_manager as get_image_write_format_manager,
+	parse_image_location as parse_image_location,
+)
+
+__all__ = [
+	"ImageLocation",
+	"ImageReadFormatManager",
+	"ImageWriteFormatManager",
+	"get_image_read_format_manager",
+	"get_image_write_format_manager",
+	"parse_image_location",
+]
@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-3.0-only
+
+"""
+Copy an extension's type stubs out of an installed package.
+
+pybind11-stubgen renders a submodule holding submodules of its own as a
+directory of stubs rather than as one file, so what it writes is a tree and
+this carries the tree. Invoked from the workflow that generates the stubs
+once and hands them to the builds that cannot generate their own.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import pathlib
+import shutil
+
+def parse_arguments() -> argparse.Namespace:
+	"""Read the module whose stubs to copy, and where to put them."""
+	parser = argparse.ArgumentParser(description=__doc__)
+	parser.add_argument("--module", required=True)
+	parser.add_argument(
+		"--output",
+		required=True,
+		help="Directory the stubs are copied to.",
+	)
+	return parser.parse_args()
+
+def find_stubs(module: str) -> pathlib.Path:
+	"""Locate the stub directory installed beside an extension."""
+	package, _, name = module.rpartition(".")
+	root = importlib.import_module(package)
+	if root.__file__ is None:
+		raise SystemExit(f"{package} has no location on disk")
+	return pathlib.Path(root.__file__).parent / name
+
+def copy_stubs(source: pathlib.Path, destination: pathlib.Path) -> int:
+	"""Copy every stub under source, keeping the path it sits at."""
+	copied = 0
+	for stub in sorted(source.rglob("*.pyi")):
+		target = destination / stub.relative_to(source)
+		target.parent.mkdir(parents=True, exist_ok=True)
+		shutil.copyfile(stub, target)
+		print(target)
+		copied += 1
+	return copied
+
+def main() -> None:
+	"""Copy the stubs, failing when there is not one to copy."""
+	arguments = parse_arguments()
+
+	source = find_stubs(arguments.module)
+	if not source.is_dir():
+		raise SystemExit(f"No stub directory at {source}")
+
+	if not copy_stubs(source, pathlib.Path(arguments.output)):
+		raise SystemExit(f"No .pyi files under {source}")
+
+if __name__ == "__main__":
+	main()
@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "image_location.hpp"
+
+#include <rexlib/em/image/image_location.hpp>
+
+#include <pybind11/operators.h>
+#include <pybind11/stl.h>
+
+#include <optional>
+#include <sstream>
+#include <string>
+
+namespace rexlib
+{
+
+namespace py = pybind11;
+
+static std::string to_string(const em::image_location &l)
+{
+	return em::to_string(l);
+}
+
+static std::string to_repr(const em::image_location &l)
+{
+	std::ostringstream oss;
+	oss << "ImageLocation(path=\"" << l.get_path() << "\", "
+		<< "position=" << l.get_position_in_stack() << ")";
+	return oss.str();
+}
+
+static std::optional<em::image_location>
+parse_image_location(const std::string &text)
+{
+	em::image_location result;
+	if (!em::parse_image_location(text, result))
+	{
+		return std::nullopt;
+	}
+	return result;
+}
+
+image_location_class declare_image_location(pybind11::module_ &m)
+{
+	return image_location_class(m, "ImageLocation");
+}
+
+void define_image_location(image_location_class &c, pybind11::module_ &m)
+{
+	c
+		.def(
+			py::init<std::string, std::size_t>(),
+			py::arg("path"),
+			py::arg("position") = em::image_location::no_position
+		)
+		.def(py::init<>())
+		.def(py::self == py::self)
+		.def(py::self != py::self)
+		.def(py::self < py::self)
+		.def(py::self <= py::self)
+		.def(py::self > py::self)
+		.def(py::self >= py::self)
+		.def("__hash__", &em::image_location::hash)
+		.def("__str__", &to_string)
+		.def("__repr__", &to_repr)
+		.def_property_readonly("path", &em::image_location::get_path)
+		.def_property_readonly(
+			"position_in_stack",
+			&em::image_location::get_position_in_stack
+		)
+		.def(py::pickle(
+			[](const em::image_location &l) // __getstate__
+			{
+				return py::make_tuple(
+					l.get_path(),
+					l.get_position_in_stack()
+				);
+			},
+			[](py::tuple t)  // __setstate__
+			{
+				return em::image_location(
+					t[0].cast<std::string>(),
+					t[1].cast<std::size_t>()
+				);
+			}
+		));
+
+	c.attr("no_position") = em::image_location::no_position;
+
+	m.def("parse_image_location", &parse_image_location, py::arg("text"));
+}
+
+} // namespace rexlib
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+#include <rexlib/em/image/image_location.hpp>
+
+namespace rexlib
+{
+
+using image_location_class = pybind11::class_<em::image_location>;
+
+image_location_class declare_image_location(pybind11::module_ &m);
+void define_image_location(image_location_class &c, pybind11::module_ &m);
+
+} // namespace rexlib
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "image_read_format_manager.hpp"
+
+#include <rexlib/core/service_catalog.hpp>
+
+namespace rexlib
+{
+
+static std::shared_ptr<em::image_read_format_manager>
+get_image_read_format_manager(service_catalog &catalog)
+{
+	return catalog.get_service_manager<em::image_read_format_manager>();
+}
+
+image_read_format_manager_class
+declare_image_read_format_manager(pybind11::module_ &m)
+{
+	return image_read_format_manager_class(m, "ImageReadFormatManager");
+}
+
+void define_image_read_format_manager(pybind11::module_ &m)
+{
+	m.def("get_image_read_format_manager", &get_image_read_format_manager);
+}
+
+} // namespace rexlib